From 4899de4d0a3de0c7ace3037fbfc34cd3a7d08b50 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Oct 2019 12:14:38 +0800
Subject: [PATCH 0001/3374] Create 66-plus-one.js

---
 66-plus-one.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 66-plus-one.js

diff --git a/66-plus-one.js b/66-plus-one.js
new file mode 100644
index 00000000..9ea6c1f0
--- /dev/null
+++ b/66-plus-one.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+const plusOne = function(digits) {
+  let p = true
+  let delta = 1
+  for(let i = digits.length - 1; i >= 0 && p; i--) {
+    let sum = digits[i] + delta
+    if (sum >= 10) p = true
+    else p = false
+    digits[i] = sum % 10
+  }
+  if(p) digits.unshift(1)
+  return digits
+};

From ec920a01bb20edd82ad609aef99ebd74acf80626 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Oct 2019 10:09:40 +0800
Subject: [PATCH 0002/3374] Create 71-simplify-path.js

---
 71-simplify-path.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 71-simplify-path.js

diff --git a/71-simplify-path.js b/71-simplify-path.js
new file mode 100644
index 00000000..e9bb4497
--- /dev/null
+++ b/71-simplify-path.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} path
+ * @return {string}
+ */
+const simplifyPath = function(path) {
+  path = path.split('/').filter(s => !!s && s !== '.')
+  while (path[0] === '..') path = path.slice(1)
+  let result = []
+  for (let val of path) {
+    if (val === '..') result.pop()
+    else result.push(val)
+  }
+  return '/' + result.join('/')
+}

From 02e322251404ae5386ec206d11017eba8b4ca837 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Oct 2019 15:49:05 +0800
Subject: [PATCH 0003/3374] Create 76-minimum-window-substring.js

---
 76-minimum-window-substring.js | 40 ++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 76-minimum-window-substring.js

diff --git a/76-minimum-window-substring.js b/76-minimum-window-substring.js
new file mode 100644
index 00000000..a6fbcb99
--- /dev/null
+++ b/76-minimum-window-substring.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+const minWindow = function(s, t) {
+  const map = {}
+  for (const c of t) {
+    map[c] = (map[c] || 0) + 1
+  }
+  let counter = t.length
+  let start = 0
+  let end = 0
+  let minLen = Infinity
+  let minStart = 0
+  while (end < s.length) {
+    const eChar = s[end]
+    if (map[eChar] > 0) {
+      counter--
+    }
+    map[eChar] = (map[eChar] || 0) - 1
+    end++
+    while (counter === 0) {
+      if (end - start < minLen) {
+        minStart = start
+        minLen = end - start
+      }
+      const sChar = s[start]
+      map[sChar] = (map[sChar] || 0) + 1
+      if (map[sChar] > 0) {
+        counter++
+      }
+      start++
+    }
+  }
+  if (minLen !== Infinity) {
+    return s.substring(minStart, minStart + minLen)
+  }
+  return ''
+}

From b7a67da710077ebdb50f7733dcaf044cc1207104 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Oct 2019 13:31:07 +0800
Subject: [PATCH 0004/3374] Create 96-unique-binary-search-trees.js

---
 96-unique-binary-search-trees.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 96-unique-binary-search-trees.js

diff --git a/96-unique-binary-search-trees.js b/96-unique-binary-search-trees.js
new file mode 100644
index 00000000..89cc4437
--- /dev/null
+++ b/96-unique-binary-search-trees.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numTrees = function(n) {
+  const hash = {
+    0: 1,
+    1: 1
+  }
+  return doNumTrees(n, hash)
+}
+
+function doNumTrees(n, hash) {
+  if (hash[n]) return hash[n]
+  let sum = 0
+  for (let i = 1; i <= n; i++) {
+    const left = doNumTrees(i - 1, hash)
+    const right = doNumTrees(n - i, hash)
+    sum += left * right
+  }
+  hash[n] = sum
+  return sum
+}

From 0dc8a29b2c86e5d725000d035b27f8940a0c3046 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Oct 2019 19:50:05 +0800
Subject: [PATCH 0005/3374] Update 96-unique-binary-search-trees.js

---
 96-unique-binary-search-trees.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/96-unique-binary-search-trees.js b/96-unique-binary-search-trees.js
index 89cc4437..59e886d5 100644
--- a/96-unique-binary-search-trees.js
+++ b/96-unique-binary-search-trees.js
@@ -1,3 +1,20 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numTrees = function(n) {
+  const arr = new Array(n + 1).fill(0)
+  arr[0] = arr[1] = 1
+  for (let i = 2; i <= n; i++) {
+    for (let j = 1; j <= i; j++) {
+      arr[i] += arr[j - 1] * arr[i - j]
+    }
+  }
+  return arr[n]
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 461282ef046504b835223779bd4ccd5e94caf225 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Oct 2019 20:41:50 +0800
Subject: [PATCH 0006/3374] Create 707-design-linked-list.js

---
 707-design-linked-list.js | 73 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 707-design-linked-list.js

diff --git a/707-design-linked-list.js b/707-design-linked-list.js
new file mode 100644
index 00000000..af126d85
--- /dev/null
+++ b/707-design-linked-list.js
@@ -0,0 +1,73 @@
+/**
+ * Initialize your data structure here.
+ */
+var MyLinkedList = function() {
+  this.arr = []
+}
+
+/**
+ * Get the value of the index-th node in the linked list. If the index is invalid, return -1.
+ * @param {number} index
+ * @return {number}
+ */
+MyLinkedList.prototype.get = function(index) {
+  if (this.arr[index] !== undefined) {
+    return this.arr[index]
+  } else {
+    return -1
+  }
+}
+
+/**
+ * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtHead = function(val) {
+  this.arr.unshift(val)
+}
+
+/**
+ * Append a node of value val to the last element of the linked list.
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtTail = function(val) {
+  this.arr.push(val)
+}
+
+/**
+ * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
+ * @param {number} index
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtIndex = function(index, val) {
+  if (this.arr.length >= index) {
+    this.arr.splice(index, 0, val)
+  }
+  if (index < 0) {
+    this.arr.unshift(val)
+  }
+}
+
+/**
+ * Delete the index-th node in the linked list, if the index is valid.
+ * @param {number} index
+ * @return {void}
+ */
+MyLinkedList.prototype.deleteAtIndex = function(index) {
+  if (index >= 0 && index < this.arr.length) {
+    this.arr.splice(index, 1)
+  }
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * var obj = new MyLinkedList()
+ * var param_1 = obj.get(index)
+ * obj.addAtHead(val)
+ * obj.addAtTail(val)
+ * obj.addAtIndex(index,val)
+ * obj.deleteAtIndex(index)
+ */

From 607a2f2fd5789039ed6701ac438776881a2907dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Oct 2019 21:19:44 +0800
Subject: [PATCH 0007/3374] Update 707-design-linked-list.js

---
 707-design-linked-list.js | 127 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 127 insertions(+)

diff --git a/707-design-linked-list.js b/707-design-linked-list.js
index af126d85..081e9b95 100644
--- a/707-design-linked-list.js
+++ b/707-design-linked-list.js
@@ -71,3 +71,130 @@ MyLinkedList.prototype.deleteAtIndex = function(index) {
  * obj.addAtIndex(index,val)
  * obj.deleteAtIndex(index)
  */
+
+// another
+
+/**
+ * Initialize your data structure here.
+ */
+var MyLinkedList = function(val) {
+  this.head = null
+  this.tail = null
+  this.size = 0
+}
+
+// Create Node class to store node data as an 'object'
+var Node = function(val) {
+  this.val = val
+  this.next = null
+}
+
+/**
+ * Get the value of the index-th node in the linked list. If the index is invalid, return -1.
+ * @param {number} index
+ * @return {number}
+ */
+MyLinkedList.prototype.get = function(index) {
+  if (index < 0 || this.size === 0 || index > this.size - 1) return -1
+  let curr = this.head
+  let i = 0
+  while (i < index) {
+    curr = curr.next
+    i += 1
+  }
+  return curr.val
+}
+
+/**
+ * Add a node of value val before the first element of the linked list. After the insertion, the new node will be the first node of the linked list.
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtHead = function(val) {
+  let newNode = new Node(val)
+  if (this.head === null) {
+    this.head = newNode
+    this.tail = newNode
+  } else {
+    newNode.next = this.head
+    this.head = newNode
+  }
+  this.size++
+  return this
+}
+
+/**
+ * Append a node of value val to the last element of the linked list.
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtTail = function(val) {
+  const newNode = new Node(val)
+  if (this.head === null) {
+    this.head = newNode
+    this.tail = newNode
+  } else {
+    this.tail.next = newNode
+    this.tail = newNode
+  }
+  this.size++
+  return this
+}
+
+/**
+ * Add a node of value val before the index-th node in the linked list. If index equals to the length of linked list, the node will be appended to the end of linked list. If index is greater than the length, the node will not be inserted.
+ * @param {number} index
+ * @param {number} val
+ * @return {void}
+ */
+MyLinkedList.prototype.addAtIndex = function(index, val) {
+  if (index > this.size) return
+  if (index <= 0) return this.addAtHead(val)
+  if (index === this.size) return this.addAtTail(val)
+  let newNode = new Node(val)
+  let i = 0
+  let curr = this.head
+  while (i < index - 1) {
+    curr = curr.next
+    i++
+  }
+  newNode.next = curr.next ? curr.next : null
+  curr.next = newNode
+  this.size++
+  return this
+}
+
+/**
+ * Delete the index-th node in the linked list, if the index is valid.
+ * @param {number} index
+ * @return {void}
+ */
+MyLinkedList.prototype.deleteAtIndex = function(index) {
+  if (index >= this.size || index < 0) return
+  if (index === 0) {
+    this.head = this.head.next
+    this.size--
+    return this
+  }
+  let curr = this.head
+  let i = 0
+  while (i < index - 1) {
+    i++
+    curr = curr.next
+  }
+  curr.next = curr.next.next ? curr.next.next : null
+  if (!curr.next) this.tail = curr
+  this.size--
+  return this
+}
+
+/**
+ * Your MyLinkedList object will be instantiated and called as such:
+ * var obj = new MyLinkedList()
+ * var param_1 = obj.get(index)
+ * obj.addAtHead(val)
+ * obj.addAtTail(val)
+ * obj.addAtIndex(index,val)
+ * obj.deleteAtIndex(index)
+ */
+

From 9c222cdf0c0af973d7ab7fbb16cf70d819ed8007 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Oct 2019 16:50:47 +0800
Subject: [PATCH 0008/3374] Create 84-largest-rectangle-in-histogram.js

---
 84-largest-rectangle-in-histogram.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 84-largest-rectangle-in-histogram.js

diff --git a/84-largest-rectangle-in-histogram.js b/84-largest-rectangle-in-histogram.js
new file mode 100644
index 00000000..48374417
--- /dev/null
+++ b/84-largest-rectangle-in-histogram.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const largestRectangleArea = function(heights) {
+  if (!heights.length) return 0;
+  let stack = [];
+  let max = 0;
+  for (let i = 0, cur, len = heights.length; i <= len; i++) {
+    cur = i === len ? -1 : heights[i];
+    while (stack.length && cur < heights[stack[stack.length - 1]]) {
+      let index = stack.pop();
+      let h = heights[index];
+      let w = !stack.length ? i : i - stack[stack.length - 1] - 1;
+      max = Math.max(max, h * w);
+    }
+    stack.push(i);
+  }
+  return max;
+};

From cd579cf68c425890c54aafc3021bab7166f94070 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Oct 2019 00:19:15 +0800
Subject: [PATCH 0009/3374] Update 84-largest-rectangle-in-histogram.js

---
 84-largest-rectangle-in-histogram.js | 40 ++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/84-largest-rectangle-in-histogram.js b/84-largest-rectangle-in-histogram.js
index 48374417..d1f094f9 100644
--- a/84-largest-rectangle-in-histogram.js
+++ b/84-largest-rectangle-in-histogram.js
@@ -1,3 +1,43 @@
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const largestRectangleArea = function(heights) {
+  let height = heights;
+  if (height == null || height.length == 0) {
+    return 0;
+  }
+  const lessFromLeft = new Array(height.length).fill(0);
+  const lessFromRight = new Array(height.length).fill(0);
+  lessFromRight[height.length - 1] = height.length;
+  lessFromLeft[0] = -1;
+  for (let i = 1; i < height.length; i++) {
+    let p = i - 1;
+    while (p >= 0 && height[p] >= height[i]) {
+      p = lessFromLeft[p];
+    }
+    lessFromLeft[i] = p;
+  }
+  for (let i = height.length - 2; i >= 0; i--) {
+    let p = i + 1;
+    while (p < height.length && height[p] >= height[i]) {
+      p = lessFromRight[p];
+    }
+    lessFromRight[i] = p;
+  }
+  let maxArea = 0;
+  for (let i = 0; i < height.length; i++) {
+    maxArea = Math.max(
+      maxArea,
+      height[i] * (lessFromRight[i] - lessFromLeft[i] - 1)
+    );
+  }
+  return maxArea;
+};
+
+
+// another
+
 /**
  * @param {number[]} heights
  * @return {number}

From 84eedf26bf62e0976f2cf20c2598108a98acf291 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Oct 2019 11:19:05 +0800
Subject: [PATCH 0010/3374] Create 87-scramble-string.js

---
 87-scramble-string.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 87-scramble-string.js

diff --git a/87-scramble-string.js b/87-scramble-string.js
new file mode 100644
index 00000000..7dbc3e0c
--- /dev/null
+++ b/87-scramble-string.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+const isScramble = function(s1, s2) {
+  if (s1 === s2) return true
+  const letters = new Array(128).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0; i < s1.length; i++) {
+    letters[s1.charCodeAt(i) - a]++
+    letters[s2.charCodeAt(i) - a]--
+  }
+  for (let i = 0; i < 128; i++) if (letters[i] !== 0) return false
+  for (let i = 1; i < s1.length; i++) {
+    if (
+      isScramble(s1.substring(0, i), s2.substring(0, i)) &&
+      isScramble(s1.substring(i), s2.substring(i))
+    )
+      return true
+    if (
+      isScramble(s1.substring(0, i), s2.substring(s2.length - i)) &&
+      isScramble(s1.substring(i), s2.substring(0, s2.length - i))
+    )
+      return true
+  }
+  return false
+}

From 01492b1730f80fd2bb8ff001433d82b61b030cf1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Oct 2019 00:00:39 +0800
Subject: [PATCH 0011/3374] Create 89-gray-code.js

---
 89-gray-code.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 89-gray-code.js

diff --git a/89-gray-code.js b/89-gray-code.js
new file mode 100644
index 00000000..3abfa9c9
--- /dev/null
+++ b/89-gray-code.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const grayCode = function(n) {
+  return n
+    ? (x => [...x, ...x.map((v, i) => x[x.length - 1 - i] + x.length)])(
+        grayCode(n - 1)
+      )
+    : [0]
+}

From eafdfdcc5ec48fd2aa05d097838a22d73d94b9eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Oct 2019 00:02:49 +0800
Subject: [PATCH 0012/3374] Update 89-gray-code.js

---
 89-gray-code.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/89-gray-code.js b/89-gray-code.js
index 3abfa9c9..93facd7e 100644
--- a/89-gray-code.js
+++ b/89-gray-code.js
@@ -1,3 +1,22 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const grayCode = function(n) {
+  if (n === 0) {
+    return [0]
+  }
+  const temp = grayCode(n - 1)
+  const nums = [].concat(temp)
+  const addNum = 1 << (n - 1)
+  for (let i = temp.length - 1; i >= 0; i--) {
+    nums.push(addNum + temp[i])
+  }
+  return nums
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number[]}

From fd97bed481577ac597cdb283942c5554ba3a4b6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Oct 2019 12:33:37 +0800
Subject: [PATCH 0013/3374] Update 89-gray-code.js

---
 89-gray-code.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/89-gray-code.js b/89-gray-code.js
index 93facd7e..862a618a 100644
--- a/89-gray-code.js
+++ b/89-gray-code.js
@@ -17,6 +17,24 @@ const grayCode = function(n) {
 
 // another
 
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const grayCode = function(n) {
+  const arr = []
+  arr.push(0)
+  for (let i = 0; i < n; i++) {
+    let inc = 1 << i
+    for (let j = arr.length - 1; j >= 0; j--) {
+      arr.push(arr[j] + inc)
+    }
+  }
+  return arr
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number[]}

From ca2988bac5da34f0d0545ce060c0a5e107774570 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Oct 2019 21:19:32 +0800
Subject: [PATCH 0014/3374] Create 98-validate-binary-search-tree.js

---
 98-validate-binary-search-tree.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 98-validate-binary-search-tree.js

diff --git a/98-validate-binary-search-tree.js b/98-validate-binary-search-tree.js
new file mode 100644
index 00000000..22856821
--- /dev/null
+++ b/98-validate-binary-search-tree.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const isValidBST = function(root) {
+  return helper(root, -Infinity, Infinity)
+}
+function helper(root, minValue, maxValue) {
+  if (!root) return true
+  if (root.val <= minValue || root.val >= maxValue) {
+    return false
+  }
+  let leftSide = helper(root.left, minValue, root.val)
+  let rightSide = helper(root.right, root.val, maxValue)
+  return leftSide && rightSide
+}

From e14495304a3718b38d28342395280f172f49c9be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Oct 2019 21:39:49 +0800
Subject: [PATCH 0015/3374] Create 107-binary-tree-level-order-traversal-ii.js

---
 107-binary-tree-level-order-traversal-ii.js | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 107-binary-tree-level-order-traversal-ii.js

diff --git a/107-binary-tree-level-order-traversal-ii.js b/107-binary-tree-level-order-traversal-ii.js
new file mode 100644
index 00000000..741598cc
--- /dev/null
+++ b/107-binary-tree-level-order-traversal-ii.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const levelOrderBottom = function(root) {
+  const levels = []
+  postOrderTraversal(root)
+  return levels.reverse()
+
+  function postOrderTraversal(node, level = 0) {
+    if (node) {
+      if (!levels[level]) levels.push([])
+      postOrderTraversal(node.left, level + 1)
+      postOrderTraversal(node.right, level + 1)
+      levels[level].push(node.val)
+    }
+  }
+}

From dd5f7e76019e1d3ae7a1ce4dea5430127304c929 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Oct 2019 22:12:15 +0800
Subject: [PATCH 0016/3374] Update 107-binary-tree-level-order-traversal-ii.js

---
 107-binary-tree-level-order-traversal-ii.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/107-binary-tree-level-order-traversal-ii.js b/107-binary-tree-level-order-traversal-ii.js
index 741598cc..12484e33 100644
--- a/107-binary-tree-level-order-traversal-ii.js
+++ b/107-binary-tree-level-order-traversal-ii.js
@@ -23,3 +23,23 @@ const levelOrderBottom = function(root) {
     }
   }
 }
+
+// another
+
+const levelOrderBottom = function(root) {
+  if (!root) return []
+  const currentLevelNodes = [root]
+  const result = []
+  while (currentLevelNodes.length > 0) {
+    const count = currentLevelNodes.length
+    const currentLevelValues = []
+    for (let i = 0; i < count; i++) {
+      const node = currentLevelNodes.shift()
+      currentLevelValues.push(node.val)
+      if (node.left) currentLevelNodes.push(node.left)
+      if (node.right) currentLevelNodes.push(node.right)
+    }
+    result.unshift(currentLevelValues)
+  }
+  return result
+}

From e7e8b3cc952f38c1da8f4a59c29d5074df6fe7ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Oct 2019 21:29:44 +0800
Subject: [PATCH 0017/3374] Create
 116-populating-next-right-pointers-in-each-node.js

---
 ...lating-next-right-pointers-in-each-node.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 116-populating-next-right-pointers-in-each-node.js

diff --git a/116-populating-next-right-pointers-in-each-node.js b/116-populating-next-right-pointers-in-each-node.js
new file mode 100644
index 00000000..6291fe8c
--- /dev/null
+++ b/116-populating-next-right-pointers-in-each-node.js
@@ -0,0 +1,29 @@
+/**
+ * // Definition for a Node.
+ * function Node(val,left,right,next) {
+ *    this.val = val;
+ *    this.left = left;
+ *    this.right = right;
+ *    this.next = next;
+ * };
+ */
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+const connect = function(root) {
+  if (root == null) return null
+  const cur = [root]
+  while (cur.length) {
+    let len = cur.length
+    for (let i = 0; i < len; i++) {
+      let el = cur.shift()
+      if (i === len - 1) el.next = null
+      else el.next = cur[0]
+
+      if (el.left) cur.push(el.left)
+      if (el.right) cur.push(el.right)
+    }
+  }
+  return root
+}

From 801cc987e4a73c35bfa1a87d4aafcbbd86bcbbca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Oct 2019 21:35:02 +0800
Subject: [PATCH 0018/3374] Update
 116-populating-next-right-pointers-in-each-node.js

---
 116-populating-next-right-pointers-in-each-node.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/116-populating-next-right-pointers-in-each-node.js b/116-populating-next-right-pointers-in-each-node.js
index 6291fe8c..3461fb0c 100644
--- a/116-populating-next-right-pointers-in-each-node.js
+++ b/116-populating-next-right-pointers-in-each-node.js
@@ -27,3 +27,16 @@ const connect = function(root) {
   }
   return root
 }
+
+// another
+
+const connect = function(root) {
+  if (!root) return null
+  if (root.left && root.right) {
+    root.left.next = root.right
+    root.right.next = root.next ? root.next.left : null
+  }
+  connect(root.left)
+  connect(root.right)
+  return root
+}

From d1b7098cac8463bde7dcf0e796dd9333fc8529b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Oct 2019 12:58:04 +0800
Subject: [PATCH 0019/3374] Create
 117-populating-next-right-pointers-in-each-node-ii.js

---
 ...ing-next-right-pointers-in-each-node-ii.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 117-populating-next-right-pointers-in-each-node-ii.js

diff --git a/117-populating-next-right-pointers-in-each-node-ii.js b/117-populating-next-right-pointers-in-each-node-ii.js
new file mode 100644
index 00000000..f0f83654
--- /dev/null
+++ b/117-populating-next-right-pointers-in-each-node-ii.js
@@ -0,0 +1,28 @@
+/**
+ * // Definition for a Node.
+ * function Node(val,left,right,next) {
+ *    this.val = val;
+ *    this.left = left;
+ *    this.right = right;
+ *    this.next = next;
+ * };
+ */
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+const connect = function(root) {
+  if (root == null) return null
+  const cur = [root]
+  while (cur.length) {
+    const len = cur.length
+    for (let i = 0; i < len; i++) {
+      const el = cur.shift()
+      if (i === len - 1) el.next = null
+      else el.next = cur[0]
+      if (el.left) cur.push(el.left)
+      if (el.right) cur.push(el.right)
+    }
+  }
+  return root
+}

From 31192e93a2dfec4450bc365c80fad372349407f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Oct 2019 13:46:31 +0800
Subject: [PATCH 0020/3374] Create 127-word-ladder.js

---
 127-word-ladder.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 127-word-ladder.js

diff --git a/127-word-ladder.js b/127-word-ladder.js
new file mode 100644
index 00000000..ebfec5da
--- /dev/null
+++ b/127-word-ladder.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} beginWord
+ * @param {string} endWord
+ * @param {string[]} wordList
+ * @return {number}
+ */
+const ladderLength = function(beginWord, endWord, wordList) {
+  const list = new Set(wordList)
+  if (!list.has(endWord)) return 0
+  let one = new Set([beginWord])
+  let two = new Set([endWord])
+  let step = 1
+  while (one.size && two.size) {
+    let temp = new Set()
+    if (two.size < one.size) [one, two] = [two, one]
+    for (const word of one) {
+      for (let i = 0; i < word.length; i++) {
+        for (let j = 0; j < 26; j++) {
+          const candidate =
+            word.slice(0, i) + String.fromCharCode(97 + j) + word.slice(i + 1)
+          if (two.has(candidate)) return step + 1
+          if (!list.has(candidate)) continue
+          temp.add(candidate)
+          list.delete(candidate)
+        }
+      }
+    }
+    ;[one, temp] = [temp, one]
+    step++
+  }
+  return 0
+}

From db4dccffd9a277036b5782da01d9784a3fa2c371 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Oct 2019 11:13:05 +0800
Subject: [PATCH 0021/3374] Create 130-surrounded-regions.js

---
 130-surrounded-regions.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 130-surrounded-regions.js

diff --git a/130-surrounded-regions.js b/130-surrounded-regions.js
new file mode 100644
index 00000000..b7295d39
--- /dev/null
+++ b/130-surrounded-regions.js
@@ -0,0 +1,33 @@
+/**
+ * @param {character[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+const solve = function(board) {
+  if (!board || board.length < 3 || board[0].length < 3) return;
+  let r = board.length;
+  let c = board[0].length;
+  for (let i = 0; i < c; i++) {
+    if (board[0][i] === "O") search(board, 0, i);
+    if (board[r - 1][i] === "O") search(board, r - 1, i);
+  }
+  for (let i = 0; i < r; i++) {
+    if (board[i][0] === "O") search(board, i, 0);
+    if (board[i][c - 1] === "O") search(board, i, c - 1);
+  }
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      if (board[i][j] === "O") board[i][j] = "X";
+      if (board[i][j] === "*") board[i][j] = "O";
+    }
+  }
+};
+
+function search(board, i, j) {
+  if (i < 0 || j < 0 || i >= board.length || j >= board[0].length) return;
+  if (board[i][j] !== "O") return;
+  board[i][j] = "*";
+  search(board, i + 1, j);
+  search(board, i - 1, j);
+  search(board, i, j + 1);
+  search(board, i, j - 1);
+}

From a6cdaaacafdabef9b094174b238b502111fb20fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Oct 2019 21:00:44 +0800
Subject: [PATCH 0022/3374] Create 131-palindrome-partitioning.js

---
 131-palindrome-partitioning.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 131-palindrome-partitioning.js

diff --git a/131-palindrome-partitioning.js b/131-palindrome-partitioning.js
new file mode 100644
index 00000000..c528343b
--- /dev/null
+++ b/131-palindrome-partitioning.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} s
+ * @return {string[][]}
+ */
+const partition = function(s) {
+  let res = []
+  backtrack(res, [], 0, s)
+  return res
+}
+
+function backtrack(res, cur, start, s) {
+  if (start === s.length) res.push([...cur])
+  else {
+    for (let i = start; i < s.length; i++) {
+      if (isPalindrome(s, start, i)) {
+        cur.push(s.substring(start, i + 1))
+        backtrack(res, cur, i + 1, s)
+        cur.pop()
+      }
+    }
+  }
+}
+
+function isPalindrome(str, start, i) {
+  let l = start,
+    r = i
+  while (l < r) {
+    if (str[l] !== str[r]) return false
+    l++
+    r--
+  }
+  return true
+}

From 0ae9da7e9aaf63862b35ce97bd5d18f2978201c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Oct 2019 10:35:01 +0800
Subject: [PATCH 0023/3374] Create 133-clone-graph.js

---
 133-clone-graph.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 133-clone-graph.js

diff --git a/133-clone-graph.js b/133-clone-graph.js
new file mode 100644
index 00000000..b2371610
--- /dev/null
+++ b/133-clone-graph.js
@@ -0,0 +1,24 @@
+/**
+ * // Definition for a Node.
+ * function Node(val,neighbors) {
+ *    this.val = val;
+ *    this.neighbors = neighbors;
+ * };
+ */
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const cloneGraph = function(node) {
+  if (!node) return node
+  const map = {}
+  return traverse(node)
+  function traverse(node) {
+    if (!map[node.val]) {
+      const newNode = new Node(node.val)
+      map[node.val] = newNode
+      newNode.neighbors = node.neighbors.map(traverse)
+    }
+    return map[node.val]
+  }
+}

From 474880c927547e58033144bb6144a6468305038a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Oct 2019 11:02:10 +0800
Subject: [PATCH 0024/3374] Update 133-clone-graph.js

---
 133-clone-graph.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/133-clone-graph.js b/133-clone-graph.js
index b2371610..0973bc54 100644
--- a/133-clone-graph.js
+++ b/133-clone-graph.js
@@ -1,3 +1,13 @@
+/**
+ *   - if(!node) return node. Graphs can also have null neighbors
+ *   - using a Set doesn't work because we are dealing with objects not primitives
+ *       - and when encountering an already-cloned node, you are supposed to return the copied node
+ *       (otherwise you are linking back to the original)
+ *       - so, map = {} is correct
+ *   - the only "trick" is that you must set the current node as "already copied" before DFS-ing its neighbors
+ *   - declaring new variable for copying a node is actually extra O(n) space
+ */
+
 /**
  * // Definition for a Node.
  * function Node(val,neighbors) {
@@ -14,6 +24,7 @@ const cloneGraph = function(node) {
   const map = {}
   return traverse(node)
   function traverse(node) {
+    if(!node) return node;
     if (!map[node.val]) {
       const newNode = new Node(node.val)
       map[node.val] = newNode

From 1d77fbbb1495f3ab12810e00805bb4bee9ad5f85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Oct 2019 21:35:35 +0800
Subject: [PATCH 0025/3374] Create 134-gas-station.js

---
 134-gas-station.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 134-gas-station.js

diff --git a/134-gas-station.js b/134-gas-station.js
new file mode 100644
index 00000000..30b3cd37
--- /dev/null
+++ b/134-gas-station.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} gas
+ * @param {number[]} cost
+ * @return {number}
+ */
+const canCompleteCircuit = function(gas, cost) {
+  let total = 0
+  let curLeft = 0
+  let curtIdx = 0
+  for (let i = 0; i < gas.length; i++) {
+    total += gas[i] - cost[i]
+    curLeft += gas[i] - cost[i]
+    if (curLeft < 0) {
+      curtIdx = i + 1
+      curLeft = 0
+    }
+  }
+  return total < 0 ? -1 : curtIdx
+}

From 99e082e8631750559f91919d4bb0c73bc253da7b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Oct 2019 22:09:21 +0800
Subject: [PATCH 0026/3374] Update 134-gas-station.js

---
 134-gas-station.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/134-gas-station.js b/134-gas-station.js
index 30b3cd37..a7dc4e04 100644
--- a/134-gas-station.js
+++ b/134-gas-station.js
@@ -17,3 +17,23 @@ const canCompleteCircuit = function(gas, cost) {
   }
   return total < 0 ? -1 : curtIdx
 }
+
+// another
+
+const canCompleteCircuit = function(gas, cost) {
+  const len = gas.length
+  let tank = 0
+  let count = 0
+  for (let i = 0; i < len * 2; i++) {
+    let idx = i % len
+    if (count === len) return idx
+    count += 1
+    tank += gas[idx] - cost[idx]
+    if (tank < 0) {
+      tank = 0
+      count = 0
+    }
+  }
+  return -1
+}
+

From 2555904fe0271cc3dc9d95ae6eadbc532aa34848 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Oct 2019 16:19:13 +0800
Subject: [PATCH 0027/3374] Create 147-insertion-sort-list.js

---
 147-insertion-sort-list.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 147-insertion-sort-list.js

diff --git a/147-insertion-sort-list.js b/147-insertion-sort-list.js
new file mode 100644
index 00000000..4a198314
--- /dev/null
+++ b/147-insertion-sort-list.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const insertionSortList = function(head) {
+  const dummy = new ListNode()
+  dummy.next = head
+  let insert = dummy
+  let cur = head
+  while (cur && cur.next) {
+    if (cur.val < cur.next.val) {
+      cur = cur.next
+      continue
+    }
+    insert = dummy
+    while (insert.next.val < cur.next.val) {
+      insert = insert.next
+    }
+    const temp = cur.next
+    cur.next = temp.next
+    temp.next = insert.next
+    insert.next = temp
+  }
+  return dummy.next
+}

From 079c08209cad79edd204e6f53539326b7f81d6db Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Oct 2019 20:54:29 +0800
Subject: [PATCH 0028/3374] Create 150-evaluate-reverse-polish-notation.js

---
 150-evaluate-reverse-polish-notation.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 150-evaluate-reverse-polish-notation.js

diff --git a/150-evaluate-reverse-polish-notation.js b/150-evaluate-reverse-polish-notation.js
new file mode 100644
index 00000000..2fbd63d0
--- /dev/null
+++ b/150-evaluate-reverse-polish-notation.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} tokens
+ * @return {number}
+ */
+const evalRPN = function(tokens) {
+  const stack = []
+  for (let token of tokens) {
+    if (token === '+') {
+      stack.push(stack.pop() + stack.pop())
+    } else if (token === '-') {
+      stack.push(-stack.pop() + stack.pop())
+    } else if (token === '*') {
+      stack.push(stack.pop() * stack.pop())
+    } else if (token === '/') {
+      stack.push(Math.trunc((1 / stack.pop()) * stack.pop()))
+    } else {
+      stack.push(parseInt(token))
+    }
+  }
+  return stack[0]
+}

From b9135028e62ebf8b3977f50d3ea6c4b0a5de021b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Oct 2019 22:08:39 +0800
Subject: [PATCH 0029/3374] Create
 154-find-minimum-in-rotated-sorted-array-ii.js

---
 ...find-minimum-in-rotated-sorted-array-ii.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 154-find-minimum-in-rotated-sorted-array-ii.js

diff --git a/154-find-minimum-in-rotated-sorted-array-ii.js b/154-find-minimum-in-rotated-sorted-array-ii.js
new file mode 100644
index 00000000..1ed12103
--- /dev/null
+++ b/154-find-minimum-in-rotated-sorted-array-ii.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMin = function(nums) {
+  for(let i = 1, len = nums.length; i < len; i++) {
+    if(nums[i] < nums[i - 1]) {
+      return nums[i]
+    }
+  }
+  return nums[0]
+};
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMin = function(nums) {
+  let lo = 0,
+    hi = nums.length - 1
+  while (lo < hi) {
+    let mid = Math.floor(lo + (hi - lo) / 2)
+    if (nums[mid] > nums[hi]) lo = mid + 1
+    else if (nums[mid] < nums[hi]) hi = mid
+    else hi--
+  }
+  return nums[lo]
+}

From def328423fdf0e5875a01452e245b804f154c99e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 11:16:59 +0800
Subject: [PATCH 0030/3374] Create 173-binary-search-tree-iterator.js

---
 173-binary-search-tree-iterator.js | 45 ++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 173-binary-search-tree-iterator.js

diff --git a/173-binary-search-tree-iterator.js b/173-binary-search-tree-iterator.js
new file mode 100644
index 00000000..025e771b
--- /dev/null
+++ b/173-binary-search-tree-iterator.js
@@ -0,0 +1,45 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+const BSTIterator = function(root) {
+  this.root = root;
+  this.stack = [];
+};
+
+/**
+ * @return the next smallest number
+ * @return {number}
+ */
+BSTIterator.prototype.next = function() {
+  while (this.root) {
+    this.stack.push(this.root);
+    this.root = this.root.left;
+  }
+  this.root = this.stack.pop();
+  const result = this.root.val;
+  this.root = this.root.right;
+  return result;
+};
+
+/**
+ * @return whether we have a next smallest number
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasNext = function() {
+  return this.root || this.stack.length;
+};
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+

From 068bf0f79945481e5abc68833b807e64234d5314 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 12:27:08 +0800
Subject: [PATCH 0031/3374] Update 173-binary-search-tree-iterator.js

---
 173-binary-search-tree-iterator.js | 61 ++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/173-binary-search-tree-iterator.js b/173-binary-search-tree-iterator.js
index 025e771b..92044020 100644
--- a/173-binary-search-tree-iterator.js
+++ b/173-binary-search-tree-iterator.js
@@ -43,3 +43,64 @@ BSTIterator.prototype.hasNext = function() {
  * var param_2 = obj.hasNext()
  */
 
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+const BSTIterator = function(root) {
+  this.generator = dfsGenerator(root)
+  this.root = root
+  this.nextSmall = this.generator.next().value
+}
+function* dfsGenerator(root) {
+  if (root === null) return
+  const stack = []
+  let current = root
+  while (true) {
+    if (current) {
+      stack.push(current)
+      current = current.left
+    } else if (stack.length) {
+      const top = stack.pop()
+      yield top.val
+      current = top.right
+    } else {
+      break
+    }
+  }
+}
+
+/**
+ * @return the next smallest number
+ * @return {number}
+ */
+BSTIterator.prototype.next = function() {
+  const smallReturn = this.nextSmall
+  this.nextSmall = this.generator.next().value
+  return smallReturn
+}
+
+/**
+ * @return whether we have a next smallest number
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasNext = function() {
+  return this.nextSmall !== undefined ? true : false
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+
+

From f026df3cf59468ed458038f623fb21e2e8ee5821 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 14:29:13 +0800
Subject: [PATCH 0032/3374] Create 162-find-peak-element.js

---
 162-find-peak-element.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 162-find-peak-element.js

diff --git a/162-find-peak-element.js b/162-find-peak-element.js
new file mode 100644
index 00000000..526b153d
--- /dev/null
+++ b/162-find-peak-element.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findPeakElement = function(nums) {
+  if(nums == null) return -1
+  const len = nums.length
+  if(len === 1) return 0
+  for(let i = 1; i < len; i++) {
+    if(i === 1 && nums[i] < nums[i - 1]) return 0
+    else if(i === len - 1 && nums[i] > nums[i - 1]) return len - 1
+    else if(nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) return i
+  }
+  return -1
+};

From 97fb7b361c12ee724255855758ef8ae7d709efe5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 14:37:53 +0800
Subject: [PATCH 0033/3374] Create 176-second-highest-salary.sql

---
 176-second-highest-salary.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 176-second-highest-salary.sql

diff --git a/176-second-highest-salary.sql b/176-second-highest-salary.sql
new file mode 100644
index 00000000..79b3dfac
--- /dev/null
+++ b/176-second-highest-salary.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT max(Salary) AS SecondHighestSalary
+FROM Employee
+WHERE Salary < (SELECT max(Salary) FROM Employee)
+
+# another
+
+# Write your MySQL query statement below
+SELECT IFNULL(
+    (SELECT DISTINCT Salary 
+    FROM Employee 
+    ORDER BY Salary DESC
+    LIMIT 1 OFFSET 1)
+    , NULL) AS SecondHighestSalary

From 8a31438363726da6b0fd624cf1c4d2d39ea89114 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 14:59:45 +0800
Subject: [PATCH 0034/3374] Create 179-largest-number.js

---
 179-largest-number.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 179-largest-number.js

diff --git a/179-largest-number.js b/179-largest-number.js
new file mode 100644
index 00000000..07b1fab7
--- /dev/null
+++ b/179-largest-number.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {string}
+ */
+const largestNumber = function(nums) {
+  const arr = nums
+    .map(v => v.toString())
+    .sort((a, b) => (a + b < b + a ? 1 : -1))
+    .join("");
+
+  return arr[0] === "0" ? "0" : arr;
+};

From b88fdf86b720d0e4a15a6468f9dd899f3a896e78 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 21:03:40 +0800
Subject: [PATCH 0035/3374] Create
 181-employees-earning-more-than-their-managers.sql

---
 181-employees-earning-more-than-their-managers.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 181-employees-earning-more-than-their-managers.sql

diff --git a/181-employees-earning-more-than-their-managers.sql b/181-employees-earning-more-than-their-managers.sql
new file mode 100644
index 00000000..3c0407bc
--- /dev/null
+++ b/181-employees-earning-more-than-their-managers.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT Name AS Employee FROM Employee AS E,
+(SELECT DISTINCT Id, Salary FROM Employee) AS M
+WHERE E.ManagerId = M.Id AND E.Salary > M.Salary

From b057fec07025c042839e3e9b7854bdeab0464632 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 21:25:04 +0800
Subject: [PATCH 0036/3374] Create 189-rotate-array.js

---
 189-rotate-array.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 189-rotate-array.js

diff --git a/189-rotate-array.js b/189-rotate-array.js
new file mode 100644
index 00000000..dfab6e7c
--- /dev/null
+++ b/189-rotate-array.js
@@ -0,0 +1,8 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+const rotate = function(nums, k) {
+  nums.unshift(...nums.splice(nums.length - k));
+};

From c94b18b4e53b16c4f43416a97db2dcbd2d05d168 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 21:28:03 +0800
Subject: [PATCH 0037/3374] Update 189-rotate-array.js

---
 189-rotate-array.js | 12 +++++++++++-
 1 file changed, 11 insertions(+), 1 deletion(-)

diff --git a/189-rotate-array.js b/189-rotate-array.js
index dfab6e7c..78f20250 100644
--- a/189-rotate-array.js
+++ b/189-rotate-array.js
@@ -4,5 +4,15 @@
  * @return {void} Do not return anything, modify nums in-place instead.
  */
 const rotate = function(nums, k) {
-  nums.unshift(...nums.splice(nums.length - k));
+  nums.unshift(...nums.splice(nums.length - k))
+};
+
+// another
+
+const rotate = function(nums, k) {
+  let i = k
+  while (i > 0) {
+    nums.unshift(nums.pop())
+    i--
+  }
 };

From 26c19804882cdea43419d5ff13eec5883fc1da26 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 21:31:49 +0800
Subject: [PATCH 0038/3374] Update 189-rotate-array.js

---
 189-rotate-array.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/189-rotate-array.js b/189-rotate-array.js
index 78f20250..f6017a19 100644
--- a/189-rotate-array.js
+++ b/189-rotate-array.js
@@ -16,3 +16,22 @@ const rotate = function(nums, k) {
     i--
   }
 };
+
+// another
+
+const rotate = function(nums, k) {
+  k %= nums.length
+  reverse(nums, 0, nums.length - 1)
+  reverse(nums, 0, k - 1)
+  reverse(nums, k, nums.length - 1)
+}
+
+function reverse(nums, start, end) {
+  while (start < end) {
+    var temp = nums[start]
+    nums[start] = nums[end]
+    nums[end] = temp
+    start++
+    end--
+  }
+}

From 356e5740365f1a00c651f3b04647108b6dcd84b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2019 21:52:52 +0800
Subject: [PATCH 0039/3374] Create 193-valid-phone-numbers.sh

---
 193-valid-phone-numbers.sh | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 193-valid-phone-numbers.sh

diff --git a/193-valid-phone-numbers.sh b/193-valid-phone-numbers.sh
new file mode 100644
index 00000000..5ab758c2
--- /dev/null
+++ b/193-valid-phone-numbers.sh
@@ -0,0 +1,10 @@
+# Read from the file file.txt and output all valid phone numbers to stdout.
+awk '/^([0-9]{3}-|\([0-9]{3}\) )[0-9]{3}-[0-9]{4}$/' file.txt
+
+# another
+
+grep -P '^(\(\d{3}\) |\d{3}-)\d{3}-\d{4}$' file.txt
+
+# another
+
+sed -n -r '/^([0-9]{3}-|\([0-9]{3}\) )[0-9]{3}-[0-9]{4}$/p' file.txt

From d0d4ad24770b9724db69146ac0a3d9e69345d61e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Oct 2019 12:33:50 +0800
Subject: [PATCH 0040/3374] Create 199-binary-tree-right-side-view.js

---
 199-binary-tree-right-side-view.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 199-binary-tree-right-side-view.js

diff --git a/199-binary-tree-right-side-view.js b/199-binary-tree-right-side-view.js
new file mode 100644
index 00000000..44098606
--- /dev/null
+++ b/199-binary-tree-right-side-view.js
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+const rightSideView = function(root) {
+  if(root == null) return []
+  const queue = [root]
+  const res = []
+  while(queue.length) {
+    const len = queue.length
+    for(let i = 0; i < len; i++) {
+      const el = queue.shift()
+      if(i === len - 1) res.push(el.val)
+      if(el.left) queue.push(el.left)
+      if(el.right) queue.push(el.right)
+    }
+  }
+  return res
+};

From 6602e6c1dce7af4c797cf4438c38cd662f6891f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Oct 2019 12:44:37 +0800
Subject: [PATCH 0041/3374] Update 199-binary-tree-right-side-view.js

---
 199-binary-tree-right-side-view.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/199-binary-tree-right-side-view.js b/199-binary-tree-right-side-view.js
index 44098606..7bbf5a42 100644
--- a/199-binary-tree-right-side-view.js
+++ b/199-binary-tree-right-side-view.js
@@ -24,3 +24,21 @@ const rightSideView = function(root) {
   }
   return res
 };
+
+// another
+
+const rightSideView = function(root) {
+  const res = []
+  const helper = function(node, level) {
+    if (!node) {
+      return
+    }
+    if (!res[level]) {
+      res.push(node.val)
+    }
+    helper(node.right, level + 1)
+    helper(node.left, level + 1)
+  }
+  helper(root, 0)
+  return res
+}

From c19d89256fc578d3c11830b825bc4d0e5d2a45c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Oct 2019 13:01:06 +0800
Subject: [PATCH 0042/3374] Create 203-remove-linked-list-elements.js

---
 203-remove-linked-list-elements.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 203-remove-linked-list-elements.js

diff --git a/203-remove-linked-list-elements.js b/203-remove-linked-list-elements.js
new file mode 100644
index 00000000..e723b517
--- /dev/null
+++ b/203-remove-linked-list-elements.js
@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} val
+ * @return {ListNode}
+ */
+const removeElements = function(head, val) {
+  const dummy = new ListNode(Infinity)
+  if(head == null) return null
+  dummy.next = head
+  let cur = head
+  let prev = dummy
+  while(cur) {
+    if(cur.val === val) {
+      prev.next = cur.next
+      cur = cur.next
+    } else {
+      prev = cur
+      cur = cur.next
+    }
+  }
+  return dummy.next
+};

From b0bc5c09821fea85efd91704ba8aa3e3ac6d73be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Oct 2019 15:47:09 +0800
Subject: [PATCH 0043/3374] Create 207-course-schedule.js

---
 207-course-schedule.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 207-course-schedule.js

diff --git a/207-course-schedule.js b/207-course-schedule.js
new file mode 100644
index 00000000..b59ad83b
--- /dev/null
+++ b/207-course-schedule.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+const canFinish = function(numCourses, prerequisites) {
+  const seen = new Set()
+  const seeing = new Set()
+  const adj = [...Array(numCourses)].map(r => [])
+  for (let [u, v] of prerequisites) {
+    adj[v].push(u)
+  }
+  for (let c = 0; c < numCourses; c++) {
+    if (!dfs(c)) {
+      return false
+    }
+  }
+  return true
+  function dfs(v) {
+    if (seen.has(v)) return true
+    if (seeing.has(v)) return false
+    seeing.add(v)
+    for (let nv of adj[v]) {
+      if (!dfs(nv)) {
+        return false
+      }
+    }
+    seeing.delete(v)
+    seen.add(v)
+    return true
+  }
+}

From 1dba49787e5b80c975d7e9235e3e6f0a1a6f486f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Oct 2019 16:53:00 +0800
Subject: [PATCH 0044/3374] Update 207-course-schedule.js

---
 207-course-schedule.js | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/207-course-schedule.js b/207-course-schedule.js
index b59ad83b..bbec50c5 100644
--- a/207-course-schedule.js
+++ b/207-course-schedule.js
@@ -30,3 +30,45 @@ const canFinish = function(numCourses, prerequisites) {
     return true
   }
 }
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+const canFinish = function(vertices, edges) {
+  const sortedOrder = []
+  if (vertices <= 0) {
+    return sortedOrder
+  }
+  const inDegree = Array(vertices).fill(0)
+  const graph = Array(vertices)
+    .fill(0)
+    .map(() => Array())
+  edges.forEach(edge => {
+    let parent = edge[0]
+    let child = edge[1]
+    graph[parent].push(child)
+    inDegree[child]++
+  })
+  const sources = []
+  for (let i = 0; i < inDegree.length; i++) {
+    if (inDegree[i] === 0) {
+      sources.push(i)
+    }
+  }
+  while (sources.length > 0) {
+    const vertex = sources.shift()
+    sortedOrder.push(vertex)
+
+    graph[vertex].forEach(child => {
+      inDegree[child] -= 1
+      if (inDegree[child] === 0) {
+        sources.push(child)
+      }
+    })
+  }
+  return sortedOrder.length === vertices ? true : false
+}

From ec4e760a53774c4a67a60f58a51a14e969b8e8ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Oct 2019 17:34:40 +0800
Subject: [PATCH 0045/3374] Create 208-implement-trie-prefix-tree.js

---
 208-implement-trie-prefix-tree.js | 53 +++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 208-implement-trie-prefix-tree.js

diff --git a/208-implement-trie-prefix-tree.js b/208-implement-trie-prefix-tree.js
new file mode 100644
index 00000000..69eafb3f
--- /dev/null
+++ b/208-implement-trie-prefix-tree.js
@@ -0,0 +1,53 @@
+/**
+ * Initialize your data structure here.
+ */
+const Trie = function() {
+  this.root = {}
+};
+
+/**
+ * Inserts a word into the trie. 
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.insert = function(word) {
+  let curr = this.root
+  word.split('').forEach(ch => (curr = curr[ch] = curr[ch] || {}))
+  curr.isWord = true
+};
+
+/**
+ * Returns if the word is in the trie. 
+ * @param {string} word
+ * @return {boolean}
+ */
+Trie.prototype.search = function(word) {
+  let node = this.traverse(word)
+  return !!node && !!node.isWord   
+};
+
+/**
+ * Returns if there is any word in the trie that starts with the given prefix. 
+ * @param {string} prefix
+ * @return {boolean}
+ */
+Trie.prototype.startsWith = function(prefix) {
+   return !!this.traverse(prefix)   
+};
+
+/** 
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */
+
+Trie.prototype.traverse = function(word) {
+  let curr = this.root
+  for (let i = 0; i < word.length; i++) {
+    if (!curr) return null
+    curr = curr[word[i]]
+  }
+  return curr
+}

From 1f687d0b67603d23734a42d56496520de72cb328 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Oct 2019 17:38:51 +0800
Subject: [PATCH 0046/3374] Update 208-implement-trie-prefix-tree.js

---
 208-implement-trie-prefix-tree.js | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/208-implement-trie-prefix-tree.js b/208-implement-trie-prefix-tree.js
index 69eafb3f..2d666bb4 100644
--- a/208-implement-trie-prefix-tree.js
+++ b/208-implement-trie-prefix-tree.js
@@ -51,3 +51,37 @@ Trie.prototype.traverse = function(word) {
   }
   return curr
 }
+
+// another
+
+class Trie {
+  constructor() {
+    this.links = new Map();
+    this.isWord = false;
+  }
+  insert(word) {
+    let node = this;
+    for (const c of word) {
+      if (!node.links.has(c)) node.links.set(c, new Trie());
+      node = node.links.get(c);
+    }
+    node.isWord = true;
+  }
+  search(word) {
+    const node = this.traverse(word);
+    return node ? node.isWord : false;
+  }
+  startsWith(prefix) {
+    const node = this.traverse(prefix);
+    return node !== null;
+  }
+  traverse(word) {
+    let node = this;
+    for (const c of word) {
+      if (node.links.has(c)) node = node.links.get(c);
+      else return null;
+    }
+    return node;
+  }
+}
+

From f14f10d032270550f6bd3128defb6331086c651b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Oct 2019 10:48:17 +0800
Subject: [PATCH 0047/3374] Create 210-course-schedule-ii.js

---
 210-course-schedule-ii.js | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 210-course-schedule-ii.js

diff --git a/210-course-schedule-ii.js b/210-course-schedule-ii.js
new file mode 100644
index 00000000..a7d6f321
--- /dev/null
+++ b/210-course-schedule-ii.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+const findOrder = function(numCourses, prerequisites) {
+  const seen = new Set()
+  const seeing = new Set()
+  const res = []
+
+  const adj = [...Array(numCourses)].map(r => [])
+  for (let [u, v] of prerequisites) {
+    adj[v].push(u)
+  }
+  for (let c = 0; c < numCourses; c++) {
+    if (!dfs(c)) {
+      return []
+    }
+  }
+  return res.reverse()
+
+  function dfs(v) {
+    if (seen.has(v)) {
+      return true
+    }
+    if (seeing.has(v)) {
+      return false
+    }
+    seeing.add(v)
+    for (let nv of adj[v]) {
+      if (!dfs(nv)) {
+        return false
+      }
+    }
+    seeing.delete(v)
+    seen.add(v)
+    res.push(v)
+    return true
+  }
+}

From acfc5c1292bb54dbefca83f7d9a6b3ade4f4aea4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Oct 2019 11:03:41 +0800
Subject: [PATCH 0048/3374] Update 210-course-schedule-ii.js

---
 210-course-schedule-ii.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/210-course-schedule-ii.js b/210-course-schedule-ii.js
index a7d6f321..f9c01679 100644
--- a/210-course-schedule-ii.js
+++ b/210-course-schedule-ii.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+const findOrder = function(numCourses, prerequisites) {
+  const indegree = new Array(numCourses).fill(0)
+  const graph = {}
+  for (let [course, prereq] of prerequisites) {
+    indegree[course]++
+    graph[prereq] === undefined
+      ? (graph[prereq] = [course])
+      : graph[prereq].push(course)
+  }
+  const queue = [],
+    ans = []
+  for (let i = 0; i < indegree.length; i++) if (!indegree[i]) queue.push(i)
+  while (queue.length) {
+    let cur = queue.shift()
+    ans.push(cur)
+    for (let neigbhors of graph[cur] || []) {
+      if (!--indegree[neigbhors]) queue.push(neigbhors)
+    }
+  }
+  return ans.length === numCourses ? ans : []
+}
+
+// another
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From 037f1509a1796fe7f5f87cd7236ef5de213e8064 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Oct 2019 12:05:22 +0800
Subject: [PATCH 0049/3374] Create 220-contains-duplicate-iii.js

---
 220-contains-duplicate-iii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 220-contains-duplicate-iii.js

diff --git a/220-contains-duplicate-iii.js b/220-contains-duplicate-iii.js
new file mode 100644
index 00000000..e627d24f
--- /dev/null
+++ b/220-contains-duplicate-iii.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} t
+ * @return {boolean}
+ */
+const containsNearbyAlmostDuplicate = function(nums, k, t) {
+  const map = nums
+    .map((val, idx) => ({ val, idx }))
+    .sort((a, b) => a.val - b.val)
+  let l = 0
+  let r = 1
+  while (r < map.length) {
+    const diff = Math.abs(map[r].val - map[l].val)
+    const range = Math.abs(map[r].idx - map[l].idx)
+    if (diff <= t && range <= k) return true
+    else if (diff > t) l++
+    else if (range > k) r++
+    if (l === r) r++
+  }
+  return false
+}

From 982ae69bc0a4cdd7f6b8a177e51437764d11b5ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Oct 2019 12:17:37 +0800
Subject: [PATCH 0050/3374] Update 220-contains-duplicate-iii.js

---
 220-contains-duplicate-iii.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/220-contains-duplicate-iii.js b/220-contains-duplicate-iii.js
index e627d24f..688979df 100644
--- a/220-contains-duplicate-iii.js
+++ b/220-contains-duplicate-iii.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} t
+ * @return {boolean}
+ */
+var containsNearbyAlmostDuplicate = function(nums, k, t) {
+  if (k < 1 || t < 0) {
+    return false
+  }
+  const array = new Map()
+  const num = 10 ** 10
+  for (let i = 0, iL = nums.length; i < iL; ++i) {
+    const noNegative = nums[i] + num
+    const factor = Math.floor(noNegative / (t + 1))
+    if (
+      array.has(factor) ||
+      (array.has(factor - 1) && noNegative - array.get(factor - 1) <= t) ||
+      (array.has(factor + 1) && array.get(factor + 1) - noNegative <= t)
+    ) {
+      return true
+    }
+    if (array.size >= k) {
+      array.delete(Math.floor((nums[i - k] + num) / (t + 1)))
+    }
+    array.set(factor, noNegative)
+  }
+  return false
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From c8adbf8a9d5ff255cb9f2223b3fb82e6739b6773 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Oct 2019 12:17:51 +0800
Subject: [PATCH 0051/3374] Update 220-contains-duplicate-iii.js

---
 220-contains-duplicate-iii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/220-contains-duplicate-iii.js b/220-contains-duplicate-iii.js
index 688979df..e0247c1c 100644
--- a/220-contains-duplicate-iii.js
+++ b/220-contains-duplicate-iii.js
@@ -4,7 +4,7 @@
  * @param {number} t
  * @return {boolean}
  */
-var containsNearbyAlmostDuplicate = function(nums, k, t) {
+const containsNearbyAlmostDuplicate = function(nums, k, t) {
   if (k < 1 || t < 0) {
     return false
   }

From 0ec931a11c781e09ea4b278a7c78da46a88398eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Oct 2019 16:01:11 +0800
Subject: [PATCH 0052/3374] Create 263-ugly-number.js

---
 263-ugly-number.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 263-ugly-number.js

diff --git a/263-ugly-number.js b/263-ugly-number.js
new file mode 100644
index 00000000..c518079d
--- /dev/null
+++ b/263-ugly-number.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+const isUgly = function(num) {
+  if (num < 1) return false
+  while (num >= 2) {
+    if (num % 2 === 0) num = num / 2
+    else if (num % 3 === 0) num = num / 3
+    else if (num % 5 === 0) num = num / 5
+    else return false
+  }
+  return true
+}

From 4ff414c48af1e77ae14e6e07771e5a447ec83e9c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Oct 2019 16:57:35 +0800
Subject: [PATCH 0053/3374] Create 264-ugly-number-ii.js

---
 264-ugly-number-ii.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 264-ugly-number-ii.js

diff --git a/264-ugly-number-ii.js b/264-ugly-number-ii.js
new file mode 100644
index 00000000..29ec9042
--- /dev/null
+++ b/264-ugly-number-ii.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const nthUglyNumber = function(n) {
+  if (n <= 0) return false
+  if (n == 1) return true
+  let t2 = 0,
+    t3 = 0,
+    t5 = 0
+  const k = Array(n).fill(0)
+  k[0] = 1
+  for (let i = 1; i < n; i++) {
+    k[i] = Math.min(k[t2] * 2, Math.min(k[t3] * 3, k[t5] * 5))
+    if (k[i] === k[t2] * 2) t2++
+    if (k[i] === k[t3] * 3) t3++
+    if (k[i] === k[t5] * 5) t5++
+  }
+  return k[n - 1]
+}

From db81484aae8f836b77174b498edd2a421e083f5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Oct 2019 17:22:31 +0800
Subject: [PATCH 0054/3374] Update 264-ugly-number-ii.js

---
 264-ugly-number-ii.js | 20 ++++++++------------
 1 file changed, 8 insertions(+), 12 deletions(-)

diff --git a/264-ugly-number-ii.js b/264-ugly-number-ii.js
index 29ec9042..b062b445 100644
--- a/264-ugly-number-ii.js
+++ b/264-ugly-number-ii.js
@@ -3,18 +3,14 @@
  * @return {number}
  */
 const nthUglyNumber = function(n) {
-  if (n <= 0) return false
-  if (n == 1) return true
-  let t2 = 0,
-    t3 = 0,
-    t5 = 0
-  const k = Array(n).fill(0)
-  k[0] = 1
+  const dp = [1]
+  let [a, b, c] = [0, 0, 0]
   for (let i = 1; i < n; i++) {
-    k[i] = Math.min(k[t2] * 2, Math.min(k[t3] * 3, k[t5] * 5))
-    if (k[i] === k[t2] * 2) t2++
-    if (k[i] === k[t3] * 3) t3++
-    if (k[i] === k[t5] * 5) t5++
+    let [ua, ub, uc] = [dp[a] * 2, dp[b] * 3, dp[c] * 5]
+    dp[i] = Math.min(ua, ub, uc)
+    if (dp[i] === ua) a++
+    if (dp[i] === ub) b++
+    if (dp[i] === uc) c++
   }
-  return k[n - 1]
+  return dp[n - 1]
 }

From eeb99da5f88f645e0d48835d21fcb1330aff0a10 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Oct 2019 20:55:54 +0800
Subject: [PATCH 0055/3374] Create 223-rectangle-area.js

---
 223-rectangle-area.js | 69 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 223-rectangle-area.js

diff --git a/223-rectangle-area.js b/223-rectangle-area.js
new file mode 100644
index 00000000..6c30c9d2
--- /dev/null
+++ b/223-rectangle-area.js
@@ -0,0 +1,69 @@
+/**
+ * @param {number} A
+ * @param {number} B
+ * @param {number} C
+ * @param {number} D
+ * @param {number} E
+ * @param {number} F
+ * @param {number} G
+ * @param {number} H
+ * @return {number}
+ */
+const computeArea = function(A, B, C, D, E, F, G, H) {
+  const areaA = (C - A) * (D - B)
+  const areaB = (G - E) * (H - F)
+  const intersectionArea =
+    Math.max(0, Math.min(C, G) - Math.max(A, E)) *
+    Math.max(0, Math.min(D, H) - Math.max(B, F))
+  return areaA + areaB - intersectionArea
+}
+
+
+// another
+
+
+/**
+ * @param {number} A
+ * @param {number} B
+ * @param {number} C
+ * @param {number} D
+ * @param {number} E
+ * @param {number} F
+ * @param {number} G
+ * @param {number} H
+ * @return {number}
+ */
+const computeArea = function(A, B, C, D, E, F, G, H) {
+  const x1 = A,
+    x2 = C,
+    x3 = E,
+    x4 = G
+  const y1 = B,
+    y2 = D,
+    y3 = F,
+    y4 = H
+  return (
+    area(x1, y1, x2, y2) +
+    area(x3, y3, x4, y4) -
+    delta(x1, x2, x3, x4) * delta(y1, y2, y3, y4)
+  )
+}
+
+function area(x1, y1, x2, y2) {
+  return Math.abs(x1 - x2) * Math.abs(y1 - y2)
+}
+
+function delta(v1, v2, v3, v4) {
+  if (v1 > v2) {
+    let tmp = v1
+    v1 = v2
+    v2 = tmp
+  }
+  if (v3 > v4) {
+    let tmp = v3
+    v3 = v4
+    v4 = tmp
+  }
+  if (v3 >= v2 || v4 <= v1) return 0
+  return Math.min(v2, v4) - Math.max(v1, v3)
+}

From fb50cb95998c5b329b732ae7fa4c093d2d1e1b57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 09:30:28 +0800
Subject: [PATCH 0056/3374] Create 224-basic-calculator.js

---
 224-basic-calculator.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 224-basic-calculator.js

diff --git a/224-basic-calculator.js b/224-basic-calculator.js
new file mode 100644
index 00000000..9705eb73
--- /dev/null
+++ b/224-basic-calculator.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  let stack = []
+  let num = 0
+  let sign = 1
+  let res = 0
+  for (let i = 0; i < s.length; i++) {
+    let char = s.charAt(i)
+    if (char >= '0' && char <= '9') {
+      num = num * 10 + parseInt(char, 10)
+    } else if (char === '+') {
+      res += sign * num
+      sign = 1
+      num = 0
+    } else if (char === '-') {
+      res += sign * num
+      sign = -1
+      num = 0
+    } else if (char === '(') {
+      stack.push(res)
+      stack.push(sign)
+      sign = 1
+      res = 0
+      num = 0
+    } else if (char === ')') {
+      res += sign * num
+      res *= stack.pop()
+      res += stack.pop()
+      num = 0
+    }
+  }
+  return res + sign * num
+}

From 993bb83078f8600ed27c4a5da0a305614d09881d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 12:06:43 +0800
Subject: [PATCH 0057/3374] Create 227-basic-calculator-ii.js

---
 227-basic-calculator-ii.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 227-basic-calculator-ii.js

diff --git a/227-basic-calculator-ii.js b/227-basic-calculator-ii.js
new file mode 100644
index 00000000..50184533
--- /dev/null
+++ b/227-basic-calculator-ii.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  if (s.length === 0) {
+    return 0
+  }
+  let op = '+'
+  let stack = []
+  for (let i = 0, n = 0; i <= s.length; ++i) {
+    let c = s.charAt(i)
+    if (c === ' ') continue
+    if (c >= '0' && c <= '9') {
+      n = n * 10 + parseInt(c)
+      continue
+    }
+    if (op === '+') {
+      stack.push(n)
+    } else if (op === '-') {
+      stack.push(-n)
+    } else if (op === '*') {
+      stack.push(stack.pop() * n)
+    } else if (op === '/') {
+      stack.push(Math.trunc(stack.pop() / n))
+    }
+    op = c
+    n = 0
+  }
+  return stack.reduce((n, acc) => n + acc, 0)
+}

From 63df4eadeb9c37de8818e79aa96c097669f97b08 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 15:13:35 +0800
Subject: [PATCH 0058/3374] Update 227-basic-calculator-ii.js

---
 227-basic-calculator-ii.js | 35 +++++++++++++++--------------------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/227-basic-calculator-ii.js b/227-basic-calculator-ii.js
index 50184533..575bb6be 100644
--- a/227-basic-calculator-ii.js
+++ b/227-basic-calculator-ii.js
@@ -3,29 +3,24 @@
  * @return {number}
  */
 const calculate = function(s) {
-  if (s.length === 0) {
-    return 0
-  }
+  if (!s || !s.length) return 0
+  let n = 0
   let op = '+'
-  let stack = []
-  for (let i = 0, n = 0; i <= s.length; ++i) {
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
     let c = s.charAt(i)
-    if (c === ' ') continue
-    if (c >= '0' && c <= '9') {
-      n = n * 10 + parseInt(c)
-      continue
+    let isNumber = '0' <= c && c <= '9'
+    if (isNumber) {
+      n = n * 10 + +c
     }
-    if (op === '+') {
-      stack.push(n)
-    } else if (op === '-') {
-      stack.push(-n)
-    } else if (op === '*') {
-      stack.push(stack.pop() * n)
-    } else if (op === '/') {
-      stack.push(Math.trunc(stack.pop() / n))
+    if ((!isNumber && c !== ' ') || i == s.length - 1) {
+      if (op === '+') stack.push(n)
+      else if (op === '-') stack.push(-n)
+      else if (op === '*') stack.push(stack.pop() * n)
+      else if (op === '/') stack.push(~~(stack.pop() / n))
+      op = c
+      n = 0
     }
-    op = c
-    n = 0
   }
-  return stack.reduce((n, acc) => n + acc, 0)
+  return stack.reduce((a, b) => a + b, 0)
 }

From e68bad275ad109f1ec1e780f1184b133544b8e94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 15:48:56 +0800
Subject: [PATCH 0059/3374] Create 228-summary-ranges.js

---
 228-summary-ranges.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 228-summary-ranges.js

diff --git a/228-summary-ranges.js b/228-summary-ranges.js
new file mode 100644
index 00000000..1cf56bf4
--- /dev/null
+++ b/228-summary-ranges.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {string[]}
+ */
+const summaryRanges = function(nums) {
+  if (nums == null || nums.length === 0) return []
+  const res = []
+  if (nums.length === 1) return [`${nums[0]}`]
+  let start = nums[0]
+  let end = nums[0]
+  let endVal = end
+  for (let i = 1, len = nums.length; i < len; i++) {
+    let cur = nums[i]
+    if (cur - end > 1) {
+      endVal = end
+      insert(res, start, end)
+      start = cur
+      end = cur
+    } else {
+      end = cur
+    }
+  }
+  if (endVal !== end) {
+    insert(res, start, end)
+  }
+  return res
+}
+
+function insert(arr, start, end) {
+  if (start === end) {
+    arr.push(`${start}`)
+  } else {
+    arr.push(`${start}->${end}`)
+  }
+}

From 62e97800f8da5fa0b8f01c672447b4637aed849e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 16:11:55 +0800
Subject: [PATCH 0060/3374] Update 228-summary-ranges.js

---
 228-summary-ranges.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/228-summary-ranges.js b/228-summary-ranges.js
index 1cf56bf4..eb708bde 100644
--- a/228-summary-ranges.js
+++ b/228-summary-ranges.js
@@ -33,3 +33,25 @@ function insert(arr, start, end) {
     arr.push(`${start}->${end}`)
   }
 }
+
+// another
+
+const summaryRanges = nums => {
+  if (!nums || nums.length === 0) {
+    return [];
+  }
+  const returnArray = [];
+  let tempIdx = 0;
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] + 1 !== nums[i + 1]) {
+      if (tempIdx === i) {
+        returnArray.push(nums[tempIdx].toString());
+      } else {
+        returnArray.push(nums[tempIdx].toString() + "->" + nums[i].toString());
+      }
+      tempIdx = i + 1;
+    }
+  }
+
+  return returnArray;
+};

From 5d20db85bbbe40d53dc9d3989b47684f82ee2ecc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 16:50:23 +0800
Subject: [PATCH 0061/3374] Create 273-integer-to-english-words.js

---
 273-integer-to-english-words.js | 70 +++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 273-integer-to-english-words.js

diff --git a/273-integer-to-english-words.js b/273-integer-to-english-words.js
new file mode 100644
index 00000000..254cc697
--- /dev/null
+++ b/273-integer-to-english-words.js
@@ -0,0 +1,70 @@
+const LESS_THAN_20 = [
+  "",
+  "One",
+  "Two",
+  "Three",
+  "Four",
+  "Five",
+  "Six",
+  "Seven",
+  "Eight",
+  "Nine",
+  "Ten",
+  "Eleven",
+  "Twelve",
+  "Thirteen",
+  "Fourteen",
+  "Fifteen",
+  "Sixteen",
+  "Seventeen",
+  "Eighteen",
+  "Nineteen"
+];
+const TENS = [
+  "",
+  "Ten",
+  "Twenty",
+  "Thirty",
+  "Forty",
+  "Fifty",
+  "Sixty",
+  "Seventy",
+  "Eighty",
+  "Ninety"
+];
+const THOUSANDS = ["", "Thousand", "Million", "Billion"];
+const RADIXS = [1, 10 ** 3, 10 ** 6, 10 ** 9];
+
+/**
+ * @param {number} num
+ * @return {string}
+ */
+const numberToWords = function(num) {
+  if (num === 0) {
+    return "Zero";
+  }
+
+  let res = "";
+  for (let i = RADIXS.length - 1; i >= 0; i--) {
+    if (~~(num / RADIXS[i]) === 0) {
+      continue;
+    }
+
+    res += transform(~~(num / RADIXS[i])) + THOUSANDS[i] + " ";
+    num %= RADIXS[i];
+  }
+
+  return res.trim();
+};
+
+const transform = num => {
+  if (num === 0) {
+    return "";
+  } else if (num < 20) {
+    return LESS_THAN_20[num] + " ";
+  } else if (num < 100) {
+    return TENS[~~(num / 10)] + " " + transform(num % 10);
+  } else {
+    return LESS_THAN_20[~~(num / 100)] + " Hundred " + transform(num % 100);
+  }
+};

From f337430b69ac9857bf1d4c31f52d3a0ef264a2c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Oct 2019 16:54:23 +0800
Subject: [PATCH 0062/3374] Update 273-integer-to-english-words.js

---
 273-integer-to-english-words.js | 107 ++++++++++++++------------------
 1 file changed, 48 insertions(+), 59 deletions(-)

diff --git a/273-integer-to-english-words.js b/273-integer-to-english-words.js
index 254cc697..caa497c7 100644
--- a/273-integer-to-english-words.js
+++ b/273-integer-to-english-words.js
@@ -1,70 +1,59 @@
-const LESS_THAN_20 = [
-  "",
-  "One",
-  "Two",
-  "Three",
-  "Four",
-  "Five",
-  "Six",
-  "Seven",
-  "Eight",
-  "Nine",
-  "Ten",
-  "Eleven",
-  "Twelve",
-  "Thirteen",
-  "Fourteen",
-  "Fifteen",
-  "Sixteen",
-  "Seventeen",
-  "Eighteen",
-  "Nineteen"
-];
-const TENS = [
-  "",
-  "Ten",
-  "Twenty",
-  "Thirty",
-  "Forty",
-  "Fifty",
-  "Sixty",
-  "Seventy",
-  "Eighty",
-  "Ninety"
-];
-const THOUSANDS = ["", "Thousand", "Million", "Billion"];
-const RADIXS = [1, 10 ** 3, 10 ** 6, 10 ** 9];
-
 /**
  * @param {number} num
  * @return {string}
  */
 const numberToWords = function(num) {
-  if (num === 0) {
-    return "Zero";
-  }
+  if (num === 0) return "Zero";
+  if (num <= 20) return translations.get(num);
+  const result = [];
 
-  let res = "";
-  for (let i = RADIXS.length - 1; i >= 0; i--) {
-    if (~~(num / RADIXS[i]) === 0) {
+  for (let [value, translation] of translations) {
+    const times = Math.floor(num / value);
+    if (times === 0) continue;
+    num -= times * value;
+    if (times === 1 && value >= 100) {
+      result.push("One", translation);
       continue;
     }
-
-    res += transform(~~(num / RADIXS[i])) + THOUSANDS[i] + " ";
-    num %= RADIXS[i];
+    if (times === 1) {
+      result.push(translation);
+      continue;
+    }
+    result.push(numberToWords(times), translation);
   }
-
-  return res.trim();
+  return result.join(" ");
 };
 
-const transform = num => {
-  if (num === 0) {
-    return "";
-  } else if (num < 20) {
-    return LESS_THAN_20[num] + " ";
-  } else if (num < 100) {
-    return TENS[~~(num / 10)] + " " + transform(num % 10);
-  } else {
-    return LESS_THAN_20[~~(num / 100)] + " Hundred " + transform(num % 100);
-  }
-};
+const translations = new Map([
+  [1000000000, "Billion"],
+  [1000000, "Million"],
+  [1000, "Thousand"],
+  [100, "Hundred"],
+  [90, "Ninety"],
+  [80, "Eighty"],
+  [70, "Seventy"],
+  [60, "Sixty"],
+  [50, "Fifty"],
+  [40, "Forty"],
+  [30, "Thirty"],
+  [20, "Twenty"],
+  [19, "Nineteen"],
+  [18, "Eighteen"],
+  [17, "Seventeen"],
+  [16, "Sixteen"],
+  [15, "Fifteen"],
+  [14, "Fourteen"],
+  [13, "Thirteen"],
+  [12, "Twelve"],
+  [11, "Eleven"],
+  [10, "Ten"],
+  [9, "Nine"],
+  [8, "Eight"],
+  [7, "Seven"],
+  [6, "Six"],
+  [5, "Five"],
+  [4, "Four"],
+  [3, "Three"],
+  [2, "Two"],
+  [1, "One"]
+]);

From 9aa25210de14c191cab26c799faabc8f900d1df2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Oct 2019 21:26:36 +0800
Subject: [PATCH 0063/3374] Create 337-house-robber-iii.js

---
 337-house-robber-iii.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 337-house-robber-iii.js

diff --git a/337-house-robber-iii.js b/337-house-robber-iii.js
new file mode 100644
index 00000000..a1417bf8
--- /dev/null
+++ b/337-house-robber-iii.js
@@ -0,0 +1,24 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const rob = function(root) {
+  return Math.max(...dfs(root))
+}
+
+function dfs(node) {
+  if (node == null) return [0, 0]
+  const left = dfs(node.left)
+  const right = dfs(node.right)
+  return [
+    node.val + left[1] + right[1],
+    Math.max(left[0], left[1]) + Math.max(right[0], right[1])
+  ]
+}

From c53ef71470b08e77704bd02af9bb0b08d9660712 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Oct 2019 21:16:05 +0800
Subject: [PATCH 0064/3374] Create 506-relative-ranks.js

---
 506-relative-ranks.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 506-relative-ranks.js

diff --git a/506-relative-ranks.js b/506-relative-ranks.js
new file mode 100644
index 00000000..a89e02a4
--- /dev/null
+++ b/506-relative-ranks.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {string[]}
+ */
+const findRelativeRanks = function(nums) {
+  const numIndexMapping = {}
+  for (let index = 0; index < nums.length; ++index) {
+    numIndexMapping[nums[index]] = index
+  }
+  let rank = nums.length
+  for (let num in numIndexMapping) {
+    const index = numIndexMapping[num]
+    if (3 < rank) {
+      nums[index] = '' + rank
+    } else if (3 == rank) {
+      nums[index] = 'Bronze Medal'
+    } else if (2 == rank) {
+      nums[index] = 'Silver Medal'
+    } else {
+      nums[index] = 'Gold Medal'
+    }
+    --rank
+  }
+
+  return nums
+}

From 033f7743ad7df05141c991511c1cd1ef18b5ed34 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 26 Oct 2019 13:47:02 +0800
Subject: [PATCH 0065/3374] Create 454-4sum-ii.js

---
 454-4sum-ii.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 454-4sum-ii.js

diff --git a/454-4sum-ii.js b/454-4sum-ii.js
new file mode 100644
index 00000000..708ea7c0
--- /dev/null
+++ b/454-4sum-ii.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} A
+ * @param {number[]} B
+ * @param {number[]} C
+ * @param {number[]} D
+ * @return {number}
+ */
+const fourSumCount = function(A, B, C, D) {
+  const map = new Map()
+  let res = 0
+  for (let i = 0, clen = C.length; i < clen; i++) {
+    for (let j = 0, dlen = D.length; j < dlen; j++) {
+      map.set(
+        C[i] + D[j],
+        typeof map.get(C[i] + D[j]) == 'undefined'
+          ? 1
+          : map.get(C[i] + D[j]) + 1
+      )
+    }
+  }
+  for (let i = 0, alen = A.length; i < alen; i++) {
+    for (let j = 0, blen = B.length; j < blen; j++) {
+      res +=
+        typeof map.get((A[i] + B[j]) * -1) == 'undefined'
+          ? 0
+          : map.get((A[i] + B[j]) * -1)
+    }
+  }
+  return res
+}

From 30d25726854f2dbf897a3b4b706299b8ff8d94cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 12:03:48 +0800
Subject: [PATCH 0066/3374] Create 504-base-7.js

---
 504-base-7.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 504-base-7.js

diff --git a/504-base-7.js b/504-base-7.js
new file mode 100644
index 00000000..b257ac32
--- /dev/null
+++ b/504-base-7.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} num
+ * @return {string}
+ */
+const convertToBase7 = function(num) {
+  if(num == null) return ''
+  const sign = num >= 0 ? '+' : '-'
+  let res = ''
+  let remain = Math.abs(num)
+  if(num === 0) return '' + num
+  while(remain > 0) {
+    let tmp = remain % 7
+    res = tmp + res
+    remain = Math.floor(remain / 7)
+  }
+  
+  return sign === '+' ? res : '-' + res
+};

From 8f4903e22cb3788d474f11b1c14cedfeac3e9486 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 12:06:08 +0800
Subject: [PATCH 0067/3374] Update 504-base-7.js

---
 504-base-7.js | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/504-base-7.js b/504-base-7.js
index b257ac32..56cc8352 100644
--- a/504-base-7.js
+++ b/504-base-7.js
@@ -7,12 +7,17 @@ const convertToBase7 = function(num) {
   const sign = num >= 0 ? '+' : '-'
   let res = ''
   let remain = Math.abs(num)
-  if(num === 0) return '' + num
+  if(num === 0) return '0'
   while(remain > 0) {
-    let tmp = remain % 7
-    res = tmp + res
+    res = remain % 7 + res
     remain = Math.floor(remain / 7)
   }
   
   return sign === '+' ? res : '-' + res
 };
+
+// another
+
+const convertToBase7 = function(num) {
+  return num.toString(7)
+};

From 7d5d1f7bb3381520a4df64aa330c55e00ee40cc1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 13:04:42 +0800
Subject: [PATCH 0068/3374] Create 274-h-index.js

---
 274-h-index.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 274-h-index.js

diff --git a/274-h-index.js b/274-h-index.js
new file mode 100644
index 00000000..f2ee3c06
--- /dev/null
+++ b/274-h-index.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} citations
+ * @return {number}
+ */
+const hIndex = function(citations) {
+  citations = citations.sort((a, b) => b - a)
+
+  for (let i = 0, len = citations.length; i < len; i++) {
+    if (i >= citations[i]) return i
+  }
+
+  return citations.length
+}

From 99e05e6653b96826dec68217d1fd1352def7f186 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 13:27:17 +0800
Subject: [PATCH 0069/3374] Update 274-h-index.js

---
 274-h-index.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/274-h-index.js b/274-h-index.js
index f2ee3c06..0a6ce359 100644
--- a/274-h-index.js
+++ b/274-h-index.js
@@ -11,3 +11,18 @@ const hIndex = function(citations) {
 
   return citations.length
 }
+
+// another
+
+
+const hIndex = function(citations) {
+  const buckets = Array(citations.length + 1).fill(0)
+  citations.forEach(citation => {
+    buckets[citation >= citations.length ? citations.length : citation]++
+  })
+  for (let i = citations.length, count = 0; i >= 0; i--) {
+    count += buckets[i]
+    if (count >= i) return i
+  }
+  return 0
+}

From ea19f05b554b4b2ec9ff646773250a4ef397ee16 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 16:43:57 +0800
Subject: [PATCH 0070/3374] Create 316-remove-duplicate-letters.js

---
 316-remove-duplicate-letters.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 316-remove-duplicate-letters.js

diff --git a/316-remove-duplicate-letters.js b/316-remove-duplicate-letters.js
new file mode 100644
index 00000000..21fe3762
--- /dev/null
+++ b/316-remove-duplicate-letters.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const removeDuplicateLetters = function(s) {
+  const m = new Array(26)
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0; i < s.length; i++) {
+    const k = s.charCodeAt(i) - a
+    m[k] = m[k] ? m[k] + 1 : 1
+  }
+  const aChNo = []
+  const visited = {}
+  for (let i = 0; i < s.length; i++) {
+    const k = s.charCodeAt(i) - a
+    m[k]--
+    if (visited[k]) continue
+    while (aChNo.length > 0) {
+      const last = aChNo[aChNo.length - 1] - a
+      if (last > k && m[last] > 0) {
+        visited[last] = 0
+        aChNo.pop()
+      } else break
+    }
+    visited[k] = 1
+    aChNo.push(k + a)
+  }
+  return String.fromCharCode(...aChNo)
+}

From 3e0f5fb793fce9799f3954114a808f122162c517 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 16:46:10 +0800
Subject: [PATCH 0071/3374] Update 316-remove-duplicate-letters.js

---
 316-remove-duplicate-letters.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/316-remove-duplicate-letters.js b/316-remove-duplicate-letters.js
index 21fe3762..e06503f9 100644
--- a/316-remove-duplicate-letters.js
+++ b/316-remove-duplicate-letters.js
@@ -1,3 +1,28 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const removeDuplicateLetters = function(s) {
+  const last = {}
+  for (let i = 0; i < s.length; i++) last[s.charAt(i)] = i
+  const added = {}
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
+    const char = s.charAt(i)
+    if (added[char]) continue
+    while (stack.length && char < stack[0] && last[stack[0]] > i) {
+      added[stack[0]] = false
+      stack.shift()
+    }
+    stack.unshift(char)
+    added[char] = true
+  }
+  return stack.reverse().join('')
+}
+
+// another
+
+
 /**
  * @param {string} s
  * @return {string}

From b228fe116342958c4a6d5363a99270e65b8ee05a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 17:10:53 +0800
Subject: [PATCH 0072/3374] Create 327-count-of-range-sum.js

---
 327-count-of-range-sum.js | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 327-count-of-range-sum.js

diff --git a/327-count-of-range-sum.js b/327-count-of-range-sum.js
new file mode 100644
index 00000000..c5e9be1d
--- /dev/null
+++ b/327-count-of-range-sum.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+const countRangeSum = function(nums, lower, upper) {
+  if (nums.length === 0) return 0
+  const sums = [nums[0]]
+  for (let i = 1; i < nums.length; i++) {
+    sums[i] = sums[i - 1] + nums[i]
+  }
+  function merge_sort(A, lo, hi) {
+    if (hi - lo === 1) {
+      return sums[lo] >= lower && sums[lo] <= upper ? 1 : 0
+    }
+    const mid = Math.floor((lo + hi) / 2)
+    let counter = merge_sort(A, lo, mid) + merge_sort(A, mid, hi)
+    let m = mid,
+      n = mid
+    for (let i = lo; i < mid; i++) {
+      while (m !== hi && sums[m] - sums[i] < lower) {
+        m++
+      }
+      while (n !== hi && sums[n] - sums[i] <= upper) {
+        n++
+      }
+      counter += n - m
+    }
+    const M = A.slice(lo, mid)
+    const N = A.slice(mid, hi)
+    M.push(Number.MAX_SAFE_INTEGER)
+    N.push(Number.MAX_SAFE_INTEGER)
+    for (let k = lo, i = 0, j = 0; k < hi; k++) {
+      A[k] = M[i] < N[j] ? M[i++] : N[j++]
+    }
+    return counter
+  }
+  return merge_sort(sums, 0, nums.length)
+}

From b37611db014c20fadd0ce53f068d217f653a4c25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 17:21:49 +0800
Subject: [PATCH 0073/3374] Create 326-power-of-three.js

---
 326-power-of-three.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 326-power-of-three.js

diff --git a/326-power-of-three.js b/326-power-of-three.js
new file mode 100644
index 00000000..6657894b
--- /dev/null
+++ b/326-power-of-three.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isPowerOfThree = function(n) {
+  const maxInt = Math.pow(3,30)
+  if(n < 0) {
+    return false
+  }
+  return maxInt % n === 0
+} 
+
+// another
+
+const isPowerOfThree = function(n) {
+  if (n == 1) return true
+  if (n === 0) return false
+  if (n % 3 !== 0) return false
+  if (n == 3) return true
+  return isPowerOfThree(n / 3)
+}
+
+// another
+
+const isPowerOfThree = function(n) {
+  if(n == null || n === 0) return false
+  let num = 1
+  while(num < n) {
+    num *= 3
+  }  
+  return num > n ? false : true
+}

From 9ab8fe6a3998b4b81c9d029033bcc5cd42206b8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 17:44:04 +0800
Subject: [PATCH 0074/3374] Create 345-reverse-vowels-of-a-string.js

---
 345-reverse-vowels-of-a-string.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 345-reverse-vowels-of-a-string.js

diff --git a/345-reverse-vowels-of-a-string.js b/345-reverse-vowels-of-a-string.js
new file mode 100644
index 00000000..e1aad50c
--- /dev/null
+++ b/345-reverse-vowels-of-a-string.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const reverseVowels = function(s) {
+  if(s == null || s === '') return ''
+  const arr = s.split('')
+  let p = 0
+  const len = s.length
+  let e = s.length - 1
+  const v = ['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U']
+  while(p < e) {
+    while(v.indexOf(arr[p]) === -1 && p < e) p++
+    while(v.indexOf(arr[e]) === -1 && p < e) e--
+    const tmp = arr[p]
+    arr[p] = arr[e]
+    arr[e] = tmp          
+    p++
+    e--
+  }
+  return arr.join('')
+};

From dff7c03584a03eb4af1731250d36d6f9fdc776ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2019 17:46:58 +0800
Subject: [PATCH 0075/3374] Update 345-reverse-vowels-of-a-string.js

---
 345-reverse-vowels-of-a-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/345-reverse-vowels-of-a-string.js b/345-reverse-vowels-of-a-string.js
index e1aad50c..f0702f84 100644
--- a/345-reverse-vowels-of-a-string.js
+++ b/345-reverse-vowels-of-a-string.js
@@ -20,3 +20,17 @@ const reverseVowels = function(s) {
   }
   return arr.join('')
 };
+
+
+// another
+
+const reverseVowels = function(s) {
+  let vowels = s.match(/[aeiou]/gi)
+  let k = 0
+  if (vowels) {
+    vowels = vowels.reverse``
+  } else {
+    return s
+  }
+  return s.replace(/[aeiou]/gi, () => vowels[k++])
+}

From 25bd255b9197361121d45203eec06f09a028e34b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Oct 2019 21:15:58 +0800
Subject: [PATCH 0076/3374] Create 498-diagonal-traverse.js

---
 498-diagonal-traverse.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 498-diagonal-traverse.js

diff --git a/498-diagonal-traverse.js b/498-diagonal-traverse.js
new file mode 100644
index 00000000..e21f0357
--- /dev/null
+++ b/498-diagonal-traverse.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+const findDiagonalOrder = function(matrix) {
+  if (!matrix.length || !matrix[0].length) {
+    return []
+  }
+  const m = matrix.length
+  const n = matrix[0].length
+  const output = []
+  for (let sum = 0; sum <= m + n - 2; sum++) {
+    for (
+      let i = Math.min(m - 1, sum);
+      sum % 2 === 0 && isValid(i, sum - i, m, n);
+      i--
+    ) {
+      const j = sum - i
+      output.push(matrix[i][j])
+    }
+    for (
+      let j = Math.min(n - 1, sum);
+      sum % 2 === 1 && isValid(sum - j, j, m, n);
+      j--
+    ) {
+      const i = sum - j
+      output.push(matrix[i][j])
+    }
+  }
+  return output
+}
+
+function isValid(i, j, m, n) {
+  if (i < 0 || i >= m || j < 0 || j >= n) {
+    return false
+  }
+  return true
+}

From 4fe11790412ec9adf1ce16dd7cb27674b97e1294 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Oct 2019 21:33:23 +0800
Subject: [PATCH 0077/3374] Update 498-diagonal-traverse.js

---
 498-diagonal-traverse.js | 43 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/498-diagonal-traverse.js b/498-diagonal-traverse.js
index e21f0357..214b065b 100644
--- a/498-diagonal-traverse.js
+++ b/498-diagonal-traverse.js
@@ -36,3 +36,46 @@ function isValid(i, j, m, n) {
   }
   return true
 }
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+const findDiagonalOrder = function(matrix) {
+  if (matrix.length == 0) return []
+  let r = 0,
+    c = 0,
+    m = matrix.length,
+    n = matrix[0].length,
+    arr = new Array(m * n)
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = matrix[r][c]
+    if ((r + c) % 2 === 0) {
+      // moving up
+      if (c === n - 1) {
+        r++
+      } else if (r === 0) {
+        c++
+      } else {
+        r--
+        c++
+      }
+    } else {
+      // moving down
+      if (r === m - 1) {
+        c++
+      } else if (c === 0) {
+        r++
+      } else {
+        r++
+        c--
+      }
+    }
+  }
+  return arr
+}
+
+
+

From 65e72135709f7096b4b6c9597f3fa37f86ece612 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Oct 2019 15:30:09 +0800
Subject: [PATCH 0078/3374] Create 282-expression-add-operators.js

---
 282-expression-add-operators.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 282-expression-add-operators.js

diff --git a/282-expression-add-operators.js b/282-expression-add-operators.js
new file mode 100644
index 00000000..e6c1cc2a
--- /dev/null
+++ b/282-expression-add-operators.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} num
+ * @param {number} target
+ * @return {string[]}
+ */
+const addOperators = function(num, target) {
+  let res = [];
+  let n = num.length;
+  function recursive(k, str, add, mul, last) {
+    let sum = add + mul * last;
+    if (k === n) {
+      if (sum === target) {
+        res.push(str);
+      }
+      return;
+    }
+    let x = num[k] - "0";
+    if (last !== 0) {
+      recursive(k + 1, str + num[k], add, mul, last * 10 + x);
+    }
+    recursive(k + 1, str + "*" + num[k], add, mul * last, x);
+    recursive(k + 1, str + "+" + num[k], sum, 1, x);
+    recursive(k + 1, str + "-" + num[k], sum, -1, x);
+  }
+  if (n) recursive(1, num[0], 0, 1, num[0] - "0");
+  return res;
+};

From efe57e2d5fb48ce68fc3afeec9eb96f9a443c66f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Oct 2019 09:16:13 +0800
Subject: [PATCH 0079/3374] Create 289-game-of-life.js

---
 289-game-of-life.js | 57 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 289-game-of-life.js

diff --git a/289-game-of-life.js b/289-game-of-life.js
new file mode 100644
index 00000000..e7bfdd90
--- /dev/null
+++ b/289-game-of-life.js
@@ -0,0 +1,57 @@
+const isValid = (arr, row, col) => {
+  const isRow = row >= 0 && row < arr.length;
+  const isCol = isRow && col >= 0 && col < arr[row].length;
+  return isRow && isCol;
+};
+
+const moves = [
+  [-1, -1],
+  [-1, 0],
+  [-1, 1],
+  [0, -1],
+  [0, 1],
+  [1, 1],
+  [1, 0],
+  [1, -1]
+];
+
+const num = (arr, row, col, val) => {
+  let count = 0;
+  moves.forEach(move => {
+    const r = row + move[0];
+    const c = col + move[1];
+    if (isValid(arr, r, c) && arr[r][c] === val) {
+      count++;
+    }
+  });
+  return count;
+};
+
+/**
+ * @param {number[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+const gameOfLife = function(board) {
+  const newArr = Array(board.length)
+    .fill(null)
+    .map(() => Array(board[0].length).fill(0));
+  for (let row = 0; row < board.length; row++) {
+    for (let col = 0; col < board[row].length; col++) {
+      const ones = num(board, row, col, 1);
+
+      newArr[row][col] = board[row][col];
+      if (board[row][col] === 1) {
+        if (ones < 2 || ones > 3) {
+          newArr[row][col] = 0;
+        }
+      } else if (ones === 3) {
+        newArr[row][col] = 1;
+      }
+    }
+  }
+  for (let row = 0; row < board.length; row++) {
+    for (let col = 0; col < board[row].length; col++) {
+      board[row][col] = newArr[row][col];
+    }
+  }
+};

From 16540ccc36539b9c6fe418bccc63a6eed3d988d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Oct 2019 10:26:17 +0800
Subject: [PATCH 0080/3374] Update 289-game-of-life.js

---
 289-game-of-life.js | 87 ++++++++++++++++++++++-----------------------
 1 file changed, 43 insertions(+), 44 deletions(-)

diff --git a/289-game-of-life.js b/289-game-of-life.js
index e7bfdd90..1af3d028 100644
--- a/289-game-of-life.js
+++ b/289-game-of-life.js
@@ -1,57 +1,56 @@
-const isValid = (arr, row, col) => {
-  const isRow = row >= 0 && row < arr.length;
-  const isCol = isRow && col >= 0 && col < arr[row].length;
-  return isRow && isCol;
-};
-
-const moves = [
-  [-1, -1],
-  [-1, 0],
-  [-1, 1],
-  [0, -1],
-  [0, 1],
-  [1, 1],
-  [1, 0],
-  [1, -1]
-];
-
-const num = (arr, row, col, val) => {
-  let count = 0;
-  moves.forEach(move => {
-    const r = row + move[0];
-    const c = col + move[1];
-    if (isValid(arr, r, c) && arr[r][c] === val) {
-      count++;
-    }
-  });
-  return count;
-};
-
 /**
  * @param {number[][]} board
  * @return {void} Do not return anything, modify board in-place instead.
  */
 const gameOfLife = function(board) {
-  const newArr = Array(board.length)
-    .fill(null)
-    .map(() => Array(board[0].length).fill(0));
-  for (let row = 0; row < board.length; row++) {
-    for (let col = 0; col < board[row].length; col++) {
-      const ones = num(board, row, col, 1);
+  const DIRECTIONS = [
+    [1, 0],
+    [1, 1],
+    [0, 1],
+    [-1, 1],
+    [-1, 0],
+    [-1, -1],
+    [0, -1],
+    [1, -1]
+  ];
 
-      newArr[row][col] = board[row][col];
-      if (board[row][col] === 1) {
-        if (ones < 2 || ones > 3) {
-          newArr[row][col] = 0;
-        }
-      } else if (ones === 3) {
-        newArr[row][col] = 1;
+  const isValid = function(x, y) {
+    if (x >= 0 && y >= 0 && x < board.length && y < board[0].length)
+      return true;
+    else return false;
+  };
+
+  const getAliveNeighbors = function(x, y) {
+    let aliveNeighs = 0;
+    for (let dir of DIRECTIONS) {
+      let newX = x + dir[0];
+      let newY = y + dir[1];
+      if (!isValid(newX, newY)) continue;
+      if (board[newX][newY] === 1 || board[newX][newY] === -1) {
+        aliveNeighs++;
+      }
+    }
+
+    return aliveNeighs;
+  };
+
+  for (let row = 0; row < board.length; row++) {
+    for (let col = 0; col < board[0].length; col++) {
+      let aliveNeighbors = getAliveNeighbors(row, col);
+      if (board[row][col] === 0) {
+        if (aliveNeighbors === 3) board[row][col] = 2;
+        else board[row][col] = 0;
+      } else {
+        if (aliveNeighbors === 2 || aliveNeighbors === 3) board[row][col] = 1;
+        else board[row][col] = -1;
       }
     }
   }
+
   for (let row = 0; row < board.length; row++) {
-    for (let col = 0; col < board[row].length; col++) {
-      board[row][col] = newArr[row][col];
+    for (let col = 0; col < board[0].length; col++) {
+      if (board[row][col] > 0) board[row][col] = 1;
+      else board[row][col] = 0;
     }
   }
 };

From ddf56cbcd6d3609b1f345a57131eb86a66e52a14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2019 21:27:06 +0800
Subject: [PATCH 0081/3374] Create 386-lexicographical-numbers.js

---
 386-lexicographical-numbers.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 386-lexicographical-numbers.js

diff --git a/386-lexicographical-numbers.js b/386-lexicographical-numbers.js
new file mode 100644
index 00000000..ae47991a
--- /dev/null
+++ b/386-lexicographical-numbers.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const lexicalOrder = function(n) {
+  let res = []
+  for (let i = 1; i < 10; ++i) {
+    if (!dfs(i, res, n)) {
+      break
+    }
+  }
+  return res
+}
+
+function dfs(num, res, n) {
+  if (num > n) {
+    return false
+  }
+  res.push(num)
+  for (let i = 0; i < 10; ++i) {
+    if (!dfs(num * 10 + i, res, n)) {
+      break
+    }
+  }
+  return true
+}

From f5a83f5003ff7e0130173b74e3a9d9e13e4dc1f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2019 21:32:07 +0800
Subject: [PATCH 0082/3374] Update 386-lexicographical-numbers.js

---
 386-lexicographical-numbers.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/386-lexicographical-numbers.js b/386-lexicographical-numbers.js
index ae47991a..8accbe77 100644
--- a/386-lexicographical-numbers.js
+++ b/386-lexicographical-numbers.js
@@ -24,3 +24,20 @@ function dfs(num, res, n) {
   }
   return true
 }
+
+// another
+
+const lexicalOrder = function(n) {
+  function getNumberByOrder(start, end) {
+    for (var i = start; i <= end; i++) {
+      if (i > n) {
+        break
+      }
+      res.push(i)
+      getNumberByOrder(i * 10, i * 10 + 9)
+    }
+  }
+  var res = []
+  getNumberByOrder(1, 9)
+  return res
+}

From da33fdc2c2352d0fb61a8468f3bba75411c21b32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2019 21:32:26 +0800
Subject: [PATCH 0083/3374] Update 386-lexicographical-numbers.js

---
 386-lexicographical-numbers.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/386-lexicographical-numbers.js b/386-lexicographical-numbers.js
index 8accbe77..609fb464 100644
--- a/386-lexicographical-numbers.js
+++ b/386-lexicographical-numbers.js
@@ -29,7 +29,7 @@ function dfs(num, res, n) {
 
 const lexicalOrder = function(n) {
   function getNumberByOrder(start, end) {
-    for (var i = start; i <= end; i++) {
+    for (let i = start; i <= end; i++) {
       if (i > n) {
         break
       }
@@ -37,7 +37,7 @@ const lexicalOrder = function(n) {
       getNumberByOrder(i * 10, i * 10 + 9)
     }
   }
-  var res = []
+  const res = []
   getNumberByOrder(1, 9)
   return res
 }

From 337a6380bbaf9919dac14f0f773bac1e35fa20b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2019 21:56:07 +0800
Subject: [PATCH 0084/3374] Update 386-lexicographical-numbers.js

---
 386-lexicographical-numbers.js | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/386-lexicographical-numbers.js b/386-lexicographical-numbers.js
index 609fb464..cd11275b 100644
--- a/386-lexicographical-numbers.js
+++ b/386-lexicographical-numbers.js
@@ -3,26 +3,19 @@
  * @return {number[]}
  */
 const lexicalOrder = function(n) {
-  let res = []
-  for (let i = 1; i < 10; ++i) {
-    if (!dfs(i, res, n)) {
-      break
-    }
-  }
-  return res
-}
-
-function dfs(num, res, n) {
-  if (num > n) {
-    return false
+  const result = []
+  for (let i = 1; i < 10; i++) {
+    dfs(i)
   }
-  res.push(num)
-  for (let i = 0; i < 10; ++i) {
-    if (!dfs(num * 10 + i, res, n)) {
-      break
+  function dfs(n) {
+    if (n <= num) result.push(n)
+    if (10 * n <= num) {
+      for (let j = 0; j < 10; j++) {
+        dfs(10 * n + j)
+      }
     }
   }
-  return true
+  return result
 }
 
 // another

From f5d6991f11ba9dccf25e644a064f4cf89311b848 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Nov 2019 19:48:37 +0800
Subject: [PATCH 0085/3374] Create
 524-longest-word-in-dictionary-through-deleting.js

---
 ...est-word-in-dictionary-through-deleting.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 524-longest-word-in-dictionary-through-deleting.js

diff --git a/524-longest-word-in-dictionary-through-deleting.js b/524-longest-word-in-dictionary-through-deleting.js
new file mode 100644
index 00000000..4e52aeaf
--- /dev/null
+++ b/524-longest-word-in-dictionary-through-deleting.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string[]} d
+ * @return {string}
+ */
+const findLongestWord = function(s, d) {
+  let results = [];
+  let maxLen = 0;
+  for (const word of d) {
+    let j = 0;
+    for (let i = 0; i < s.length; i++) {
+      if (s[i] === word[j]) {
+        j++;
+        if (j === word.length) break;
+      }
+    }
+    if (j === word.length && word.length >= maxLen) {
+      if (word.length > maxLen) {
+        maxLen = word.length;
+        results = [];
+      }
+      results.push(word);
+    }
+  }
+  
+  let result = results[0];
+  for (let i = 1; i < results.length; i++) {
+    if (results[i] < result) result = results[i];
+  }
+  return result || '';
+}

From f5fc857304581ebce5f1a3bede750104c74cb701 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Nov 2019 21:17:03 +0800
Subject: [PATCH 0086/3374] Create 492-construct-the-rectangle.js

---
 492-construct-the-rectangle.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 492-construct-the-rectangle.js

diff --git a/492-construct-the-rectangle.js b/492-construct-the-rectangle.js
new file mode 100644
index 00000000..59e6e663
--- /dev/null
+++ b/492-construct-the-rectangle.js
@@ -0,0 +1,9 @@
+/**
+ * @param {number} area
+ * @return {number[]}
+ */
+const constructRectangle = function(area) {
+  let w = Math.sqrt(area) >> 0;
+  while (area % w != 0) w--;
+  return [(area / w) >> 0, w];
+};

From d16ff97a3defb304e0f9142f5b4384c359478b73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Nov 2019 10:57:25 +0800
Subject: [PATCH 0087/3374] Create 404-sum-of-left-leaves.js

---
 404-sum-of-left-leaves.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 404-sum-of-left-leaves.js

diff --git a/404-sum-of-left-leaves.js b/404-sum-of-left-leaves.js
new file mode 100644
index 00000000..348d6a82
--- /dev/null
+++ b/404-sum-of-left-leaves.js
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const sumOfLeftLeaves = function(root) {
+  if(root == null) return 0
+  let res = 0
+  function dfs(node, side) {
+    if(node === null) return
+    if(node.left === null && node.right === null) {
+      if(side === 'left') res += node.val
+      return
+    }
+    dfs(node.left, 'left')
+    dfs(node.right, 'right')
+  }
+  dfs(root.left, 'left')
+  dfs(root.right, 'right')
+
+  return res
+};

From ef6e6e22ae8ba0f31d05ec805b95527ae5890ae2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Nov 2019 20:27:45 +0800
Subject: [PATCH 0088/3374] Create 563-binary-tree-tilt.js

---
 563-binary-tree-tilt.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 563-binary-tree-tilt.js

diff --git a/563-binary-tree-tilt.js b/563-binary-tree-tilt.js
new file mode 100644
index 00000000..802a0037
--- /dev/null
+++ b/563-binary-tree-tilt.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const findTilt = function(root) {
+  const tilt = { val: 0 }
+  dfs(root, tilt)
+  function dfs(root, tilt) {
+    if (!root) return 0
+    let left = dfs(root.left, tilt)
+    let right = dfs(root.right, tilt)
+    tilt.val += Math.abs(left - right)
+    return root.val + left + right
+  }
+  return tilt.val
+}

From 49147084d233558cdbcc2d89ef27df83ab9f4fbf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Nov 2019 10:50:25 +0800
Subject: [PATCH 0089/3374] Create 529-minesweeper.js

---
 529-minesweeper.js | 58 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 529-minesweeper.js

diff --git a/529-minesweeper.js b/529-minesweeper.js
new file mode 100644
index 00000000..7e772c49
--- /dev/null
+++ b/529-minesweeper.js
@@ -0,0 +1,58 @@
+/**
+ * @param {character[][]} board
+ * @param {number[]} click
+ * @return {character[][]}
+ */
+const updateBoard = function(board, click) {
+  const visited = new Set();
+  const [clickRow, clickCol] = click;
+  if (board[clickRow][clickCol] === "M") {
+    board[clickRow][clickCol] = "X";
+    return board;
+  }
+  const directions = [
+    [-1, 0], // top
+    [1, 0], // down
+    [0, -1], // left
+    [0, 1], // right
+    [-1, -1], // top left
+    [1, 1], // bottom right
+    [-1, 1], // top right
+    [1, -1] // bottom left
+  ];
+
+  function dfs(row, col) {
+    visited.add(`${row},${col}`);
+    if (board[row][col] === "M") return;
+    let numBombs = 0;
+    for (let dir of directions) {
+      if (
+        board[row + dir[0]] === undefined ||
+        board[row + dir[0]][col + dir[1]] === undefined
+      )
+        continue;
+      if (board[row + dir[0]][col + dir[1]] === "M") {
+        numBombs += 1;
+      }
+    }
+    if (numBombs) {
+      board[row][col] = `${numBombs}`;
+      return;
+    }
+    board[row][col] = "B";
+    for (let dir of directions) {
+      if (
+        board[row + dir[0]] === undefined ||
+        board[row + dir[0]][col + dir[1]] === undefined ||
+        board[row + dir[0]][col + dir[1]] !== "E"
+      )
+        continue;
+      if (!visited.has(`${row + dir[0]},${col + dir[1]}`)) {
+        dfs(row + dir[0], col + dir[1]);
+      }
+    }
+  }
+  dfs(clickRow, clickCol);
+  return board;
+};
+

From 3d2ed4d74c501fff4354cd24e38c909b82c2deda Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Nov 2019 11:12:56 +0800
Subject: [PATCH 0090/3374] Create
 452-minimum-number-of-arrows-to-burst-balloons.js

---
 ...nimum-number-of-arrows-to-burst-balloons.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 452-minimum-number-of-arrows-to-burst-balloons.js

diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
new file mode 100644
index 00000000..96b42c08
--- /dev/null
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const findMinArrowShots = function(points) {
+  const sorted = points.sort((a, b) => a[0] - b[0])
+  let ans = 0
+  let lastX = null
+  for (let i = 0; i < sorted.length; i += 1) {
+    if (lastX && sorted[i][0] <= lastX) {
+      lastX = Math.min(sorted[i][1], lastX)
+    } else {
+      ans += 1
+      lastX = sorted[i][1]
+    }
+  }
+  return ans
+}

From 62655d01d593eff4469ff753cc543484d58625b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Nov 2019 16:08:06 +0800
Subject: [PATCH 0091/3374] Update
 452-minimum-number-of-arrows-to-burst-balloons.js

---
 ...imum-number-of-arrows-to-burst-balloons.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
index 96b42c08..bdc4ebda 100644
--- a/452-minimum-number-of-arrows-to-burst-balloons.js
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -16,3 +16,23 @@ const findMinArrowShots = function(points) {
   }
   return ans
 }
+
+// another
+
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const findMinArrowShots = function(points) {
+  if(points == null || points.length === 0) return 0
+  points.sort((a, b) => a[1] - b[1])
+  let ans = 1
+  let lastX = points[0][1]
+  for (let i = 1; i < points.length; i++) {
+    if(points[i][0] <= lastX) continue
+    ans++
+    lastX = points[i][1]
+  }
+  return ans
+}
+

From a718ab3af80f7beb2fb2847f01c9c0955c99112d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Nov 2019 20:30:21 +0800
Subject: [PATCH 0092/3374] Create 606-construct-string-from-binary-tree.js

---
 606-construct-string-from-binary-tree.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 606-construct-string-from-binary-tree.js

diff --git a/606-construct-string-from-binary-tree.js b/606-construct-string-from-binary-tree.js
new file mode 100644
index 00000000..7e2f1a4a
--- /dev/null
+++ b/606-construct-string-from-binary-tree.js
@@ -0,0 +1,19 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} t
+ * @return {string}
+ */
+const tree2str = function(t) {
+  if (!t) return ''
+  const left = tree2str(t.left)
+  const right = tree2str(t.right)
+  if (right) return `${t.val}(${left})(${right})`
+  else if (left) return `${t.val}(${left})`
+  else return `${t.val}`
+};

From 73f66bf5056fe59600a6fb8f234f7fe4ec633448 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Nov 2019 16:23:24 +0800
Subject: [PATCH 0093/3374] Create 373-find-k-pairs-with-smallest-sums.js

---
 373-find-k-pairs-with-smallest-sums.js | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 373-find-k-pairs-with-smallest-sums.js

diff --git a/373-find-k-pairs-with-smallest-sums.js b/373-find-k-pairs-with-smallest-sums.js
new file mode 100644
index 00000000..6b4c9123
--- /dev/null
+++ b/373-find-k-pairs-with-smallest-sums.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number[][]}
+ */
+const kSmallestPairs = function(nums1, nums2, k) {
+  let len1 = nums1.length,
+    len2 = nums2.length
+  let arr = Array(len1).fill(0),
+    resList = []
+  while (k-- > 0) {
+    let min = Infinity,
+      index = -1,
+      lastj = Infinity
+    for (let i = 0; i < len1; i++) {
+      const j = arr[i]
+      if (j < lastj && j < len2) {
+        const sum = nums1[i] + nums2[j]
+        if (sum < min) {
+          min = sum
+          index = i
+        }
+        lastj = j
+      }
+    }
+    if (index == -1) {
+      break
+    }
+    resList.push([nums1[index], nums2[arr[index]]])
+    arr[index]++
+  }
+  return resList
+}

From d69105144b99cf6a6f84f66e40f227440d2fc275 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Nov 2019 10:04:48 +0800
Subject: [PATCH 0094/3374] Create 547-friend-circles.js

---
 547-friend-circles.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 547-friend-circles.js

diff --git a/547-friend-circles.js b/547-friend-circles.js
new file mode 100644
index 00000000..48f88ce0
--- /dev/null
+++ b/547-friend-circles.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} M
+ * @return {number}
+ */
+const findCircleNum = function(M) {
+  let count = 0
+  const visited = {}
+  const dfs = function(M, i) {
+    for (let j = 0; j < M[i].length; j++) {
+      if (M[i][j] == 1 && !visited[j]) {
+        visited[j] = true
+        dfs(M, j)
+      }
+    }
+  }
+  for (let i = 0; i < M.length; i++) {
+    if (!visited[i]) {
+      dfs(M, i)
+      count++
+    }
+  }
+  return count
+}

From 336440b15dfab0ff970478fb352cb3d532536000 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Nov 2019 10:38:05 +0800
Subject: [PATCH 0095/3374] Create 645-set-mismatch.js

---
 645-set-mismatch.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 645-set-mismatch.js

diff --git a/645-set-mismatch.js b/645-set-mismatch.js
new file mode 100644
index 00000000..b55c998b
--- /dev/null
+++ b/645-set-mismatch.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findErrorNums = function(nums) {
+  if(nums == null || nums.length === 0) return null
+  const res = []
+  const hash = {}
+  for(let el of nums) {
+    if(hash.hasOwnProperty(el)){
+      res[0] = el
+    } else hash[el] = 0
+    hash[el]++
+  }
+  for(let i = 1, len = nums.length; i <= len; i++) {
+    if(!hash.hasOwnProperty(i)) {
+      res[1] = i
+      break
+    }
+  }
+  return res
+};

From 851ab1afcda786cd583f45b9eb7d005b4197ff9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2019 10:58:05 +0800
Subject: [PATCH 0096/3374] Create 541-reverse-string-ii.js

---
 541-reverse-string-ii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 541-reverse-string-ii.js

diff --git a/541-reverse-string-ii.js b/541-reverse-string-ii.js
new file mode 100644
index 00000000..7486e7a1
--- /dev/null
+++ b/541-reverse-string-ii.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const reverseStr = function(s, k) {
+  const arr = s.split('')
+  for(let i = 0, len = s.length; i < len; i += 2 * k) {
+    helper(arr, i, k)
+  }
+  return arr.join('')
+};
+
+function helper(arr, start, k) {
+  let s = start
+  let e = arr.length > start + k - 1 ? start + k - 1 : arr.length
+  while(s < e) {
+    swap(arr, s, e)
+    s++
+    e--
+  }
+}
+
+function swap(arr, s, e) {
+  const tmp = arr[s]
+  arr[s] = arr[e]
+  arr[e] = tmp
+}

From d69c85292b3698c2dbe7325b4dfac11a6762ce15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Nov 2019 12:31:25 +0800
Subject: [PATCH 0097/3374] Create 703-kth-largest-element-in-a-stream.js

---
 703-kth-largest-element-in-a-stream.js | 39 ++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 703-kth-largest-element-in-a-stream.js

diff --git a/703-kth-largest-element-in-a-stream.js b/703-kth-largest-element-in-a-stream.js
new file mode 100644
index 00000000..0c1fc313
--- /dev/null
+++ b/703-kth-largest-element-in-a-stream.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number} k
+ * @param {number[]} nums
+ */
+const KthLargest = function(k, nums) {
+  this.sorted = nums.sort((a, b) => a - b);
+  this.k = k;
+};
+
+/**
+ * @param {number} val
+ * @return {number}
+ */
+KthLargest.prototype.add = function(val) {
+  let left = 0;
+  let right = this.sorted.length - 1;
+  let insertIndex = left;
+  while (left <= right) {
+    let mid = left + Math.floor((right - left) / 2);
+    if (val > this.sorted[mid]) {
+      left = mid + 1;
+      insertIndex = mid + 1;
+    } else if (val < this.sorted[mid]) {
+      right = mid - 1;
+      insertIndex = mid;
+    } else {
+      insertIndex = mid;
+      break;
+    }
+  }
+  this.sorted.splice(insertIndex, 0, val);
+  return this.sorted[this.sorted.length - this.k];
+};
+
+/** 
+ * Your KthLargest object will be instantiated and called as such:
+ * var obj = new KthLargest(k, nums)
+ * var param_1 = obj.add(val)
+ */

From b4334f22699dfb5a9830af81d4aa3f3a15443be4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Nov 2019 11:51:33 +0800
Subject: [PATCH 0098/3374] Create 901-online-stock-span.js

---
 901-online-stock-span.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 901-online-stock-span.js

diff --git a/901-online-stock-span.js b/901-online-stock-span.js
new file mode 100644
index 00000000..55eee528
--- /dev/null
+++ b/901-online-stock-span.js
@@ -0,0 +1,25 @@
+const StockSpanner = function() {
+  this.values = []
+}
+
+/**
+ * @param {number} price
+ * @return {number}
+ */
+StockSpanner.prototype.next = function(price) {
+  let count = 1
+  while (
+    this.values.length > 0 &&
+    this.values[this.values.length - 1][0] <= price
+  ) {
+    count += this.values.pop()[1]
+  }
+  this.values.push([price, count])
+  return count
+}
+
+/**
+ * Your StockSpanner object will be instantiated and called as such:
+ * var obj = new StockSpanner()
+ * var param_1 = obj.next(price)
+ */

From b2d00604bbbc2b5f9e555814ed74b75f68571a00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Nov 2019 12:00:08 +0800
Subject: [PATCH 0099/3374] Create 863-all-nodes-distance-k-in-binary-tree.js

---
 863-all-nodes-distance-k-in-binary-tree.js | 46 ++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 863-all-nodes-distance-k-in-binary-tree.js

diff --git a/863-all-nodes-distance-k-in-binary-tree.js b/863-all-nodes-distance-k-in-binary-tree.js
new file mode 100644
index 00000000..cec2d885
--- /dev/null
+++ b/863-all-nodes-distance-k-in-binary-tree.js
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} target
+ * @param {number} K
+ * @return {number[]}
+ */
+const distanceK = function(root, target, K) {
+  let res = []
+  dfs(root, target, K, res)
+  return res
+}
+
+function dfs(node, target, k, res) {
+  if (node === null) return -1
+  if (node === target) {
+    getRes(node, 0, k, res)
+    return 1
+  }
+  let left = dfs(node.left, target, k, res)
+  let right = dfs(node.right, target, k, res)
+  if (left !== -1) {
+    if (left === k) res.push(node.val)
+    getRes(node.right, left + 1, k, res)
+    return left + 1
+  }
+  if (right !== -1) {
+    if (right === k) res.push(node.val)
+    getRes(node.left, right + 1, k, res)
+    return right + 1
+  }
+  return -1
+}
+
+function getRes(node, dist, k, res) {
+  if (node === null) return
+  if (dist === k) return res.push(node.val)
+  getRes(node.left, dist + 1, k, res)
+  getRes(node.right, dist + 1, k, res)
+}

From 7e4765ae2449cac044046c9744be1e8f787c8a96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Nov 2019 14:22:41 +0800
Subject: [PATCH 0100/3374] Update 863-all-nodes-distance-k-in-binary-tree.js

---
 863-all-nodes-distance-k-in-binary-tree.js | 57 ++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/863-all-nodes-distance-k-in-binary-tree.js b/863-all-nodes-distance-k-in-binary-tree.js
index cec2d885..51fc2e8f 100644
--- a/863-all-nodes-distance-k-in-binary-tree.js
+++ b/863-all-nodes-distance-k-in-binary-tree.js
@@ -1,3 +1,60 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} target
+ * @param {number} K
+ * @return {number[]}
+ */
+const distanceK = function(root, target, K) {
+  const map = new Map();
+  const res = [];
+  if (target == null || K < 0 || root == null) return res;
+  buildGraph(root, null);
+  const visited = new Set();
+  const q = [];
+  visited.add(target);
+  q.push(target);
+  while (q.length) {
+    const len = q.length;
+    if (K === 0) {
+      for (let i = 0; i < len; i++) res.push(q.shift().val);
+      return res;
+    }
+    for (let i = 0; i < len; i++) {
+      const el = q.shift();
+      for (let e of map.get(el)) {
+        if (visited.has(e)) continue;
+        visited.add(e);
+        q.push(e);
+      }
+    }
+    K--;
+  }
+  return res;
+
+  function buildGraph(node, parent) {
+    if (node === null) return;
+    if (!map.has(node)) {
+      map.set(node, []);
+      if (parent !== null) {
+        map.get(node).push(parent);
+        if (!map.has(parent)) map.set(parent, []);
+        map.get(parent).push(node);
+      }
+      buildGraph(node.left, node);
+      buildGraph(node.right, node);
+    }
+  }
+};
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 305e63fd4284c15c585a126763203264db49d997 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Nov 2019 10:24:24 +0800
Subject: [PATCH 0101/3374] Create 429-n-ary-tree-level-order-traversal.js

---
 429-n-ary-tree-level-order-traversal.js | 30 +++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 429-n-ary-tree-level-order-traversal.js

diff --git a/429-n-ary-tree-level-order-traversal.js b/429-n-ary-tree-level-order-traversal.js
new file mode 100644
index 00000000..1accc76a
--- /dev/null
+++ b/429-n-ary-tree-level-order-traversal.js
@@ -0,0 +1,30 @@
+/**
+ * // Definition for a Node.
+ * function Node(val,children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+/**
+ * @param {Node} root
+ * @return {number[][]}
+ */
+const levelOrder = function(root) {
+  const res = []
+  if(root == null) return res
+  const q = []
+  q.push(root)
+  while(q.length) {
+    const size = q.length
+    const cur = []
+    for(let i = 0; i < size; i++) {
+      const node = q.shift()
+      cur.push(node.val)
+      for(let j = 0, len = node.children.length; j < len; j++) {
+        q.push(node.children[j])
+      }
+    }
+    res.push(cur)
+  }
+  return res
+};

From 178666dcab0c3179c7308c0f05ea7a691d1047b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Nov 2019 10:32:11 +0800
Subject: [PATCH 0102/3374] Update 429-n-ary-tree-level-order-traversal.js

---
 429-n-ary-tree-level-order-traversal.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/429-n-ary-tree-level-order-traversal.js b/429-n-ary-tree-level-order-traversal.js
index 1accc76a..6f47ba5b 100644
--- a/429-n-ary-tree-level-order-traversal.js
+++ b/429-n-ary-tree-level-order-traversal.js
@@ -20,9 +20,7 @@ const levelOrder = function(root) {
     for(let i = 0; i < size; i++) {
       const node = q.shift()
       cur.push(node.val)
-      for(let j = 0, len = node.children.length; j < len; j++) {
-        q.push(node.children[j])
-      }
+      q.push(...node.children)
     }
     res.push(cur)
   }

From 2f4f3c16780d8cc350770f00bdfd8331e4a9cba1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Nov 2019 10:59:14 +0800
Subject: [PATCH 0103/3374] Update 429-n-ary-tree-level-order-traversal.js

---
 429-n-ary-tree-level-order-traversal.js | 29 +++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/429-n-ary-tree-level-order-traversal.js b/429-n-ary-tree-level-order-traversal.js
index 6f47ba5b..413cc641 100644
--- a/429-n-ary-tree-level-order-traversal.js
+++ b/429-n-ary-tree-level-order-traversal.js
@@ -1,3 +1,32 @@
+/**
+ * // Definition for a Node.
+ * function Node(val,children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+/**
+ * @param {Node} root
+ * @return {number[][]}
+ */
+const levelOrder = function(root) {
+  const res = []
+  if(root == null) return res
+  helper(root, 0, res)
+  return res
+};
+
+function helper(node, index, res) {
+  if(node == null) return
+  if(res[index] == null) res[index] = []
+  res[index].push(node.val)
+  for(let i = 0, len = node.children.length; i < len; i++) {
+    helper(node.children[i], index + 1, res)
+  }
+}
+
+// another
+
 /**
  * // Definition for a Node.
  * function Node(val,children) {

From 03030d3678601de8803717a1c37e90c13b526be0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Nov 2019 18:37:36 +0800
Subject: [PATCH 0104/3374] Create 713-subarray-product-less-than-k.js

---
 713-subarray-product-less-than-k.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 713-subarray-product-less-than-k.js

diff --git a/713-subarray-product-less-than-k.js b/713-subarray-product-less-than-k.js
new file mode 100644
index 00000000..33400b8d
--- /dev/null
+++ b/713-subarray-product-less-than-k.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const numSubarrayProductLessThanK = function(nums, k) {
+  if (k == 0) return 0
+  let cnt = 0
+  let pro = 1
+  for (let i = 0, j = 0, len = nums.length; j < len; j++) {
+    pro *= nums[j]
+    while (i <= j && pro >= k) {
+      pro /= nums[i++]
+    }
+    cnt += j - i + 1
+  }
+  return cnt
+}

From ccc7efa5c642ee5592dbdf6dfc6a22299ff667fc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Nov 2019 13:14:27 +0800
Subject: [PATCH 0105/3374] Create 748-shortest-completing-word.js

---
 748-shortest-completing-word.js | 65 +++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 748-shortest-completing-word.js

diff --git a/748-shortest-completing-word.js b/748-shortest-completing-word.js
new file mode 100644
index 00000000..b791dcc9
--- /dev/null
+++ b/748-shortest-completing-word.js
@@ -0,0 +1,65 @@
+/**
+ * @param {string} licensePlate
+ * @param {string[]} words
+ * @return {string}
+ */
+const shortestCompletingWord = function(licensePlate, words) {
+  const letters = licensePlate
+    .replace(/\d/g, '')
+    .replace(/ /g, '')
+    .toLowerCase()
+    .split('')
+  let matchingWords = words.filter(word => {
+    let completingWord = true
+    letters.forEach(letter => {
+      let letterIndex = word.indexOf(letter)
+      if (letterIndex > -1) {
+        let re = new RegExp(letter)
+        word = word.replace(re, '')
+      } else {
+        completingWord = false
+      }
+    })
+    return completingWord
+  })
+  const wordLengths = matchingWords.map(word => word.length)
+  return matchingWords[wordLengths.indexOf(Math.min.apply(Math, wordLengths))]
+}
+
+// another
+
+/**
+ * @param {string} licensePlate
+ * @param {string[]} words
+ * @return {string}
+ */
+const shortestCompletingWord = function(licensePlate, words) {
+  licensePlate = licensePlate.toLowerCase()
+  const plateCount = Array(26).fill(0)
+  let plateLength = 0
+  for (let i = 0; i < licensePlate.length; i += 1) {
+    const code = licensePlate.charCodeAt(i)
+    if (code < 97 || code > 122) {
+      continue
+    }
+    plateCount[code - 97] += 1
+    plateLength += 1
+  }
+  const longerOrEqualWords = words.filter(word => word.length >= plateLength)
+  return longerOrEqualWords.reduce((shortest, word) => {
+    if (shortest && shortest.length <= word.length) {
+      return shortest
+    }
+    const wordCount = Array(26).fill(0)
+    for (let i = 0; i < word.length; i += 1) {
+      const code = word.charCodeAt(i)
+      wordCount[code - 97] += 1
+    }
+    for (let i = 0; i < 26; i += 1) {
+      if (wordCount[i] - plateCount[i] < 0) {
+        return shortest
+      }
+    }
+    return word
+  }, null)
+}

From ca10bd8bd551556bc7e1beecfb56c21f2a418e63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Nov 2019 09:26:46 +0800
Subject: [PATCH 0106/3374] Create 921-minimum-add-to-make-parentheses-valid.js

---
 921-minimum-add-to-make-parentheses-valid.js | 25 ++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 921-minimum-add-to-make-parentheses-valid.js

diff --git a/921-minimum-add-to-make-parentheses-valid.js b/921-minimum-add-to-make-parentheses-valid.js
new file mode 100644
index 00000000..3b92cefc
--- /dev/null
+++ b/921-minimum-add-to-make-parentheses-valid.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} S
+ * @return {number}
+ */
+const minAddToMakeValid = function(S) {
+  if(S === '' || S == null) return 0
+  const len = S.length
+  const h = {
+    o: 0,
+    c: 0
+  }
+  for(let i = 0; i < len; i++) {
+    if(S[i] === '(') {
+      h.o++
+    } else {
+      if(h.o > 0) {
+        h.o--
+      } else {
+        h.c++
+      }
+    }
+  }
+  
+  return h.o + h.c
+};

From a58f5efcc59d2c4235122364473c09a430745c31 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Nov 2019 10:14:34 +0800
Subject: [PATCH 0107/3374] Create 912-sort-an-array.js

---
 912-sort-an-array.js | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 912-sort-an-array.js

diff --git a/912-sort-an-array.js b/912-sort-an-array.js
new file mode 100644
index 00000000..b34d0dab
--- /dev/null
+++ b/912-sort-an-array.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+function swap(items, l, r) {
+  const temp = items[l];
+  items[l] = items[r];
+  items[r] = temp;
+}
+function partition(items, left, right) {
+  let pivot = items[left + Math.floor((right - left) / 2)],
+    i = left,
+    j = right;
+  while (i <= j) {
+    while (items[i] < pivot) {
+      i++;
+    }
+    while (items[j] > pivot) {
+      j--;
+    }
+    if (i <= j) {
+      swap(items, i, j);
+      i++;
+      j--;
+    }
+  }
+  return i;
+}
+
+function quickSort(items, left, right) {
+  if (items.length > 1) {
+    const index = partition(items, left, right);
+    if (left < index - 1) {
+      quickSort(items, left, index - 1);
+    }
+    if (index < right) {
+      quickSort(items, index, right);
+    }
+  }
+  return items;
+}
+const sortArray = function(nums) {
+  return quickSort(nums, 0, nums.length - 1);
+};

From cdab0c8e283b889c716761430d96d2fdf4646c1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Nov 2019 11:22:08 +0800
Subject: [PATCH 0108/3374] Update 912-sort-an-array.js

---
 912-sort-an-array.js | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/912-sort-an-array.js b/912-sort-an-array.js
index b34d0dab..3d89197d 100644
--- a/912-sort-an-array.js
+++ b/912-sort-an-array.js
@@ -7,35 +7,23 @@ function swap(items, l, r) {
   items[l] = items[r];
   items[r] = temp;
 }
-function partition(items, left, right) {
-  let pivot = items[left + Math.floor((right - left) / 2)],
-    i = left,
-    j = right;
-  while (i <= j) {
-    while (items[i] < pivot) {
-      i++;
-    }
-    while (items[j] > pivot) {
-      j--;
-    }
-    if (i <= j) {
-      swap(items, i, j);
-      i++;
-      j--;
+function partition(items, start, end) {
+  let pivot = items[end], s = start
+  for(let i = start; i < end; i++) {
+    if(items[i] <= pivot) {
+      swap(items, s, i)
+      s++
     }
   }
-  return i;
+  swap(items, s, end)
+  return s
 }
 
 function quickSort(items, left, right) {
-  if (items.length > 1) {
-    const index = partition(items, left, right);
-    if (left < index - 1) {
-      quickSort(items, left, index - 1);
-    }
-    if (index < right) {
-      quickSort(items, index, right);
-    }
+  if(left < right) {
+    const pIdx = partition(items, left, right)
+    quickSort(items, left, pIdx - 1)
+    quickSort(items, pIdx + 1, right)
   }
   return items;
 }

From 3155f89d77e495dbd3e9ea9f8447e10f500b0e43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Nov 2019 09:45:59 +0800
Subject: [PATCH 0109/3374] Create 797-all-paths-from-source-to-target.js

---
 797-all-paths-from-source-to-target.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 797-all-paths-from-source-to-target.js

diff --git a/797-all-paths-from-source-to-target.js b/797-all-paths-from-source-to-target.js
new file mode 100644
index 00000000..a9f60e58
--- /dev/null
+++ b/797-all-paths-from-source-to-target.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} graph
+ * @return {number[][]}
+ */
+const allPathsSourceTarget = function(graph) {
+  const res = []
+  traverse(graph, 0, [0], res)
+  return res
+};
+
+function traverse(arr, idx, cur, res) {
+  if(idx === arr.length - 1) {
+    res.push(cur.slice(0))
+    return
+  }
+  for(let i = 0, len = arr[idx].length; i < len; i++) {
+    cur.push(arr[idx][i])
+    traverse(arr, arr[idx][i], cur, res)
+    cur.pop(arr[idx][i])
+  }
+}

From d242c59c33428d073e9698ecf9b1ee9daaf6c59f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Nov 2019 10:49:10 +0800
Subject: [PATCH 0110/3374] Create 890-find-and-replace-pattern.js

---
 890-find-and-replace-pattern.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 890-find-and-replace-pattern.js

diff --git a/890-find-and-replace-pattern.js b/890-find-and-replace-pattern.js
new file mode 100644
index 00000000..f46137ae
--- /dev/null
+++ b/890-find-and-replace-pattern.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[]} words
+ * @param {string} pattern
+ * @return {string[]}
+ */
+const findAndReplacePattern = (words, pattern) => {
+  return words.reduce((acc, item, index) => {
+    if (compose(words[index], pattern)) acc.push(words[index]);
+    return acc;
+  }, []);
+
+  function compose(element, pattern) {
+    const s = new Set();
+    const m = new Map();
+    for (let i = 0; i < element.length; i++) {
+      const e = element[i];
+      const p = pattern[i];
+      s.add(e);
+      if (m.get(p) === undefined) {
+        m.set(p, e);
+      } else if (m.get(p) !== e) {
+        return false;
+      }
+    }
+    return m.size === s.size;
+  }
+};

From dbfcb14a0c7697512d151ecd9605911b9e080329 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Nov 2019 11:36:44 +0800
Subject: [PATCH 0111/3374] Update 890-find-and-replace-pattern.js

---
 890-find-and-replace-pattern.js | 35 +++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/890-find-and-replace-pattern.js b/890-find-and-replace-pattern.js
index f46137ae..118af02a 100644
--- a/890-find-and-replace-pattern.js
+++ b/890-find-and-replace-pattern.js
@@ -25,3 +25,38 @@ const findAndReplacePattern = (words, pattern) => {
     return m.size === s.size;
   }
 };
+
+// anoother
+
+/**
+ * @param {string[]} words
+ * @param {string} pattern
+ * @return {string[]}
+ */
+const findAndReplacePattern = function(words, pattern) {
+  const p = helper(pattern);
+  const res = [];
+  for (let w of words) {
+    if (arrEqual(helper(w), p)) res.push(w);
+  }
+  return res;
+};
+
+function arrEqual(a, b) {
+  if (a.length !== b.length) return false;
+  for (let i = 0, len = a.length; i < len; i++) {
+    if (a[i] !== b[i]) return false;
+  }
+  return true;
+}
+
+function helper(w) {
+  const m = new Map();
+  const n = w.length;
+  const res = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    if (!m.has(w[i])) m.set(w[i], m.size);
+    res[i] = m.get(w[i]);
+  }
+  return res;
+}

From e6d566ee64ab57573d1d2c38d2b2cd45cf002d83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Nov 2019 16:06:19 +0800
Subject: [PATCH 0112/3374] Create 761-special-binary-string.js

---
 761-special-binary-string.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 761-special-binary-string.js

diff --git a/761-special-binary-string.js b/761-special-binary-string.js
new file mode 100644
index 00000000..8c8c31f1
--- /dev/null
+++ b/761-special-binary-string.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} S
+ * @return {string}
+ */
+const makeLargestSpecial = function(S) {
+  let count = 0, i = 0
+  const res = []
+  for(let j = 0, len = S.length; i < len; j++) {
+    if(S.charAt(j) === '1') count++
+    else count--
+    if(count === 0) {
+      res.push('1' + makeLargestSpecial(S.substring(i + 1, j)) + '0')
+      i = j + 1
+    }
+  }
+  return res.sort().reverse().join('')
+};

From cb08126f40ae01028764d1d5b02d908ae6fe32f5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Nov 2019 11:37:08 +0800
Subject: [PATCH 0113/3374] Create 931-minimum-falling-path-sum.js

---
 931-minimum-falling-path-sum.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 931-minimum-falling-path-sum.js

diff --git a/931-minimum-falling-path-sum.js b/931-minimum-falling-path-sum.js
new file mode 100644
index 00000000..706b3172
--- /dev/null
+++ b/931-minimum-falling-path-sum.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} A
+ * @return {number}
+ */
+const minFallingPathSum = function(A) {
+    for (let i = A.length - 2; i >= 0; i -= 1) {
+      for (let j = 0; j < A[i].length; j += 1) {
+        A[i][j] += Math.min(
+          getValueOrMax(A, i + 1, j - 1),
+          getValueOrMax(A, i + 1, j),
+          getValueOrMax(A, i + 1, j + 1)
+        )
+      }
+    }
+    return Math.min(...A[0])
+  }
+  
+  function getValueOrMax(A, i, j) {
+    return A[i][j] !== undefined ? A[i][j] : Number.MAX_VALUE
+  }
+  

From 8ee2c5dd380f099462d9d51da7a57a2dc795f58f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Nov 2019 14:06:06 +0800
Subject: [PATCH 0114/3374] Update 931-minimum-falling-path-sum.js

---
 931-minimum-falling-path-sum.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/931-minimum-falling-path-sum.js b/931-minimum-falling-path-sum.js
index 706b3172..d41ece0e 100644
--- a/931-minimum-falling-path-sum.js
+++ b/931-minimum-falling-path-sum.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} A
+ * @return {number}
+ */
+const minFallingPathSum = function(A) {
+  for (let i = 1, rows = A.length; i < rows; i++) {
+    for (let j = 0, cols = A[0].length; j < cols; j++) {
+      A[i][j] += Math.min(
+        getValueOrMax(A, i - 1, j - 1),
+        getValueOrMax(A, i - 1, j),
+        getValueOrMax(A, i - 1, j + 1)
+      );
+    }
+  }
+  return Math.min(...A[A.length - 1]);
+};
+
+function getValueOrMax(A, i, j) {
+  return A[i][j] !== undefined ? A[i][j] : Number.MAX_VALUE;
+}
+
+// another
+
 /**
  * @param {number[][]} A
  * @return {number}

From 8cb71af2c373f19399e4bc508abfa41362ca69aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Nov 2019 14:45:44 +0800
Subject: [PATCH 0115/3374] Create 929-unique-email-addresses.js

---
 929-unique-email-addresses.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 929-unique-email-addresses.js

diff --git a/929-unique-email-addresses.js b/929-unique-email-addresses.js
new file mode 100644
index 00000000..4ef8394c
--- /dev/null
+++ b/929-unique-email-addresses.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string[]} emails
+ * @return {number}
+ */
+const numUniqueEmails = function(emails) {
+  const res = new Set()
+  emails.forEach(el => helper(el, res))
+  return res.size
+};
+
+function helper(str, s) {
+  const arr = str.split('@')
+  const p = arr[0]
+  const d = arr[1]
+  let res = ''
+  for(let i = 0, len = p.length; i < len; i++) {
+    if(p[i] === '.') {
+      continue
+    } else if(p[i] === '+') {
+      break
+    } else {
+      res += p[i]
+    }
+  }
+  s.add(`${res}@${d}`)
+}

From 746d341a1c7f9341f7ae2cf48b471cb136c2210f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Nov 2019 17:37:24 +0800
Subject: [PATCH 0116/3374] Create 951-flip-equivalent-binary-trees.js

---
 951-flip-equivalent-binary-trees.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 951-flip-equivalent-binary-trees.js

diff --git a/951-flip-equivalent-binary-trees.js b/951-flip-equivalent-binary-trees.js
new file mode 100644
index 00000000..0ddcdcdf
--- /dev/null
+++ b/951-flip-equivalent-binary-trees.js
@@ -0,0 +1,20 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root1
+ * @param {TreeNode} root2
+ * @return {boolean}
+ */
+const flipEquiv = function(root1, root2) {
+  if(root1 == null || root2 == null) return root1 === root2
+  return root1.val === root2.val &&
+    (
+      (flipEquiv(root1.left, root2.left) && flipEquiv(root1.right, root2.right)) ||
+      (flipEquiv(root1.left, root2.right) && flipEquiv(root1.right, root2.left))
+    )
+};

From 3d12f6e5b2d4c71366900a14226926f92810336c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Nov 2019 22:14:39 +0800
Subject: [PATCH 0117/3374] Create 733-flood-fill.js

---
 733-flood-fill.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 733-flood-fill.js

diff --git a/733-flood-fill.js b/733-flood-fill.js
new file mode 100644
index 00000000..f09287bb
--- /dev/null
+++ b/733-flood-fill.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[][]} image
+ * @param {number} sr
+ * @param {number} sc
+ * @param {number} newColor
+ * @return {number[][]}
+ */
+const floodFill = function(image, sr, sc, newColor, firstColor = image[sr][sc]) {
+  if (
+    sr < 0 ||
+    sc < 0 ||
+    sr >= image.length ||
+    sc >= image[sr].length ||
+    image[sr][sc] !== firstColor ||
+    image[sr][sc] === newColor
+  ) {
+    return image
+  }
+
+  image[sr][sc] = newColor
+
+  floodFill(image, sr + 1, sc, newColor, firstColor)
+  floodFill(image, sr - 1, sc, newColor, firstColor)
+  floodFill(image, sr, sc + 1, newColor, firstColor)
+  floodFill(image, sr, sc - 1, newColor, firstColor)
+
+  return image
+}

From 71c12dfa1211f1410cfa8dbb39caebd97852ceae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Nov 2019 10:34:59 +0800
Subject: [PATCH 0118/3374] Create 299-bulls-and-cows.js

---
 299-bulls-and-cows.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 299-bulls-and-cows.js

diff --git a/299-bulls-and-cows.js b/299-bulls-and-cows.js
new file mode 100644
index 00000000..6acc441a
--- /dev/null
+++ b/299-bulls-and-cows.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} secret
+ * @param {string} guess
+ * @return {string}
+ */
+const getHint = function(secret, guess) {
+  let bulls = 0
+  let cows = 0
+  const h = {}
+  for(let i = 0, len = secret.length; i < len; i++) {
+    if(secret[i] === guess[i]) {
+      bulls++
+    } else {
+      if(!h.hasOwnProperty(secret[i])) h[secret[i]] = 0
+      h[secret[i]]++
+    }
+  }
+  
+  for(let i = 0, len = secret.length; i < len; i++) {
+    if(secret[i] !== guess[i]) {
+      if(h.hasOwnProperty(guess[i]) && h[guess[i]] > 0) {
+        cows++
+        h[guess[i]]--
+      }
+    }
+  }
+
+  return `${bulls}A${cows}B`
+};

From 3f79d81b7de2060a530b626a82643f1a74f65ae3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Nov 2019 13:16:39 +0800
Subject: [PATCH 0119/3374] Create 1042-flower-planting-with-no-adjacent.js

---
 1042-flower-planting-with-no-adjacent.js | 36 ++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1042-flower-planting-with-no-adjacent.js

diff --git a/1042-flower-planting-with-no-adjacent.js b/1042-flower-planting-with-no-adjacent.js
new file mode 100644
index 00000000..f7fe14f8
--- /dev/null
+++ b/1042-flower-planting-with-no-adjacent.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number} N
+ * @param {number[][]} paths
+ * @return {number[]}
+ */
+const gardenNoAdj = function(N, paths) {
+  let map = {};
+  for (let i = 0; i < N; i++) {
+    map[i] = [];
+  }
+
+  for (let path of paths) {
+    let lhs = path[0] - 1;
+    let rhs = path[1] - 1;
+    map[lhs].push(rhs);
+    map[rhs].push(lhs);
+  }
+
+  let result = new Array(N).fill(-1);
+  for (let i = 0; i < N; i++) {
+    let colors = new Array(4).fill(false);
+    for (let neighbor of map[i]) {
+      if (result[neighbor] !== -1) {
+        colors[result[neighbor] - 1] = true;
+      }
+    }
+    for (let j = 0; j < colors.length; j++) {
+      if (!colors[j]) {
+        result[i] = j + 1;
+        break;
+      }
+    }
+  }
+
+  return result;
+};

From dbbe2c21e910746ac41bdb978895f82163cc25b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Nov 2019 16:22:38 +0800
Subject: [PATCH 0120/3374] Update 1042-flower-planting-with-no-adjacent.js

---
 1042-flower-planting-with-no-adjacent.js | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/1042-flower-planting-with-no-adjacent.js b/1042-flower-planting-with-no-adjacent.js
index f7fe14f8..66b18f90 100644
--- a/1042-flower-planting-with-no-adjacent.js
+++ b/1042-flower-planting-with-no-adjacent.js
@@ -4,19 +4,17 @@
  * @return {number[]}
  */
 const gardenNoAdj = function(N, paths) {
-  let map = {};
+  const map = {};
   for (let i = 0; i < N; i++) {
     map[i] = [];
   }
-
   for (let path of paths) {
-    let lhs = path[0] - 1;
-    let rhs = path[1] - 1;
-    map[lhs].push(rhs);
-    map[rhs].push(lhs);
+    let l = path[0] - 1;
+    let r = path[1] - 1;
+    map[l].push(r);
+    map[r].push(l);
   }
-
-  let result = new Array(N).fill(-1);
+  const result = new Array(N).fill(-1);
   for (let i = 0; i < N; i++) {
     let colors = new Array(4).fill(false);
     for (let neighbor of map[i]) {
@@ -31,6 +29,5 @@ const gardenNoAdj = function(N, paths) {
       }
     }
   }
-
   return result;
 };

From b92dfa6182607b58f42658bc48f055c9fd47c7bd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Nov 2019 16:53:54 +0800
Subject: [PATCH 0121/3374] Update 1042-flower-planting-with-no-adjacent.js

---
 1042-flower-planting-with-no-adjacent.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1042-flower-planting-with-no-adjacent.js b/1042-flower-planting-with-no-adjacent.js
index 66b18f90..8dd0b263 100644
--- a/1042-flower-planting-with-no-adjacent.js
+++ b/1042-flower-planting-with-no-adjacent.js
@@ -19,15 +19,15 @@ const gardenNoAdj = function(N, paths) {
     let colors = new Array(4).fill(false);
     for (let neighbor of map[i]) {
       if (result[neighbor] !== -1) {
-        colors[result[neighbor] - 1] = true;
+        colors[result[neighbor]] = true;
       }
     }
     for (let j = 0; j < colors.length; j++) {
       if (!colors[j]) {
-        result[i] = j + 1;
+        result[i] = j;
         break;
       }
     }
   }
-  return result;
+  return result.map(i => ++i);
 };

From 933eb72f5620f9ef00125757c8487d06c6a5f5ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Nov 2019 10:09:17 +0800
Subject: [PATCH 0122/3374] Create
 423-reconstruct-original-digits-from-english.js

---
 ...econstruct-original-digits-from-english.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 423-reconstruct-original-digits-from-english.js

diff --git a/423-reconstruct-original-digits-from-english.js b/423-reconstruct-original-digits-from-english.js
new file mode 100644
index 00000000..8a9c0db3
--- /dev/null
+++ b/423-reconstruct-original-digits-from-english.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const originalDigits = function(s) {
+  const count = new Array(10).fill(0);
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charAt(i);
+    if (c === "z") count[0]++;
+    if (c === "w") count[2]++;
+    if (c === "x") count[6]++;
+    if (c === "s") count[7]++; //7-6
+    if (c === "g") count[8]++;
+    if (c === "u") count[4]++;
+    if (c === "f") count[5]++; //5-4
+    if (c === "h") count[3]++; //3-8
+    if (c === "i") count[9]++; //9-8-5-6
+    if (c === "o") count[1]++; //1-0-2-4
+  }
+  count[7] -= count[6];
+  count[5] -= count[4];
+  count[3] -= count[8];
+  count[9] = count[9] - count[8] - count[5] - count[6];
+  count[1] = count[1] - count[0] - count[2] - count[4];
+  let ans = "";
+  for (let i = 0; i <= 9; i++) {
+    ans += `${i}`.repeat(count[i]);
+  }
+  return ans;
+};

From b597d463cec055f9b890de9e9cedf8f522dec497 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 12:46:08 +0800
Subject: [PATCH 0123/3374] Create 937-reorder-data-in-log-files.js

---
 937-reorder-data-in-log-files.js | 34 ++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 937-reorder-data-in-log-files.js

diff --git a/937-reorder-data-in-log-files.js b/937-reorder-data-in-log-files.js
new file mode 100644
index 00000000..93cfbc74
--- /dev/null
+++ b/937-reorder-data-in-log-files.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string[]} logs
+ * @return {string[]}
+ */
+const reorderLogFiles = function(logs) {
+  if(logs == null || logs.length === 0) return []
+  const ll = []
+  const dl = []
+  const zero = '0'.charCodeAt(0)
+  const nine = '9'.charCodeAt(0)
+  for(let e of logs) {
+    const arr = e.split(' ')
+    if(arr[1].charCodeAt(0) >= zero && arr[1].charCodeAt(0) <= nine) {
+      dl.push(arr)
+    } else {
+      ll.push(arr)
+    }
+  }
+  const rll = ll.map(el => {
+    const r = el.slice(1).join(' ')
+    return [el[0], r]
+  }).sort((a, b) => {
+    if(a[1] < b[1]) return -1
+    else if(a[1] > b[1]) return 1
+    else {
+      if(`${a[0]} ${a[1]}` > `${b[0]} ${b[1]}`) return 1
+      else if(`${a[0]} ${a[1]}` < `${b[0]} ${b[1]}`) return -1
+      else return 0
+    }
+  }).map(el => el.join(' '))
+  
+  const rdl = dl.map(el => el.join(' '))
+  return rll.concat(rdl)
+};

From 2505542005642d6fb0e074340d341ba3716af46f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 12:49:35 +0800
Subject: [PATCH 0124/3374] Update 937-reorder-data-in-log-files.js

---
 937-reorder-data-in-log-files.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/937-reorder-data-in-log-files.js b/937-reorder-data-in-log-files.js
index 93cfbc74..aa103f4e 100644
--- a/937-reorder-data-in-log-files.js
+++ b/937-reorder-data-in-log-files.js
@@ -1,3 +1,31 @@
+/**
+ * @param {string[]} logs
+ * @return {string[]}
+ */
+const reorderLogFiles = function(logs) {
+  const letterLog = [],
+    digitLog = []
+  for (let log of logs) {
+    if (isNaN(log.split(' ')[1])) {
+      letterLog.push(log)
+    } else {
+      digitLog.push(log)
+    }
+  }
+  letterLog.sort((log1, log2) => {
+    let body1 = log1.slice(log1.indexOf(' '))
+    let body2 = log2.slice(log2.indexOf(' '))
+    if (body1 === body2) {
+      return log1.split(' ')[0] > log2.split(' ')[0] ? 1 : -1
+    } else {
+      return body1 > body2 ? 1 : -1
+    }
+  })
+  return [...letterLog, ...digitLog]
+}
+
+// another
+
 /**
  * @param {string[]} logs
  * @return {string[]}

From 4e175fe5c2f80ee8df83afa9cf2013724b39813e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 13:28:43 +0800
Subject: [PATCH 0125/3374] Create 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 253-meeting-rooms-ii.js

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
new file mode 100644
index 00000000..bce25fb3
--- /dev/null
+++ b/253-meeting-rooms-ii.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  const len = intervals.length
+  const starts = new Array(len)
+  const ends = new Array(len)
+  for (let i = 0; i < len; i++) {
+    starts[i] = intervals[i][0]
+    ends[i] = intervals[i][1]
+  }
+  starts.sort((a, b) => a - b)
+  ends.sort((a, b) => a - b)
+  let rooms = 0
+  let endsItr = 0
+  for (let i = 0, l = starts.length; i < l; i++) {
+    if (starts[i] < ends[endsItr]) rooms++
+    else endsItr++
+  }
+  return rooms
+}

From 1fd18e555cdcd45b16f81ecfda479e4319e3a858 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 13:30:30 +0800
Subject: [PATCH 0126/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index bce25fb3..34fe675b 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -1,3 +1,20 @@
+/**
+
+Given an array of meeting time intervals consisting of
+start and end times [[s1,e1],[s2,e2],...] (si < ei),
+find the minimum number of conference rooms required.
+
+Example 1:
+
+Input: [[0, 30],[5, 10],[15, 20]]
+Output: 2
+Example 2:
+
+Input: [[7,10],[2,4]]
+Output: 1
+ 
+ */
+
 /**
  * @param {number[][]} intervals
  * @return {number}

From 4889881f893468e612a37ed9876cde17b6595c2c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 13:32:12 +0800
Subject: [PATCH 0127/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index 34fe675b..8215f354 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -31,7 +31,7 @@ const minMeetingRooms = function(intervals) {
   ends.sort((a, b) => a - b)
   let rooms = 0
   let endsItr = 0
-  for (let i = 0, l = starts.length; i < l; i++) {
+  for (let i = 0; i < len; i++) {
     if (starts[i] < ends[endsItr]) rooms++
     else endsItr++
   }

From 7929c3335a0f65d9c4c759cb48d834bc1c929b48 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 15:10:53 +0800
Subject: [PATCH 0128/3374] Create .keep

---
 images/.keep | 1 +
 1 file changed, 1 insertion(+)
 create mode 100644 images/.keep

diff --git a/images/.keep b/images/.keep
new file mode 100644
index 00000000..8b137891
--- /dev/null
+++ b/images/.keep
@@ -0,0 +1 @@
+

From af102a93343266eaebc4d495fe3eb39298d01c9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 15:13:04 +0800
Subject: [PATCH 0129/3374] Add files via upload

---
 images/meeting-room-ii-0.jpg | Bin 0 -> 358495 bytes
 images/meeting-room-ii-1.jpg | Bin 0 -> 603179 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/meeting-room-ii-0.jpg
 create mode 100644 images/meeting-room-ii-1.jpg

diff --git a/images/meeting-room-ii-0.jpg b/images/meeting-room-ii-0.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..65dae20e7fd2c107b8a455feea8c048e3b58b169
GIT binary patch
literal 358495
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%0Dp-u
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%0DpreVXx!!=2C7rb+K4{Qj^r%^f+gMod
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

literal 0
HcmV?d00001

diff --git a/images/meeting-room-ii-1.jpg b/images/meeting-room-ii-1.jpg
new file mode 100644
index 0000000000000000000000000000000000000000..881687fb64ca68c35733e20bbb2ca000c47893bf
GIT binary patch
literal 603179
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%0DrynDvRsD5!=-smnr(drh
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

literal 0
HcmV?d00001


From 3319d56a9037940a2a08d79735a5d7e80dcc49a9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2019 15:53:10 +0800
Subject: [PATCH 0130/3374] Create meeting-room-ii.md

---
 detailed/meeting-room-ii.md | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 detailed/meeting-room-ii.md

diff --git a/detailed/meeting-room-ii.md b/detailed/meeting-room-ii.md
new file mode 100644
index 00000000..10342eb3
--- /dev/null
+++ b/detailed/meeting-room-ii.md
@@ -0,0 +1,27 @@
+![alt text](https://github.com/everthis/leetcode-js/blob/master/images/meeting-room-ii-0.jpg "meeting-room-ii")
+![alt text](https://github.com/everthis/leetcode-js/blob/master/images/meeting-room-ii-1.jpg "meeting-room-ii")
+
+```javascript
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  const len = intervals.length
+  const starts = new Array(len)
+  const ends = new Array(len)
+  for (let i = 0; i < len; i++) {
+    starts[i] = intervals[i][0]
+    ends[i] = intervals[i][1]
+  }
+  starts.sort((a, b) => a - b)
+  ends.sort((a, b) => a - b)
+  let rooms = 0
+  let endsIdx = 0
+  for (let i = 0; i < len; i++) {
+    if (starts[i] < ends[endsIdx]) rooms++
+    else endsIdx++
+  }
+  return rooms
+}
+```

From 290660d48d4c37dba71ddd889e93e57d4365b7e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Nov 2019 09:44:55 +0800
Subject: [PATCH 0131/3374] Create 336-palindrome-pairs.js

---
 336-palindrome-pairs.js | 51 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 336-palindrome-pairs.js

diff --git a/336-palindrome-pairs.js b/336-palindrome-pairs.js
new file mode 100644
index 00000000..2237d086
--- /dev/null
+++ b/336-palindrome-pairs.js
@@ -0,0 +1,51 @@
+const reverseStr = s => {
+  let str = ''
+  for (let i = 0; i < s.length; i++) {
+    str = s[i] + str
+  }
+  return str
+}
+const isPalindrome = str => {
+  for (let i = 0; i < str.length / 2; i++) {
+    if (str[i] !== str[str.length - 1 - i]) return false
+  }
+  return true
+}
+/**
+ * @param {string[]} words
+ * @return {number[][]}
+ */
+const palindromePairs = function(words) {
+  const map = new Map()
+  words.forEach((word, idx) => map.set(word, idx))
+  const result = []
+  if (map.has('')) {
+    const idx = map.get('')
+    words.forEach((word, i) => {
+      if (i !== idx && isPalindrome(word)) {
+        result.push([idx, map.get(word)])
+        result.push([map.get(word), idx])
+      }
+    })
+  }
+  map.delete('')
+  words.forEach((word, idx) => {
+    for (let i = 0; i < word.length; i++) {
+      const left = word.slice(0, i)
+      const right = word.slice(i)
+      if (isPalindrome(left)) {
+        const reversedRight = reverseStr(right)
+        if (map.has(reversedRight) && map.get(reversedRight) !== idx) {
+          result.push([map.get(reversedRight), idx])
+        }
+      }
+      if (isPalindrome(right)) {
+        const reversedLeft = reverseStr(left)
+        if (map.has(reversedLeft) && map.get(reversedLeft) !== idx) {
+          result.push([idx, map.get(reversedLeft)])
+        }
+      }
+    }
+  })
+  return result
+}

From 3b77f63e7a0d175b02919c40242703c71bd200a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Nov 2019 10:54:45 +0800
Subject: [PATCH 0132/3374] Update 336-palindrome-pairs.js

---
 336-palindrome-pairs.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/336-palindrome-pairs.js b/336-palindrome-pairs.js
index 2237d086..c1c64142 100644
--- a/336-palindrome-pairs.js
+++ b/336-palindrome-pairs.js
@@ -1,3 +1,21 @@
+/**
+
+Given a list of unique words, find all pairs of distinct indices (i, j) in the given list,
+so that the concatenation of the two words, i.e. words[i] + words[j] is a palindrome.
+
+Example 1:
+
+Input: ["abcd","dcba","lls","s","sssll"]
+Output: [[0,1],[1,0],[3,2],[2,4]] 
+Explanation: The palindromes are ["dcbaabcd","abcddcba","slls","llssssll"]
+Example 2:
+
+Input: ["bat","tab","cat"]
+Output: [[0,1],[1,0]] 
+Explanation: The palindromes are ["battab","tabbat"]
+
+*/
+
 const reverseStr = s => {
   let str = ''
   for (let i = 0; i < s.length; i++) {

From 692d23b7dcf6a9acffd409f3cad50e0b1fd84b6a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Nov 2019 10:47:05 +0800
Subject: [PATCH 0133/3374] Update 336-palindrome-pairs.js

---
 336-palindrome-pairs.js | 59 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/336-palindrome-pairs.js b/336-palindrome-pairs.js
index c1c64142..e640f6d1 100644
--- a/336-palindrome-pairs.js
+++ b/336-palindrome-pairs.js
@@ -16,6 +16,65 @@ Explanation: The palindromes are ["battab","tabbat"]
 
 */
 
+/**
+ * @param {string[]} words
+ * @return {number[][]}
+ */
+const palindromePairs = function(words) {
+  const root = new Trie();
+  const pairs = [];
+  words.forEach((word, index) => addWord(word, index, root));
+  words.forEach((word, index) => searchWord(word, index, root, pairs));
+  return pairs;
+};
+
+const addWord = (word, wordIndex, root) => { 
+  const length = word.length;
+  let curr = root;
+  for (let i = length - 1; i >= 0; i--) {
+    let char = word.charAt(i);
+    if (!curr.children[char]) curr.children[char] = new Trie();
+    if (isPalindrome(0, i, word)) curr.words.push(wordIndex);
+    curr = curr.children[char];
+  }
+  curr.wordIndex = wordIndex;
+  curr.words.push(wordIndex);
+}
+
+const searchWord = (word, wordIndex, root, pairs) => {
+  const length = word.length;
+  let curr = root;
+  for (let i = 0; i < length; i++) {
+    let char = word.charAt(i);
+    if (curr.wordIndex >= 0 && curr.wordIndex !== wordIndex && isPalindrome(i, length - 1, word)) {
+      pairs.push([wordIndex, curr.wordIndex]);
+    }
+    curr = curr.children[char];
+    if (!curr) return;
+  }
+  
+  curr.words.forEach((suffix) => {
+    if (suffix !== wordIndex) pairs.push([wordIndex, suffix]);
+  })
+}
+
+const isPalindrome = (left, right, word) => {
+  while (left < right) {
+    if (word.charAt(left++) !== word.charAt(right--)) return false;
+  }
+  return true;
+}
+
+class Trie {
+  constructor() {
+    this.wordIndex = -1;
+    this.children = {};
+    this.words = [];
+  }
+}
+
+// another
+
 const reverseStr = s => {
   let str = ''
   for (let i = 0; i < s.length; i++) {

From 7229de5b6f758174efc00e2923ebaa76f27c6eaa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Nov 2019 12:20:12 +0800
Subject: [PATCH 0134/3374] Create 269-alien-dictionary.js

---
 269-alien-dictionary.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 269-alien-dictionary.js

diff --git a/269-alien-dictionary.js b/269-alien-dictionary.js
new file mode 100644
index 00000000..11858ade
--- /dev/null
+++ b/269-alien-dictionary.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+const alienOrder = function(words) {
+  const graph = {}
+  words.forEach(w => w.split('').forEach(ch => (graph[ch] = new Set())))
+  words.reduce((prev, curr) => {
+    for (let i = 0; i < Math.min(prev.length, curr.length); i++) {
+      if (prev[i] !== curr[i]) {
+        graph[prev[i]].add(curr[i])
+        break
+      }
+    }
+    return curr
+  })
+  const marked = {},
+    visited = {}
+  let str = ''
+  let hasCycle = false
+  Object.keys(graph).map(visit)
+  return hasCycle ? '' : str
+  function visit(n) {
+    if (marked[n]) return
+    if (visited[n]) {
+      hasCycle = true
+      return
+    }
+    visited[n] = true
+    graph[n].forEach(visit)
+    marked[n] = true
+    str = n + str
+  }
+}

From eda026fe23f810c8375d656b2e76561d8bccca02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Nov 2019 12:21:50 +0800
Subject: [PATCH 0135/3374] Update 269-alien-dictionary.js

---
 269-alien-dictionary.js | 50 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/269-alien-dictionary.js b/269-alien-dictionary.js
index 11858ade..dcc879a9 100644
--- a/269-alien-dictionary.js
+++ b/269-alien-dictionary.js
@@ -1,3 +1,53 @@
+/**
+
+There is a new alien language which uses the latin alphabet. 
+However, the order among letters are unknown to you. 
+You receive a list of non-empty words from the dictionary, 
+where words are sorted lexicographically by the rules of
+this new language. Derive the order of letters in this language.
+
+Example 1:
+
+Input:
+[
+  "wrt",
+  "wrf",
+  "er",
+  "ett",
+  "rftt"
+]
+
+Output: "wertf"
+Example 2:
+
+Input:
+[
+  "z",
+  "x"
+]
+
+Output: "zx"
+Example 3:
+
+Input:
+[
+  "z",
+  "x",
+  "z"
+] 
+
+Output: "" 
+
+Explanation: The order is invalid, so return "".
+Note:
+
+You may assume all letters are in lowercase.
+You may assume that if a is a prefix of b, then a must appear before b in the given dictionary.
+If the order is invalid, return an empty string.
+There may be multiple valid order of letters, return any one of them is fine.
+
+*/
+
 /**
  * @param {string[]} words
  * @return {string}

From da64ed842a5081830cb3d31887bff059245b524d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Dec 2019 15:22:20 +0800
Subject: [PATCH 0136/3374] Create 1181-before-and-after-puzzle.js

---
 1181-before-and-after-puzzle.js | 71 +++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 1181-before-and-after-puzzle.js

diff --git a/1181-before-and-after-puzzle.js b/1181-before-and-after-puzzle.js
new file mode 100644
index 00000000..211eeef9
--- /dev/null
+++ b/1181-before-and-after-puzzle.js
@@ -0,0 +1,71 @@
+/**
+
+Given a list of phrases, generate a list of Before and After puzzles.
+
+A phrase is a string that consists of lowercase English letters and spaces only.
+No space appears in the start or the end of a phrase. There are no consecutive spaces in a phrase.
+Before and After puzzles are phrases that are formed by merging two phrases where the last word of
+the first phrase is the same as the first word of the second phrase.
+Return the Before and After puzzles that can be formed by every two phrases phrases[i] and
+phrases[j] where i != j. Note that the order of matching two phrases matters,
+we want to consider both orders.
+
+You should return a list of distinct strings sorted lexicographically.
+
+Example 1:
+
+Input: phrases = ["writing code","code rocks"]
+Output: ["writing code rocks"]
+Example 2:
+
+Input: phrases = ["mission statement",
+                  "a quick bite to eat",
+                  "a chip off the old block",
+                  "chocolate bar",
+                  "mission impossible",
+                  "a man on a mission",
+                  "block party",
+                  "eat my words",
+                  "bar of soap"]
+Output: ["a chip off the old block party",
+         "a man on a mission impossible",
+         "a man on a mission statement",
+         "a quick bite to eat my words",
+         "chocolate bar of soap"]
+Example 3:
+
+Input: phrases = ["a","b","a"]
+Output: ["a"]
+
+Constraints:
+
+1 <= phrases.length <= 100
+1 <= phrases[i].length <= 100
+
+*/
+
+/**
+ * @param {string[]} phrases
+ * @return {string[]}
+ */
+const beforeAndAfterPuzzles = function(phrases) {
+  const ret = new Set()
+  const start = {}
+  const splitArr = phrases.map(el => el.split(' '))
+  for (let i = 0; i < splitArr.length; i++) {
+    const firstWord = splitArr[i][0]
+    start[firstWord] = start[firstWord] || []
+    start[firstWord].push(i)
+  }
+  for (let i = 0; i < splitArr.length; i++) {
+    const lastWord = splitArr[i][splitArr[i].length - 1]
+    if (start[lastWord]) {
+      for (let idx of start[lastWord]) {
+        if (idx !== i) {
+          ret.add(splitArr[i].concat(splitArr[idx].slice(1)).join(' '))
+        }
+      }
+    }
+  }
+  return [...ret].sort()
+}

From 5ae232e7e5cc7bcd2cf5d905c21d00e959b61c23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Dec 2019 10:53:10 +0800
Subject: [PATCH 0137/3374] Create 741-cherry-pickup.js

---
 741-cherry-pickup.js | 66 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 741-cherry-pickup.js

diff --git a/741-cherry-pickup.js b/741-cherry-pickup.js
new file mode 100644
index 00000000..7bb78790
--- /dev/null
+++ b/741-cherry-pickup.js
@@ -0,0 +1,66 @@
+/**
+
+In a N x N grid representing a field of cherries, each cell is one of three possible integers.
+
+0 means the cell is empty, so you can pass through;
+1 means the cell contains a cherry, that you can pick up and pass through;
+-1 means the cell contains a thorn that blocks your way.
+ 
+Your task is to collect maximum number of cherries possible by following the rules below:
+
+Starting at the position (0, 0) and reaching (N-1, N-1) by moving right or down through valid
+path cells (cells with value 0 or 1);
+After reaching (N-1, N-1), returning to (0, 0) by moving left or up through valid path cells;
+When passing through a path cell containing a cherry, you pick it up and the cell becomes an empty cell (0);
+If there is no valid path between (0, 0) and (N-1, N-1), then no cherries can be collected.
+
+Example 1:
+
+Input: grid =
+[[0, 1, -1],
+ [1, 0, -1],
+ [1, 1,  1]]
+Output: 5
+Explanation: 
+The player started at (0, 0) and went down, down, right right to reach (2, 2).
+4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]].
+Then, the player went left, up, up, left to return home, picking up one more cherry.
+The total number of cherries picked up is 5, and this is the maximum possible.
+
+Note:
+
+grid is an N by N 2D array, with 1 <= N <= 50.
+Each grid[i][j] is an integer in the set {-1, 0, 1}.
+It is guaranteed that grid[0][0] and grid[N-1][N-1] are not -1.
+
+*/
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const cherryPickup = grid => {
+  const n = grid.length
+  const dp = [...new Array(n)].map(() =>
+    [...new Array(n)].map(() => Array(n).fill(-Infinity))
+  )
+  dp[0][0][0] = grid[0][0]
+  const go = (x1, y1, x2) => {
+    const y2 = x1 + y1 - x2
+    if (x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0) return -1
+    if (grid[y1][x1] === -1 || grid[y2][x2] === -1) return -1
+    if (dp[y1][x1][x2] !== -Infinity) return dp[y1][x1][x2]
+    dp[y1][x1][x2] = Math.max(
+      go(x1 - 1, y1, x2 - 1),
+      go(x1, y1 - 1, x2),
+      go(x1, y1 - 1, x2 - 1),
+      go(x1 - 1, y1, x2)
+    )
+    if (dp[y1][x1][x2] >= 0) {
+      dp[y1][x1][x2] += grid[y1][x1]
+      if (x1 !== x2) dp[y1][x1][x2] += grid[y2][x2]
+    }
+    return dp[y1][x1][x2]
+  }
+  return Math.max(0, go(n - 1, n - 1, n - 1))
+}

From 4786e84fa880b13011142623c229b53880842b8a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Dec 2019 13:09:45 +0800
Subject: [PATCH 0138/3374] Create 759-employee-free-time.js

---
 759-employee-free-time.js | 69 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 759-employee-free-time.js

diff --git a/759-employee-free-time.js b/759-employee-free-time.js
new file mode 100644
index 00000000..cffe2434
--- /dev/null
+++ b/759-employee-free-time.js
@@ -0,0 +1,69 @@
+/**
+
+We are given a list schedule of employees, which represents the working time for each employee.
+
+Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.
+
+Return the list of finite intervals representing common, positive-length free time for all employees,
+also in sorted order.
+
+(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals,
+not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2,
+and schedule[0][0][0] is not defined).  Also, we wouldn't include intervals like [5, 5] in our answer,
+as they have zero length.
+
+Example 1:
+
+Input: schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]]
+Output: [[3,4]]
+Explanation: There are a total of three employees, and all common
+free time intervals would be [-inf, 1], [3, 4], [10, inf].
+We discard any intervals that contain inf as they aren't finite.
+Example 2:
+
+Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]
+Output: [[5,6],[7,9]]
+
+Constraints:
+
+1 <= schedule.length , schedule[i].length <= 50
+0 <= schedule[i].start < schedule[i].end <= 10^8
+
+*/
+
+
+/**
+ * // Definition for an Interval.
+ * function Interval(start, end) {
+ *    this.start = start;
+ *    this.end = end;
+ * };
+ */
+/**
+ * @param {Interval[][]} schedule
+ * @return {Interval[]}
+ */
+const employeeFreeTime = function(schedule) {
+  schedule = [].concat(...schedule)
+  schedule.sort((a, b) => a.start - b.start)
+  const intervals = [schedule[0]]
+  for (let i = 1; i < schedule.length; i++) {
+    const prev = intervals.pop()
+    const current = schedule[i]
+    if (prev.end >= current.start) {
+      const start = Math.min(prev.start, current.start)
+      const end = Math.max(prev.end, current.end)
+      intervals.push(new Interval(start, end))
+    } else {
+      intervals.push(prev)
+      intervals.push(current)
+    }
+  }
+  const result = []
+  for (let i = 1; i < intervals.length; i++) {
+    const prev = intervals[i - 1]
+    const current = intervals[i]
+    result.push(new Interval(prev.end, current.start))
+  }
+  return result
+}

From 05cdffe90390248a46122b8fb6eb629848d6b2ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Dec 2019 16:28:34 +0800
Subject: [PATCH 0139/3374] Update 759-employee-free-time.js

---
 759-employee-free-time.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/759-employee-free-time.js b/759-employee-free-time.js
index cffe2434..c3600a22 100644
--- a/759-employee-free-time.js
+++ b/759-employee-free-time.js
@@ -67,3 +67,25 @@ const employeeFreeTime = function(schedule) {
   }
   return result
 }
+
+// another
+
+const employeeFreeTime = function(schedule) {
+  const intervals = []
+  schedule.forEach(s => s.forEach(t => intervals.push(t)))
+  intervals.sort((a, b) =>
+    a.start !== b.start ? a.start - b.start : a.end - b.end
+  )
+  let i1 = intervals[0]
+  const res = []
+  for (let interval of intervals.slice(1)) {
+    let i2 = interval
+    if (i1.end >= i2.start) {
+      i1.end = Math.max(i1.end, i2.end)
+    } else {
+      res.push(new Interval(i1.end, i2.start))
+      i1 = i2
+    }
+  }
+  return res
+}

From fb4f3eae4d628e4a29f41eb9a2f41ba22fa56dff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Dec 2019 10:47:03 +0800
Subject: [PATCH 0140/3374] Update 759-employee-free-time.js

---
 759-employee-free-time.js | 62 +++++++++++++++++++++++++++------------
 1 file changed, 43 insertions(+), 19 deletions(-)

diff --git a/759-employee-free-time.js b/759-employee-free-time.js
index c3600a22..401a5d9f 100644
--- a/759-employee-free-time.js
+++ b/759-employee-free-time.js
@@ -39,35 +39,59 @@ Constraints:
  *    this.end = end;
  * };
  */
+/**
+ * // Definition for an Interval.
+ * function Interval(start, end) {
+ *    this.start = start;
+ *    this.end = end;
+ * };
+ */
+
 /**
  * @param {Interval[][]} schedule
  * @return {Interval[]}
  */
 const employeeFreeTime = function(schedule) {
-  schedule = [].concat(...schedule)
-  schedule.sort((a, b) => a.start - b.start)
-  const intervals = [schedule[0]]
-  for (let i = 1; i < schedule.length; i++) {
-    const prev = intervals.pop()
-    const current = schedule[i]
-    if (prev.end >= current.start) {
-      const start = Math.min(prev.start, current.start)
-      const end = Math.max(prev.end, current.end)
-      intervals.push(new Interval(start, end))
-    } else {
-      intervals.push(prev)
-      intervals.push(current)
+  const n = schedule.length
+  const time = mergeSort(schedule, 0, n - 1)
+  const free = []
+  let end = time[0].end
+  for(let i = 1; i < time.length; i++) {
+    if(time[i].start > end) {
+      free.push(new Interval(end, time[i].start))
     }
+    end = Math.max(end, time[i].end)
   }
-  const result = []
-  for (let i = 1; i < intervals.length; i++) {
-    const prev = intervals[i - 1]
-    const current = intervals[i]
-    result.push(new Interval(prev.end, current.start))
+  return free
+}
+
+function mergeSort(schedule, l, r) {
+  if(l === r) return schedule[l]
+  const mid = l + ((r - l) >> 1)
+  const left = mergeSort(schedule, l, mid)
+  const right = mergeSort(schedule, mid + 1, r)
+  return merge(left, right)
+}
+
+function merge(A, B) {
+  const res = []
+  const m = A.length, n = B.length
+  let i = 0, j = 0
+  while(i < m || j < n) {
+    if(i === m) {
+      res.push(B[j++])
+    } else if(j === n) {
+      res.push(A[i++])
+    } else if(A[i].start < B[j].start) {
+      res.push(A[i++])
+    } else {
+      res.push(B[j++])
+    }
   }
-  return result
+  return res
 }
 
+
 // another
 
 const employeeFreeTime = function(schedule) {

From 16e7eaebc3cbe01000eeaecde2fc193087368b7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Dec 2019 13:45:45 +0800
Subject: [PATCH 0141/3374] Create 362-design-hit-counter.js

---
 362-design-hit-counter.js | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 362-design-hit-counter.js

diff --git a/362-design-hit-counter.js b/362-design-hit-counter.js
new file mode 100644
index 00000000..9010dec7
--- /dev/null
+++ b/362-design-hit-counter.js
@@ -0,0 +1,50 @@
+/**
+ * Initialize your data structure here.
+ */
+const HitCounter = function() {
+  this.times = []
+  this.hits = []
+}
+
+/**
+ * Record a hit.
+        @param timestamp - The current timestamp (in seconds granularity). 
+ * @param {number} timestamp
+ * @return {void}
+ */
+HitCounter.prototype.hit = function(timestamp) {
+  const idx = timestamp % 300
+  const times = this.times
+  const hits = this.hits
+  if (times[idx] !== timestamp) {
+    times[idx] = timestamp
+    hits[idx] = 1
+  } else {
+    hits[idx]++
+  }
+}
+
+/**
+ * Return the number of hits in the past 5 minutes.
+        @param timestamp - The current timestamp (in seconds granularity). 
+ * @param {number} timestamp
+ * @return {number}
+ */
+HitCounter.prototype.getHits = function(timestamp) {
+  let total = 0
+  const times = this.times
+  const hits = this.hits
+  for (let i = 0; i < 300; i++) {
+    if (timestamp - times[i] < 300) {
+      total += hits[i]
+    }
+  }
+  return total
+}
+
+/**
+ * Your HitCounter object will be instantiated and called as such:
+ * var obj = new HitCounter()
+ * obj.hit(timestamp)
+ * var param_2 = obj.getHits(timestamp)
+ */

From 298a48108741289b93858b94a46c704024640dff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Dec 2019 15:01:27 +0800
Subject: [PATCH 0142/3374] Update 362-design-hit-counter.js

---
 362-design-hit-counter.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/362-design-hit-counter.js b/362-design-hit-counter.js
index 9010dec7..26d21476 100644
--- a/362-design-hit-counter.js
+++ b/362-design-hit-counter.js
@@ -1,3 +1,42 @@
+/**
+
+Design a hit counter which counts the number of hits received in the past 5 minutes.
+Each function accepts a timestamp parameter (in seconds granularity) and you may
+assume that calls are being made to the system in chronological order (ie,
+the timestamp is monotonically increasing). You may assume that the earliest timestamp starts at 1.
+It is possible that several hits arrive roughly at the same time.
+
+Example:
+
+HitCounter counter = new HitCounter();
+
+// hit at timestamp 1.
+counter.hit(1);
+
+// hit at timestamp 2.
+counter.hit(2);
+
+// hit at timestamp 3.
+counter.hit(3);
+
+// get hits at timestamp 4, should return 3.
+counter.getHits(4);
+
+// hit at timestamp 300.
+counter.hit(300);
+
+// get hits at timestamp 300, should return 4.
+counter.getHits(300);
+
+// get hits at timestamp 301, should return 3.
+counter.getHits(301); 
+
+Follow up:
+What if the number of hits per second could be very large? Does your design scale?
+
+*/
+
+
 /**
  * Initialize your data structure here.
  */

From 1111001b55ea4f5d5648aaaca6cd89fc61ee3cfc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 11:15:11 +0800
Subject: [PATCH 0143/3374] Create
 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js

---
 ...earch-tree-to-sorted-doubly-linked-list.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js

diff --git a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
new file mode 100644
index 00000000..f3d77ac0
--- /dev/null
+++ b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
@@ -0,0 +1,30 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, left, right) {
+ *      this.val = val;
+ *      this.left = left;
+ *      this.right = right;
+ *  };
+ */
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+const treeToDoublyList = function(root) {
+  let head = null, tail = null;
+  const helper = (node) => {
+    if(!node) return;
+    helper(node.left);
+    if(!head) head = node;
+    if(tail) tail.right = node;
+    node.left = tail;
+    tail = node;
+    helper(node.right);
+  };
+  helper(root);
+  if(head) {
+    head.left = tail;
+    tail.right = head;
+  }
+  return head;
+};

From 3244416197cc8197b84eda960770af0a3c02bbdd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 13:57:48 +0800
Subject: [PATCH 0144/3374] Update
 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js

---
 ...earch-tree-to-sorted-doubly-linked-list.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
index f3d77ac0..a34b1a15 100644
--- a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
+++ b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
@@ -28,3 +28,36 @@ const treeToDoublyList = function(root) {
   }
   return head;
 };
+
+// another
+
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+const treeToDoublyList = function(root) {
+  if(root == null) return null
+  let cur = root
+  let start = root
+  while(start.left !== null) {
+    start = start.left
+  }
+  let prev = null
+  const stack = []
+  while(stack.length !== 0 || cur !== null) {
+    while(cur !== null) {
+      stack.push(cur)
+      cur = cur.left
+    }
+    cur = stack.pop()
+    if(prev !== null) {
+      prev.right = cur
+      cur.left = prev
+    }
+    prev = cur
+    cur = cur.right
+  }
+  start.left = prev
+  prev.right = start
+  return start
+};

From 7253dbd1922cd5ed10369e262bad9712338c671d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 15:26:03 +0800
Subject: [PATCH 0145/3374] Update
 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js

---
 ...earch-tree-to-sorted-doubly-linked-list.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
index a34b1a15..7627f34c 100644
--- a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
+++ b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
@@ -31,6 +31,35 @@ const treeToDoublyList = function(root) {
 
 // another
 
+/**
+ * @param {Node} root
+ * @return {Node}
+ */
+const treeToDoublyList = function(root) {
+  if(root === null) return null
+  const left = treeToDoublyList(root.left)
+  const right = treeToDoublyList(root.right)
+  root.left = root
+  root.right = root
+  return connect(connect(left, root), right)
+};
+
+function connect(n1, n2) {
+  if(n1 === null) return n2
+  if(n2 === null) return n1
+  const t1 = n1.left
+  const t2 = n2.left
+
+  t1.right = n2
+  n2.left = t1
+  t2.right = n1
+  n1.left = t2
+
+  return n1
+}
+
+// another
+
 /**
  * @param {Node} root
  * @return {Node}

From 29f974f26161ea827a0d891be1185f2296ecd98c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 15:41:52 +0800
Subject: [PATCH 0146/3374] Update
 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js

---
 426-convert-binary-search-tree-to-sorted-doubly-linked-list.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
index 7627f34c..a75ad8a8 100644
--- a/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
+++ b/426-convert-binary-search-tree-to-sorted-doubly-linked-list.js
@@ -44,6 +44,7 @@ const treeToDoublyList = function(root) {
   return connect(connect(left, root), right)
 };
 
+// n1 is the head of circular DLL as well as n2
 function connect(n1, n2) {
   if(n1 === null) return n2
   if(n2 === null) return n1

From e26609f3a0e419f00fa045028ec6195bbb39e1af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 17:41:19 +0800
Subject: [PATCH 0147/3374] Create 716-max-stack.js

---
 716-max-stack.js | 64 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 716-max-stack.js

diff --git a/716-max-stack.js b/716-max-stack.js
new file mode 100644
index 00000000..bdc90cd7
--- /dev/null
+++ b/716-max-stack.js
@@ -0,0 +1,64 @@
+/**
+ * initialize your data structure here.
+ */
+const MaxStack = function() {
+  this.stack = []
+}
+
+/**
+ * @param {number} x
+ * @return {void}
+ */
+MaxStack.prototype.push = function(x) {
+  this.stack.push(x)
+}
+
+/**
+ * @return {number}
+ */
+MaxStack.prototype.pop = function() {
+  return this.stack.pop()
+}
+
+/**
+ * @return {number}
+ */
+MaxStack.prototype.top = function() {
+  return this.stack[this.stack.length - 1]
+}
+
+/**
+ * @return {number}
+ */
+MaxStack.prototype.peekMax = function() {
+  return Math.max(...this.stack)
+}
+
+/**
+ * @return {number}
+ */
+MaxStack.prototype.popMax = function() {
+  let max = Number.MIN_SAFE_INTEGER
+  let k = 0
+  if (this.stack.length == 1) {
+    return this.stack.pop()
+  }
+  for (let i = 0; i < this.stack.length; i++) {
+    if (max <= this.stack[i]) {
+      max = this.stack[i]
+      k = i
+    }
+  }
+  this.stack.splice(k, 1)
+  return max
+}
+
+/**
+ * Your MaxStack object will be instantiated and called as such:
+ * var obj = new MaxStack()
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.peekMax()
+ * var param_5 = obj.popMax()
+ */

From 66b517c841998d9fa85b644ce101a9c30717b2cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2019 17:44:40 +0800
Subject: [PATCH 0148/3374] Update 716-max-stack.js

---
 716-max-stack.js | 16 +++-------------
 1 file changed, 3 insertions(+), 13 deletions(-)

diff --git a/716-max-stack.js b/716-max-stack.js
index bdc90cd7..5fbe1b18 100644
--- a/716-max-stack.js
+++ b/716-max-stack.js
@@ -38,19 +38,9 @@ MaxStack.prototype.peekMax = function() {
  * @return {number}
  */
 MaxStack.prototype.popMax = function() {
-  let max = Number.MIN_SAFE_INTEGER
-  let k = 0
-  if (this.stack.length == 1) {
-    return this.stack.pop()
-  }
-  for (let i = 0; i < this.stack.length; i++) {
-    if (max <= this.stack[i]) {
-      max = this.stack[i]
-      k = i
-    }
-  }
-  this.stack.splice(k, 1)
-  return max
+  const elem = Math.max(...this.stack)
+  const index = this.stack.lastIndexOf(elem)
+  return this.stack.splice(index, 1)[0]
 }
 
 /**

From 1c5258c1f45c409203fa0f004fa88fde1e6e795e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Dec 2019 13:47:27 +0800
Subject: [PATCH 0149/3374] Create 314-binary-tree-vertical-order-traversal.js

---
 314-binary-tree-vertical-order-traversal.js | 122 ++++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 314-binary-tree-vertical-order-traversal.js

diff --git a/314-binary-tree-vertical-order-traversal.js b/314-binary-tree-vertical-order-traversal.js
new file mode 100644
index 00000000..7432db06
--- /dev/null
+++ b/314-binary-tree-vertical-order-traversal.js
@@ -0,0 +1,122 @@
+/**
+
+Given a binary tree, return the vertical order traversal of its
+nodes' values. (ie, from top to bottom, column by column).
+
+If two nodes are in the same row and column, the order
+should be from left to right.
+
+Examples 1:
+
+Input: [3,9,20,null,null,15,7]
+
+   3
+  /\
+ /  \
+ 9  20
+    /\
+   /  \
+  15   7 
+
+Output:
+
+[
+  [9],
+  [3,15],
+  [20],
+  [7]
+]
+
+Examples 2:
+
+Input: [3,9,8,4,0,1,7]
+
+     3
+    /\
+   /  \
+   9   8
+  /\  /\
+ /  \/  \
+ 4  01   7 
+
+Output:
+
+[
+  [4],
+  [9],
+  [3,0,1],
+  [8],
+  [7]
+]
+
+Examples 3:
+
+Input: [3,9,8,4,0,1,7,null,null,null,2,5] (0's right child is 2 and 1's left child is 5)
+
+     3
+    /\
+   /  \
+   9   8
+  /\  /\
+ /  \/  \
+ 4  01   7
+    /\
+   /  \
+   5   2
+
+Output:
+
+[
+  [4],
+  [9,5],
+  [3,0,1],
+  [8,2],
+  [7]
+]
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const verticalOrder = function(root) {
+  const res = []
+  if(root == null) return res
+  const map = new Map()
+  const q = []
+  const cols = []
+  q.push(root)
+  cols.push(0)
+  let min = 0
+  let max = 0
+  while(q.length) {
+    const node = q.shift()
+    const col = cols.shift()
+    if(!map.has(col)) {
+      map.set(col, [])
+    }
+    map.get(col).push(node.val)
+    if(node.left !== null) {
+      q.push(node.left)
+      cols.push(col - 1)
+      min = Math.min(min, col - 1)
+    }
+    if(node.right !== null) {
+      q.push(node.right)
+      cols.push(col + 1)
+      max = Math.max(max, col + 1)
+    }
+  }
+  for(let i = min; i <= max; i++) {
+    res.push(map.get(i))
+  }
+  return res
+};

From cc94ac5e652be54c4b070ea2977f44fc453da0a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Dec 2019 13:50:33 +0800
Subject: [PATCH 0150/3374] Update 314-binary-tree-vertical-order-traversal.js

---
 314-binary-tree-vertical-order-traversal.js | 22 +++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/314-binary-tree-vertical-order-traversal.js b/314-binary-tree-vertical-order-traversal.js
index 7432db06..46123f5d 100644
--- a/314-binary-tree-vertical-order-traversal.js
+++ b/314-binary-tree-vertical-order-traversal.js
@@ -120,3 +120,25 @@ const verticalOrder = function(root) {
   }
   return res
 };
+
+// another
+
+const verticalOrder = function(root) {
+  if (!root) return []
+  let result = []
+  function recurse(root, col, row) {
+    if (!root) return
+    recurse(root.left, col - 1, row + 1)
+    recurse(root.right, col + 1, row + 1)
+    result[col] = result[col] || []
+    result[col][row] = result[col][row] || []
+    result[col][row].push(root.val)
+  }
+
+  recurse(root, 100, 0)
+  return result
+    .filter(x => x)
+    .map(row => row.reduce((acc, val) => acc.concat(val), []))
+}
+
+

From 47633f18f67f1ee8440ac3e3b85cb0a3c6d235cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Dec 2019 15:23:30 +0800
Subject: [PATCH 0151/3374] Create 256-paint-house.js

---
 256-paint-house.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 256-paint-house.js

diff --git a/256-paint-house.js b/256-paint-house.js
new file mode 100644
index 00000000..8ec40906
--- /dev/null
+++ b/256-paint-house.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[][]} costs
+ * @return {number}
+ */
+const minCost = function(costs) {
+  if (!costs || costs.length < 1) return 0
+  const n = costs.length
+  for (let i = 1; i < n; i++) {
+    const c = costs[i],
+      cPrev = costs[i - 1]
+    c[0] += Math.min(cPrev[1], cPrev[2])
+    c[1] += Math.min(cPrev[0], cPrev[2])
+    c[2] += Math.min(cPrev[0], cPrev[1])
+  }
+  const cLast = costs[n - 1]
+  return Math.min(cLast[0], cLast[1], cLast[2])
+}

From cde9e07c2be5e0a3d78b37a34e1360767767a662 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2019 10:00:53 +0800
Subject: [PATCH 0152/3374] Create 277-find-the-celebrity.js

---
 277-find-the-celebrity.js | 41 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 277-find-the-celebrity.js

diff --git a/277-find-the-celebrity.js b/277-find-the-celebrity.js
new file mode 100644
index 00000000..4ffe9d48
--- /dev/null
+++ b/277-find-the-celebrity.js
@@ -0,0 +1,41 @@
+/**
+ * Definition for knows()
+ *
+ * @param {integer} person a
+ * @param {integer} person b
+ * @return {boolean} whether a knows b
+ * knows = function(a, b) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} knows()
+ * @return {function}
+ */
+const solution = function(knows) {
+  /**
+   * @param {integer} n Total people
+   * @return {integer} The celebrity
+   */
+  return function(n) {
+    if (n < 1) return -1
+    let celebrity = 0
+    for (let i = 1; i < n; i++) {
+      if (knows(celebrity, i)) {
+        celebrity = i
+      }
+    }
+    for (let i = 0; i < celebrity; i++) {
+      if (knows(celebrity, i)) {
+        return -1
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      if (i != celebrity && !knows(i, celebrity)) {
+        return -1
+      }
+    }
+    return celebrity
+  }
+}

From 62abef22e2d306c82281d8a1a9e2113d6bbbef5a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2019 12:29:37 +0800
Subject: [PATCH 0153/3374] Update 277-find-the-celebrity.js

---
 277-find-the-celebrity.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/277-find-the-celebrity.js b/277-find-the-celebrity.js
index 4ffe9d48..c37e8bdd 100644
--- a/277-find-the-celebrity.js
+++ b/277-find-the-celebrity.js
@@ -39,3 +39,41 @@ const solution = function(knows) {
     return celebrity
   }
 }
+
+// another
+
+/**
+ * Definition for knows()
+ *
+ * @param {integer} person a
+ * @param {integer} person b
+ * @return {boolean} whether a knows b
+ * knows = function(a, b) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} knows()
+ * @return {function}
+ */
+const solution = function(knows) {
+  /**
+   * @param {integer} n Total people
+   * @return {integer} The celebrity
+   */
+  return function(n) {
+    if (n < 1) return -1
+    let candidate = 0
+    for (let i = 1; i < n; i++) {
+      if (knows(candidate, i)) candidate = i
+    }
+    for (let i = 0; i < n; i++) {
+      if (i < candidate && (knows(candidate, i) || !knows(i, candidate)))
+        return -1
+      if (i > candidate && !knows(i, candidate)) return -1
+    }
+    return candidate
+  }
+}
+

From 6bf473bb976a5fa56a0013822e63dee9f0c6f73f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2019 16:09:35 +0800
Subject: [PATCH 0154/3374] Create 1060-missing-element-in-sorted-array.js

---
 1060-missing-element-in-sorted-array.js | 48 +++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 1060-missing-element-in-sorted-array.js

diff --git a/1060-missing-element-in-sorted-array.js b/1060-missing-element-in-sorted-array.js
new file mode 100644
index 00000000..93b19459
--- /dev/null
+++ b/1060-missing-element-in-sorted-array.js
@@ -0,0 +1,48 @@
+/**
+
+Given a sorted array A of unique numbers, find the K-th missing number
+starting from the leftmost number of the array.
+
+Example 1:
+
+Input: A = [4,7,9,10], K = 1
+Output: 5
+Explanation: 
+The first missing number is 5.
+Example 2:
+
+Input: A = [4,7,9,10], K = 3
+Output: 8
+Explanation: 
+The missing numbers are [5,6,8,...], hence the third missing number is 8.
+Example 3:
+
+Input: A = [1,2,4], K = 3
+Output: 6
+Explanation: 
+The missing numbers are [3,5,6,7,...], hence the third missing number is 6.
+ 
+Note:
+
+1 <= A.length <= 50000
+1 <= A[i] <= 1e7
+1 <= K <= 1e8
+
+*/
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const missingElement = function(nums, k) {
+  for (let i = 1, len = nums.length; i < len; i++) {
+    const dif = nums[i] - nums[i - 1] - 1
+    if (dif >= k) {
+      return nums[i - 1] + k
+    }
+    k -= dif
+  }
+  return nums[nums.length - 1] + k
+}

From bb263be134fc9d48610bc0c31dd80abb0efde44a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Dec 2019 09:45:29 +0800
Subject: [PATCH 0155/3374] Update 1060-missing-element-in-sorted-array.js

---
 1060-missing-element-in-sorted-array.js | 29 +++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1060-missing-element-in-sorted-array.js b/1060-missing-element-in-sorted-array.js
index 93b19459..9c0a8c6e 100644
--- a/1060-missing-element-in-sorted-array.js
+++ b/1060-missing-element-in-sorted-array.js
@@ -46,3 +46,32 @@ const missingElement = function(nums, k) {
   }
   return nums[nums.length - 1] + k
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const missingElement = function(nums, k) {
+  const n = nums.length
+  let l = 0
+  let h = n - 1
+  const missingNum = nums[n - 1] - nums[0] + 1 - n
+  if (missingNum < k) {
+    return nums[n - 1] + k - missingNum
+  }
+  while (l < h - 1) {
+    const m = l + ((h - l) >> 1)
+    const missing = nums[m] - nums[l] - (m - l)
+    if (missing >= k) {
+      h = m
+    } else {
+      k -= missing
+      l = m
+    }
+  }
+  return nums[l] + k
+}
+

From 3638104a3cff9cb11bfeb6d96b2a690bcad4c770 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Dec 2019 11:59:28 +0800
Subject: [PATCH 0156/3374] Update 1060-missing-element-in-sorted-array.js

---
 1060-missing-element-in-sorted-array.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1060-missing-element-in-sorted-array.js b/1060-missing-element-in-sorted-array.js
index 9c0a8c6e..a151e66f 100644
--- a/1060-missing-element-in-sorted-array.js
+++ b/1060-missing-element-in-sorted-array.js
@@ -75,3 +75,27 @@ const missingElement = function(nums, k) {
   return nums[l] + k
 }
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const missingElement = function(nums, k) {
+  const n = nums.length
+  if (k > missing(nums, n - 1)) return nums[n - 1] + k - missing(nums, n - 1)
+  let left = 0,
+    right = n - 1,
+    pivot
+  while (left < right) {
+    pivot = left + Math.floor((right - left) / 2)
+    if (missing(nums, pivot) < k) left = pivot + 1
+    else right = pivot
+  }
+  return nums[left - 1] + k - missing(nums, left - 1)
+}
+function missing(arr, idx) {
+  return arr[idx] - arr[0] - idx
+}
+

From 69e63c67616e690af27953efc1d79c1e1d1874a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Dec 2019 14:03:22 +0800
Subject: [PATCH 0157/3374] Create 742-closest-leaf-in-a-binary-tree.js

---
 742-closest-leaf-in-a-binary-tree.js | 104 +++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 742-closest-leaf-in-a-binary-tree.js

diff --git a/742-closest-leaf-in-a-binary-tree.js b/742-closest-leaf-in-a-binary-tree.js
new file mode 100644
index 00000000..c5093fbf
--- /dev/null
+++ b/742-closest-leaf-in-a-binary-tree.js
@@ -0,0 +1,104 @@
+/**
+
+Given a binary tree where every node has a unique value, and a target key k,
+find the value of the nearest leaf node to target k in the tree.
+
+Here, nearest to a leaf means the least number of edges travelled on the binary
+tree to reach any leaf of the tree. Also, a node is called a leaf if it has no children.
+
+In the following examples, the input tree is represented in flattened form
+row by row. The actual root tree given will be a TreeNode object.
+
+Example 1:
+
+Input:
+root = [1, 3, 2], k = 1
+Diagram of binary tree:
+          1
+         / \
+        3   2
+
+Output: 2 (or 3)
+
+Explanation: Either 2 or 3 is the nearest leaf node to the target of 1.
+Example 2:
+
+Input:
+root = [1], k = 1
+Output: 1
+
+Explanation: The nearest leaf node is the root node itself.
+Example 3:
+
+Input:
+root = [1,2,3,4,null,null,null,5,null,6], k = 2
+Diagram of binary tree:
+             1
+            / \
+           2   3
+          /
+         4
+        /
+       5
+      /
+     6
+
+Output: 3
+Explanation: The leaf node with value 3 (and not the leaf node with value 6)
+is nearest to the node with value 2.
+
+Note:
+root represents a binary tree with at least 1 node and at most 1000 nodes.
+Every node has a unique node.val in range [1, 1000].
+There exists some node in the given binary tree for which node.val == k.
+
+*/
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {number}
+ */
+const findClosestLeaf = function(root, k) {
+  if (root == null) return -1
+  const g = new Map()
+  dfs(root, null, g)
+  const q = []
+  for (let [key, value] of g) {
+    if (key.val === k) {
+      q.push(key, ...g.get(key))
+      break
+    }
+  }
+  const s = new Set()
+  while (q.length) {
+    const size = q.length
+    for (let i = 0; i < size; i++) {
+      const node = q.shift()
+      if (node.left === null && node.right === null) return node.val
+      if (!s.has(node)) q.push(...g.get(node))
+      s.add(node)
+    }
+  }
+  return root.val
+}
+
+function dfs(node, parent, g) {
+  if (node == null) return
+  if (g.get(node) == null) g.set(node, new Set())
+  if (parent) {
+    g.get(node).add(parent)
+    if (g.get(parent) == null) g.set(parent, new Set())
+    g.get(parent).add(node)
+  }
+  dfs(node.left, node, g)
+  dfs(node.right, node, g)
+}

From f1d8fbd633f5e690e173cd3be8de7798502291a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Dec 2019 14:09:04 +0800
Subject: [PATCH 0158/3374] Update 742-closest-leaf-in-a-binary-tree.js

---
 742-closest-leaf-in-a-binary-tree.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/742-closest-leaf-in-a-binary-tree.js b/742-closest-leaf-in-a-binary-tree.js
index c5093fbf..8d39ab62 100644
--- a/742-closest-leaf-in-a-binary-tree.js
+++ b/742-closest-leaf-in-a-binary-tree.js
@@ -88,7 +88,6 @@ const findClosestLeaf = function(root, k) {
       s.add(node)
     }
   }
-  return root.val
 }
 
 function dfs(node, parent, g) {

From 14a00ed8aa00cdc323927d91a3d6e1db8add2603 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Dec 2019 09:48:28 +0800
Subject: [PATCH 0159/3374] Create 286-walls-and-gates.js

---
 286-walls-and-gates.js | 60 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 286-walls-and-gates.js

diff --git a/286-walls-and-gates.js b/286-walls-and-gates.js
new file mode 100644
index 00000000..933c9e71
--- /dev/null
+++ b/286-walls-and-gates.js
@@ -0,0 +1,60 @@
+/**
+
+You are given a m x n 2D grid initialized with these three possible values.
+
+-1 - A wall or an obstacle.
+0 - A gate.
+INF - Infinity means an empty room. We use the value 231 - 1 = 2147483647
+to represent INF as you may assume that the distance to a gate
+is less than 2147483647.
+
+Fill each empty room with the distance to its nearest gate.
+If it is impossible to reach a gate, it should be filled with INF.
+
+Example: 
+
+Given the 2D grid:
+
+INF  -1  0  INF
+INF INF INF  -1
+INF  -1 INF  -1
+  0  -1 INF INF
+After running your function, the 2D grid should be:
+
+  3  -1   0   1
+  2   2   1  -1
+  1  -1   2  -1
+  0  -1   3   4
+
+*/
+
+/**
+ * @param {number[][]} rooms
+ * @return {void} Do not return anything, modify rooms in-place instead.
+ */
+const wallsAndGates = function(rooms) {
+  const d = [0, 1, 0, -1, 0];
+  const INF = 2147483647;
+  if (rooms.length == 0) return;
+  const m = rooms.length,
+    n = rooms[0].length;
+  const queue = [];
+  for (let i = 0; i < m; ++i) {
+    for (let j = 0; j < n; ++j) {
+      if (rooms[i][j] == 0) queue.push(i * n + j);
+    }
+  }
+  while (queue.length) {
+    let x = queue.shift();
+    let i = (x / n) >> 0,
+      j = x % n;
+    for (let k = 0; k < 4; k++) {
+      let p = i + d[k],
+        q = j + d[k + 1];
+      if (0 <= p && p < m && 0 <= q && q < n && rooms[p][q] == INF) {
+        rooms[p][q] = rooms[i][j] + 1;
+        queue.push(p * n + q);
+      }
+    }
+  }
+};

From 8b42db89ed23a3aad6c372e9eafd4e147700353c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Dec 2019 10:53:04 +0800
Subject: [PATCH 0160/3374] Update 286-walls-and-gates.js

---
 286-walls-and-gates.js | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/286-walls-and-gates.js b/286-walls-and-gates.js
index 933c9e71..0b7f37ac 100644
--- a/286-walls-and-gates.js
+++ b/286-walls-and-gates.js
@@ -33,28 +33,25 @@ After running your function, the 2D grid should be:
  * @return {void} Do not return anything, modify rooms in-place instead.
  */
 const wallsAndGates = function(rooms) {
-  const d = [0, 1, 0, -1, 0];
-  const INF = 2147483647;
-  if (rooms.length == 0) return;
-  const m = rooms.length,
-    n = rooms[0].length;
-  const queue = [];
-  for (let i = 0; i < m; ++i) {
-    for (let j = 0; j < n; ++j) {
-      if (rooms[i][j] == 0) queue.push(i * n + j);
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  const rows = rooms.length
+  const cols = rows === 0 ? 0 : rooms[0].length
+  const q = []
+  const INF = 2147483647
+  for(let i = 0; i < rows; i++) {
+    for(let j = 0; j < cols; j++) {
+      if(rooms[i][j] === 0) q.push([i, j])
     }
   }
-  while (queue.length) {
-    let x = queue.shift();
-    let i = (x / n) >> 0,
-      j = x % n;
-    for (let k = 0; k < 4; k++) {
-      let p = i + d[k],
-        q = j + d[k + 1];
-      if (0 <= p && p < m && 0 <= q && q < n && rooms[p][q] == INF) {
-        rooms[p][q] = rooms[i][j] + 1;
-        queue.push(p * n + q);
-      }
+  while(q.length) {
+    const el = q.shift()
+    for(let d of dirs) {
+      const r = el[0] + d[0]
+      const c = el[1] + d[1]
+      if(r < 0 || c < 0 || r >= rows || c >= cols || rooms[r][c] !== INF) continue
+      rooms[r][c] = rooms[el[0]][el[1]] + 1
+      q.push([r, c])
     }
   }
 };
+

From 745dd1e0b776e9901d00bdba26e923c78cfc3cd7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Dec 2019 12:05:25 +0800
Subject: [PATCH 0161/3374] Update 286-walls-and-gates.js

---
 286-walls-and-gates.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/286-walls-and-gates.js b/286-walls-and-gates.js
index 0b7f37ac..f0a47019 100644
--- a/286-walls-and-gates.js
+++ b/286-walls-and-gates.js
@@ -55,3 +55,44 @@ const wallsAndGates = function(rooms) {
   }
 };
 
+// another
+
+/**
+ * @param {number[][]} rooms
+ * @return {void} Do not return anything, modify rooms in-place instead.
+ */
+const wallsAndGates = function(rooms) {
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1]
+  ];
+  const rows = rooms.length;
+  const cols = rows === 0 ? 0 : rooms[0].length;
+  const q = [];
+  const INF = 2147483647;
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (rooms[i][j] === 0) dfs(dirs, rooms, i, j, rows, cols, 0);
+    }
+  }
+};
+
+function dfs(dirs, rooms, i, j, rows, cols, dis) {
+  if (
+    i < 0 ||
+    j < 0 ||
+    i >= rows ||
+    j >= cols ||
+    rooms[i][j] === -1 ||
+    rooms[i][j] < dis
+  ) {
+    return;
+  }
+  rooms[i][j] = dis;
+  for (let dir of dirs) {
+    dfs(dirs, rooms, i + dir[0], j + dir[1], rows, cols, dis + 1);
+  }
+}
+

From 4b0c5d11c80b1ea6971f439f7a205ef632e0f729 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Dec 2019 13:44:40 +0800
Subject: [PATCH 0162/3374] Create 1086-high-five.js

---
 1086-high-five.js | 67 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 1086-high-five.js

diff --git a/1086-high-five.js b/1086-high-five.js
new file mode 100644
index 00000000..28a31f5c
--- /dev/null
+++ b/1086-high-five.js
@@ -0,0 +1,67 @@
+/**
+
+Given a list of scores of different students, return the average score
+of each student's top five scores in the order of each student's id.
+
+Each entry items[i] has items[i][0] the student's id, and items[i][1]
+the student's score.  The average score is calculated using integer division.
+
+Example 1:
+
+Input: [[1,91],[1,92],[2,93],[2,97],[1,60],[2,77],[1,65],[1,87],[1,100],[2,100],[2,76]]
+Output: [[1,87],[2,88]]
+Explanation: 
+The average of the student with id = 1 is 87.
+The average of the student with id = 2 is 88.6. But with integer division
+their average converts to 88.
+
+Note:
+
+1 <= items.length <= 1000
+items[i].length == 2
+The IDs of the students is between 1 to 1000
+The score of the students is between 1 to 100
+For each student, there are at least 5 scores
+
+*/
+
+/**
+ * @param {number[][]} items
+ * @return {number[][]}
+ */
+const highFive = function(items) {
+  const m = {}
+  for(let el of items) {
+    const key = '' + el[0]
+    if(!m.hasOwnProperty(key)) m[key] = []
+    add(m[key], el[1])
+  }
+  const res = []
+  Object.entries(m).forEach(el => {
+    res.push([+el[0], div(el[1])])
+  })
+  return res.sort((a, b) => a[0] - b[0])
+};
+
+function div(arr) {
+  let sum = 0
+  arr.forEach(el => sum += el)
+  return sum / 5 >> 0
+}
+
+function add(arr, val) {
+  if(arr.length < 5) arr.push(val)
+  else {
+    let min = Number.MAX_VALUE
+    let idx = -1
+    for(let i = 0, len = arr.length; i < len; i++) {
+      if(arr[i] < min) {
+        min = arr[i]
+        idx = i
+      }
+    }
+    if(val > min && idx !== -1) {
+      arr.splice(idx, 1, val)
+    }
+  }
+}

From 04d8c6daaeed61dec97883a0ab81e48e7bd3785a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 09:55:13 +0800
Subject: [PATCH 0163/3374] Create 250-count-univalue-subtrees.js

---
 250-count-univalue-subtrees.js | 47 ++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 250-count-univalue-subtrees.js

diff --git a/250-count-univalue-subtrees.js b/250-count-univalue-subtrees.js
new file mode 100644
index 00000000..609989cd
--- /dev/null
+++ b/250-count-univalue-subtrees.js
@@ -0,0 +1,47 @@
+/**
+
+Given a binary tree, count the number of uni-value subtrees.
+
+A Uni-value subtree means all nodes of the subtree have the same value.
+
+Example :
+
+Input:  root = [5,1,5,5,5,null,5]
+
+              5
+             / \
+            1   5
+           / \   \
+          5   5   5
+
+Output: 4
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const countUnivalSubtrees = function(root) {
+  let res = { num: 0 }
+  chk(root, null, res)
+  return res.num
+}
+
+function chk(node, pVal, obj) {
+  if (node == null) return true
+  const left = chk(node.left, node.val, obj)
+  const right = chk(node.right, node.val, obj)
+  if (left && right) {
+    obj.num++
+    return pVal == null ? true : pVal === node.val
+  }
+  return false
+}

From b555e31f0e4ad254f320dd784f483f8ee55c536b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 10:06:19 +0800
Subject: [PATCH 0164/3374] Update 250-count-univalue-subtrees.js

---
 250-count-univalue-subtrees.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/250-count-univalue-subtrees.js b/250-count-univalue-subtrees.js
index 609989cd..88a14625 100644
--- a/250-count-univalue-subtrees.js
+++ b/250-count-univalue-subtrees.js
@@ -17,7 +17,6 @@ Input:  root = [5,1,5,5,5,null,5]
 Output: 4
 
 */
-
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {
@@ -40,8 +39,15 @@ function chk(node, pVal, obj) {
   const left = chk(node.left, node.val, obj)
   const right = chk(node.right, node.val, obj)
   if (left && right) {
+    if (node.left !== null && node.val !== node.left.val) {
+      return false;
+    }
+    if (node.right !== null && node.val !== node.right.val) {
+      return false;
+    }
     obj.num++
-    return pVal == null ? true : pVal === node.val
+    return true
   }
   return false
 }
+

From 000ec43981834426d8d9ae55a3a20bcdea8c11d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 11:22:16 +0800
Subject: [PATCH 0165/3374] Create 272-closest-binary-search-tree-value-ii.js

---
 272-closest-binary-search-tree-value-ii.js | 64 ++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 272-closest-binary-search-tree-value-ii.js

diff --git a/272-closest-binary-search-tree-value-ii.js b/272-closest-binary-search-tree-value-ii.js
new file mode 100644
index 00000000..9573ea85
--- /dev/null
+++ b/272-closest-binary-search-tree-value-ii.js
@@ -0,0 +1,64 @@
+/**
+
+Given a non-empty binary search tree and a target value,
+find k values in the BST that are closest to the target.
+
+Note:
+
+Given target value is a floating point.
+You may assume k is always valid, that is: k ≤ total nodes.
+You are guaranteed to have only one unique set of k values
+in the BST that are closest to the target.
+Example:
+
+Input: root = [4,2,5,1,3], target = 3.714286, and k = 2
+
+    4
+   / \
+  2   5
+ / \
+1   3
+
+Output: [4,3]
+Follow up:
+Assume that the BST is balanced, could you solve it in
+less than O(n) runtime (where n = total nodes)?
+
+*/
+
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @param {number} k
+ * @return {number[]}
+ */
+const closestKValues = function(root, target, k) {
+  const res = []
+  let node = root
+  const stack = []
+  while (node || stack.length) {
+    if (node) {
+      stack.push(node)
+      node = node.left
+    } else {
+      node = stack.pop()
+      if (res.length === k) {
+        if (Math.abs(res[0] - target) <= Math.abs(node.val - target)) {
+          return res
+        }
+        res.shift()
+      }
+      res.push(node.val)
+      node = node.right
+    }
+  }
+  return res
+}

From 2e7a2d6b031df1532247dfd11af5baee157ed57a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 13:03:40 +0800
Subject: [PATCH 0166/3374] Create 252-meeting-rooms.js

---
 252-meeting-rooms.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 252-meeting-rooms.js

diff --git a/252-meeting-rooms.js b/252-meeting-rooms.js
new file mode 100644
index 00000000..fdb29954
--- /dev/null
+++ b/252-meeting-rooms.js
@@ -0,0 +1,29 @@
+/**
+
+Given an array of meeting time intervals consisting of
+start and end times [[s1,e1],[s2,e2],...] (si < ei),
+determine if a person could attend all meetings.
+
+Example 1:
+
+Input: [[0,30],[5,10],[15,20]]
+Output: false
+Example 2:
+
+Input: [[7,10],[2,4]]
+Output: true
+
+*/
+
+/**
+ * @param {number[][]} intervals
+ * @return {boolean}
+ */
+const canAttendMeetings = function(intervals) {
+  if(intervals == null || intervals.length === 0) return true
+  intervals.sort((a,b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+  for (let i = 0; i < intervals.length - 1; i++) {
+    if (intervals[i][1] > intervals[i+1][0]) return false;
+  }
+  return true;
+};

From db413f6d6c3262579fcd6b1ad6770857de6ba556 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 14:12:00 +0800
Subject: [PATCH 0167/3374] Create 270-closest-binary-search-tree-value.js

---
 270-closest-binary-search-tree-value.js | 61 +++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 270-closest-binary-search-tree-value.js

diff --git a/270-closest-binary-search-tree-value.js b/270-closest-binary-search-tree-value.js
new file mode 100644
index 00000000..7ae6f7d0
--- /dev/null
+++ b/270-closest-binary-search-tree-value.js
@@ -0,0 +1,61 @@
+/**
+
+Given a non-empty binary search tree and a target value,
+find the value in the BST that is closest to the target.
+
+Note:
+
+Given target value is a floating point.
+You are guaranteed to have only one unique value
+in the BST that is closest to the target.
+
+Example:
+
+Input: root = [4,2,5,1,3], target = 3.714286
+
+    4
+   / \
+  2   5
+ / \
+1   3
+
+Output: 4
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {number}
+ */
+const closestValue = function(root, target) {
+  if(root == null) return -1
+  let node = root
+  const stack = []
+  const res = []
+  const K = 1
+  while(node || stack.length) {
+    if(node) {
+      stack.push(node)
+      node = node.left
+    } else {
+      node = stack.pop()
+      if(res.length === K) {
+        if(Math.abs(res[0] - target) < Math.abs(node.val - target)) {
+          return res[0]   
+        }
+        res.shift()
+      }
+      res.push(node.val)
+      node = node.right
+    }
+  }
+  return res[0]
+};

From f420047251e9d654c08b6b02684485314fa19423 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 14:22:49 +0800
Subject: [PATCH 0168/3374] Update 270-closest-binary-search-tree-value.js

---
 270-closest-binary-search-tree-value.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/270-closest-binary-search-tree-value.js b/270-closest-binary-search-tree-value.js
index 7ae6f7d0..95498abc 100644
--- a/270-closest-binary-search-tree-value.js
+++ b/270-closest-binary-search-tree-value.js
@@ -35,6 +35,17 @@ Output: 4
  * @param {number} target
  * @return {number}
  */
+const closestValue = function(root, target) {
+  const child = target < root.val ? root.left : root.right;
+  if (!child) return root.val;
+  const closest = closestValue(child, target);
+  return Math.abs(closest - target) < Math.abs(root.val - target)
+    ? closest
+    : root.val;
+};
+
+// another
+
 const closestValue = function(root, target) {
   if(root == null) return -1
   let node = root

From 0a2aaa16e2df46cc9d1aca1bfa2eec3c48be3cab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 14:57:37 +0800
Subject: [PATCH 0169/3374] Update 270-closest-binary-search-tree-value.js

---
 270-closest-binary-search-tree-value.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/270-closest-binary-search-tree-value.js b/270-closest-binary-search-tree-value.js
index 95498abc..5bde4e8b 100644
--- a/270-closest-binary-search-tree-value.js
+++ b/270-closest-binary-search-tree-value.js
@@ -35,6 +35,19 @@ Output: 4
  * @param {number} target
  * @return {number}
  */
+const closestValue = function(root, target) {
+  let res = root.val
+  while(root) {
+    if(Math.abs(root.val - target) < Math.abs(res - target)) {
+      res = root.val
+    }
+    root = root.val > target ? root.left : root.right
+  }
+  return res
+};
+
+// another
+
 const closestValue = function(root, target) {
   const child = target < root.val ? root.left : root.right;
   if (!child) return root.val;

From 8122d42e8822f2e241fac6adcd8492dbf610a85d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2019 15:35:14 +0800
Subject: [PATCH 0170/3374] Create 333-largest-bst-subtree.js

---
 333-largest-bst-subtree.js | 55 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 333-largest-bst-subtree.js

diff --git a/333-largest-bst-subtree.js b/333-largest-bst-subtree.js
new file mode 100644
index 00000000..593b47c7
--- /dev/null
+++ b/333-largest-bst-subtree.js
@@ -0,0 +1,55 @@
+/**
+
+Given a binary tree, find the largest subtree
+which is a Binary Search Tree (BST),
+where largest means subtree with largest number of nodes in it.
+
+Note:
+A subtree must include all of its descendants.
+
+Example:
+
+Input: [10,5,15,1,8,null,7]
+
+   10 
+   / \ 
+  5  15 
+ / \   \ 
+1   8   7
+
+Output: 3
+Explanation: The Largest BST Subtree in this case is the highlighted one.
+             The return value is the subtree's size, which is 3.
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const largestBSTSubtree = function(root) {
+  const res = helper(root)
+  return res[2]
+}
+
+function helper(node) {
+  if (!node) return [Number.MAX_VALUE, -Number.MAX_VALUE, 0]
+  const left = helper(node.left)
+  const right = helper(node.right)
+  if (node.val > left[1] && node.val < right[0]) {
+    return [
+      Math.min(node.val, left[0]),
+      Math.max(node.val, right[1]),
+      left[2] + right[2] + 1
+    ]
+  } else {
+    return [-Number.MAX_VALUE, Number.MAX_VALUE, Math.max(left[2], right[2])]
+  }
+}

From 2818931e2a012b762197905292276ff49f6b28b0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Dec 2019 10:03:51 +0800
Subject: [PATCH 0171/3374] Update 333-largest-bst-subtree.js

---
 333-largest-bst-subtree.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/333-largest-bst-subtree.js b/333-largest-bst-subtree.js
index 593b47c7..f3655aae 100644
--- a/333-largest-bst-subtree.js
+++ b/333-largest-bst-subtree.js
@@ -53,3 +53,22 @@ function helper(node) {
     return [-Number.MAX_VALUE, Number.MAX_VALUE, Math.max(left[2], right[2])]
   }
 }
+
+// another
+
+const largestBSTSubtree = function(root) {
+  function dfs(node) {
+    if (!node) return [0, 0, Number.MAX_VALUE, -Number.MAX_VALUE]
+    const [N1, n1, min1, max1] = dfs(node.left)
+    const [N2, n2, min2, max2] = dfs(node.right)
+    const n =
+      max1 < node.val && min2 > node.val ? n1 + 1 + n2 : -Number.MAX_VALUE
+    return [
+      Math.max(N1, N2, n),
+      n,
+      Math.min(min1, node.val),
+      Math.max(max2, node.val)
+    ]
+  }
+  return dfs(root)[0]
+}

From 8a6adea1719e9cff4b85b5f840e32793bb298e76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Dec 2019 11:13:52 +0800
Subject: [PATCH 0172/3374] Create 1087-brace-expansion.js

---
 1087-brace-expansion.js | 46 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1087-brace-expansion.js

diff --git a/1087-brace-expansion.js b/1087-brace-expansion.js
new file mode 100644
index 00000000..5f1039d5
--- /dev/null
+++ b/1087-brace-expansion.js
@@ -0,0 +1,46 @@
+/**
+ * @param {string} S
+ * @return {string[]}
+ */
+const expand = function(S) {
+  const arr = []
+  let cur = ''
+  for (let i = 0, len = S.length; i < len; i++) {
+    const ch = S.charAt(i)
+    if (ch === '{') {
+      if (cur) arr.push(cur)
+      cur = []
+    } else if (ch === '}') {
+      arr.push(cur.sort())
+      cur = ''
+    } else if (ch === ',') {
+    } else {
+      if (typeof cur === 'string' || cur === '') {
+        cur += ch
+      } else {
+        cur.push(ch)
+      }
+    }
+  }
+  arr.push(cur)
+  const res = []
+  bt(arr, 0, '', res)
+  return res
+}
+function bt(arr, i, cur, res) {
+  if (i === arr.length) {
+    res.push(cur)
+    return
+  }
+  if (typeof arr[i] === 'string') {
+    cur += arr[i]
+    bt(arr, i + 1, cur, res)
+  } else {
+    for (let j = 0, len = arr[i].length; j < len; j++) {
+      let bak = cur
+      cur += arr[i][j]
+      bt(arr, i + 1, cur, res)
+      cur = bak
+    }
+  }
+}

From 5ab9a349fa8fa0903161092ac4fce3355b7228cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Dec 2019 13:22:20 +0800
Subject: [PATCH 0173/3374] Create 694-number-of-distinct-islands.js

---
 694-number-of-distinct-islands.js | 65 +++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 694-number-of-distinct-islands.js

diff --git a/694-number-of-distinct-islands.js b/694-number-of-distinct-islands.js
new file mode 100644
index 00000000..e5401b31
--- /dev/null
+++ b/694-number-of-distinct-islands.js
@@ -0,0 +1,65 @@
+/**
+
+Given a non-empty 2D array grid of 0's and 1's,
+an island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.)
+You may assume all four edges of the grid are surrounded by water.
+
+Count the number of distinct islands. An island is considered to
+be the same as another if and only if one island can
+be translated (and not rotated or reflected) to equal the other.
+
+Example 1:
+11000
+11000
+00011
+00011
+
+Given the above grid map, return 1.
+
+Example 2:
+11011
+10000
+00001
+11011
+
+Given the above grid map, return 3.
+
+Notice that:
+11
+1
+and
+ 1
+11
+are considered different island shapes, because we do not consider reflection / rotation.
+Note: The length of each dimension in the given grid does not exceed 50.
+
+*/
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const numDistinctIslands = function(grid) {
+  if (!grid.length) return 0;
+  const pattern = new Set();
+  grid.forEach((rows, row) => {
+    rows.forEach((val, col) => {
+      if (val === 1) pattern.add(depthFirst(grid, row, col, "o"));
+    });
+  });
+  return pattern.size;
+};
+
+function depthFirst(graph, row, col, di) {
+  if (graph[row] && graph[row][col]) {
+    graph[row][col] = 0;
+    let p =
+      di +
+      depthFirst(graph, row + 1, col, "d") +
+      depthFirst(graph, row - 1, col, "u") +
+      depthFirst(graph, row, col + 1, "r") +
+      depthFirst(graph, row, col - 1, "l") +
+      "b";
+    return p;
+  } else return "";
+}

From 67949d01355aacb849f578139f5019068142ee4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Dec 2019 14:04:08 +0800
Subject: [PATCH 0174/3374] Update 694-number-of-distinct-islands.js

---
 694-number-of-distinct-islands.js | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/694-number-of-distinct-islands.js b/694-number-of-distinct-islands.js
index e5401b31..1472a640 100644
--- a/694-number-of-distinct-islands.js
+++ b/694-number-of-distinct-islands.js
@@ -35,6 +35,46 @@ Note: The length of each dimension in the given grid does not exceed 50.
 
 */
 
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const numDistinctIslands = function(grid) {
+  const set = new Set()
+  for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid[0].length; j++) {
+      if (grid[i][j] === 1) {
+        const tempArr = []
+        helper(i, j, grid, tempArr)
+        const x = tempArr[0][0] - 0
+        const y = tempArr[0][1] - 0
+        let str = ''
+        for (let k = 0; k < tempArr.length; k++) {
+          str += '#' + (tempArr[k][0] - x) + '#' + (tempArr[k][1] - y)
+        }
+        set.add(str)
+      }
+    }
+  }
+  return set.size
+}
+
+function helper(i, j, arr, tempArr) {
+  tempArr.push([i, j])
+  arr[i][j] = 0
+
+  if (arr[i][j - 1] === 1) helper(i, j - 1, arr, tempArr)
+  if (arr[i][j + 1] === 1) helper(i, j + 1, arr, tempArr)
+  if (arr[i - 1]) {
+    if (arr[i - 1][j] === 1) helper(i - 1, j, arr, tempArr)
+  }
+  if (arr[i + 1]) {
+    if (arr[i + 1][j] === 1) helper(i + 1, j, arr, tempArr)
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 694b116001d0a50f7b774e6d4c887bafa4941634 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Dec 2019 10:27:02 +0800
Subject: [PATCH 0175/3374] Create 1167-minimum-cost-to-connect-sticks.js

---
 1167-minimum-cost-to-connect-sticks.js | 42 ++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 1167-minimum-cost-to-connect-sticks.js

diff --git a/1167-minimum-cost-to-connect-sticks.js b/1167-minimum-cost-to-connect-sticks.js
new file mode 100644
index 00000000..8d9cfb72
--- /dev/null
+++ b/1167-minimum-cost-to-connect-sticks.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} sticks
+ * @return {number}
+ */
+const connectSticks = function(sticks) {
+  if (sticks.length < 1) return 0
+  let size = sticks.length - 1
+  let i = Math.floor(sticks.length / 2)
+  for (; i >= 0; i--) {
+    heapify(sticks, i, size)
+  }
+  let cost = 0
+  while (size >= 1) {
+    const temp = sticks[0]
+    sticks[0] = sticks[size--]
+    heapify(sticks, 0, size)
+    sticks[0] = sticks[0] + temp
+    cost += sticks[0]
+    heapify(sticks, 0, size)
+  }
+  return cost
+}
+const heapify = (arr, index, size) => {
+  let smallest = index
+  let l = index * 2 + 1
+  let r = index * 2 + 2
+  if (l <= size && arr[l] < arr[smallest]) {
+    smallest = l
+  }
+  if (r <= size && arr[r] < arr[smallest]) {
+    smallest = r
+  }
+  if (smallest != index) {
+    swap(arr, index, smallest)
+    heapify(arr, smallest, size)
+  }
+}
+const swap = (arr, i, j) => {
+  const temp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = temp
+}

From 67c3ac25a2a76ec379933c734104b20c38c53c9c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Dec 2019 13:18:16 +0800
Subject: [PATCH 0176/3374] Update 1167-minimum-cost-to-connect-sticks.js

---
 1167-minimum-cost-to-connect-sticks.js | 54 ++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1167-minimum-cost-to-connect-sticks.js b/1167-minimum-cost-to-connect-sticks.js
index 8d9cfb72..d42183ab 100644
--- a/1167-minimum-cost-to-connect-sticks.js
+++ b/1167-minimum-cost-to-connect-sticks.js
@@ -1,3 +1,28 @@
+/**
+
+You have some sticks with positive integer lengths.
+
+You can connect any two sticks of lengths X and Y into
+one stick by paying a cost of X + Y.  You perform this action until there is one stick remaining.
+
+Return the minimum cost of connecting all the given sticks into one stick in this way.
+
+Example 1:
+
+Input: sticks = [2,4,3]
+Output: 14
+Example 2:
+
+Input: sticks = [1,8,3,5]
+Output: 30
+ 
+Constraints:
+
+1 <= sticks.length <= 10^4
+1 <= sticks[i] <= 10^4
+
+*/
+
 /**
  * @param {number[]} sticks
  * @return {number}
@@ -40,3 +65,32 @@ const swap = (arr, i, j) => {
   arr[i] = arr[j]
   arr[j] = temp
 }
+
+// another
+
+/**
+ * @param {number[]} sticks
+ * @return {number}
+ */
+const connectSticks = function(sticks) {
+  if (sticks.length === 1) return 0
+  sticks.sort((a, b) => a - b)
+  let sum = [],
+    result = 0
+  while (sticks.length || sum.length > 1) {
+    let cur = 0
+    for (let i = 0; i < 2; i++) {
+      if (sticks[0] && (sum[0] === undefined || sticks[0] < sum[0])) {
+        cur += sticks[0]
+        sticks.shift()
+      } else {
+        cur += sum[0]
+        sum.shift()
+      }
+    }
+    sum.push(cur)
+    result += cur
+  }
+  return result
+}
+

From 8ff35e6fa95b88eb492228c0fef316ae49642ee3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Dec 2019 13:58:20 +0800
Subject: [PATCH 0177/3374] Update 1167-minimum-cost-to-connect-sticks.js

---
 1167-minimum-cost-to-connect-sticks.js | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1167-minimum-cost-to-connect-sticks.js b/1167-minimum-cost-to-connect-sticks.js
index d42183ab..ff6d7fa1 100644
--- a/1167-minimum-cost-to-connect-sticks.js
+++ b/1167-minimum-cost-to-connect-sticks.js
@@ -94,3 +94,34 @@ const connectSticks = function(sticks) {
   return result
 }
 
+// another
+
+/**
+ * @param {number[]} sticks
+ * @return {number}
+ */
+const connectSticks = function(sticks) {
+  sticks.sort((a, b) => a - b)
+  const sums = []
+  let result = 0
+  if (sticks.length < 2) return result
+  const getMin = () => {
+    const stick = sticks.length ? sticks[0] : Infinity
+    const sum = sums.length ? sums[0] : Infinity
+    if (sum < stick) {
+      return sums.shift()
+    } else {
+      return sticks.shift()
+    }
+  }
+  while (sticks.length || sums.length > 1) {
+    const tmp1 = getMin()
+    const tmp2 = getMin()
+    const curr = tmp1 + tmp2
+    result += curr
+    sums.push(curr)
+  }
+  return result
+}
+
+

From e7c50d6c3b2132ccf5abc148b1055246b499f745 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2019 09:49:28 +0800
Subject: [PATCH 0178/3374] Create 285-inorder-successor-in-bst.js

---
 285-inorder-successor-in-bst.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 285-inorder-successor-in-bst.js

diff --git a/285-inorder-successor-in-bst.js b/285-inorder-successor-in-bst.js
new file mode 100644
index 00000000..98e94956
--- /dev/null
+++ b/285-inorder-successor-in-bst.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @return {TreeNode}
+ */
+const inorderSuccessor = function(root, p) {
+  const res = { node: null }
+  dfs(root, [], res, p)
+  return res.node
+};
+
+function dfs(node, arr, res, target) {
+  if(node === null) return
+  dfs(node.left, arr, res, target)
+  if(arr.length && arr[arr.length - 1] === target) res.node = node
+  arr.push(node)
+  dfs(node.right, arr, res, target)
+} 

From 4977b73aebc15315f68665b51fb01728e3fd85ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2019 10:00:54 +0800
Subject: [PATCH 0179/3374] Update 285-inorder-successor-in-bst.js

---
 285-inorder-successor-in-bst.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/285-inorder-successor-in-bst.js b/285-inorder-successor-in-bst.js
index 98e94956..8ca737e0 100644
--- a/285-inorder-successor-in-bst.js
+++ b/285-inorder-successor-in-bst.js
@@ -23,3 +23,18 @@ function dfs(node, arr, res, target) {
   arr.push(node)
   dfs(node.right, arr, res, target)
 } 
+
+// another
+
+const inorderSuccessor = function(root, p) {
+  let last = null
+  const chk = node => {
+    if(!node) return
+    const l = chk(node.left)
+    if(l !== undefined) return l
+    if(last === p) return node
+    last = node
+    return chk(node.right)
+  }
+  return chk(root)
+};

From 37c6cffda3706224d4eaf0b3c032f40219ddd839 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2019 10:17:29 +0800
Subject: [PATCH 0180/3374] Update 285-inorder-successor-in-bst.js

---
 285-inorder-successor-in-bst.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/285-inorder-successor-in-bst.js b/285-inorder-successor-in-bst.js
index 8ca737e0..014afadc 100644
--- a/285-inorder-successor-in-bst.js
+++ b/285-inorder-successor-in-bst.js
@@ -38,3 +38,11 @@ const inorderSuccessor = function(root, p) {
   }
   return chk(root)
 };
+
+// another
+
+const inorderSuccessor = function(root, p) {
+  while (root != null && root.val <= p.val) root = root.right
+  const left = root == null ? null : inorderSuccessor(root.left, p)
+  return left != null && left.val > p.val ? left : root
+}

From c9b98c6a92555566f23dd5e48af0ca3714641469 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2019 10:53:26 +0800
Subject: [PATCH 0181/3374] Update 285-inorder-successor-in-bst.js

---
 285-inorder-successor-in-bst.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/285-inorder-successor-in-bst.js b/285-inorder-successor-in-bst.js
index 014afadc..71cf8ef9 100644
--- a/285-inorder-successor-in-bst.js
+++ b/285-inorder-successor-in-bst.js
@@ -46,3 +46,18 @@ const inorderSuccessor = function(root, p) {
   const left = root == null ? null : inorderSuccessor(root.left, p)
   return left != null && left.val > p.val ? left : root
 }
+
+// another
+
+const inorderSuccessor = function(root, p) {
+  let succ = null
+  while(root) {
+    if (p.val < root.val) {
+      succ = root
+      root = root.left
+    } else {
+      root = root.right
+    }
+  }
+  return succ
+}

From 4d93cc061db532a855c471fe543f5034c36d9b3d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2019 13:00:37 +0800
Subject: [PATCH 0182/3374] Create
 889-construct-binary-tree-from-preorder-and-postorder-traversal.js

---
 ...e-from-preorder-and-postorder-traversal.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 889-construct-binary-tree-from-preorder-and-postorder-traversal.js

diff --git a/889-construct-binary-tree-from-preorder-and-postorder-traversal.js b/889-construct-binary-tree-from-preorder-and-postorder-traversal.js
new file mode 100644
index 00000000..8bd0f678
--- /dev/null
+++ b/889-construct-binary-tree-from-preorder-and-postorder-traversal.js
@@ -0,0 +1,43 @@
+/**
+
+Return any binary tree that matches the given preorder and postorder traversals.
+Values in the traversals pre and post are distinct positive integers.
+
+Example 1:
+
+Input: pre = [1,2,4,5,3,6,7], post = [4,5,2,6,7,3,1]
+Output: [1,2,3,4,5,6,7]
+ 
+Note:
+
+1 <= pre.length == post.length <= 30
+pre[] and post[] are both permutations of 1, 2, ..., pre.length.
+It is guaranteed an answer exists.
+If there exists multiple answers, you can return any of them.
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} pre
+ * @param {number[]} post
+ * @return {TreeNode}
+ */
+const constructFromPrePost = function(pre, post) {
+  let i = 0,
+    j = 0
+  return (function dfs() {
+    let val = pre[i++]
+    let node = new TreeNode(val)
+    if (val !== post[j]) node.left = dfs()
+    if (val !== post[j]) node.right = dfs()
+    j++
+    return node
+  })()
+}

From ac0c6a35e8fcd7725919ee453d92be22f82a1ca0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Dec 2019 10:04:10 +0800
Subject: [PATCH 0183/3374] Create
 1153-string-transforms-into-another-string.js

---
 1153-string-transforms-into-another-string.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1153-string-transforms-into-another-string.js

diff --git a/1153-string-transforms-into-another-string.js b/1153-string-transforms-into-another-string.js
new file mode 100644
index 00000000..2d35d4f4
--- /dev/null
+++ b/1153-string-transforms-into-another-string.js
@@ -0,0 +1,45 @@
+/**
+
+Given two strings str1 and str2 of the same length,
+determine whether you can transform str1 into str2 by doing zero or more conversions.
+In one conversion you can convert all occurrences of one character
+in str1 to any other lowercase English character.
+Return true if and only if you can transform str1 into str2.
+
+Example 1:
+
+Input: str1 = "aabcc", str2 = "ccdee"
+Output: true
+Explanation: Convert 'c' to 'e' then 'b' to 'd' then 'a' to 'c'. 
+Note that the order of conversions matter.
+
+Example 2:
+
+Input: str1 = "leetcode", str2 = "codeleet"
+Output: false
+Explanation: There is no way to transform str1 to str2.
+
+Note:
+
+1 <= str1.length == str2.length <= 10^4
+Both str1 and str2 contain only lowercase English letters.
+
+*/
+
+/**
+ * @param {string} str1
+ * @param {string} str2
+ * @return {boolean}
+ */
+const canConvert = function(str1, str2) {
+  if (str1 === str2) return true
+  const map = new Map()
+  for (let i = 0; i < str1.length; i++) {
+    if (map.has(str1[i]) && map.get(str1[i]) !== str2[i]) {
+      return false
+    }
+    map.set(str1[i], str2[i])
+  }
+  const set = new Set(map.values())
+  return set.size < 26
+}

From 4feed2e03241cb02a9d1ae60e0f3090324af7a4c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Dec 2019 09:54:00 +0800
Subject: [PATCH 0184/3374] Create 360-sort-transformed-array.js

---
 360-sort-transformed-array.js | 52 +++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 360-sort-transformed-array.js

diff --git a/360-sort-transformed-array.js b/360-sort-transformed-array.js
new file mode 100644
index 00000000..c3cca671
--- /dev/null
+++ b/360-sort-transformed-array.js
@@ -0,0 +1,52 @@
+/**
+
+Given a sorted array of integers nums and integer values a, b and c.
+Apply a quadratic function of the form f(x) = ax2 + bx + c to each element x in the array.
+
+The returned array must be in sorted order.
+
+Expected time complexity: O(n)
+
+Example 1:
+
+Input: nums = [-4,-2,2,4], a = 1, b = 3, c = 5
+Output: [3,9,15,33]
+Example 2:
+
+Input: nums = [-4,-2,2,4], a = -1, b = 3, c = 5
+Output: [-23,-5,1,7]
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number[]}
+ */
+const sortTransformedArray = function(nums, a, b, c) {
+  const n = nums.length
+  const sorted = new Array(n)
+  let i = 0,
+    j = n - 1
+  let index = a >= 0 ? n - 1 : 0
+  while (i <= j) {
+    if (a >= 0) {
+      sorted[index--] =
+        quad(nums[i], a, b, c) >= quad(nums[j], a, b, c)
+          ? quad(nums[i++], a, b, c)
+          : quad(nums[j--], a, b, c)
+    } else {
+      sorted[index++] =
+        quad(nums[i], a, b, c) >= quad(nums[j], a, b, c)
+          ? quad(nums[j--], a, b, c)
+          : quad(nums[i++], a, b, c)
+    }
+  }
+  return sorted
+}
+
+function quad(x, a, b, c) {
+  return a * x * x + b * x +c
+}

From cf9fba0676f3b2b9b0c68cc2f02e7ad9d5cdf990 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Dec 2019 10:30:39 +0800
Subject: [PATCH 0185/3374] Update 360-sort-transformed-array.js

---
 360-sort-transformed-array.js | 53 +++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/360-sort-transformed-array.js b/360-sort-transformed-array.js
index c3cca671..2caedcd0 100644
--- a/360-sort-transformed-array.js
+++ b/360-sort-transformed-array.js
@@ -50,3 +50,56 @@ const sortTransformedArray = function(nums, a, b, c) {
 function quad(x, a, b, c) {
   return a * x * x + b * x +c
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number[]}
+ */
+const sortTransformedArray = function(nums, a, b, c) {
+  const ret = []
+  const sum = v => a * v * v + b * v + c
+  if (a > 0) {
+    const point = (b / a / 2) * -1
+    let i = 0,
+      j = nums.length
+    while (i < j) {
+      let ax = nums[i]
+      if (Math.abs(nums[i] - point) - Math.abs(nums[j - 1] - point) > 0) {
+        ++i
+      } else {
+        ax = nums[--j]
+      }
+      ret.unshift(sum(ax))
+    }
+    return ret
+  } else if (a < 0) {
+    const point = (b / a / 2) * -1
+    let i = 0,
+      j = nums.length
+    while (i < j) {
+      let ax = nums[i]
+      if (Math.abs(ax - point) - Math.abs(nums[j - 1] - point) > 0) {
+        ++i
+      } else {
+        ax = nums[--j]
+      }
+      ret.push(sum(ax))
+    }
+    return ret
+  } else {
+    if (b > 0) {
+      return nums.map(v => sum(v))
+    } else {
+      nums.forEach(v => {
+        ret.unshift(sum(v))
+      })
+      return ret
+    }
+  }
+}
+

From 7e5f9d7fb180f2565bc050fa79c127f6c5773ce4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Dec 2019 11:02:58 +0800
Subject: [PATCH 0186/3374] Create 1099-two-sum-less-than-k.js

---
 1099-two-sum-less-than-k.js | 49 +++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 1099-two-sum-less-than-k.js

diff --git a/1099-two-sum-less-than-k.js b/1099-two-sum-less-than-k.js
new file mode 100644
index 00000000..87166250
--- /dev/null
+++ b/1099-two-sum-less-than-k.js
@@ -0,0 +1,49 @@
+/**
+
+Given an array A of integers and integer K,
+return the maximum S such that there exists i < j with A[i] + A[j] = S and S < K.
+If no i, j exist satisfying this equation, return -1.
+
+Example 1:
+
+Input: A = [34,23,1,24,75,33,54,8], K = 60
+Output: 58
+Explanation: 
+We can use 34 and 24 to sum 58 which is less than 60.
+
+Example 2:
+
+Input: A = [10,20,30], K = 15
+Output: -1
+Explanation: 
+In this case it's not possible to get a pair sum less that 15.
+
+Note:
+
+1 <= A.length <= 100
+1 <= A[i] <= 1000
+1 <= K <= 2000
+
+*/
+
+/**
+ * @param {number[]} A
+ * @param {number} K
+ * @return {number}
+ */
+const twoSumLessThanK = function(A, K) {
+  A.sort((a, b) => a - b)
+  let max = -1,
+    i = 0,
+    j = A.length - 1
+  while (i < j) {
+    const sum = A[i] + A[j]
+    if (sum < K) {
+      max = Math.max(max, sum)
+      i++
+    } else {
+      j--
+    }
+  }
+  return max
+}

From a83fe39d7a3bb0a8775d7bcbdfbd4be997668dd1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Dec 2019 11:18:56 +0800
Subject: [PATCH 0187/3374] Create 266-palindrome-permutation.js

---
 266-palindrome-permutation.js | 37 +++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 266-palindrome-permutation.js

diff --git a/266-palindrome-permutation.js b/266-palindrome-permutation.js
new file mode 100644
index 00000000..c8e86728
--- /dev/null
+++ b/266-palindrome-permutation.js
@@ -0,0 +1,37 @@
+/**
+
+Given a string, determine if a permutation of the string could form a palindrome.
+
+Example 1:
+
+Input: "code"
+Output: false
+Example 2:
+
+Input: "aab"
+Output: true
+Example 3:
+
+Input: "carerac"
+Output: true
+
+*/
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const canPermutePalindrome = function(s) {
+  const m = {}
+  for(let i = 0, len = s.length; i < len; i++) {
+    if(m[s[i]] == null || m[s[i]] === 0) m[s[i]] = 1
+    else m[s[i]] -= 1
+  }
+  let num = 0
+  for(let el in m) {
+    if(m.hasOwnProperty(el)) {
+      if(m[el] > 0) num++
+    }
+  }
+  return num === 0 || num === 1
+};

From 8fca8f66f797db4b83c8eb1172c293e82117f565 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Dec 2019 12:20:01 +0800
Subject: [PATCH 0188/3374] Create 259-3sum-smaller.js

---
 259-3sum-smaller.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 259-3sum-smaller.js

diff --git a/259-3sum-smaller.js b/259-3sum-smaller.js
new file mode 100644
index 00000000..8a41e731
--- /dev/null
+++ b/259-3sum-smaller.js
@@ -0,0 +1,38 @@
+/**
+
+Given an array of n integers nums and a target,
+find the number of index triplets i, j, k with 0 <= i < j < k < n
+that satisfy the condition nums[i] + nums[j] + nums[k] < target.
+
+Example:
+
+Input: nums = [-2,0,1,3], and target = 2
+Output: 2 
+Explanation: Because there are two triplets which sums are less than 2:
+             [-2,0,1]
+             [-2,0,3]
+
+Follow up: Could you solve it in O(n2) runtime?
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const threeSumSmaller = function(nums, target) {
+  nums.sort((a, b) => a - b)
+  let res = 0
+  for(let i = 0, len = nums.length; i < len - 2; i++) {
+    let lo = i + 1
+    let hi = len - 1
+    while(lo < hi) {
+      if(nums[i] + nums[lo] + nums[hi] < target) {
+        res += hi - lo
+        lo++
+      } else hi--
+    }
+  }
+  return res
+};

From 63b816c55eac258bb9986c91d727910d72f64620 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Dec 2019 10:45:01 +0800
Subject: [PATCH 0189/3374] Create 1216-valid-palindrome-iii.js

---
 1216-valid-palindrome-iii.js | 46 ++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1216-valid-palindrome-iii.js

diff --git a/1216-valid-palindrome-iii.js b/1216-valid-palindrome-iii.js
new file mode 100644
index 00000000..943ba620
--- /dev/null
+++ b/1216-valid-palindrome-iii.js
@@ -0,0 +1,46 @@
+/**
+
+Given a string s and an integer k, find out if the given string is a K-Palindrome or not.
+
+A string is K-Palindrome if it can be transformed into a palindrome by removing at most k characters from it.
+
+Example 1:
+
+Input: s = "abcdeca", k = 2
+Output: true
+Explanation: Remove 'b' and 'e' characters.
+ 
+Constraints:
+
+1 <= s.length <= 1000
+s has only lowercase English letters.
+1 <= k <= s.length
+
+*/
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {boolean}
+ */
+const isValidPalindrome = function(s, k) {
+  const len = s.length
+  const reverse = s.split('').reverse().join('')
+  const lps = lcs(s, reverse, len, len)
+  return len - lps <= k
+  
+};
+
+function lcs(s1, s2, m, n) {
+  const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0))
+  for(let i = 1; i <= m; i++) {
+    for(let j = 1; j <= n; j++) {
+      if(s1[i - 1] === s2[j - 1]) {
+        dp[i][j] = dp[i - 1][j - 1] + 1
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
+      }
+    }
+  }
+  return dp[m][n]
+}

From d93f539c41c9cde66af61801f1112050466bfde4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Dec 2019 11:26:43 +0800
Subject: [PATCH 0190/3374] Update 1216-valid-palindrome-iii.js

---
 1216-valid-palindrome-iii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1216-valid-palindrome-iii.js b/1216-valid-palindrome-iii.js
index 943ba620..474c1942 100644
--- a/1216-valid-palindrome-iii.js
+++ b/1216-valid-palindrome-iii.js
@@ -44,3 +44,31 @@ function lcs(s1, s2, m, n) {
   }
   return dp[m][n]
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {boolean}
+ */
+const isValidPalindrome = function(s, k) {
+  const len = s.length
+  const cache = Array.from({ length: len }, () => new Array(len).fill(0))
+  chk(s, 0, len - 1, cache)
+  return cache[0][len - 1] <= k
+};
+
+function chk(s, l, r, cache) {
+  if(l >= r) return 0
+  if(cache[l][r]) return cache[l][r]
+  let num = 0
+  if(s[l] === s[r]) {
+    num = chk(s, l + 1, r - 1, cache) 
+  } else {
+    num = 1 + Math.min(chk(s, l, r - 1, cache), chk(s, l + 1, r, cache))
+  }
+  cache[l][r] = num
+  return num
+}
+

From 8c55b37cdc77cbeb598ddb511afe4dbe4a531be2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Dec 2019 12:45:36 +0800
Subject: [PATCH 0191/3374] Update 1216-valid-palindrome-iii.js

---
 1216-valid-palindrome-iii.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1216-valid-palindrome-iii.js b/1216-valid-palindrome-iii.js
index 474c1942..44208940 100644
--- a/1216-valid-palindrome-iii.js
+++ b/1216-valid-palindrome-iii.js
@@ -72,3 +72,18 @@ function chk(s, l, r, cache) {
   return num
 }
 
+// another
+
+const isValidPalindrome = function(s, k) {
+  const len = s.length
+  const dp = Array.from({ length: len }, () => new Array(len).fill(0))
+  for(let i = len - 1; i >= 0; i--) {
+    dp[i][i] = 1
+    for(let j = i + 1; j < len; j++) {
+      if(s[i] === s[j]) dp[i][j] = dp[i + 1][j - 1] + 2
+      else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1])
+    }
+  }
+  return len <= dp[0][len - 1] + k
+};
+

From 4f918cdf383ed02ac1468c8c3c64d2499d89c8f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Dec 2019 09:44:01 +0800
Subject: [PATCH 0192/3374] Create 254-factor-combinations.js

---
 254-factor-combinations.js | 72 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 254-factor-combinations.js

diff --git a/254-factor-combinations.js b/254-factor-combinations.js
new file mode 100644
index 00000000..37603303
--- /dev/null
+++ b/254-factor-combinations.js
@@ -0,0 +1,72 @@
+/**
+
+Numbers can be regarded as product of its factors. For example,
+
+8 = 2 x 2 x 2;
+  = 2 x 4.
+Write a function that takes an integer n and return all possible combinations of its factors.
+
+Note:
+
+You may assume that n is always positive.
+Factors should be greater than 1 and less than n.
+Example 1:
+
+Input: 1
+Output: []
+Example 2:
+
+Input: 37
+Output:[]
+Example 3:
+
+Input: 12
+Output:
+[
+  [2, 6],
+  [2, 2, 3],
+  [3, 4]
+]
+Example 4:
+
+Input: 32
+Output:
+[
+  [2, 16],
+  [2, 2, 8],
+  [2, 2, 2, 4],
+  [2, 2, 2, 2, 2],
+  [2, 4, 4],
+  [4, 8]
+]
+
+*/
+
+/**
+ * @param {number} n
+ * @return {number[][]}
+ */
+const getFactors = function(n) {
+  const res = []
+  if(n <= 3) return res
+  helper(n, 2, [], res)
+  return res
+};
+function helper(n, start, cur, res) {
+  if(n === 1) {
+    if(cur.length > 1) {
+      res.push(cur.slice())
+    }
+    return
+  }
+  for(let i = start; i <= Math.sqrt(n); i++) {
+    if(n % i !== 0) continue
+    cur.push(i)
+    helper(n/i, i, cur, res)
+    cur.pop()
+  }
+  let i = n
+  cur.push(i)
+  helper(n/i, i, cur, res)
+  cur.pop()
+}

From ff7a2553f4a1fddbfd69c3b0927a16b8c1547ba2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Dec 2019 10:33:28 +0800
Subject: [PATCH 0193/3374] Update 254-factor-combinations.js

---
 254-factor-combinations.js | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/254-factor-combinations.js b/254-factor-combinations.js
index 37603303..e7f906aa 100644
--- a/254-factor-combinations.js
+++ b/254-factor-combinations.js
@@ -47,26 +47,23 @@ Output:
  * @return {number[][]}
  */
 const getFactors = function(n) {
-  const res = []
-  if(n <= 3) return res
-  helper(n, 2, [], res)
-  return res
-};
-function helper(n, start, cur, res) {
-  if(n === 1) {
-    if(cur.length > 1) {
-      res.push(cur.slice())
-    }
-    return
+  if (n <= 0) {
+    return []
   }
-  for(let i = start; i <= Math.sqrt(n); i++) {
-    if(n % i !== 0) continue
-    cur.push(i)
-    helper(n/i, i, cur, res)
-    cur.pop()
+  const result = []
+  helper(n, result, [], 2)
+  return result
+}
+const helper = (n, result, list, start) => {
+  for (let i = start; i * i <= n; i++) {
+    if (n % i === 0) {
+      list.push(i)
+      list.push(n / i)
+      result.push(list.slice())
+      list.pop()
+      helper(n / i, result, list, i)
+      list.pop()
+    }
   }
-  let i = n
-  cur.push(i)
-  helper(n/i, i, cur, res)
-  cur.pop()
 }
+

From b8276849f65b35fd3cf03939b118be3f742cd148 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Dec 2019 14:05:15 +0800
Subject: [PATCH 0194/3374] Create 325-maximum-size-subarray-sum-equals-k.js

---
 325-maximum-size-subarray-sum-equals-k.js | 42 +++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 325-maximum-size-subarray-sum-equals-k.js

diff --git a/325-maximum-size-subarray-sum-equals-k.js b/325-maximum-size-subarray-sum-equals-k.js
new file mode 100644
index 00000000..d98dec51
--- /dev/null
+++ b/325-maximum-size-subarray-sum-equals-k.js
@@ -0,0 +1,42 @@
+/**
+
+Given an array nums and a target value k,
+find the maximum length of a subarray that sums to k.
+If there isn't one, return 0 instead.
+
+Note:
+The sum of the entire nums array is guaranteed to fit within the 32-bit signed integer range.
+
+Example 1:
+
+Input: nums = [1, -1, 5, -2, 3], k = 3
+Output: 4 
+Explanation: The subarray [1, -1, 5, -2] sums to 3 and is the longest.
+
+Example 2:
+
+Input: nums = [-2, -1, 2, 1], k = 1
+Output: 2 
+Explanation: The subarray [-1, 2] sums to 1 and is the longest.
+
+Follow Up:
+Can you do it in O(n) time?
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxSubArrayLen = function(nums, k) {
+  let sum = 0, max = 0
+  const m = new Map()
+  for(let i = 0, len = nums.length; i < len; i++) {
+    sum += nums[i]
+    if(sum === k) max = i + 1
+    else if(m.has(sum - k)) max = Math.max(max, i - m.get(sum - k))
+    if(!m.has(sum)) m.set(sum, i)
+  }
+  return max
+};

From 9f00ee91323aaf5f917e5c5c9cd2697e67d4ecb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2019 09:26:02 +0800
Subject: [PATCH 0195/3374] Create
 298-binary-tree-longest-consecutive-sequence.js

---
 ...inary-tree-longest-consecutive-sequence.js | 71 +++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 298-binary-tree-longest-consecutive-sequence.js

diff --git a/298-binary-tree-longest-consecutive-sequence.js b/298-binary-tree-longest-consecutive-sequence.js
new file mode 100644
index 00000000..c9c981a3
--- /dev/null
+++ b/298-binary-tree-longest-consecutive-sequence.js
@@ -0,0 +1,71 @@
+/**
+
+Given a binary tree, find the length of the longest consecutive sequence path.
+
+The path refers to any sequence of nodes from some starting node to any node
+in the tree along the parent-child connections.
+The longest consecutive path need to be from parent to child (cannot be the reverse).
+
+Example 1:
+
+Input:
+
+   1
+    \
+     3
+    / \
+   2   4
+        \
+         5
+
+Output: 3
+
+Explanation: Longest consecutive sequence path is 3-4-5, so return 3.
+
+Example 2:
+
+Input:
+
+   2
+    \
+     3
+    / 
+   2    
+  / 
+ 1
+
+Output: 2 
+
+Explanation: Longest consecutive sequence path is 2-3, not 3-2-1, so return 2.
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const longestConsecutive = function(root) {
+  const res = { max: 0 }
+  dfs(root, null, 0, res)
+  return res.max
+};
+
+function dfs(node, p, cur, res) {
+  if(node === null) {
+    return
+  }
+  let s = 0
+  if(p === null) s = 1
+  else if(node.val - p.val === 1) s = cur + 1
+  else s = 1
+  if(s > res.max) res.max = s
+  dfs(node.left, node, s, res)
+  dfs(node.right, node, s, res)
+}

From ec8a483a5ac979a225bdddd4c75e989a94be3a10 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2019 10:24:02 +0800
Subject: [PATCH 0196/3374] Create 296-best-meeting-point.js

---
 296-best-meeting-point.js | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 296-best-meeting-point.js

diff --git a/296-best-meeting-point.js b/296-best-meeting-point.js
new file mode 100644
index 00000000..a4cdcdd0
--- /dev/null
+++ b/296-best-meeting-point.js
@@ -0,0 +1,55 @@
+/**
+
+A group of two or more people wants to meet and minimize the total travel distance.
+You are given a 2D grid of values 0 or 1, where each 1 marks the home of someone in the group.
+The distance is calculated using Manhattan Distance,
+where distance(p1, p2) = |p2.x - p1.x| + |p2.y - p1.y|.
+
+Example:
+
+Input: 
+
+1 - 0 - 0 - 0 - 1
+|   |   |   |   |
+0 - 0 - 0 - 0 - 0
+|   |   |   |   |
+0 - 0 - 1 - 0 - 0
+
+Output: 6 
+
+Explanation: Given three people living at (0,0), (0,4), and (2,2):
+             The point (0,2) is an ideal meeting point, as the total travel distance 
+             of 2+2+2=6 is minimal. So return 6.
+
+*/
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minTotalDistance = function(grid) {
+  const m = grid.length
+  if(!m) return 0
+  const n = grid[0].length
+  const I = []
+  const J = []
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 1) I.push(i)
+    }
+  }
+  for(let j = 0; j < n; j++) {
+    for(let i = 0; i < m; i++) {
+      if(grid[i][j] === 1) J.push(j)
+    }
+  }
+  return min(I) + min(J)
+};
+
+function min(arr) {
+  let i = 0, j = arr.length - 1, sum = 0
+  while(i < j) {
+    sum += arr[j--] - arr[i++]
+  }
+  return sum
+}

From 8aa685bf9400b9774bc6e1faa980c124e9e87ebf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2019 17:36:39 +0800
Subject: [PATCH 0197/3374] Create 369-plus-one-linked-list.js

---
 369-plus-one-linked-list.js | 66 +++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 369-plus-one-linked-list.js

diff --git a/369-plus-one-linked-list.js b/369-plus-one-linked-list.js
new file mode 100644
index 00000000..9b61412b
--- /dev/null
+++ b/369-plus-one-linked-list.js
@@ -0,0 +1,66 @@
+/**
+
+Given a non-negative integer represented as non-empty a singly linked list of digits, plus one to the integer.
+You may assume the integer do not contain any leading zero, except the number 0 itself.
+The digits are stored such that the most significant digit is at the head of the list.
+
+Example :
+
+Input: [1,2,3]
+Output: [1,2,4]
+
+*/
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const plusOne = function(head) {
+  const dummy = new ListNode(1)
+  dummy.next = head
+  const carry = plusOneRecursion(head)
+  return carry ? dummy : dummy.next
+}
+const plusOneRecursion = node => {
+  if (!node) return 1
+  node.val += plusOneRecursion(node.next)
+  if (node.val > 9) {
+    node.val %= 10
+    return 1
+  }
+  return 0
+}
+
+// another
+
+const plusOne = function(head) {
+  if(head == null) return null
+  let inc = false
+  const arr = []
+  const dummy = new ListNode(1)
+  dummy.next = head
+  while(head) {
+    arr.push(head)
+    head = head.next
+  }
+  let oneAdded = false
+  for(let i = arr.length - 1; i >= 0; i--) {
+    const el = arr[i]
+    let sum 
+    if(!oneAdded) {
+      sum = el.val + 1
+      oneAdded = true
+    } else sum = el.val
+    if(inc) sum += 1
+    arr[i].val = sum % 10
+    inc = sum >= 10 ? true : false
+  }
+  return inc ? dummy : dummy.next 
+};

From d6b68207be104293842109a829e47496ee9136ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2019 21:24:36 +0800
Subject: [PATCH 0198/3374] Create 635-design-log-storage-system.js

---
 635-design-log-storage-system.js | 79 ++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 635-design-log-storage-system.js

diff --git a/635-design-log-storage-system.js b/635-design-log-storage-system.js
new file mode 100644
index 00000000..32fb33aa
--- /dev/null
+++ b/635-design-log-storage-system.js
@@ -0,0 +1,79 @@
+/**
+
+You are given several logs that each log contains a unique id and timestamp.
+Timestamp is a string that has the following format: Year:Month:Day:Hour:Minute:Second,
+for example, 2017:01:01:23:59:59. All domains are zero-padded decimal numbers.
+
+Design a log storage system to implement the following functions:
+
+void Put(int id, string timestamp): Given a log's unique id and timestamp,
+store the log in your storage system.
+
+int[] Retrieve(String start, String end, String granularity): Return the id of logs whose
+timestamps are within the range from start to end. Start and end all have the same format as timestamp.
+However, granularity means the time level for consideration. For example, start = "2017:01:01:23:59:59",
+end = "2017:01:02:23:59:59", granularity = "Day", it means that we need to find the logs within the range
+from Jan. 1st 2017 to Jan. 2nd 2017.
+
+Example 1:
+put(1, "2017:01:01:23:59:59");
+put(2, "2017:01:01:22:59:59");
+put(3, "2016:01:01:00:00:00");
+retrieve("2016:01:01:01:01:01","2017:01:01:23:00:00","Year"); // return [1,2,3], because you need to return all logs within 2016 and 2017.
+retrieve("2016:01:01:01:01:01","2017:01:01:23:00:00","Hour"); // return [1,2], because you need to return all logs start from 2016:01:01:01 to 2017:01:01:23, where log 3 is left outside the range.
+
+Note:
+There will be at most 300 operations of Put or Retrieve.
+Year ranges from [2000,2017]. Hour ranges from [00,23].
+Output for Retrieve has no order required.
+
+*/
+
+const Log = function(id, timeArgs) {
+  this.id = id;
+  this.timeArgs = timeArgs;
+};
+const LogSystem = function() {
+  this.logs = [];
+};
+
+/**
+ * @param {number} id
+ * @param {string} timestamp
+ * @return {void}
+ */
+LogSystem.prototype.put = function(id, timestamp) {
+  const args = timestamp.split(":");
+  this.logs.push(new Log(id, args));
+};
+
+/**
+ * @param {string} s
+ * @param {string} e
+ * @param {string} gra
+ * @return {number[]}
+ */
+LogSystem.prototype.retrieve = function(s, e, gra) {
+  const gransarr = ["Year", "Month", "Day", "Hour", "Minute", "Second"];
+  const idx = gransarr.indexOf(gra);
+  const sargs = s.split(":").slice(0, idx + 1);
+  const eargs = e.split(":").slice(0, idx + 1);
+  const sdate = new Date(...sargs).getTime();
+  const edate = new Date(...eargs).getTime();
+  const set = [];
+  this.logs.forEach(function(item) {
+    const itemArgs = item.timeArgs.slice(0, idx + 1);
+    const itemTime = new Date(...itemArgs).getTime();
+    if (itemTime >= sdate && itemTime <= edate) {
+      set.push(item.id);
+    }
+  });
+  return set;
+};
+
+/**
+ * Your LogSystem object will be instantiated and called as such:
+ * var obj = new LogSystem()
+ * obj.put(id,timestamp)
+ * var param_2 = obj.retrieve(s,e,gra)
+ */

From c9857d590ec5d673143cd7e75a4a41f1b09bbf2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Dec 2019 09:19:08 +0800
Subject: [PATCH 0199/3374] Update 369-plus-one-linked-list.js

---
 369-plus-one-linked-list.js | 39 ++++++++++++++++++-------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/369-plus-one-linked-list.js b/369-plus-one-linked-list.js
index 9b61412b..23f754b5 100644
--- a/369-plus-one-linked-list.js
+++ b/369-plus-one-linked-list.js
@@ -40,27 +40,26 @@ const plusOneRecursion = node => {
 
 // another
 
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
 const plusOne = function(head) {
-  if(head == null) return null
-  let inc = false
-  const arr = []
-  const dummy = new ListNode(1)
+  const dummy = new ListNode(0)
   dummy.next = head
-  while(head) {
-    arr.push(head)
-    head = head.next
+  let node = head
+  let lastNotNine = dummy
+  while(node) {
+    if(node.val !== 9) lastNotNine = node
+    node = node.next
   }
-  let oneAdded = false
-  for(let i = arr.length - 1; i >= 0; i--) {
-    const el = arr[i]
-    let sum 
-    if(!oneAdded) {
-      sum = el.val + 1
-      oneAdded = true
-    } else sum = el.val
-    if(inc) sum += 1
-    arr[i].val = sum % 10
-    inc = sum >= 10 ? true : false
+  lastNotNine.val++
+  node = lastNotNine.next
+  while(node) {
+    node.val = 0
+    node = node.next
   }
-  return inc ? dummy : dummy.next 
-};
+  return dummy.val === 1 ? dummy : dummy.next
+}
+
+

From 24abd6e570a2452e78945c887f44f33d057918e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Dec 2019 09:20:43 +0800
Subject: [PATCH 0200/3374] Rename 369-rotate-function.js to
 396-rotate-function.js

---
 369-rotate-function.js => 396-rotate-function.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 369-rotate-function.js => 396-rotate-function.js (100%)

diff --git a/369-rotate-function.js b/396-rotate-function.js
similarity index 100%
rename from 369-rotate-function.js
rename to 396-rotate-function.js

From 3093f750c70619a795873b0dfd08cfec4c769de3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Dec 2019 10:42:26 +0800
Subject: [PATCH 0201/3374] Create 311-sparse-matrix-multiplication.js

---
 311-sparse-matrix-multiplication.js | 49 +++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 311-sparse-matrix-multiplication.js

diff --git a/311-sparse-matrix-multiplication.js b/311-sparse-matrix-multiplication.js
new file mode 100644
index 00000000..9a1c3b7f
--- /dev/null
+++ b/311-sparse-matrix-multiplication.js
@@ -0,0 +1,49 @@
+/**
+
+Given two sparse matrices A and B, return the result of AB.
+You may assume that A's column number is equal to B's row number.
+
+Example:
+
+Input:
+
+A = [
+  [ 1, 0, 0],
+  [-1, 0, 3]
+]
+
+B = [
+  [ 7, 0, 0 ],
+  [ 0, 0, 0 ],
+  [ 0, 0, 1 ]
+]
+
+Output:
+
+     |  1 0 0 |   | 7 0 0 |   |  7 0 0 |
+AB = | -1 0 3 | x | 0 0 0 | = | -7 0 3 |
+                  | 0 0 1 |
+
+*/
+
+/**
+ * @param {number[][]} A
+ * @param {number[][]} B
+ * @return {number[][]}
+ */
+const multiply = function(A, B) {
+  const aLen = A.length, bLen = B.length
+  if(aLen === 0 || bLen === 0) return []
+  const aCol = A[0].length, bCol = B[0].length
+  const res = Array.from({ length: aLen }, () => new Array(bCol).fill(0))
+  for(let i = 0; i < aLen; i++) {
+    for(let j = 0; j < bCol; j++) {
+      let tmp = 0
+      for(let k = 0; k < bLen; k++) {
+        tmp += A[i][k] * B[k][j]
+      }
+      res[i][j] = tmp
+    }
+  }
+  return res
+};

From ad857f0b0c04a8bbdae5a3966433aae2411b566d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Dec 2019 16:38:45 +0800
Subject: [PATCH 0202/3374] Create 1120-maximum-average-subtree.js

---
 1120-maximum-average-subtree.js | 47 +++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 1120-maximum-average-subtree.js

diff --git a/1120-maximum-average-subtree.js b/1120-maximum-average-subtree.js
new file mode 100644
index 00000000..4d02b632
--- /dev/null
+++ b/1120-maximum-average-subtree.js
@@ -0,0 +1,47 @@
+/**
+
+Given the root of a binary tree, find the maximum average value of any subtree of that tree.
+(A subtree of a tree is any node of that tree plus all its descendants.
+The average value of a tree is the sum of its values, divided by the number of nodes.)
+
+Example 1:
+
+Input: [5,6,1]
+Output: 6.00000
+Explanation: 
+For the node with value = 5 we have an average of (5 + 6 + 1) / 3 = 4.
+For the node with value = 6 we have an average of 6 / 1 = 6.
+For the node with value = 1 we have an average of 1 / 1 = 1.
+So the answer is 6 which is the maximum.
+
+Note:
+
+The number of nodes in the tree is between 1 and 5000.
+Each node will have a value between 0 and 100000.
+Answers will be accepted as correct if they are within 10^-5 of the correct answer.
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maximumAverageSubtree = function(root) {
+  let max = -Number.MIN_VALUE;
+  function helper(root) {
+    if (!root) return [0, 0]; // [value, number of nodes]
+    const [lTotal, lNum] = helper(root.left);
+    const [rTotal, rNum] = helper(root.right);
+    max = Math.max(max, (rTotal + lTotal + root.val) / (rNum + lNum + 1));
+    return [lTotal + rTotal + root.val, lNum + rNum + 1];
+  }
+  helper(root);
+  return max;
+};

From 1d4afa4c929a9356f870384fab7cdeb03ae13466 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Dec 2019 17:19:07 +0800
Subject: [PATCH 0203/3374] Create 170-two-sum-iii-data-structure-design.js

---
 170-two-sum-iii-data-structure-design.js | 37 ++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 170-two-sum-iii-data-structure-design.js

diff --git a/170-two-sum-iii-data-structure-design.js b/170-two-sum-iii-data-structure-design.js
new file mode 100644
index 00000000..3e478359
--- /dev/null
+++ b/170-two-sum-iii-data-structure-design.js
@@ -0,0 +1,37 @@
+/**
+ * Initialize your data structure here.
+ */
+const TwoSum = function() {
+  this.hm = new Map();
+};
+
+/**
+ * Add the number to an internal data structure..
+ * @param {number} number
+ * @return {void}
+ */
+TwoSum.prototype.add = function(number) {
+  this.hm.set(number, (this.hm.get(number) || 0) + 1);
+};
+
+/**
+ * Find if there exists any pair of numbers which sum is equal to the value.
+ * @param {number} value
+ * @return {boolean}
+ */
+TwoSum.prototype.find = function(value) {
+  for (let item of this.hm) {
+    let target = value - item[0];
+    if (this.hm.has(target)) {
+      if (target !== item[0] || this.hm.get(target) > 1) return true;
+    }
+  }
+  return false;
+};
+
+/**
+ * Your TwoSum object will be instantiated and called as such:
+ * var obj = new TwoSum()
+ * obj.add(number)
+ * var param_2 = obj.find(value)
+ */

From 69ba6837aeda6bdd8d46fc28f758921e43fd78d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Dec 2019 11:31:26 +0800
Subject: [PATCH 0204/3374] Create 624-maximum-distance-in-arrays.js

---
 624-maximum-distance-in-arrays.js | 47 +++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 624-maximum-distance-in-arrays.js

diff --git a/624-maximum-distance-in-arrays.js b/624-maximum-distance-in-arrays.js
new file mode 100644
index 00000000..020fad88
--- /dev/null
+++ b/624-maximum-distance-in-arrays.js
@@ -0,0 +1,47 @@
+/**
+
+Given m arrays, and each array is sorted in ascending order.
+Now you can pick up two integers from two different arrays (each array picks one)
+and calculate the distance.
+We define the distance between two integers a and b to be their absolute difference |a-b|.
+Your task is to find the maximum distance.
+
+Example 1:
+
+Input: 
+[[1,2,3],
+ [4,5],
+ [1,2,3]]
+
+Output: 4
+
+Explanation: 
+One way to reach the maximum distance 4 is to pick 1 in the first or third array and pick 5 in the second array.
+
+Note:
+Each given array will have at least 1 number. There will be at least two non-empty arrays.
+The total number of the integers in all the m arrays will be in the range of [2, 10000].
+The integers in the m arrays will be in the range of [-10000, 10000].
+
+*/
+
+/**
+ * @param {number[][]} arrays
+ * @return {number}
+ */
+const maxDistance = function(arrays) {
+  if (arrays == null) return 0
+  let result = 0
+  let min = arrays[0][0]
+  let max = arrays[0][arrays[0].length - 1]
+  for (let i = 1; i < arrays.length; i++) {
+    result = Math.max(
+      result,
+      Math.abs(arrays[i][arrays[i].length - 1] - min),
+      Math.abs(arrays[i][0] - max)
+    )
+    max = Math.max(max, arrays[i][arrays[i].length - 1])
+    min = Math.min(min, arrays[i][0])
+  }
+  return result
+}

From cc31fbde9eab0150253a65858569007bfac69a8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Dec 2019 13:25:37 +0800
Subject: [PATCH 0205/3374] Create 1118-number-of-days-in-a-month.js

---
 1118-number-of-days-in-a-month.js | 60 +++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 1118-number-of-days-in-a-month.js

diff --git a/1118-number-of-days-in-a-month.js b/1118-number-of-days-in-a-month.js
new file mode 100644
index 00000000..9185f9aa
--- /dev/null
+++ b/1118-number-of-days-in-a-month.js
@@ -0,0 +1,60 @@
+/**
+
+Given a year Y and a month M, return how many days there are in that month.
+
+Example 1:
+
+Input: Y = 1992, M = 7
+Output: 31
+Example 2:
+
+Input: Y = 2000, M = 2
+Output: 29
+Example 3:
+
+Input: Y = 1900, M = 2
+Output: 28
+
+Note:
+
+1583 <= Y <= 2100
+1 <= M <= 12
+
+*/
+
+/**
+ * @param {number} Y
+ * @param {number} M
+ * @return {number}
+ */
+function numberOfDays(Y, M) {
+  switch (M) {
+    case 2:
+      return Y % 400 === 0 || (Y % 4 === 0 && Y % 100 !== 0) ? 29 : 28;
+    case 4:
+    case 6:
+    case 9:
+    case 11:
+      return 30;
+    default:
+      return 31;
+  }
+}
+
+// another
+
+/**
+ * @param {number} Y
+ * @param {number} M
+ * @return {number}
+ */
+const numberOfDays = function(Y, M) {
+  const d = new Date(Y, M - 1)
+  let num = 0
+  while(d.getMonth() === M - 1) {
+    num++
+    const n = d.getDate()
+    d.setDate(n + 1)
+  }
+  return num
+};

From 8106fa600938217e95b5f70137f21740c312b302 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Dec 2019 13:26:56 +0800
Subject: [PATCH 0206/3374] Update 1118-number-of-days-in-a-month.js

---
 1118-number-of-days-in-a-month.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/1118-number-of-days-in-a-month.js b/1118-number-of-days-in-a-month.js
index 9185f9aa..f9a90c14 100644
--- a/1118-number-of-days-in-a-month.js
+++ b/1118-number-of-days-in-a-month.js
@@ -43,6 +43,12 @@ function numberOfDays(Y, M) {
 
 // another
 
+const numberOfDays = function(Y, M) {
+    return new Date(Y,M,0).getDate();
+};
+
+// another
+
 /**
  * @param {number} Y
  * @param {number} M

From afd28ca733a795e4259ee0689e60a49173132ac5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Dec 2019 13:56:46 +0800
Subject: [PATCH 0207/3374] Create 644-maximum-average-subarray-ii.js

---
 644-maximum-average-subarray-ii.js | 62 ++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 644-maximum-average-subarray-ii.js

diff --git a/644-maximum-average-subarray-ii.js b/644-maximum-average-subarray-ii.js
new file mode 100644
index 00000000..f9c70e0b
--- /dev/null
+++ b/644-maximum-average-subarray-ii.js
@@ -0,0 +1,62 @@
+/**
+
+Given an array consisting of n integers,
+find the contiguous subarray whose length is greater than or
+equal to k that has the maximum average value.
+And you need to output the maximum average value.
+
+Example 1:
+Input: [1,12,-5,-6,50,3], k = 4
+Output: 12.75
+Explanation:
+when length is 5, maximum average value is 10.8,
+when length is 6, maximum average value is 9.16667.
+Thus return 12.75.
+Note:
+1 <= k <= n <= 10,000.
+Elements of the given array will be in range [-10,000, 10,000].
+The answer with the calculation error less than 10-5 will be accepted.
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const findMaxAverage = function(nums, k) {
+  let left = nums[0]
+  let right = nums[0]
+  nums.forEach(num => {
+    left = Math.min(left, num)
+    right = Math.max(right, num)
+  })
+  const check = average => {
+    let rightSum = 0
+    let leftSum = 0
+    let minLeftSum = 0
+    for (let i = 0; i < k; i++) {
+      rightSum += nums[i] - average
+    }
+    for (let i = k; i <= nums.length; i++) {
+      if (rightSum - minLeftSum >= 0) {
+        return true
+      }
+      if (i < nums.length) {
+        rightSum += nums[i] - average
+        leftSum += nums[i - k] - average
+        minLeftSum = Math.min(leftSum, minLeftSum)
+      }
+    }
+    return false
+  }
+  while (left + 1e-5 < right) {
+    let mid = (left + right) / 2
+    if (check(mid)) {
+      left = mid
+    } else {
+      right = mid
+    }
+  }
+  return left
+}

From 97199e745383feae0cbad27d0444c855f8edb1ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Dec 2019 14:08:52 +0800
Subject: [PATCH 0208/3374] Create 1166-design-file-system.js

---
 1166-design-file-system.js | 48 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 1166-design-file-system.js

diff --git a/1166-design-file-system.js b/1166-design-file-system.js
new file mode 100644
index 00000000..c38762ab
--- /dev/null
+++ b/1166-design-file-system.js
@@ -0,0 +1,48 @@
+class Node {
+  constructor(v) {
+    this.val = v
+    this.children = new Map()
+  }
+}
+const FileSystem = function() {
+  this.r = new Node(null)
+};
+
+/** 
+ * @param {string} path 
+ * @param {number} value
+ * @return {boolean}
+ */
+FileSystem.prototype.createPath = function(path, value) {
+  if(path == null || path === '') return
+  const arr = path.split('/').filter(e => e !== '/' && e !== '')
+  let cur = this.r
+  for(let i = 0, len = arr.length; i < len; i++) {
+    if(i !== len - 1 && !cur.children.has(arr[i])) return false
+    if(i === len - 1 && cur.children.has(arr[i])) return false 
+    if(i !== len - 1) cur = cur.children.get(arr[i])
+  }
+  cur.children.set(arr[arr.length - 1], new Node(value))
+  return true
+};
+
+/** 
+ * @param {string} path
+ * @return {number}
+ */
+FileSystem.prototype.get = function(path) {
+  const arr = path.split('/').filter(e => e !== '/' && e !== '')
+  let cur = this.r
+  for(let i = 0, len = arr.length; i < len; i++) {
+    if(!cur.children.has(arr[i])) return -1
+    cur = cur.children.get(arr[i])
+  }
+  return cur.val
+};
+
+/** 
+ * Your FileSystem object will be instantiated and called as such:
+ * var obj = new FileSystem()
+ * var param_1 = obj.createPath(path,value)
+ * var param_2 = obj.get(path)
+ */

From 81e4b008e4d3d063436b872c791c39fa3d035b14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Dec 2019 14:56:17 +0800
Subject: [PATCH 0209/3374] Update 1166-design-file-system.js

---
 1166-design-file-system.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/1166-design-file-system.js b/1166-design-file-system.js
index c38762ab..8378b6d1 100644
--- a/1166-design-file-system.js
+++ b/1166-design-file-system.js
@@ -1,3 +1,40 @@
+
+const FileSystem = function() {
+  this.m = new Map()
+  this.m.set('', 1)
+};
+
+/** 
+ * @param {string} path 
+ * @param {number} value
+ * @return {boolean}
+ */
+FileSystem.prototype.createPath = function(path, value) {
+  if(this.m.has(path)) return false
+  const p = path.slice(0, path.lastIndexOf('/'))
+  if(!this.m.has(p)) return false
+  this.m.set(path, value)
+  return true
+};
+
+/** 
+ * @param {string} path
+ * @return {number}
+ */
+FileSystem.prototype.get = function(path) {
+  if(!this.m.has(path)) return -1
+  return this.m.get(path)
+};
+
+/** 
+ * Your FileSystem object will be instantiated and called as such:
+ * var obj = new FileSystem()
+ * var param_1 = obj.createPath(path,value)
+ * var param_2 = obj.get(path)
+ */
+
+// another
+
 class Node {
   constructor(v) {
     this.val = v

From 5d3ae63ffae4a45c1a56439fb2b636d8c78dbfae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Dec 2019 21:10:17 +0800
Subject: [PATCH 0210/3374] Create 161-one-edit-distance.js

---
 161-one-edit-distance.js | 50 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 161-one-edit-distance.js

diff --git a/161-one-edit-distance.js b/161-one-edit-distance.js
new file mode 100644
index 00000000..866ec378
--- /dev/null
+++ b/161-one-edit-distance.js
@@ -0,0 +1,50 @@
+/**
+
+Given two strings s and t, determine if they are both one edit distance apart.
+
+Note: 
+
+There are 3 possiblities to satisify one edit distance apart:
+
+Insert a character into s to get t
+Delete a character from s to get t
+Replace a character of s to get t
+Example 1:
+
+Input: s = "ab", t = "acb"
+Output: true
+Explanation: We can insert 'c' into s to get t.
+Example 2:
+
+Input: s = "cab", t = "ad"
+Output: false
+Explanation: We cannot get t from s by only one step.
+Example 3:
+
+Input: s = "1203", t = "1213"
+Output: true
+Explanation: We can replace '0' with '1' to get t.
+
+*/
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+const isOneEditDistance = function(s, t) {
+  const m = s.length,
+    n = t.length;
+  if (m > n) {
+    return isOneEditDistance(t, s);
+  }
+  for (let i = 0; i < m; i++) {
+    if (s[i] !== t[i]) {
+      if (m === n) {
+        return s.slice(i + 1) === t.slice(i + 1);
+      }
+      return s.slice(i) === t.slice(i + 1);
+    }
+  }
+  return m + 1 === n;
+};

From 6a6e656be08416de62b1a9560f66f5dd2d3c89df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Dec 2019 14:14:52 +0800
Subject: [PATCH 0211/3374] Create 366-find-leaves-of-binary-tree.js

---
 366-find-leaves-of-binary-tree.js | 69 +++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 366-find-leaves-of-binary-tree.js

diff --git a/366-find-leaves-of-binary-tree.js b/366-find-leaves-of-binary-tree.js
new file mode 100644
index 00000000..ee766cc1
--- /dev/null
+++ b/366-find-leaves-of-binary-tree.js
@@ -0,0 +1,69 @@
+/**
+
+Given a binary tree, collect a tree's nodes as if you were doing this:
+Collect and remove all leaves, repeat until the tree is empty. 
+
+Example:
+
+Input: [1,2,3,4,5]
+  
+          1
+         / \
+        2   3
+       / \     
+      4   5    
+
+Output: [[4,5,3],[2],[1]]
+ 
+Explanation:
+
+1. Removing the leaves [4,5,3] would result in this tree:
+
+          1
+         / 
+        2          
+ 
+2. Now removing the leaf [2] would result in this tree:
+
+          1          
+ 
+3. Now removing the leaf [1] would result in the empty tree:
+
+          []   
+
+*/
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const findLeaves = function(root) {
+  const res = []
+  if(root == null) return res
+  while(root.left || root.right) {
+    const tmp = []
+    leaves(root, null, tmp)
+    res.push(tmp)
+  }
+  res.push([root.val])
+  return res
+};
+
+function leaves(node, p, res) {
+  if(node == null) return
+  if(node.left === null && node.right === null) {
+    res.push(node.val)
+    if(p && p.left === node) p.left = null
+    if(p && p.right === node) p.right = null
+    return
+  }
+  leaves(node.left, node, res)
+  leaves(node.right, node, res)
+}

From 0ffb47c0e3583ad5c2a1a3b20b0df7f06319832f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Dec 2019 15:14:49 +0800
Subject: [PATCH 0212/3374] Update 366-find-leaves-of-binary-tree.js

---
 366-find-leaves-of-binary-tree.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/366-find-leaves-of-binary-tree.js b/366-find-leaves-of-binary-tree.js
index ee766cc1..a88ff385 100644
--- a/366-find-leaves-of-binary-tree.js
+++ b/366-find-leaves-of-binary-tree.js
@@ -67,3 +67,19 @@ function leaves(node, p, res) {
   leaves(node.left, node, res)
   leaves(node.right, node, res)
 }
+
+// another
+
+const findLeaves = function(root) {
+  const res = []
+  dfs(root, res)
+  return res
+};
+
+function dfs(node, res) {
+  if(node == null) return -1
+  const i = 1 + Math.max(dfs(node.left, res), dfs(node.right, res))
+  if(!res[i]) res[i] = []
+  res[i].push(node.val)
+  return i
+}

From 29fc409c8ffbbde8670bfe4a993d2f72838ff1f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Dec 2019 13:03:38 +0800
Subject: [PATCH 0213/3374] Create 1272-remove-interval.js

---
 1272-remove-interval.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1272-remove-interval.js

diff --git a/1272-remove-interval.js b/1272-remove-interval.js
new file mode 100644
index 00000000..16709b31
--- /dev/null
+++ b/1272-remove-interval.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} toBeRemoved
+ * @return {number[][]}
+ */
+const removeInterval = function(intervals, toBeRemoved) {
+  const n = intervals.length
+  if (n < 1) return []
+  const res = []
+  const [x, y] = toBeRemoved
+  for (const [a, b] of intervals) {
+    const lo = Math.max(a, x)
+    const hi = Math.min(b, y)
+    if (lo < hi) {
+      if (a < lo) {
+        res.push([a, lo])
+      }
+      if (hi < b) {
+        res.push([hi, b])
+      }
+    } else {
+      res.push([a, b])
+    }
+  }
+  return res
+}

From 0331a7ac3d8156c6789d9b264c0521bef2e44e9c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 09:28:33 +0800
Subject: [PATCH 0214/3374] Create 1068-product-sales-analysis-i.sql

---
 1068-product-sales-analysis-i.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1068-product-sales-analysis-i.sql

diff --git a/1068-product-sales-analysis-i.sql b/1068-product-sales-analysis-i.sql
new file mode 100644
index 00000000..fb17c96c
--- /dev/null
+++ b/1068-product-sales-analysis-i.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT p.product_name, s.year, s.price
+FROM
+    (SELECT DISTINCT product_id, year, price
+     FROM Sales) AS s
+INNER JOIN Product AS p
+WHERE s.product_id = p.product_id

From acfae946b94e9f29f318f0d91ff711f9228ecfb1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 09:32:37 +0800
Subject: [PATCH 0215/3374] Create 1070-product-sales-analysis-iii.sql

---
 1070-product-sales-analysis-iii.sql | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1070-product-sales-analysis-iii.sql

diff --git a/1070-product-sales-analysis-iii.sql b/1070-product-sales-analysis-iii.sql
new file mode 100644
index 00000000..dfa5ddef
--- /dev/null
+++ b/1070-product-sales-analysis-iii.sql
@@ -0,0 +1,12 @@
+# Write your MySQL query statement below
+select sub.product_id, 
+       sub.first_year, 
+       S.quantity,
+       S.price
+from (select product_id, 
+      min(year) as first_year
+      from Sales
+      group by product_id) sub, 
+      Sales S
+where S.product_id = sub.product_id
+and S.year = sub.first_year

From 6972f882dbe39de40438a8f3fd416b41bb550dea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 09:45:13 +0800
Subject: [PATCH 0216/3374] Create 1069-product-sales-analysis-ii.sql

---
 1069-product-sales-analysis-ii.sql | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 1069-product-sales-analysis-ii.sql

diff --git a/1069-product-sales-analysis-ii.sql b/1069-product-sales-analysis-ii.sql
new file mode 100644
index 00000000..b35be6c5
--- /dev/null
+++ b/1069-product-sales-analysis-ii.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+select product_id, sum(quantity) as total_quantity from Sales s group by product_id;

From a10f8487afb9ff142c5e8f844e8b0934c8ba0b69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 10:07:51 +0800
Subject: [PATCH 0217/3374] Create 1084-sales-analysis-iii.sql

---
 1084-sales-analysis-iii.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1084-sales-analysis-iii.sql

diff --git a/1084-sales-analysis-iii.sql b/1084-sales-analysis-iii.sql
new file mode 100644
index 00000000..a58724c0
--- /dev/null
+++ b/1084-sales-analysis-iii.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT product_id, product_name
+FROM Sales 
+JOIN Product 
+Using(product_id)
+GROUP BY product_id
+HAVING MIN(sale_date) >= '2019-01-01' AND MAX(sale_date) <= '2019-03-31' 

From 9b979ebc9afc9ffc2232a3d63064e6381aeee69b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 10:26:10 +0800
Subject: [PATCH 0218/3374] Create 1082-sales-analysis-i.sql

---
 1082-sales-analysis-i.sql | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1082-sales-analysis-i.sql

diff --git a/1082-sales-analysis-i.sql b/1082-sales-analysis-i.sql
new file mode 100644
index 00000000..f60b4738
--- /dev/null
+++ b/1082-sales-analysis-i.sql
@@ -0,0 +1,12 @@
+# Write your MySQL query statement below
+select a.seller_id from
+(select seller_id, sum(price) as p from Sales
+group by seller_id) a
+join 
+(select  sum(price) p 
+from Sales
+group by seller_id
+order by 1 desc
+ limit 1
+ ) b
+ on a.p = b.p 

From 433c16ef76d67fc814638109dba826fd8787b161 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 10:29:25 +0800
Subject: [PATCH 0219/3374] Update 1082-sales-analysis-i.sql

---
 1082-sales-analysis-i.sql | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/1082-sales-analysis-i.sql b/1082-sales-analysis-i.sql
index f60b4738..39fb6d3e 100644
--- a/1082-sales-analysis-i.sql
+++ b/1082-sales-analysis-i.sql
@@ -1,12 +1,9 @@
 # Write your MySQL query statement below
-select a.seller_id from
-(select seller_id, sum(price) as p from Sales
-group by seller_id) a
-join 
-(select  sum(price) p 
+select seller_id from Sales
+group by seller_id
+having sum(price) =
+(select sum(price) as sm
 from Sales
 group by seller_id
-order by 1 desc
- limit 1
- ) b
- on a.p = b.p 
+order by sm desc
+limit 1);

From 6796b4f3d8d73b5ba16468bd73ad034b515b94b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 10:39:05 +0800
Subject: [PATCH 0220/3374] Create 1083-sales-analysis-ii.sql

---
 1083-sales-analysis-ii.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1083-sales-analysis-ii.sql

diff --git a/1083-sales-analysis-ii.sql b/1083-sales-analysis-ii.sql
new file mode 100644
index 00000000..b4d215c8
--- /dev/null
+++ b/1083-sales-analysis-ii.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+select distinct buyer_id from sales s
+join product p
+on p.product_id = s.product_id 
+where buyer_id not in (
+  select distinct buyer_id from sales s
+  join product p on 
+  s.product_id = p.product_id 
+  where product_name = 'iPhone'
+) and product_name='S8';

From 1f58d41ccdb58e96a8b6e7a966b5585b1bc075f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 10:45:41 +0800
Subject: [PATCH 0221/3374] Create 607-sales-person.sql

---
 607-sales-person.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 607-sales-person.sql

diff --git a/607-sales-person.sql b/607-sales-person.sql
new file mode 100644
index 00000000..7b2051eb
--- /dev/null
+++ b/607-sales-person.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+select name
+from salesperson
+where sales_id not in (select sales_id from
+orders left join company
+on orders.com_id = company.com_id
+where company.name = 'red');

From 2d9197a9979da7e3dfcd603fa82f9ac4463e80b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 11:02:13 +0800
Subject: [PATCH 0222/3374] Create 569-median-employee-salary.sql

---
 569-median-employee-salary.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 569-median-employee-salary.sql

diff --git a/569-median-employee-salary.sql b/569-median-employee-salary.sql
new file mode 100644
index 00000000..d92fb3c3
--- /dev/null
+++ b/569-median-employee-salary.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT a.Id, a.Company, a.Salary
+FROM (
+    SELECT e.Id, e.Company, e.Salary,
+        IF(@prev = e.Company, @rank := @rank+1, @rank := 1) AS Ranking,
+        @prev := e.Company
+    FROM Employee e, (SELECT @rank := 0, @prev := 0) AS t
+    ORDER BY e.Company, e.Salary #, e.Id
+) AS a, (
+    SELECT Company, COUNT(*) AS cnt
+    FROM Employee
+    GROUP BY Company
+) AS b
+WHERE a.Company = b.Company AND Ranking IN (FLOOR((cnt+1)/2), FLOOR((cnt+2)/2));

From dabded8880a80a3a19c8d4207491a47e34f7ac58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 11:19:08 +0800
Subject: [PATCH 0223/3374] Create 1075-project-employees-i.sql

---
 1075-project-employees-i.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1075-project-employees-i.sql

diff --git a/1075-project-employees-i.sql b/1075-project-employees-i.sql
new file mode 100644
index 00000000..4384a49a
--- /dev/null
+++ b/1075-project-employees-i.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT p.project_id,
+ROUND(AVG(e.experience_years), 2) AS average_years
+FROM Project AS p
+INNER JOIN Employee AS e
+ON p.employee_id = e.employee_id
+GROUP BY p.project_id;

From 5aff15ed3dedf736ed65ec8a2e435b10d5663716 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 11:25:42 +0800
Subject: [PATCH 0224/3374] Create 1076-project-employees-ii.sql

---
 1076-project-employees-ii.sql | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1076-project-employees-ii.sql

diff --git a/1076-project-employees-ii.sql b/1076-project-employees-ii.sql
new file mode 100644
index 00000000..b24cd3f0
--- /dev/null
+++ b/1076-project-employees-ii.sql
@@ -0,0 +1,11 @@
+# Write your MySQL query statement below
+SELECT project_id
+FROM project
+GROUP BY project_id
+HAVING COUNT(*) = (
+    SELECT COUNT(*) cnt
+    FROM project
+    GROUP BY project_id 
+    ORDER BY cnt DESC 
+    LIMIT 1
+);

From 96ef2093d980f2a98623ddecad96080dfd80d7aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 11:51:22 +0800
Subject: [PATCH 0225/3374] Create 1077-project-employees-iii.sql

---
 1077-project-employees-iii.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1077-project-employees-iii.sql

diff --git a/1077-project-employees-iii.sql b/1077-project-employees-iii.sql
new file mode 100644
index 00000000..254561ee
--- /dev/null
+++ b/1077-project-employees-iii.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT P.project_id, E.employee_id
+FROM Project as P 
+INNER JOIN Employee as E On E.employee_id = P.employee_id
+WHERE (P.project_id , E.experience_years) in (
+SELECT P.project_id, MAX(E.experience_years)
+FROM Project as P 
+INNER JOIN Employee as E On E.employee_id = P.employee_id
+GROUP BY P.project_id);

From 765a861679e5519a6c954361510caa9442a7459f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 12:11:24 +0800
Subject: [PATCH 0226/3374] Create 1173-immediate-food-delivery-i.sql

---
 1173-immediate-food-delivery-i.sql | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 1173-immediate-food-delivery-i.sql

diff --git a/1173-immediate-food-delivery-i.sql b/1173-immediate-food-delivery-i.sql
new file mode 100644
index 00000000..03068217
--- /dev/null
+++ b/1173-immediate-food-delivery-i.sql
@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+select round(100 * sum(order_date = customer_pref_delivery_date) / count(*), 2)
+as immediate_percentage from Delivery;

From 8dc01dcf71418966cccdd2db9bbb349fef09dadf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 12:25:22 +0800
Subject: [PATCH 0227/3374] Create 1174-immediate-food-delivery-ii.sql

---
 1174-immediate-food-delivery-ii.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1174-immediate-food-delivery-ii.sql

diff --git a/1174-immediate-food-delivery-ii.sql b/1174-immediate-food-delivery-ii.sql
new file mode 100644
index 00000000..12308311
--- /dev/null
+++ b/1174-immediate-food-delivery-ii.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+select 
+round(100*sum(case when b.min_order_date = b.min_delivery_date then 1 else 0 end)/count(*), 2)
+as immediate_percentage
+from (
+  select min(order_date) as min_order_date, min(customer_pref_delivery_date) as min_delivery_date
+  from delivery
+  group by customer_id
+) b;

From 18b0779190bebac0b03fa3d502872b122d69f754 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 15:24:49 +0800
Subject: [PATCH 0228/3374] Create 156-binary-tree-upside-down.js

---
 156-binary-tree-upside-down.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 156-binary-tree-upside-down.js

diff --git a/156-binary-tree-upside-down.js b/156-binary-tree-upside-down.js
new file mode 100644
index 00000000..0fe85375
--- /dev/null
+++ b/156-binary-tree-upside-down.js
@@ -0,0 +1,26 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const upsideDownBinaryTree = function(root) {
+  let curr = root
+  let next = null
+  let temp = null
+  let prev = null
+  while (curr !== null) {
+    next = curr.left
+    curr.left = temp
+    temp = curr.right
+    curr.right = prev
+    prev = curr
+    curr = next
+  }
+  return prev
+}

From f869b7ce15d69627e3fb0ba877194bd6704bdcfa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 22:49:21 +0800
Subject: [PATCH 0229/3374] Update 156-binary-tree-upside-down.js

---
 156-binary-tree-upside-down.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/156-binary-tree-upside-down.js b/156-binary-tree-upside-down.js
index 0fe85375..0be7cc53 100644
--- a/156-binary-tree-upside-down.js
+++ b/156-binary-tree-upside-down.js
@@ -24,3 +24,17 @@ const upsideDownBinaryTree = function(root) {
   }
   return prev
 }
+
+// another
+
+const upsideDownBinaryTree = function(root) {
+  if (root == null || root.left == null) {
+    return root
+  }
+  const newRoot = upsideDownBinaryTree(root.left)
+  root.left.left = root.right
+  root.left.right = root
+  root.left = null
+  root.right = null
+  return newRoot
+}

From 2d6fed58b2fb4893584cea4b1d7e793f9a9d99f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 22:57:44 +0800
Subject: [PATCH 0230/3374] Add files via upload

---
 images/binary-tree-upside-down.webp | Bin 0 -> 6966 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/binary-tree-upside-down.webp

diff --git a/images/binary-tree-upside-down.webp b/images/binary-tree-upside-down.webp
new file mode 100644
index 0000000000000000000000000000000000000000..22974412663c50cef9e7e39df034ee6a93cb7584
GIT binary patch
literal 6966
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

literal 0
HcmV?d00001


From 5709c3267cb2bef4f16474d1f1922ca08ce529a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 23:02:08 +0800
Subject: [PATCH 0231/3374] Create 156-binary-tree-upside-down.md

---
 detailed/156-binary-tree-upside-down.md | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 detailed/156-binary-tree-upside-down.md

diff --git a/detailed/156-binary-tree-upside-down.md b/detailed/156-binary-tree-upside-down.md
new file mode 100644
index 00000000..571e5c9c
--- /dev/null
+++ b/detailed/156-binary-tree-upside-down.md
@@ -0,0 +1,44 @@
+![alt text](https://github.com/everthis/leetcode-js/blob/master/images/binary-tree-upside-down.webp "binary-tree-upside-down")
+
+```js
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const upsideDownBinaryTree = function(root) {
+  let curr = root
+  let next = null
+  let temp = null
+  let prev = null
+  while (curr !== null) {
+    next = curr.left
+    curr.left = temp
+    temp = curr.right
+    curr.right = prev
+    prev = curr
+    curr = next
+  }
+  return prev
+}
+
+// another
+
+const upsideDownBinaryTree = function(root) {
+  if (root == null || root.left == null) {
+    return root
+  }
+  const newRoot = upsideDownBinaryTree(root.left)
+  root.left.left = root.right
+  root.left.right = root
+  root.left = null
+  root.right = null
+  return newRoot
+}
+```

From 2e4970bcdf41a6235622c4b048ebea36a2546f9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2019 23:30:27 +0800
Subject: [PATCH 0232/3374] Update 156-binary-tree-upside-down.js

---
 156-binary-tree-upside-down.js | 23 ++++++++++-------------
 1 file changed, 10 insertions(+), 13 deletions(-)

diff --git a/156-binary-tree-upside-down.js b/156-binary-tree-upside-down.js
index 0be7cc53..f5e6e354 100644
--- a/156-binary-tree-upside-down.js
+++ b/156-binary-tree-upside-down.js
@@ -10,20 +10,17 @@
  * @return {TreeNode}
  */
 const upsideDownBinaryTree = function(root) {
-  let curr = root
-  let next = null
-  let temp = null
-  let prev = null
-  while (curr !== null) {
-    next = curr.left
-    curr.left = temp
-    temp = curr.right
-    curr.right = prev
-    prev = curr
-    curr = next
+  let node = root, parent = null, right = null
+  while(node !== null) {
+    const left = node.left
+    node.left = right
+    right = node.right
+    node.right = parent
+    parent = node
+    node = left
   }
-  return prev
-}
+  return parent
+};
 
 // another
 

From 81a1f68433f210ad331f89c9209208d1082bd0c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jan 2020 09:51:58 +0800
Subject: [PATCH 0233/3374] Create 157-read-n-characters-given-read4.js

---
 157-read-n-characters-given-read4.js | 36 ++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 157-read-n-characters-given-read4.js

diff --git a/157-read-n-characters-given-read4.js b/157-read-n-characters-given-read4.js
new file mode 100644
index 00000000..82dfc29e
--- /dev/null
+++ b/157-read-n-characters-given-read4.js
@@ -0,0 +1,36 @@
+/**
+ * Definition for read4()
+ *
+ * @param {character[]} buf Destination buffer
+ * @return {number} The number of actual characters read
+ * read4 = function(buf) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} read4()
+ * @return {function}
+ */
+const solution = function(read4) {
+  const internalBuf = []
+  /**
+   * @param {character[]} buf Destination buffer
+   * @param {number} n Number of characters to read
+   * @return {number} The number of actual characters read
+   */
+  return function(buf, n) {
+    let readChars = 0
+    while (n > 0) {
+      if (internalBuf.length === 0) {
+        if (read4(internalBuf) === 0) {
+          return readChars
+        }
+      }
+      buf.push(internalBuf.shift())
+      readChars++
+      n--
+    }
+    return readChars
+  }
+}

From 4213b8f6e49a85115a3d7be74e0676485e2d91f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jan 2020 10:53:27 +0800
Subject: [PATCH 0234/3374] Create
 158-read-n-characters-given-read4-ii-call-multiple-times.js

---
 ...ters-given-read4-ii-call-multiple-times.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 158-read-n-characters-given-read4-ii-call-multiple-times.js

diff --git a/158-read-n-characters-given-read4-ii-call-multiple-times.js b/158-read-n-characters-given-read4-ii-call-multiple-times.js
new file mode 100644
index 00000000..efb12750
--- /dev/null
+++ b/158-read-n-characters-given-read4-ii-call-multiple-times.js
@@ -0,0 +1,36 @@
+/**
+ * Definition for read4()
+ *
+ * @param {character[]} buf Destination buffer
+ * @return {number} The number of characters read
+ * read4 = function(buf) {
+ *     ...
+ * };
+ */
+
+/**
+ * @param {function} read4()
+ * @return {function}
+ */
+const solution = function(read4) {
+  const internalBuf = []
+  /**
+   * @param {character[]} buf Destination buffer
+   * @param {number} n Number of characters to read
+   * @return {number} The number of actual characters read
+   */
+  return function(buf, n) {
+    let readChars = 0
+    while (n > 0) {
+      if (internalBuf.length === 0) {
+        if (read4(internalBuf) === 0) {
+          return readChars
+        }
+      }
+      buf.push(internalBuf.shift())
+      readChars++
+      n--
+    }
+    return readChars
+  }
+}

From a70736908a1613057f25f67ee68c937dade978ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jan 2020 13:15:35 +0800
Subject: [PATCH 0235/3374] Create
 159-longest-substring-with-at-most-two-distinct-characters.js

---
 ...ng-with-at-most-two-distinct-characters.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 159-longest-substring-with-at-most-two-distinct-characters.js

diff --git a/159-longest-substring-with-at-most-two-distinct-characters.js b/159-longest-substring-with-at-most-two-distinct-characters.js
new file mode 100644
index 00000000..0069690e
--- /dev/null
+++ b/159-longest-substring-with-at-most-two-distinct-characters.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstringTwoDistinct = function(s) {
+  const map = new Map()
+  let start = 0,
+    end = 0,
+    counter = 0,
+    len = 0
+  while (end < s.length) {
+    let c = s.charAt(end)
+    map.set(c, (map.get(c) || 0) + 1)
+    if (map.get(c) === 1) counter++
+    end++
+    while (counter > 2) {
+      let cTemp = s.charAt(start)
+      map.set(cTemp, map.get(cTemp) - 1)
+      if (map.get(cTemp) === 0) {
+        counter--
+      }
+      start++
+    }
+    len = Math.max(len, end - start)
+  }
+  return len
+}

From 0844bd87fa9c96abaad267e134157a4d46ed9194 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jan 2020 12:45:22 +0800
Subject: [PATCH 0236/3374] Create 163-missing-ranges.js

---
 163-missing-ranges.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 163-missing-ranges.js

diff --git a/163-missing-ranges.js b/163-missing-ranges.js
new file mode 100644
index 00000000..eab02268
--- /dev/null
+++ b/163-missing-ranges.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {string[]}
+ */
+const findMissingRanges = function(nums, lower, upper) {
+  const res = [];
+  let next = lower;
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] < next) continue;
+    if (nums[i] === next) {
+      next++;
+      continue;
+    }
+    range(next, nums[i] - 1, res);
+    next = nums[i] + 1;
+  }
+  if (next <= upper) range(next, upper, res);
+  return res;
+  function range(l, r, a) {
+    a.push(l < r ? `${l}->${r}` : `${l}`)
+  }
+};
+    

From 9b79a8645dabce3889804a7a8752f42733e47bf0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jan 2020 14:09:08 +0800
Subject: [PATCH 0237/3374] Update 163-missing-ranges.js

---
 163-missing-ranges.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/163-missing-ranges.js b/163-missing-ranges.js
index eab02268..40aabd0a 100644
--- a/163-missing-ranges.js
+++ b/163-missing-ranges.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {string[]}
+ */
+const findMissingRanges = function(nums, lower, upper) {
+  const list = []
+  for (let n of nums) {
+    let justBelow = n - 1
+    if (lower === justBelow) list.push(lower + '')
+    else if (lower < justBelow) list.push(lower + '->' + justBelow)
+    lower = n + 1
+  }
+  if (lower === upper) list.push(lower + '')
+  else if (lower < upper) list.push(lower + '->' + upper)
+  return list
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} lower

From 7d1865b741dff8c8834db99fee5279f8bf62ebf7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jan 2020 14:22:18 +0800
Subject: [PATCH 0238/3374] Create 186-reverse-words-in-a-string-ii.js

---
 186-reverse-words-in-a-string-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 186-reverse-words-in-a-string-ii.js

diff --git a/186-reverse-words-in-a-string-ii.js b/186-reverse-words-in-a-string-ii.js
new file mode 100644
index 00000000..bc2b78c0
--- /dev/null
+++ b/186-reverse-words-in-a-string-ii.js
@@ -0,0 +1,22 @@
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+const reverseWords = function(s) {
+  reverse(s, 0, s.length - 1)
+  for (let i = 0, j = 0; i <= s.length; i++) {
+    if (i == s.length || s[i] == ' ') {
+      reverse(s, j, i - 1)
+      j = i + 1
+    }
+  }
+}
+function reverse(s, begin, end) {
+  while (begin < end) {
+    let c = s[begin]
+    s[begin] = s[end]
+    s[end] = c
+    begin++
+    end--
+  }
+}

From 0c9a5bd2caf8f0af2db0c200b0ccdb1a0bf804a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jan 2020 16:01:00 +0800
Subject: [PATCH 0239/3374] Create 243-shortest-word-distance.js

---
 243-shortest-word-distance.js | 40 +++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 243-shortest-word-distance.js

diff --git a/243-shortest-word-distance.js b/243-shortest-word-distance.js
new file mode 100644
index 00000000..324015ff
--- /dev/null
+++ b/243-shortest-word-distance.js
@@ -0,0 +1,40 @@
+/**
+
+Given a list of words and two words word1 and word2,
+return the shortest distance between these two words in the list.
+
+Example:
+Assume that words = ["practice", "makes", "perfect", "coding", "makes"].
+
+Input: word1 = “coding”, word2 = “practice”
+Output: 3
+Input: word1 = "makes", word2 = "coding"
+Output: 1
+
+Note:
+You may assume that word1 does not equal to word2, and word1 and word2 are both in the list.
+
+*/
+
+/**
+ * @param {string[]} words
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const shortestDistance = function(words, word1, word2) {
+  let w1 = -1
+  let w2 = -1
+  let min = Number.MAX_VALUE
+  for (let i = 0; i < words.length; i++) {
+    if (words[i] === word1) {
+      w1 = i
+    } else if (words[i] === word2) {
+      w2 = i
+    }
+    if (w1 >= 0 && w2 >= 0) {
+      min = Math.min(min, Math.abs(w1 - w2))
+    }
+  }
+  return min
+}

From 2bf4c8cb8d6b71b0eb3f85eedb6e6c3871611b57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jan 2020 16:34:13 +0800
Subject: [PATCH 0240/3374] Create 244-shortest-word-distance-ii.js

---
 244-shortest-word-distance-ii.js | 37 ++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 244-shortest-word-distance-ii.js

diff --git a/244-shortest-word-distance-ii.js b/244-shortest-word-distance-ii.js
new file mode 100644
index 00000000..7bf6f7c1
--- /dev/null
+++ b/244-shortest-word-distance-ii.js
@@ -0,0 +1,37 @@
+/**
+ * @param {string[]} words
+ */
+const WordDistance = function(words) {
+  this.wordMap = {}
+  for (let i = 0; i < words.length; i++) {
+    const word = words[i]
+    if (!this.wordMap[word]) this.wordMap[word] = []
+    this.wordMap[word].push(i)
+  }
+}
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+WordDistance.prototype.shortest = function(word1, word2) {
+  let min = Infinity
+  const iList = this.wordMap[word1]
+  const jList = this.wordMap[word2]
+  for (let i = 0, j = 0; i < iList.length && j < jList.length; ) {
+    min = Math.min(min, Math.abs(iList[i] - jList[j]))
+    if (iList[i] < jList[j]) {
+      i++
+    } else {
+      j++
+    }
+  }
+  return min
+}
+
+/**
+ * Your WordDistance object will be instantiated and called as such:
+ * var obj = new WordDistance(words)
+ * var param_1 = obj.shortest(word1,word2)
+ */

From 17a3546cc97d9aefae8f591a4bda0cab9a271865 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jan 2020 21:18:51 +0800
Subject: [PATCH 0241/3374] Create 245-shortest-word-distance-iii.js

---
 245-shortest-word-distance-iii.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 245-shortest-word-distance-iii.js

diff --git a/245-shortest-word-distance-iii.js b/245-shortest-word-distance-iii.js
new file mode 100644
index 00000000..4fae325c
--- /dev/null
+++ b/245-shortest-word-distance-iii.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string[]} words
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const shortestWordDistance = function(words, word1, word2) {
+  let l = Infinity
+  let r = Infinity
+  let res = Infinity
+  const same = word1 === word2
+  for (let i = 0; i < words.length; i++) {
+    if (same) r = l
+    if (words[i] === word1) {
+      l = i
+    } else if (words[i] === word2) {
+      r = i
+    } else {
+      continue
+    }
+    res = Math.min(res, Math.abs(l - r))
+  }
+  return res
+}

From 6c73fce038292cc619aed8ee00026dad92ec1846 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jan 2020 09:30:55 +0800
Subject: [PATCH 0242/3374] Create 246-strobogrammatic-number.js

---
 246-strobogrammatic-number.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 246-strobogrammatic-number.js

diff --git a/246-strobogrammatic-number.js b/246-strobogrammatic-number.js
new file mode 100644
index 00000000..134b4d38
--- /dev/null
+++ b/246-strobogrammatic-number.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} num
+ * @return {boolean}
+ */
+const isStrobogrammatic = function(num) {
+  const m = {
+    0: 0,
+    1: 1,
+    2: null,
+    3: null,
+    4: null,
+    5: null,
+    6: 9,
+    7: null,
+    8: 8,
+    9: 6
+  }
+  const arr = num.split('')
+  for(let i = 0, len = arr.length; i < len; i++) {
+    if(m[arr[i]] === null) return false
+    else arr[i] = m[arr[i]]
+  }
+  return num === arr.reverse().join('')
+};

From 36ce0934e064d089ba2b40da59b17caf253618f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jan 2020 09:32:52 +0800
Subject: [PATCH 0243/3374] Update 246-strobogrammatic-number.js

---
 246-strobogrammatic-number.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/246-strobogrammatic-number.js b/246-strobogrammatic-number.js
index 134b4d38..c02c9772 100644
--- a/246-strobogrammatic-number.js
+++ b/246-strobogrammatic-number.js
@@ -22,3 +22,23 @@ const isStrobogrammatic = function(num) {
   }
   return num === arr.reverse().join('')
 };
+
+// another
+
+const isStrobogrammatic = function(num) {
+  const map = { 0: '0', 1: '1', 8: '8', 6: '9', 9: '6' }
+  let left = 0
+  let right = num.length - 1
+
+  while (left < right) {
+    const leftNum = num[left]
+    const rightNum = num[right]
+    if (map[leftNum] != rightNum) return false
+    left++
+    right--
+  }
+  if (right == left) {
+    if (!map[num[right]] || num[right] == '9' || num[right] == '6') return false
+  }
+  return true
+}

From 9c2b876dd3aa40f5ca41db89535f93734234b207 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jan 2020 10:31:05 +0800
Subject: [PATCH 0244/3374] Create 247-strobogrammatic-number-ii.js

---
 247-strobogrammatic-number-ii.js | 45 ++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 247-strobogrammatic-number-ii.js

diff --git a/247-strobogrammatic-number-ii.js b/247-strobogrammatic-number-ii.js
new file mode 100644
index 00000000..17d7e188
--- /dev/null
+++ b/247-strobogrammatic-number-ii.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+const findStrobogrammatic = function(n) {
+  return recursionHelper(n, n)
+}
+const recursionHelper = function(n, m) {
+  if (n === 0) return ['']
+  if (n === 1) return ['0', '1', '8']
+  let rtnArr = recursionHelper(n - 2, m)
+  let res = []
+  for (let i = 0; i < rtnArr.length; i++) {
+    if (n !== m) res.push('0' + rtnArr[i] + '0')
+    res.push('1' + rtnArr[i] + '1')
+    res.push('6' + rtnArr[i] + '9')
+    res.push('8' + rtnArr[i] + '8')
+    res.push('9' + rtnArr[i] + '6')
+  }
+  return res
+}
+
+// another
+
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+const findStrobogrammatic = function(n) {
+  let cur, ans
+  ans = (n & 1) == 0 ? [''] : ['0', '1', '8']
+  if (n < 2) return ans
+  for (; n > 1; n -= 2) {
+    cur = ans
+    ans = []
+    for (let i of cur) {
+      if (n > 3) ans.push('0' + i + '0')
+      ans.push('1' + i + '1')
+      ans.push('8' + i + '8')
+      ans.push('6' + i + '9')
+      ans.push('9' + i + '6')
+    }
+  }
+  return ans
+}

From 15c911c25bb80afd372571629d57afcd2226abbc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jan 2020 11:24:09 +0800
Subject: [PATCH 0245/3374] Create 248-strobogrammatic-number-iii.js

---
 248-strobogrammatic-number-iii.js | 43 +++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 248-strobogrammatic-number-iii.js

diff --git a/248-strobogrammatic-number-iii.js b/248-strobogrammatic-number-iii.js
new file mode 100644
index 00000000..c3701d02
--- /dev/null
+++ b/248-strobogrammatic-number-iii.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} low
+ * @param {string} high
+ * @return {number}
+ */
+const strobogrammaticInRange = function(low, high) {
+  const pairs = [
+    ['0', '0'],
+    ['1', '1'],
+    ['6', '9'],
+    ['8', '8'],
+    ['9', '6']
+  ]
+  let count = 0
+  function dfs(left, right, current) {
+    if (left > right) {
+      const s = current.join('')
+      if (
+        (s.length === low.length && s < low) ||
+        (s.length === high.length && s > high)
+      ) {
+        return
+      }
+      count++
+      return
+    }
+    for (const [p1, p2] of pairs) {
+      current[left] = p1
+      current[right] = p2
+      if (left === right && p1 !== p2) {
+        continue
+      }
+      if (current.length !== 1 && current[0] === '0') {
+        continue
+      }
+      dfs(left + 1, right - 1, current)
+    }
+  }
+  for (let i = low.length; i <= high.length; i++) {
+    dfs(0, i - 1, Array(i).fill(''))
+  }
+  return count
+}

From e4204724ea4b87cf38f837e36f7d302938fd0e6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jan 2020 13:51:20 +0800
Subject: [PATCH 0246/3374] Create 249-group-shifted-strings.js

---
 249-group-shifted-strings.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 249-group-shifted-strings.js

diff --git a/249-group-shifted-strings.js b/249-group-shifted-strings.js
new file mode 100644
index 00000000..54f6abec
--- /dev/null
+++ b/249-group-shifted-strings.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string[]} strings
+ * @return {string[][]}
+ */
+const groupStrings = function(strings) {
+  const m = {}
+  for(let e of strings) {
+    const key = gkey(e)
+    let list
+    if(m.hasOwnProperty(key)) {
+      list = m[key]
+    } else {
+      list = []
+    }
+    list.push(e)
+    m[key] = list
+  }
+  return Object.values(m)
+};
+
+function gkey(str) {
+  let res = ''
+  for(let i = 1, len = str.length; i < len; i++) {
+    const diff = str.charCodeAt(i) - str.charCodeAt(i - 1)
+    res += `${diff < 0 ? diff + 26 : diff},`
+  }
+  return res
+}

From 8101553e1a369afbc6a51712d84df1914921ffe9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jan 2020 09:52:38 +0800
Subject: [PATCH 0247/3374] Create 251-flatten-2d-vector.js

---
 251-flatten-2d-vector.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 251-flatten-2d-vector.js

diff --git a/251-flatten-2d-vector.js b/251-flatten-2d-vector.js
new file mode 100644
index 00000000..f0f2c23a
--- /dev/null
+++ b/251-flatten-2d-vector.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} v
+ */
+const Vector2D = function(v) {
+  this.a = []
+  this.idx = 0
+  v.forEach(el => this.a.push(...el))
+};
+
+/**
+ * @return {number}
+ */
+Vector2D.prototype.next = function() {
+  return this.a[this.idx++]
+};
+
+/**
+ * @return {boolean}
+ */
+Vector2D.prototype.hasNext = function() {
+  return this.idx <= this.a.length - 1
+};
+
+/** 
+ * Your Vector2D object will be instantiated and called as such:
+ * var obj = new Vector2D(v)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */

From 7cbb085666a33c0de43c8fee16dd661eda1009a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jan 2020 09:58:34 +0800
Subject: [PATCH 0248/3374] Update 251-flatten-2d-vector.js

---
 251-flatten-2d-vector.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/251-flatten-2d-vector.js b/251-flatten-2d-vector.js
index f0f2c23a..1a1e2f76 100644
--- a/251-flatten-2d-vector.js
+++ b/251-flatten-2d-vector.js
@@ -27,3 +27,38 @@ Vector2D.prototype.hasNext = function() {
  * var param_1 = obj.next()
  * var param_2 = obj.hasNext()
  */
+
+// another
+
+/**
+ * @param {number[][]} v
+ */
+const Vector2D = function(v) {
+  this.iterator = v[Symbol.iterator]()
+  this.row = this.iterator.next()
+  this.idx = 0
+}
+/**
+ * @return {number}
+ */
+Vector2D.prototype.next = function() {
+  if (this.hasNext()) {
+    return this.row.value[this.idx++]
+  }
+}
+/**
+ * @return {boolean}
+ */
+Vector2D.prototype.hasNext = function() {
+  while (this.row.done == false && this.idx == this.row.value.length) {
+    this.row = this.iterator.next()
+    this.idx = 0
+  }
+  return this.row.done == false
+}
+/**
+ * Your Vector2D object will be instantiated and called as such:
+ * var obj = new Vector2D(v)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */

From e6ed3a6bdde9d324c6b1af74eca22187601245d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jan 2020 11:11:25 +0800
Subject: [PATCH 0249/3374] Create
 255-verify-preorder-sequence-in-binary-search-tree.js

---
 ...rify-preorder-sequence-in-binary-search-tree.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 255-verify-preorder-sequence-in-binary-search-tree.js

diff --git a/255-verify-preorder-sequence-in-binary-search-tree.js b/255-verify-preorder-sequence-in-binary-search-tree.js
new file mode 100644
index 00000000..4457702c
--- /dev/null
+++ b/255-verify-preorder-sequence-in-binary-search-tree.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} preorder
+ * @return {boolean}
+ */
+const verifyPreorder = function(preorder) {
+  let low = Number.MIN_VALUE,
+    i = -1
+  for (let p of preorder) {
+    if (p < low) return false
+    while (i >= 0 && p > preorder[i]) low = preorder[i--]
+    preorder[++i] = p
+  }
+  return true
+}

From 77c9060c1d96b27bc168f78796ac6a258f096331 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jan 2020 09:50:05 +0800
Subject: [PATCH 0250/3374] Create 261-graph-valid-tree.js

---
 261-graph-valid-tree.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 261-graph-valid-tree.js

diff --git a/261-graph-valid-tree.js b/261-graph-valid-tree.js
new file mode 100644
index 00000000..9ed367bb
--- /dev/null
+++ b/261-graph-valid-tree.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean}
+ */
+const validTree = function(n, edges) {
+  const nums = Array(n).fill(-1)
+  for(let i = 0; i < edges.length; i++) {
+    const x = find(nums, edges[i][0])
+    const y = find(nums, edges[i][1])
+    if(x === y) return false
+    nums[x] = y
+  }
+  return edges.length === n - 1
+  function find(arr, i) {
+    if(arr[i] === -1) return i
+    return find(arr, arr[i])
+  }
+};

From 123a8f70d57b34289759e01edce3c53d08a78a86 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jan 2020 09:53:45 +0800
Subject: [PATCH 0251/3374] Update 261-graph-valid-tree.js

---
 261-graph-valid-tree.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/261-graph-valid-tree.js b/261-graph-valid-tree.js
index 9ed367bb..5347da57 100644
--- a/261-graph-valid-tree.js
+++ b/261-graph-valid-tree.js
@@ -17,3 +17,41 @@ const validTree = function(n, edges) {
     return find(arr, arr[i])
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean}
+ */
+const validTree = function(n, edges) {
+  if (edges.length !== n - 1) {
+    return false
+  }
+  const graph = {}
+  edges.forEach(edge => {
+    if (!graph[edge[0]]) {
+      graph[edge[0]] = []
+    }
+    if (!graph[edge[1]]) {
+      graph[edge[1]] = []
+    }
+    graph[edge[0]].push(edge[1])
+    graph[edge[1]].push(edge[0])
+  })
+  const queue = [0],
+    visited = new Set()
+  while (queue.length) {
+    const currentNode = queue.shift()
+    visited.add(currentNode)
+    if (graph[currentNode]) {
+      graph[currentNode].forEach(node => {
+        if (!visited.has(node)) {
+          queue.push(node)
+        }
+      })
+    }
+  }
+  return visited.size === n
+}

From 6e807d3bb7d28ae89957d56e712e9cf020afea62 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jan 2020 21:41:36 +0800
Subject: [PATCH 0252/3374] Create 265-paint-house-ii.js

---
 265-paint-house-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 265-paint-house-ii.js

diff --git a/265-paint-house-ii.js b/265-paint-house-ii.js
new file mode 100644
index 00000000..c8b47547
--- /dev/null
+++ b/265-paint-house-ii.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} costs
+ * @return {number}
+ */
+const minCostII = function(costs) {
+  if (costs == null || costs.length === 0 || costs[0].length === 0) return 0
+  let n = costs.length,
+    k = costs[0].length
+  if (k === 1) return n === 1 ? costs[0][0] : -1
+
+  let prevMin = 0,
+    prevMinInd = -1,
+    prevSecMin = 0
+  for (let i = 0; i < n; i++) {
+    let min = Number.MAX_VALUE,
+      minInd = -1,
+      secMin = Number.MAX_VALUE
+    for (let j = 0; j < k; j++) {
+      const val = costs[i][j] + (j == prevMinInd ? prevSecMin : prevMin)
+      if (val < min) {
+        secMin = min
+        min = val
+        minInd = j
+      } else if (val < secMin) {
+        secMin = val
+      }
+    }
+    prevMin = min
+    prevMinInd = minInd
+    prevSecMin = secMin
+  }
+  return prevMin
+}

From 5a0e90a5a0521ead3cbb9affb107ca1a297e2b6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Jan 2020 21:10:26 +0800
Subject: [PATCH 0253/3374] Create 267-palindrome-permutation-ii.js

---
 267-palindrome-permutation-ii.js | 39 ++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 267-palindrome-permutation-ii.js

diff --git a/267-palindrome-permutation-ii.js b/267-palindrome-permutation-ii.js
new file mode 100644
index 00000000..ec8c2c3a
--- /dev/null
+++ b/267-palindrome-permutation-ii.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+const generatePalindromes = function(s) {
+  const ans = []
+  const count = Array(256).fill(0)
+  let odds = 0
+  for (let c of s) count[c.charCodeAt(0)]++
+  for (let c of count) if (c % 2 !== 0) odds++
+  if (odds <= 1) {
+    let center = null
+    for (let idx = 0; idx < count.length; idx++) {
+      if (count[idx] % 2 === 1) {
+        center = String.fromCharCode(idx)
+        count[idx]--
+        break
+      }
+    }
+    generate(ans, count, center != null ? center : '', s.length)
+  }
+  return ans
+}
+
+function generate(ans, count, build, len) {
+  for (let idx = 0; idx < count.length; idx++) {
+    if (count[idx] > 0) {
+      count[idx] -= 2
+      generate(
+        ans,
+        count,
+        String.fromCharCode(idx) + build + String.fromCharCode(idx),
+        len
+      )
+      count[idx] += 2
+    }
+  }
+  if (build.length === len) ans.push(build)
+}

From cc267fa4099097caaa8fed452fd45b96879f1729 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jan 2020 00:11:53 +0800
Subject: [PATCH 0254/3374] Update 267-palindrome-permutation-ii.js

---
 267-palindrome-permutation-ii.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/267-palindrome-permutation-ii.js b/267-palindrome-permutation-ii.js
index ec8c2c3a..70701c1b 100644
--- a/267-palindrome-permutation-ii.js
+++ b/267-palindrome-permutation-ii.js
@@ -23,6 +23,10 @@ const generatePalindromes = function(s) {
 }
 
 function generate(ans, count, build, len) {
+  if (build.length === len) {
+    ans.push(build)
+    return
+  }
   for (let idx = 0; idx < count.length; idx++) {
     if (count[idx] > 0) {
       count[idx] -= 2
@@ -35,5 +39,4 @@ function generate(ans, count, build, len) {
       count[idx] += 2
     }
   }
-  if (build.length === len) ans.push(build)
 }

From 03ea010b48fcd09a25849d031580d543c4370aaa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jan 2020 00:27:55 +0800
Subject: [PATCH 0255/3374] Update 267-palindrome-permutation-ii.js

---
 267-palindrome-permutation-ii.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/267-palindrome-permutation-ii.js b/267-palindrome-permutation-ii.js
index 70701c1b..1afa5e02 100644
--- a/267-palindrome-permutation-ii.js
+++ b/267-palindrome-permutation-ii.js
@@ -1,3 +1,19 @@
+/**
+
+Given a string s, return all the palindromic permutations (without duplicates) of it.
+Return an empty list if no palindromic permutation could be form.
+
+Example 1:
+
+Input: "aabb"
+Output: ["abba", "baab"]
+Example 2:
+
+Input: "abc"
+Output: []
+
+*/
+
 /**
  * @param {string} s
  * @return {string[]}

From e5eb1bdbb2cf1b088f6325386b1fe9ff2724ee73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jan 2020 20:57:56 +0800
Subject: [PATCH 0256/3374] Create 271-encode-and-decode-strings.js

---
 271-encode-and-decode-strings.js | 36 ++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 271-encode-and-decode-strings.js

diff --git a/271-encode-and-decode-strings.js b/271-encode-and-decode-strings.js
new file mode 100644
index 00000000..33e17adb
--- /dev/null
+++ b/271-encode-and-decode-strings.js
@@ -0,0 +1,36 @@
+/**
+ * Encodes a list of strings to a single string.
+ *
+ * @param {string[]} strs
+ * @return {string}
+ */
+const encode = function(strs) {
+  let s = ''
+  for(let e of strs) {
+    s += e.length + '/' + e
+  }
+  return s
+};
+
+/**
+ * Decodes a single string to a list of strings.
+ *
+ * @param {string} s
+ * @return {string[]}
+ */
+const decode = function(s) {
+  const res = []
+  let i = 0
+  while(i < s.length) {
+    const idx = s.indexOf('/', i)
+    const size = s.slice(i, idx)
+    i = idx + (+size) + 1
+    res.push(s.slice(idx + 1, i))
+  }
+  return res
+};
+
+/**
+ * Your functions will be called as such:
+ * decode(encode(strs));
+ */

From e1fb7ab6a24be6d97dc24bbb613d63d9cfc4d2b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jan 2020 12:16:10 +0800
Subject: [PATCH 0257/3374] Create 275-h-index-ii.js

---
 275-h-index-ii.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 275-h-index-ii.js

diff --git a/275-h-index-ii.js b/275-h-index-ii.js
new file mode 100644
index 00000000..44988085
--- /dev/null
+++ b/275-h-index-ii.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} citations
+ * @return {number}
+ */
+const hIndex = function(citations) {
+  let left = 0,
+    len = citations.length,
+    right = len - 1,
+    mid
+  while (left <= right) {
+    mid = (left + (right - left)) >> 1
+    if (citations[mid] >= len - mid) right = mid - 1
+    else left = mid + 1
+  }
+  return len - left
+}

From 41317750792241974a6b62c903ba0653b1158f2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jan 2020 20:22:24 +0800
Subject: [PATCH 0258/3374] Create 276-paint-fence.js

---
 276-paint-fence.js | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 276-paint-fence.js

diff --git a/276-paint-fence.js b/276-paint-fence.js
new file mode 100644
index 00000000..e2670ce4
--- /dev/null
+++ b/276-paint-fence.js
@@ -0,0 +1,45 @@
+/**
+
+There is a fence with n posts, each post can be painted with one of the k colors.
+
+You have to paint all the posts such that no more than two adjacent fence posts have the same color.
+
+Return the total number of ways you can paint the fence.
+
+Note:
+n and k are non-negative integers.
+
+Example:
+
+Input: n = 3, k = 2
+Output: 6
+Explanation: Take c1 as color 1, c2 as color 2. All possible ways are:
+
+            post1  post2  post3      
+ -----      -----  -----  -----       
+   1         c1     c1     c2 
+   2         c1     c2     c1 
+   3         c1     c2     c2 
+   4         c2     c1     c1  
+   5         c2     c1     c2
+   6         c2     c2     c1
+
+*/
+
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const numWays = function(n, k) {
+  if (n === 0) return 0;
+  if (n === 1) return k;
+  let diff = k * (k - 1);
+  let same = k;
+  for (let i = 2; i < n; i ++) {
+    const temp = diff;
+    diff = (diff + same) * (k - 1);
+    same = temp;
+  }
+  return diff + same;
+}

From 37cccb209eba2fc32f632b17c1a8f690ac1cd469 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Jan 2020 09:33:09 +0800
Subject: [PATCH 0259/3374] Update 275-h-index-ii.js

---
 275-h-index-ii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/275-h-index-ii.js b/275-h-index-ii.js
index 44988085..9ba2eae8 100644
--- a/275-h-index-ii.js
+++ b/275-h-index-ii.js
@@ -8,7 +8,7 @@ const hIndex = function(citations) {
     right = len - 1,
     mid
   while (left <= right) {
-    mid = (left + (right - left)) >> 1
+    mid = left + ((right - left) >> 1)
     if (citations[mid] >= len - mid) right = mid - 1
     else left = mid + 1
   }

From e9987a8362555eca9d97b6bfb0ac090c3b2a2d64 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Jan 2020 09:55:46 +0800
Subject: [PATCH 0260/3374] Update 275-h-index-ii.js

---
 275-h-index-ii.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/275-h-index-ii.js b/275-h-index-ii.js
index 9ba2eae8..d747ad69 100644
--- a/275-h-index-ii.js
+++ b/275-h-index-ii.js
@@ -14,3 +14,26 @@ const hIndex = function(citations) {
   }
   return len - left
 }
+
+// another
+
+/**
+ * @param {number[]} citations
+ * @return {number}
+ */
+const hIndex = function(citations) {
+  let len = citations.length
+  let lo = 0,
+    hi = len - 1
+  while (lo <= hi) {
+    let med = lo + ((hi - lo) >> 1)
+    if (citations[med] === len - med) {
+      return len - med
+    } else if (citations[med] < len - med) {
+      lo = med + 1
+    } else {
+      hi = med - 1
+    }
+  }
+  return len - lo
+}

From 157c1172def9b0be3978f5dc557d11601a05bbdc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jan 2020 12:44:24 +0800
Subject: [PATCH 0261/3374] Create 291-word-pattern-ii.js

---
 291-word-pattern-ii.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 291-word-pattern-ii.js

diff --git a/291-word-pattern-ii.js b/291-word-pattern-ii.js
new file mode 100644
index 00000000..c0243b91
--- /dev/null
+++ b/291-word-pattern-ii.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} pattern
+ * @param {string} str
+ * @return {boolean}
+ */
+const wordPatternMatch = function(pattern, str) {
+  const map = new Map()
+  const set = new Set()
+  return isMatch(str, 0, pattern, 0, map, set)
+};
+function isMatch(str, i, pat, j, map, set) {
+  if(i === str.length && j === pat.length) return true
+  if(i === str.length || j === pat.length) return false
+  let c = pat.charAt(j)
+  if(map.has(c)) {
+    let s = map.get(c)
+    if(!str.startsWith(s, i)) return false
+    return isMatch(str, i + s.length, pat, j + 1, map, set)
+  }
+  for(let k = i; k < str.length; k++) {
+    let p = str.slice(i, k + 1)
+    if(set.has(p)) continue
+    map.set(c, p)
+    set.add(p)
+    if(isMatch(str, k + 1, pat, j + 1, map, set)) return true
+    map.delete(c)
+    set.delete(p)
+  }
+  return false
+}

From cd1552590021d3609607a12687f3fa1d7328afef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jan 2020 17:23:51 +0800
Subject: [PATCH 0262/3374] Create 292-nim-game.js

---
 292-nim-game.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 292-nim-game.js

diff --git a/292-nim-game.js b/292-nim-game.js
new file mode 100644
index 00000000..04d31e55
--- /dev/null
+++ b/292-nim-game.js
@@ -0,0 +1,7 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const canWinNim = function(n) {
+  return n % 4 !== 0 ;  
+};

From 8810b1f57aeedf12616e9282cf7efe925c7a5d91 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Jan 2020 15:59:07 +0800
Subject: [PATCH 0263/3374] Create 293-flip-game.js

---
 293-flip-game.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 293-flip-game.js

diff --git a/293-flip-game.js b/293-flip-game.js
new file mode 100644
index 00000000..b37ca28b
--- /dev/null
+++ b/293-flip-game.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+const generatePossibleNextMoves = function(s) {
+  const list = []
+  for (let i = -1; (i = s.indexOf('++', i + 1)) >= 0; )
+    list.push(s.slice(0, i) + '--' + s.slice(i + 2))
+  return list
+}

From d14f469bab8b1f6f97633b68837abc2d0510acb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Jan 2020 10:15:26 +0800
Subject: [PATCH 0264/3374] Create 294-flip-game-ii.js

---
 294-flip-game-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 294-flip-game-ii.js

diff --git a/294-flip-game-ii.js b/294-flip-game-ii.js
new file mode 100644
index 00000000..3a4a183b
--- /dev/null
+++ b/294-flip-game-ii.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const canWin = function(s) {
+  const ss = s.split('')
+  const len = s.length
+  return chk()
+  function chk() {
+    for (let i = 0; i <= len - 2; i++) {
+      if (ss[i] === '+' && ss[i + 1] === '+') {
+        ss[i] = '-'
+        ss[i + 1] = '-'
+        const wins = !chk()
+        ss[i] = '+'
+        ss[i + 1] = '+'
+        if (wins) return true
+      }
+    }
+    return false
+  }
+}

From 7249be5f4bc8fc5626a3f20364548addd8c29a94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jan 2020 09:05:58 +0800
Subject: [PATCH 0265/3374] Create 288-unique-word-abbreviation.js

---
 288-unique-word-abbreviation.js | 40 +++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 288-unique-word-abbreviation.js

diff --git a/288-unique-word-abbreviation.js b/288-unique-word-abbreviation.js
new file mode 100644
index 00000000..4afe5e29
--- /dev/null
+++ b/288-unique-word-abbreviation.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string[]} dictionary
+ */
+const ValidWordAbbr = function(dictionary) {
+  this.map = new Map()
+  for (let i = 0; i < dictionary.length; i++) {
+    let w = dictionary[i]
+    if (w.length < 3) this.map.set(w, true)
+    else {
+      let key = this.toAbbr(w)
+      let val = this.map.has(key) ? false : w
+      this.map.set(key, val)
+    }
+  }
+}
+/**
+ * @param {string} word
+ * @return {boolean}
+ */
+ValidWordAbbr.prototype.isUnique = function(word) {
+  let len = word.length
+  if (len < 3) return true
+  let key = this.toAbbr(word)
+  if (this.map.has(key)) {
+    let val = this.map.get(key)
+    if (val === false) return false
+    return word === val
+  }
+  return true
+}
+ValidWordAbbr.prototype.toAbbr = word => {
+  let len = word.length
+  if (len < 3) return word
+  return word[0] + (len - 2) + word[len - 1]
+}
+/**
+ * Your ValidWordAbbr object will be instantiated and called as such:
+ * var obj = new ValidWordAbbr(dictionary)
+ * var param_1 = obj.isUnique(word)
+ */

From f34e7123a0cbdf82ba338ac15be06e16ad404d14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jan 2020 09:46:30 +0800
Subject: [PATCH 0266/3374] Create 280-wiggle-sort.js

---
 280-wiggle-sort.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 280-wiggle-sort.js

diff --git a/280-wiggle-sort.js b/280-wiggle-sort.js
new file mode 100644
index 00000000..754dc845
--- /dev/null
+++ b/280-wiggle-sort.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+const wiggleSort = function(nums) {
+  for (let i = 1; i < nums.length; i++) {
+    let a = nums[i - 1]
+    if ((i % 2 === 1) === a > nums[i]) {
+      nums[i - 1] = nums[i]
+      nums[i] = a
+    }
+  }
+}

From de04b30e76ccd31a39c90231df0d155e011e13b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 10:43:02 +0800
Subject: [PATCH 0267/3374] Create 281-zigzag-iterator.js

---
 281-zigzag-iterator.js | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 281-zigzag-iterator.js

diff --git a/281-zigzag-iterator.js b/281-zigzag-iterator.js
new file mode 100644
index 00000000..de52df2c
--- /dev/null
+++ b/281-zigzag-iterator.js
@@ -0,0 +1,42 @@
+/**
+ * @constructor
+ * @param {Integer[]} v1
+ * @param {Integer[]} v1
+ */
+const ZigzagIterator = function ZigzagIterator(v1, v2) {
+  this.collection = []
+  if (v1 !== null && v1.length !== 0) {
+    this.collection.push(v1)
+  }
+  if (v2 !== null && v2.length !== 0) {
+    this.collection.push(v2)
+  }
+}
+
+/**
+ * @this ZigzagIterator
+ * @returns {boolean}
+ */
+ZigzagIterator.prototype.hasNext = function hasNext() {
+  return this.collection.length > 0
+}
+
+/**
+ * @this ZigzagIterator
+ * @returns {integer}
+ */
+ZigzagIterator.prototype.next = function next() {
+  if (this.collection[0].length === 1) {
+    return this.collection.shift()[0]
+  } else {
+    let v = this.collection.shift()
+    this.collection.push(v)
+    return v.shift()
+  }
+}
+
+/**
+ * Your ZigzagIterator will be called like this:
+ * var i = new ZigzagIterator(v1, v2), a = [];
+ * while (i.hasNext()) a.push(i.next());
+ */

From 6cc3795888cab20603a5051a0a969d7f10313eda Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 11:08:25 +0800
Subject: [PATCH 0268/3374] Update 281-zigzag-iterator.js

---
 281-zigzag-iterator.js | 56 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/281-zigzag-iterator.js b/281-zigzag-iterator.js
index de52df2c..01e5d6cd 100644
--- a/281-zigzag-iterator.js
+++ b/281-zigzag-iterator.js
@@ -40,3 +40,59 @@ ZigzagIterator.prototype.next = function next() {
  * var i = new ZigzagIterator(v1, v2), a = [];
  * while (i.hasNext()) a.push(i.next());
  */
+
+// another
+
+/**
+ * @constructor
+ * @param {Integer[]} v1
+ * @param {Integer[]} v1
+ */
+const ZigzagIterator = function ZigzagIterator(v1, v2) {
+  const A = [v1, v2]
+  this.A = A
+  this.n = A.length
+  this.m = Math.max(v1.length, v2.length)
+  this.j = 0
+  this.i = 0
+}
+
+/**
+ * @this ZigzagIterator
+ * @returns {boolean}
+ */
+ZigzagIterator.prototype.hasNext = function hasNext() {
+  return this.j < this.m
+}
+
+/**
+ * @this ZigzagIterator
+ * @returns {integer}
+ */
+ZigzagIterator.prototype.incrementPointers = function incrementPointers() {
+  this.i += 1
+  if (this.i === this.n) {
+    this.j += 1
+    this.i = 0
+  }
+}
+
+ZigzagIterator.prototype.next = function next() {
+  let next = undefined
+  while (next === undefined) {
+    next = this.A[this.i][this.j]
+    this.incrementPointers()
+  }
+  while (this.hasNext()) {
+    if (this.A[this.i][this.j] !== undefined) break
+    this.incrementPointers()
+  }
+  return next
+}
+
+/**
+ * Your ZigzagIterator will be called like this:
+ * var i = new ZigzagIterator(v1, v2), a = [];
+ * while (i.hasNext()) a.push(i.next());
+ */
+

From 169387b09d38c30e78523295b595c4d9f6cebe53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 11:44:41 +0800
Subject: [PATCH 0269/3374] Update 281-zigzag-iterator.js

---
 281-zigzag-iterator.js | 44 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/281-zigzag-iterator.js b/281-zigzag-iterator.js
index 01e5d6cd..7d8ec1ce 100644
--- a/281-zigzag-iterator.js
+++ b/281-zigzag-iterator.js
@@ -96,3 +96,47 @@ ZigzagIterator.prototype.next = function next() {
  * while (i.hasNext()) a.push(i.next());
  */
 
+// another
+
+/**
+ * @constructor
+ * @param {Integer[]} v1
+ * @param {Integer[]} v1
+ */
+const ZigzagIterator = function ZigzagIterator(v1, v2) {
+  this.queue = []
+  if (v1.length > 0) {
+    const it = v1[Symbol.iterator]()
+    const res = it.next()
+    this.queue.push({ it, res })
+  }
+  if (v2.length > 0) {
+    const it = v2[Symbol.iterator]()
+    const res = it.next()
+    this.queue.push({ it, res })
+  }
+}
+/**
+ * @this ZigzagIterator
+ * @returns {boolean}
+ */
+ZigzagIterator.prototype.hasNext = function hasNext() {
+  return this.queue.length > 0
+}
+/**
+ * @this ZigzagIterator
+ * @returns {integer}
+ */
+ZigzagIterator.prototype.next = function next() {
+  const { it, res } = this.queue.shift()
+  const { value } = res
+  const res1 = it.next()
+  if (!res1.done) this.queue.push({ it, res: res1 })
+  return value
+}
+/**
+ * Your ZigzagIterator will be called like this:
+ * var i = new ZigzagIterator(v1, v2), a = [];
+ * while (i.hasNext()) a.push(i.next());
+ */
+

From 676c158ffa4f76cdacaf96b953be5b2b08a79c9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 14:17:00 +0800
Subject: [PATCH 0270/3374] Create
 302-smallest-rectangle-enclosing-black-pixels.js

---
 ...allest-rectangle-enclosing-black-pixels.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 302-smallest-rectangle-enclosing-black-pixels.js

diff --git a/302-smallest-rectangle-enclosing-black-pixels.js b/302-smallest-rectangle-enclosing-black-pixels.js
new file mode 100644
index 00000000..1ac95456
--- /dev/null
+++ b/302-smallest-rectangle-enclosing-black-pixels.js
@@ -0,0 +1,35 @@
+/**
+ * @param {character[][]} image
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const minArea = function(image, x, y) {
+  const m = image.length,
+    n = image[0].length;
+  const left = searchColumns(0, y, 0, m, true);
+  const right = searchColumns(y + 1, n, 0, m, false);
+  const top = searchRows(0, x, left, right, true);
+  const bottom = searchRows(x + 1, m, left, right, false);
+  return (right - left) * (bottom - top);
+  function searchColumns(i, j, top, bottom, opt) {
+    while (i != j) {
+      let k = top,
+        mid = ((i + j) >> 1);
+      while (k < bottom && image[k][mid] === "0") ++k;
+      if (k < bottom === opt) j = mid;
+      else i = mid + 1;
+    }
+    return i;
+  }
+  function searchRows(i, j, left, right, opt) {
+    while (i != j) {
+      let k = left,
+        mid = ((i + j) >> 1);
+      while (k < right && image[mid][k] === "0") ++k;
+      if (k < right === opt) j = mid;
+      else i = mid + 1;
+    }
+    return i;
+  }
+};

From 88e5a436488e99ea8e1fc1f33b7f37271a4c0b9e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 14:21:24 +0800
Subject: [PATCH 0271/3374] Update
 302-smallest-rectangle-enclosing-black-pixels.js

---
 ...allest-rectangle-enclosing-black-pixels.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/302-smallest-rectangle-enclosing-black-pixels.js b/302-smallest-rectangle-enclosing-black-pixels.js
index 1ac95456..c7c237c4 100644
--- a/302-smallest-rectangle-enclosing-black-pixels.js
+++ b/302-smallest-rectangle-enclosing-black-pixels.js
@@ -33,3 +33,42 @@ const minArea = function(image, x, y) {
     return i;
   }
 };
+
+// another
+
+/**
+ * @param {character[][]} image
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const minArea = function(image, x, y) {
+  let top = x,
+    bottom = x
+  let left = y,
+    right = y
+  function dfs(x, y) {
+    if (
+      x < 0 ||
+      y < 0 ||
+      x >= image.length ||
+      y >= image[0].length ||
+      image[x][y] === '0'
+    )
+      return
+    image[x][y] = '0'
+    top = Math.min(top, x)
+    bottom = Math.max(bottom, x + 1)
+    left = Math.min(left, y)
+    right = Math.max(right, y + 1)
+    dfs(x + 1, y)
+    dfs(x - 1, y)
+    dfs(x, y - 1)
+    dfs(x, y + 1)
+  }
+
+  if (image.length == 0 || image[0].length == 0) return 0
+  dfs(x, y)
+  return (right - left) * (bottom - top)
+}
+

From 084b7fc1c5e6eb050468e641996453073ffc8eb2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 14:37:52 +0800
Subject: [PATCH 0272/3374] Update
 302-smallest-rectangle-enclosing-black-pixels.js

---
 302-smallest-rectangle-enclosing-black-pixels.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/302-smallest-rectangle-enclosing-black-pixels.js b/302-smallest-rectangle-enclosing-black-pixels.js
index c7c237c4..16a96862 100644
--- a/302-smallest-rectangle-enclosing-black-pixels.js
+++ b/302-smallest-rectangle-enclosing-black-pixels.js
@@ -67,7 +67,7 @@ const minArea = function(image, x, y) {
     dfs(x, y + 1)
   }
 
-  if (image.length == 0 || image[0].length == 0) return 0
+  if (image.length === 0 || image[0].length === 0) return 0
   dfs(x, y)
   return (right - left) * (bottom - top)
 }

From 1eb8f7e4dbe7a33190acc1546965dd6fc477aa4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jan 2020 14:57:45 +0800
Subject: [PATCH 0273/3374] Update
 302-smallest-rectangle-enclosing-black-pixels.js

---
 302-smallest-rectangle-enclosing-black-pixels.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/302-smallest-rectangle-enclosing-black-pixels.js b/302-smallest-rectangle-enclosing-black-pixels.js
index 16a96862..7c085de5 100644
--- a/302-smallest-rectangle-enclosing-black-pixels.js
+++ b/302-smallest-rectangle-enclosing-black-pixels.js
@@ -58,9 +58,9 @@ const minArea = function(image, x, y) {
       return
     image[x][y] = '0'
     top = Math.min(top, x)
-    bottom = Math.max(bottom, x + 1)
+    bottom = Math.max(bottom, x)
     left = Math.min(left, y)
-    right = Math.max(right, y + 1)
+    right = Math.max(right, y)
     dfs(x + 1, y)
     dfs(x - 1, y)
     dfs(x, y - 1)
@@ -69,6 +69,6 @@ const minArea = function(image, x, y) {
 
   if (image.length === 0 || image[0].length === 0) return 0
   dfs(x, y)
-  return (right - left) * (bottom - top)
+  return (right - left + 1) * (bottom - top + 1)
 }
 

From cfb944c59f8336d12aa34104215a49c5d56559bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Jan 2020 21:05:54 +0800
Subject: [PATCH 0274/3374] Create 390-elimination-game.js

---
 390-elimination-game.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 390-elimination-game.js

diff --git a/390-elimination-game.js b/390-elimination-game.js
new file mode 100644
index 00000000..06b3803a
--- /dev/null
+++ b/390-elimination-game.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const lastRemaining = function(n) {
+  let left = true
+  let remaining = n
+  let step = 1
+  let head = 1
+  while (remaining > 1) {
+    if (left || remaining % 2 === 1) {
+      head = head + step
+    }
+    remaining = remaining >> 1
+    step = step * 2
+    left = !left
+  }
+  return head
+}

From 05b8fb8261680ec0022b957f16c997ce1bdee595 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Jan 2020 17:31:08 +0800
Subject: [PATCH 0275/3374] Create 393-utf-8-validation.js

---
 393-utf-8-validation.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 393-utf-8-validation.js

diff --git a/393-utf-8-validation.js b/393-utf-8-validation.js
new file mode 100644
index 00000000..8155ecee
--- /dev/null
+++ b/393-utf-8-validation.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} data
+ * @return {boolean}
+ */
+const validUtf8 = function(data) {
+  let count = 0
+  for (let c of data) {
+    if (count === 0) {
+      if (c >> 5 === 0b110) count = 1
+      else if (c >> 4 === 0b1110) count = 2
+      else if (c >> 3 === 0b11110) count = 3
+      else if (c >> 7) return false
+    } else {
+      if (c >> 6 !== 0b10) return false
+      count--
+    }
+  }
+  return count == 0
+}

From 23052cb4c3c195e9c06cb3606b0ab81f1de10794 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jan 2020 00:33:11 +0800
Subject: [PATCH 0276/3374] Create 388-longest-absolute-file-path.js

---
 388-longest-absolute-file-path.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 388-longest-absolute-file-path.js

diff --git a/388-longest-absolute-file-path.js b/388-longest-absolute-file-path.js
new file mode 100644
index 00000000..546a6e6c
--- /dev/null
+++ b/388-longest-absolute-file-path.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} input
+ * @return {number}
+ */
+const lengthLongestPath = function(input) {
+  const stack = []
+  return input.split('\n').reduce((max, p) => {
+    const level = p.lastIndexOf('\t') + 1
+    stack[level] = p.length - level + (level ? stack[level - 1] : 0)
+    return p.indexOf('.') === -1 ? max : Math.max(max, stack[level] + level)
+  }, 0)
+}

From c76a1501b5d5042d152fc50f078dc2d50a099f44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jan 2020 15:50:51 +0800
Subject: [PATCH 0277/3374] Create 385-mini-parser.js

---
 385-mini-parser.js | 69 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 385-mini-parser.js

diff --git a/385-mini-parser.js b/385-mini-parser.js
new file mode 100644
index 00000000..280bff05
--- /dev/null
+++ b/385-mini-parser.js
@@ -0,0 +1,69 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a single integer equal to value.
+ *     @return {void}
+ *     this.setInteger = function(value) {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
+ *     @return {void}
+ *     this.add = function(elem) {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {string} s
+ * @return {NestedInteger}
+ */
+const deserialize = function(s) {
+  const recursion = s => {
+    const re = new NestedInteger()
+    if (!s || s.length === 0) {
+      return re
+    }
+    if (s.charAt(0) !== '[') {
+      re.setInteger(parseInt(s, 10))
+    } else if (s.length > 2) {
+      let start = 1
+      let cnt = 0
+      for (let i = 1; i < s.length; i++) {
+        const char = s.charAt(i)
+        if (cnt === 0 && (char === ',' || i === s.length - 1)) {
+          re.add(recursion(s.substring(start, i)))
+          start = i + 1
+        } else if (char === '[') {
+          cnt++
+        } else if (char === ']') {
+          cnt--
+        }
+      }
+    }
+    return re
+  }
+  return recursion(s)
+}

From 028616976d9d8814898127048ecc53adf76843dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Jan 2020 00:26:30 +0800
Subject: [PATCH 0278/3374] Create
 381-insert-delete-getrandom-o1-duplicates-allowed.js

---
 ...-delete-getrandom-o1-duplicates-allowed.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 381-insert-delete-getrandom-o1-duplicates-allowed.js

diff --git a/381-insert-delete-getrandom-o1-duplicates-allowed.js b/381-insert-delete-getrandom-o1-duplicates-allowed.js
new file mode 100644
index 00000000..3e907571
--- /dev/null
+++ b/381-insert-delete-getrandom-o1-duplicates-allowed.js
@@ -0,0 +1,61 @@
+/**
+ * Initialize your data structure here.
+ */
+const RandomizedCollection = function() {
+  this.map = new Map()
+  this.list = []
+}
+
+/**
+ * Inserts a value to the collection. Returns true if the collection did not already contain the specified element.
+ * @param {number} val
+ * @return {boolean}
+ */
+RandomizedCollection.prototype.insert = function(val) {
+  const index = this.list.length
+  const node = { val, index }
+  this.list[index] = node
+
+  const nodeList = this.map.get(val)
+  const isNew = nodeList === undefined || nodeList.length === 0
+  if (nodeList === undefined) {
+    this.map.set(val, [node])
+  } else {
+    nodeList.push(node)
+  }
+  return isNew
+}
+
+/**
+ * Removes a value from the collection. Returns true if the collection contained the specified element.
+ * @param {number} val
+ * @return {boolean}
+ */
+RandomizedCollection.prototype.remove = function(val) {
+  const nodeList = this.map.get(val)
+  if (!nodeList || nodeList.length === 0) return false
+  const node = nodeList.pop()
+  const replacement = this.list.pop()
+  if (replacement.index !== node.index) {
+    replacement.index = node.index
+    this.list[replacement.index] = replacement
+  }
+  return true
+}
+
+/**
+ * Get a random element from the collection.
+ * @return {number}
+ */
+RandomizedCollection.prototype.getRandom = function() {
+  const index = Math.floor(Math.random() * this.list.length)
+  return this.list[index].val
+}
+
+/**
+ * Your RandomizedCollection object will be instantiated and called as such:
+ * var obj = new RandomizedCollection()
+ * var param_1 = obj.insert(val)
+ * var param_2 = obj.remove(val)
+ * var param_3 = obj.getRandom()
+ */

From 075d732826f91ea532d33b3dd7f0ccefa2dbd50c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Jan 2020 16:04:06 +0800
Subject: [PATCH 0279/3374] Create 379-design-phone-directory.js

---
 379-design-phone-directory.js | 48 +++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 379-design-phone-directory.js

diff --git a/379-design-phone-directory.js b/379-design-phone-directory.js
new file mode 100644
index 00000000..1143ae21
--- /dev/null
+++ b/379-design-phone-directory.js
@@ -0,0 +1,48 @@
+/**
+ * Initialize your data structure here
+        @param maxNumbers - The maximum numbers that can be stored in the phone directory.
+ * @param {number} maxNumbers
+ */
+const PhoneDirectory = function(maxNumbers) {
+  this.len = maxNumbers
+  this.set = new Set()
+  while (maxNumbers--) this.set.add(maxNumbers)
+}
+
+/**
+ * Provide a number which is not assigned to anyone.
+        @return - Return an available number. Return -1 if none is available.
+ * @return {number}
+ */
+PhoneDirectory.prototype.get = function() {
+  if (this.set.size === 0) return -1
+  const n = this.set.values().next().value
+  this.set.delete(n)
+  return n
+}
+
+/**
+ * Check if a number is available or not.
+ * @param {number} number
+ * @return {boolean}
+ */
+PhoneDirectory.prototype.check = function(number) {
+  return this.set.has(number)
+}
+
+/**
+ * Recycle or release a number.
+ * @param {number} number
+ * @return {void}
+ */
+PhoneDirectory.prototype.release = function(number) {
+  this.set.add(number)
+}
+
+/**
+ * Your PhoneDirectory object will be instantiated and called as such:
+ * var obj = new PhoneDirectory(maxNumbers)
+ * var param_1 = obj.get()
+ * var param_2 = obj.check(number)
+ * obj.release(number)
+ */

From 47b1844f1496d08d327ae1a3b8a0791648e9d246 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Jan 2020 21:43:28 +0800
Subject: [PATCH 0280/3374] Update 379-design-phone-directory.js

---
 379-design-phone-directory.js | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/379-design-phone-directory.js b/379-design-phone-directory.js
index 1143ae21..eb78f5b1 100644
--- a/379-design-phone-directory.js
+++ b/379-design-phone-directory.js
@@ -5,8 +5,8 @@
  */
 const PhoneDirectory = function(maxNumbers) {
   this.len = maxNumbers
-  this.set = new Set()
-  while (maxNumbers--) this.set.add(maxNumbers)
+  this.used = new Set()
+  this.free = []
 }
 
 /**
@@ -15,10 +15,10 @@ const PhoneDirectory = function(maxNumbers) {
  * @return {number}
  */
 PhoneDirectory.prototype.get = function() {
-  if (this.set.size === 0) return -1
-  const n = this.set.values().next().value
-  this.set.delete(n)
-  return n
+  if (this.used.size === this.len) return -1
+  const tmp = this.free.length === 0 ? this.used.size : this.free.pop()
+  this.used.add(tmp)
+  return tmp
 }
 
 /**
@@ -27,7 +27,7 @@ PhoneDirectory.prototype.get = function() {
  * @return {boolean}
  */
 PhoneDirectory.prototype.check = function(number) {
-  return this.set.has(number)
+  return !this.used.has(number)
 }
 
 /**
@@ -36,7 +36,10 @@ PhoneDirectory.prototype.check = function(number) {
  * @return {void}
  */
 PhoneDirectory.prototype.release = function(number) {
-  this.set.add(number)
+  if(this.used.has(number)) {
+    this.used.delete(number)
+    this.free.push(number)
+  }
 }
 
 /**

From 1e8b5c05890d8c3c2d289ab4c77b2f62d57f1dc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Feb 2020 19:45:36 +0800
Subject: [PATCH 0281/3374] Create 375-guess-number-higher-or-lower-ii.js

---
 375-guess-number-higher-or-lower-ii.js | 43 ++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 375-guess-number-higher-or-lower-ii.js

diff --git a/375-guess-number-higher-or-lower-ii.js b/375-guess-number-higher-or-lower-ii.js
new file mode 100644
index 00000000..fa83a99c
--- /dev/null
+++ b/375-guess-number-higher-or-lower-ii.js
@@ -0,0 +1,43 @@
+/**
+
+We are playing the Guess Game. The game is as follows:
+I pick a number from 1 to n. You have to guess which number I picked.
+Every time you guess wrong, I'll tell you whether the number I picked is higher or lower.
+However, when you guess a particular number x, and you guess wrong, you pay $x.
+You win the game when you guess the number I picked.
+
+Example:
+
+n = 10, I pick 8.
+
+First round:  You guess 5, I tell you that it's higher. You pay $5.
+Second round: You guess 7, I tell you that it's higher. You pay $7.
+Third round:  You guess 9, I tell you that it's lower. You pay $9.
+
+Game over. 8 is the number I picked.
+
+You end up paying $5 + $7 + $9 = $21.
+Given a particular n ≥ 1, find out how much money you need to have to guarantee a win.
+
+*/
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const getMoneyAmount = function(n) {
+  const dp = Array.from({length: n + 1}, () => new Array(n + 1).fill(0))
+  return helper(dp, 1, n)
+};
+
+function helper(dp, s, e) {
+  if(s >= e) return 0
+  if(dp[s][e] !== 0) return dp[s][e]
+  let res = Number.MAX_VALUE
+  for(let i = s; i <= e; i++) {
+    const tmp = i + Math.max(helper(dp, s, i - 1), helper(dp, i + 1, e))
+    res = Math.min(res, tmp)
+  }
+  dp[s][e] = res
+  return res
+}

From 7ce10c0f046fb55eefebfd4f24061962a8af27f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Feb 2020 20:51:01 +0800
Subject: [PATCH 0282/3374] Create 372-super-pow.js

---
 372-super-pow.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 372-super-pow.js

diff --git a/372-super-pow.js b/372-super-pow.js
new file mode 100644
index 00000000..f0c6473f
--- /dev/null
+++ b/372-super-pow.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} a
+ * @param {number[]} b
+ * @return {number}
+ */
+const superPow = function(a, b) {
+   const base = 1337
+   function powmod(a, k) {
+     a %= base
+     let res = 1
+     for(let i = 0; i < k; i++) res = res * a % base
+     return res
+   }
+   if(b.length === 0) return 1
+   const last = b.pop()
+   return powmod(superPow(a, b), 10) * powmod(a, last) % base
+}; 

From 4834ac33216be2583cfd23499ff33d9d1ec4da0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Feb 2020 14:18:30 +0800
Subject: [PATCH 0283/3374] Create 370-range-addition.js

---
 370-range-addition.js | 50 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 370-range-addition.js

diff --git a/370-range-addition.js b/370-range-addition.js
new file mode 100644
index 00000000..828b72e2
--- /dev/null
+++ b/370-range-addition.js
@@ -0,0 +1,50 @@
+/**
+
+Assume you have an array of length n initialized with all 0's and are given k update operations.
+Each operation is represented as a triplet:
+[startIndex, endIndex, inc] which increments each element of
+subarray A[startIndex ... endIndex] (startIndex and endIndex inclusive) with inc.
+
+Return the modified array after all k operations were executed.
+
+Example:
+
+Input: length = 5, updates = [[1,3,2],[2,4,3],[0,2,-2]]
+Output: [-2,0,3,5,3]
+Explanation:
+
+Initial state:
+[0,0,0,0,0]
+
+After applying operation [1,3,2]:
+[0,2,2,2,0]
+
+After applying operation [2,4,3]:
+[0,2,5,5,3]
+
+After applying operation [0,2,-2]:
+[-2,0,3,5,3]
+
+*/
+
+/**
+ * @param {number} length
+ * @param {number[][]} updates
+ * @return {number[]}
+ */
+const getModifiedArray = function(length, updates) {
+  const res = new Array(length).fill(0)
+  for (let update of updates) {
+    let value = update[2]
+    let start = update[0]
+    let end = update[1]
+    res[start] += value
+    if (end < length - 1) res[end + 1] -= value
+  }
+  let sum = 0
+  for (let i = 0; i < length; i++) {
+    sum += res[i]
+    res[i] = sum
+  }
+  return res
+}

From 334f7afcbca50c4b6494526f3ee196897239b983 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Feb 2020 21:17:42 +0800
Subject: [PATCH 0284/3374] Create 365-water-and-jug-problem.js

---
 365-water-and-jug-problem.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 365-water-and-jug-problem.js

diff --git a/365-water-and-jug-problem.js b/365-water-and-jug-problem.js
new file mode 100644
index 00000000..ca25488e
--- /dev/null
+++ b/365-water-and-jug-problem.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {boolean}
+ */
+const canMeasureWater = function(x, y, z) {
+  return z === 0 || (x + y >= z && z % gcd(x, y) === 0)
+}
+function gcd(x, y) {
+  if (y === 0) {
+    return x
+  }
+  return gcd(y, x % y)
+}

From f95ab7c836b1de6ef7676b16f56d09177b03256a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Feb 2020 22:28:07 +0800
Subject: [PATCH 0285/3374] Create 364-nested-list-weight-sum-ii.js

---
 364-nested-list-weight-sum-ii.js | 63 ++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 364-nested-list-weight-sum-ii.js

diff --git a/364-nested-list-weight-sum-ii.js b/364-nested-list-weight-sum-ii.js
new file mode 100644
index 00000000..0a4a0e6a
--- /dev/null
+++ b/364-nested-list-weight-sum-ii.js
@@ -0,0 +1,63 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a single integer equal to value.
+ *     @return {void}
+ *     this.setInteger = function(value) {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
+ *     @return {void}
+ *     this.add = function(elem) {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {NestedInteger[]} nestedList
+ * @return {number}
+ */
+const depthSumInverse = function(nestedList) {
+  const maxDepth = nestedList.reduce(
+    (max, list) => Math.max(max, getMaxDepth(list)),
+    1
+  )
+  return nestedList.reduce((total, list) => total + sum(list, maxDepth), 0)
+}
+
+function getMaxDepth(nestedList) {
+  if (nestedList.isInteger()) return 1
+  return nestedList
+    .getList()
+    .reduce((max, list) => Math.max(max, 1 + getMaxDepth(list)), 1)
+}
+
+function sum(nestedList, n) {
+  if (nestedList.isInteger()) return n * nestedList.getInteger()
+  return nestedList
+    .getList()
+    .reduce((total, list) => total + sum(list, n - 1), 0)
+}

From 20a79bb3cd07e2bd48fa776472aa25a90ace099b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Feb 2020 22:31:11 +0800
Subject: [PATCH 0286/3374] Update 364-nested-list-weight-sum-ii.js

---
 364-nested-list-weight-sum-ii.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/364-nested-list-weight-sum-ii.js b/364-nested-list-weight-sum-ii.js
index 0a4a0e6a..e3d1f4b1 100644
--- a/364-nested-list-weight-sum-ii.js
+++ b/364-nested-list-weight-sum-ii.js
@@ -61,3 +61,34 @@ function sum(nestedList, n) {
     .getList()
     .reduce((total, list) => total + sum(list, n - 1), 0)
 }
+
+// another
+
+const depthSumInverse = function(nestedList) {
+  const Q = []
+  let temp = []
+  while (nestedList.length) {
+    temp = []
+    for (let i = 0; i < nestedList.length; i++) {
+      if (nestedList[i].isInteger()) {
+        Q.push(nestedList[i].getInteger())
+      } else {
+        let list = nestedList[i].getList()
+        temp.push(...list)
+      }
+    }
+    Q.push('level')
+    nestedList = temp
+  }
+  let sum = 0
+  let level = 0
+  while (Q.length) {
+    let item = Q.pop()
+    if (item === 'level') {
+      level++
+    } else {
+      sum += item * level
+    }
+  }
+  return sum
+}

From 77f9e8cf72a1e1aeda4a22871de153534031a1bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 16:04:36 +0800
Subject: [PATCH 0287/3374] Create 361-bomb-enemy.js

---
 361-bomb-enemy.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 361-bomb-enemy.js

diff --git a/361-bomb-enemy.js b/361-bomb-enemy.js
new file mode 100644
index 00000000..ea75f28c
--- /dev/null
+++ b/361-bomb-enemy.js
@@ -0,0 +1,27 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+const maxKilledEnemies = function(grid) {
+  const m = grid.length
+  const n = m != 0 ? grid[0].length : 0
+  let result = 0
+  let rowhits = 0
+  const colhits = new Array(n).fill(0)
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (j === 0 || grid[i][j - 1] === 'W') {
+        rowhits = 0
+        for (let k = j; k < n && grid[i][k] !== 'W'; k++)
+          rowhits += grid[i][k] === 'E' ? 1 : 0
+      }
+      if (i === 0 || grid[i - 1][j] === 'W') {
+        colhits[j] = 0
+        for (let k = i; k < m && grid[k][j] !== 'W'; k++)
+          colhits[j] += grid[k][j] === 'E' ? 1 : 0
+      }
+      if (grid[i][j] === '0') result = Math.max(result, rowhits + colhits[j])
+    }
+  }
+  return result
+}

From 3a82795dbe0e3e627aca978325b5aba89c1addb1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 16:07:44 +0800
Subject: [PATCH 0288/3374] Update 361-bomb-enemy.js

---
 361-bomb-enemy.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/361-bomb-enemy.js b/361-bomb-enemy.js
index ea75f28c..aae49f43 100644
--- a/361-bomb-enemy.js
+++ b/361-bomb-enemy.js
@@ -4,7 +4,7 @@
  */
 const maxKilledEnemies = function(grid) {
   const m = grid.length
-  const n = m != 0 ? grid[0].length : 0
+  const n = m !== 0 ? grid[0].length : 0
   let result = 0
   let rowhits = 0
   const colhits = new Array(n).fill(0)

From dd38ca665f73fe846710527e51304d495ea71dc5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 16:47:16 +0800
Subject: [PATCH 0289/3374] Update 361-bomb-enemy.js

---
 361-bomb-enemy.js | 63 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/361-bomb-enemy.js b/361-bomb-enemy.js
index aae49f43..0bd22f2c 100644
--- a/361-bomb-enemy.js
+++ b/361-bomb-enemy.js
@@ -25,3 +25,66 @@ const maxKilledEnemies = function(grid) {
   }
   return result
 }
+
+// another
+
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+const maxKilledEnemies = function(grid) {
+  if (grid == null || grid.length === 0 || grid[0].length === 0) return 0
+  const rows = grid.length
+  const cols = grid[0].length
+  let max = 0
+  const dp = Array.from({ length: rows }, () => new Array(cols).fill(0))
+  //travel each column twice: from left and from right
+  for (let i = 0; i < rows; i++) {
+    let cnt = 0
+    for (let k = 0; k < cols; k++) {
+      if (grid[i][k] === '0') {
+        dp[i][k] = cnt
+      } else if (grid[i][k] === 'E') {
+        cnt++
+      } else {
+        cnt = 0
+      }
+    }
+    cnt = 0
+    for (let k = cols - 1; k >= 0; k--) {
+      if (grid[i][k] === '0') {
+        dp[i][k] += cnt
+      } else if (grid[i][k] === 'E') {
+        cnt++
+      } else {
+        cnt = 0
+      }
+    }
+  }
+  //travel each row twice: from top and from bottom
+  for (let i = 0; i < cols; i++) {
+    let cnt = 0
+    for (let k = 0; k < rows; k++) {
+      if (grid[k][i] === '0') {
+        dp[k][i] += cnt
+      } else if (grid[k][i] === 'E') {
+        cnt++
+      } else {
+        cnt = 0
+      }
+    }
+    cnt = 0
+    for (let k = rows - 1; k >= 0; k--) {
+      if (grid[k][i] === '0') {
+        dp[k][i] += cnt
+        max = Math.max(max, dp[k][i])
+      } else if (grid[k][i] === 'E') {
+        cnt++
+      } else {
+        cnt = 0
+      }
+    }
+  }
+  return max
+}
+

From a4c67bd32090801a572276548cdc3adcde28141b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 19:29:08 +0800
Subject: [PATCH 0290/3374] Update 361-bomb-enemy.js

---
 361-bomb-enemy.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/361-bomb-enemy.js b/361-bomb-enemy.js
index 0bd22f2c..dd401e0a 100644
--- a/361-bomb-enemy.js
+++ b/361-bomb-enemy.js
@@ -1,3 +1,28 @@
+/**
+
+Given a 2D grid, each cell is either a wall 'W',
+an enemy 'E' or empty '0' (the number zero),
+return the maximum enemies you can kill using one bomb.
+The bomb kills all the enemies in the same row and column
+from the planted point until it hits the wall since the wall
+is too strong to be destroyed.
+
+Note: You can only put the bomb at an empty cell.
+
+Example:
+
+Input: [["0","E","0","0"],["E","0","W","E"],["0","E","0","0"]]
+Output: 3 
+Explanation: For the given grid,
+
+0 E 0 0 
+E 0 W E 
+0 E 0 0
+
+Placing a bomb at (1,1) kills 3 enemies.
+
+*/
+
 /**
  * @param {character[][]} grid
  * @return {number}

From 3a0d731da4c83fd4ef33ab155aab7545ca6bdf27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 19:58:13 +0800
Subject: [PATCH 0291/3374] Create 359-logger-rate-limiter.js

---
 359-logger-rate-limiter.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 359-logger-rate-limiter.js

diff --git a/359-logger-rate-limiter.js b/359-logger-rate-limiter.js
new file mode 100644
index 00000000..c59dba0d
--- /dev/null
+++ b/359-logger-rate-limiter.js
@@ -0,0 +1,34 @@
+/**
+ * Initialize your data structure here.
+ */
+const Logger = function() {
+  this.m = new Map()
+};
+
+/**
+ * Returns true if the message should be printed in the given timestamp, otherwise returns false.
+        If this method returns false, the message will not be printed.
+        The timestamp is in seconds granularity. 
+ * @param {number} timestamp 
+ * @param {string} message
+ * @return {boolean}
+ */
+Logger.prototype.shouldPrintMessage = function(timestamp, message) {
+  if(!this.m.has(message)) {
+    this.m.set(message, timestamp)
+    return true
+  }
+  const p = this.m.get(message)
+  const res = timestamp - p >= 10 ? true : false
+  if(res) {
+    this.m.set(message, timestamp)
+    return true
+  }
+  return false
+};
+
+/** 
+ * Your Logger object will be instantiated and called as such:
+ * var obj = new Logger()
+ * var param_1 = obj.shouldPrintMessage(timestamp,message)
+ */

From 221b2db1b4cf001042a41f74916dbc06b8248dcd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Feb 2020 23:23:28 +0800
Subject: [PATCH 0292/3374] Create 358-rearrange-string-k-distance-apart.js

---
 358-rearrange-string-k-distance-apart.js | 60 ++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 358-rearrange-string-k-distance-apart.js

diff --git a/358-rearrange-string-k-distance-apart.js b/358-rearrange-string-k-distance-apart.js
new file mode 100644
index 00000000..9e1593ed
--- /dev/null
+++ b/358-rearrange-string-k-distance-apart.js
@@ -0,0 +1,60 @@
+/**
+
+Given a non-empty string s and an integer k,
+rearrange the string such that the same characters are at least distance k from each other.
+
+All input strings are given in lowercase letters.
+If it is not possible to rearrange the string, return an empty string "".
+
+Example 1:
+
+Input: s = "aabbcc", k = 3
+Output: "abcabc" 
+Explanation: The same letters are at least distance 3 from each other.
+Example 2:
+
+Input: s = "aaabc", k = 3
+Output: "" 
+Explanation: It is not possible to rearrange the string.
+Example 3:
+
+Input: s = "aaadbbcc", k = 2
+Output: "abacabcd"
+Explanation: The same letters are at least distance 2 from each other.
+
+*/
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const rearrangeString = function(s, k) {
+  const length = s.length
+  const count = new Array(26).fill(0)
+  const valid = new Array(26).fill(0)
+  for (let i = 0; i < length; i++) {
+    count[s.charCodeAt(i) - 'a'.charCodeAt(0)]++
+  }
+  let sb = ''
+  for (let index = 0; index < length; index++) {
+    let candidatePos = findValidMax(count, valid, index)
+    if (candidatePos == -1) return ''
+    count[candidatePos]--
+    valid[candidatePos] = index + k
+    sb += String.fromCharCode('a'.charCodeAt(0) + candidatePos)
+  }
+  return sb
+}
+
+function findValidMax(count, valid, index) {
+  let max = Number.MIN_VALUE
+  let candidatePos = -1
+  for (let i = 0; i < count.length; i++) {
+    if (count[i] > 0 && count[i] > max && index >= valid[i]) {
+      max = count[i]
+      candidatePos = i
+    }
+  }
+  return candidatePos
+}

From f6ab607aa3bd8d24fc3827f4184edd3fd3b9f978 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Feb 2020 00:14:51 +0800
Subject: [PATCH 0293/3374] Update 358-rearrange-string-k-distance-apart.js

---
 358-rearrange-string-k-distance-apart.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/358-rearrange-string-k-distance-apart.js b/358-rearrange-string-k-distance-apart.js
index 9e1593ed..19ea6b2a 100644
--- a/358-rearrange-string-k-distance-apart.js
+++ b/358-rearrange-string-k-distance-apart.js
@@ -33,8 +33,9 @@ const rearrangeString = function(s, k) {
   const length = s.length
   const count = new Array(26).fill(0)
   const valid = new Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
   for (let i = 0; i < length; i++) {
-    count[s.charCodeAt(i) - 'a'.charCodeAt(0)]++
+    count[s.charCodeAt(i) - a]++
   }
   let sb = ''
   for (let index = 0; index < length; index++) {
@@ -42,7 +43,7 @@ const rearrangeString = function(s, k) {
     if (candidatePos == -1) return ''
     count[candidatePos]--
     valid[candidatePos] = index + k
-    sb += String.fromCharCode('a'.charCodeAt(0) + candidatePos)
+    sb += String.fromCharCode(a + candidatePos)
   }
   return sb
 }
@@ -58,3 +59,4 @@ function findValidMax(count, valid, index) {
   }
   return candidatePos
 }
+

From 9b7e239d00068e09dafc6fa69cb4c041dfab8dbd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Feb 2020 00:43:37 +0800
Subject: [PATCH 0294/3374] Update 358-rearrange-string-k-distance-apart.js

---
 358-rearrange-string-k-distance-apart.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/358-rearrange-string-k-distance-apart.js b/358-rearrange-string-k-distance-apart.js
index 19ea6b2a..f0f22313 100644
--- a/358-rearrange-string-k-distance-apart.js
+++ b/358-rearrange-string-k-distance-apart.js
@@ -30,6 +30,7 @@ Explanation: The same letters are at least distance 2 from each other.
  * @return {string}
  */
 const rearrangeString = function(s, k) {
+  if(k > 26) return ''
   const length = s.length
   const count = new Array(26).fill(0)
   const valid = new Array(26).fill(0)

From 2eb36ff8955ede36759593bbc09cfde6c9f8a5ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Feb 2020 15:34:43 +0800
Subject: [PATCH 0295/3374] Create 356-line-reflection.js

---
 356-line-reflection.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 356-line-reflection.js

diff --git a/356-line-reflection.js b/356-line-reflection.js
new file mode 100644
index 00000000..8ce5f5cc
--- /dev/null
+++ b/356-line-reflection.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} points
+ * @return {boolean}
+ */
+const isReflected = function(points) {
+  let max = -Infinity,
+    min = +Infinity,
+    sum = 0,
+    length = points.length
+  const set = new Set()
+  for (let i = 0; i < length; i++) {
+    max = Math.max(max, points[i][0])
+    min = Math.min(min, points[i][0])
+    let curStr = points[i][0] + 'a' + points[i][1]
+    set.add(curStr)
+  }
+  sum = max + min
+  for (let j = 0; j < length; j++) {
+    let cur = sum - points[j][0] + 'a' + points[j][1]
+    if (!set.has(cur)) {
+      return false
+    }
+  }
+  return true
+}

From 35bd9618d1541b22aa0a9cbb7a1681348b32bde4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Feb 2020 16:45:14 +0800
Subject: [PATCH 0296/3374] Create 355-design-twitter.js

---
 355-design-twitter.js | 82 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 355-design-twitter.js

diff --git a/355-design-twitter.js b/355-design-twitter.js
new file mode 100644
index 00000000..44631adb
--- /dev/null
+++ b/355-design-twitter.js
@@ -0,0 +1,82 @@
+/**
+ * Initialize your data structure here.
+ */
+const Twitter = function() {
+  this.userTweets = new Map()
+  this.userFollowing = new Map()
+  this.lastIndex = 1
+}
+
+/**
+ * Compose a new tweet.
+ * @param {number} userId
+ * @param {number} tweetId
+ * @return {void}
+ */
+Twitter.prototype.postTweet = function(userId, tweetId) {
+  let tweets = this.userTweets.get(userId)
+  if (!tweets) {
+    tweets = []
+    this.userTweets.set(userId, tweets)
+  }
+  tweets.unshift({ id: tweetId, index: this.lastIndex })
+  this.lastIndex = this.lastIndex + 1
+}
+
+/**
+ * Retrieve the 10 most recent tweet ids in the user's news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent.
+ * @param {number} userId
+ * @return {number[]}
+ */
+Twitter.prototype.getNewsFeed = function(userId) {
+  const followings = this.userFollowing.get(userId)
+  let tweets = (this.userTweets.get(userId) || []).slice(0, 10)
+  followings &&
+    followings.forEach(uid => {
+      if (uid === userId) return
+
+      const userTweets = this.userTweets.get(uid)
+      if (userTweets) {
+        tweets = tweets.concat(userTweets)
+      }
+    })
+  return tweets
+    .sort((a, b) => b.index - a.index)
+    .map(tweet => tweet.id)
+    .slice(0, 10)
+}
+
+/**
+ * Follower follows a followee. If the operation is invalid, it should be a no-op.
+ * @param {number} followerId
+ * @param {number} followeeId
+ * @return {void}
+ */
+Twitter.prototype.follow = function(followerId, followeeId) {
+  let followings = this.userFollowing.get(followerId)
+  if (!followings) {
+    followings = new Set()
+    this.userFollowing.set(followerId, followings)
+  }
+  followings.add(followeeId)
+}
+
+/**
+ * Follower unfollows a followee. If the operation is invalid, it should be a no-op.
+ * @param {number} followerId
+ * @param {number} followeeId
+ * @return {void}
+ */
+Twitter.prototype.unfollow = function(followerId, followeeId) {
+  const followings = this.userFollowing.get(followerId)
+  followings && followings.delete(followeeId)
+}
+
+/**
+ * Your Twitter object will be instantiated and called as such:
+ * var obj = new Twitter()
+ * obj.postTweet(userId,tweetId)
+ * var param_2 = obj.getNewsFeed(userId)
+ * obj.follow(followerId,followeeId)
+ * obj.unfollow(followerId,followeeId)
+ */

From e47f0710a8194b148bd6d9dbd2d43718ab5f489e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Feb 2020 21:42:11 +0800
Subject: [PATCH 0297/3374] Create 353-design-snake-game.js

---
 353-design-snake-game.js | 79 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 353-design-snake-game.js

diff --git a/353-design-snake-game.js b/353-design-snake-game.js
new file mode 100644
index 00000000..0d650a8e
--- /dev/null
+++ b/353-design-snake-game.js
@@ -0,0 +1,79 @@
+/**
+ * Initialize your data structure here.
+        @param width - screen width
+        @param height - screen height 
+        @param food - A list of food positions
+        E.g food = [[1,1], [1,0]] means the first food is positioned at [1,1], the second is at [1,0].
+ * @param {number} width
+ * @param {number} height
+ * @param {number[][]} food
+ */
+const SnakeGame = function(width, height, food) {
+  this.width = width
+  this.height = height
+  this.food = food
+  this.foodIdx = 0
+  this.row = 0
+  this.col = 0
+  this.queue = [0]
+  this.visited = new Set([0])
+}
+
+/**
+ * Moves the snake.
+        @param direction - 'U' = Up, 'L' = Left, 'R' = Right, 'D' = Down 
+        @return The game's score after the move. Return -1 if game over. 
+        Game over when snake crosses the screen boundary or bites its body. 
+ * @param {string} direction
+ * @return {number}
+ */
+SnakeGame.prototype.move = function(direction) {
+  if (direction === 'U') {
+    this.row--
+  }
+  if (direction === 'R') {
+    this.col++
+  }
+  if (direction === 'D') {
+    this.row++
+  }
+  if (direction === 'L') {
+    this.col--
+  }
+  const head = this.row * this.width + this.col
+
+  // in the next move, head can be the previous tail, so check head !== this.queue[0]
+  if (head !== this.queue[0] && this.visited.has(head)) {
+    return -1
+  }
+
+  if (
+    this.row >= 0 &&
+    this.row < this.height &&
+    this.col >= 0 &&
+    this.col < this.width
+  ) {
+    // check if can eat food
+    if (
+      this.foodIdx < this.food.length &&
+      this.food[this.foodIdx][0] === this.row &&
+      this.food[this.foodIdx][1] === this.col
+    ) {
+      this.foodIdx++
+    } else {
+      this.visited.delete(this.queue[0])
+      this.queue.shift()
+    }
+
+    this.queue.push(head)
+    this.visited.add(head)
+    return this.foodIdx
+  }
+  return -1
+}
+
+/**
+ * Your SnakeGame object will be instantiated and called as such:
+ * var obj = new SnakeGame(width, height, food)
+ * var param_1 = obj.move(direction)
+ */

From c55915cbad649e7f46285b17ca80fab1e05f64bd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Feb 2020 16:51:05 +0800
Subject: [PATCH 0298/3374] Create 351-android-unlock-patterns.js

---
 351-android-unlock-patterns.js | 40 ++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 351-android-unlock-patterns.js

diff --git a/351-android-unlock-patterns.js b/351-android-unlock-patterns.js
new file mode 100644
index 00000000..749c4cf6
--- /dev/null
+++ b/351-android-unlock-patterns.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const numberOfPatterns = function(m, n) {
+  // Skip array represents number to skip between two pairs
+  const skip = Array.from({ length: 10 }, () => new Array(10).fill(0))
+  skip[1][3] = skip[3][1] = 2
+  skip[1][7] = skip[7][1] = 4
+  skip[3][9] = skip[9][3] = 6
+  skip[7][9] = skip[9][7] = 8
+  skip[1][9] = skip[9][1] = skip[2][8] = skip[8][2] = skip[3][7] = skip[7][3] = skip[4][6] = skip[6][4] = 5
+  const vis = new Array(10).fill(false)
+  let rst = 0
+  // DFS search each length from m to n
+  for (let i = m; i <= n; ++i) {
+    rst += DFS(vis, skip, 1, i - 1) * 4 // 1, 3, 7, 9 are symmetric
+    rst += DFS(vis, skip, 2, i - 1) * 4 // 2, 4, 6, 8 are symmetric
+    rst += DFS(vis, skip, 5, i - 1) // 5
+  }
+  return rst
+}
+
+// cur: the current position
+// remain: the steps remaining
+function DFS(vis, skip, cur, remain) {
+  if (remain < 0) return 0
+  if (remain === 0) return 1
+  vis[cur] = true
+  let rst = 0
+  for (let i = 1; i <= 9; ++i) {
+    // If vis[i] is not visited and (two numbers are adjacent or skip number is already visited)
+    if (!vis[i] && (skip[cur][i] === 0 || vis[skip[cur][i]])) {
+      rst += DFS(vis, skip, i, remain - 1)
+    }
+  }
+  vis[cur] = false
+  return rst
+}

From 1adcc60547595598f54d6ed68cf81c133bf5915c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Feb 2020 20:07:03 +0800
Subject: [PATCH 0299/3374] Create 348-design-tic-tac-toe.js

---
 348-design-tic-tac-toe.js | 52 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 348-design-tic-tac-toe.js

diff --git a/348-design-tic-tac-toe.js b/348-design-tic-tac-toe.js
new file mode 100644
index 00000000..53f8f840
--- /dev/null
+++ b/348-design-tic-tac-toe.js
@@ -0,0 +1,52 @@
+/**
+ * Initialize your data structure here.
+ * @param {number} n
+ */
+const TicTacToe = function(n) {
+  this.cols = new Array(n).fill(0)
+  this.rows = new Array(n).fill(0)
+  this.diagonal = 0
+  this.antiDiagonal = 0
+}
+
+/**
+ * Player {player} makes a move at ({row}, {col}).
+        @param row The row of the board.
+        @param col The column of the board.
+        @param player The player, can be either 1 or 2.
+        @return The current winning condition, can be either:
+                0: No one wins.
+                1: Player 1 wins.
+                2: Player 2 wins. 
+ * @param {number} row 
+ * @param {number} col 
+ * @param {number} player
+ * @return {number}
+ */
+TicTacToe.prototype.move = function(row, col, player) {
+  const toAdd = player === 1 ? 1 : -1
+  this.rows[row] += toAdd
+  this.cols[col] += toAdd
+  if (row === col) {
+    this.diagonal += toAdd
+  }
+  if (col === this.cols.length - row - 1) {
+    this.antiDiagonal += toAdd
+  }
+  const size = this.rows.length
+  if (
+    Math.abs(this.rows[row]) === size ||
+    Math.abs(this.cols[col]) === size ||
+    Math.abs(this.diagonal) === size ||
+    Math.abs(this.antiDiagonal) === size
+  ) {
+    return player
+  }
+  return 0
+}
+
+/**
+ * Your TicTacToe object will be instantiated and called as such:
+ * var obj = new TicTacToe(n)
+ * var param_1 = obj.move(row,col,player)
+ */

From 8153b1b374de0bebe160c7e5f95d90285587210b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Feb 2020 20:17:26 +0800
Subject: [PATCH 0300/3374] Update 348-design-tic-tac-toe.js

---
 348-design-tic-tac-toe.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/348-design-tic-tac-toe.js b/348-design-tic-tac-toe.js
index 53f8f840..131a396c 100644
--- a/348-design-tic-tac-toe.js
+++ b/348-design-tic-tac-toe.js
@@ -3,6 +3,7 @@
  * @param {number} n
  */
 const TicTacToe = function(n) {
+  this.n = n
   this.cols = new Array(n).fill(0)
   this.rows = new Array(n).fill(0)
   this.diagonal = 0
@@ -24,21 +25,21 @@ const TicTacToe = function(n) {
  * @return {number}
  */
 TicTacToe.prototype.move = function(row, col, player) {
+  const { n } = this
   const toAdd = player === 1 ? 1 : -1
   this.rows[row] += toAdd
   this.cols[col] += toAdd
   if (row === col) {
     this.diagonal += toAdd
   }
-  if (col === this.cols.length - row - 1) {
+  if (col === n - row - 1) {
     this.antiDiagonal += toAdd
   }
-  const size = this.rows.length
   if (
-    Math.abs(this.rows[row]) === size ||
-    Math.abs(this.cols[col]) === size ||
-    Math.abs(this.diagonal) === size ||
-    Math.abs(this.antiDiagonal) === size
+    Math.abs(this.rows[row]) === n ||
+    Math.abs(this.cols[col]) === n ||
+    Math.abs(this.diagonal) === n ||
+    Math.abs(this.antiDiagonal) === n
   ) {
     return player
   }

From 97cb3e4c5c1fe10f5b723b0a095338292c27b3a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Feb 2020 20:06:13 +0800
Subject: [PATCH 0301/3374] Create 346-moving-average-from-data-stream.js

---
 346-moving-average-from-data-stream.js | 30 ++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 346-moving-average-from-data-stream.js

diff --git a/346-moving-average-from-data-stream.js b/346-moving-average-from-data-stream.js
new file mode 100644
index 00000000..2b670d60
--- /dev/null
+++ b/346-moving-average-from-data-stream.js
@@ -0,0 +1,30 @@
+/**
+ * Initialize your data structure here.
+ * @param {number} size
+ */
+const MovingAverage = function(size) {
+  this.limit = size
+  this.arr = []
+  this.sum = 0
+};
+
+/** 
+ * @param {number} val
+ * @return {number}
+ */
+MovingAverage.prototype.next = function(val) {
+  this.arr.push(val)
+  this.sum += val
+  if(this.arr.length > this.limit) {
+    const tmp = this.arr[0]
+    this.arr.shift()
+    this.sum -= tmp
+  }
+  return this.sum / this.arr.length
+};
+
+/** 
+ * Your MovingAverage object will be instantiated and called as such:
+ * var obj = new MovingAverage(size)
+ * var param_1 = obj.next(val)
+ */

From f2d1aa591042e3c1aca9c6918f27b9f88fac1d88 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Feb 2020 20:43:38 +0800
Subject: [PATCH 0302/3374] Create
 340-longest-substring-with-at-most-k-distinct-characters.js

---
 ...ring-with-at-most-k-distinct-characters.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 340-longest-substring-with-at-most-k-distinct-characters.js

diff --git a/340-longest-substring-with-at-most-k-distinct-characters.js b/340-longest-substring-with-at-most-k-distinct-characters.js
new file mode 100644
index 00000000..76f65f15
--- /dev/null
+++ b/340-longest-substring-with-at-most-k-distinct-characters.js
@@ -0,0 +1,39 @@
+/**
+
+Given a string, find the length of the longest substring T that contains at most k distinct characters.
+
+Example 1:
+
+Input: s = "eceba", k = 2
+Output: 3
+Explanation: T is "ece" which its length is 3.
+Example 2:
+
+Input: s = "aa", k = 1
+Output: 2
+Explanation: T is "aa" which its length is 2.
+
+*/
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const lengthOfLongestSubstringKDistinct = function(s, k) {
+  const map = new Map()
+  let left = 0
+  let best = 0
+  for(let i = 0; i < s.length; i++) {
+    const c = s.charAt(i)
+    map.set(c, (map.get(c) || 0) + 1)
+    while(map.size > k) {
+      const lc = s.charAt(left)
+      map.set(lc, map.get(lc) - 1)
+      if(map.get(lc) === 0) map.delete(lc)
+      left++
+    }
+    best = Math.max(best, i - left + 1)
+  }
+  return best
+};

From 73d1d334e257072a14b9f5e81da5702495044dbb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Feb 2020 15:14:52 +0800
Subject: [PATCH 0303/3374] Create 339-nested-list-weight-sum.js

---
 339-nested-list-weight-sum.js | 61 +++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 339-nested-list-weight-sum.js

diff --git a/339-nested-list-weight-sum.js b/339-nested-list-weight-sum.js
new file mode 100644
index 00000000..ca6211ef
--- /dev/null
+++ b/339-nested-list-weight-sum.js
@@ -0,0 +1,61 @@
+/**
+ * // This is the interface that allows for creating nested lists.
+ * // You should not implement it, or speculate about its implementation
+ * function NestedInteger() {
+ *
+ *     Return true if this NestedInteger holds a single integer, rather than a nested list.
+ *     @return {boolean}
+ *     this.isInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Return the single integer that this NestedInteger holds, if it holds a single integer
+ *     Return null if this NestedInteger holds a nested list
+ *     @return {integer}
+ *     this.getInteger = function() {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a single integer equal to value.
+ *     @return {void}
+ *     this.setInteger = function(value) {
+ *         ...
+ *     };
+ *
+ *     Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
+ *     @return {void}
+ *     this.add = function(elem) {
+ *         ...
+ *     };
+ *
+ *     Return the nested list that this NestedInteger holds, if it holds a nested list
+ *     Return null if this NestedInteger holds a single integer
+ *     @return {NestedInteger[]}
+ *     this.getList = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {NestedInteger[]} nestedList
+ * @return {number}
+ */
+const depthSum = function(nestedList) {
+  const obj = { res: 0 }
+  h(nestedList, 1, obj)
+  return obj.res
+};
+
+function h(arr, level, obj) {
+  if(arr == null || arr.length === 0) return 0
+  const next = []
+  let sum = 0
+  for(let i = 0, len = arr.length; i < len; i++) {
+    if(arr[i].isInteger()) sum += arr[i].getInteger() * level
+    else {
+      next.push(...(arr[i].getList()))
+    }
+  }
+  obj.res += sum
+  h(next, level + 1, obj)
+}

From c8fbd02abf022690bfe945a584c533025c53d131 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Feb 2020 15:26:04 +0800
Subject: [PATCH 0304/3374] Update 339-nested-list-weight-sum.js

---
 339-nested-list-weight-sum.js | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/339-nested-list-weight-sum.js b/339-nested-list-weight-sum.js
index ca6211ef..688bb277 100644
--- a/339-nested-list-weight-sum.js
+++ b/339-nested-list-weight-sum.js
@@ -41,21 +41,17 @@
  * @return {number}
  */
 const depthSum = function(nestedList) {
-  const obj = { res: 0 }
-  h(nestedList, 1, obj)
-  return obj.res
+  return h(nestedList, 1)
 };
 
-function h(arr, level, obj) {
+function h(arr, level) {
   if(arr == null || arr.length === 0) return 0
-  const next = []
   let sum = 0
   for(let i = 0, len = arr.length; i < len; i++) {
     if(arr[i].isInteger()) sum += arr[i].getInteger() * level
     else {
-      next.push(...(arr[i].getList()))
+      sum += h(arr[i].getList(), level + 1)
     }
   }
-  obj.res += sum
-  h(next, level + 1, obj)
+  return sum
 }

From 807b4098a8a27bb2d9a30e86c5e0b3e3dfa683b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Feb 2020 15:51:29 +0800
Subject: [PATCH 0305/3374] Update 339-nested-list-weight-sum.js

---
 339-nested-list-weight-sum.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/339-nested-list-weight-sum.js b/339-nested-list-weight-sum.js
index 688bb277..d38d5c9f 100644
--- a/339-nested-list-weight-sum.js
+++ b/339-nested-list-weight-sum.js
@@ -55,3 +55,22 @@ function h(arr, level) {
   }
   return sum
 }
+
+// another
+
+const depthSum = function(nestedList) {
+  if(nestedList == null) return 0
+  let sum = 0
+  let level = 1
+  const q = [...nestedList]
+  while(q.length) {
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const el = q.shift()
+      if(el.isInteger()) sum += el.getInteger() * level
+      else q.push(...(el.getList()))
+    }
+    level++
+  }
+  return sum
+};

From d15c4ed21e45a3fa584c9cb414d9cc02ec60ab54 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Feb 2020 17:34:59 +0800
Subject: [PATCH 0306/3374] Create 335-self-crossing.js

---
 335-self-crossing.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 335-self-crossing.js

diff --git a/335-self-crossing.js b/335-self-crossing.js
new file mode 100644
index 00000000..85aa2f09
--- /dev/null
+++ b/335-self-crossing.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} x
+ * @return {boolean}
+ */
+const isSelfCrossing = function(x) {
+  for (let i = 3, l = x.length; i < l; i++) {
+    // Case 1: current line crosses the line 3 steps ahead of it
+    if (x[i] >= x[i - 2] && x[i - 1] <= x[i - 3]) return true
+    // Case 2: current line crosses the line 4 steps ahead of it
+    else if (i >= 4 && x[i - 1] == x[i - 3] && x[i] + x[i - 4] >= x[i - 2])
+      return true
+    // Case 3: current line crosses the line 6 steps ahead of it
+    else if (
+      i >= 5 &&
+      x[i - 2] >= x[i - 4] &&
+      x[i] + x[i - 4] >= x[i - 2] &&
+      x[i - 1] <= x[i - 3] &&
+      x[i - 1] + x[i - 5] >= x[i - 3]
+    )
+      return true
+  }
+  return false
+}

From 7097d183cb3a27d2ad0cfe01e371be403cde2590 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Feb 2020 16:25:19 +0800
Subject: [PATCH 0307/3374] Create 330-patching-array.js

---
 330-patching-array.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 330-patching-array.js

diff --git a/330-patching-array.js b/330-patching-array.js
new file mode 100644
index 00000000..83e6f9f6
--- /dev/null
+++ b/330-patching-array.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} n
+ * @return {number}
+ */
+const minPatches = function(nums, n) {
+  let answer = 0
+  for (let i = 0, next = 1; next <= n; ) {
+    if (i >= nums.length || nums[i] > next) {
+      answer++
+      next *= 2
+    } else next += nums[i++]
+  }
+  return answer
+}

From 2d7316a83ba247f1698d012db1b2a05baa9e1f42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Feb 2020 00:23:35 +0800
Subject: [PATCH 0308/3374] Create
 323-number-of-connected-components-in-an-undirected-graph.js

---
 ...ected-components-in-an-undirected-graph.js | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 323-number-of-connected-components-in-an-undirected-graph.js

diff --git a/323-number-of-connected-components-in-an-undirected-graph.js b/323-number-of-connected-components-in-an-undirected-graph.js
new file mode 100644
index 00000000..845491b7
--- /dev/null
+++ b/323-number-of-connected-components-in-an-undirected-graph.js
@@ -0,0 +1,52 @@
+/**
+
+Given n nodes labeled from 0 to n - 1 and a list of undirected
+edges (each edge is a pair of nodes), write a function to find
+the number of connected components in an undirected graph.
+
+Example 1:
+
+Input: n = 5 and edges = [[0, 1], [1, 2], [3, 4]]
+
+     0          3
+     |          |
+     1 --- 2    4 
+
+Output: 2
+
+Example 2:
+
+Input: n = 5 and edges = [[0, 1], [1, 2], [2, 3], [3, 4]]
+
+     0           4
+     |           |
+     1 --- 2 --- 3
+
+Output:  1
+
+Note:
+You can assume that no duplicate edges will appear in edges.
+Since all edges are undirected, [0, 1] is the same
+as [1, 0] and thus will not appear together in edges.
+
+*/
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countComponents = function(n, edges) {
+  const nums = Array(n).fill(-1)
+  for (let i = 0; i < edges.length; i++) {
+    const x = find(nums, edges[i][0])
+    const y = find(nums, edges[i][1])
+    if (x !== y) nums[x] = y
+  }
+  return nums.filter(num => num === -1).length
+}
+
+const find = (nums, i) => {
+  if (nums[i] === -1) return i
+  return find(nums, nums[i])
+}

From f8da7487a1cb2fd719a7260965f17e9d3122d945 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Feb 2020 18:12:28 +0800
Subject: [PATCH 0309/3374] Create 320-generalized-abbreviation.js

---
 320-generalized-abbreviation.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 320-generalized-abbreviation.js

diff --git a/320-generalized-abbreviation.js b/320-generalized-abbreviation.js
new file mode 100644
index 00000000..29748d4f
--- /dev/null
+++ b/320-generalized-abbreviation.js
@@ -0,0 +1,32 @@
+/**
+
+Write a function to generate the generalized abbreviations of a word. 
+Note: The order of the output does not matter.
+
+Example:
+
+Input: "word"
+Output:
+["word", "1ord", "w1rd", "wo1d", "wor1", "2rd", "w2d", "wo2", "1o1d", "1or1", "w1r1", "1o2", "2r1", "3d", "w3", "4"]
+
+*/
+
+/**
+ * @param {string} word
+ * @return {string[]}
+ */
+const generateAbbreviations = function(word) {
+  const arr = []
+  bt(arr, word, 0, '', 0)
+  return arr
+};
+
+function bt(res, word, pos, cur, cnt) {
+  if(pos === word.length) {
+    if(cnt > 0) cur += cnt
+    res.push(cur)
+  } else {
+    bt(res, word, pos + 1, cur, cnt + 1)
+    bt(res, word, pos + 1, cur + (cnt > 0 ? cnt : '') + word.charAt(pos), 0)
+  }
+}

From 8c3f028dbcb7858376e67d05e3110aca2473aaba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Feb 2020 22:16:23 +0800
Subject: [PATCH 0310/3374] Update 320-generalized-abbreviation.js

---
 320-generalized-abbreviation.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/320-generalized-abbreviation.js b/320-generalized-abbreviation.js
index 29748d4f..016c0045 100644
--- a/320-generalized-abbreviation.js
+++ b/320-generalized-abbreviation.js
@@ -17,16 +17,16 @@ Output:
  */
 const generateAbbreviations = function(word) {
   const arr = []
-  bt(arr, word, 0, '', 0)
+  dfs(arr, word, 0, '', 0)
   return arr
 };
 
-function bt(res, word, pos, cur, cnt) {
+function dfs(res, word, pos, cur, cnt) {
   if(pos === word.length) {
     if(cnt > 0) cur += cnt
     res.push(cur)
   } else {
-    bt(res, word, pos + 1, cur, cnt + 1)
-    bt(res, word, pos + 1, cur + (cnt > 0 ? cnt : '') + word.charAt(pos), 0)
+    dfs(res, word, pos + 1, cur, cnt + 1)
+    dfs(res, word, pos + 1, cur + (cnt > 0 ? cnt : '') + word.charAt(pos), 0)
   }
 }

From 432e2963df2098ab9a18dfb3df75e2e61111513a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Feb 2020 21:23:21 +0800
Subject: [PATCH 0311/3374] Create 317-shortest-distance-from-all-buildings.js

---
 317-shortest-distance-from-all-buildings.js | 59 +++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 317-shortest-distance-from-all-buildings.js

diff --git a/317-shortest-distance-from-all-buildings.js b/317-shortest-distance-from-all-buildings.js
new file mode 100644
index 00000000..0c60a3da
--- /dev/null
+++ b/317-shortest-distance-from-all-buildings.js
@@ -0,0 +1,59 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const DIRECTIONS = [
+  [0, 1],
+  [1, 0],
+  [0, -1],
+  [-1, 0]
+]
+
+function distanceFromBuilding(grid, r, c, distance, start) {
+  const rows = grid.length
+  const cols = grid[0].length
+  const queue = [[r, c, 1]]
+  let qIndex = 0
+  let minDistance = Infinity
+  while (qIndex < queue.length) {
+    const [r0, c0, d] = queue[qIndex]
+    for (const [dr, dc] of DIRECTIONS) {
+      const r1 = r0 + dr
+      const c1 = c0 + dc
+      if (
+        0 <= r1 &&
+        r1 < rows &&
+        0 <= c1 &&
+        c1 < cols &&
+        grid[r1][c1] === start
+      ) {
+        distance[r1][c1] += d
+        minDistance = Math.min(minDistance, distance[r1][c1])
+        grid[r1][c1] -= 1
+        queue.push([r1, c1, d + 1])
+      }
+    }
+    qIndex += 1
+  }
+  return minDistance
+}
+
+const shortestDistance = function(grid) {
+  const rows = grid.length
+  const cols = grid[0].length
+  const distance = new Array(rows).fill(null).map(() => new Array(cols).fill(0))
+  let start = 0
+  let minDistance = 0
+  for (let r = 0; r < rows; r += 1) {
+    for (let c = 0; c < cols; c += 1) {
+      if (grid[r][c] === 1) {
+        minDistance = distanceFromBuilding(grid, r, c, distance, start)
+        if (minDistance === Infinity) {
+          return -1
+        }
+        start -= 1
+      }
+    }
+  }
+  return minDistance
+}

From b08136b7c81c48311fd04e253d81e75a4ade306d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Feb 2020 14:04:02 +0800
Subject: [PATCH 0312/3374] Update 317-shortest-distance-from-all-buildings.js

---
 317-shortest-distance-from-all-buildings.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/317-shortest-distance-from-all-buildings.js b/317-shortest-distance-from-all-buildings.js
index 0c60a3da..1c670748 100644
--- a/317-shortest-distance-from-all-buildings.js
+++ b/317-shortest-distance-from-all-buildings.js
@@ -1,7 +1,3 @@
-/**
- * @param {number[][]} grid
- * @return {number}
- */
 const DIRECTIONS = [
   [0, 1],
   [1, 0],
@@ -38,6 +34,10 @@ function distanceFromBuilding(grid, r, c, distance, start) {
   return minDistance
 }
 
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
 const shortestDistance = function(grid) {
   const rows = grid.length
   const cols = grid[0].length

From ae9b4401ccd32e2b99860ce6b60665c113c269f5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Feb 2020 15:52:04 +0800
Subject: [PATCH 0313/3374] Create 313-super-ugly-number.js

---
 313-super-ugly-number.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 313-super-ugly-number.js

diff --git a/313-super-ugly-number.js b/313-super-ugly-number.js
new file mode 100644
index 00000000..4de633c8
--- /dev/null
+++ b/313-super-ugly-number.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} n
+ * @param {number[]} primes
+ * @return {number}
+ */
+const nthSuperUglyNumber = function(n, primes) {
+  if (n === 1) return 1
+  const indexes = new Array(primes.length).fill(0)
+  const arr = [1]
+  for (let i = 1; i <= n - 1; i++) {
+    arr[i] = +Infinity
+    for (let j = 0; j < primes.length; j++) {
+      arr[i] = Math.min(arr[i], arr[indexes[j]] * primes[j])
+    }
+    for (let j = 0; j < primes.length; j++) {
+      if (arr[i] === arr[indexes[j]] * primes[j]) {
+        indexes[j]++
+      }
+    }
+  }
+  return arr[n - 1]
+}

From 0a85740d8072e62fa11ea2c0f2eddcdd8bff9b1f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Feb 2020 12:36:53 +0800
Subject: [PATCH 0314/3374] Create 308-range-sum-query-2d-mutable.js

---
 308-range-sum-query-2d-mutable.js | 68 +++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 308-range-sum-query-2d-mutable.js

diff --git a/308-range-sum-query-2d-mutable.js b/308-range-sum-query-2d-mutable.js
new file mode 100644
index 00000000..183b4e31
--- /dev/null
+++ b/308-range-sum-query-2d-mutable.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number[][]} matrix
+ */
+const NumMatrix = function(matrix) {
+  this.matrix = matrix
+  if (matrix.length === 0) {
+    this.sums = []
+  } else {
+    this.sums = new Array(matrix.length + 1)
+      .fill()
+      .map(() => new Array(matrix[0].length + 1).fill(0))
+  }
+  this.insert = (i, j, diff) => {
+    for (let n = i; n < this.sums.length; n += n & -n) {
+      for (let m = j; m < this.sums[n].length; m += m & -m) {
+        this.sums[n][m] += diff
+      }
+    }
+  }
+  this.search = (i, j) => {
+    let sum = 0
+    for (let n = i; n > 0; n -= n & -n) {
+      for (let m = j; m > 0; m -= m & -m) {
+        sum += this.sums[n][m]
+      }
+    }
+    return sum
+  }
+  for (let n = 0; n < matrix.length; n++) {
+    for (let m = 0; m < matrix[n].length; m++) {
+      this.insert(n + 1, m + 1, matrix[n][m])
+    }
+  }
+}
+
+/**
+ * @param {number} row
+ * @param {number} col
+ * @param {number} val
+ * @return {void}
+ */
+NumMatrix.prototype.update = function(row, col, val) {
+  this.insert(row + 1, col + 1, val - this.matrix[row][col])
+  this.matrix[row][col] = val
+}
+
+/**
+ * @param {number} row1
+ * @param {number} col1
+ * @param {number} row2
+ * @param {number} col2
+ * @return {number}
+ */
+NumMatrix.prototype.sumRegion = function(row1, col1, row2, col2) {
+  return (
+    this.search(row2 + 1, col2 + 1) -
+    this.search(row1, col2 + 1) -
+    this.search(row2 + 1, col1) +
+    this.search(row1, col1)
+  )
+}
+
+/**
+ * Your NumMatrix object will be instantiated and called as such:
+ * var obj = new NumMatrix(matrix)
+ * obj.update(row,col,val)
+ * var param_2 = obj.sumRegion(row1,col1,row2,col2)
+ */

From 0614d59fefacf07ab2c35f203c671db2b50de5a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Feb 2020 20:47:16 +0800
Subject: [PATCH 0315/3374] Create 306-additive-number.js

---
 306-additive-number.js | 54 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 306-additive-number.js

diff --git a/306-additive-number.js b/306-additive-number.js
new file mode 100644
index 00000000..29879f49
--- /dev/null
+++ b/306-additive-number.js
@@ -0,0 +1,54 @@
+/**
+
+Additive number is a string whose digits can form additive sequence.
+A valid additive sequence should contain at least three numbers.
+Except for the first two numbers, each subsequent number in the sequence must be the sum of the preceding two.
+Given a string containing only digits '0'-'9', write a function to determine if it's an additive number.
+Note: Numbers in the additive sequence cannot have leading zeros, so sequence 1, 2, 03 or 1, 02, 3 is invalid.
+
+Example 1:
+
+Input: "112358"
+Output: true
+Explanation: The digits can form an additive sequence: 1, 1, 2, 3, 5, 8. 
+             1 + 1 = 2, 1 + 2 = 3, 2 + 3 = 5, 3 + 5 = 8
+
+Example 2:
+
+Input: "199100199"
+Output: true
+Explanation: The additive sequence is: 1, 99, 100, 199. 
+             1 + 99 = 100, 99 + 100 = 199
+ 
+Constraints:
+
+num consists only of digits '0'-'9'.
+1 <= num.length <= 35
+
+*/
+
+/**
+ * @param {string} num
+ * @return {boolean}
+ */
+const isAdditiveNumber = function(num) {
+  const n = num.length
+  for (let i = 1; i <= (n / 2) >> 0; ++i) {
+    if (num.charAt(0) === '0' && i > 1) return false
+    const x1 = +num.slice(0, i)
+    for (let j = 1; Math.max(j, i) <= n - i - j; ++j) {
+      if (num.charAt(i) == '0' && j > 1) break
+      const x2 = +num.slice(i, i + j)
+      if (isValid(x1, x2, j + i, num)) return true
+    }
+  }
+  return false
+}
+
+function isValid(x1, x2, start, num) {
+  if (start === num.length) return true
+  x2 = x2 + x1
+  x1 = x2 - x1
+  const sum = x2 + ''
+  return num.startsWith(sum, start) && isValid(x1, x2, start + sum.length, num)
+}

From f023a0709c222c2c4512cb03f858ae6573239495 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Feb 2020 21:32:34 +0800
Subject: [PATCH 0316/3374] Create 305-number-of-islands-ii.js

---
 305-number-of-islands-ii.js | 49 +++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 305-number-of-islands-ii.js

diff --git a/305-number-of-islands-ii.js b/305-number-of-islands-ii.js
new file mode 100644
index 00000000..aeb510f7
--- /dev/null
+++ b/305-number-of-islands-ii.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} positions
+ * @return {number[]}
+ */
+const numIslands2 = function(m, n, positions) {
+  const result = []
+  if (m <= 0 || n <= 0) return result
+  const dirs = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0]
+  ]
+  let count = 0
+  const roots = new Array(m * n).fill(-1)
+  for (let p of positions) {
+    let root = n * p[0] + p[1]
+    if (roots[root] !== -1) {
+      result.push(count)
+      continue
+    }
+    roots[root] = root
+    count++
+    for (let dir of dirs) {
+      const x = p[0] + dir[0]
+      const y = p[1] + dir[1]
+      const nb = n * x + y
+      if (x < 0 || x >= m || y < 0 || y >= n || roots[nb] === -1) continue
+      const rootNb = findIsland(roots, nb)
+      if (root !== rootNb) {
+        roots[root] = rootNb
+        root = rootNb
+        count--
+      }
+    }
+    result.push(count)
+  }
+  return result
+}
+
+function findIsland(roots, id) {
+  while (id !== roots[id]) {
+    roots[id] = roots[roots[id]]
+    id = roots[id]
+  }
+  return id
+}

From fe519f0b6bdfb47d9a40285dd61712c15b60487c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Feb 2020 21:34:24 +0800
Subject: [PATCH 0317/3374] Update 305-number-of-islands-ii.js

---
 305-number-of-islands-ii.js | 42 +++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/305-number-of-islands-ii.js b/305-number-of-islands-ii.js
index aeb510f7..2002e476 100644
--- a/305-number-of-islands-ii.js
+++ b/305-number-of-islands-ii.js
@@ -1,3 +1,45 @@
+/**
+
+A 2d grid map of m rows and n columns is initially filled with water.
+We may perform an addLand operation which turns the water at position (row, col) into a land.
+Given a list of positions to operate, count the number of islands after each addLand operation.
+An island is surrounded by water and is formed by connecting adjacent lands horizontally or vertically.
+You may assume all four edges of the grid are all surrounded by water.
+
+Example:
+
+Input: m = 3, n = 3, positions = [[0,0], [0,1], [1,2], [2,1]]
+Output: [1,1,2,3]
+Explanation:
+
+Initially, the 2d grid grid is filled with water. (Assume 0 represents water and 1 represents land).
+
+0 0 0
+0 0 0
+0 0 0
+Operation #1: addLand(0, 0) turns the water at grid[0][0] into a land.
+
+1 0 0
+0 0 0   Number of islands = 1
+0 0 0
+Operation #2: addLand(0, 1) turns the water at grid[0][1] into a land.
+
+1 1 0
+0 0 0   Number of islands = 1
+0 0 0
+Operation #3: addLand(1, 2) turns the water at grid[1][2] into a land.
+
+1 1 0
+0 0 1   Number of islands = 2
+0 0 0
+Operation #4: addLand(2, 1) turns the water at grid[2][1] into a land.
+
+1 1 0
+0 0 1   Number of islands = 3
+0 1 0
+
+*/
+
 /**
  * @param {number} m
  * @param {number} n

From eb96dcbb75fb490169f942cf68c11ab1435d7690 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Feb 2020 14:27:02 +0800
Subject: [PATCH 0318/3374] Create 499-the-maze-iii.js

---
 499-the-maze-iii.js | 113 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 499-the-maze-iii.js

diff --git a/499-the-maze-iii.js b/499-the-maze-iii.js
new file mode 100644
index 00000000..fb2afeff
--- /dev/null
+++ b/499-the-maze-iii.js
@@ -0,0 +1,113 @@
+const dirs = [
+  [1, 0, 'd'],
+  [0, -1, 'l'],
+  [0, 1, 'r'],
+  [-1, 0, 'u']
+]
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} ball
+ * @param {number[]} hole
+ * @return {string}
+ */
+const findShortestWay = function(maze, ball, hole) {
+  const m = maze.length
+  const n = maze[0].length
+  const dist = [...new Array(m)].map(() => new Array(n).fill(Infinity))
+  dist[ball[0]][ball[1]] = 0
+  const pq = new PriorityQueue({
+    comparator: (a, b) => {
+      if (dist[a[0][0]][a[0][1]] !== dist[b[0][0]][b[0][1]]) {
+        return dist[a[0][0]][a[0][1]] < dist[b[0][0]][b[0][1]]
+      }
+      return a[1] < b[1]
+    }
+  })
+  pq.enqueue([ball, ''])
+  while (pq.length) {
+    const [[x, y], path] = pq.dequeue()
+    if (x === hole[0] && y === hole[1]) {
+      return path
+    }
+    for (const [di, dj, dir] of dirs) {
+      if (isValidPosition(x + di, y + dj, m, n) && maze[x + di][y + dj] === 0) {
+        const [i, j] = walk(maze, x + di, y + dj, di, dj, m, n, hole)
+        const deltaDist = Math.abs(x - i) + Math.abs(y - j)
+        if (dist[x][y] + deltaDist <= dist[i][j]) {
+          dist[i][j] = dist[x][y] + deltaDist
+          pq.enqueue([[i, j], path + dir])
+        }
+      }
+    }
+  }
+  return 'impossible'
+}
+
+function walk(maze, x, y, di, dj, m, n, [hi, hj]) {
+  let i = x
+  let j = y
+  while (
+    isValidPosition(i + di, j + dj, m, n) &&
+    maze[i + di][j + dj] === 0 &&
+    !(hi === i && hj === j)
+  ) {
+    i += di
+    j += dj
+  }
+  return [i, j]
+}
+
+function isValidPosition(i, j, m, n) {
+  if (i < 0 || i >= m || j < 0 || j >= n) {
+    return false
+  }
+  return true
+}
+
+class PriorityQueue {
+  constructor({ comparator }) {
+    this.comparator = comparator
+    this.arr = []
+  }
+
+  enqueue(element) {
+    this.arr.push(element)
+    moveUp(this.arr, this.arr.length - 1, this.comparator)
+  }
+
+  dequeue() {
+    const output = this.arr[0]
+    this.arr[0] = this.arr[this.arr.length - 1]
+    this.arr.pop()
+    moveDown(this.arr, 0, this.comparator)
+    return output
+  }
+
+  get length() {
+    return this.arr.length
+  }
+}
+
+function moveUp(arr, i, comparator) {
+  const p = Math.floor((i - 1) / 2)
+  const isValid = p < 0 || comparator(arr[p], arr[i])
+  if (!isValid) {
+    ;[arr[i], arr[p]] = [arr[p], arr[i]]
+    moveUp(arr, p, comparator)
+  }
+}
+
+function moveDown(arr, i, comparator) {
+  const left = 2 * i + 1
+  const right = 2 * i + 2
+  const isValid =
+    (left >= arr.length || comparator(arr[i], arr[left])) &&
+    (right >= arr.length || comparator(arr[i], arr[right]))
+  if (!isValid) {
+    const next =
+      right >= arr.length || comparator(arr[left], arr[right]) ? left : right
+    ;[arr[i], arr[next]] = [arr[next], arr[i]]
+    moveDown(arr, next, comparator)
+  }
+}

From 8ab71e8433421bc189e21bd24eb8784557a954d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Feb 2020 14:29:41 +0800
Subject: [PATCH 0319/3374] Update 499-the-maze-iii.js

---
 499-the-maze-iii.js | 64 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/499-the-maze-iii.js b/499-the-maze-iii.js
index fb2afeff..8a960cd0 100644
--- a/499-the-maze-iii.js
+++ b/499-the-maze-iii.js
@@ -1,3 +1,67 @@
+/**
+
+There is a ball in a maze with empty spaces and walls.
+The ball can go through empty spaces by rolling up (u), down (d), left (l) or right (r),
+but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.
+There is also a hole in this maze. The ball will drop into the hole if it rolls on to the hole.
+
+Given the ball position, the hole position and the maze,
+find out how the ball could drop into the hole by moving the shortest distance.
+The distance is defined by the number of empty spaces traveled by the ball from
+the start position (excluded) to the hole (included).
+Output the moving directions by using 'u', 'd', 'l' and 'r'.
+Since there could be several different shortest ways, you should output the lexicographically smallest way.
+If the ball cannot reach the hole, output "impossible".
+
+The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space.
+You may assume that the borders of the maze are all walls.
+The ball and the hole coordinates are represented by row and column indexes.
+
+Example 1:
+
+Input 1: a maze represented by a 2D array
+
+0 0 0 0 0
+1 1 0 0 1
+0 0 0 0 0
+0 1 0 0 1
+0 1 0 0 0
+
+Input 2: ball coordinate (rowBall, colBall) = (4, 3)
+Input 3: hole coordinate (rowHole, colHole) = (0, 1)
+
+Output: "lul"
+
+Explanation: There are two shortest ways for the ball to drop into the hole.
+The first way is left -> up -> left, represented by "lul".
+The second way is up -> left, represented by 'ul'.
+Both ways have shortest distance 6, but the first way is lexicographically smaller because 'l' < 'u'. So the output is "lul".
+
+Example 2:
+
+Input 1: a maze represented by a 2D array
+
+0 0 0 0 0
+1 1 0 0 1
+0 0 0 0 0
+0 1 0 0 1
+0 1 0 0 0
+
+Input 2: ball coordinate (rowBall, colBall) = (4, 3)
+Input 3: hole coordinate (rowHole, colHole) = (3, 0)
+
+Output: "impossible"
+
+Note:
+
+There is only one ball and one hole in the maze.
+Both the ball and hole exist on an empty space, and they will not be at the same position initially.
+The given maze does not contain border (like the red rectangle in the example pictures),
+but you could assume the border of the maze are all walls.
+The maze contains at least 2 empty spaces, and the width and the height of the maze won't exceed 30.
+
+*/
+
 const dirs = [
   [1, 0, 'd'],
   [0, -1, 'l'],

From 70fa39223782bcd8433c9a307d98e5f49938c96a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Feb 2020 21:57:37 +0800
Subject: [PATCH 0320/3374] Update 499-the-maze-iii.js

---
 499-the-maze-iii.js | 53 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/499-the-maze-iii.js b/499-the-maze-iii.js
index 8a960cd0..f7543ea1 100644
--- a/499-the-maze-iii.js
+++ b/499-the-maze-iii.js
@@ -62,6 +62,59 @@ The maze contains at least 2 empty spaces, and the width and the height of the m
 
 */
 
+/**
+ * @param {number[][]} maze
+ * @param {number[]} ball
+ * @param {number[]} hole
+ * @return {string}
+ */
+function findShortestWay(maze, ball, hole) {
+  const H = maze.length
+  const W = maze[0].length
+  const costs = [...Array(H)].map(r => Array(W).fill(Number.MAX_VALUE))
+  let minRoute = ''
+  dfs(ball[0], ball[1], 0, '')
+  return minRoute || 'impossible'
+
+  function dfs(r, c, cost, route) {
+    if (cost >= costs[r][c]) return
+    costs[r][c] = cost
+    for (let [dr, dc, d] of [
+      [1, 0, 'd'],
+      [0, -1, 'l'],
+      [0, 1, 'r'],
+      [-1, 0, 'u']
+    ]) {
+      let rr = r
+      let cc = c
+      let steps = 0
+      for (
+        ;
+        rr + dr >= 0 &&
+        rr + dr < H &&
+        cc + dc >= 0 &&
+        cc + dc < W &&
+        maze[rr + dr][cc + dc] !== 1;
+
+      ) {
+        rr += dr
+        cc += dc
+        steps++
+        if (rr === hole[0] && cc === hole[1]) {
+          if (cost + steps < costs[hole[0]][hole[1]]) {
+            costs[hole[0]][hole[1]] = cost + steps
+            minRoute = route + d
+          }
+          return
+        }
+      }
+      dfs(rr, cc, cost + steps, route + d)
+    }
+  }
+}
+
+// another
+
 const dirs = [
   [1, 0, 'd'],
   [0, -1, 'l'],

From 617945124c40acd5278de95120512bd69a061991 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Feb 2020 01:23:49 +0800
Subject: [PATCH 0321/3374] Create 505-the-maze-ii.js

---
 505-the-maze-ii.js | 110 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 505-the-maze-ii.js

diff --git a/505-the-maze-ii.js b/505-the-maze-ii.js
new file mode 100644
index 00000000..b63952bd
--- /dev/null
+++ b/505-the-maze-ii.js
@@ -0,0 +1,110 @@
+/**
+
+There is a ball in a maze with empty spaces and walls.
+The ball can go through empty spaces by rolling up, down, left or right,
+but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.
+
+Given the ball's start position, the destination and the maze,
+find the shortest distance for the ball to stop at the destination.
+The distance is defined by the number of empty spaces traveled by the ball from the start position (excluded) to
+the destination (included). If the ball cannot stop at the destination, return -1.
+
+The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space.
+You may assume that the borders of the maze are all walls.
+The start and destination coordinates are represented by row and column indexes.
+
+Example 1:
+
+Input 1: a maze represented by a 2D array
+
+0 0 1 0 0
+0 0 0 0 0
+0 0 0 1 0
+1 1 0 1 1
+0 0 0 0 0
+
+Input 2: start coordinate (rowStart, colStart) = (0, 4)
+Input 3: destination coordinate (rowDest, colDest) = (4, 4)
+
+Output: 12
+
+Explanation: One shortest way is : left -> down -> left -> down -> right -> down -> right.
+             The total distance is 1 + 1 + 3 + 1 + 2 + 2 + 2 = 12.
+
+Example 2:
+
+Input 1: a maze represented by a 2D array
+
+0 0 1 0 0
+0 0 0 0 0
+0 0 0 1 0
+1 1 0 1 1
+0 0 0 0 0
+
+Input 2: start coordinate (rowStart, colStart) = (0, 4)
+Input 3: destination coordinate (rowDest, colDest) = (3, 2)
+
+Output: -1
+
+Explanation: There is no way for the ball to stop at the destination.
+
+Note:
+
+There is only one ball and one destination in the maze.
+Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
+The given maze does not contain border (like the red rectangle in the example pictures),
+but you could assume the border of the maze are all walls.
+The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.
+
+*/
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} start
+ * @param {number[]} destination
+ * @return {number}
+ */
+const shortestDistance = function(maze, start, destination) {
+  const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, 1],
+    [0, -1]
+  ]
+  if (maze == null || maze.length === 0 || maze[0].length === 0) return -1
+  const m = maze.length
+  const n = maze[0].length
+  const d = Array.from({ length: m }, () => new Array(n).fill(Infinity))
+  const q = [[start[0], start[1], 0]]
+
+  while (q.length) {
+    const cur = q.shift()
+    for (let dir of dirs) {
+      let nextX = cur[0]
+      let nextY = cur[1]
+      let len = cur[2]
+      while (
+        nextX >= 0 &&
+        nextX < m &&
+        nextY >= 0 &&
+        nextY < n &&
+        maze[nextX][nextY] === 0
+      ) {
+        nextX += dir[0]
+        nextY += dir[1]
+        len++
+      }
+      nextX -= dir[0]
+      nextY -= dir[1]
+      len--
+      if (len > d[destination[0]][destination[1]]) continue
+      if (len < d[nextX][nextY]) {
+        d[nextX][nextY] = len
+        q.push([nextX, nextY, len])
+      }
+    }
+  }
+  return d[destination[0]][destination[1]] === Infinity
+    ? -1
+    : d[destination[0]][destination[1]]
+}

From 9a9578beaf898b7047f279d4e7285dafca5c4b25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Feb 2020 14:16:42 +0800
Subject: [PATCH 0322/3374] Create 490-the-maze.js

---
 490-the-maze.js | 92 +++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 490-the-maze.js

diff --git a/490-the-maze.js b/490-the-maze.js
new file mode 100644
index 00000000..067b742e
--- /dev/null
+++ b/490-the-maze.js
@@ -0,0 +1,92 @@
+/**
+
+There is a ball in a maze with empty spaces and walls.
+The ball can go through empty spaces by rolling up, down, left or right,
+but it won't stop rolling until hitting a wall. When the ball stops, it could choose the next direction.
+Given the ball's start position, the destination and the maze, determine whether the ball could stop at the destination.
+
+The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space.
+You may assume that the borders of the maze are all walls.
+The start and destination coordinates are represented by row and column indexes.
+
+Example 1:
+
+Input 1: a maze represented by a 2D array
+
+0 0 1 0 0
+0 0 0 0 0
+0 0 0 1 0
+1 1 0 1 1
+0 0 0 0 0
+
+Input 2: start coordinate (rowStart, colStart) = (0, 4)
+Input 3: destination coordinate (rowDest, colDest) = (4, 4)
+
+Output: true
+
+Explanation: One possible way is : left -> down -> left -> down -> right -> down -> right.
+
+Example 2:
+
+Input 1: a maze represented by a 2D array
+
+0 0 1 0 0
+0 0 0 0 0
+0 0 0 1 0
+1 1 0 1 1
+0 0 0 0 0
+
+Input 2: start coordinate (rowStart, colStart) = (0, 4)
+Input 3: destination coordinate (rowDest, colDest) = (3, 2)
+
+Output: false
+
+Explanation: There is no way for the ball to stop at the destination.
+
+Note:
+
+There is only one ball and one destination in the maze.
+Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
+The given maze does not contain border (like the red rectangle in the example pictures),
+but you could assume the border of the maze are all walls.
+The maze contains at least 2 empty spaces, and both the width and height of the maze won't exceed 100.
+
+*/
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} start
+ * @param {number[]} destination
+ * @return {boolean}
+ */
+const hasPath = function(maze, start, destination) {
+  const m = maze.length
+  const n = maze[0].length
+  const queue = []
+  const visited = Array.from({ length: m }, () => new Array(n).fill(false))
+  queue.push(start)
+  const dirs = [
+    [-1, 0],
+    [0, -1],
+    [0, 1],
+    [1, 0]
+  ]
+  while (queue.length) {
+    const cur = queue.shift()
+    if (cur[0] === destination[0] && cur[1] === destination[1]) return true
+    if (visited[cur[0]][cur[1]]) continue
+    visited[cur[0]][cur[1]] = true
+    for (let dir of dirs) {
+      let x = cur[0],
+        y = cur[1]
+      while (x >= 0 && x < m && y >= 0 && y < n && maze[x][y] === 0) {
+        x += dir[0]
+        y += dir[1]
+      }
+      x -= dir[0]
+      y -= dir[1]
+      queue.push([x, y])
+    }
+  }
+  return false
+}

From 7ec8d6f38fd71e00591e3ea8945103286e154f80 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Feb 2020 14:56:57 +0800
Subject: [PATCH 0323/3374] Update 490-the-maze.js

---
 490-the-maze.js | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/490-the-maze.js b/490-the-maze.js
index 067b742e..ff002f72 100644
--- a/490-the-maze.js
+++ b/490-the-maze.js
@@ -90,3 +90,51 @@ const hasPath = function(maze, start, destination) {
   }
   return false
 }
+
+// another
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} start
+ * @param {number[]} destination
+ * @return {boolean}
+ */
+const hasPath = function(maze, start, destination) {
+  const visited = Array.from({ length: maze.length }, () =>
+    new Array(maze[0].length).fill(false)
+  )
+  const dirs = [
+    [-1, 0],
+    [0, -1],
+    [0, 1],
+    [1, 0]
+  ]
+  return dfs(maze, start, destination, visited, dirs)
+}
+
+function dfs(maze, start, destination, visited, dirs) {
+  if (visited[start[0]][start[1]]) return false
+  if (start[0] === destination[0] && start[1] === destination[1]) return true
+  visited[start[0]][start[1]] = true
+  for (let i = 0; i < dirs.length; i++) {
+    const d = dirs[i]
+    let row = start[0]
+    let col = start[1]
+    while (isValid(maze, row + d[0], col + d[1])) {
+      row += d[0]
+      col += d[1]
+    }
+    if (dfs(maze, [row, col], destination, visited, dirs)) return true
+  }
+  return false
+}
+
+function isValid(maze, row, col) {
+  return (
+    row >= 0 &&
+    row < maze.length &&
+    col >= 0 &&
+    col < maze[0].length &&
+    maze[row][col] !== 1
+  )
+}

From b87c5dcf00418ffae2b24c67200096f1b4a0d00d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Feb 2020 10:05:29 +0800
Subject: [PATCH 0324/3374] Create
 497-random-point-in-non-overlapping-rectangles.js

---
 ...dom-point-in-non-overlapping-rectangles.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 497-random-point-in-non-overlapping-rectangles.js

diff --git a/497-random-point-in-non-overlapping-rectangles.js b/497-random-point-in-non-overlapping-rectangles.js
new file mode 100644
index 00000000..e7aba4df
--- /dev/null
+++ b/497-random-point-in-non-overlapping-rectangles.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} rects
+ */
+const Solution = function(rects) {
+  this.rects = rects
+  this.areas = rects.map(([x1, y1, x2, y2]) => (x2 - x1 + 1) * (y2 - y1 + 1))
+}
+
+/**
+ * @return {number[]}
+ */
+Solution.prototype.pick = function() {
+  const { rects, areas } = this
+  let areaSum = 0
+  let selected
+  for (let i = 0; i < rects.length; i++) {
+    const area = areas[i]
+    areaSum += area
+    const p = area / areaSum
+    if (Math.random() < p) {
+      selected = rects[i]
+    }
+  }
+  const [x1, y1, x2, y2] = selected
+  return [
+    ((Math.random() * (x2 - x1 + 1)) | 0) + x1,
+    ((Math.random() * (y2 - y1 + 1)) | 0) + y1
+  ]
+}
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(rects)
+ * var param_1 = obj.pick()
+ */

From d510e2936b5f300574390acf4182c9cd393cdc89 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Feb 2020 10:23:08 +0800
Subject: [PATCH 0325/3374] Update
 497-random-point-in-non-overlapping-rectangles.js

---
 ...dom-point-in-non-overlapping-rectangles.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/497-random-point-in-non-overlapping-rectangles.js b/497-random-point-in-non-overlapping-rectangles.js
index e7aba4df..1dc372ac 100644
--- a/497-random-point-in-non-overlapping-rectangles.js
+++ b/497-random-point-in-non-overlapping-rectangles.js
@@ -32,3 +32,47 @@ Solution.prototype.pick = function() {
  * var obj = new Solution(rects)
  * var param_1 = obj.pick()
  */
+
+// another
+
+/**
+ * @param {number[][]} rects
+ */
+const Solution = function(rects) {
+  const xywhs = []
+  const acc_sums = [0]
+  let sum = 0
+  for (const [x, y, x2, y2] of rects) {
+    const w = x2 - x + 1
+    const h = y2 - y + 1
+    xywhs.push({ x, y, w, h })
+    sum += w * h
+    acc_sums.push(sum)
+  }
+  this.xywhs = xywhs
+  this.acc_sums = acc_sums
+}
+
+/**
+ * @return {number[]}
+ */
+Solution.prototype.pick = function() {
+  const picked = Math.floor(
+    Math.random() * this.acc_sums[this.acc_sums.length - 1]
+  )
+  let i = 0
+  for (; i < this.acc_sums.length - 2; i++) {
+    if (picked >= this.acc_sums[i] && picked < this.acc_sums[i + 1]) {
+      break
+    }
+  }
+  const { x, y, w, h } = this.xywhs[i]
+  return [x + Math.floor(Math.random() * w), y + Math.floor(Math.random() * h)]
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(rects)
+ * var param_1 = obj.pick()
+ */
+

From f9a82df1f363e09af4c4ee355e2dc98d45293963 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Feb 2020 17:38:52 +0800
Subject: [PATCH 0326/3374] Create 495-teemo-attacking.js

---
 495-teemo-attacking.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 495-teemo-attacking.js

diff --git a/495-teemo-attacking.js b/495-teemo-attacking.js
new file mode 100644
index 00000000..47876b5a
--- /dev/null
+++ b/495-teemo-attacking.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} timeSeries
+ * @param {number} duration
+ * @return {number}
+ */
+const findPoisonedDuration = function(timeSeries, duration) {
+  if (timeSeries == null || timeSeries.length === 0) return 0
+  let res = 0
+  for (let i = 1, len = timeSeries.length; i < len; i++) {
+    const tmp =
+      timeSeries[i - 1] + duration > timeSeries[i]
+        ? timeSeries[i] - timeSeries[i - 1]
+        : duration
+    res += tmp
+  }
+  return res + duration
+}

From 79be4d5605b0d65f9685e4241df5922d38bc0763 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Feb 2020 18:26:49 +0800
Subject: [PATCH 0327/3374] Create 489-robot-room-cleaner.js

---
 489-robot-room-cleaner.js | 60 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 489-robot-room-cleaner.js

diff --git a/489-robot-room-cleaner.js b/489-robot-room-cleaner.js
new file mode 100644
index 00000000..94f96564
--- /dev/null
+++ b/489-robot-room-cleaner.js
@@ -0,0 +1,60 @@
+/**
+ * // This is the robot's control interface.
+ * // You should not implement it, or speculate about its implementation
+ * function Robot() {
+ *
+ *     // Returns true if the cell in front is open and robot moves into the cell.
+ *     // Returns false if the cell in front is blocked and robot stays in the current cell.
+ *     @return {boolean}
+ *     this.move = function() {
+ *         ...
+ *     };
+ *
+ *     // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *     // Each turn will be 90 degrees.
+ *     @return {void}
+ *     this.turnLeft = function() {
+ *         ...
+ *     };
+ * 
+ *     // Robot will stay in the same cell after calling turnLeft/turnRight.
+ *     // Each turn will be 90 degrees.
+ *     @return {void} 
+ *     this.turnRight = function() {
+ *         ...
+ *     };
+ *
+ *     // Clean the current cell.
+ *     @return {void}
+ *     this.clean = function() {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {Robot} robot
+ * @return {void}
+ */
+const cleanRoom = function(robot) {
+    const visited = new Set();
+    const shift = [[-1,0],[0,1],[1,0],[0,-1]];
+    dfs(0,0,0);
+    function dfs(r, c, dir) {
+        visited.add(r+','+c);
+        robot.clean();
+        for (let i = 0; i < 4; i++) {
+            const newDir = (dir + i) % 4;
+            const x = shift[newDir][0] + r;
+            const y = shift[newDir][1] + c;
+            if (!visited.has(x+','+y) && robot.move()) {
+                dfs(x, y, newDir);
+                robot.turnRight();
+                robot.turnRight();
+                robot.move();
+                robot.turnRight();
+                robot.turnRight();
+            }
+            robot.turnRight();
+        }
+    }
+};

From 7fd31275d452e144bb12014d6562a9240df25b63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Feb 2020 18:27:37 +0800
Subject: [PATCH 0328/3374] Update 489-robot-room-cleaner.js

---
 489-robot-room-cleaner.js | 51 +++++++++++++++++++++------------------
 1 file changed, 28 insertions(+), 23 deletions(-)

diff --git a/489-robot-room-cleaner.js b/489-robot-room-cleaner.js
index 94f96564..38c82566 100644
--- a/489-robot-room-cleaner.js
+++ b/489-robot-room-cleaner.js
@@ -16,10 +16,10 @@
  *     this.turnLeft = function() {
  *         ...
  *     };
- * 
+ *
  *     // Robot will stay in the same cell after calling turnLeft/turnRight.
  *     // Each turn will be 90 degrees.
- *     @return {void} 
+ *     @return {void}
  *     this.turnRight = function() {
  *         ...
  *     };
@@ -36,25 +36,30 @@
  * @return {void}
  */
 const cleanRoom = function(robot) {
-    const visited = new Set();
-    const shift = [[-1,0],[0,1],[1,0],[0,-1]];
-    dfs(0,0,0);
-    function dfs(r, c, dir) {
-        visited.add(r+','+c);
-        robot.clean();
-        for (let i = 0; i < 4; i++) {
-            const newDir = (dir + i) % 4;
-            const x = shift[newDir][0] + r;
-            const y = shift[newDir][1] + c;
-            if (!visited.has(x+','+y) && robot.move()) {
-                dfs(x, y, newDir);
-                robot.turnRight();
-                robot.turnRight();
-                robot.move();
-                robot.turnRight();
-                robot.turnRight();
-            }
-            robot.turnRight();
-        }
+  const visited = new Set()
+  const shift = [
+    [-1, 0],
+    [0, 1],
+    [1, 0],
+    [0, -1]
+  ]
+  dfs(0, 0, 0)
+  function dfs(r, c, dir) {
+    visited.add(r + ',' + c)
+    robot.clean()
+    for (let i = 0; i < 4; i++) {
+      const newDir = (dir + i) % 4
+      const x = shift[newDir][0] + r
+      const y = shift[newDir][1] + c
+      if (!visited.has(x + ',' + y) && robot.move()) {
+        dfs(x, y, newDir)
+        robot.turnRight()
+        robot.turnRight()
+        robot.move()
+        robot.turnRight()
+        robot.turnRight()
+      }
+      robot.turnRight()
     }
-};
+  }
+}

From e4a659217e48c334391b32e8185c690531be0aca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Feb 2020 15:20:39 +0800
Subject: [PATCH 0329/3374] Create 488-zuma-game.js

---
 488-zuma-game.js | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 488-zuma-game.js

diff --git a/488-zuma-game.js b/488-zuma-game.js
new file mode 100644
index 00000000..f394d12b
--- /dev/null
+++ b/488-zuma-game.js
@@ -0,0 +1,46 @@
+/**
+ * @param {string} board
+ * @param {string} hand
+ * @return {number}
+ */
+const findMinStep = function(board, hand) {
+  const map = {}
+  for (let c of hand) map[c] = (map[c] || 0) + 1
+  const res = helper(board, map)
+  return res === Number.MAX_VALUE ? -1 : res
+}
+
+function helper(s, m) {
+  const str = reduce(s)
+  if (str.length === 0) return 0
+  let res = Number.MAX_VALUE
+  let i = 0
+  while (i < str.length) {
+    const beg = i
+    while (i < str.length && str[i] === str[beg]) {
+      i++
+    }
+    if (m[str[beg]] >= 3 - (i - beg)) {
+      const dval = 3 - i + beg
+      m[str[beg]] -= dval
+      const tmp = helper(s.slice(0, beg) + s.slice(i), m)
+      m[str[beg]] += dval
+      if (tmp !== Number.MAX_VALUE) res = res < tmp + dval ? res : tmp + dval
+    }
+  }
+  return res
+}
+function reduce(str) {
+  let res = ''
+  let i = 0
+  while (i < str.length) {
+    const beg = i
+    while (i < str.length && str[beg] === str[i]) {
+      i++
+    }
+    if (i - beg >= 3) {
+      return reduce(str.slice(0, beg) + str.slice(i))
+    }
+  }
+  return str
+}

From 7b4edb6a6d52e322e5eb0b56589f09db32f947aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Feb 2020 15:22:07 +0800
Subject: [PATCH 0330/3374] Update 488-zuma-game.js

---
 488-zuma-game.js | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/488-zuma-game.js b/488-zuma-game.js
index f394d12b..9a0ca829 100644
--- a/488-zuma-game.js
+++ b/488-zuma-game.js
@@ -1,3 +1,46 @@
+/**
+
+Think about Zuma Game. You have a row of balls on the table, colored red(R), yellow(Y), blue(B), green(G), and white(W).
+You also have several balls in your hand.
+
+Each time, you may choose a ball in your hand, and insert it into the row (including the leftmost place and rightmost place).
+Then, if there is a group of 3 or more balls in the same color touching, remove these balls.
+Keep doing this until no more balls can be removed.
+
+Find the minimal balls you have to insert to remove all the balls on the table.
+If you cannot remove all the balls, output -1.
+
+Example 1:
+
+Input: board = "WRRBBW", hand = "RB"
+Output: -1
+Explanation: WRRBBW -> WRR[R]BBW -> WBBW -> WBB[B]W -> WW
+Example 2:
+
+Input: board = "WWRRBBWW", hand = "WRBRW"
+Output: 2
+Explanation: WWRRBBWW -> WWRR[R]BBWW -> WWBBWW -> WWBB[B]WW -> WWWW -> empty
+Example 3:
+
+Input: board = "G", hand = "GGGGG"
+Output: 2
+Explanation: G -> G[G] -> GG[G] -> empty 
+Example 4:
+
+Input: board = "RBYYBBRRB", hand = "YRBGB"
+Output: 3
+Explanation: RBYYBBRRB -> RBYY[Y]BBRRB -> RBBBRRB -> RRRB -> B -> B[B] -> BB[B] -> empty 
+ 
+
+Constraints:
+
+You may assume that the initial row of balls on the table won’t have any 3 or more consecutive balls with the same color.
+The number of balls on the table won't exceed 16, and the string represents these balls is called "board" in the input.
+The number of balls in your hand won't exceed 5, and the string represents these balls is called "hand" in the input.
+Both input strings will be non-empty and only contain characters 'R','Y','B','G','W'.
+
+*/
+
 /**
  * @param {string} board
  * @param {string} hand

From 061830d87429a237dc9033b33cfc97fb6564a992 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Feb 2020 11:04:40 +0800
Subject: [PATCH 0331/3374] Create 487-max-consecutive-ones-ii.js

---
 487-max-consecutive-ones-ii.js | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 487-max-consecutive-ones-ii.js

diff --git a/487-max-consecutive-ones-ii.js b/487-max-consecutive-ones-ii.js
new file mode 100644
index 00000000..e200962d
--- /dev/null
+++ b/487-max-consecutive-ones-ii.js
@@ -0,0 +1,35 @@
+/**
+
+Given a binary array, find the maximum number of consecutive 1s in this array if you can flip at most one 0.
+
+Example 1:
+Input: [1,0,1,1,0]
+Output: 4
+Explanation: Flip the first zero will get the the maximum number of consecutive 1s.
+    After flipping, the maximum number of consecutive 1s is 4.
+Note:
+
+The input array will only contain 0 and 1.
+The length of input array is a positive integer and will not exceed 10,000
+Follow up:
+What if the input numbers come in one by one as an infinite stream?
+In other words, you can't store all numbers coming from the stream as it's too large to hold in memory.
+Could you solve it efficiently?
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaxConsecutiveOnes = function(nums) {
+  let max = 0,
+    k = 1
+  const zeroIndex = []
+  for (let l = 0, h = 0; h < nums.length; h++) {
+    if (nums[h] === 0) zeroIndex.push(h)
+    if (zeroIndex.length > k) l = zeroIndex.shift() + 1
+    max = Math.max(max, h - l + 1)
+  }
+  return max
+}

From 46da269a5deff1ed499b6bdc2e9bba353e742c76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Feb 2020 18:12:53 +0800
Subject: [PATCH 0332/3374] Create 484-find-permutation.js

---
 484-find-permutation.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 484-find-permutation.js

diff --git a/484-find-permutation.js b/484-find-permutation.js
new file mode 100644
index 00000000..024f433f
--- /dev/null
+++ b/484-find-permutation.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number[]}
+ */
+const findPermutation = function(s) {
+  const n = s.length
+  const arr = Array.from({ length: n + 1 }, (el, idx) => idx + 1)
+  for(let h = 0; h < n; h++) {
+    if(s.charAt(h) === 'D') {
+      const l = h
+      while(h < n && s.charAt(h) === 'D') h++
+      reverse(arr, l, h)
+    }
+  }
+  return arr
+};
+
+function reverse(arr, l, h) {
+  while(l < h) {
+    arr[l] ^= arr[h]
+    arr[h] ^= arr[l]
+    arr[l] ^= arr[h]
+    l++, h--
+  }
+}

From f97a142f0090b915ab270738b97bff8ebf39e5a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Feb 2020 20:51:14 +0800
Subject: [PATCH 0333/3374] Create 483-smallest-good-base.js

---
 483-smallest-good-base.js | 44 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 483-smallest-good-base.js

diff --git a/483-smallest-good-base.js b/483-smallest-good-base.js
new file mode 100644
index 00000000..b47b275d
--- /dev/null
+++ b/483-smallest-good-base.js
@@ -0,0 +1,44 @@
+/**
+ * @param {string} n
+ * @return {string}
+ */
+const smallestGoodBase = function(n) {
+  const N = BigInt(n),
+    bigint2 = BigInt(2),
+    bigint1 = BigInt(1),
+    bigint0 = BigInt(0)
+  let maxLen = countLength(N, bigint2)
+  for (let length = maxLen; length > 0; length--) {
+    let [found, base] = findMatchInHalf(length)
+    if (found) return '' + base
+  }
+  return '' + (N - 1)
+  function findMatchInHalf(length, smaller = bigint2, bigger = N) {
+    if (smaller > bigger) return [false]
+    if (smaller === bigger) {
+      return [valueOf1s(smaller, length) === N, smaller]
+    }
+    let mid = (smaller + bigger) / bigint2
+    let val = valueOf1s(mid, length)
+    if (val === N) return [true, mid]
+    if (val > N) return findMatchInHalf(length, smaller, mid - bigint1)
+    return findMatchInHalf(length, mid + bigint1, bigger)
+  }
+  function valueOf1s(base, lengthOf1s) {
+    let t = bigint1
+    for (let i = 1; i < lengthOf1s; i++) {
+      t *= base
+      t += bigint1
+    }
+    return t
+  }
+  function countLength(N, base) {
+    let t = N,
+      len = 0
+    while (t > bigint0) {
+      t /= base
+      len++
+    }
+    return len
+  }
+}

From 4248f559f477b753487d53442e3eca7cf52cdd3b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Feb 2020 14:46:53 +0800
Subject: [PATCH 0334/3374] Create 482-license-key-formatting.js

---
 482-license-key-formatting.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 482-license-key-formatting.js

diff --git a/482-license-key-formatting.js b/482-license-key-formatting.js
new file mode 100644
index 00000000..45f818c1
--- /dev/null
+++ b/482-license-key-formatting.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} S
+ * @param {number} K
+ * @return {string}
+ */
+const licenseKeyFormatting = function(S, K) {
+  if (S == null || S === "") return "";
+  const newStr = S.replace(/-/g, "").toUpperCase();
+  const arr = newStr.split("");
+  for (let i = arr.length - 1 - K; i >= 0; i -= K) {
+    arr[i] = arr[i] + "-";
+  }
+  return arr.join("");
+};

From 8483600a8fcc2a3f891b92e7c8fa7e9d328d4f4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Feb 2020 17:00:09 +0800
Subject: [PATCH 0335/3374] Create 479-largest-palindrome-product.js

---
 479-largest-palindrome-product.js | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 479-largest-palindrome-product.js

diff --git a/479-largest-palindrome-product.js b/479-largest-palindrome-product.js
new file mode 100644
index 00000000..515ba62a
--- /dev/null
+++ b/479-largest-palindrome-product.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const largestPalindrome = function(n) {
+  if (n === 1) {
+    return 9
+  } else if (n === 8) {
+    return 475
+  }
+  let max = Math.pow(10, n)
+  let min = Math.pow(10, n - 1)
+  let ret = 0
+
+  for (let i = max - 1; i > 0; i--) {
+    ret = i * max + getReverse(i)
+    for (let factor = ~~Math.sqrt(ret); factor < max; factor++) {
+      if (ret % factor == 0 && ret / factor < max) {
+        return ret % 1337
+      }
+    }
+  }
+  return -1
+}
+
+function getReverse(n) {
+  let result = 0
+  let num = n
+  while (num > 0) {
+    result = result * 10 + (num % 10)
+    num = ~~(num / 10)
+  }
+  return result
+}

From 4bafcb260fa7430d6b976798a860cec3a64a2da4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Feb 2020 12:05:49 +0800
Subject: [PATCH 0336/3374] Create 478-generate-random-point-in-a-circle.js

---
 478-generate-random-point-in-a-circle.js | 27 ++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 478-generate-random-point-in-a-circle.js

diff --git a/478-generate-random-point-in-a-circle.js b/478-generate-random-point-in-a-circle.js
new file mode 100644
index 00000000..65b17eb4
--- /dev/null
+++ b/478-generate-random-point-in-a-circle.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} radius
+ * @param {number} x_center
+ * @param {number} y_center
+ */
+const Solution = function(radius, x_center, y_center) {
+  this.radius = radius
+  this.x_center = x_center
+  this.y_center = y_center
+}
+
+/**
+ * @return {number[]}
+ */
+Solution.prototype.randPoint = function() {
+  let len = Math.sqrt(Math.random()) * this.radius
+  let deg = Math.random() * 2 * Math.PI
+  let x = this.x_center + len * Math.cos(deg)
+  let y = this.y_center + len * Math.sin(deg)
+  return [x, y]
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(radius, x_center, y_center)
+ * var param_1 = obj.randPoint()
+ */

From 6f7edf7224eed9956e9a28823f9de21e6066cc11 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Feb 2020 21:48:07 +0800
Subject: [PATCH 0337/3374] Create 475-heaters.js

---
 475-heaters.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 475-heaters.js

diff --git a/475-heaters.js b/475-heaters.js
new file mode 100644
index 00000000..38e918ef
--- /dev/null
+++ b/475-heaters.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} houses
+ * @param {number[]} heaters
+ * @return {number}
+ */
+const findRadius = function(houses, heaters) {
+  heaters.sort((a, b) => a - b)
+  return Math.max(...houses.map(h => findMinDistance(h, heaters)))
+}
+
+const findMinDistance = (house, heaters) => {
+  let left = 0
+  let right = heaters.length - 1
+  while (left <= right) {
+    const mid = left + ((right - left) >> 1)
+    if (heaters[mid] <= house && house <= heaters[mid + 1]) {
+      return Math.min(house - heaters[mid], heaters[mid + 1] - house)
+    } else if (heaters[mid] <= house) {
+      left = mid + 1
+    } else {
+      right = mid - 1
+    }
+  }
+  if (left === 0) return heaters[0] - house
+  if (left === heaters.length) return house - heaters[heaters.length - 1]
+}

From 735822e28d4edab52972fc080fa22a5f6dfebc59 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Feb 2020 22:13:19 +0800
Subject: [PATCH 0338/3374] Update 475-heaters.js

---
 475-heaters.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/475-heaters.js b/475-heaters.js
index 38e918ef..5d069bf9 100644
--- a/475-heaters.js
+++ b/475-heaters.js
@@ -24,3 +24,28 @@ const findMinDistance = (house, heaters) => {
   if (left === 0) return heaters[0] - house
   if (left === heaters.length) return house - heaters[heaters.length - 1]
 }
+
+// another
+
+/**
+ * @param {number[]} houses
+ * @param {number[]} heaters
+ * @return {number}
+ */
+const findRadius = function(houses, heaters) {
+  let res = 0
+  let k = 0
+  houses = houses.sort((a, b) => a - b)
+  heaters = heaters.sort((a, b) => a - b)
+  for (let i = 0; i < houses.length; i++) {
+    const curr = houses[i]
+    while (
+      k < heaters.length &&
+      Math.abs(heaters[k + 1] - curr) <= Math.abs(heaters[k] - curr)
+    ) {
+      k++
+    }
+    res = Math.max(res, Math.abs(heaters[k] - curr))
+  }
+  return res
+}

From 64b50e43551b1a8e33fd71862676ed44c08b77ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Feb 2020 23:50:45 +0800
Subject: [PATCH 0339/3374] Update 475-heaters.js

---
 475-heaters.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/475-heaters.js b/475-heaters.js
index 5d069bf9..316c0f51 100644
--- a/475-heaters.js
+++ b/475-heaters.js
@@ -49,3 +49,22 @@ const findRadius = function(houses, heaters) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} houses
+ * @param {number[]} heaters
+ * @return {number}
+ */
+const findRadius = function(houses, heaters) {
+  heaters.sort((a, b) => a - b)
+  houses.sort((a, b) => a - b)
+  let res = 0, i = 0
+  for(let h of houses) {
+    while(i < heaters.length - 1 && heaters[i] + heaters[i + 1] <= h * 2) i++
+    res = Math.max(res, Math.abs(heaters[i] - h))
+  }
+  return res
+}
+

From e359dcd7ff3c39c87f2255f843dc627d7a0b34dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Mar 2020 13:06:44 +0800
Subject: [PATCH 0340/3374] Create 473-matchsticks-to-square.js

---
 473-matchsticks-to-square.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 473-matchsticks-to-square.js

diff --git a/473-matchsticks-to-square.js b/473-matchsticks-to-square.js
new file mode 100644
index 00000000..b2072a73
--- /dev/null
+++ b/473-matchsticks-to-square.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const makesquare = function(nums) {
+  if (nums.length == 0) return false
+  const edge = nums.reduce((accum, val) => accum + val) / 4
+  nums.sort((val1, val2) => val2 - val1)
+  if (edge !== Math.floor(edge)) return false
+  const findEdge = function(target) {
+    if (target <= 0) return target === 0
+    let newNums = []
+    while (nums.length) {
+      let item = nums.shift()
+      if (findEdge(target - item)) {
+        nums = newNums.concat(nums)
+        return true
+      }
+      newNums.push(item)
+    }
+    nums = newNums
+    return false
+  }
+  let count = 4
+  while (count) {
+    if (!findEdge(edge)) return false
+    count--
+  }
+  return true
+}

From cc326e24a49fff71ff2a03b669c4d0a48f84eebf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Mar 2020 13:24:22 +0800
Subject: [PATCH 0341/3374] Update 473-matchsticks-to-square.js

---
 473-matchsticks-to-square.js | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/473-matchsticks-to-square.js b/473-matchsticks-to-square.js
index b2072a73..ab12c477 100644
--- a/473-matchsticks-to-square.js
+++ b/473-matchsticks-to-square.js
@@ -1,3 +1,44 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const makesquare = function(nums) {
+  if (nums == null || nums.length < 4) return false
+  const sum = nums.reduce((ac, el) => ac + el, 0)
+  if (sum % 4 !== 0) return false
+  nums.sort((a, b) => a - b)
+  reverse(nums)
+  return dfs(nums, new Array(4).fill(0), 0, sum / 4)
+}
+
+function dfs(nums, arr, idx, target) {
+  if (idx === nums.length) {
+    return true
+  }
+  for (let i = 0; i < 4; i++) {
+    if (arr[i] + nums[idx] > target || (i > 0 && arr[i] === arr[i - 1]))
+      continue
+    arr[i] += nums[idx]
+    if (dfs(nums, arr, idx + 1, target)) return true
+    arr[i] -= nums[idx]
+  }
+  return false
+}
+
+function reverse(nums) {
+  let i = 0,
+    j = nums.length - 1
+  while (i < j) {
+    let temp = nums[i]
+    nums[i] = nums[j]
+    nums[j] = temp
+    i++
+    j--
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {boolean}
@@ -28,3 +69,4 @@ const makesquare = function(nums) {
   }
   return true
 }
+

From 55761228d4f8840df4e9c340dc60d6a084d577a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Mar 2020 13:54:46 +0800
Subject: [PATCH 0342/3374] Update 473-matchsticks-to-square.js

---
 473-matchsticks-to-square.js | 15 ++-------------
 1 file changed, 2 insertions(+), 13 deletions(-)

diff --git a/473-matchsticks-to-square.js b/473-matchsticks-to-square.js
index ab12c477..101edd1d 100644
--- a/473-matchsticks-to-square.js
+++ b/473-matchsticks-to-square.js
@@ -6,8 +6,7 @@ const makesquare = function(nums) {
   if (nums == null || nums.length < 4) return false
   const sum = nums.reduce((ac, el) => ac + el, 0)
   if (sum % 4 !== 0) return false
-  nums.sort((a, b) => a - b)
-  reverse(nums)
+  nums.sort((a, b) => b - a)
   return dfs(nums, new Array(4).fill(0), 0, sum / 4)
 }
 
@@ -25,17 +24,7 @@ function dfs(nums, arr, idx, target) {
   return false
 }
 
-function reverse(nums) {
-  let i = 0,
-    j = nums.length - 1
-  while (i < j) {
-    let temp = nums[i]
-    nums[i] = nums[j]
-    nums[j] = temp
-    i++
-    j--
-  }
-}
+
 
 // another
 

From aaf2da799e877521b0faf160f09e50584d517203 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Mar 2020 15:17:49 +0800
Subject: [PATCH 0343/3374] Create 471-encode-string-with-shortest-length.js

---
 471-encode-string-with-shortest-length.js | 36 +++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 471-encode-string-with-shortest-length.js

diff --git a/471-encode-string-with-shortest-length.js b/471-encode-string-with-shortest-length.js
new file mode 100644
index 00000000..1c296b8d
--- /dev/null
+++ b/471-encode-string-with-shortest-length.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const encode = function(s) {
+  let N = s.length
+  let dp = Array(N)
+    .fill(0)
+    .map(() => Array(N))
+  for (let len = 1; len <= N; len++) {
+    for (let i = 0; i <= N - len; i++) {
+      let j = i + len - 1
+      dp[i][j] = s.slice(i, j + 1)
+      if (len > 4) {
+        for (let m = i; m < j; m++) {
+          if (dp[i][j].length > dp[i][m].length + dp[m + 1][j].length) {
+            dp[i][j] = dp[i][m] + dp[m + 1][j]
+          }
+        }
+        let substr = s.slice(i, j + 1)
+        for (let k = 1; k <= Math.floor(len / 2); k++) {
+          if (len % k === 0) {
+            let first = s.slice(i, i + k)
+            if (substr.split(first).join('') === '') {
+              let newStr = len / k + '[' + dp[i][i + k - 1] + ']'
+              if (newStr.length < dp[i][j].length) {
+                dp[i][j] = newStr
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return dp[0][N - 1]
+}

From 7f39f07f5684ac429ffd6d3514cdce4d99f12360 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Mar 2020 20:06:41 +0800
Subject: [PATCH 0344/3374] Create 470-implement-rand10-using-rand7.js

---
 470-implement-rand10-using-rand7.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 470-implement-rand10-using-rand7.js

diff --git a/470-implement-rand10-using-rand7.js b/470-implement-rand10-using-rand7.js
new file mode 100644
index 00000000..9ea03193
--- /dev/null
+++ b/470-implement-rand10-using-rand7.js
@@ -0,0 +1,12 @@
+/**
+ * The rand7() API is already defined for you.
+ * var rand7 = function() {}
+ * @return {number} a random integer in the range 1 to 7
+ */
+const rand10 = function() {
+  let result = 40
+  while (result >= 40) {
+    result = 7 * (rand7() - 1) + (rand7() - 1)
+  }
+  return (result % 10) + 1
+}

From 429b703673d27a3d2e09d423ffa5bc3cf108919c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Mar 2020 10:01:12 +0800
Subject: [PATCH 0345/3374] Create 469-convex-polygon.js

---
 469-convex-polygon.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 469-convex-polygon.js

diff --git a/469-convex-polygon.js b/469-convex-polygon.js
new file mode 100644
index 00000000..bf2741be
--- /dev/null
+++ b/469-convex-polygon.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} points
+ * @return {boolean}
+ */
+const isConvex = function(points) {
+  let negative = false
+  let positive = false
+  const num = points.length
+  for (let p1 = 0; p1 < num; p1 += 1) {
+    const p2 = (p1 + 1) % num
+    const p3 = (p2 + 1) % num
+    const [Ax, Ay] = points[p1]
+    const [Bx, By] = points[p2]
+    const [Cx, Cy] = points[p3]
+    const crossProduct = CrossProductLength(Ax, Ay, Bx, By, Cx, Cy)
+    if (crossProduct < 0) {
+      negative = true
+    } else if (crossProduct > 0) {
+      positive = true
+    }
+    if (negative && positive) return false
+  }
+  return true
+}
+
+function CrossProductLength(Ax, Ay, Bx, By, Cx, Cy) {
+  const BAx = Ax - Bx
+  const BAy = Ay - By
+  const BCx = Cx - Bx
+  const BCy = Cy - By
+  return BAx * BCy - BAy * BCx
+}

From ec7b50d012e5781edf9112cf305f8662d3a75e73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Mar 2020 12:23:36 +0800
Subject: [PATCH 0346/3374] Create 468-validate-ip-address.js

---
 468-validate-ip-address.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 468-validate-ip-address.js

diff --git a/468-validate-ip-address.js b/468-validate-ip-address.js
new file mode 100644
index 00000000..85653595
--- /dev/null
+++ b/468-validate-ip-address.js
@@ -0,0 +1,9 @@
+/**
+ * @param {string} IP
+ * @return {string}
+ */
+const validIPAddress = function(IP) {
+  const ipv4 = /^((\d|[1-9]\d|1\d\d|2([0-4]\d|5[0-5]))\.){4}$/
+  const ipv6 = /^([\da-f]{1,4}:){8}$/i
+  return ipv4.test(IP + '.') ? 'IPv4' : ipv6.test(IP + ':') ? 'IPv6' : 'Neither'
+}

From e8aa5b1dbfd0e792085506e40d56c22fbaf09a76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Mar 2020 12:42:44 +0800
Subject: [PATCH 0347/3374] Update 468-validate-ip-address.js

---
 468-validate-ip-address.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/468-validate-ip-address.js b/468-validate-ip-address.js
index 85653595..66233a9b 100644
--- a/468-validate-ip-address.js
+++ b/468-validate-ip-address.js
@@ -7,3 +7,38 @@ const validIPAddress = function(IP) {
   const ipv6 = /^([\da-f]{1,4}:){8}$/i
   return ipv4.test(IP + '.') ? 'IPv4' : ipv6.test(IP + ':') ? 'IPv6' : 'Neither'
 }
+
+// another
+
+/**
+ * @param {string} IP
+ * @return {string}
+ */
+const validIPAddress = function(IP) {
+  if (IP.indexOf('.') != -1) {
+    const arr = IP.split('.')
+    if (arr.length !== 4) return 'Neither'
+    for (let i = 0; i < arr.length; i++) {
+      const numVal = parseInt(arr[i])
+      if (
+        numVal < 0 ||
+        numVal >= 256 ||
+        arr[i].length !== ('' + numVal).length
+      ) {
+        return 'Neither'
+      }
+    }
+    return 'IPv4'
+  } else if (IP.indexOf(':') != -1) {
+    const arr = IP.split(':')
+    if (arr.length !== 8) return 'Neither'
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i].length > 4 || arr[i].length === 0) return 'Neither'
+      const re = /[^0-9A-F]/i
+      if (re.test(arr[i])) return 'Neither'
+    }
+    return 'IPv6'
+  } else {
+    return 'Neither'
+  }
+}

From cdb17df691b42a28fd98fd1c4752775adf600629 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Mar 2020 10:50:08 +0800
Subject: [PATCH 0348/3374] Create 465-optimal-account-balancing.js

---
 465-optimal-account-balancing.js | 81 ++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 465-optimal-account-balancing.js

diff --git a/465-optimal-account-balancing.js b/465-optimal-account-balancing.js
new file mode 100644
index 00000000..c3d21412
--- /dev/null
+++ b/465-optimal-account-balancing.js
@@ -0,0 +1,81 @@
+/**
+
+A group of friends went on holiday and sometimes lent each other money.
+For example, Alice paid for Bill's lunch for $10.
+Then later Chris gave Alice $5 for a taxi ride.
+We can model each transaction as a tuple (x, y, z) which means person x gave person y $z.
+Assuming Alice, Bill, and Chris are person 0, 1, and 2 respectively (0, 1, 2 are the person's ID),
+the transactions can be represented as [[0, 1, 10], [2, 0, 5]].
+
+Given a list of transactions between a group of people,
+return the minimum number of transactions required to settle the debt.
+
+Note:
+
+A transaction will be given as a tuple (x, y, z). Note that x ≠ y and z > 0.
+Person's IDs may not be linear, e.g. we could have the persons 0, 1, 2 or we could also have the persons 0, 2, 6.
+Example 1:
+
+Input:
+[[0,1,10], [2,0,5]]
+
+Output:
+2
+
+Explanation:
+Person #0 gave person #1 $10.
+Person #2 gave person #0 $5.
+
+Two transactions are needed. One way to settle the debt is person #1 pays person #0 and #2 $5 each.
+Example 2:
+
+Input:
+[[0,1,10], [1,0,1], [1,2,5], [2,0,5]]
+
+Output:
+1
+
+Explanation:
+Person #0 gave person #1 $10.
+Person #1 gave person #0 $1.
+Person #1 gave person #2 $5.
+Person #2 gave person #0 $5.
+
+Therefore, person #1 only need to give person #0 $4, and all debt is settled.
+
+*/
+
+/**
+ * @param {number[][]} transactions
+ * @return {number}
+ */
+const minTransfers = function(transactions) {
+  if (transactions.length === 0) return 0;
+  const map = new Map();
+  for (let [a, b, m] of transactions) {
+    if (!map.has(a)) map.set(a, 0);
+    if (!map.has(b)) map.set(b, 0);
+    map.set(a, map.get(a) - m);
+    map.set(b, map.get(b) + m);
+  }
+  const debts = [...map.values()].filter(debt => debt !== 0);
+  const len = debts.length;
+  const dfs = (id, d) => {
+    if (id >= d.length) return 0;
+    const cur = d[id];
+    if (cur === 0) return dfs(id + 1, d);
+
+    let res = Infinity;
+    for (let i = id + 1; i < len; i++) {
+      const next = d[i];
+      if (cur * next < 0) {
+        d[i] = cur + next;
+        res = Math.min(res, 1 + dfs(id + 1, d));
+        d[i] = next;
+        if (next + cur === 0) break;
+      }
+    }
+    return res;
+  };
+  return dfs(0, debts);
+};

From e4b41afcc7c0c88524024484615e0b254b11d66e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Mar 2020 09:18:39 +0800
Subject: [PATCH 0349/3374] Create 464-can-i-win.js

---
 464-can-i-win.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 464-can-i-win.js

diff --git a/464-can-i-win.js b/464-can-i-win.js
new file mode 100644
index 00000000..35423537
--- /dev/null
+++ b/464-can-i-win.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} maxChoosableInteger
+ * @param {number} desiredTotal
+ * @return {boolean}
+ */
+const canIWin = function(maxChoosableInteger, desiredTotal) {
+  if (desiredTotal <= 0) return true
+  if ((maxChoosableInteger * (1 + maxChoosableInteger)) / 2 < desiredTotal)
+    return false
+  const dp = new Array(1 << maxChoosableInteger).fill(0)
+  return dfs(dp, 0, maxChoosableInteger, desiredTotal)
+
+  function dfs(dp, chs, max, target) {
+    if (target <= 0) return false
+    if (dp[chs] != 0) return dp[chs] === 1
+    let win = false
+    for (let i = 0; i < max; i++) {
+      if ((chs & (1 << i)) === 0) {
+        //not used
+        win = win || !dfs(dp, chs ^ (1 << i), max, target - i - 1)
+      }
+    }
+    dp[chs] = win ? 1 : -1
+    return win
+  }
+}

From 00aa09237d80c5d95980801cfcf7713c0c162da9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Mar 2020 11:14:56 +0800
Subject: [PATCH 0350/3374] Create 458-poor-pigs.js

---
 458-poor-pigs.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 458-poor-pigs.js

diff --git a/458-poor-pigs.js b/458-poor-pigs.js
new file mode 100644
index 00000000..da075dcc
--- /dev/null
+++ b/458-poor-pigs.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} buckets
+ * @param {number} minutesToDie
+ * @param {number} minutesToTest
+ * @return {number}
+ */
+const poorPigs = function(buckets, minutesToDie, minutesToTest) {
+  const index = Math.ceil(minutesToTest / minutesToDie) + 1
+  return Math.ceil(Math.log(buckets) / Math.log(index))
+}
+
+// another
+
+/**
+ * @param {number} buckets
+ * @param {number} minutesToDie
+ * @param {number} minutesToTest
+ * @return {number}
+ */
+const poorPigs = function(buckets, minutesToDie, minutesToTest) {
+  let pigs = 0
+  while ((minutesToTest / minutesToDie + 1) ** pigs < buckets) {
+    pigs++
+  }
+  return pigs
+}

From bc4068d1c626cb70b0b1a3431d449f75698b6afc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Mar 2020 17:46:06 +0800
Subject: [PATCH 0351/3374] Create 456-132-pattern.js

---
 456-132-pattern.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 456-132-pattern.js

diff --git a/456-132-pattern.js b/456-132-pattern.js
new file mode 100644
index 00000000..97c07738
--- /dev/null
+++ b/456-132-pattern.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const find132pattern = function(nums) {
+  let [stack, s3] = [[], -Infinity]
+  for (let i = nums.length - 1; i >= 0; i--) {
+    if (nums[i] < s3) {
+      return true
+    }
+    while (stack[stack.length - 1] < nums[i]) {
+      s3 = stack.pop()
+    }
+    stack.push(nums[i])
+  }
+  return false
+}

From b9ed12fcfe5819606b9450c286c697fbfc562825 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Mar 2020 11:17:41 +0800
Subject: [PATCH 0352/3374] Update 456-132-pattern.js

---
 456-132-pattern.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/456-132-pattern.js b/456-132-pattern.js
index 97c07738..e584d194 100644
--- a/456-132-pattern.js
+++ b/456-132-pattern.js
@@ -15,3 +15,23 @@ const find132pattern = function(nums) {
   }
   return false
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const find132pattern = function(nums) {
+  let idx = nums.length
+  let s3 = Number.NEGATIVE_INFINITY
+  for(let len = nums.length, i = len - 1; i >= 0; i--) {
+    if(nums[i] < s3) return true
+    while(idx < nums.length && nums[i] > nums[idx]) {
+      s3 = nums[idx++]
+    }
+    nums[--idx] = nums[i] 
+  }
+  return false
+}
+

From c92abcce3c217278cbaa628a823d6729d4b8fe0a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Mar 2020 14:02:30 +0800
Subject: [PATCH 0353/3374] Create 447-number-of-boomerangs.js

---
 447-number-of-boomerangs.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 447-number-of-boomerangs.js

diff --git a/447-number-of-boomerangs.js b/447-number-of-boomerangs.js
new file mode 100644
index 00000000..84f9081c
--- /dev/null
+++ b/447-number-of-boomerangs.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const numberOfBoomerangs = function(points) {
+  const m = new Map()
+  const len = points.length
+  let res = 0
+  for(let i = 0; i < len; i++) {
+    for(let j = 0; j < len; j++) {
+      if(i === j) continue
+      const d = dis(points[i], points[j])
+      if(!m.has(d)) m.set(d, 0)
+      m.set(d, m.get(d) + 1)
+    }
+    for(let v of m.values()) {
+      res += v * (v - 1)
+    }
+    m.clear()
+  }
+  return res
+};
+
+function dis(a, b) {
+  return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
+}

From 35a1ed6c0b7970c2a93afff726116a510f9e8766 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Mar 2020 15:40:36 +0800
Subject: [PATCH 0354/3374] Create 446-arithmetic-slices-ii-subsequence.js

---
 446-arithmetic-slices-ii-subsequence.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 446-arithmetic-slices-ii-subsequence.js

diff --git a/446-arithmetic-slices-ii-subsequence.js b/446-arithmetic-slices-ii-subsequence.js
new file mode 100644
index 00000000..0eec4146
--- /dev/null
+++ b/446-arithmetic-slices-ii-subsequence.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+const numberOfArithmeticSlices = function(A) {
+  if (!A || A.length < 3) return 0;
+  let res = 0;
+  const dp = Array(A.length);
+  for (let i = 0; i < A.length; i++) {
+    dp[i] = new Map();
+    for (let j = 0; j < i; j++) {
+      const diff = A[i] - A[j];
+      const prevCount = dp[j].get(diff) || 0;
+      res += prevCount;
+      const currCount = (dp[i].get(diff) || 0) + 1;
+      dp[i].set(diff, prevCount + currCount);
+    }
+  }
+  return res;
+};

From 9186686ec7bf6dcf078453bb276f2546f7e39ad0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Mar 2020 12:39:12 +0800
Subject: [PATCH 0355/3374] Create 444-sequence-reconstruction.js

---
 444-sequence-reconstruction.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 444-sequence-reconstruction.js

diff --git a/444-sequence-reconstruction.js b/444-sequence-reconstruction.js
new file mode 100644
index 00000000..aaac00cf
--- /dev/null
+++ b/444-sequence-reconstruction.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} org
+ * @param {number[][]} seqs
+ * @return {boolean}
+ */
+const sequenceReconstruction = function(org, seqs) {
+  const pairs = {}
+  const idxs = {}
+  for (let i = 0; i < org.length; i++) idxs[org[i]] = i
+  for (let j = 0; j < seqs.length; j++) {
+    const s = seqs[j]
+    for (let i = 0; i < s.length; i++) {
+      if (idxs[s[i]] == null) return false
+      if (i > 0 && idxs[s[i - 1]] >= idxs[s[i]]) return false
+      pairs[`${s[i - 1]}_${s[i]}`] = 1
+    }
+  }
+
+  for (let i = 0; i < org.length; i++)
+    if (pairs[`${org[i - 1]}_${org[i]}`] == null) return false
+
+  return true
+}

From 2a2f0e48fefbac1b33cf057ce3f3903fb12eb7be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Mar 2020 13:35:48 +0800
Subject: [PATCH 0356/3374] Update 444-sequence-reconstruction.js

---
 444-sequence-reconstruction.js | 42 ++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/444-sequence-reconstruction.js b/444-sequence-reconstruction.js
index aaac00cf..d8fde009 100644
--- a/444-sequence-reconstruction.js
+++ b/444-sequence-reconstruction.js
@@ -21,3 +21,45 @@ const sequenceReconstruction = function(org, seqs) {
 
   return true
 }
+
+// another
+
+/**
+ * @param {number[]} org
+ * @param {number[][]} seqs
+ * @return {boolean}
+ */
+const sequenceReconstruction = function(org, seqs) {
+  const graph = new Map()
+  const indegree = new Map()
+  seqs.forEach(seq => {
+    for (let i = 0; i < seq.length; i++) {
+      if (!graph.has(seq[i])) graph.set(seq[i], [])
+      if (!indegree.has(seq[i])) indegree.set(seq[i], 0)
+      if (i > 0) {
+        graph.get(seq[i - 1]).push(seq[i])
+        indegree.set(seq[i], indegree.get(seq[i]) + 1)
+      }
+    }
+  })
+  if (org.length !== graph.size) return false
+  const array = []
+  for (let [key, val] of indegree.entries()) {
+    if (val === 0) array.push(key)
+  }
+  let index = 0
+  while (array.length > 0) {
+    if (array.length > 1) return false
+    const current = array.shift()
+    if (org[index] !== current) {
+      return false
+    }
+    index++
+    graph.get(current).forEach(next => {
+      indegree.set(next, indegree.get(next) - 1)
+      if (indegree.get(next) === 0) array.push(next)
+    })
+  }
+  return index === org.length
+}
+

From 056c7fcc6b8a739b845777691f35de9d2b35c8fa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Mar 2020 21:35:45 +0800
Subject: [PATCH 0357/3374] Create 439-ternary-expression-parser.js

---
 439-ternary-expression-parser.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 439-ternary-expression-parser.js

diff --git a/439-ternary-expression-parser.js b/439-ternary-expression-parser.js
new file mode 100644
index 00000000..e19fa880
--- /dev/null
+++ b/439-ternary-expression-parser.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} expression
+ * @return {string}
+ */
+const parseTernary = function(expression) {
+  const N = expression.length
+  const stack = [expression[N - 1]]
+  for (let i = N - 2; i >= 0; i -= 2) {
+    if (expression[i] === ':') {
+      stack.push(expression[i - 1])
+    } else {
+      const l = stack.pop()
+      const r = stack.pop()
+      if (expression[i - 1] === 'T') {
+        stack.push(l)
+      } else {
+        stack.push(r)
+      }
+    }
+  }
+  return stack[0]
+}

From dad2060163e99e640bd802ca8d545c7e88b4b506 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Mar 2020 21:45:41 +0800
Subject: [PATCH 0358/3374] Create 436-find-right-interval.js

---
 436-find-right-interval.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 436-find-right-interval.js

diff --git a/436-find-right-interval.js b/436-find-right-interval.js
new file mode 100644
index 00000000..913ab727
--- /dev/null
+++ b/436-find-right-interval.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[]}
+ */
+const findRightInterval = function(intervals) {
+  const len = intervals.length
+  if (len === 0) return []
+  if (len === 1) return [-1]
+  intervals = intervals
+    .map((item, idx) => {
+      item.idx = idx
+      return item
+    })
+    .sort((a, b) => a.start - b.start)
+  const results = []
+  for (const item of intervals) {
+    results[item.idx] = binarySearch(item, intervals)
+  }
+  return results
+}
+
+function binarySearch(target, intervals) {
+  let left = 0
+  let right = intervals.length - 1
+  let solution = -1
+  while (left <= right) {
+    const mid = ((left + right) / 2) | 0
+    if (target.end > intervals[mid].start) {
+      left = mid + 1
+    } else {
+      solution = intervals[mid].idx
+      right = mid - 1
+    }
+  }
+  return solution
+}

From 551157c33f880a4f36ecd092f39eff8d23e5f68d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Mar 2020 21:52:04 +0800
Subject: [PATCH 0359/3374] Update 436-find-right-interval.js

---
 436-find-right-interval.js | 47 ++++++++++++++++----------------------
 1 file changed, 20 insertions(+), 27 deletions(-)

diff --git a/436-find-right-interval.js b/436-find-right-interval.js
index 913ab727..6d1c3031 100644
--- a/436-find-right-interval.js
+++ b/436-find-right-interval.js
@@ -3,34 +3,27 @@
  * @return {number[]}
  */
 const findRightInterval = function(intervals) {
-  const len = intervals.length
-  if (len === 0) return []
-  if (len === 1) return [-1]
-  intervals = intervals
-    .map((item, idx) => {
-      item.idx = idx
-      return item
-    })
-    .sort((a, b) => a.start - b.start)
-  const results = []
-  for (const item of intervals) {
-    results[item.idx] = binarySearch(item, intervals)
-  }
-  return results
-}
-
-function binarySearch(target, intervals) {
-  let left = 0
-  let right = intervals.length - 1
-  let solution = -1
-  while (left <= right) {
-    const mid = ((left + right) / 2) | 0
-    if (target.end > intervals[mid].start) {
-      left = mid + 1
+  const res = []
+  const arrary = intervals
+    .map((interval, idx) => ({ interval, idx }))
+    .sort((obj1, obj2) => obj1.interval[0] - obj2.interval[0])
+  for (let interval of intervals) {
+    const val = interval[interval.length - 1]
+    let left = 0,
+      right = intervals.length
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2)
+      if (arrary[mid].interval[0] >= val) {
+        right = mid
+      } else {
+        left = mid + 1
+      }
+    }
+    if (left >= intervals.length) {
+      res.push(-1)
     } else {
-      solution = intervals[mid].idx
-      right = mid - 1
+      res.push(arrary[left].idx)
     }
   }
-  return solution
+  return res
 }

From 849de3c838c162224d7b5b745e688ada6eb09d34 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Mar 2020 16:10:16 +0800
Subject: [PATCH 0360/3374] Create 433-minimum-genetic-mutation.js

---
 433-minimum-genetic-mutation.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 433-minimum-genetic-mutation.js

diff --git a/433-minimum-genetic-mutation.js b/433-minimum-genetic-mutation.js
new file mode 100644
index 00000000..07d3b73b
--- /dev/null
+++ b/433-minimum-genetic-mutation.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} start
+ * @param {string} end
+ * @param {string[]} bank
+ * @return {number}
+ */
+const minMutation = function(start, end, bank) {
+  const bankSet = new Set(bank)
+  if (!bankSet.has(end)) return -1
+  const queue = [[start, 0]]
+  const dna = ['A', 'C', 'G', 'T']
+  while (queue.length) {
+    let [node, count] = queue.shift()
+    if (node === end) return count
+    for (let i = 0; i < node.length; i++) {
+      for (let j = 0; j < dna.length; j++) {
+        const d = node.slice(0, i) + dna[j] + node.slice(i + 1)
+        if (bankSet.has(d)) {
+          queue.push([d, count + 1])
+          bankSet.delete(d)
+        }
+      }
+    }
+  }
+  return -1
+}

From 91fb545a93362cd0d157dae6769fd5ab511c6bd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Mar 2020 20:35:55 +0800
Subject: [PATCH 0361/3374] Update 433-minimum-genetic-mutation.js

---
 433-minimum-genetic-mutation.js | 35 +++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/433-minimum-genetic-mutation.js b/433-minimum-genetic-mutation.js
index 07d3b73b..8c5ab37c 100644
--- a/433-minimum-genetic-mutation.js
+++ b/433-minimum-genetic-mutation.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string} start
+ * @param {string} end
+ * @param {string[]} bank
+ * @return {number}
+ */
+const minMutation = function(start, end, bank) {
+  const obj = { res: Number.MAX_VALUE }
+  dfs(start, end, bank, 0, obj, new Set())
+  return obj.res === Number.MAX_VALUE ? -1 : obj.res
+}
+
+function dfs(s, e, bank, num, obj, visited) {
+  if(s === e) {
+    obj.res = Math.min(obj.res, num)
+    return
+  }
+  for(let el of bank) {
+    let diff = 0
+    for(let i = 0, len = s.length; i < len; i++) {
+      if(s[i] !== el[i]) {
+        diff++
+        if(diff > 1) break
+      }
+    }
+    if(diff === 1 && !visited.has(el)) {
+      visited.add(el)
+      dfs(el, e, bank, num + 1, obj, visited)
+      visited.delete(el)
+    }
+  }
+} 
+
+// another
+
 /**
  * @param {string} start
  * @param {string} end

From 8a1025dcd37aca378e06276787bfeaea544cb801 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Mar 2020 22:04:18 +0800
Subject: [PATCH 0362/3374] Create 431-encode-n-ary-tree-to-binary-tree.js

---
 431-encode-n-ary-tree-to-binary-tree.js | 58 +++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 431-encode-n-ary-tree-to-binary-tree.js

diff --git a/431-encode-n-ary-tree-to-binary-tree.js b/431-encode-n-ary-tree-to-binary-tree.js
new file mode 100644
index 00000000..85de1f54
--- /dev/null
+++ b/431-encode-n-ary-tree-to-binary-tree.js
@@ -0,0 +1,58 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+class Codec {
+  constructor() {}
+
+  /**
+   * @param {Node} root
+   * @return {TreeNode}
+   */
+  // Encodes an n-ary tree to a binary tree.
+  encode = function(root) {
+    if (root == null) return null
+    let result = new TreeNode(root.val)
+    if (root.children.length > 0) {
+      result.left = this.encode(root.children[0])
+    }
+    let cur = result.left
+    for (let i = 1; i < root.children.length; i++) {
+      cur.right = this.encode(root.children[i])
+      cur = cur.right
+    }
+    return result
+  }
+
+  /**
+   * @param {TreeNode} root
+   * @return {Node}
+   */
+  // Decodes your binary tree to an n-ary tree.
+  decode = function(root) {
+    if (root == null) return null
+    let result = new Node(root.val, [])
+    let cur = root.left
+    while (cur != null) {
+      result.children.push(this.decode(cur))
+      cur = cur.right
+    }
+    return result
+  }
+}
+/*
+ * Your Codec object will be instantiated and called as such:
+ * codec = Codec()
+ * codec.decode(codec.encode(root))
+ */

From 29bdc98669e9a8707184e1d4a2d904d2e54e354b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Mar 2020 14:41:39 +0800
Subject: [PATCH 0363/3374] Create 428-serialize-and-deserialize-n-ary-tree.js

---
 428-serialize-and-deserialize-n-ary-tree.js | 60 +++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 428-serialize-and-deserialize-n-ary-tree.js

diff --git a/428-serialize-and-deserialize-n-ary-tree.js b/428-serialize-and-deserialize-n-ary-tree.js
new file mode 100644
index 00000000..b85a6db2
--- /dev/null
+++ b/428-serialize-and-deserialize-n-ary-tree.js
@@ -0,0 +1,60 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+
+class Codec {
+  constructor() {}
+  /**
+   * @param {Node} root
+   * @return {string}
+   */
+  // Encodes a tree to a single string.
+  serialize = function(root) {
+    if (root === null) return ''
+    let str = ''
+    function dfs(node) {
+      str += node.val + ',' + node.children.length + ','
+      for (let child of node.children) dfs(child)
+    }
+    dfs(root)
+    return str
+  }
+  /**
+   * @param {string} data
+   * @return {Node}
+   */
+  // Decodes your encoded data to tree.
+  deserialize = function(data) {
+    if (data === '') return null
+    let idx = 0
+    function input() {
+      let j = data.indexOf(',', idx)
+      let n = Number(data.slice(idx, j))
+      idx = j + 1
+      return n
+    }
+    function dfs() {
+      let val = input(),
+        len = input()
+      let node = new Node(val, [])
+      while (len-- > 0) node.children.push(dfs())
+      return node
+    }
+    return dfs()
+  }
+}
+// Your Codec object will be instantiated and called as such:
+// Codec codec = new Codec();
+// codec.deserialize(codec.serialize(root));
+
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */

From 69bd6b2c34d0d3f5b2fd39190cb15dfa52444a41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Mar 2020 15:19:00 +0800
Subject: [PATCH 0364/3374] Update 428-serialize-and-deserialize-n-ary-tree.js

---
 428-serialize-and-deserialize-n-ary-tree.js | 64 +++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/428-serialize-and-deserialize-n-ary-tree.js b/428-serialize-and-deserialize-n-ary-tree.js
index b85a6db2..edd89f55 100644
--- a/428-serialize-and-deserialize-n-ary-tree.js
+++ b/428-serialize-and-deserialize-n-ary-tree.js
@@ -58,3 +58,67 @@ class Codec {
  *    this.children = children;
  * };
  */
+
+// another
+
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+
+class Codec {
+  constructor() {}
+  /**
+   * @param {Node} root
+   * @return {string}
+   */
+  // Encodes a tree to a single string.
+  serialize = function(root) {
+    const ans = []
+    const stack = root ? [root] : []
+    while (stack.length) {
+      const cur = stack.pop()
+      ans.push(cur.val, cur.children.length)
+      for (let i = cur.children.length - 1; i >= 0; i--) {
+        stack.push(cur.children[i])
+      }
+    }
+    return ans.join(',')
+  }
+  /**
+   * @param {string} data
+   * @return {Node}
+   */
+  // Decodes your encoded data to tree.
+  deserialize = function(data) {
+    if (!data) return null
+    const arr = data.split(',')
+    const helper = (index = 0, parent) => {
+      const node = new Node(arr[index++], [])
+      parent.children.push(node)
+      let childCount = arr[index++]
+      while (childCount--) {
+        index = helper(index, node)
+      }
+      return index
+    }
+    const fakeRoot = new Node(null, [])
+    helper(0, fakeRoot)
+    return fakeRoot.children[0]
+  }
+}
+// Your Codec object will be instantiated and called as such:
+// Codec codec = new Codec();
+// codec.deserialize(codec.serialize(root));
+
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val;
+ *    this.children = children;
+ * };
+ */
+

From 10e1b07dde43d89749e1aaf7c9996ce22dc08f07 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Mar 2020 22:43:55 +0800
Subject: [PATCH 0365/3374] Create 425-word-squares.js

---
 425-word-squares.js | 47 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 425-word-squares.js

diff --git a/425-word-squares.js b/425-word-squares.js
new file mode 100644
index 00000000..798bee6d
--- /dev/null
+++ b/425-word-squares.js
@@ -0,0 +1,47 @@
+/**
+ * @param {string[]} words
+ * @return {string[][]}
+ */
+const wordSquares = function(words) {
+  const length = words[0].length
+  const createPrefixMap = function(words) {
+    const result = new Map()
+    for (let word of words) {
+      for (let i = 0; i < word.length - 1; ++i) {
+        const prefix = word.substr(0, i + 1)
+        const array = result.get(prefix)
+        if (array) {
+          array.push(word)
+        } else {
+          result.set(prefix, [word])
+        }
+      }
+    }
+    return result
+  }
+  const backtracking = function(step, result, martix, wordsList) {
+    if (step === length) {
+      result.push([...martix])
+      return
+    }
+    const visited = []
+    for (let word of wordsList) {
+      if (visited.indexOf(word) == -1) {
+        martix.push(word)
+        let prefix = ''
+        for (let i = 0; i < step + 1; ++i) {
+          prefix += martix[i][step + 1]
+        }
+        let newLists = dictMap.get(prefix)
+        newLists = newLists ? newLists : []
+        backtracking(step + 1, result, martix, newLists)
+        martix.pop()
+        visited.push(word)
+      }
+    }
+  }
+  const result = []
+  const dictMap = createPrefixMap(words)
+  backtracking(0, result, [], words)
+  return result
+}

From 49ba389f4401abc8697e2a6da0544fcf14144e1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Mar 2020 22:59:38 +0800
Subject: [PATCH 0366/3374] Update 425-word-squares.js

---
 425-word-squares.js | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/425-word-squares.js b/425-word-squares.js
index 798bee6d..fcebef6e 100644
--- a/425-word-squares.js
+++ b/425-word-squares.js
@@ -8,7 +8,7 @@ const wordSquares = function(words) {
     const result = new Map()
     for (let word of words) {
       for (let i = 0; i < word.length - 1; ++i) {
-        const prefix = word.substr(0, i + 1)
+        const prefix = word.slice(0, i + 1)
         const array = result.get(prefix)
         if (array) {
           array.push(word)
@@ -24,20 +24,16 @@ const wordSquares = function(words) {
       result.push([...martix])
       return
     }
-    const visited = []
     for (let word of wordsList) {
-      if (visited.indexOf(word) == -1) {
-        martix.push(word)
-        let prefix = ''
-        for (let i = 0; i < step + 1; ++i) {
-          prefix += martix[i][step + 1]
-        }
-        let newLists = dictMap.get(prefix)
-        newLists = newLists ? newLists : []
-        backtracking(step + 1, result, martix, newLists)
-        martix.pop()
-        visited.push(word)
+      martix.push(word)
+      let prefix = ''
+      for (let i = 0; i < step + 1; ++i) {
+        prefix += martix[i][step + 1]
       }
+      let newLists = dictMap.get(prefix)
+      newLists = newLists ? newLists : []
+      backtracking(step + 1, result, martix, newLists)
+      martix.pop()
     }
   }
   const result = []

From 82659c06ad45bf1c46d7c1d2399495562b470291 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 Mar 2020 14:30:28 +0800
Subject: [PATCH 0367/3374] Update 425-word-squares.js

---
 425-word-squares.js | 76 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/425-word-squares.js b/425-word-squares.js
index fcebef6e..66c6d9e8 100644
--- a/425-word-squares.js
+++ b/425-word-squares.js
@@ -41,3 +41,79 @@ const wordSquares = function(words) {
   backtracking(0, result, [], words)
   return result
 }
+
+// another
+
+/**
+ * @param {string[]} words
+ * @return {string[][]}
+ */
+const wordSquares = function(words) {
+  let result = []
+  let trie = new Trie()
+  for (let word of words) {
+    trie.add(word)
+  }
+  
+  findWordSquare(result, [], trie)
+  return result
+};
+
+function findWordSquare (result, temp, trie) {
+  if (temp.length > 0 && temp.length === temp[0].length) {
+    result.push(temp)
+    return
+  }
+  
+  let prefix = ''
+  let j = temp.length
+  for (let i = 0; i < temp.length; i++) {
+    prefix += temp[i][j]
+  }
+  
+  let startWith = trie.startWith(prefix)
+  for (let word of startWith) {
+    findWordSquare(result, temp.concat([word]), trie)
+  }
+}
+
+function Trie () {
+  this.isWord = false
+  this.children = new Map()
+}
+
+Trie.prototype.add = function (word) {
+  let cur = this
+  for (let i = 0; i < word.length; i++) {
+    if (!cur.children.has(word[i])) {
+      cur.children.set(word[i], new Trie())
+    }
+    cur = cur.children.get(word[i])
+  }
+  cur.isWord = true
+}
+
+Trie.prototype.startWith = function (prefix) {
+  let cur = this
+  for (let i = 0; i < prefix.length; i++) {
+    if (cur.children.has(prefix[i])) {
+      cur = cur.children.get(prefix[i])
+    } else {
+      return []
+    }
+  }
+  
+  let res = []
+  const findWords = function (res, cur, str) {
+    if (!cur.isWord) {
+      for (let [key, val] of cur.children) {
+        findWords(res, val, str + key)
+      }
+    } else {
+      res.push(str)
+    }
+  }
+  
+  findWords(res, cur, prefix)
+  return res
+}

From 85b84f2892c57b513ecb49a6440217d3b022ffec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 Mar 2020 15:23:44 +0800
Subject: [PATCH 0368/3374] Create 427-construct-quad-tree.js

---
 427-construct-quad-tree.js | 41 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 427-construct-quad-tree.js

diff --git a/427-construct-quad-tree.js b/427-construct-quad-tree.js
new file mode 100644
index 00000000..5e84d5fe
--- /dev/null
+++ b/427-construct-quad-tree.js
@@ -0,0 +1,41 @@
+/**
+ * // Definition for a QuadTree node.
+ * function Node(val,isLeaf,topLeft,topRight,bottomLeft,bottomRight) {
+ *    this.val = val;
+ *    this.isLeaf = isLeaf;
+ *    this.topLeft = topLeft;
+ *    this.topRight = topRight;
+ *    this.bottomLeft = bottomLeft;
+ *    this.bottomRight = bottomRight;
+ * };
+ */
+/**
+ * @param {number[][]} grid
+ * @return {Node}
+ */
+const construct = function(grid) {
+  const tree = m => {
+    const node = new Node()
+    const isAllOne = m.every(r => r.every(v => v === 1))
+    const isAllZero = m.every(r => r.every(v => v === 0))
+    if (isAllOne) {
+      node.val = true
+      node.isLeaf = true
+    } else if (isAllZero) {
+      node.val = false
+      node.isLeaf = true
+    } else {
+      const len = m.length
+      let left = m.map(r => r.slice(0, len / 2))
+      let right = m.map(r => r.slice(len / 2))
+      node.topLeft = tree(left.slice(0, len / 2))
+      node.topRight = tree(right.slice(0, len / 2))
+      node.bottomLeft = tree(left.slice(len / 2))
+      node.bottomRight = tree(right.slice(len / 2))
+      node.isLeaf = false
+      node.val = true
+    }
+    return node
+  }
+  return tree(grid)
+}

From 223e78290a41821b08370a8aee583ccb0741c1c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 Mar 2020 16:44:20 +0800
Subject: [PATCH 0369/3374] Create 422-valid-word-square.js

---
 422-valid-word-square.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 422-valid-word-square.js

diff --git a/422-valid-word-square.js b/422-valid-word-square.js
new file mode 100644
index 00000000..3e1475ca
--- /dev/null
+++ b/422-valid-word-square.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string[]} words
+ * @return {boolean}
+ */
+const validWordSquare = function(words) {
+  if (words == null || words.length === 0) return true
+  const n = words.length
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < words[i].length; j++) {
+      if (
+        j >= n ||
+        words[j].length <= i ||
+        words[j].charAt(i) !== words[i].charAt(j)
+      )
+        return false
+    }
+  }
+  return true
+}

From 3e1f30325bb9c59bc5300cae126074f69ec180ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Mar 2020 10:15:49 +0800
Subject: [PATCH 0370/3374] Create 418-sentence-screen-fitting.js

---
 418-sentence-screen-fitting.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 418-sentence-screen-fitting.js

diff --git a/418-sentence-screen-fitting.js b/418-sentence-screen-fitting.js
new file mode 100644
index 00000000..9f87bffa
--- /dev/null
+++ b/418-sentence-screen-fitting.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string[]} sentence
+ * @param {number} rows
+ * @param {number} cols
+ * @return {number}
+ */
+const wordsTyping = function(sentence, rows, cols) {
+  let start = 0
+  const s = sentence.join(' ') + ' '
+  const l = s.length
+  for (let i = 0; i < rows; i++) {
+    start += cols
+    while (start >= 0 && s[start % l] !== ' ') start--
+    start++
+  }
+  return Math.floor(start / l)
+}

From 8bf5ffc276a810358875299a66fbb163b7887a76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Mar 2020 13:31:49 +0800
Subject: [PATCH 0371/3374] Create 411-minimum-unique-word-abbreviation.js

---
 411-minimum-unique-word-abbreviation.js | 56 +++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 411-minimum-unique-word-abbreviation.js

diff --git a/411-minimum-unique-word-abbreviation.js b/411-minimum-unique-word-abbreviation.js
new file mode 100644
index 00000000..eb0e830b
--- /dev/null
+++ b/411-minimum-unique-word-abbreviation.js
@@ -0,0 +1,56 @@
+/**
+ * @param {string} target
+ * @param {string[]} dictionary
+ * @return {string}
+ */
+const minAbbreviation = function(target, dictionary) {
+  let n = target.length,
+    bn = 1 << n,
+    cand = 0,
+    minlen = Number.MAX_VALUE
+  let minab = 0
+  const dict = []
+  let res = ''
+
+  for (let w of dictionary) {
+    let word = 0
+    if (w.length != n) continue
+    for (let i = n - 1, bit = 1; i >= 0; --i, bit <<= 1)
+      if (target[i] != w[i]) word += bit
+    dict.push(word)
+    cand |= word
+  }
+  dfs(1, 0)
+
+  for (let i = n - 1, pre = i; i >= 0; --i, minab >>= 1) {
+    if (minab & 1) {
+      if (pre - i > 0) res = pre - i + res
+      pre = i - 1
+      res = target[i] + res
+    } else if (i == 0) res = pre - i + 1 + res
+  }
+  return res
+  
+  function abbrLen(mask) {
+    let count = n
+    for (let b = 3; b < bn; b <<= 1) if ((mask & b) == 0) count--
+    return count
+  }
+
+  function dfs(bit, mask) {
+    const len = abbrLen(mask)
+    if (len >= minlen) return
+    let match = true
+    for (let d of dict) {
+      if ((mask & d) == 0) {
+        match = false
+        break
+      }
+    }
+    if (match) {
+      minlen = len
+      minab = mask
+    } else
+      for (let b = bit; b < bn; b <<= 1) if (cand & b) dfs(b << 1, mask + b)
+  }
+}

From cbcdfd60bf820e6fa5b550a5fad65955d432a267 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Mar 2020 15:05:17 +0800
Subject: [PATCH 0372/3374] Create 408-valid-word-abbreviation.js

---
 408-valid-word-abbreviation.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 408-valid-word-abbreviation.js

diff --git a/408-valid-word-abbreviation.js b/408-valid-word-abbreviation.js
new file mode 100644
index 00000000..cb7ab451
--- /dev/null
+++ b/408-valid-word-abbreviation.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} word
+ * @param {string} abbr
+ * @return {boolean}
+ */
+const validWordAbbreviation = (word, abbr) => {
+  if (word == null || abbr == null) return false
+  let i = 0
+  let j = 0
+  const len = word.length
+  const aLen = abbr.length
+  while (i < len && j < aLen) {
+    if (isNum(abbr[j])) {
+      if (abbr[j] === '0') return false
+      let n = 0
+      while (j < aLen && isNum(abbr[j])) {
+        n = n * 10 + Number(abbr[j])
+        j++
+      }
+      i += n
+    } else {
+      if (word[i] !== abbr[j]) return false
+      i++
+      j++
+    }
+  }
+  return i === word.length && j === aLen
+}
+const isNum = c => !isNaN(c)

From 39c9664e2eab5904493b3e78a27f44d5e78a510f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Mar 2020 16:26:22 +0800
Subject: [PATCH 0373/3374] Update 408-valid-word-abbreviation.js

---
 408-valid-word-abbreviation.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/408-valid-word-abbreviation.js b/408-valid-word-abbreviation.js
index cb7ab451..c9b27e3f 100644
--- a/408-valid-word-abbreviation.js
+++ b/408-valid-word-abbreviation.js
@@ -27,3 +27,32 @@ const validWordAbbreviation = (word, abbr) => {
   return i === word.length && j === aLen
 }
 const isNum = c => !isNaN(c)
+
+// another
+
+/**
+ * @param {string} word
+ * @param {string} abbr
+ * @return {boolean}
+ */
+const validWordAbbreviation = (word, abbr) => {
+  let i = 0,
+    j = 0
+  while (i < word.length && j < abbr.length) {
+    if (word.charAt(i) === abbr.charAt(j)) {
+      ++i
+      ++j
+      continue
+    }
+    if (abbr.charAt(j) <= '0' || abbr.charAt(j) > '9') {
+      return false
+    }
+    let start = j
+    while (j < abbr.length && abbr.charAt(j) >= '0' && abbr.charAt(j) <= '9') {
+      ++j
+    }
+    let num = +abbr.slice(start, j)
+    i += num
+  }
+  return i == word.length && j == abbr.length
+}

From e74526f14ccd80759c5106bfc40f83260b264dd1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Mar 2020 17:48:25 +0800
Subject: [PATCH 0374/3374] Create 401-binary-watch.js

---
 401-binary-watch.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 401-binary-watch.js

diff --git a/401-binary-watch.js b/401-binary-watch.js
new file mode 100644
index 00000000..07014e53
--- /dev/null
+++ b/401-binary-watch.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} num
+ * @return {string[]}
+ */
+const readBinaryWatch = function(num) {
+  const output = []
+  for (let h = 0; h < 12; h++) {
+    for (let m = 0; m < 60; m++) {
+      const ones = Number(h * 64 + m)
+        .toString(2)
+        .split('')
+        .filter(d => d === '1').length
+      if (ones === num) output.push(m < 10 ? `${h}:0${m}` : `${h}:${m}`)
+    }
+  }
+  return output
+}

From 0d34663247eec9a1f098ba6f36f44dc028b6b786 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Mar 2020 10:18:45 +0800
Subject: [PATCH 0375/3374] Create 510-inorder-successor-in-bst-ii.js

---
 510-inorder-successor-in-bst-ii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 510-inorder-successor-in-bst-ii.js

diff --git a/510-inorder-successor-in-bst-ii.js b/510-inorder-successor-in-bst-ii.js
new file mode 100644
index 00000000..1f9a4ef1
--- /dev/null
+++ b/510-inorder-successor-in-bst-ii.js
@@ -0,0 +1,27 @@
+/**
+ * // Definition for a Node.
+ * function Node(val) {
+ *    this.val = val;
+ *    this.left = null;
+ *    this.right = null;
+ *    this.parent = null;
+ * };
+ */
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const inorderSuccessor = function(node) {
+  if (node.right == null) {
+    let cur = node
+    while (cur.parent !== null && cur.parent.right === cur) {
+      cur = cur.parent
+    }
+    return cur.parent
+  }
+  let cur = node.right
+  while (cur.left !== null) {
+    cur = cur.left
+  }
+  return cur
+}

From cab456f7c329d9fc782d37e02689ff7c6bbe90f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Mar 2020 12:23:34 +0800
Subject: [PATCH 0376/3374] Create 511-game-play-analysis-i.sql

---
 511-game-play-analysis-i.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 511-game-play-analysis-i.sql

diff --git a/511-game-play-analysis-i.sql b/511-game-play-analysis-i.sql
new file mode 100644
index 00000000..1c31ac33
--- /dev/null
+++ b/511-game-play-analysis-i.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+select player_id, min(event_date) as first_login
+from Activity
+group by player_id;

From 5b7182e065ea8e73db20e0d3ec90c8fc573327d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Mar 2020 12:32:28 +0800
Subject: [PATCH 0377/3374] Create 512-game-play-analysis-ii.sql

---
 512-game-play-analysis-ii.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 512-game-play-analysis-ii.sql

diff --git a/512-game-play-analysis-ii.sql b/512-game-play-analysis-ii.sql
new file mode 100644
index 00000000..023a9cb7
--- /dev/null
+++ b/512-game-play-analysis-ii.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+select player_id, device_id 
+from activity 
+where (player_id, event_date) in (
+select player_id, min(event_date)
+from activity 
+group by player_id
+); 

From 8bf6f5297b3cd6d82681f04e6d2f86403c9363aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Mar 2020 15:54:14 +0800
Subject: [PATCH 0378/3374] Create 514-freedom-trail.js

---
 514-freedom-trail.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 514-freedom-trail.js

diff --git a/514-freedom-trail.js b/514-freedom-trail.js
new file mode 100644
index 00000000..cd42d63d
--- /dev/null
+++ b/514-freedom-trail.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} ring
+ * @param {string} key
+ * @return {number}
+ */
+const findRotateSteps = function(ring, key) {
+  function findLeft(i, j) {
+    let k = i
+    let count = 0
+    while (ring[k] !== key[j]) {
+      k--
+      count++
+      if (k === -1) k += ring.length
+    }
+    return [k, count]
+  }
+  function findRight(i, j) {
+    let k = i
+    let count = 0
+    while (ring[k] !== key[j]) {
+      k++
+      count++
+      if (k === ring.length) k -= ring.length
+    }
+    return [k, count]
+  }
+  const dp = []
+  for (let i = 0; i < ring.length; i++) {
+    dp[i] = []
+  }
+  function f(i, j) {
+    if (dp[i][j] !== undefined) return dp[i][j]
+    if (j === key.length) return (dp[i][j] = 0)
+    const [i1, c1] = findLeft(i, j)
+    const [i2, c2] = findRight(i, j)
+    return (dp[i][j] = Math.min(c1 + 1 + f(i1, j + 1), c2 + 1 + f(i2, j + 1)))
+  }
+  return f(0, 0)
+}

From 80e6d354da0249882661e1e42f74f104e45d941c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Mar 2020 21:45:26 +0800
Subject: [PATCH 0379/3374] Create 517-super-washing-machines.js

---
 517-super-washing-machines.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 517-super-washing-machines.js

diff --git a/517-super-washing-machines.js b/517-super-washing-machines.js
new file mode 100644
index 00000000..1b5dbf17
--- /dev/null
+++ b/517-super-washing-machines.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} machines
+ * @return {number}
+ */
+const findMinMoves = function(machines) {
+  let total = 0
+  for (let i of machines) total += i
+  if (total % machines.length !== 0) return -1
+  let avg = (total / machines.length) >> 0,
+    cnt = 0,
+    max = 0
+  for (let load of machines) {
+    cnt += load - avg
+    max = Math.max(Math.max(max, Math.abs(cnt)), load - avg)
+  }
+  return max
+}

From cefc40e74225ed001857929b7aff42169f977aa6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Mar 2020 16:48:01 +0800
Subject: [PATCH 0380/3374] Create 519-random-flip-matrix.js

---
 519-random-flip-matrix.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 519-random-flip-matrix.js

diff --git a/519-random-flip-matrix.js b/519-random-flip-matrix.js
new file mode 100644
index 00000000..19bfe982
--- /dev/null
+++ b/519-random-flip-matrix.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number} n_rows
+ * @param {number} n_cols
+ */
+const Solution = function(n_rows, n_cols) {
+  this.r = n_rows
+  this.c = n_cols
+  this.m = new Map()
+  this.total = n_rows * n_cols
+}
+
+/**
+ * @return {number[]}
+ */
+Solution.prototype.flip = function() {
+  const rand = Math.random()
+  const r = (rand * this.total--) >> 0
+  let x = this.m.get(r) || r
+  this.m.set(r, this.m.get(this.total) || this.total)
+  return [(x / this.c) >> 0, x % this.c]
+}
+
+/**
+ * @return {void}
+ */
+Solution.prototype.reset = function() {
+  this.m.clear()
+  this.total = this.r * this.c
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(n_rows, n_cols)
+ * var param_1 = obj.flip()
+ * obj.reset()
+ */

From 91ef70d0d4c05143a527b92c9fba81bd85343c8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Mar 2020 22:24:03 +0800
Subject: [PATCH 0381/3374] Update 519-random-flip-matrix.js

---
 519-random-flip-matrix.js | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/519-random-flip-matrix.js b/519-random-flip-matrix.js
index 19bfe982..2cbbf632 100644
--- a/519-random-flip-matrix.js
+++ b/519-random-flip-matrix.js
@@ -5,19 +5,18 @@
 const Solution = function(n_rows, n_cols) {
   this.r = n_rows
   this.c = n_cols
-  this.m = new Map()
   this.total = n_rows * n_cols
+  this.m = new Map()
 }
 
 /**
  * @return {number[]}
  */
 Solution.prototype.flip = function() {
-  const rand = Math.random()
-  const r = (rand * this.total--) >> 0
-  let x = this.m.get(r) || r
+  const r = (Math.random() * this.total--) >> 0
+  const i = this.m.get(r) || r
   this.m.set(r, this.m.get(this.total) || this.total)
-  return [(x / this.c) >> 0, x % this.c]
+  return [(i / this.c) >> 0, i % this.c]
 }
 
 /**
@@ -25,12 +24,12 @@ Solution.prototype.flip = function() {
  */
 Solution.prototype.reset = function() {
   this.m.clear()
-  this.total = this.r * this.c
+  this.total = this.c * this.r
 }
 
 /**
  * Your Solution object will be instantiated and called as such:
- * var obj = new Solution(n_rows, n_cols)
+ * var obj = Object.create(Solution).createNew(n_rows, n_cols)
  * var param_1 = obj.flip()
  * obj.reset()
  */

From 9914defda8b4540b1c35bf457b6efa65fa751c56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Mar 2020 11:09:38 +0800
Subject: [PATCH 0382/3374] Create 522-longest-uncommon-subsequence-ii.js

---
 522-longest-uncommon-subsequence-ii.js | 38 ++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 522-longest-uncommon-subsequence-ii.js

diff --git a/522-longest-uncommon-subsequence-ii.js b/522-longest-uncommon-subsequence-ii.js
new file mode 100644
index 00000000..cf62c60b
--- /dev/null
+++ b/522-longest-uncommon-subsequence-ii.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string[]} strs
+ * @return {number}
+ */
+const findLUSlength = function(strs) {
+  strs.sort((a, b)  => b.length - a.length)
+  const dup = getDuplicates(strs)
+  for(let i = 0; i < strs.length; i++) {
+    if(!dup.has(strs[i])) {
+      if(i === 0) return strs[0].length
+      for(let j = 0; j < i; j++) {
+        if(isSubsequence(strs[j], strs[i])) break
+        if(j === i - 1) return strs[i].length
+      }
+    }
+  }
+  return -1
+};
+
+function isSubsequence(a, b) {
+  let i = 0, j = 0
+  while(i < a.length && j < b.length) {
+    if(a.charAt(i) === b.charAt(j)) j++
+    i++
+  }
+  return j === b.length
+}
+
+function getDuplicates(arr) {
+  const set = new Set()
+  const dup = new Set()
+  for(let el of arr) {
+    if(set.has(el)) dup.add(el)
+    else set.add(el)
+  }
+  return dup
+}
+

From 91ebd95ab4df882695f5669329af45b716f2bbcf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Mar 2020 09:40:13 +0800
Subject: [PATCH 0383/3374] Create 527-word-abbreviation.js

---
 527-word-abbreviation.js | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 527-word-abbreviation.js

diff --git a/527-word-abbreviation.js b/527-word-abbreviation.js
new file mode 100644
index 00000000..3cdbcaac
--- /dev/null
+++ b/527-word-abbreviation.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string[]} dict
+ * @return {string[]}
+ */
+const wordsAbbreviation = function(dict) {
+  const result = []
+  const prefixLen = new Array(dict.length).fill(1)
+  for (let i = 0; i < dict.length; i++) {
+    result[i] = makeAbbr(dict[i], 1)
+  }
+  for (let i = 0; i < dict.length; i++) {
+    while (true) {
+      const set = new Set()
+      for (let j = i + 1; j < dict.length; j++) {
+        if (result[i] === result[j]) {
+          set.add(j)
+        }
+      }
+      if (set.size === 0) {
+        break
+      }
+      set.add(i)
+      for (let val of set.values()) {
+        result[val] = makeAbbr(dict[val], ++prefixLen[val])
+      }
+    }
+  }
+  return result
+}
+
+function makeAbbr(s, prefixLen) {
+  if (prefixLen >= s.length - 2) {
+    return s
+  }
+  let str = ''
+  str += s.slice(0, prefixLen)
+  str += s.length - 1 - prefixLen
+  str += s[s.length - 1]
+  return str
+}

From 73e2ed1032b90d9f531db2b3ef78f02687fd2093 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Mar 2020 11:31:24 +0800
Subject: [PATCH 0384/3374] Create 528-random-pick-with-weight.js

---
 528-random-pick-with-weight.js | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 528-random-pick-with-weight.js

diff --git a/528-random-pick-with-weight.js b/528-random-pick-with-weight.js
new file mode 100644
index 00000000..151f2c9d
--- /dev/null
+++ b/528-random-pick-with-weight.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} w
+ */
+const Solution = function(w) {
+  this.a = []
+  let sum = 0
+  for (let i = 0, len = w.length; i < len; i++) {
+    sum += w[i]
+    this.a[i] = sum
+  }
+}
+
+/**
+ * @return {number}
+ */
+Solution.prototype.pickIndex = function() {
+  const len = this.a.length
+  const sum = this.a[len - 1]
+  const rand = ((Math.random() * sum) >> 0) + 1
+  let l = 0,
+    h = len - 1
+  while (l < h) {
+    const mid = (l + h) >> 1
+    if (this.a[mid] === rand) return mid
+    else if (this.a[mid] < rand) l = mid + 1
+    else h = mid
+  }
+  return l
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(w)
+ * var param_1 = obj.pickIndex()
+ */

From 65d7f19558cfea8f1a335178efd73e742ea3140b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Mar 2020 12:58:51 +0800
Subject: [PATCH 0385/3374] Update 528-random-pick-with-weight.js

---
 528-random-pick-with-weight.js | 37 ++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/528-random-pick-with-weight.js b/528-random-pick-with-weight.js
index 151f2c9d..fe063da3 100644
--- a/528-random-pick-with-weight.js
+++ b/528-random-pick-with-weight.js
@@ -33,3 +33,40 @@ Solution.prototype.pickIndex = function() {
  * var obj = new Solution(w)
  * var param_1 = obj.pickIndex()
  */
+
+// another
+
+/**
+ * @param {number[]} w
+ */
+const Solution = function(w) {
+  this.a = []
+  let sum = 0
+  for(let i = 0, len = w.length; i < len; i++) {
+    sum += w[i]
+    this.a[i] = sum
+  }
+};
+
+/**
+ * @return {number}
+ */
+Solution.prototype.pickIndex = function() {
+  const len = this.a.length
+  const sum = this.a[len - 1]
+  const rand = ((Math.random() * sum) >> 0) + 1
+  let l = 0, h = len - 1
+  while(l <= h) {
+    const mid = (l + h) >> 1
+    if(this.a[mid] === rand) return mid
+    else if(this.a[mid] < rand) l = mid + 1
+    else h = mid - 1
+  }
+  return l
+};
+
+/** 
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(w)
+ * var param_1 = obj.pickIndex()
+ */

From b8b3dd7ab08262b4eee3a739b4ca42fd001ffade Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Mar 2020 13:52:15 +0800
Subject: [PATCH 0386/3374] Update 528-random-pick-with-weight.js

---
 528-random-pick-with-weight.js | 36 ++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/528-random-pick-with-weight.js b/528-random-pick-with-weight.js
index fe063da3..e33a3904 100644
--- a/528-random-pick-with-weight.js
+++ b/528-random-pick-with-weight.js
@@ -70,3 +70,39 @@ Solution.prototype.pickIndex = function() {
  * var obj = new Solution(w)
  * var param_1 = obj.pickIndex()
  */
+
+// another
+
+/**
+ * @param {number[]} w
+ */
+const Solution = function(w) {
+  this.a = []
+  let sum = 0
+  for(let i = 0, len = w.length; i < len; i++) {
+    sum += w[i]
+    this.a[i] = sum
+  }
+};
+
+/**
+ * @return {number}
+ */
+Solution.prototype.pickIndex = function() {
+  const len = this.a.length
+  const sum = this.a[len - 1]
+  const rand = ((Math.random() * sum) >> 0) + 1
+  let l = 0, h = len - 1
+  while(l < h) {
+    const mid = (l + h) >> 1
+    if(this.a[mid] < rand) l = mid + 1
+    else h = mid
+  }
+  return l
+};
+
+/** 
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(w)
+ * var param_1 = obj.pickIndex()
+ */

From e5a48faed6e1ab10090e8a2af48d4fe361db8812 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Mar 2020 15:46:59 +0800
Subject: [PATCH 0387/3374] Create 531-lonely-pixel-i.js

---
 531-lonely-pixel-i.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 531-lonely-pixel-i.js

diff --git a/531-lonely-pixel-i.js b/531-lonely-pixel-i.js
new file mode 100644
index 00000000..9fcc40c5
--- /dev/null
+++ b/531-lonely-pixel-i.js
@@ -0,0 +1,28 @@
+/**
+ * @param {character[][]} picture
+ * @return {number}
+ */
+const findLonelyPixel = function(picture) {
+  if(picture == null || picture[0].length === 0) return 0
+  const rows = picture.length
+  const cols = picture[0].length
+  const r = new Array(rows).fill(0)
+  const c = new Array(cols).fill(0)
+  for(let i = 0; i < rows; i++) {
+    for(let j = 0; j < cols; j++) {
+      r[i] += picture[i][j] === 'B' ? 1 : 0
+      c[j] += picture[i][j] === 'B' ? 1 : 0
+    }
+  }
+  let res = 0
+  for(let i = 0; i < rows; i++) {
+    if(r[i] === 1) {
+      for(let j = 0; j < cols; j++) {
+        if(c[j] === 1 && picture[i][j] === 'B') {
+          res++
+        }
+      }      
+    }
+  }
+  return res
+};

From 94cecb1aa864cbfabea16ed3c2f39463d28e9f3d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Mar 2020 16:45:10 +0800
Subject: [PATCH 0388/3374] Update 531-lonely-pixel-i.js

---
 531-lonely-pixel-i.js | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/531-lonely-pixel-i.js b/531-lonely-pixel-i.js
index 9fcc40c5..da53bba3 100644
--- a/531-lonely-pixel-i.js
+++ b/531-lonely-pixel-i.js
@@ -10,16 +10,19 @@ const findLonelyPixel = function(picture) {
   const c = new Array(cols).fill(0)
   for(let i = 0; i < rows; i++) {
     for(let j = 0; j < cols; j++) {
-      r[i] += picture[i][j] === 'B' ? 1 : 0
-      c[j] += picture[i][j] === 'B' ? 1 : 0
+      if(picture[i][j] === 'B') {
+        r[i]++
+        c[j]++
+      }
     }
   }
   let res = 0
   for(let i = 0; i < rows; i++) {
     if(r[i] === 1) {
       for(let j = 0; j < cols; j++) {
-        if(c[j] === 1 && picture[i][j] === 'B') {
-          res++
+        if(picture[i][j] === 'B') {
+          if(c[j] === 1)res++
+          break
         }
       }      
     }

From 040f09aa824e308c385b98cade290775e941b4bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Mar 2020 21:15:33 +0800
Subject: [PATCH 0389/3374] Update 531-lonely-pixel-i.js

---
 531-lonely-pixel-i.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/531-lonely-pixel-i.js b/531-lonely-pixel-i.js
index da53bba3..c56dd1ea 100644
--- a/531-lonely-pixel-i.js
+++ b/531-lonely-pixel-i.js
@@ -29,3 +29,32 @@ const findLonelyPixel = function(picture) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {character[][]} picture
+ * @return {number}
+ */
+const findLonelyPixel = function(picture) {
+  if(picture == null || picture[0].length === 0) return 0
+  const rows = picture.length
+  const cols = picture[0].length
+  const c = new Array(cols).fill(0)
+  for(let i = 0; i < rows; i++) {
+    for(let j = 0; j < cols; j++) {
+      if(picture[i][j] === 'B') c[j]++
+    }
+  }
+  let res = 0
+  for(let i = 0; i < rows; i++) {
+    let cnt = 0, pos = -1
+    for(let j = 0; j < cols; j++) {
+      if(picture[i][j] !== 'B') continue
+      if(++cnt === 1) pos = j
+      else break
+    }
+    if(cnt === 1 && c[pos] === 1) res++
+  }
+  return res
+};

From 6e419bcb137fe7541ba2afb46ae79e841cab1fa6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Mar 2020 12:54:18 +0800
Subject: [PATCH 0390/3374] Create 533-lonely-pixel-ii.js

---
 533-lonely-pixel-ii.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 533-lonely-pixel-ii.js

diff --git a/533-lonely-pixel-ii.js b/533-lonely-pixel-ii.js
new file mode 100644
index 00000000..aae07230
--- /dev/null
+++ b/533-lonely-pixel-ii.js
@@ -0,0 +1,35 @@
+/**
+ * @param {character[][]} picture
+ * @param {number} N
+ * @return {number}
+ */
+const findBlackPixel = function(picture, N) {
+  let m = []
+  for (let i = 0; i < picture.length; i++) {
+    let cnt = 0
+    let str = ''
+    for (let j = 0; j < picture[0].length; j++) {
+      if (picture[i][j] === 'W') continue
+      cnt++
+      if (cnt > N) break
+      str += j + ','
+    }
+    if (cnt === N) m[i] = str
+  }
+  let ans = 0
+  for (let j = 0; j < picture[0].length; j++) {
+    let cnt = 0
+    let rowStr = ''
+    for (let i = 0; i < picture.length; i++) {
+      if (picture[i][j] === 'W') continue
+      cnt++
+      if (cnt === 1) rowStr = m[i]
+      else if (cnt > N || m[i] !== rowStr) {
+        rowStr = ''
+        break
+      }
+    }
+    if (cnt === N && rowStr) ans += N
+  }
+  return ans
+}

From 6fbe7439dc682b3c4e88e5dd3fbd0ca0689eb75c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Mar 2020 21:16:07 +0800
Subject: [PATCH 0391/3374] Update 533-lonely-pixel-ii.js

---
 533-lonely-pixel-ii.js | 46 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/533-lonely-pixel-ii.js b/533-lonely-pixel-ii.js
index aae07230..f4de89c9 100644
--- a/533-lonely-pixel-ii.js
+++ b/533-lonely-pixel-ii.js
@@ -33,3 +33,49 @@ const findBlackPixel = function(picture, N) {
   }
   return ans
 }
+
+// another
+
+/**
+ * @param {character[][]} picture
+ * @param {number} N
+ * @return {number}
+ */
+const findBlackPixel = function(picture, N) {
+  const rows = picture.length
+  if(rows === 0) return 0
+  const cols = picture[0].length
+  if(cols === 0) return 0
+  const m = new Map()
+  const colCnt = new Array(cols).fill(0)
+  for(let i = 0; i < rows; i++) {
+    const k = scanRow(picture, i, cols, N, colCnt)
+    if(k) {
+      m.set(k, (m.get(k) || 0) + 1)
+    }
+  }
+  let res = 0
+  for(let [k, v] of m) {
+    if(v === N) {
+      for(let i = 0; i < cols; i++) {
+        if(k[i] === 'B' && colCnt[i] === N) res += N
+      }
+    }
+  }
+  return res
+}
+
+function scanRow(p, r, cols, N, arr) {
+  let str = ''
+  let cnt = 0
+  for(let i = 0; i < cols; i++) {
+    if(p[r][i] === 'B') {
+      cnt++
+      arr[i] += 1
+    }
+    str += p[r][i]
+  }
+  if(cnt === N) return str
+  return ''
+}
+

From 997b3bba523b0f6ae2f5c9d0e4b923e20d74a161 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Mar 2020 21:30:20 +0800
Subject: [PATCH 0392/3374] Create 534-game-play-analysis-iii.sql

---
 534-game-play-analysis-iii.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 534-game-play-analysis-iii.sql

diff --git a/534-game-play-analysis-iii.sql b/534-game-play-analysis-iii.sql
new file mode 100644
index 00000000..d6e0dbf6
--- /dev/null
+++ b/534-game-play-analysis-iii.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+select player_id, event_date, sum(games_played) as games_played_so_far
+from (select a.player_id, a.event_date, b.games_played
+from (
+select player_id, event_date
+from activity
+group by player_id, event_date) a
+join activity b
+on a.player_id = b.player_id and a.event_date >=b.event_date) as tb
+group by player_id, event_date;

From f3be1ebf46d555ea06ff4e1eb05cc06f80b91883 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Mar 2020 23:48:40 +0800
Subject: [PATCH 0393/3374] Create 536-construct-binary-tree-from-string.js

---
 536-construct-binary-tree-from-string.js | 34 ++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 536-construct-binary-tree-from-string.js

diff --git a/536-construct-binary-tree-from-string.js b/536-construct-binary-tree-from-string.js
new file mode 100644
index 00000000..841f7b10
--- /dev/null
+++ b/536-construct-binary-tree-from-string.js
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {string} s
+ * @return {TreeNode}
+ */
+const str2tree = function(s) {
+  const stack = []
+  for (let i = 0, j = i; i < s.length; i++, j = i) {
+    const c = s.charAt(i)
+    if (c === ')') stack.pop()
+    else if ((c >= '0' && c <= '9') || c === '-') {
+      while (
+        i + 1 < s.length &&
+        s.charAt(i + 1) >= '0' &&
+        s.charAt(i + 1) <= '9'
+      )
+        i++
+      const currentNode = new TreeNode(+s.slice(j, i + 1))
+      if (stack.length) {
+        const parent = stack[stack.length - 1]
+        if (parent.left !== null) parent.right = currentNode
+        else parent.left = currentNode
+      }
+      stack.push(currentNode)
+    }
+  }
+  return stack.length === 0 ? null : stack[stack.length - 1]
+}

From 9d47ecf0d96563b1d0b38dbbac2dead09f91c2f2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Mar 2020 00:31:24 +0800
Subject: [PATCH 0394/3374] Update 536-construct-binary-tree-from-string.js

---
 536-construct-binary-tree-from-string.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/536-construct-binary-tree-from-string.js b/536-construct-binary-tree-from-string.js
index 841f7b10..4fb1ea18 100644
--- a/536-construct-binary-tree-from-string.js
+++ b/536-construct-binary-tree-from-string.js
@@ -30,5 +30,5 @@ const str2tree = function(s) {
       stack.push(currentNode)
     }
   }
-  return stack.length === 0 ? null : stack[stack.length - 1]
+  return stack.length === 0 ? null : stack[0]
 }

From 601d0a491d9298ad6c214036a7d16aa7249e3925 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Mar 2020 12:29:10 +0800
Subject: [PATCH 0395/3374] Create 544-output-contest-matches.js

---
 544-output-contest-matches.js | 58 +++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 544-output-contest-matches.js

diff --git a/544-output-contest-matches.js b/544-output-contest-matches.js
new file mode 100644
index 00000000..08e29271
--- /dev/null
+++ b/544-output-contest-matches.js
@@ -0,0 +1,58 @@
+/**
+
+During the NBA playoffs, we always arrange the rather strong team to play with the rather weak team,
+like make the rank 1 team play with the rank nth team, which is a good strategy to make the contest more interesting.
+Now, you're given n teams, you need to output their final contest matches in the form of a string.
+
+The n teams are given in the form of positive integers from 1 to n, which represents their initial rank.
+(Rank 1 is the strongest team and Rank n is the weakest team.)
+We'll use parentheses('(', ')') and commas(',') to represent the contest team pairing - parentheses('(' , ')') for
+pairing and commas(',') for partition. During the pairing process in each round,
+you always need to follow the strategy of making the rather strong one pair with the rather weak one.
+
+Example 1:
+Input: 2
+Output: (1,2)
+Explanation: 
+Initially, we have the team 1 and the team 2, placed like: 1,2.
+Then we pair the team (1,2) together with '(', ')' and ',', which is the final answer.
+Example 2:
+Input: 4
+Output: ((1,4),(2,3))
+Explanation: 
+In the first round, we pair the team 1 and 4, the team 2 and 3 together, as we need to make the strong team and weak team together.
+And we got (1,4),(2,3).
+In the second round, the winners of (1,4) and (2,3) need to play again to generate the final winner,
+so you need to add the paratheses outside them.
+And we got the final answer ((1,4),(2,3)).
+Example 3:
+Input: 8
+Output: (((1,8),(4,5)),((2,7),(3,6)))
+Explanation: 
+First round: (1,8),(2,7),(3,6),(4,5)
+Second round: ((1,8),(4,5)),((2,7),(3,6))
+Third round: (((1,8),(4,5)),((2,7),(3,6)))
+Since the third round will generate the final winner, you need to output the answer (((1,8),(4,5)),((2,7),(3,6))).
+Note:
+The n is in range [2, 212].
+We ensure that the input n can be converted into the form 2k, where k is a positive integer.
+
+*/
+
+/**
+ * @param {number} n
+ * @return {string}
+ */
+const findContestMatch = function(n) {
+  const arr = []
+  for(let i = 0; i < n; i++) {
+    arr[i] = i + 1
+  }
+  while(n > 1) {
+    for(let i = 0; i < (n >> 1); i++) {
+      arr[i] = `(${arr[i]},${arr[n - 1 - i]})`
+    }
+    n = n >> 1
+  }
+  return arr[0]
+}; 

From 9270a23c272451e3f5dca8f1efa497af8f2d47cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Mar 2020 12:43:22 +0800
Subject: [PATCH 0396/3374] Update 544-output-contest-matches.js

---
 544-output-contest-matches.js | 26 +++++++++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/544-output-contest-matches.js b/544-output-contest-matches.js
index 08e29271..e81f6d0f 100644
--- a/544-output-contest-matches.js
+++ b/544-output-contest-matches.js
@@ -55,4 +55,28 @@ const findContestMatch = function(n) {
     n = n >> 1
   }
   return arr[0]
-}; 
+};
+
+// another
+
+/**
+ * @param {number} n
+ * @return {string}
+ */
+const findContestMatch = function(n) {
+  const arr = []
+  for(let i = 0; i < n; i++) {
+    arr[i] = i + 1
+  }
+  let l = 0
+  let r = n - 1
+  while(l < r) {
+    while(l < r) {
+      arr[l] = `(${arr[l]},${arr[r]})`
+      l++
+      r--
+    }
+    l = 0
+  }
+  return arr[0]
+};

From 5b09f5ca9006656bce144334340c4bede6ce1360 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Mar 2020 20:45:31 +0800
Subject: [PATCH 0397/3374] Create 545-boundary-of-binary-tree.js

---
 545-boundary-of-binary-tree.js | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 545-boundary-of-binary-tree.js

diff --git a/545-boundary-of-binary-tree.js b/545-boundary-of-binary-tree.js
new file mode 100644
index 00000000..79a2985e
--- /dev/null
+++ b/545-boundary-of-binary-tree.js
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[]}
+ */
+const boundaryOfBinaryTree = function (root) {
+  if (!root) return []
+  if (!root.left && !root.right) return [root.val]
+  const res = [root.val]
+  buildSide(root.left, 'left', res)
+  buildBottom(root, res)
+  const right = []
+  buildSide(root.right, 'right', right)
+  return [...res, ...right.reverse()]
+}
+
+function buildSide(root, side, res) {
+  if (!root) return
+  if (root.left || root.right) res.push(root.val)
+  if (root[side]) buildSide(root[side], side, res)
+  else buildSide(root[side === 'left' ? 'right' : 'left'], side, res)
+}
+
+function buildBottom(root, res) {
+  if (!root) return
+  if (!root.left && !root.right) res.push(root.val)
+  buildBottom(root.left, res)
+  buildBottom(root.right, res)
+}

From afc7e1533d7eb78478cccfc5a05eed5fac4935bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 11:42:30 +0800
Subject: [PATCH 0398/3374] Create 548-split-array-with-equal-sum.js

---
 548-split-array-with-equal-sum.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 548-split-array-with-equal-sum.js

diff --git a/548-split-array-with-equal-sum.js b/548-split-array-with-equal-sum.js
new file mode 100644
index 00000000..20d0899c
--- /dev/null
+++ b/548-split-array-with-equal-sum.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const splitArray = function(nums) {
+  if (nums.length < 7) return false
+  const sum = new Array(nums.length).fill(0)
+  sum[0] = nums[0]
+  for (let i = 1; i < nums.length; i++) {
+    sum[i] = sum[i - 1] + nums[i]
+  }
+  for (let j = 3; j < nums.length - 3; j++) {
+    const set = new Set()
+    for (let i = 1; i < j - 1; i++) {
+      if (sum[i - 1] == sum[j - 1] - sum[i]) set.add(sum[i - 1])
+    }
+    for (let k = j + 2; k < nums.length - 1; k++) {
+      if (
+        sum[nums.length - 1] - sum[k] == sum[k - 1] - sum[j] &&
+        set.has(sum[k - 1] - sum[j])
+      )
+        return true
+    }
+  }
+  return false
+}

From c54bbd4f74489023a737aa8fd217145d59fdebff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 14:37:39 +0800
Subject: [PATCH 0399/3374] Update 548-split-array-with-equal-sum.js

---
 548-split-array-with-equal-sum.js | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/548-split-array-with-equal-sum.js b/548-split-array-with-equal-sum.js
index 20d0899c..4b414be1 100644
--- a/548-split-array-with-equal-sum.js
+++ b/548-split-array-with-equal-sum.js
@@ -4,19 +4,20 @@
  */
 const splitArray = function(nums) {
   if (nums.length < 7) return false
-  const sum = new Array(nums.length).fill(0)
+  const len = nums.lenght
+  const sum = new Array(len.length).fill(0)
   sum[0] = nums[0]
-  for (let i = 1; i < nums.length; i++) {
+  for (let i = 1; i < len; i++) {
     sum[i] = sum[i - 1] + nums[i]
   }
-  for (let j = 3; j < nums.length - 3; j++) {
+  for (let j = 3; j < len - 3; j++) {
     const set = new Set()
     for (let i = 1; i < j - 1; i++) {
-      if (sum[i - 1] == sum[j - 1] - sum[i]) set.add(sum[i - 1])
+      if (sum[i - 1] === sum[j - 1] - sum[i]) set.add(sum[i - 1])
     }
-    for (let k = j + 2; k < nums.length - 1; k++) {
+    for (let k = j + 2; k < len - 1; k++) {
       if (
-        sum[nums.length - 1] - sum[k] == sum[k - 1] - sum[j] &&
+        sum[len - 1] - sum[k] === sum[k - 1] - sum[j] &&
         set.has(sum[k - 1] - sum[j])
       )
         return true

From 028877640a6d9e38a5aff2cfa12bfb03cb033ca1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 14:46:19 +0800
Subject: [PATCH 0400/3374] Update 548-split-array-with-equal-sum.js

---
 548-split-array-with-equal-sum.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/548-split-array-with-equal-sum.js b/548-split-array-with-equal-sum.js
index 4b414be1..57036340 100644
--- a/548-split-array-with-equal-sum.js
+++ b/548-split-array-with-equal-sum.js
@@ -1,3 +1,28 @@
+/**
+
+Given an array with n integers, you need to find if there are triplets (i, j, k) which satisfies following conditions:
+0 < i, i + 1 < j, j + 1 < k < n - 1
+Sum of subarrays (0, i - 1), (i + 1, j - 1), (j + 1, k - 1) and (k + 1, n - 1) should be equal.
+where we define that subarray (L, R) represents a slice of the original array starting
+from the element indexed L to the element indexed R.
+
+Example:
+
+Input: [1,2,1,2,1,2,1]
+Output: True
+Explanation:
+i = 1, j = 3, k = 5. 
+sum(0, i - 1) = sum(0, 0) = 1
+sum(i + 1, j - 1) = sum(2, 2) = 1
+sum(j + 1, k - 1) = sum(4, 4) = 1
+sum(k + 1, n - 1) = sum(6, 6) = 1
+
+Note:
+1 <= n <= 2000.
+Elements in the given array will be in range [-1,000,000, 1,000,000].
+
+*/
+
 /**
  * @param {number[]} nums
  * @return {boolean}

From 8ae1e261bf9d7695ac10a84839b6caa82cca2f10 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 17:17:24 +0800
Subject: [PATCH 0401/3374] Create
 549-binary-tree-longest-consecutive-sequence-ii.js

---
 ...ry-tree-longest-consecutive-sequence-ii.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 549-binary-tree-longest-consecutive-sequence-ii.js

diff --git a/549-binary-tree-longest-consecutive-sequence-ii.js b/549-binary-tree-longest-consecutive-sequence-ii.js
new file mode 100644
index 00000000..465b7b91
--- /dev/null
+++ b/549-binary-tree-longest-consecutive-sequence-ii.js
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const longestConsecutive = function (root, res = { val: 0 }) {
+  if (!root) return 0;
+  const left1 = dfs(root, -1);
+  const right1 = dfs(root);
+  const left2 = dfs(root);
+  const right2 = dfs(root, -1);
+  res.val = Math.max(
+    res.val,
+    Math.max(
+      left1 + right1 - !!(left1 && right1),
+      left2 + right2 - !!(left2 && right2)
+    )
+  );
+  longestConsecutive(root.left, res);
+  longestConsecutive(root.right, res);
+  return res.val;
+};
+
+function dfs(root, dir = 1, prev = null) {
+  if (!root || (prev !== null && root.val !== prev + dir)) return 0;
+  return (
+    1 + Math.max(dfs(root.left, dir, root.val), dfs(root.right, dir, root.val))
+  );
+}

From 8ae67b12a9759ad4a67c735774f35171cffc991b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 17:42:52 +0800
Subject: [PATCH 0402/3374] Update
 549-binary-tree-longest-consecutive-sequence-ii.js

---
 ...ry-tree-longest-consecutive-sequence-ii.js | 39 ++++++++-----------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/549-binary-tree-longest-consecutive-sequence-ii.js b/549-binary-tree-longest-consecutive-sequence-ii.js
index 465b7b91..af61208a 100644
--- a/549-binary-tree-longest-consecutive-sequence-ii.js
+++ b/549-binary-tree-longest-consecutive-sequence-ii.js
@@ -10,26 +10,21 @@
  * @return {number}
  */
 const longestConsecutive = function (root, res = { val: 0 }) {
-  if (!root) return 0;
-  const left1 = dfs(root, -1);
-  const right1 = dfs(root);
-  const left2 = dfs(root);
-  const right2 = dfs(root, -1);
-  res.val = Math.max(
-    res.val,
-    Math.max(
-      left1 + right1 - !!(left1 && right1),
-      left2 + right2 - !!(left2 && right2)
-    )
-  );
-  longestConsecutive(root.left, res);
-  longestConsecutive(root.right, res);
-  return res.val;
+  if (root === null) return 0;
+  let ans = 0;
+  function f(node) {
+    let inc = 1,
+      dec = 1;
+    const child = [node.left, node.right];
+    for (let c of child) {
+      if (c === null) continue;
+      let r = f(c);
+      if (node.val + 1 === c.val) inc = Math.max(inc, r[0] + 1);
+      else if (node.val - 1 === c.val) dec = Math.max(dec, r[1] + 1);
+    }
+    ans = Math.max(ans, inc + dec - 1);
+    return [inc, dec];
+  }
+  f(root);
+  return ans;
 };
-
-function dfs(root, dir = 1, prev = null) {
-  if (!root || (prev !== null && root.val !== prev + dir)) return 0;
-  return (
-    1 + Math.max(dfs(root.left, dir, root.val), dfs(root.right, dir, root.val))
-  );
-}

From c1074f27d70b53281a18436259eb2b48e4dfc74e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Mar 2020 23:12:40 +0800
Subject: [PATCH 0403/3374] Create 550-game-play-analysis-iv.sql

---
 550-game-play-analysis-iv.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 550-game-play-analysis-iv.sql

diff --git a/550-game-play-analysis-iv.sql b/550-game-play-analysis-iv.sql
new file mode 100644
index 00000000..ac439a25
--- /dev/null
+++ b/550-game-play-analysis-iv.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+select 
+round((select count(distinct a.player_id) from Activity a
+inner join 
+(select player_id, min(event_date) as first_logged 
+    from Activity 
+    group by player_id) b on datediff(a.event_date, b.first_logged)=1
+    and a.player_id = b.player_id)
+    /
+    (select count(distinct player_id) from Activity),2) as fraction;

From 7edd2806ed71237714d5d6ad6f08560271a55480 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Mar 2020 13:13:10 +0800
Subject: [PATCH 0404/3374] Create 555-split-concatenated-strings.js

---
 555-split-concatenated-strings.js | 36 +++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 555-split-concatenated-strings.js

diff --git a/555-split-concatenated-strings.js b/555-split-concatenated-strings.js
new file mode 100644
index 00000000..fb16ff4d
--- /dev/null
+++ b/555-split-concatenated-strings.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string[]} strs
+ * @return {string}
+ */
+const splitLoopedString = function (strs) {
+  let ans = ''
+  const n = strs.length
+  if (n === 0) return ''
+  findMaxStrings(strs)
+  for (let i = 0; i < n; ++i) {
+    solve(strs, i, true)
+    solve(strs, i, false)
+  }
+  return ans
+  function findMaxStrings(strs) {
+    for (let i = 0; i < n; ++i) {
+      const temp = strs[i].split('').reverse().join('')
+      strs[i] = strs[i] > temp ? strs[i] : temp
+    }
+  }
+  function solve(strs, i, flag) {
+    let temp = strs[i]
+    if (flag) {
+      temp = temp.split('').reverse().join('')
+    }
+    let size = temp.length
+    let str1 = '',
+      str2 = ''
+    for (let j = i + 1; j < n; ++j) str1 += strs[j]
+    for (let j = 0; j < i; ++j) str2 += strs[j]
+    for (let k = 0; k < size; ++k) {
+      let newOne = temp.substr(k) + str1 + str2 + temp.substr(0, k)
+      ans = ans === '' ? newOne : ans > newOne ? ans : newOne
+    }
+  }
+}

From eeb7cc999c8419aba46cba196d571c2a40a4ee65 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Mar 2020 13:54:05 +0800
Subject: [PATCH 0405/3374] Create
 558-logical-or-of-two-binary-grids-represented-as-quad-trees.js

---
 ...-binary-grids-represented-as-quad-trees.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 558-logical-or-of-two-binary-grids-represented-as-quad-trees.js

diff --git a/558-logical-or-of-two-binary-grids-represented-as-quad-trees.js b/558-logical-or-of-two-binary-grids-represented-as-quad-trees.js
new file mode 100644
index 00000000..e9d1533a
--- /dev/null
+++ b/558-logical-or-of-two-binary-grids-represented-as-quad-trees.js
@@ -0,0 +1,44 @@
+/**
+ * // Definition for a QuadTree node.
+ * function Node(val,isLeaf,topLeft,topRight,bottomLeft,bottomRight) {
+ *    this.val = val;
+ *    this.isLeaf = isLeaf;
+ *    this.topLeft = topLeft;
+ *    this.topRight = topRight;
+ *    this.bottomLeft = bottomLeft;
+ *    this.bottomRight = bottomRight;
+ * };
+ */
+/**
+ * @param {Node} quadTree1
+ * @param {Node} quadTree2
+ * @return {Node}
+ */
+const intersect = function (quadTree1, quadTree2) {
+  if (quadTree1.isLeaf) {
+    return quadTree1.val ? quadTree1 : quadTree2;
+  }
+
+  if (quadTree2.isLeaf) {
+    return quadTree2.val ? quadTree2 : quadTree1;
+  }
+
+  const topLeft = intersect(quadTree1.topLeft, quadTree2.topLeft);
+  const topRight = intersect(quadTree1.topRight, quadTree2.topRight);
+  const bottomLeft = intersect(quadTree1.bottomLeft, quadTree2.bottomLeft);
+  const bottomRight = intersect(quadTree1.bottomRight, quadTree2.bottomRight);
+
+  if (
+    topLeft.isLeaf &&
+    topRight.isLeaf &&
+    bottomLeft.isLeaf &&
+    bottomRight.isLeaf &&
+    topLeft.val == topRight.val &&
+    topRight.val == bottomLeft.val &&
+    bottomLeft.val == bottomRight.val
+  ) {
+    return new Node(topLeft.val, true, null, null, null, null);
+  } else {
+    return new Node(false, false, topLeft, topRight, bottomLeft, bottomRight);
+  }
+};

From 376936e312ab980f2f4f5b34a821d410ab778bae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Mar 2020 18:48:04 +0800
Subject: [PATCH 0406/3374] Create
 562-longest-line-of-consecutive-one-in-matrix.js

---
 ...ngest-line-of-consecutive-one-in-matrix.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 562-longest-line-of-consecutive-one-in-matrix.js

diff --git a/562-longest-line-of-consecutive-one-in-matrix.js b/562-longest-line-of-consecutive-one-in-matrix.js
new file mode 100644
index 00000000..d6a61b0a
--- /dev/null
+++ b/562-longest-line-of-consecutive-one-in-matrix.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} M
+ * @return {number}
+ */
+const longestLine = function (M) {
+  const m = M.length
+  if (!m) return 0
+  const n = M[0].length
+  if (!n) return 0
+
+  const DP = [...Array(m)].map(() => [...Array(n)].map(() => [0, 0, 0, 0]))
+  let max = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (M[i][j]) {
+        DP[i][j][0] = (i ? DP[i - 1][j][0] : 0) + 1 // up
+        DP[i][j][1] = (j < n - 1 && i ? DP[i - 1][j + 1][1] : 0) + 1 // diag
+        DP[i][j][2] = (j && i ? DP[i - 1][j - 1][2] : 0) + 1 // anti diag
+        DP[i][j][3] = (j ? DP[i][j - 1][3] : 0) + 1 // left
+        max = Math.max(max, ...DP[i][j])
+      }
+    }
+  }
+  return max
+}

From 686e3a9b10fb44464cf2f473c4695b00c36b446c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Mar 2020 07:54:33 +0800
Subject: [PATCH 0407/3374] Update
 562-longest-line-of-consecutive-one-in-matrix.js

---
 562-longest-line-of-consecutive-one-in-matrix.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/562-longest-line-of-consecutive-one-in-matrix.js b/562-longest-line-of-consecutive-one-in-matrix.js
index d6a61b0a..1fead0e2 100644
--- a/562-longest-line-of-consecutive-one-in-matrix.js
+++ b/562-longest-line-of-consecutive-one-in-matrix.js
@@ -13,10 +13,10 @@ const longestLine = function (M) {
   for (let i = 0; i < m; i++) {
     for (let j = 0; j < n; j++) {
       if (M[i][j]) {
-        DP[i][j][0] = (i ? DP[i - 1][j][0] : 0) + 1 // up
-        DP[i][j][1] = (j < n - 1 && i ? DP[i - 1][j + 1][1] : 0) + 1 // diag
-        DP[i][j][2] = (j && i ? DP[i - 1][j - 1][2] : 0) + 1 // anti diag
-        DP[i][j][3] = (j ? DP[i][j - 1][3] : 0) + 1 // left
+        DP[i][j][0] = (i ? DP[i - 1][j][0] : 0) + 1
+        DP[i][j][1] = (j < n - 1 && i ? DP[i - 1][j + 1][1] : 0) + 1
+        DP[i][j][2] = (j && i ? DP[i - 1][j - 1][2] : 0) + 1
+        DP[i][j][3] = (j ? DP[i][j - 1][3] : 0) + 1
         max = Math.max(max, ...DP[i][j])
       }
     }

From f16a594a00f87cdae8353684f9f261ef2e122332 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Mar 2020 13:52:46 +0800
Subject: [PATCH 0408/3374] Create 568-maximum-vacation-days.js

---
 568-maximum-vacation-days.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 568-maximum-vacation-days.js

diff --git a/568-maximum-vacation-days.js b/568-maximum-vacation-days.js
new file mode 100644
index 00000000..ffc8508b
--- /dev/null
+++ b/568-maximum-vacation-days.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} flights
+ * @param {number[][]} days
+ * @return {number}
+ */
+const maxVacationDays = function (flights, days) {
+  const N = flights.length
+  let dp = new Array(N).fill(0)
+  for (let k = days[0].length - 1; k >= 0; k--) {
+    const tmp = new Array(N)
+    for (let i = 0; i < N; i++) {
+      tmp[i] = days[i][k] + dp[i]
+      for (let j = 0; j < N; j++) {
+        if (flights[i][j] === 0) continue
+        tmp[i] = Math.max(tmp[i], days[j][k] + dp[j])
+      }
+    }
+    dp = tmp
+  }
+  return dp[0]
+}

From a34864eeb19a196d92f019eb2a3ce0c2ec40f893 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Mar 2020 19:42:37 +0800
Subject: [PATCH 0409/3374] Create
 570-managers-with-at-least-5-direct-reports.sql

---
 570-managers-with-at-least-5-direct-reports.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 570-managers-with-at-least-5-direct-reports.sql

diff --git a/570-managers-with-at-least-5-direct-reports.sql b/570-managers-with-at-least-5-direct-reports.sql
new file mode 100644
index 00000000..641b9df0
--- /dev/null
+++ b/570-managers-with-at-least-5-direct-reports.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+SELECT e1.Name
+FROM Employee e1
+JOIN (
+	SELECT ManagerId 
+	FROM Employee
+	GROUP BY ManagerId
+	HAVING COUNT(ManagerId) >= 5
+) e2
+ON e1.Id = e2.ManagerId;

From 003b8a96d21f78de19c63e4d24d526abde793b30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Mar 2020 19:55:48 +0800
Subject: [PATCH 0410/3374] Create
 571-find-median-given-frequency-of-numbers.sql

---
 571-find-median-given-frequency-of-numbers.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 571-find-median-given-frequency-of-numbers.sql

diff --git a/571-find-median-given-frequency-of-numbers.sql b/571-find-median-given-frequency-of-numbers.sql
new file mode 100644
index 00000000..c563c8e0
--- /dev/null
+++ b/571-find-median-given-frequency-of-numbers.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT AVG(Number) AS median
+FROM 
+    (SELECT * FROM Numbers ORDER BY Number) a, 
+    (SELECT @i:=0) init
+WHERE 
+    Frequency >= ABS(@i+(@i:=@i+Frequency) - (SELECT SUM(Frequency) FROM Numbers)); 

From bcb0187e3012b8c3c7f286c01dd702fc212b6af9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Mar 2020 21:14:54 +0800
Subject: [PATCH 0411/3374] Create 573-squirrel-simulation.js

---
 573-squirrel-simulation.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 573-squirrel-simulation.js

diff --git a/573-squirrel-simulation.js b/573-squirrel-simulation.js
new file mode 100644
index 00000000..b1f5ab80
--- /dev/null
+++ b/573-squirrel-simulation.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} height
+ * @param {number} width
+ * @param {number[]} tree
+ * @param {number[]} squirrel
+ * @param {number[][]} nuts
+ * @return {number}
+ */
+const minDistance = function(height, width, tree, squirrel, nuts) {
+  const arr = nuts.map(el => 2 * distance(el, tree))
+  const sum = arr.reduce((ac, el) => ac + el, 0)
+  let res = Number.MAX_VALUE
+  for(let i = 0, len = arr.length; i < len; i++) {
+    let tmp = sum - arr[i] + distance(squirrel, nuts[i]) + distance(nuts[i], tree)
+    res = Math.min(res, tmp)
+  }
+  return res
+};
+
+function distance(p1, p2) {
+  return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1])
+}

From fd76d898a88157e60defb7033c68552541085b35 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Mar 2020 21:33:31 +0800
Subject: [PATCH 0412/3374] Update 573-squirrel-simulation.js

---
 573-squirrel-simulation.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/573-squirrel-simulation.js b/573-squirrel-simulation.js
index b1f5ab80..6d9f5cd5 100644
--- a/573-squirrel-simulation.js
+++ b/573-squirrel-simulation.js
@@ -20,3 +20,27 @@ const minDistance = function(height, width, tree, squirrel, nuts) {
 function distance(p1, p2) {
   return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1])
 }
+
+// another
+
+/**
+ * @param {number} height
+ * @param {number} width
+ * @param {number[]} tree
+ * @param {number[]} squirrel
+ * @param {number[][]} nuts
+ * @return {number}
+ */
+const minDistance = function (height, width, tree, squirrel, nuts) {
+  let sum = 0,
+    maxDiff = -Number.MAX_VALUE
+  for (let nut of nuts) {
+    const dist = Math.abs(tree[0] - nut[0]) + Math.abs(tree[1] - nut[1])
+    sum += 2 * dist
+    maxDiff = Math.max(
+      maxDiff,
+      dist - Math.abs(squirrel[0] - nut[0]) - Math.abs(squirrel[1] - nut[1])
+    )
+  }
+  return sum - maxDiff
+}

From 7a6c9fcafe1631ed07d327a7ccbe25571777312a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Mar 2020 21:46:50 +0800
Subject: [PATCH 0413/3374] Create 574-winning-candidate.sql

---
 574-winning-candidate.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 574-winning-candidate.sql

diff --git a/574-winning-candidate.sql b/574-winning-candidate.sql
new file mode 100644
index 00000000..352f0ce6
--- /dev/null
+++ b/574-winning-candidate.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT Name
+FROM Candidate c
+INNER JOIN (SELECT CandidateId
+    FROM Vote
+    GROUP BY CandidateId
+    ORDER BY COUNT(CandidateId)  DESC
+    LIMIT 0,1) v
+ON c.id = v.CandidateId;

From 18e9dca1a9ee66f6e61daffa4c9fd7cbe90b24a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 11:41:43 +0800
Subject: [PATCH 0414/3374] Create 576-out-of-boundary-paths.js

---
 576-out-of-boundary-paths.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 576-out-of-boundary-paths.js

diff --git a/576-out-of-boundary-paths.js b/576-out-of-boundary-paths.js
new file mode 100644
index 00000000..bb725632
--- /dev/null
+++ b/576-out-of-boundary-paths.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} N
+ * @param {number} i
+ * @param {number} j
+ * @return {number}
+ */
+const findPaths = function (m, n, N, i, j) {
+  const dp = [...Array(2)].map((_) =>
+    [...Array(50)].map((_) => Array(50).fill(0))
+  )
+  while (N-- > 0) {
+    for (let i = 0; i < m; i++) {
+      for (let j = 0, nc = (N + 1) % 2, np = N % 2; j < n; j++) {
+        dp[nc][i][j] =
+          ((i === 0 ? 1 : dp[np][i - 1][j]) +
+            (i === m - 1 ? 1 : dp[np][i + 1][j]) +
+            (j === 0 ? 1 : dp[np][i][j - 1]) +
+            (j === n - 1 ? 1 : dp[np][i][j + 1])) %
+          1000000007
+      }
+    }
+  }
+  return dp[1][i][j]
+}

From 3555df1db92b48594decf33cc175f534b13d57fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 12:47:08 +0800
Subject: [PATCH 0415/3374] Update 576-out-of-boundary-paths.js

---
 576-out-of-boundary-paths.js | 43 ++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/576-out-of-boundary-paths.js b/576-out-of-boundary-paths.js
index bb725632..3241ee0b 100644
--- a/576-out-of-boundary-paths.js
+++ b/576-out-of-boundary-paths.js
@@ -24,3 +24,46 @@ const findPaths = function (m, n, N, i, j) {
   }
   return dp[1][i][j]
 }
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} N
+ * @param {number} i
+ * @param {number} j
+ * @return {number}
+ */
+const findPaths = function (m, n, N, i, j) {
+  if (N <= 0) return 0;
+  const MOD = 1000000007;
+  let count = Array.from({ length: m }, () => new Array(n).fill(0));
+  count[i][j] = 1;
+  let result = 0;
+  const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ];
+  for (let step = 0; step < N; step++) {
+    const temp = Array.from({ length: m }, () => new Array(n).fill(0));
+    for (let r = 0; r < m; r++) {
+      for (let c = 0; c < n; c++) {
+        for (let d of dirs) {
+          let nr = r + d[0];
+          let nc = c + d[1];
+          if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
+            result = (result + count[r][c]) % MOD;
+          } else {
+            temp[nr][nc] = (temp[nr][nc] + count[r][c]) % MOD;
+          }
+        }
+      }
+    }
+    count = temp;
+  }
+  return result;
+};
+

From 41853cff11a5488cd05c29c2fe42e2829d567412 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 12:58:49 +0800
Subject: [PATCH 0416/3374] Update 576-out-of-boundary-paths.js

---
 576-out-of-boundary-paths.js | 44 ++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/576-out-of-boundary-paths.js b/576-out-of-boundary-paths.js
index 3241ee0b..af30410f 100644
--- a/576-out-of-boundary-paths.js
+++ b/576-out-of-boundary-paths.js
@@ -67,3 +67,47 @@ const findPaths = function (m, n, N, i, j) {
   return result;
 };
 
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} N
+ * @param {number} i
+ * @param {number} j
+ * @return {number}
+ */
+const findPaths = function (m, n, N, i, j) {
+  const cache = []
+  const M = 1000000007
+  for (let i = 0; i < N; i++) {
+    const map2D = []
+    for (let j = 0; j < m; j++) {
+      const arr = []
+      for (let k = 0; k < n; k++) {
+        arr.push(null)
+      }
+      map2D.push(arr)
+    }
+    cache.push(map2D)
+  }
+  return makeMove(cache, m, n, N, i, j)
+
+  function makeMove(cache, m, n, N, i, j) {
+    if (i === m || j === n || i < 0 || j < 0) return 1
+    if (N === 0) return 0
+    if (cache[N - 1][i][j] !== null) return cache[N - 1][i][j]
+    cache[N - 1][i][j] =
+      (((makeMove(cache, m, n, N - 1, i - 1, j) +
+        makeMove(cache, m, n, N - 1, i + 1, j)) %
+        M) +
+        ((makeMove(cache, m, n, N - 1, i, j - 1) +
+          makeMove(cache, m, n, N - 1, i, j + 1)) %
+          M)) %
+      M
+
+    return cache[N - 1][i][j]
+  }
+}
+
+

From f7aa8df55bcf2885f9eccad77a36c0f6e9bafa8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 13:54:56 +0800
Subject: [PATCH 0417/3374] Update 576-out-of-boundary-paths.js

---
 576-out-of-boundary-paths.js | 44 +++++++++++-------------------------
 1 file changed, 13 insertions(+), 31 deletions(-)

diff --git a/576-out-of-boundary-paths.js b/576-out-of-boundary-paths.js
index af30410f..67d9eae9 100644
--- a/576-out-of-boundary-paths.js
+++ b/576-out-of-boundary-paths.js
@@ -77,37 +77,19 @@ const findPaths = function (m, n, N, i, j) {
  * @param {number} j
  * @return {number}
  */
-const findPaths = function (m, n, N, i, j) {
-  const cache = []
-  const M = 1000000007
-  for (let i = 0; i < N; i++) {
-    const map2D = []
-    for (let j = 0; j < m; j++) {
-      const arr = []
-      for (let k = 0; k < n; k++) {
-        arr.push(null)
-      }
-      map2D.push(arr)
-    }
-    cache.push(map2D)
-  }
-  return makeMove(cache, m, n, N, i, j)
-
-  function makeMove(cache, m, n, N, i, j) {
-    if (i === m || j === n || i < 0 || j < 0) return 1
-    if (N === 0) return 0
-    if (cache[N - 1][i][j] !== null) return cache[N - 1][i][j]
-    cache[N - 1][i][j] =
-      (((makeMove(cache, m, n, N - 1, i - 1, j) +
-        makeMove(cache, m, n, N - 1, i + 1, j)) %
-        M) +
-        ((makeMove(cache, m, n, N - 1, i, j - 1) +
-          makeMove(cache, m, n, N - 1, i, j + 1)) %
-          M)) %
-      M
-
-    return cache[N - 1][i][j]
-  }
+const findPaths = function (m, n, N, i, j, memo = new Map()) {
+    const key = N + ',' + i + ',' + j;
+    if (memo.has(key)) return memo.get(key);
+    const isOutside = i === -1 || i === m || j === -1 || j === n;
+    if (N === 0 || isOutside) return +isOutside;
+    memo.set(key, (
+          findPaths(m, n, N - 1, i - 1, j, memo)
+        + findPaths(m, n, N - 1, i + 1, j, memo)
+        + findPaths(m, n, N - 1, i, j + 1, memo)
+        + findPaths(m, n, N - 1, i, j - 1, memo)
+    ) % 1000000007);
+    return memo.get(key);
 }
 
 
+

From 0bca4167d98e0a579f685b51c5102261222f1087 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 14:15:39 +0800
Subject: [PATCH 0418/3374] Update 576-out-of-boundary-paths.js

---
 576-out-of-boundary-paths.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/576-out-of-boundary-paths.js b/576-out-of-boundary-paths.js
index 67d9eae9..78472acd 100644
--- a/576-out-of-boundary-paths.js
+++ b/576-out-of-boundary-paths.js
@@ -52,8 +52,8 @@ const findPaths = function (m, n, N, i, j) {
     for (let r = 0; r < m; r++) {
       for (let c = 0; c < n; c++) {
         for (let d of dirs) {
-          let nr = r + d[0];
-          let nc = c + d[1];
+          const nr = r + d[0];
+          const nc = c + d[1];
           if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
             result = (result + count[r][c]) % MOD;
           } else {

From fd9bea1bac13f716ad1d91fbcf32bf6319324e95 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 14:23:59 +0800
Subject: [PATCH 0419/3374] Create 577-employee-bonus.sql

---
 577-employee-bonus.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 577-employee-bonus.sql

diff --git a/577-employee-bonus.sql b/577-employee-bonus.sql
new file mode 100644
index 00000000..74d8825a
--- /dev/null
+++ b/577-employee-bonus.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT Employee.name, Bonus.bonus 
+from Employee LEFT JOIN Bonus ON
+Employee.empid = Bonus.empid
+WHERE bonus is null or bonus<1000;

From 3aa9821df2b327d24d2665614d18e1166fa757f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 15:12:24 +0800
Subject: [PATCH 0420/3374] Create 578-get-highest-answer-rate-question.sql

---
 578-get-highest-answer-rate-question.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 578-get-highest-answer-rate-question.sql

diff --git a/578-get-highest-answer-rate-question.sql b/578-get-highest-answer-rate-question.sql
new file mode 100644
index 00000000..590c50f5
--- /dev/null
+++ b/578-get-highest-answer-rate-question.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+select question_id as survey_log
+from survey_log
+group by question_id
+order by count(answer_id) desc
+limit 1;

From 6b01d977a36d54b158956737213fd1dfe42c0357 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Mar 2020 15:28:55 +0800
Subject: [PATCH 0421/3374] Update 578-get-highest-answer-rate-question.sql

---
 578-get-highest-answer-rate-question.sql | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/578-get-highest-answer-rate-question.sql b/578-get-highest-answer-rate-question.sql
index 590c50f5..6a376996 100644
--- a/578-get-highest-answer-rate-question.sql
+++ b/578-get-highest-answer-rate-question.sql
@@ -1,6 +1,8 @@
 # Write your MySQL query statement below
 select question_id as survey_log
-from survey_log
-group by question_id
-order by count(answer_id) desc
-limit 1;
+from (
+  select question_id, count(answer_id)/count(*) as count
+  from survey_log group by question_id
+  order by count desc 
+  limit 1
+) as p;

From 2513e1ae0ef508f7870fcb6c213f14b416cf887e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 10:40:31 +0800
Subject: [PATCH 0422/3374] Create
 579-find-cumulative-salary-of-an-employee.sql

---
 579-find-cumulative-salary-of-an-employee.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 579-find-cumulative-salary-of-an-employee.sql

diff --git a/579-find-cumulative-salary-of-an-employee.sql b/579-find-cumulative-salary-of-an-employee.sql
new file mode 100644
index 00000000..b7f187b9
--- /dev/null
+++ b/579-find-cumulative-salary-of-an-employee.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT   A.Id, MAX(B.Month) as Month, SUM(B.Salary) as Salary
+FROM     Employee A, Employee B
+WHERE    A.Id = B.Id AND B.Month BETWEEN (A.Month-3) AND (A.Month-1)
+GROUP BY A.Id, A.Month
+ORDER BY Id, Month DESC;

From 2dcc3095c5a2129222bcdc37def3a05de428c1e5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 10:53:48 +0800
Subject: [PATCH 0423/3374] Create 580-count-student-number-in-departments.sql

---
 580-count-student-number-in-departments.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 580-count-student-number-in-departments.sql

diff --git a/580-count-student-number-in-departments.sql b/580-count-student-number-in-departments.sql
new file mode 100644
index 00000000..03a2b52f
--- /dev/null
+++ b/580-count-student-number-in-departments.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT dept_name, IFNULL(COUNT(student_id),0) as student_number 
+FROM department 
+LEFT JOIN student
+USING (dept_id)
+GROUP BY dept_name
+ORDER BY student_number DESC, dept_name;

From 577fed027260f783abd22d1f21be867d3a66b5c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 11:24:20 +0800
Subject: [PATCH 0424/3374] Create 582-kill-process.js

---
 582-kill-process.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 582-kill-process.js

diff --git a/582-kill-process.js b/582-kill-process.js
new file mode 100644
index 00000000..3e0b8372
--- /dev/null
+++ b/582-kill-process.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} pid
+ * @param {number[]} ppid
+ * @param {number} kill
+ * @return {number[]}
+ */
+const killProcess = function(pid, ppid, kill) {
+  const pm = new Map()
+  for(let i = 0, len = pid.length; i < len; i++) {
+    const c = pid[i]
+    const p = ppid[i]
+    let tmp = pm.get(p)
+    if(!tmp) tmp = new Set()
+    tmp.add(c)
+    pm.set(p, tmp)
+  }
+  const res = []
+  const q = [kill]
+  while(q.length) {
+    const size = q.length
+    for(let i = 0; i < size; i++) {
+      const el = q.shift()
+      res.push(el)
+      if(pm.get(el)) {
+        q.push(...Array.from(pm.get(el)))
+      }
+    }
+  }
+  return res
+};

From 30d0a67e6475429ba54172aa5fd0e04877bb48fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 11:42:35 +0800
Subject: [PATCH 0425/3374] Update 582-kill-process.js

---
 582-kill-process.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/582-kill-process.js b/582-kill-process.js
index 3e0b8372..d5c5c502 100644
--- a/582-kill-process.js
+++ b/582-kill-process.js
@@ -28,3 +28,33 @@ const killProcess = function(pid, ppid, kill) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} pid
+ * @param {number[]} ppid
+ * @param {number} kill
+ * @return {number[]}
+ */
+const killProcess = function(pid, ppid, kill) {
+  const pm = new Map()
+  for(let i = 0, len = pid.length; i < len; i++) {
+    const p = ppid[i]
+    let tmp = pm.get(p)
+    if(!tmp) tmp = new Set()
+    tmp.add(pid[i])
+    pm.set(p, tmp)
+  }
+  const res = []
+  function dfs(k) {
+    res.push(k)
+    if(pm.get(k)) {
+      for(let e of pm.get(k)) {
+        dfs(e)
+      }      
+    }
+  }
+  dfs(kill)
+  return res
+};

From 885892a2655bc278713da3ae42ee8d67c74ea6a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 12:13:43 +0800
Subject: [PATCH 0426/3374] Create 583-delete-operation-for-two-strings.js

---
 583-delete-operation-for-two-strings.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 583-delete-operation-for-two-strings.js

diff --git a/583-delete-operation-for-two-strings.js b/583-delete-operation-for-two-strings.js
new file mode 100644
index 00000000..bd4ea9eb
--- /dev/null
+++ b/583-delete-operation-for-two-strings.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const minDistance = function (word1, word2, memo = new Map()) {
+  if (word1 === word2) return 0
+  if (word1 === '' || word2 === '') return Math.max(word1.length, word2.length)
+  const len1 = word1.length
+  const len2 = word2.length
+  if (memo.has(`${word1}-${word2}`)) return memo.get(`${word1}-${word2}`)
+  let res
+  if (word1[len1 - 1] === word2[len2 - 1]) {
+    res = minDistance(word1.slice(0, len1 - 1), word2.slice(0, len2 - 1), memo)
+  } else {
+    res =
+      1 +
+      Math.min(
+        minDistance(word1.slice(0, len1 - 1), word2, memo),
+        minDistance(word1, word2.slice(0, len2 - 1), memo)
+      )
+  }
+  memo.set(`${word1}-${word2}`, res)
+  return res
+}

From 98431e472741a4b643ae4c4e16b2873cd818e2f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 13:15:50 +0800
Subject: [PATCH 0427/3374] Update 583-delete-operation-for-two-strings.js

---
 583-delete-operation-for-two-strings.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/583-delete-operation-for-two-strings.js b/583-delete-operation-for-two-strings.js
index bd4ea9eb..d2951c30 100644
--- a/583-delete-operation-for-two-strings.js
+++ b/583-delete-operation-for-two-strings.js
@@ -23,3 +23,24 @@ const minDistance = function (word1, word2, memo = new Map()) {
   memo.set(`${word1}-${word2}`, res)
   return res
 }
+
+// another
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const minDistance = function (word1, word2) {
+  const len1 = word1.length
+  const len2 = word2.length
+  const dp = Array.from({ length: len1 + 1 }, () => new Array(len2 + 1).fill(0))
+  for(let i = 1; i <= len1; i++) {
+    for(let j = 1; j<= len2; j++) {
+      if(word1[i - 1] === word2[j - 1]) dp[i][j] = dp[i - 1][j - 1] + 1
+      else dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
+    }
+  }
+  return len1 + len2 - dp[len1][len2] * 2
+}
+

From 097a914acb46617d0de752b0ce8e3108915b8543 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 13:47:26 +0800
Subject: [PATCH 0428/3374] Update 583-delete-operation-for-two-strings.js

---
 583-delete-operation-for-two-strings.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/583-delete-operation-for-two-strings.js b/583-delete-operation-for-two-strings.js
index d2951c30..66821d18 100644
--- a/583-delete-operation-for-two-strings.js
+++ b/583-delete-operation-for-two-strings.js
@@ -44,3 +44,28 @@ const minDistance = function (word1, word2) {
   return len1 + len2 - dp[len1][len2] * 2
 }
 
+// another
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const minDistance = function (word1, word2) {
+  const len1 = word1.length
+  const len2 = word2.length
+  const dp = Array.from({ length: len1 + 1 }, () => new Array(len2 + 1).fill(0))
+  for(let i = 1; i <= len2; i++) {
+    dp[0][i] = i
+  }
+  for(let j = 1; j <= len1; j++) {
+    dp[j][0] = j
+  }
+  for(let i = 1; i <= len1; i++) {
+    for(let j = 1; j<= len2; j++) {
+      if(word1[i - 1] === word2[j - 1]) dp[i][j] = dp[i - 1][j - 1]
+      else dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + 1
+    }
+  }
+  return dp[len1][len2]
+}

From 408f7f868de46d24779fc13e0aec1fe2e880a27c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 13:58:24 +0800
Subject: [PATCH 0429/3374] Create 584-find-customer-referee.sql

---
 584-find-customer-referee.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 584-find-customer-referee.sql

diff --git a/584-find-customer-referee.sql b/584-find-customer-referee.sql
new file mode 100644
index 00000000..7378efcb
--- /dev/null
+++ b/584-find-customer-referee.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+select name
+from customer
+where referee_id <> 2 or referee_id is NULL;

From c3c9581efe97711d6991a0209c3f34b4487a51d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 14:27:53 +0800
Subject: [PATCH 0430/3374] Create 585-investments-in-2016.sql

---
 585-investments-in-2016.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 585-investments-in-2016.sql

diff --git a/585-investments-in-2016.sql b/585-investments-in-2016.sql
new file mode 100644
index 00000000..26c97210
--- /dev/null
+++ b/585-investments-in-2016.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+select sum(TIV_2016) TIV_2016
+from insurance a
+where 1 = (select count(*) from insurance b where a.LAT = b.LAT and a.LON = b.LON) 
+and 1 < (select count(*) from insurance c where a.TIV_2015 = c.TIV_2015);

From 607a4d3bac780a4e66d2406d97f649ed904d52be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 15:39:43 +0800
Subject: [PATCH 0431/3374] Create
 596-customer-placing-the-largest-number-of-orders.sql

---
 596-customer-placing-the-largest-number-of-orders.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 596-customer-placing-the-largest-number-of-orders.sql

diff --git a/596-customer-placing-the-largest-number-of-orders.sql b/596-customer-placing-the-largest-number-of-orders.sql
new file mode 100644
index 00000000..088b10cc
--- /dev/null
+++ b/596-customer-placing-the-largest-number-of-orders.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+select customer_number
+from orders
+group by customer_number
+order by count(*) desc limit 1;

From a945fa6e503259260b69209f1298935ba174d20d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Mar 2020 17:33:56 +0800
Subject: [PATCH 0432/3374] Create 587-erect-the-fence.js

---
 587-erect-the-fence.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 587-erect-the-fence.js

diff --git a/587-erect-the-fence.js b/587-erect-the-fence.js
new file mode 100644
index 00000000..61a73a70
--- /dev/null
+++ b/587-erect-the-fence.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} points
+ * @return {number[][]}
+ */
+const outerTrees = function (points) {
+  const orientation = (p1, p2, p3) => {
+    return (p2[1] - p1[1]) * (p3[0] - p2[0]) - (p2[0] - p1[0]) * (p3[1] - p2[1])
+  }
+  points.sort((a, b) => {
+    return a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]
+  })
+  const stack = []
+  for (let i = 0; i < points.length; i++) {
+    while (
+      stack.length >= 2 &&
+      orientation(stack[stack.length - 2], stack[stack.length - 1], points[i]) >
+        0
+    )
+      stack.pop()
+    stack.push(points[i])
+  }
+  stack.pop()
+  for (let i = points.length - 1; i >= 0; i--) {
+    while (
+      stack.length >= 2 &&
+      orientation(stack[stack.length - 2], stack[stack.length - 1], points[i]) >
+        0
+    )
+      stack.pop()
+    stack.push(points[i])
+  }
+  return [...new Set(stack)]
+}

From 2c2985c4a2d76e007a3375fb53e1692e151b06af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Mar 2020 09:04:22 +0800
Subject: [PATCH 0433/3374] Create 588-design-in-memory-file-system.js

---
 588-design-in-memory-file-system.js | 75 +++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 588-design-in-memory-file-system.js

diff --git a/588-design-in-memory-file-system.js b/588-design-in-memory-file-system.js
new file mode 100644
index 00000000..61695f2c
--- /dev/null
+++ b/588-design-in-memory-file-system.js
@@ -0,0 +1,75 @@
+const FileSystem = function () {
+  this.items = new Map()
+}
+
+/**
+ * @param {string} path
+ * @return {string[]}
+ */
+FileSystem.prototype.ls = function (path) {
+  const paths = path.split('/').filter((p) => !!p.length)
+  let curr = this.items
+  let last = ''
+
+  for (const p of paths) {
+    curr = curr.get(p)
+    last = p
+  }
+  const list = Array.from(curr.keys()).filter((e) => e !== 'content')
+  if (curr.has('content')) list.push(last)
+  return list.sort()
+}
+
+/**
+ * @param {string} path
+ * @return {void}
+ */
+FileSystem.prototype.mkdir = function (path) {
+  const paths = path.split('/').filter((p) => !!p.length)
+  let curr = this.items
+  for (const p of paths) {
+    if (!curr.has(p)) {
+      curr.set(p, new Map())
+    }
+    curr = curr.get(p)
+  }
+}
+
+/**
+ * @param {string} filePath
+ * @param {string} content
+ * @return {void}
+ */
+FileSystem.prototype.addContentToFile = function (filePath, content) {
+  const paths = filePath.split('/').filter((p) => !!p.length)
+  let curr = this.items
+  for (const p of paths) {
+    if (!curr.has(p)) {
+      curr.set(p, new Map())
+    }
+    curr = curr.get(p)
+  }
+  curr.set('content', (curr.get('content') || '') + content)
+}
+
+/**
+ * @param {string} filePath
+ * @return {string}
+ */
+FileSystem.prototype.readContentFromFile = function (filePath) {
+  const paths = filePath.split('/').filter((p) => !!p.length)
+  let curr = this.items
+  for (const p of paths) {
+    curr = curr.get(p)
+  }
+  return curr.get('content')
+}
+
+/**
+ * Your FileSystem object will be instantiated and called as such:
+ * var obj = new FileSystem()
+ * var param_1 = obj.ls(path)
+ * obj.mkdir(path)
+ * obj.addContentToFile(filePath,content)
+ * var param_4 = obj.readContentFromFile(filePath)
+ */

From 0a87ddf931f1523c427809dda2578e4568e7a9fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Mar 2020 12:28:39 +0800
Subject: [PATCH 0434/3374] Create 591-tag-validator.js

---
 591-tag-validator.js | 139 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 591-tag-validator.js

diff --git a/591-tag-validator.js b/591-tag-validator.js
new file mode 100644
index 00000000..81d5e2d9
--- /dev/null
+++ b/591-tag-validator.js
@@ -0,0 +1,139 @@
+/**
+ * @param {string} code
+ * @return {boolean}
+ */
+const isValid = function (code) {
+  const STATES = {
+    lt: 1, // <
+    tagOrData: 2, // uppercase=tag, '!'=data
+    tagName: 3, // uppercase, '>'=end
+    dataContent: 4, // any, ']'=wait-for-end
+    dataEnd: 5, // any, ']'=end
+    tagContent: 6, // any, '<'=tag-or-data
+  }
+  class Validator {
+    constructor(str) {
+      this.state = STATES.lt
+      this.str = str
+      this.stack = []
+      this.i = 0
+      // this ensure it doesnt start with cdata
+      this.isValid = this.isUpperCase(this.str[1])
+      // check through code
+      while (this.isValid && this.i < this.str.length) {
+        this.isValid = this.validate()
+      }
+      // check if there is unclosed tags
+      this.isValid = this.isValid && !this.stack.length
+    }
+
+    /**
+     * check and move on
+     */
+    validate() {
+      let char = this.str[this.i]
+      switch (this.state) {
+        // expect '<', only used at start
+        case STATES.lt:
+          this.i++
+          if (char == '<') {
+            this.state = STATES.tagOrData
+            return true
+          }
+          return false
+        // expect (end-)tag-name or cdata
+        case STATES.tagOrData:
+          // data
+          if (char == '!') {
+            this.i = this.findStrEnd(this.i + 1, '[CDATA[')
+            if (this.i == -1) {
+              return false
+            }
+            this.state = STATES.dataContent
+            return true
+          }
+          // end tag
+          if (char == '/') {
+            let name = this.stack.pop()
+            if (!name) {
+              return false
+            }
+            this.i = this.findStrEnd(this.i + 1, name + '>')
+            if (this.i == -1) {
+              return false
+            }
+            if (!this.stack.length & (this.i < this.str.length)) {
+              // more than one top level tags
+              return false
+            }
+            this.state = STATES.tagContent
+            return true
+          }
+          // tag name
+          {
+            let name = this.findTagName(this.i)
+            if (!name) {
+              return false
+            }
+            if (name.length > 9) {
+              return false
+            }
+            this.i += name.length + 1
+            this.stack.push(name)
+            this.state = STATES.tagContent
+            return true
+          }
+        case STATES.dataContent: // you can try replace these code with indexOf
+        {
+          let end = this.findStrEnd(this.i, ']]>')
+          if (end != -1) {
+            // found end
+            this.i = end
+            this.state = STATES.tagContent
+            return true
+          }
+          // not yet
+          this.i++
+          return true
+        }
+        case STATES.tagContent:
+          if (char == '<') {
+            this.state = STATES.tagOrData
+            this.i++
+            return true
+          }
+          this.i++
+          return true
+      }
+    }
+
+    isUpperCase(char) {
+      return /[A-Z]/.test(char)
+    }
+
+    findStrEnd(from, toFind = '') {
+      let end = from + toFind.length
+      for (let i = 0; i < toFind.length; i++) {
+        if (toFind[i] != this.str[i + from]) return -1
+      }
+      return end
+    }
+
+    findTagName(from) {
+      let tagName = ''
+      for (let i = from; i < this.str.length; i++) {
+        if (this.isUpperCase(this.str[i])) {
+          tagName += this.str[i]
+          continue
+        }
+        if (this.str[i] == '>') {
+          return tagName
+        }
+        return ''
+      }
+      return ''
+    }
+  }
+  let v = new Validator(code)
+  return v.isValid
+}

From 9d7b69342af2377aee65a9afed3c3b4ddf01c018 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Mar 2020 13:46:36 +0800
Subject: [PATCH 0435/3374] Update 591-tag-validator.js

---
 591-tag-validator.js | 49 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/591-tag-validator.js b/591-tag-validator.js
index 81d5e2d9..206a826a 100644
--- a/591-tag-validator.js
+++ b/591-tag-validator.js
@@ -1,3 +1,52 @@
+/**
+ * @param {string} code
+ * @return {boolean}
+ */
+const isValid = function (code) {
+  const stack = []
+  const [A, Z] = ['A', 'Z'].map((e) => e.charCodeAt(0))
+  for (let i = 0; i < code.length; ) {
+    if (i > 0 && stack.length === 0) return false
+    if (code.startsWith('<![CDATA[', i)) {
+      let j = i + 9
+      i = code.indexOf(']]>', j)
+      if (i < 0) return false
+      i += 3
+    } else if (code.startsWith('</', i)) {
+      let j = i + 2
+      i = code.indexOf('>', j)
+      if (i < 0 || i === j || i - j > 9) return false
+      for (let k = j; k < i; k++) {
+        if (
+          code.charAt(k) !== code[k].toUpperCase() ||
+          !(code.charCodeAt(k) >= A && code.charCodeAt(k) <= Z)
+        )
+          return false
+      }
+      let s = code.slice(j, i++)
+      if (stack.length === 0 || stack.pop() !== s) return false
+    } else if (code.startsWith('<', i)) {
+      let j = i + 1
+      i = code.indexOf('>', j)
+      if (i < 0 || i === j || i - j > 9) return false
+      for (let k = j; k < i; k++) {
+        if (
+          code.charAt(k) !== code[k].toUpperCase() ||
+          !(code.charCodeAt(k) >= A && code.charCodeAt(k) <= Z)
+        )
+          return false
+      }
+      let s = code.slice(j, i++)
+      stack.push(s)
+    } else {
+      i++
+    }
+  }
+  return stack.length === 0
+}
+
+// another
+
 /**
  * @param {string} code
  * @return {boolean}

From 43706a5de10b76b0915ed25e08e8acffb1fa4417 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Mar 2020 16:40:49 +0800
Subject: [PATCH 0436/3374] Update 591-tag-validator.js

---
 591-tag-validator.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/591-tag-validator.js b/591-tag-validator.js
index 206a826a..ead25315 100644
--- a/591-tag-validator.js
+++ b/591-tag-validator.js
@@ -45,6 +45,23 @@ const isValid = function (code) {
   return stack.length === 0
 }
 
+// another
+
+/**
+ * @param {string} code
+ * @return {boolean}
+ */
+const isValid = function (code) {
+  code = code.replace(/<!\[CDATA\[.*?\]\]>|t/g, '-')
+  let prev
+  while (code !== prev) {
+    prev = code
+    code = code.replace(/<([A-Z]{1,9})>[^<]*<\/\1>/g, 't')
+  }
+  return code === 't'
+}
+
+
 // another
 
 /**

From 57c9442e0189e11a058b53e587d74a13e8a74374 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Mar 2020 20:45:34 +0800
Subject: [PATCH 0437/3374] Create 592-fraction-addition-and-subtraction.js

---
 592-fraction-addition-and-subtraction.js | 36 ++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 592-fraction-addition-and-subtraction.js

diff --git a/592-fraction-addition-and-subtraction.js b/592-fraction-addition-and-subtraction.js
new file mode 100644
index 00000000..323df6c3
--- /dev/null
+++ b/592-fraction-addition-and-subtraction.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} expression
+ * @return {string}
+ */
+const fractionAddition = function (expression) {
+  if (expression[0] === '-') expression = '0/1' + expression
+  const terms = expression.split(/[+-]/g)
+  const ops = '+' + expression.replace(/[^+-]/g, '')
+  const nums = [],
+    dens = []
+  for (let term of terms) {
+    let t = term.split('/')
+    nums.push(parseInt(t[0]))
+    dens.push(parseInt(t[1]))
+  }
+  const lcm = LCM(dens)
+  const numSum = nums.reduce(
+    (sum, num, i) => sum + ((+(ops[i] === '+') || -1) * num * lcm) / dens[i],
+    0
+  )
+  const gcd = Math.abs(GCD(numSum, lcm))
+  return numSum / gcd + '/' + lcm / gcd
+}
+
+function LCM(arr) {
+  let res = arr[0]
+  for (let i = 1; i < arr.length; i++) {
+    res = (arr[i] * res) / GCD(arr[i], res)
+  }
+  return res
+}
+
+function GCD(a, b) {
+  if (b === 0) return a
+  return GCD(b, a % b)
+}

From 1696c9da04f36622940db1df067f26d5b51dd769 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Apr 2020 12:16:54 +0800
Subject: [PATCH 0438/3374] Create
 597-friend-requests-i-overall-acceptance-rate.sql

---
 597-friend-requests-i-overall-acceptance-rate.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 597-friend-requests-i-overall-acceptance-rate.sql

diff --git a/597-friend-requests-i-overall-acceptance-rate.sql b/597-friend-requests-i-overall-acceptance-rate.sql
new file mode 100644
index 00000000..8f0e1e47
--- /dev/null
+++ b/597-friend-requests-i-overall-acceptance-rate.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+select round(ifnull(
+  (select count(*) from (select distinct requester_id, accepter_id from request_accepted) as a)
+  /
+  (select count(*) from (select distinct sender_id, send_to_id from friend_request) as b)    
+  ,0),2) as accept_rate;

From a68c9bf443e393d5d5d10add04ebc2bf6ddf38bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Apr 2020 12:58:57 +0800
Subject: [PATCH 0439/3374] Create 598-range-addition-ii.js

---
 598-range-addition-ii.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 598-range-addition-ii.js

diff --git a/598-range-addition-ii.js b/598-range-addition-ii.js
new file mode 100644
index 00000000..7d95a8a1
--- /dev/null
+++ b/598-range-addition-ii.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} ops
+ * @return {number}
+ */
+const maxCount = function (m, n, ops) {
+  for (let i = 0, len = ops.length; i < len; i++) {
+    if (ops[i][0] < m) m = ops[i][0]
+    if (ops[i][1] < n) n = ops[i][1]
+  }
+  return m * n
+}

From 1559ff1ba28eb4a8a635413b258612cda15dda11 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Apr 2020 13:22:19 +0800
Subject: [PATCH 0440/3374] Create
 600-non-negative-integers-without-consecutive-ones.js

---
 ...ative-integers-without-consecutive-ones.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 600-non-negative-integers-without-consecutive-ones.js

diff --git a/600-non-negative-integers-without-consecutive-ones.js b/600-non-negative-integers-without-consecutive-ones.js
new file mode 100644
index 00000000..36c61434
--- /dev/null
+++ b/600-non-negative-integers-without-consecutive-ones.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+const findIntegers = function (num) {
+  const binary = num.toString(2)
+  const fibonacci = [1, 2]
+  for (let i = 2; i < binary.length; ++i) {
+    fibonacci.push(fibonacci[i - 2] + fibonacci[i - 1])
+  }
+  let answer = binary.indexOf('11') === -1 ? 1 : 0
+  for (let i = 0; i < binary.length; ++i) {
+    if (binary[i] === '1') {
+      answer += fibonacci[binary.length - 1 - i]
+      if (binary[i - 1] === '1') {
+        break
+      }
+    }
+  }
+  return answer
+}

From c01d026221af7c665b087de17bde1a3cb48f0b7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 13:19:20 +0800
Subject: [PATCH 0441/3374] Create 601-human-traffic-of-stadium.sql

---
 601-human-traffic-of-stadium.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 601-human-traffic-of-stadium.sql

diff --git a/601-human-traffic-of-stadium.sql b/601-human-traffic-of-stadium.sql
new file mode 100644
index 00000000..628b0024
--- /dev/null
+++ b/601-human-traffic-of-stadium.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+select distinct s1.* from stadium as s1, stadium as s2, stadium as s3
+where
+    ((s1.id + 1 = s2.id and s1.id + 2 = s3.id)
+    or (s1.id - 1 = s2.id and s1.id + 1 = s3.id)
+    or (s1.id - 2 = s2.id and s1.id - 1 = s3.id))
+    and s1.people >= 100 and s2.people >= 100 and s3.people >= 100
+order by s1.id;

From e25c841cb3995bb46d6256e6306c844a8a8ebeeb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 13:29:10 +0800
Subject: [PATCH 0442/3374] Create
 602-friend-requests-ii-who-has-the-most-friends.sql

---
 602-friend-requests-ii-who-has-the-most-friends.sql | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 602-friend-requests-ii-who-has-the-most-friends.sql

diff --git a/602-friend-requests-ii-who-has-the-most-friends.sql b/602-friend-requests-ii-who-has-the-most-friends.sql
new file mode 100644
index 00000000..06ee877f
--- /dev/null
+++ b/602-friend-requests-ii-who-has-the-most-friends.sql
@@ -0,0 +1,11 @@
+# Write your MySQL query statement below
+select id1 as id, count(id2) as num
+from
+(select requester_id as id1, accepter_id as id2 
+from request_accepted
+union
+select accepter_id as id1, requester_id as id2 
+from request_accepted) tmp1
+group by id1 
+order by num desc
+limit 1;

From 853cd30ac62e503fa040660b9c21056d36153aec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 13:41:13 +0800
Subject: [PATCH 0443/3374] Create 603-consecutive-available-seats.sql

---
 603-consecutive-available-seats.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 603-consecutive-available-seats.sql

diff --git a/603-consecutive-available-seats.sql b/603-consecutive-available-seats.sql
new file mode 100644
index 00000000..0f06e5e3
--- /dev/null
+++ b/603-consecutive-available-seats.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+select distinct a.seat_id 
+from cinema a
+left join cinema b on a.seat_id = b.seat_id - 1 or a.seat_id = b.seat_id + 1
+where a.free = 1 and b.free = 1;

From 96ade0f1e117a0a2afd7e2aaa837843ac029523c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 14:09:40 +0800
Subject: [PATCH 0444/3374] Create 604-design-compressed-string-iterator.js

---
 604-design-compressed-string-iterator.js | 38 ++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 604-design-compressed-string-iterator.js

diff --git a/604-design-compressed-string-iterator.js b/604-design-compressed-string-iterator.js
new file mode 100644
index 00000000..3cbe0a42
--- /dev/null
+++ b/604-design-compressed-string-iterator.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string} compressedString
+ */
+const StringIterator = function(compressedString) {
+  const s = compressedString.replace(/[a-zA-Z]/g,'-')
+  const ss = compressedString.replace(/[0-9]+/g, '-')
+  const sa = s.split('-').filter(e => !!e).map(e => +e)
+  const ssa = ss.split('-').filter(e => !!e)
+  this.idx = 0
+  this.charArr = ssa
+  this.numArr = sa
+};
+
+/**
+ * @return {character}
+ */
+StringIterator.prototype.next = function() {
+  let res = ' '
+  if(this.idx >= this.numArr.length) return res
+  if(this.numArr[this.idx]) res = this.charArr[this.idx]
+  this.numArr[this.idx]--
+  if(this.numArr[this.idx] === 0) this.idx++
+  return res
+};
+
+/**
+ * @return {boolean}
+ */
+StringIterator.prototype.hasNext = function() {
+  return this.numArr[this.idx] > 0
+};
+
+/** 
+ * Your StringIterator object will be instantiated and called as such:
+ * var obj = new StringIterator(compressedString)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */

From 576e6cd4d4da2048b9d7ee3139533e45d9b32eca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 14:20:36 +0800
Subject: [PATCH 0445/3374] Create 608-tree-node.sql

---
 608-tree-node.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 608-tree-node.sql

diff --git a/608-tree-node.sql b/608-tree-node.sql
new file mode 100644
index 00000000..c7ec6a9e
--- /dev/null
+++ b/608-tree-node.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+select distinct
+  t1.id, 
+  case when t1.p_id is NULL then 'Root'
+    when t2.id is NULL then 'Leaf'
+    else 'Inner' 
+  end as Type
+from tree t1 left join tree t2 on t1.id = t2.p_id;

From b9b83fe7fd764cf77b62129357b546880aa27f9f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 17:37:02 +0800
Subject: [PATCH 0446/3374] Create 609-find-duplicate-file-in-system.js

---
 609-find-duplicate-file-in-system.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 609-find-duplicate-file-in-system.js

diff --git a/609-find-duplicate-file-in-system.js b/609-find-duplicate-file-in-system.js
new file mode 100644
index 00000000..0f8bcbac
--- /dev/null
+++ b/609-find-duplicate-file-in-system.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string[]} paths
+ * @return {string[][]}
+ */
+const findDuplicate = function (paths) {
+  const map = {}
+  for (let text of paths) {
+    for (let i = 1, files = text.split(' '); i < files.length; i++) {
+      const paren = files[i].indexOf('(')
+      const content = files[i].substring(paren + 1, files[i].length - 1)
+      map[content] = map[content] || []
+      map[content].push(files[0] + '/' + files[i].substr(0, paren))
+    }
+  }
+  return Object.values(map).filter((dups) => dups.length > 1)
+}

From a7deff5e65bb5b898bb1c4cd85b94ceb73e80558 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 17:53:27 +0800
Subject: [PATCH 0447/3374] Create 610-triangle-judgement.sql

---
 610-triangle-judgement.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 610-triangle-judgement.sql

diff --git a/610-triangle-judgement.sql b/610-triangle-judgement.sql
new file mode 100644
index 00000000..9c5c9cf6
--- /dev/null
+++ b/610-triangle-judgement.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT x
+     , y
+     , z
+     , CASE WHEN 
+            x + y > z AND x + z > y AND y + z > x THEN 'Yes'
+            ELSE 'No'
+       END AS triangle
+  FROM triangle;

From 64541a228d248fda48cebf27ad2e05794042677f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 21:26:03 +0800
Subject: [PATCH 0448/3374] Create 612-shortest-distance-in-a-plane.sql

---
 612-shortest-distance-in-a-plane.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 612-shortest-distance-in-a-plane.sql

diff --git a/612-shortest-distance-in-a-plane.sql b/612-shortest-distance-in-a-plane.sql
new file mode 100644
index 00000000..8cedcf8f
--- /dev/null
+++ b/612-shortest-distance-in-a-plane.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+select round(sqrt(min(pow(a.x-b.x,2) + pow(a.y-b.y,2))), 2) shortest
+from point_2d a, point_2d b
+where (a.x,a.y) != (b.x,b.y);

From b41cc2af802437c3950f60dafc2fa33bf47e84ed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 21:31:38 +0800
Subject: [PATCH 0449/3374] Create 613-shortest-distance-in-a-line.sql

---
 613-shortest-distance-in-a-line.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 613-shortest-distance-in-a-line.sql

diff --git a/613-shortest-distance-in-a-line.sql b/613-shortest-distance-in-a-line.sql
new file mode 100644
index 00000000..c6a56425
--- /dev/null
+++ b/613-shortest-distance-in-a-line.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+select min(abs(t1.x-t2.x)) as shortest
+from point as t1
+join point as t2
+on t1.x != t2.x;

From d40029f1b6dc9ee86cb75f0440b74d14b91d7144 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 21:40:04 +0800
Subject: [PATCH 0450/3374] Create 614-second-degree-follower.sql

---
 614-second-degree-follower.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 614-second-degree-follower.sql

diff --git a/614-second-degree-follower.sql b/614-second-degree-follower.sql
new file mode 100644
index 00000000..d171a2cd
--- /dev/null
+++ b/614-second-degree-follower.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+SELECT 
+    followee AS follower, 
+    COUNT(DISTINCT follower) AS num
+FROM follow
+WHERE followee IN (SELECT follower FROM follow)
+GROUP BY followee
+ORDER BY followee;

From f98fda8c97c08e96e754991ac2a8700a0c7ea946 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 21:48:48 +0800
Subject: [PATCH 0451/3374] Update 614-second-degree-follower.sql

---
 614-second-degree-follower.sql | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/614-second-degree-follower.sql b/614-second-degree-follower.sql
index d171a2cd..191777de 100644
--- a/614-second-degree-follower.sql
+++ b/614-second-degree-follower.sql
@@ -6,3 +6,12 @@ FROM follow
 WHERE followee IN (SELECT follower FROM follow)
 GROUP BY followee
 ORDER BY followee;
+
+# another
+
+select distinct follower, num
+from follow, 
+(select followee, count(distinct follower) as num from follow 
+group by followee) as t
+where follower = t.followee
+order by follower;

From 2f7fff37b72d726b0d50a7eafb07483eb60e61af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 21:57:48 +0800
Subject: [PATCH 0452/3374] Create
 615-average-salary-departments-vs-company.sql

---
 615-average-salary-departments-vs-company.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 615-average-salary-departments-vs-company.sql

diff --git a/615-average-salary-departments-vs-company.sql b/615-average-salary-departments-vs-company.sql
new file mode 100644
index 00000000..28a8a6c8
--- /dev/null
+++ b/615-average-salary-departments-vs-company.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT d1.pay_month, d1.department_id, 
+CASE WHEN d1.department_avg > c1.company_avg THEN 'higher'
+  WHEN d1.department_avg < c1.company_avg THEN 'lower'
+  ELSE 'same'
+END AS 'comparison'
+FROM ((SELECT LEFT(s1.pay_date, 7) pay_month, e1.department_id, AVG(s1.amount) department_avg
+FROM salary s1
+JOIN employee e1 ON s1.employee_id = e1.employee_id
+GROUP BY pay_month, e1.department_id) d1
+LEFT JOIN (SELECT LEFT(pay_date, 7) pay_month, AVG(amount) company_avg
+FROM salary
+GROUP BY pay_month) c1 ON d1.pay_month = c1.pay_month)
+ORDER BY pay_month DESC, department_id;

From 2bcb491e094ed295657c9accdeaa044db3693700 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Apr 2020 22:46:45 +0800
Subject: [PATCH 0453/3374] Create 616-add-bold-tag-in-string.js

---
 616-add-bold-tag-in-string.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 616-add-bold-tag-in-string.js

diff --git a/616-add-bold-tag-in-string.js b/616-add-bold-tag-in-string.js
new file mode 100644
index 00000000..c06d70ac
--- /dev/null
+++ b/616-add-bold-tag-in-string.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string[]} dict
+ * @return {string}
+ */
+const addBoldTag = function (s, dict) {
+  const bold = new Array(s.length)
+  for (let sub of dict) {
+    let found = -1
+    let prevBold = 0
+    while ((found = s.indexOf(sub, found + 1)) !== -1) {
+      for (let i = Math.max(prevBold, found); i < found + sub.length; i++) {
+        bold[i] = 1
+      }
+      prevBold = found + sub.length
+    }
+  }
+  let res = ''
+  let open = false
+  for (let i = 0; i < s.length; i++) {
+    if (bold[i] && !open) {
+      open = true
+      res += '<b>'
+    } else if (!bold[i] && open) {
+      open = false
+      res += '</b>'
+    }
+    res += s[i]
+  }
+  return open ? res + '</b>' : res
+}

From 0e1c3b0b3c327e9f8c8e64448a90404585ce13d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 09:54:43 +0800
Subject: [PATCH 0454/3374] Create 618-students-report-by-geography.sql

---
 618-students-report-by-geography.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 618-students-report-by-geography.sql

diff --git a/618-students-report-by-geography.sql b/618-students-report-by-geography.sql
new file mode 100644
index 00000000..252089ee
--- /dev/null
+++ b/618-students-report-by-geography.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT MAX(America) AS America, MAX(Asia) as Asia, MAX(Europe) AS Europe
+FROM (
+  SELECT 
+    CASE WHEN continent = 'America' THEN @r1 := @r1 + 1
+         WHEN continent = 'Asia'    THEN @r2 := @r2 + 1
+         WHEN continent = 'Europe'  THEN @r3 := @r3 + 1 END row_id,
+    CASE WHEN continent = 'America' THEN name END America,
+    CASE WHEN continent = 'Asia'    THEN name END Asia,
+    CASE WHEN continent = 'Europe'  THEN name END Europe
+  FROM student, (SELECT @r1 := 0, @r2 := 0, @r3 := 0) AS row_id
+  ORDER BY name
+) t
+GROUP BY row_id;

From 6887695eac95bdd24e56f3e17dc6e8f3d0e4fbe3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 11:02:03 +0800
Subject: [PATCH 0455/3374] Create 619-biggest-single-number.sql

---
 619-biggest-single-number.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 619-biggest-single-number.sql

diff --git a/619-biggest-single-number.sql b/619-biggest-single-number.sql
new file mode 100644
index 00000000..978912d9
--- /dev/null
+++ b/619-biggest-single-number.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+select(
+  select num
+  from my_numbers
+  group by num
+  having count(*) = 1
+  order by num desc limit 1
+) as num;

From 01cb6cd2de5fb822d996c46c2c0410b721b89c1a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 11:55:25 +0800
Subject: [PATCH 0456/3374] Create 622-design-circular-queue.js

---
 622-design-circular-queue.js | 79 ++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 622-design-circular-queue.js

diff --git a/622-design-circular-queue.js b/622-design-circular-queue.js
new file mode 100644
index 00000000..2575fa4a
--- /dev/null
+++ b/622-design-circular-queue.js
@@ -0,0 +1,79 @@
+/**
+ * Initialize your data structure here. Set the size of the queue to be k.
+ * @param {number} k
+ */
+const MyCircularQueue = function(k) {
+  this.a = new Array(k).fill(0)
+  this.front = 0
+  this.rear = -1
+  this.len = 0
+};
+
+/**
+ * Insert an element into the circular queue. Return true if the operation is successful. 
+ * @param {number} value
+ * @return {boolean}
+ */
+MyCircularQueue.prototype.enQueue = function(value) {
+  if (!this.isFull()) {
+    this.rear = (this.rear + 1) % this.a.length;
+    this.a[this.rear] = value;
+    this.len++;
+    return true;
+  } else return false;
+};
+
+/**
+ * Delete an element from the circular queue. Return true if the operation is successful.
+ * @return {boolean}
+ */
+MyCircularQueue.prototype.deQueue = function() {
+  if (!this.isEmpty()) {
+      this.front = (this.front + 1) % this.a.length;
+      this.len--;
+      return true;
+  } else return false;
+};
+
+/**
+ * Get the front item from the queue.
+ * @return {number}
+ */
+MyCircularQueue.prototype.Front = function() {
+  return this.isEmpty() ? -1 : this.a[this.front];  
+};
+
+/**
+ * Get the last item from the queue.
+ * @return {number}
+ */
+MyCircularQueue.prototype.Rear = function() {
+  return this.isEmpty() ? -1 : this.a[this.rear];
+};
+
+/**
+ * Checks whether the circular queue is empty or not.
+ * @return {boolean}
+ */
+MyCircularQueue.prototype.isEmpty = function() {
+  return this.len === 0;  
+};
+
+/**
+ * Checks whether the circular queue is full or not.
+ * @return {boolean}
+ */
+MyCircularQueue.prototype.isFull = function() {
+  return this.len == this.a.length;
+};
+
+/** 
+ * Your MyCircularQueue object will be instantiated and called as such:
+ * var obj = new MyCircularQueue(k)
+ * var param_1 = obj.enQueue(value)
+ * var param_2 = obj.deQueue()
+ * var param_3 = obj.Front()
+ * var param_4 = obj.Rear()
+ * var param_5 = obj.isEmpty()
+ * var param_6 = obj.isFull()
+ */

From e418ad1bf7f48e687837d9cc4122c6021eaeaf7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 11:58:06 +0800
Subject: [PATCH 0457/3374] Update 622-design-circular-queue.js

---
 622-design-circular-queue.js | 58 ++++++++++++++++++------------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/622-design-circular-queue.js b/622-design-circular-queue.js
index 2575fa4a..668cd4ff 100644
--- a/622-design-circular-queue.js
+++ b/622-design-circular-queue.js
@@ -2,72 +2,72 @@
  * Initialize your data structure here. Set the size of the queue to be k.
  * @param {number} k
  */
-const MyCircularQueue = function(k) {
+const MyCircularQueue = function (k) {
   this.a = new Array(k).fill(0)
   this.front = 0
   this.rear = -1
   this.len = 0
-};
+}
 
 /**
- * Insert an element into the circular queue. Return true if the operation is successful. 
+ * Insert an element into the circular queue. Return true if the operation is successful.
  * @param {number} value
  * @return {boolean}
  */
-MyCircularQueue.prototype.enQueue = function(value) {
+MyCircularQueue.prototype.enQueue = function (value) {
   if (!this.isFull()) {
-    this.rear = (this.rear + 1) % this.a.length;
-    this.a[this.rear] = value;
-    this.len++;
-    return true;
-  } else return false;
-};
+    this.rear = (this.rear + 1) % this.a.length
+    this.a[this.rear] = value
+    this.len++
+    return true
+  } else return false
+}
 
 /**
  * Delete an element from the circular queue. Return true if the operation is successful.
  * @return {boolean}
  */
-MyCircularQueue.prototype.deQueue = function() {
+MyCircularQueue.prototype.deQueue = function () {
   if (!this.isEmpty()) {
-      this.front = (this.front + 1) % this.a.length;
-      this.len--;
-      return true;
-  } else return false;
-};
+    this.front = (this.front + 1) % this.a.length
+    this.len--
+    return true
+  } else return false
+}
 
 /**
  * Get the front item from the queue.
  * @return {number}
  */
-MyCircularQueue.prototype.Front = function() {
-  return this.isEmpty() ? -1 : this.a[this.front];  
-};
+MyCircularQueue.prototype.Front = function () {
+  return this.isEmpty() ? -1 : this.a[this.front]
+}
 
 /**
  * Get the last item from the queue.
  * @return {number}
  */
-MyCircularQueue.prototype.Rear = function() {
-  return this.isEmpty() ? -1 : this.a[this.rear];
-};
+MyCircularQueue.prototype.Rear = function () {
+  return this.isEmpty() ? -1 : this.a[this.rear]
+}
 
 /**
  * Checks whether the circular queue is empty or not.
  * @return {boolean}
  */
-MyCircularQueue.prototype.isEmpty = function() {
-  return this.len === 0;  
-};
+MyCircularQueue.prototype.isEmpty = function () {
+  return this.len === 0
+}
 
 /**
  * Checks whether the circular queue is full or not.
  * @return {boolean}
  */
-MyCircularQueue.prototype.isFull = function() {
-  return this.len == this.a.length;
-};
+MyCircularQueue.prototype.isFull = function () {
+  return this.len == this.a.length
+}
 
-/** 
+/**
  * Your MyCircularQueue object will be instantiated and called as such:
  * var obj = new MyCircularQueue(k)
  * var param_1 = obj.enQueue(value)

From ab4bafc244c81555389ac4a140e605b800d9ab2c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 19:26:44 +0800
Subject: [PATCH 0458/3374] Create 623-add-one-row-to-tree.js

---
 623-add-one-row-to-tree.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 623-add-one-row-to-tree.js

diff --git a/623-add-one-row-to-tree.js b/623-add-one-row-to-tree.js
new file mode 100644
index 00000000..86f38b34
--- /dev/null
+++ b/623-add-one-row-to-tree.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} v
+ * @param {number} d
+ * @return {TreeNode}
+ */
+const addOneRow = function (root, v, d, level = 1) {
+  if (!root) return
+  if (d === 1) {
+    const newRoot = new TreeNode(v)
+    newRoot.left = root
+    return newRoot
+  } else if (d === level + 1) {
+    const oldLeft = root.left
+    const oldRight = root.right
+    root.left = new TreeNode(v)
+    root.right = new TreeNode(v)
+    root.left.left = oldLeft
+    root.right.right = oldRight
+  } else {
+    addOneRow(root.left, v, d, level + 1)
+    addOneRow(root.right, v, d, level + 1)
+  }
+  return root
+}

From 7f7ca830c3528b937f09e3ef55e50c19e28d2613 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 19:44:35 +0800
Subject: [PATCH 0459/3374] Update 623-add-one-row-to-tree.js

---
 623-add-one-row-to-tree.js | 49 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/623-add-one-row-to-tree.js b/623-add-one-row-to-tree.js
index 86f38b34..1ce663de 100644
--- a/623-add-one-row-to-tree.js
+++ b/623-add-one-row-to-tree.js
@@ -1,3 +1,52 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} v
+ * @param {number} d
+ * @return {TreeNode}
+ */
+const addOneRow = function (root, v, d, level = 1) {
+  if (d === 1) {
+    const node = new TreeNode(v)
+    node.left = root
+    return node
+  }
+  const queue = []
+  queue.push(root)
+  let depth = 1
+  while (queue.length) {
+    const size = queue.length
+    for (let i = 0; i < size; i++) {
+      const cur = queue.shift()
+      if (depth === d - 1) {
+        let left = new TreeNode(v)
+        let right = new TreeNode(v)
+        left.left = cur.left
+        right.right = cur.right
+        cur.left = left
+        cur.right = right
+      } else {
+        if (cur.left !== null) {
+          queue.push(cur.left)
+        }
+        if (cur.right !== null) {
+          queue.push(cur.right)
+        }
+      }
+    }
+    depth++
+  }
+  return root
+}
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From bdbf4af218f016520a136556e08bea460d59679d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 22:04:32 +0800
Subject: [PATCH 0460/3374] Create 625-minimum-factorization.js

---
 625-minimum-factorization.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 625-minimum-factorization.js

diff --git a/625-minimum-factorization.js b/625-minimum-factorization.js
new file mode 100644
index 00000000..95df687e
--- /dev/null
+++ b/625-minimum-factorization.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} a
+ * @return {number}
+ */
+const smallestFactorization = function (a) {
+  if (a < 2) return a
+  let MAX_INT = 2 ** 31 - 1,
+    res = 0,
+    mul = 1
+  for (let i = 9; i >= 2; i--) {
+    while (a % i === 0) {
+      a /= i
+      res = mul * i + res
+      mul *= 10
+    }
+  }
+  return a < 2 && res <= MAX_INT ? res : 0
+}

From 8c85558f53e3c8d2f77d00af8291b4f65c0a8f22 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 23:32:35 +0800
Subject: [PATCH 0461/3374] Create 628-maximum-product-of-three-numbers.js

---
 628-maximum-product-of-three-numbers.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 628-maximum-product-of-three-numbers.js

diff --git a/628-maximum-product-of-three-numbers.js b/628-maximum-product-of-three-numbers.js
new file mode 100644
index 00000000..3c4cab58
--- /dev/null
+++ b/628-maximum-product-of-three-numbers.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumProduct = function (nums) {
+  nums.sort((a, b) => a - b)
+  return Math.max(
+    nums[0] * nums[1] * nums[nums.length - 1],
+    nums[nums.length - 1] * nums[nums.length - 2] * nums[nums.length - 3]
+  )
+}

From a5880c9678a9ce387d2566cdd36a37abdc5ce03e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 23:34:00 +0800
Subject: [PATCH 0462/3374] Update 628-maximum-product-of-three-numbers.js

---
 628-maximum-product-of-three-numbers.js | 34 +++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/628-maximum-product-of-three-numbers.js b/628-maximum-product-of-three-numbers.js
index 3c4cab58..d801ee9f 100644
--- a/628-maximum-product-of-three-numbers.js
+++ b/628-maximum-product-of-three-numbers.js
@@ -9,3 +9,37 @@ const maximumProduct = function (nums) {
     nums[nums.length - 1] * nums[nums.length - 2] * nums[nums.length - 3]
   )
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumProduct = function (nums) {
+  let max1 = -Infinity
+  let max2 = -Infinity
+  let max3 = -Infinity
+  let min1 = Infinity
+  let min2 = Infinity
+  for (let num of nums) {
+    if (num > max1) {
+      max3 = max2
+      max2 = max1
+      max1 = num
+    } else if (num > max2) {
+      max3 = max2
+      max2 = num
+    } else if (num > max3) {
+      max3 = num
+    }
+
+    if (num < min1) {
+      min2 = min1
+      min1 = num
+    } else if (num < min2) {
+      min2 = num
+    }
+  }
+  return Math.max(max1 * max2 * max3, max1 * min1 * min2)
+}

From 94fa8381f663f1faa3d5d505219646de45a7ea48 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Apr 2020 23:37:50 +0800
Subject: [PATCH 0463/3374] Create 627-swap-salary.sql

---
 627-swap-salary.sql | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 627-swap-salary.sql

diff --git a/627-swap-salary.sql b/627-swap-salary.sql
new file mode 100644
index 00000000..317dd008
--- /dev/null
+++ b/627-swap-salary.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+UPDATE salary SET sex = IF(sex='m','f','m');

From 1872d8449fc6ab108828d027c18bc1419cc4599d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Apr 2020 12:00:34 +0800
Subject: [PATCH 0464/3374] Create 630-course-schedule-iii.js

---
 630-course-schedule-iii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 630-course-schedule-iii.js

diff --git a/630-course-schedule-iii.js b/630-course-schedule-iii.js
new file mode 100644
index 00000000..fa7ffdaa
--- /dev/null
+++ b/630-course-schedule-iii.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} courses
+ * @return {number}
+ */
+const scheduleCourse = function (courses) {
+  courses.sort((c1, c2) => c1[1] - c2[1])
+  let count = 0
+  let time = 0
+  const queue = []
+  const inQueue = (val) => {
+    let i = 0
+    while (i < queue.length && queue[i] > val) i += 1
+    queue.splice(i, 0, val)
+  }
+  for (let i = 0; i < courses.length; i += 1) {
+    const [dur, end] = courses[i]
+    if (time <= end - dur) {
+      count += 1
+      time += dur
+      inQueue(dur)
+    } else if (queue.length && queue[0] > dur) {
+      time = time - queue.shift() + dur
+      inQueue(dur)
+    }
+  }
+  return count
+}

From 213b5b6ed9eebe1323aeef5cb16c92cffb23e40d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Apr 2020 12:55:58 +0800
Subject: [PATCH 0465/3374] Update 630-course-schedule-iii.js

---
 630-course-schedule-iii.js | 86 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/630-course-schedule-iii.js b/630-course-schedule-iii.js
index fa7ffdaa..824fca51 100644
--- a/630-course-schedule-iii.js
+++ b/630-course-schedule-iii.js
@@ -25,3 +25,89 @@ const scheduleCourse = function (courses) {
   }
   return count
 }
+
+// another
+
+/**
+ * @param {number[][]} courses
+ * @return {number}
+ */
+const scheduleCourse = function (courses) {
+  courses.sort((a, b) => +a[1] - +b[1])
+  let queue = new Heap()
+  let time = 0
+  for (let c of courses) {
+    if (c[0] + time <= c[1]) {
+      time += c[0]
+      queue.push(c[0])
+    } else if (queue.size() > 0) {
+      let top = queue.peek()
+      if (top > c[0]) {
+        queue.pop()
+        queue.push(c[0])
+        time += c[0] - top
+      }
+    }
+  }
+  return queue.size()
+}
+
+const parent = (i) => Math.floor((i - 1) / 2)
+const left = (i) => 2 * i + 1
+const right = (i) => 2 * i + 2
+class Heap {
+  constructor() {
+    this.compare = (a, b) => +b - +a
+    this._heap = []
+  }
+  size() {
+    return this._heap.length
+  }
+  _upper(i, j) {
+    return this.compare(this._heap[i], this._heap[j]) < 0
+  }
+  _swap(i, j) {
+    let tmp = this._heap[i]
+    this._heap[i] = this._heap[j]
+    this._heap[j] = tmp
+  }
+  push(item) {
+    this._heap.push(item)
+    this._siftUp()
+    return this.size()
+  }
+  _siftUp() {
+    let node = this._heap.length - 1
+    while (node > 0 && this._upper(node, parent(node))) {
+      this._swap(node, parent(node))
+      node = parent(node)
+    }
+  }
+  peek() {
+    return this._heap[0]
+  }
+  pop() {
+    let ret = this._heap[0]
+    if (this.size() > 1) {
+      this._swap(0, this._heap.length - 1)
+    }
+    this._heap.pop()
+    this._siftDown()
+    return ret
+  }
+  _siftDown() {
+    let node = 0
+    while (
+      (right(node) < this.size() && this._upper(right(node), node)) ||
+      (left(node) < this.size() && this._upper(left(node), node))
+    ) {
+      let upperChild =
+        right(node) < this.size() && this._upper(right(node), left(node))
+          ? right(node)
+          : left(node)
+      this._swap(upperChild, node)
+      node = upperChild
+    }
+  }
+}
+

From c4ffb0bb51c8cf1e9c814167065fe20fade30d93 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Apr 2020 23:12:29 +0800
Subject: [PATCH 0466/3374] Create 631-design-excel-sum-formula.js

---
 631-design-excel-sum-formula.js | 81 +++++++++++++++++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 631-design-excel-sum-formula.js

diff --git a/631-design-excel-sum-formula.js b/631-design-excel-sum-formula.js
new file mode 100644
index 00000000..09c5f234
--- /dev/null
+++ b/631-design-excel-sum-formula.js
@@ -0,0 +1,81 @@
+/**
+ * @param {number} H
+ * @param {character} W
+ */
+const Excel = function (H, W) {
+  this.W = W.charCodeAt(0) - 'A'.charCodeAt(0) + 1
+  this.H = H
+  this.map = {}
+  this.mat = []
+  for (let i = 0; i < this.H; i++) {
+    this.mat[i] = new Array(this.W).fill(0)
+  }
+  return
+}
+
+/**
+ * @param {number} r
+ * @param {character} c
+ * @param {number} v
+ * @return {void}
+ */
+Excel.prototype.set = function (r, c, v) {
+  let row = r - 1
+  let col = c.charCodeAt(0) - 'A'.charCodeAt(0)
+  if (this.map[r + ':' + c]) delete this.map[r + ':' + c]
+  this.mat[row][col] = v
+}
+/**
+ * @param {number} r
+ * @param {character} c
+ * @return {number}
+ */
+Excel.prototype.get = function (r, c) {
+  let row = r - 1
+  let col = c.charCodeAt(0) - 'A'.charCodeAt(0)
+  if (this.map[r + ':' + c] !== undefined)
+    return this.sum(r, c, this.map[r + ':' + c])
+  return this.mat[row][col]
+}
+
+/**
+ * @param {number} r
+ * @param {character} c
+ * @param {string[]} strs
+ * @return {number}
+ */
+Excel.prototype.sum = function (r, c, strs) {
+  let sum = 0
+  for (let str of strs) {
+    if (str.indexOf(':') < 0) {
+      sum += this.get(+str.substring(1), str[0])
+    } else {
+      let [r1, c1, r2, c2] = this.getRange(str.split(':'))
+      for (let i = r1; i <= r2; i++) {
+        for (let j = c1; j <= c2; j++) {
+          sum += this.get(i + 1, String.fromCharCode(j + 'A'.charCodeAt(0)))
+        }
+      }
+    }
+  }
+  this.map[r + ':' + c] = strs
+  return sum
+}
+
+Excel.prototype.getRange = function (arr) {
+  let p1 = arr[0],
+    p2 = arr[1]
+  let c1 = p1[0].charCodeAt(0) - 'A'.charCodeAt(0)
+  let r1 = +p1.substring(1) - 1
+  let c2 = p2[0].charCodeAt(0) - 'A'.charCodeAt(0)
+  let r2 = +p2.substring(1) - 1
+  return [r1, c1, r2, c2]
+}
+
+/**
+ * Your Excel object will be instantiated and called as such:
+ * var obj = Object.create(Excel).createNew(H, W)
+ * obj.set(r,c,v)
+ * var param_2 = obj.get(r,c)
+ * var param_3 = obj.sum(r,c,strs)
+ */

From a77278a7ba19807e7afc06c083f5cc18b2c88b42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Apr 2020 15:32:34 +0800
Subject: [PATCH 0467/3374] Create 122-best-time-to-buy-and-sell-stock-ii.js

---
 122-best-time-to-buy-and-sell-stock-ii.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 122-best-time-to-buy-and-sell-stock-ii.js

diff --git a/122-best-time-to-buy-and-sell-stock-ii.js b/122-best-time-to-buy-and-sell-stock-ii.js
new file mode 100644
index 00000000..20ced781
--- /dev/null
+++ b/122-best-time-to-buy-and-sell-stock-ii.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+const maxProfit = function (prices) {
+  let p = 0
+  for (let i = 1; i < prices.length; ++i) {
+    let delta = prices[i] - prices[i - 1]
+    if (delta > 0) {
+      p += delta
+    }
+  }
+  return p
+}

From 0fa813fa4adf7493175698e4139827a93b0db082 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Apr 2020 15:58:11 +0800
Subject: [PATCH 0468/3374] Update 631-design-excel-sum-formula.js

---
 631-design-excel-sum-formula.js | 88 +++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/631-design-excel-sum-formula.js b/631-design-excel-sum-formula.js
index 09c5f234..ad7db1f9 100644
--- a/631-design-excel-sum-formula.js
+++ b/631-design-excel-sum-formula.js
@@ -79,3 +79,91 @@ Excel.prototype.getRange = function (arr) {
  * var param_2 = obj.get(r,c)
  * var param_3 = obj.sum(r,c,strs)
  */
+
+
+// another
+
+/**
+ * @param {number} H
+ * @param {character} W
+ */
+const Excel = function (H, W) {
+  this.data = []
+  for (let i = 1; i <= H; i++) {
+    this.data[i] = []
+    for (let j = 1; j <= this.col(W); j++) {
+      this.data[i][j] = 0
+    }
+  }
+}
+
+Excel.prototype.col = function (c) {
+  return c.charCodeAt() - 'A'.charCodeAt() + 1
+}
+
+Excel.prototype.parse = function (str) {
+  let idx = str.indexOf(':')
+  if (idx === -1) return { r: Number(str.slice(1)), c: str[0] }
+  let topLeft = str.slice(0, idx),
+    bottomRight = str.slice(idx + 1)
+  return [
+    { r: Number(topLeft.slice(1)), c: topLeft[0] },
+    { r: Number(bottomRight.slice(1)), c: bottomRight[0] },
+  ]
+}
+
+/**
+ * @param {number} r
+ * @param {character} c
+ * @param {number} v
+ * @return {void}
+ */
+Excel.prototype.set = function (r, c, v) {
+  this.data[r][this.col(c)] = v
+}
+
+/**
+ * @param {number} r
+ * @param {character} c
+ * @return {number}
+ */
+Excel.prototype.get = function (r, c) {
+  if (Array.isArray(this.data[r][this.col(c)])) {
+    let sum = 0
+    for (let str of this.data[r][this.col(c)]) {
+      let parsed = this.parse(str)
+      if (Array.isArray(parsed)) {
+        for (let i = parsed[0].r; i <= parsed[1].r; i++) {
+          for (
+            let jc = parsed[0].c;
+            jc <= parsed[1].c;
+            jc = String.fromCharCode(jc.charCodeAt() + 1)
+          ) {
+            sum += this.get(i, jc)
+          }
+        }
+      } else sum += this.get(parsed.r, parsed.c)
+    }
+    return sum
+  }
+  return this.data[r][this.col(c)]
+}
+
+/**
+ * @param {number} r
+ * @param {character} c
+ * @param {string[]} strs
+ * @return {number}
+ */
+Excel.prototype.sum = function (r, c, strs) {
+  this.set(r, c, strs)
+  return this.get(r, c)
+}
+
+/**
+ * Your Excel object will be instantiated and called as such:
+ * var obj = new Excel(H, W)
+ * obj.set(r,c,v)
+ * var param_2 = obj.get(r,c)
+ * var param_3 = obj.sum(r,c,strs)
+ */

From 200e25ea871d447c803729998f27f56f9e47a4b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Apr 2020 21:37:15 +0800
Subject: [PATCH 0469/3374] Create 634-find-the-derangement-of-an-array.js

---
 634-find-the-derangement-of-an-array.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 634-find-the-derangement-of-an-array.js

diff --git a/634-find-the-derangement-of-an-array.js b/634-find-the-derangement-of-an-array.js
new file mode 100644
index 00000000..9ad26e2f
--- /dev/null
+++ b/634-find-the-derangement-of-an-array.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const findDerangement = function (n) {
+  if ([0, 1].includes(n)) return 0
+  if (n == 2) return 1
+  let prev = 1
+  let MOD = 10 ** 9 + 7
+  let result = 0
+  for (let i = 3; i <= n; i++) {
+    result = (prev * i + (i % 2 == 1 ? -1 : 1)) % MOD
+    prev = result
+  }
+  return result
+}

From 81ced087a8fc9ac10ed1f6c1c9e92bff572bf3da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Apr 2020 22:15:20 +0800
Subject: [PATCH 0470/3374] Update 634-find-the-derangement-of-an-array.js

---
 634-find-the-derangement-of-an-array.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/634-find-the-derangement-of-an-array.js b/634-find-the-derangement-of-an-array.js
index 9ad26e2f..0a0d5e52 100644
--- a/634-find-the-derangement-of-an-array.js
+++ b/634-find-the-derangement-of-an-array.js
@@ -14,3 +14,20 @@ const findDerangement = function (n) {
   }
   return result
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const findDerangement = function (n) {
+  if (n === 0) return 0
+  const MOD = 10 ** 9 + 7
+  const dp = [1, 0]
+  for (let i = 2; i <= n; i++) {
+    dp[i] = ((i - 1) * (dp[i - 2] + dp[i - 1])) % MOD
+  }
+  return dp[n]
+}
+

From 2ac9392777e83a06f9846e4ee5817a24997811b0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Apr 2020 23:08:11 +0800
Subject: [PATCH 0471/3374] Update 634-find-the-derangement-of-an-array.js

---
 634-find-the-derangement-of-an-array.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/634-find-the-derangement-of-an-array.js b/634-find-the-derangement-of-an-array.js
index 0a0d5e52..ae7c4945 100644
--- a/634-find-the-derangement-of-an-array.js
+++ b/634-find-the-derangement-of-an-array.js
@@ -4,12 +4,12 @@
  */
 const findDerangement = function (n) {
   if ([0, 1].includes(n)) return 0
-  if (n == 2) return 1
+  if (n === 2) return 1
   let prev = 1
-  let MOD = 10 ** 9 + 7
+  const MOD = 10 ** 9 + 7
   let result = 0
   for (let i = 3; i <= n; i++) {
-    result = (prev * i + (i % 2 == 1 ? -1 : 1)) % MOD
+    result = (prev * i + (i % 2 === 1 ? -1 : 1)) % MOD
     prev = result
   }
   return result

From 01680e1072df0d2fb6d7e958feab38bac3481aab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 11:01:15 +0800
Subject: [PATCH 0472/3374] Create 636-exclusive-time-of-functions.js

---
 636-exclusive-time-of-functions.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 636-exclusive-time-of-functions.js

diff --git a/636-exclusive-time-of-functions.js b/636-exclusive-time-of-functions.js
new file mode 100644
index 00000000..5c9f06ad
--- /dev/null
+++ b/636-exclusive-time-of-functions.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {string[]} logs
+ * @return {number[]}
+ */
+const exclusiveTime = function (n, logs) {
+  const res = [...Array(n)].fill(0),
+    stack = []
+  for (let i = 0; i < logs.length; i++) {
+    const log = logs[i].split(':')
+    if (log[1] == 'start') {
+      stack.push([log[2], 0])
+    } else {
+      const start = stack.pop()
+      const time = log[2] - start[0] + 1
+      res[log[0]] += time - start[1]
+      if (stack.length > 0) {
+        stack[stack.length - 1][1] += time
+      }
+    }
+  }
+  return res
+}

From eb146962cdb6c8c739a2103a85e9b62d434051e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 12:03:39 +0800
Subject: [PATCH 0473/3374] Update 636-exclusive-time-of-functions.js

---
 636-exclusive-time-of-functions.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/636-exclusive-time-of-functions.js b/636-exclusive-time-of-functions.js
index 5c9f06ad..d2bcf0d5 100644
--- a/636-exclusive-time-of-functions.js
+++ b/636-exclusive-time-of-functions.js
@@ -4,19 +4,19 @@
  * @return {number[]}
  */
 const exclusiveTime = function (n, logs) {
-  const res = [...Array(n)].fill(0),
-    stack = []
+  const res = [...Array(n)].fill(0)
+  const stack = []
+  let pre = 0
   for (let i = 0; i < logs.length; i++) {
     const log = logs[i].split(':')
-    if (log[1] == 'start') {
-      stack.push([log[2], 0])
+    if (log[1] === 'start') {
+      if(stack.length !== 0) res[stack[stack.length - 1]] += +log[2] - pre
+      stack.push(log[0])
+      pre = log[2]
+      
     } else {
-      const start = stack.pop()
-      const time = log[2] - start[0] + 1
-      res[log[0]] += time - start[1]
-      if (stack.length > 0) {
-        stack[stack.length - 1][1] += time
-      }
+      res[stack.pop()] += +log[2] - pre + 1
+      pre = +log[2] + 1
     }
   }
   return res

From 90c9b98160cab35aab4846d76e83d0121c639229 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 12:03:52 +0800
Subject: [PATCH 0474/3374] Update 636-exclusive-time-of-functions.js

---
 636-exclusive-time-of-functions.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/636-exclusive-time-of-functions.js b/636-exclusive-time-of-functions.js
index d2bcf0d5..81663d95 100644
--- a/636-exclusive-time-of-functions.js
+++ b/636-exclusive-time-of-functions.js
@@ -13,7 +13,6 @@ const exclusiveTime = function (n, logs) {
       if(stack.length !== 0) res[stack[stack.length - 1]] += +log[2] - pre
       stack.push(log[0])
       pre = log[2]
-      
     } else {
       res[stack.pop()] += +log[2] - pre + 1
       pre = +log[2] + 1

From 84bfb21a84d9ade165432cd7afebc10bd731b776 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 16:40:43 +0800
Subject: [PATCH 0475/3374] Create 638-shopping-offers.js

---
 638-shopping-offers.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 638-shopping-offers.js

diff --git a/638-shopping-offers.js b/638-shopping-offers.js
new file mode 100644
index 00000000..9870b16c
--- /dev/null
+++ b/638-shopping-offers.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[]} price
+ * @param {number[][]} special
+ * @param {number[]} needs
+ * @return {number}
+ */
+const shoppingOffers = function (price, special, needs) {
+  const directBuy = function (price, needs) {
+    let res = 0
+    for (let i = 0; i < price.length; i++) {
+      res += price[i] * needs[i]
+    }
+    return res
+  }
+  const isValid = function (offer, needs) {
+    for (let i = 0; i < offer.length; i++) {
+      if (offer[i] > needs[i]) return false
+    }
+    return true
+  }
+  const help = (price, special, needs) => {
+    let curMin = directBuy(price, needs)
+    for (let i = 0; i < special.length; i++) {
+      let curOf = special[i]
+      if (isValid(curOf, needs)) {
+        let tem = []
+        for (let j = 0; j < needs.length; j++) {
+          tem.push(needs[j] - curOf[j])
+        }
+        if (tem.length > 0) {
+          curMin = Math.min(
+            curMin,
+            curOf[curOf.length - 1] + help(price, special, tem)
+          )
+        }
+      }
+    }
+    return curMin
+  }
+  return help(price, special, needs)
+}

From f3d54cd056f2d578a3b1692f388ab2b893b9160a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 18:19:39 +0800
Subject: [PATCH 0476/3374] Update 49-group-anagrams.js

---
 49-group-anagrams.js | 24 +++++++++++++++++++++++-
 1 file changed, 23 insertions(+), 1 deletion(-)

diff --git a/49-group-anagrams.js b/49-group-anagrams.js
index f5baeff2..c59d7b86 100755
--- a/49-group-anagrams.js
+++ b/49-group-anagrams.js
@@ -1,3 +1,26 @@
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+const groupAnagrams = function (strs) {
+  const hash = new Map()
+  for (let str of strs) {
+    let key = 0
+    for (let char of str) {
+      const idx = char.charCodeAt(0)
+      key += Math.pow(idx, 4)
+    }
+    if (!hash.has(key)) hash.set(key, [str])
+    else {
+      hash.set(key, hash.get(key).concat(str))
+    }
+  }
+  return Array.from(hash.values())
+}
+
+
+// another
+
 /**
  * @param {string[]} strs
  * @return {string[][]}
@@ -19,6 +42,5 @@ const groupAnagrams = function(strs) {
       hash[sel] = [el];
     }
   }
-
   return Object.values(hash);
 };

From 40569be6ffac264b8b18780fa1546a730afe5fb0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 18:27:01 +0800
Subject: [PATCH 0477/3374] Update 49-group-anagrams.js

---
 49-group-anagrams.js | 60 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/49-group-anagrams.js b/49-group-anagrams.js
index c59d7b86..c1bd2479 100755
--- a/49-group-anagrams.js
+++ b/49-group-anagrams.js
@@ -18,6 +18,66 @@ const groupAnagrams = function (strs) {
   return Array.from(hash.values())
 }
 
+// another
+
+/**
+ * @param {string[]} strs
+ * @return {string[][]}
+ */
+const groupAnagrams = (strs) => {
+  const resp = new Array(),
+    termsGrouped = new Map()
+  strs.forEach((term) => {
+    const hashed = hash(term)
+    if (!termsGrouped.has(hashed)) termsGrouped.set(hashed, new Array())
+    termsGrouped.get(hashed).push(term)
+  })
+  termsGrouped.forEach((terms) => {
+    resp.push(terms)
+  })
+  return resp
+}
+
+const hash = (term) => {
+  const primeLetterNumbers = [
+    2,
+    3,
+    5,
+    7,
+    11,
+    13,
+    17,
+    19,
+    23,
+    29,
+    31,
+    37,
+    41,
+    43,
+    47,
+    53,
+    59,
+    61,
+    67,
+    71,
+    73,
+    79,
+    83,
+    89,
+    97,
+    101,
+  ]
+  let accum = 1
+  for (let letter of term) {
+    const primeIndex = letter.charCodeAt(0) - 'a'.charCodeAt(0)
+    const primeMapping = primeLetterNumbers[primeIndex]
+    accum *= primeMapping
+  }
+  return accum
+}
+
+
+
 
 // another
 

From d8e2527265fb251f749ff1351aedfbef4bd54e18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 20:53:44 +0800
Subject: [PATCH 0478/3374] Update 49-group-anagrams.js

---
 49-group-anagrams.js | 64 ++++----------------------------------------
 1 file changed, 5 insertions(+), 59 deletions(-)

diff --git a/49-group-anagrams.js b/49-group-anagrams.js
index c1bd2479..dfffbb2f 100755
--- a/49-group-anagrams.js
+++ b/49-group-anagrams.js
@@ -1,25 +1,3 @@
-/**
- * @param {string[]} strs
- * @return {string[][]}
- */
-const groupAnagrams = function (strs) {
-  const hash = new Map()
-  for (let str of strs) {
-    let key = 0
-    for (let char of str) {
-      const idx = char.charCodeAt(0)
-      key += Math.pow(idx, 4)
-    }
-    if (!hash.has(key)) hash.set(key, [str])
-    else {
-      hash.set(key, hash.get(key).concat(str))
-    }
-  }
-  return Array.from(hash.values())
-}
-
-// another
-
 /**
  * @param {string[]} strs
  * @return {string[][]}
@@ -39,46 +17,14 @@ const groupAnagrams = (strs) => {
 }
 
 const hash = (term) => {
-  const primeLetterNumbers = [
-    2,
-    3,
-    5,
-    7,
-    11,
-    13,
-    17,
-    19,
-    23,
-    29,
-    31,
-    37,
-    41,
-    43,
-    47,
-    53,
-    59,
-    61,
-    67,
-    71,
-    73,
-    79,
-    83,
-    89,
-    97,
-    101,
-  ]
-  let accum = 1
-  for (let letter of term) {
-    const primeIndex = letter.charCodeAt(0) - 'a'.charCodeAt(0)
-    const primeMapping = primeLetterNumbers[primeIndex]
-    accum *= primeMapping
+  const arr = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for(let i = 0, len = term.length; i < len; i++) {
+    arr[term[i].charCodeAt(0) - a]++
   }
-  return accum
+  return arr.join('-')
 }
 
-
-
-
 // another
 
 /**

From 364020bf028eb37ac40fb6ab11a7070fa9a56241 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Apr 2020 22:17:59 +0800
Subject: [PATCH 0479/3374] Create 641-design-circular-deque.js

---
 641-design-circular-deque.js | 103 +++++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 641-design-circular-deque.js

diff --git a/641-design-circular-deque.js b/641-design-circular-deque.js
new file mode 100644
index 00000000..2689aa20
--- /dev/null
+++ b/641-design-circular-deque.js
@@ -0,0 +1,103 @@
+/**
+ * Initialize your data structure here. Set the size of the deque to be k.
+ * @param {number} k
+ */
+const MyCircularDeque = function(k) {
+  this.q = []
+  this.k = k
+};
+
+/**
+ * Adds an item at the front of Deque. Return true if the operation is successful. 
+ * @param {number} value
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.insertFront = function(value) {
+  if(this.q.length < this.k) {
+    this.q.unshift(value)
+    return true
+  }
+  return false
+};
+
+/**
+ * Adds an item at the rear of Deque. Return true if the operation is successful. 
+ * @param {number} value
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.insertLast = function(value) {
+  if(this.q.length < this.k) {
+    this.q.push(value)
+    return true
+  }
+  return false
+};
+
+/**
+ * Deletes an item from the front of Deque. Return true if the operation is successful.
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.deleteFront = function() {
+  if(this.q.length) {
+    this.q.shift()
+    return true
+  }
+  return false
+};
+
+/**
+ * Deletes an item from the rear of Deque. Return true if the operation is successful.
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.deleteLast = function() {
+  if(this.q.length) {
+    this.q.pop()
+    return true
+  }
+  return false 
+};
+
+/**
+ * Get the front item from the deque.
+ * @return {number}
+ */
+MyCircularDeque.prototype.getFront = function() {
+  return this.q[0] === undefined ? -1 : this.q[0]
+};
+
+/**
+ * Get the last item from the deque.
+ * @return {number}
+ */
+MyCircularDeque.prototype.getRear = function() {
+  return this.q[this.q.length - 1] === undefined ? -1 : this.q[this.q.length - 1]
+};
+
+/**
+ * Checks whether the circular deque is empty or not.
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.isEmpty = function() {
+  return this.q.length === 0
+};
+
+/**
+ * Checks whether the circular deque is full or not.
+ * @return {boolean}
+ */
+MyCircularDeque.prototype.isFull = function() {
+  return this.q.length === this.k
+};
+
+/** 
+ * Your MyCircularDeque object will be instantiated and called as such:
+ * var obj = new MyCircularDeque(k)
+ * var param_1 = obj.insertFront(value)
+ * var param_2 = obj.insertLast(value)
+ * var param_3 = obj.deleteFront()
+ * var param_4 = obj.deleteLast()
+ * var param_5 = obj.getFront()
+ * var param_6 = obj.getRear()
+ * var param_7 = obj.isEmpty()
+ * var param_8 = obj.isFull()
+ */

From 1f62933332412e3268512b623689ee8ad23a8127 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Apr 2020 15:58:18 +0800
Subject: [PATCH 0480/3374] Create 690-employee-importance.js

---
 690-employee-importance.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 690-employee-importance.js

diff --git a/690-employee-importance.js b/690-employee-importance.js
new file mode 100644
index 00000000..a958653e
--- /dev/null
+++ b/690-employee-importance.js
@@ -0,0 +1,34 @@
+/**
+ * Definition for Employee.
+ * function Employee(id, importance, subordinates) {
+ *     // It's the unique id of each node
+ *     // unique id of this employee
+ *     this.id = id;
+ *     // the importance value of this employee
+ *     this.importance = importance;
+ *     // the id of direct subordinates
+ *     this.subordinates = subordinates;
+ * }
+ */
+
+/**
+ * @param {Employee[]} employees
+ * @param {number} id
+ * @return {number}
+ */
+const GetImportance = function (employees, id) {
+  const map = {}
+  employees.forEach((employee) => {
+    map[employee.id] = employee
+  })
+  const s = [id]
+  let importance = 0
+  while (s.length) {
+    let current = map[s.pop()]
+    importance += current.importance
+    if (current.subordinates.length) {
+      s.push(...current.subordinates.reverse())
+    }
+  }
+  return importance
+}

From 7ee83f2fc37beed33798fd083c334ff5237ffa77 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Apr 2020 12:52:20 +0800
Subject: [PATCH 0481/3374] Create 642-design-search-autocomplete-system.js

---
 642-design-search-autocomplete-system.js | 108 +++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 642-design-search-autocomplete-system.js

diff --git a/642-design-search-autocomplete-system.js b/642-design-search-autocomplete-system.js
new file mode 100644
index 00000000..706dc546
--- /dev/null
+++ b/642-design-search-autocomplete-system.js
@@ -0,0 +1,108 @@
+/**
+ * @param {string[]} sentences
+ * @param {number[]} times
+ */
+const AutocompleteSystem = function (sentences, times) {
+  this.trie = new Trie()
+  this.inputString = ''
+  this.MAX_RESULTS = 3
+  for (let i = 0; i < times.length; i++) {
+    const sentence = sentences[i]
+    this.trie.insert(sentence, times[i])
+  }
+}
+
+/**
+ * @param {character} c
+ * @return {string[]}
+ */
+AutocompleteSystem.prototype.input = function (c) {
+  if (c === '#') {
+    this.trie.insert(this.inputString)
+    this.inputString = ''
+    return []
+  }
+  this.inputString += c
+  const strings = this.trie.stringsStartingWith(this.inputString)
+  const results = Object.keys(strings)
+  results.sort((a, b) => {
+    const aFreq = strings[a]
+    const bFreq = strings[b]
+    return aFreq !== bFreq ? bFreq - aFreq : a > b ? 1 : -1
+  })
+  return results.slice(0, this.MAX_RESULTS)
+}
+
+/**
+ * Your AutocompleteSystem object will be instantiated and called as such:
+ * var obj = new AutocompleteSystem(sentences, times)
+ * var param_1 = obj.input(c)
+ */
+
+// Using a Trie (Prefix tree).
+/**
+ * Initialize your data structure here.
+ */
+const Trie = function () {
+  this._trie = {}
+}
+
+/**
+ * Inserts a string into the trie a number of times.
+ * @param {string} word
+ * @param {number} [count=1]
+ * @return {void}
+ */
+Trie.prototype.insert = function (word, count = 1) {
+  if (!word.length || count < 1) {
+    return
+  }
+  let curr = this._trie
+  for (let i = 0; i < word.length; i++) {
+    const char = word[i]
+    if (!curr.hasOwnProperty(char)) {
+      curr[char] = {}
+    }
+    curr = curr[char]
+  }
+  if (!curr.hasOwnProperty('#')) {
+    curr['#'] = 0
+  }
+  curr['#'] += count
+}
+
+/**
+ * Returns if there is any string in the trie that starts with the given prefix.
+ * @param {string} prefix
+ * @return {Object}
+ */
+// Time: O(n), where n is the number of different strings in the Trie.
+// Space: O(1)
+Trie.prototype.stringsStartingWith = function (prefix) {
+  if (!prefix.length) {
+    return false
+  }
+  let curr = this._trie
+  for (let i = 0; i < prefix.length; i++) {
+    const char = prefix[i]
+    if (!curr.hasOwnProperty(char)) {
+      return false
+    }
+    curr = curr[char]
+  }
+  const results = {}
+  function traverse(node, chars) {
+    if (!node) {
+      return
+    }
+    Object.keys(node).forEach((char) => {
+      if (char === '#') {
+        results[chars] = node[char]
+        return
+      }
+      traverse(node[char], chars + char)
+    })
+  }
+  traverse(curr, prefix)
+  return results
+}

From 50401dfd5e3a292dfb02f64bb60daa43f1f3be7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Apr 2020 14:33:32 +0800
Subject: [PATCH 0482/3374] Update 642-design-search-autocomplete-system.js

---
 642-design-search-autocomplete-system.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/642-design-search-autocomplete-system.js b/642-design-search-autocomplete-system.js
index 706dc546..d00efdb3 100644
--- a/642-design-search-autocomplete-system.js
+++ b/642-design-search-autocomplete-system.js
@@ -6,9 +6,8 @@ const AutocompleteSystem = function (sentences, times) {
   this.trie = new Trie()
   this.inputString = ''
   this.MAX_RESULTS = 3
-  for (let i = 0; i < times.length; i++) {
-    const sentence = sentences[i]
-    this.trie.insert(sentence, times[i])
+  for (let i = 0, len = times.length; i < len; i++) {
+    this.trie.insert(sentences[i], times[i])
   }
 }
 

From 30694a13b5a5de6ebb473e6945e417d4d172d5f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Apr 2020 16:14:39 +0800
Subject: [PATCH 0483/3374] Create 876-middle-of-the-linked-list.js

---
 876-middle-of-the-linked-list.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 876-middle-of-the-linked-list.js

diff --git a/876-middle-of-the-linked-list.js b/876-middle-of-the-linked-list.js
new file mode 100644
index 00000000..fc709a48
--- /dev/null
+++ b/876-middle-of-the-linked-list.js
@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const middleNode = function (head) {
+  if (head == null) return null
+  let count = 1
+  let iter = head
+  while (iter.next) {
+    iter = iter.next
+    count++
+  }
+  count = (count / 2) >> 0
+  while (count) {
+    head = head.next
+    count--
+  }
+  return head
+}

From 668c150b349a2f7e4b313ef5051c39af21bb25a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Apr 2020 16:55:19 +0800
Subject: [PATCH 0484/3374] Create 649-dota2-senate.js

---
 649-dota2-senate.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 649-dota2-senate.js

diff --git a/649-dota2-senate.js b/649-dota2-senate.js
new file mode 100644
index 00000000..eb15ae80
--- /dev/null
+++ b/649-dota2-senate.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} senate
+ * @return {string}
+ */
+const predictPartyVictory = function (senate) {
+  const m = senate.length,
+    radiant = [],
+    dire = []
+  for (let i = 0; i < m; i++) {
+    if (senate[i] === 'R') {
+      radiant.push(i)
+    } else {
+      dire.push(i)
+    }
+  }
+
+  while (radiant.length && dire.length) {
+    let r = radiant.shift(),
+      d = dire.shift()
+    if (r < d) {
+      radiant.push(r + m)
+    } else {
+      dire.push(d + m)
+    }
+  }
+  return radiant.length > dire.length ? 'Radiant' : 'Dire'
+}

From 8023f07b3f7d7f671df6d1a0e2d7ba878fbb87c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Apr 2020 16:19:37 +0800
Subject: [PATCH 0485/3374] Create 844-backspace-string-compare.js

---
 844-backspace-string-compare.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 844-backspace-string-compare.js

diff --git a/844-backspace-string-compare.js b/844-backspace-string-compare.js
new file mode 100644
index 00000000..059aa76a
--- /dev/null
+++ b/844-backspace-string-compare.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} S
+ * @param {string} T
+ * @return {boolean}
+ */
+const backspaceCompare = function(S, T) {
+  return chk(S) === chk(T)
+};
+
+function chk(str) {
+  const s = []
+  for(let i = 0, len = str.length; i < len; i++) {
+    if(str[i] === '#') s.pop()
+    else s.push(str[i])
+  }
+  return s.join('')
+}

From f6a8d899d7817e99e6c50d74bf80959d5979f803 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 11:00:24 +0800
Subject: [PATCH 0486/3374] Create 652-find-duplicate-subtrees.js

---
 652-find-duplicate-subtrees.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 652-find-duplicate-subtrees.js

diff --git a/652-find-duplicate-subtrees.js b/652-find-duplicate-subtrees.js
new file mode 100644
index 00000000..65949019
--- /dev/null
+++ b/652-find-duplicate-subtrees.js
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode[]}
+ */
+const findDuplicateSubtrees = function (root) {
+  const obj = {},
+    res = []
+  preOrder(root, obj, res)
+  return res
+}
+
+function preOrder(root, map, res) {
+  if (root === null) return '#'
+  const str =
+    root.val + preOrder(root.left, map, res) + preOrder(root.right, map, res)
+  if (!map[str]) map[str] = 0
+  map[str]++
+  if (map[str] === 2) res.push(root)
+  return str
+}

From 544ecf0129e38963acae0a4e1781df7fe019f0d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 12:12:55 +0800
Subject: [PATCH 0487/3374] Create 653-two-sum-iv-input-is-a-bst.js

---
 653-two-sum-iv-input-is-a-bst.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 653-two-sum-iv-input-is-a-bst.js

diff --git a/653-two-sum-iv-input-is-a-bst.js b/653-two-sum-iv-input-is-a-bst.js
new file mode 100644
index 00000000..ba7dc1e9
--- /dev/null
+++ b/653-two-sum-iv-input-is-a-bst.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {boolean}
+ */
+const findTarget = function(root, k) {
+  const m = new Map()
+  return traverse(root, k, m)
+};
+
+function traverse(node, k, m) {
+  if(node == null) return false
+  if(m.has(k - node.val)) return true
+  m.set(node.val, node)
+  return traverse(node.left,k,m) || traverse(node.right,k,m)
+}

From c724c20d3fb0021c47100eacfcee3da289d71a0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 14:03:22 +0800
Subject: [PATCH 0488/3374] Create 655-print-binary-tree.js

---
 655-print-binary-tree.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 655-print-binary-tree.js

diff --git a/655-print-binary-tree.js b/655-print-binary-tree.js
new file mode 100644
index 00000000..a3ef06f5
--- /dev/null
+++ b/655-print-binary-tree.js
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {string[][]}
+ */
+const printTree = function (root) {
+  const h = getH(root)
+  const w = Math.pow(2, h) - 1
+  const matrix = new Array(h).fill(0).map((_) => new Array(w).fill(''))
+  fill(root, 0, 0, w - 1)
+  return matrix
+  function getH(root) {
+    if (!root) return 0
+    return Math.max(getH(root.left), getH(root.right)) + 1
+  }
+  function fill(root, level, start, end) {
+    if (!root) return
+    let mid = (start + end) / 2
+    matrix[level][mid] = root.val + ''
+    fill(root.left, level + 1, start, mid - 1)
+    fill(root.right, level + 1, mid + 1, end)
+  }
+}

From 30ef87ecc6328d039dabbee34bf345827ffe2c64 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 15:08:49 +0800
Subject: [PATCH 0489/3374] Update 155-min-stack.js

---
 155-min-stack.js | 50 +++++++++++++++++++++++++++---------------------
 1 file changed, 28 insertions(+), 22 deletions(-)

diff --git a/155-min-stack.js b/155-min-stack.js
index 4ddc3d4a..a48bb5f2 100644
--- a/155-min-stack.js
+++ b/155-min-stack.js
@@ -1,46 +1,52 @@
 /**
  * initialize your data structure here.
  */
-const MinStack = function() {
-    this.arr = []
-};
+const MinStack = function () {
+  this.stack = []
+  this.min = null
+}
 
-/** 
+/**
  * @param {number} x
  * @return {void}
  */
-MinStack.prototype.push = function(x) {
-    this.arr.push(x)
-};
+MinStack.prototype.push = function (x) {
+  if (this.min === null) {
+    this.min = x
+  } else {
+    this.min = Math.min(x, this.min)
+  }
+  return this.stack.push(x)
+}
 
 /**
  * @return {void}
  */
-MinStack.prototype.pop = function() {
-    this.arr.pop()
-};
+MinStack.prototype.pop = function () {
+  let removed = this.stack.pop()
+  if (this.min === removed) {
+    this.min = this.stack.length > 0 ? Math.min(...this.stack) : null
+  }
+  return this.stack
+}
 
 /**
  * @return {number}
  */
-MinStack.prototype.top = function() {
-    return this.arr[this.arr.length - 1]
-};
+MinStack.prototype.top = function () {
+  return this.stack[this.stack.length - 1]
+}
 
 /**
  * @return {number}
  */
-MinStack.prototype.getMin = function() {
-  let min = Number.MAX_VALUE
-  for(let el of this.arr) {
-    if(el < min) min = el
-  }
-  return min
-};
+MinStack.prototype.getMin = function () {
+  return this.min
+}
 
-/** 
+/**
  * Your MinStack object will be instantiated and called as such:
- * var obj = Object.create(MinStack).createNew()
+ * var obj = new MinStack()
  * obj.push(x)
  * obj.pop()
  * var param_3 = obj.top()

From c91a01f5e582d215b33fe4881b462ac70aa13b43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 16:25:28 +0800
Subject: [PATCH 0490/3374] Create 688-knight-probability-in-chessboard.js

---
 688-knight-probability-in-chessboard.js | 43 +++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 688-knight-probability-in-chessboard.js

diff --git a/688-knight-probability-in-chessboard.js b/688-knight-probability-in-chessboard.js
new file mode 100644
index 00000000..546677d2
--- /dev/null
+++ b/688-knight-probability-in-chessboard.js
@@ -0,0 +1,43 @@
+/**
+ * @param {number} N
+ * @param {number} K
+ * @param {number} r
+ * @param {number} c
+ * @return {number}
+ */
+const knightProbability = function (N, K, r, c) {
+  const moves = [
+    [1, 2],
+    [1, -2],
+    [2, 1],
+    [2, -1],
+    [-1, 2],
+    [-1, -2],
+    [-2, 1],
+    [-2, -1],
+  ]
+  const dp = [...Array(K + 1)].map(() =>
+    [...Array(N)].map(() => Array(N).fill(0))
+  )
+  dp[0][r][c] = 1
+  for (let step = 1; step <= K; step++) {
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        for (let move of moves) {
+          let row = i + move[0],
+            col = j + move[1]
+          if (row >= 0 && row < N && col >= 0 && col < N)
+            dp[step][i][j] += dp[step - 1][row][col] / 8
+        }
+      }
+    }
+  }
+  let res = 0
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      res += dp[K][i][j]
+    }
+  }
+  return res
+}
+

From 3f44bce0919cff6a1b9811e373bcdcd4225da870 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 19:54:45 +0800
Subject: [PATCH 0491/3374] Create 651-4-keys-keyboard.js

---
 651-4-keys-keyboard.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 651-4-keys-keyboard.js

diff --git a/651-4-keys-keyboard.js b/651-4-keys-keyboard.js
new file mode 100644
index 00000000..d21050d9
--- /dev/null
+++ b/651-4-keys-keyboard.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const maxA = function (N) {
+  const dp = [...new Array(N + 1)].map((_, i) => i)
+  for (let i = 4; i <= N; i++) {
+    for (let j = 1; j <= i - 3; j++) {
+      dp[i] = Math.max(dp[i], dp[j] * (i - j - 1))
+    }
+  }
+  return dp[N]
+}

From 0f90a2fbc153b6ff47b4084eedb927e8e636cf85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 19:59:18 +0800
Subject: [PATCH 0492/3374] Update 651-4-keys-keyboard.js

---
 651-4-keys-keyboard.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/651-4-keys-keyboard.js b/651-4-keys-keyboard.js
index d21050d9..5fd0e25f 100644
--- a/651-4-keys-keyboard.js
+++ b/651-4-keys-keyboard.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const maxA = function (N) {
+  const dp = [0, 1, 2, 3, 4, 5, 6]
+  const recurse = function (n) {
+    if (dp[n]) return dp[n]
+    const max = Math.max(
+      recurse(n - 3) * 2,
+      recurse(n - 4) * 3,
+      recurse(n - 5) * 4
+    )
+    return (dp[n] = max)
+  }
+  return recurse(N)
+}
+
+// another
+
 /**
  * @param {number} N
  * @return {number}

From 2c2800b884d60544761f08cb7a044c56ffdff819 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Apr 2020 22:24:16 +0800
Subject: [PATCH 0493/3374] Update 651-4-keys-keyboard.js

---
 651-4-keys-keyboard.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/651-4-keys-keyboard.js b/651-4-keys-keyboard.js
index 5fd0e25f..b20bcd6f 100644
--- a/651-4-keys-keyboard.js
+++ b/651-4-keys-keyboard.js
@@ -31,3 +31,24 @@ const maxA = function (N) {
   }
   return dp[N]
 }
+
+// another
+
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const maxA = function (N) {
+  const dp = new Array(7).fill(0)
+  for (let i = 1; i <= N; i++) {
+    dp[0] = i
+    for (let k = 6; k > 2; k--) {
+      dp[0] = Math.max(dp[0], dp[k] * (k - 1))
+    }
+    for (let k = 6; k > 0; k--) {
+      dp[k] = dp[k - 1]
+    }
+  }
+  return dp[0]
+}
+

From dc3bfe179d3d18e079cf25b87d12b29e25425a17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Apr 2020 11:37:18 +0800
Subject: [PATCH 0494/3374] Create 656-coin-path.js

---
 656-coin-path.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 656-coin-path.js

diff --git a/656-coin-path.js b/656-coin-path.js
new file mode 100644
index 00000000..93debc6b
--- /dev/null
+++ b/656-coin-path.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} A
+ * @param {number} B
+ * @return {number[]}
+ */
+const cheapestJump = function (A, B) {
+  if (A[A.length - 1] < 0) return []
+  let dp = []
+  let nextTo = []
+  dp[A.length - 1] = A[A.length - 1]
+  nextTo[A.length - 1] = -1
+  for (let i = A.length - 2; i >= 0; i--) {
+    dp[i] = -1
+    if (A[i] === -1) continue
+    let cost = Infinity
+    for (let j = i + 1; j <= Math.min(i + B, A.length - 1); j++) {
+      if (dp[j] !== -1 && dp[j] < cost) {
+        cost = dp[j]
+        nextTo[i] = j
+      }
+    }
+    if (cost < Infinity) dp[i] = cost + A[i]
+  }
+  let ans = []
+  if (dp[0] >= 0) {
+    let p = 0
+    while (p >= 0) {
+      ans.push(p + 1)
+      p = nextTo[p]
+    }
+  }
+  return ans
+}

From 9c573c8328d9444b05988df0c7af0beaf00f6a27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Apr 2020 15:18:02 +0800
Subject: [PATCH 0495/3374] Update 543-diameter-of-binary-tree.js

---
 543-diameter-of-binary-tree.js | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/543-diameter-of-binary-tree.js b/543-diameter-of-binary-tree.js
index c428ae2c..a8d6dd5f 100755
--- a/543-diameter-of-binary-tree.js
+++ b/543-diameter-of-binary-tree.js
@@ -9,16 +9,17 @@
  * @param {TreeNode} root
  * @return {number}
  */
-let ans;
-const diameterOfBinaryTree = function(root) {
-  ans = 1;
-  depth(root);
-  return ans - 1;
-};
-function depth(node) {
-  if (node == null) return 0;
-  let L = depth(node.left);
-  let R = depth(node.right);
-  ans = Math.max(ans, L + R + 1);
-  return Math.max(L, R) + 1;
+const diameterOfBinaryTree = function (root) {
+  if (root === null) return 0
+  let longest = 0
+  function dfs(node) {
+    if (node === null) return 0
+    let leftmax = dfs(node.left)
+    let rightmax = dfs(node.right)
+    longest = Math.max(longest, leftmax + 1 + rightmax)
+    return Math.max(leftmax, rightmax) + 1
+  }
+  dfs(root)
+  return longest - 1
 }
+

From 8ffe796a68e80a6acc6a163fb63a4d6d97b737e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Apr 2020 09:24:49 +0800
Subject: [PATCH 0496/3374] Create 666-path-sum-iv.js

---
 666-path-sum-iv.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 666-path-sum-iv.js

diff --git a/666-path-sum-iv.js b/666-path-sum-iv.js
new file mode 100644
index 00000000..a6030f35
--- /dev/null
+++ b/666-path-sum-iv.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const pathSum = function (nums) {
+  const arr = Array(1 << 5).fill(-1)
+  for (let num of nums) {
+    let [lvl, pos, val] = [
+      parseInt(num / 100),
+      parseInt((num % 100) / 10),
+      num % 10,
+    ]
+    arr[(1 << (lvl - 1)) - 1 + pos - 1] = val
+  }
+  let sum = 0
+  for (let i = 0; i < 1 << 4; i++) {
+    if (arr[i] !== -1) {
+      arr[i] += i > 0 ? arr[parseInt((i - 1) >> 1)] : 0
+      if (arr[i * 2 + 1] === -1 && arr[i * 2 + 2] === -1) {
+        sum += arr[i]
+      }
+    }
+  }
+  return sum
+}

From 1dbe00a3d21d7d282dba6aeb8fd8ebddc0d6b9ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Apr 2020 16:38:20 +0800
Subject: [PATCH 0497/3374] Update 666-path-sum-iv.js

---
 666-path-sum-iv.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/666-path-sum-iv.js b/666-path-sum-iv.js
index a6030f35..e2fb7b6f 100644
--- a/666-path-sum-iv.js
+++ b/666-path-sum-iv.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const pathSum = function (nums) {
+  if (nums == null || nums.length === 0) return 0
+  const tree = Array(2 ** 5).fill(null)
+  for (let num of nums) {
+    const r = ((num / 100) >> 0) - 1
+    const pos = (((num % 100) / 10) >> 0) - 1
+    const v = num % 10
+    tree[Math.pow(2, r) + pos] = v
+  }
+  let res = 0
+  const q = [1]
+  while (q.length) {
+    const cur = q.shift()
+    const left = cur * 2
+    const right = cur * 2 + 1
+    if (left >= tree.length || (tree[left] == null && tree[right] == null))
+      res += tree[cur]
+    else {
+      if (tree[left] != null) {
+        q.push(left)
+        tree[left] += tree[cur]
+      }
+      if (tree[right] != null) {
+        q.push(right)
+        tree[right] += tree[cur]
+      }
+    }
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 0e2fb57c0946975510f53a86c94c4817e11bedd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Apr 2020 20:55:26 +0800
Subject: [PATCH 0498/3374] Update 666-path-sum-iv.js

---
 666-path-sum-iv.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/666-path-sum-iv.js b/666-path-sum-iv.js
index e2fb7b6f..a223b42f 100644
--- a/666-path-sum-iv.js
+++ b/666-path-sum-iv.js
@@ -35,6 +35,33 @@ const pathSum = function (nums) {
 
 // another
 
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const pathSum = function (nums) {
+  if (nums == null || nums.length === 0) return 0
+  const tree = new Map()
+  for (let num of nums) {
+    tree.set((num / 10) >> 0, num % 10)
+  }
+  return traverse((nums[0] / 10) >> 0, 0)
+
+  function traverse(node, prev) {
+    if (!tree.has(node)) return 0
+    const level = (node / 10) >> 0
+    const pos = node % 10
+    const val = tree.get(node)
+    const left = (level + 1) * 10 + pos * 2 - 1
+    const right = (level + 1) * 10 + pos * 2
+    const cur = prev + val
+    if (!tree.has(left) && !tree.has(right)) return cur
+    return traverse(left, cur) + traverse(right, cur)
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 266239f84ca8fbecb3d389f1dcb1d0e54c54f61f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Apr 2020 21:35:58 +0800
Subject: [PATCH 0499/3374] Create 1046-last-stone-weight.js

---
 1046-last-stone-weight.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1046-last-stone-weight.js

diff --git a/1046-last-stone-weight.js b/1046-last-stone-weight.js
new file mode 100644
index 00000000..978dbd30
--- /dev/null
+++ b/1046-last-stone-weight.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+const lastStoneWeight = function(stones) {
+  stones.sort((a, b) => a - b)
+  while (stones.length > 1) {
+    const num = Math.abs(stones.pop() - stones.pop())
+    stones.splice(stones.findIndex(item => item >= num), 0, num)
+  }
+  return stones[0] 
+};

From 68880a9bd02734a3d818574feb09792cf8d4ef47 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Apr 2020 16:03:15 +0800
Subject: [PATCH 0500/3374] Update 525-contiguous-array.js

---
 525-contiguous-array.js | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/525-contiguous-array.js b/525-contiguous-array.js
index 7b12241c..fcd03339 100644
--- a/525-contiguous-array.js
+++ b/525-contiguous-array.js
@@ -2,4 +2,24 @@
  * @param {number[]} nums
  * @return {number}
  */
-const findMaxLength = function(nums) {}
+const findMaxLength = function (nums) {
+  const map = new Map()
+  map.set(0, -1)
+  let count = 0
+  let max = 0
+  for (let i = 0; i < nums.length; i++) {
+    let num = nums[i]
+    if (num === 0) {
+      count -= 1
+    }
+    if (num === 1) {
+      count += 1
+    }
+    if (map.has(count)) {
+      max = Math.max(max, i - map.get(count))
+    } else {
+      map.set(count, i)
+    }
+  }
+  return max
+}

From 329fd0c10f5bf2f2076d630edc18390d47d6a7ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Apr 2020 17:34:41 +0800
Subject: [PATCH 0501/3374] Create 684-redundant-connection.js

---
 684-redundant-connection.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 684-redundant-connection.js

diff --git a/684-redundant-connection.js b/684-redundant-connection.js
new file mode 100644
index 00000000..23df8832
--- /dev/null
+++ b/684-redundant-connection.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const findRedundantConnection = function (edges) {
+  const uf = {}
+  for (let edge of edges) {
+    let u = edge[0]
+    let v = edge[1]
+    if (find(u) === find(v)) {
+      return edge
+    } else {
+      union(u, v)
+    }
+  }
+  function union(a, b) {
+    uf[find(a)] = uf[find(b)]
+  }
+  function find(x) {
+    if (!uf[x]) uf[x] = x
+    if (uf[x] === x) return x
+    return find(uf[x])
+  }
+}

From ed0719486e80f048936e6072780425e103d4e6a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Apr 2020 08:59:05 +0800
Subject: [PATCH 0502/3374] Create 685-redundant-connection-ii.js

---
 685-redundant-connection-ii.js | 39 ++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 685-redundant-connection-ii.js

diff --git a/685-redundant-connection-ii.js b/685-redundant-connection-ii.js
new file mode 100644
index 00000000..012a084d
--- /dev/null
+++ b/685-redundant-connection-ii.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const findRedundantDirectedConnection = function (edges) {
+  const parent = []
+  //detect circle
+  for (let i = 1; i <= edges.length; i++) {
+    parent[i] = i
+  }
+  let circleEdge, removedEdge, candidateEdge
+  for (let i = 0; i < edges.length; i++) {
+    const [u, v] = edges[i]
+    const pu = findParent(parent, u)
+    const pv = findParent(parent, v)
+    if (pv !== v) {
+      removedEdge = [u, v] // node with 2 parents
+    } else {
+      if (pv === pu) {
+        circleEdge = [u, v] // circle edge
+      }
+      parent[v] = pu
+    }
+  }
+  if (!removedEdge) {
+    return circleEdge
+  }
+  if (circleEdge) {
+    return edges.find((d) => d[1] === removedEdge[1] && d[0] !== removedEdge[0])
+  } else {
+    return removedEdge
+  }
+}
+const findParent = function (parent, i) {
+  if (parent[i] !== i) {
+    parent[i] = findParent(parent, parent[i])
+  }
+  return parent[i]
+}

From 33647eb552a0c48e71317f7acc57b37f4ca5c594 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Apr 2020 17:05:44 +0800
Subject: [PATCH 0503/3374] Create 683-k-empty-slots.js

---
 683-k-empty-slots.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 683-k-empty-slots.js

diff --git a/683-k-empty-slots.js b/683-k-empty-slots.js
new file mode 100644
index 00000000..edffbf4f
--- /dev/null
+++ b/683-k-empty-slots.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} bulbs
+ * @param {number} K
+ * @return {number}
+ */
+const kEmptySlots = function (bulbs, K) {
+  const days = new Array(bulbs.length)
+  for (let i = 0; i < bulbs.length; i++) days[bulbs[i] - 1] = i + 1
+  let left = 0,
+    right = K + 1,
+    res = Number.MAX_VALUE
+  for (let i = 0; right < days.length; i++) {
+    if (days[i] < days[left] || days[i] <= days[right]) {
+      if (i === right) res = Math.min(res, Math.max(days[left], days[right]))
+      left = i
+      right = K + 1 + i
+    }
+  }
+  return res === Number.MAX_VALUE ? -1 : res
+}

From aac251b5c8b35a1103839d9306a5c224f646a9bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Apr 2020 16:38:19 +0800
Subject: [PATCH 0504/3374] Update 238-product-of-array-except-self.js

---
 238-product-of-array-except-self.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/238-product-of-array-except-self.js b/238-product-of-array-except-self.js
index ded9a69a..ccf2aa3e 100755
--- a/238-product-of-array-except-self.js
+++ b/238-product-of-array-except-self.js
@@ -3,10 +3,10 @@
  * @return {number[]}
  */
 const productExceptSelf = function(nums) {
-  let zeroIdxArr = [];
+  const zeroIdx = new Set();
   const p = nums.reduce((ac, el, idx) => {
     if (el === 0) {
-      zeroIdxArr.push(idx);
+      zeroIdx.add(idx);
       return ac;
     } else {
       return ac * el;
@@ -14,13 +14,14 @@ const productExceptSelf = function(nums) {
   }, 1);
   const res = [];
   for (let i = 0; i < nums.length; i++) {
-    if (zeroIdxArr.length > 1) {
+    if (zeroIdx.size > 1) {
       res.push(0);
-    } else if (zeroIdxArr.length === 1) {
-      res.push(i === zeroIdxArr[0] ? p : 0);
+    } else if (zeroIdx.size === 1) {
+      res.push(i === [...zeroIdx.values()][0] ? p : 0);
     } else {
       res.push(p / nums[i]);
     }
   }
   return res;
 };
+

From a454d8836a1e2813fa2080f3b51d869048608ac0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Apr 2020 16:57:46 +0800
Subject: [PATCH 0505/3374] Create 681-next-closest-time.js

---
 681-next-closest-time.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 681-next-closest-time.js

diff --git a/681-next-closest-time.js b/681-next-closest-time.js
new file mode 100644
index 00000000..43f52975
--- /dev/null
+++ b/681-next-closest-time.js
@@ -0,0 +1,35 @@
+/**
+ * @param {string} time
+ * @return {string}
+ */
+const nextClosestTime = function (time) {
+  const [a, b, _, c, d] = time.split('').map((n) => parseInt(n))
+  const min = Math.min(a, b, c, d)
+  if ([a, b, c].some((n) => n > d)) {
+    return [a, b, ':', c, Math.min(...[a, b, c].filter((n) => n > d))].join('')
+  }
+  if ([a, b, d].some((n) => n > c && n < 6)) {
+    return [
+      a,
+      b,
+      ':',
+      Math.min(...[a, b, d].filter((n) => n > c && n < 6)),
+      min,
+    ].join('')
+  }
+  if ([a, c, d].some((n) => n > b && ((a == 2 && n < 4) || a < 2))) {
+    return [
+      a,
+      Math.min(
+        ...[a, c, d].filter((n) => n > b && ((a == 2 && n < 4) || a < 2))
+      ),
+      ':',
+      min,
+      min,
+    ].join('')
+  }
+  if ([b, c, d].some((n) => n > a && n <= 2)) {
+    return [[b, c, d].some((n) => n > a && n <= 2), min, ':', min, min].join('')
+  }
+  return [min, min, ':', min, min].join('')
+}

From 2325a53fbbcd4ba781de1a41012957f0cb29c995 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Apr 2020 21:45:53 +0800
Subject: [PATCH 0506/3374] Update 681-next-closest-time.js

---
 681-next-closest-time.js | 62 +++++++++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 27 deletions(-)

diff --git a/681-next-closest-time.js b/681-next-closest-time.js
index 43f52975..3dcecc92 100644
--- a/681-next-closest-time.js
+++ b/681-next-closest-time.js
@@ -3,33 +3,41 @@
  * @return {string}
  */
 const nextClosestTime = function (time) {
-  const [a, b, _, c, d] = time.split('').map((n) => parseInt(n))
-  const min = Math.min(a, b, c, d)
-  if ([a, b, c].some((n) => n > d)) {
-    return [a, b, ':', c, Math.min(...[a, b, c].filter((n) => n > d))].join('')
+  const digits = time.split('')
+  const orderedDigits = [...digits].sort()
+  for (let i = digits.length - 1; i >= 0; i--) {
+    const current = digits[i]
+    switch (i) {
+      case 4:
+        digits[i] = findSmallest(digits[i], '9', orderedDigits)
+        if (digits[i] > current) return digits.join('')
+        break
+      case 3:
+        digits[i] = findSmallest(digits[i], '5', orderedDigits)
+        if (digits[i] > current) return digits.join('')
+        break
+      case 1:
+        digits[i] = findSmallest(
+          digits[i],
+          digits[i - 1] == '2' ? '4' : '9',
+          orderedDigits
+        )
+        if (digits[i] > current) return digits.join('')
+        break
+      case 0:
+        digits[i] = findSmallest(digits[i], '2', orderedDigits)
+        if (digits[i] > current) return digits.join('')
+        break
+    }
   }
-  if ([a, b, d].some((n) => n > c && n < 6)) {
-    return [
-      a,
-      b,
-      ':',
-      Math.min(...[a, b, d].filter((n) => n > c && n < 6)),
-      min,
-    ].join('')
-  }
-  if ([a, c, d].some((n) => n > b && ((a == 2 && n < 4) || a < 2))) {
-    return [
-      a,
-      Math.min(
-        ...[a, c, d].filter((n) => n > b && ((a == 2 && n < 4) || a < 2))
-      ),
-      ':',
-      min,
-      min,
-    ].join('')
-  }
-  if ([b, c, d].some((n) => n > a && n <= 2)) {
-    return [[b, c, d].some((n) => n > a && n <= 2), min, ':', min, min].join('')
+  return digits.join('')
+}
+
+const findSmallest = (low, high, order) => {
+  for (let d = 0; d < order.length; d++) {
+    if (order[d] != ':' && order[d] > low && order[d] <= high) {
+      return order[d]
+    }
   }
-  return [min, min, ':', min, min].join('')
+  return order[0]
 }

From 77f4ddacbe86067fcd01ae71319acf17e4d0f388 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Apr 2020 08:04:12 +0800
Subject: [PATCH 0507/3374] Create 671-second-minimum-node-in-a-binary-tree.js

---
 671-second-minimum-node-in-a-binary-tree.js | 31 +++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 671-second-minimum-node-in-a-binary-tree.js

diff --git a/671-second-minimum-node-in-a-binary-tree.js b/671-second-minimum-node-in-a-binary-tree.js
new file mode 100644
index 00000000..f0700373
--- /dev/null
+++ b/671-second-minimum-node-in-a-binary-tree.js
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const findSecondMinimumValue = function(root) {
+  if(root == null) return -1
+  const q = [root]
+  let min = Number.MAX_VALUE
+  let min2nd = Number.MAX_VALUE
+  while(q.length) {
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const cur = q.shift()
+      if(cur.val <= min) {
+        min = cur.val
+      } else if(cur.val > min && cur.val < min2nd) {
+        min2nd = cur.val
+      }
+      if(cur.left) q.push(cur.left)
+      if(cur.right) q.push(cur.right)
+    }
+  }
+  return min2nd === Number.MAX_VALUE ? -1 : min2nd
+};

From b0a6be7f0acd3aef612d4493b1bb5f3feec83f18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Apr 2020 08:17:21 +0800
Subject: [PATCH 0508/3374] Update 671-second-minimum-node-in-a-binary-tree.js

---
 671-second-minimum-node-in-a-binary-tree.js | 35 +++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/671-second-minimum-node-in-a-binary-tree.js b/671-second-minimum-node-in-a-binary-tree.js
index f0700373..12bd486a 100644
--- a/671-second-minimum-node-in-a-binary-tree.js
+++ b/671-second-minimum-node-in-a-binary-tree.js
@@ -29,3 +29,38 @@ const findSecondMinimumValue = function(root) {
   }
   return min2nd === Number.MAX_VALUE ? -1 : min2nd
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const findSecondMinimumValue = function (root) {
+  if (root === null) return -1;
+  if (root.left === null && root.right === null) return -1;
+  let left = root.left.val;
+  let right = root.right.val;
+  if (left === root.val) {
+    left = findSecondMinimumValue(root.left);
+  }
+  if (right === root.val) {
+    right = findSecondMinimumValue(root.right);
+  }
+  if (right !== -1 && left !== -1) {
+    return Math.min(left, right);
+  }
+  if (right === -1) {
+    return left;
+  }
+  if (left === -1) {
+    return right;
+  }
+};

From 0009fa00e3c6807ab9954be1f36c7d52cd2138fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Apr 2020 15:59:18 +0800
Subject: [PATCH 0509/3374] Create 672-bulb-switcher-ii.js

---
 672-bulb-switcher-ii.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 672-bulb-switcher-ii.js

diff --git a/672-bulb-switcher-ii.js b/672-bulb-switcher-ii.js
new file mode 100644
index 00000000..9e3bb96e
--- /dev/null
+++ b/672-bulb-switcher-ii.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+const flipLights = function (n, m) {
+  n = Math.min(n, 3)
+  if (m === 0) return 1
+  if (m === 1) return n === 1 ? 2 : n === 2 ? 3 : 4
+  if (m === 2) return n === 1 ? 2 : n === 2 ? 4 : 7
+  return n === 1 ? 2 : n === 2 ? 4 : 8
+}

From 827269dabc20ee3f707af230a8ef43d549d9d933 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 18 Apr 2020 23:02:21 +0800
Subject: [PATCH 0510/3374] Create 667-beautiful-arrangement-ii.js

---
 667-beautiful-arrangement-ii.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 667-beautiful-arrangement-ii.js

diff --git a/667-beautiful-arrangement-ii.js b/667-beautiful-arrangement-ii.js
new file mode 100644
index 00000000..a8f665c1
--- /dev/null
+++ b/667-beautiful-arrangement-ii.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number[]}
+ */
+const constructArray = function (n, k) {
+  const res = [1]
+  while (k) {
+    const index = res.length
+    if (index % 2 === 1) {
+      res.push(res[index - 1] + k)
+    } else {
+      res.push(res[index - 1] - k)
+    }
+    k -= 1
+  }
+  if (res.length < n) {
+    for (let i = res.length + 1; i <= n; i += 1) {
+      res.push(i)
+    }
+  }
+  return res
+}

From 2e5e28e81fa08d98446f4b249b4d4edef5d9c632 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Apr 2020 16:23:40 +0800
Subject: [PATCH 0511/3374] Create 663-equal-tree-partition.js

---
 663-equal-tree-partition.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 663-equal-tree-partition.js

diff --git a/663-equal-tree-partition.js b/663-equal-tree-partition.js
new file mode 100644
index 00000000..e7f7b9c6
--- /dev/null
+++ b/663-equal-tree-partition.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const checkEqualTree = function (root) {
+  const s = new Set()
+  const visit = (node, k = 1) => {
+    if (!node) return 0
+    const l = visit(node.left)
+    const r = visit(node.right)
+    const ret = l + r + node.val
+    if (k) s.add(ret)
+    return ret
+  }
+  const sum = visit(root, 0)
+  if (sum % 2) return false
+  return s.has(sum / 2)
+}

From 57f8b5e8048de8e27e16883b8c43d691b5a5b9df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Apr 2020 07:54:18 +0800
Subject: [PATCH 0512/3374] Create 675-cut-off-trees-for-golf-event.js

---
 675-cut-off-trees-for-golf-event.js | 63 +++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 675-cut-off-trees-for-golf-event.js

diff --git a/675-cut-off-trees-for-golf-event.js b/675-cut-off-trees-for-golf-event.js
new file mode 100644
index 00000000..4f70ad23
--- /dev/null
+++ b/675-cut-off-trees-for-golf-event.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[][]} forest
+ * @return {number}
+ */
+const cutOffTree = function (forest) {
+  const n = forest.length
+  if (n === 0) return 0
+  const m = forest[0].length
+  if (m === 0) return 0
+  const entries = []
+  for (let i = 0; i < n; i += 1) {
+    for (let j = 0; j < m; j += 1) {
+      if (forest[i][j] > 0) {
+        entries.push([forest[i][j], i, j])
+      }
+    }
+  }
+  entries.sort((e1, e2) => e1[0] - e2[0])
+  const direct = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+  ]
+  const visited = Array(n)
+    .fill(null)
+    .map(() => Array(m).fill(0))
+  const bfs = function (start, end) {
+    for (let i = 0; i < n; i += 1)
+      for (let j = 0; j < m; j += 1) visited[i][j] = 0
+    let cur = [start],
+      next = [],
+      step = 0
+    visited[start[0]][start[1]] = 1
+    while (cur.length > 0) {
+      next = []
+      for (const [x, y] of cur) {
+        if (x === end[0] && y === end[1]) return step
+        for (const [dx, dy] of direct) {
+          const p = x + dx,
+            q = y + dy
+          if (p < 0 || q < 0 || p >= n || q >= m || visited[p][q] === 1)
+            continue
+          if (forest[p][q] === 0) continue
+          visited[p][q] = 1
+          next.push([p, q])
+        }
+      }
+      step += 1
+      cur = next
+    }
+    return -1
+  }
+  let pre = [0, 0],
+    totalCnt = 0
+  for (const entry of entries) {
+    const step = bfs(pre, entry.slice(1))
+    if (step === -1) return -1
+    totalCnt += step
+    pre = entry.slice(1)
+  }
+  return totalCnt
+}

From 6878a779be5b939613699ec3c7f06f48d6a937d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Apr 2020 10:50:23 +0800
Subject: [PATCH 0513/3374] Update 675-cut-off-trees-for-golf-event.js

---
 675-cut-off-trees-for-golf-event.js | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/675-cut-off-trees-for-golf-event.js b/675-cut-off-trees-for-golf-event.js
index 4f70ad23..8e370aa8 100644
--- a/675-cut-off-trees-for-golf-event.js
+++ b/675-cut-off-trees-for-golf-event.js
@@ -39,9 +39,15 @@ const cutOffTree = function (forest) {
         for (const [dx, dy] of direct) {
           const p = x + dx,
             q = y + dy
-          if (p < 0 || q < 0 || p >= n || q >= m || visited[p][q] === 1)
+          if (
+            p < 0 ||
+            q < 0 ||
+            p >= n ||
+            q >= m ||
+            visited[p][q] === 1 ||
+            forest[p][q] === 0
+          )
             continue
-          if (forest[p][q] === 0) continue
           visited[p][q] = 1
           next.push([p, q])
         }

From 8af88d29f80a30ec0b21304ac3393dba49393a0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Apr 2020 11:02:41 +0800
Subject: [PATCH 0514/3374] Create 660-remove-9.js

---
 660-remove-9.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 660-remove-9.js

diff --git a/660-remove-9.js b/660-remove-9.js
new file mode 100644
index 00000000..70ef5763
--- /dev/null
+++ b/660-remove-9.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const newInteger = function (n) {
+  let res = ''
+  while (n > 0) {
+    res = (n % 9) + res
+    n = Math.floor(n / 9)
+  }
+  return parseInt(res, 10)
+}

From 8c2b0c264379d326f2da0ff927377d1a8ff2a3fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Apr 2020 15:56:01 +0800
Subject: [PATCH 0515/3374] Create 661-image-smoother.js

---
 661-image-smoother.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 661-image-smoother.js

diff --git a/661-image-smoother.js b/661-image-smoother.js
new file mode 100644
index 00000000..c55f98fd
--- /dev/null
+++ b/661-image-smoother.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} M
+ * @return {number[][]}
+ */
+const imageSmoother = function (M) {
+  const r = M.length
+  if (r === 0) return 0
+  const c = M[0].length
+  if (c === 0) return 0
+  const res = Array.from({ length: r }, () => Array(c).fill(0))
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      res[i][j] = helper(M, i, j, res)
+    }
+  }
+  return res
+}
+
+function helper(M, i, j, res) {
+  let val = M[i][j]
+  let num = 1
+  const dirs = [
+    [-1, -1],
+    [-1, 0],
+    [-1, 1],
+    [0, -1],
+    [0, 1],
+    [1, -1],
+    [1, 0],
+    [1, 1],
+  ]
+  for (let [dr, dc] of dirs) {
+    const ii = i + dr
+    const jj = j + dc
+    if (M[ii] != null && M[ii][jj] != null) {
+      val += M[ii][jj]
+      num++
+    }
+  }
+  return (val / num) >> 0
+}

From 7203f80a308fb976045422b5837328183051d6ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Apr 2020 08:24:38 +0800
Subject: [PATCH 0516/3374] Create
 702-search-in-a-sorted-array-of-unknown-size.js

---
 ...earch-in-a-sorted-array-of-unknown-size.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 702-search-in-a-sorted-array-of-unknown-size.js

diff --git a/702-search-in-a-sorted-array-of-unknown-size.js b/702-search-in-a-sorted-array-of-unknown-size.js
new file mode 100644
index 00000000..2b884a65
--- /dev/null
+++ b/702-search-in-a-sorted-array-of-unknown-size.js
@@ -0,0 +1,33 @@
+/**
+ * // This is the ArrayReader's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * function ArrayReader() {
+ *
+ *     @param {number} index
+ *     @return {number}
+ *     this.get = function(index) {
+ *         ...
+ *     };
+ * };
+ */
+
+/**
+ * @param {ArrayReader} reader
+ * @param {number} target
+ * @return {number}
+ */
+const search = function (reader, target) {
+  let left = 0,
+    right = 1
+  while (reader.get(right) < target) {
+    left = right
+    right <<= 1
+  }
+  while (left <= right) {
+    const mid = left + Math.floor((right - left) / 2)
+    if (reader.get(mid) === target) return mid
+    if (reader.get(mid) > target) right = mid - 1
+    else left = mid + 1
+  }
+  return -1
+}

From be15c9d1b4893bd7c5caf62211f3c75104baec53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Apr 2020 09:11:52 +0800
Subject: [PATCH 0517/3374] Create
 708-insert-into-a-sorted-circular-linked-list.js

---
 ...sert-into-a-sorted-circular-linked-list.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 708-insert-into-a-sorted-circular-linked-list.js

diff --git a/708-insert-into-a-sorted-circular-linked-list.js b/708-insert-into-a-sorted-circular-linked-list.js
new file mode 100644
index 00000000..6714c100
--- /dev/null
+++ b/708-insert-into-a-sorted-circular-linked-list.js
@@ -0,0 +1,32 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, next) {
+ *     this.val = val;
+ *     this.next = next;
+ * };
+ */
+
+/**
+ * @param {Node} head
+ * @param {number} insertVal
+ * @return {Node}
+ */
+const insert = function (head, insertVal) {
+  if (head === null) {
+    const node = new Node(insertVal)
+    node.next = node
+    return node
+  }
+  let prev = head,
+    cur = prev.next
+  while (cur != head) {
+    if (prev.val > cur.val) {
+      if (insertVal >= prev.val || insertVal <= cur.val) break
+    }
+    if (prev.val <= insertVal && insertVal <= cur.val) break
+    prev = cur
+    cur = cur.next
+  }
+  prev.next = new Node(insertVal, cur)
+  return head
+}

From f148338d8fc0c6f359388bcfd78e63b59563db18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Apr 2020 15:02:48 +0800
Subject: [PATCH 0518/3374] Create 710-random-pick-with-blacklist.js

---
 710-random-pick-with-blacklist.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 710-random-pick-with-blacklist.js

diff --git a/710-random-pick-with-blacklist.js b/710-random-pick-with-blacklist.js
new file mode 100644
index 00000000..700d339b
--- /dev/null
+++ b/710-random-pick-with-blacklist.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} N
+ * @param {number[]} blacklist
+ */
+const Solution = function (N, blacklist) {
+  this.map = new Map()
+  for (let b of blacklist) this.map.set(b, -1)
+  this.M = N - this.map.size
+  for (let b of blacklist) {
+    if (b < this.M) {
+      while (this.map.has(N - 1)) N--
+      this.map.set(b, N - 1)
+      N--
+    }
+  }
+}
+
+/**
+ * @return {number}
+ */
+Solution.prototype.pick = function () {
+  const p = Math.floor(Math.random() * this.M)
+  if (this.map.has(p)) return this.map.get(p)
+  return p
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * var obj = new Solution(N, blacklist)
+ * var param_1 = obj.pick()
+ */

From 2d8383a7170742b0dd3e7ce49417a8b0194beae5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Apr 2020 15:32:00 +0800
Subject: [PATCH 0519/3374] Create TBD-leftmost-column-with-at-least-a-one.js

---
 TBD-leftmost-column-with-at-least-a-one.js | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 TBD-leftmost-column-with-at-least-a-one.js

diff --git a/TBD-leftmost-column-with-at-least-a-one.js b/TBD-leftmost-column-with-at-least-a-one.js
new file mode 100644
index 00000000..bfd5e911
--- /dev/null
+++ b/TBD-leftmost-column-with-at-least-a-one.js
@@ -0,0 +1,34 @@
+/**
+ * // This is the BinaryMatrix's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * function BinaryMatrix() {
+ *     @param {integer} x, y
+ *     @return {integer}
+ *     this.get = function(x, y) {
+ *         ...
+ *     };
+ *
+ *     @return {[integer, integer]}
+ *     this.dimensions = function() {
+ *         ...
+ *     };
+ * };
+ */
+
+/**
+ * @param {BinaryMatrix} binaryMatrix
+ * @return {number}
+ */
+const leftMostColumnWithOne = function (binaryMatrix) {
+  const [rows, cols] = binaryMatrix.dimensions()
+  let candidate = -1
+  for (let r = 0, c = cols - 1; r < rows && c >= 0; ) {
+    if (binaryMatrix.get(r, c) === 1) {
+      candidate = c
+      c--
+    } else {
+      r++
+    }
+  }
+  return candidate
+}

From bab6dd6deda5929d7c9514700777c3a94fc0de73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Apr 2020 15:58:19 +0800
Subject: [PATCH 0520/3374] Create 711-number-of-distinct-islands-ii.js

---
 711-number-of-distinct-islands-ii.js | 58 ++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 711-number-of-distinct-islands-ii.js

diff --git a/711-number-of-distinct-islands-ii.js b/711-number-of-distinct-islands-ii.js
new file mode 100644
index 00000000..1a6e9bfe
--- /dev/null
+++ b/711-number-of-distinct-islands-ii.js
@@ -0,0 +1,58 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const numDistinctIslands2 = function (grid) {
+  const dirs = [
+    [0, 1],
+    [0, -1],
+    [-1, 0],
+    [1, 0],
+  ]
+  const rowSize = grid.length
+  const colSize = grid[0].length
+  const seen = Array.from({ length: rowSize }, () => Array(colSize).fill(false))
+  const islands = new Set()
+  for (let r = 0; r < rowSize; r++) {
+    for (let c = 0; c < colSize; c++) {
+      const shape = []
+      dfs(r, c, shape)
+      if (shape.length > 0) islands.add(canonical(shape))
+    }
+  }
+  return islands.size
+  function dfs(r, c, shape = []) {
+    if (!inBound(r, c) || grid[r][c] !== 1 || seen[r][c]) return
+    seen[r][c] = true
+    shape.push(r * colSize + c)
+    dirs.forEach(([dr, dc]) => dfs(r + dr, c + dc, shape))
+  }
+  function canonical(shape) {
+    let ans = ''
+    const lift = rowSize + colSize
+    const n = shape.length
+    const out = Array(n).fill(0)
+    const xs = Array(n).fill(0)
+    const ys = Array(n).fill(0)
+    for (let rotate = 0; rotate < 8; rotate++) {
+      for (let i = 0; i < n; i++) {
+        const x = ~~(shape[i] / colSize)
+        const y = shape[i] % colSize
+        xs[i] = rotate <= 1 ? x : rotate <= 3 ? -x : rotate <= 5 ? y : -y
+        ys[i] =
+          rotate <= 3 ? (rotate % 2 === 0 ? y : -y) : rotate % 2 === 0 ? x : -x
+      }
+      const mx = Math.min(...xs)
+      const my = Math.min(...ys)
+      for (let i = 0; i < n; i++) {
+        out[i] = (xs[i] - mx) * lift + (ys[i] - my)
+      }
+      const candidate = out.sort((a, b) => a - b).join(',')
+      if (ans < candidate) ans = candidate
+    }
+    return ans
+  }
+  function inBound(r, c) {
+    return r >= 0 && r < rowSize && c >= 0 && c < colSize
+  }
+}

From 423d7e6ed22eb8322bd4bdbf9eb510c8db533a07 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Apr 2020 13:30:52 +0800
Subject: [PATCH 0521/3374] Create 720-longest-word-in-dictionary.js

---
 720-longest-word-in-dictionary.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 720-longest-word-in-dictionary.js

diff --git a/720-longest-word-in-dictionary.js b/720-longest-word-in-dictionary.js
new file mode 100644
index 00000000..d1dce3a4
--- /dev/null
+++ b/720-longest-word-in-dictionary.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+const longestWord = function(words) {
+  if(words == null || words.length === 0) return ''
+  words.sort()
+  const s = new Set()
+  let res = ''
+  for(let i = 0, len = words.length; i < len; i++) {
+    const w = words[i]
+    if(w.length === 1 || s.has(w.slice(0, w.length - 1))) {
+      res = w.length > res.length ? w : res
+      s.add(w)
+    }
+  }
+  return res
+};

From 33c19d94b51c11c232105eef2192a1776407c92c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Apr 2020 14:28:30 +0800
Subject: [PATCH 0522/3374] Create 721-accounts-merge.js

---
 721-accounts-merge.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 721-accounts-merge.js

diff --git a/721-accounts-merge.js b/721-accounts-merge.js
new file mode 100644
index 00000000..f4a0be07
--- /dev/null
+++ b/721-accounts-merge.js
@@ -0,0 +1,35 @@
+/**
+ * @param {string[][]} accounts
+ * @return {string[][]}
+ */
+const accountsMerge = function (accounts) {
+  const roots = new Set()
+  const owner = {}
+  const parent = {}
+  const children = {}
+
+  for (let account of accounts) {
+    let [user, root, ...emails] = account
+    let r1 = find(root)
+    owner[root] = user
+    children[r1] = children[r1] || [root]
+    roots.add(r1)
+
+    for (let email of emails) {
+      let r2 = find(email)
+      if (r2 !== r1) {
+        parent[r2] = r1
+        children[r1].push(...(children[r2] ? children[r2] : [email]))
+        roots.delete(r2)
+        delete children[r2]
+      }
+    }
+  }
+
+  return [...roots].map((r) => [owner[r], ...children[r].sort()])
+
+  function find(a) {
+    parent[a] = parent[a] || a
+    return a === parent[a] ? a : find(parent[a])
+  }
+}

From 50a7eeea64b212976b2f0184847ce95b2f1b722b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Apr 2020 16:20:41 +0800
Subject: [PATCH 0523/3374] Create 722-remove-comments.js

---
 722-remove-comments.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 722-remove-comments.js

diff --git a/722-remove-comments.js b/722-remove-comments.js
new file mode 100644
index 00000000..901cc15d
--- /dev/null
+++ b/722-remove-comments.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string[]} source
+ * @return {string[]}
+ */
+const removeComments = function (source) {
+  const code = source.join('\n')
+  const isBlockStart = (c, i) => c[i] === '/' && c[i + 1] === '*'
+  const isBlockEnd = (c, i) => c[i] === '*' && c[i + 1] === '/'
+  const isLineStart = (c, i) => c[i] === '/' && c[i + 1] === '/'
+  const isNewLine = (c, i) => c[i] === '\n'
+  let i = 0,
+    output = ''
+
+  while (i < code.length) {
+    if (isBlockStart(code, i)) {
+      i += 2
+      while (!isBlockEnd(code, i) && i < code.length) i++
+      i += 2
+    } else if (isLineStart(code, i)) {
+      i += 2
+      while (!isNewLine(code, i) && i < code.length) i++
+    } else {
+      output += code[i++]
+    }
+  }
+
+  return output.split('\n').filter((l) => l.length)
+}

From 0511e46e5ddc39a7766aaa498f7f274ae31be25b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Apr 2020 16:38:52 +0800
Subject: [PATCH 0524/3374] Update 560-subarray-sum-equals-k.js

---
 560-subarray-sum-equals-k.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/560-subarray-sum-equals-k.js b/560-subarray-sum-equals-k.js
index cbce19c3..5024c772 100644
--- a/560-subarray-sum-equals-k.js
+++ b/560-subarray-sum-equals-k.js
@@ -5,10 +5,10 @@
  */
 const subarraySum = function(nums, k) {
   let totalNum = 0
-  let map = new Map()
+  const map = new Map()
   let cumulativeSum = 0
   map.set(0, 1)
-  for (let i = 0; i < nums.length; i++) {
+  for (let i = 0, len = nums.length; i < len; i++) {
     cumulativeSum += nums[i]
     if (map.get(cumulativeSum - k)) {
       totalNum += map.get(cumulativeSum - k)

From 425e5754720db249d3e4c560dfad3209d5ea7949 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Apr 2020 08:33:18 +0800
Subject: [PATCH 0525/3374] Create 727-minimum-window-subsequence.js

---
 727-minimum-window-subsequence.js | 47 +++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 727-minimum-window-subsequence.js

diff --git a/727-minimum-window-subsequence.js b/727-minimum-window-subsequence.js
new file mode 100644
index 00000000..54599fdb
--- /dev/null
+++ b/727-minimum-window-subsequence.js
@@ -0,0 +1,47 @@
+/**
+ * @param {string} S
+ * @param {string} T
+ * @return {string}
+ */
+const minWindow = function (S, T) {
+  if (S.length === 0 || T.length === 0) {
+    return ''
+  }
+  let right = 0
+  let minLen = Number.MAX_VALUE
+  let result = ''
+  while (right < S.length) {
+    let tIndex = 0
+    while (right < S.length) {
+      if (S.charAt(right) === T.charAt(tIndex)) {
+        tIndex++
+      }
+      if (tIndex === T.length) {
+        break
+      }
+      right++
+    }
+    if (right === S.length) {
+      break
+    }
+    let left = right
+    tIndex = T.length - 1
+    while (left >= 0) {
+      if (S.charAt(left) === T.charAt(tIndex)) {
+        tIndex--
+      }
+      if (tIndex < 0) {
+        break
+      }
+      left--
+    }
+    if (right - left + 1 < minLen) {
+      minLen = right - left + 1
+      result = S.slice(left, right + 1)
+    }
+    // we have to move right pointer to the next position of left pointer, NOT the next position
+    // of right pointer
+    right = left + 1
+  }
+  return result
+}

From ed33b513b99ef4f2327418d11494a1340ec25a52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Apr 2020 21:54:01 +0800
Subject: [PATCH 0526/3374] Update 201-bitwise-and-of-numbers-range.js

---
 201-bitwise-and-of-numbers-range.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/201-bitwise-and-of-numbers-range.js b/201-bitwise-and-of-numbers-range.js
index ab7ee841..7ab808b4 100644
--- a/201-bitwise-and-of-numbers-range.js
+++ b/201-bitwise-and-of-numbers-range.js
@@ -7,3 +7,20 @@ const rangeBitwiseAnd = function(m, n) {
   while(m<n) n = n & (n-1);
   return n;
 };
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const rangeBitwiseAnd = function(m, n) {
+  let s = 0
+  while(m !== n) {
+    m >>= 1
+    n >>= 1
+    s++
+  }
+  return m << s
+};

From 6a9a8f56378fc4481d257f540b3401259be695ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Apr 2020 14:11:20 +0800
Subject: [PATCH 0527/3374] Create 734-sentence-similarity.js

---
 734-sentence-similarity.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 734-sentence-similarity.js

diff --git a/734-sentence-similarity.js b/734-sentence-similarity.js
new file mode 100644
index 00000000..af0b37d5
--- /dev/null
+++ b/734-sentence-similarity.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string[]} words1
+ * @param {string[]} words2
+ * @param {string[][]} pairs
+ * @return {boolean}
+ */
+const areSentencesSimilar = function(words1, words2, pairs) {
+  if(pairs == null || pairs.length === 0) {
+    if(words1.length === words2.length) return true
+    return false
+  }
+  const m = new Map()
+  for(let p of pairs) {
+    if(!m.has(p[0])) m.set(p[0], new Set())
+    m.get(p[0]).add(p[1])
+    if(!m.has(p[1])) m.set(p[1], new Set())
+    m.get(p[1]).add(p[0])
+  }
+  for(let i = 0, len = Math.max(words1.length, words2.length); i < len; i++) {
+    const c1 = words1[i]
+    const c2 = words2[i]
+    if( c1 === c2 ) continue
+    if( !(m.has(c1) && m.get(c1).has(c2)) ) return false
+  }
+  return true
+};

From 21c8b1ec87f1c0fb359852e1f32935fb8ccc9717 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Apr 2020 16:44:46 +0800
Subject: [PATCH 0528/3374] Update 146-lru-cache.js

---
 146-lru-cache.js | 47 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/146-lru-cache.js b/146-lru-cache.js
index 52ee77b5..90bb19f1 100755
--- a/146-lru-cache.js
+++ b/146-lru-cache.js
@@ -80,3 +80,50 @@ LRUCache.prototype.put = function(key, value) {
  * var param_1 = obj.get(key)
  * obj.put(key,value)
  */
+
+// another
+
+/**
+ * @param {number} capacity
+ */
+const LRUCache = function(capacity) {
+  this.m = new Map()
+  this.l = capacity
+};
+
+/** 
+ * @param {number} key
+ * @return {number}
+ */
+LRUCache.prototype.get = function(key) {
+  if(!this.m.has(key)) return -1
+  const v = this.m.get(key)
+  this.m.delete(key)
+  this.m.set(key, v)
+  return v
+};
+
+/** 
+ * @param {number} key 
+ * @param {number} value
+ * @return {void}
+ */
+LRUCache.prototype.put = function(key, value) {
+  if(this.m.has(key)) {
+    this.m.delete(key)
+    this.m.set(key, value)
+  } else {
+    if(this.m.size >= this.l) {
+      const k = this.m.keys().next().value
+      this.m.delete(k)
+    }
+    this.m.set(key, 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)
+ */

From 220fdaabc2c1a02bc1aff6573f91f1586ed0a86e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Apr 2020 17:28:33 +0800
Subject: [PATCH 0529/3374] Create 729-my-calendar-i.js

---
 729-my-calendar-i.js | 49 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 729-my-calendar-i.js

diff --git a/729-my-calendar-i.js b/729-my-calendar-i.js
new file mode 100644
index 00000000..789e8c78
--- /dev/null
+++ b/729-my-calendar-i.js
@@ -0,0 +1,49 @@
+const MyCalendar = function () {
+  this.root = null
+}
+
+const Node = function (start, end) {
+  this.start = start
+  this.end = end
+  this.left = null
+  this.right = null
+}
+
+Node.prototype.insert = function (node) {
+  if (node.start >= this.end) {
+    if (this.right === null) {
+      this.right = node
+      return true
+    }
+    return this.right.insert(node)
+  } else if (node.end <= this.start) {
+    if (this.left === null) {
+      this.left = node
+      return true
+    }
+    return this.left.insert(node)
+  } else {
+    return false
+  }
+}
+
+/**
+ * @param {number} start
+ * @param {number} end
+ * @return {boolean}
+ */
+MyCalendar.prototype.book = function (start, end) {
+  const newNode = new Node(start, end)
+  if (this.root === null) {
+    this.root = newNode
+    return true
+  } else {
+    return this.root.insert(newNode)
+  }
+}
+
+/**
+ * Your MyCalendar object will be instantiated and called as such:
+ * var obj = new MyCalendar()
+ * var param_1 = obj.book(start,end)
+ */

From 64580d619326b61c743c5102c73681c7974d2d63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Apr 2020 23:09:09 +0800
Subject: [PATCH 0530/3374] Update 729-my-calendar-i.js

---
 729-my-calendar-i.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/729-my-calendar-i.js b/729-my-calendar-i.js
index 789e8c78..22425c94 100644
--- a/729-my-calendar-i.js
+++ b/729-my-calendar-i.js
@@ -47,3 +47,28 @@ MyCalendar.prototype.book = function (start, end) {
  * var obj = new MyCalendar()
  * var param_1 = obj.book(start,end)
  */
+
+// another
+
+const MyCalendar = function() {
+  this.s = new Set()
+};
+
+/** 
+ * @param {number} start 
+ * @param {number} end
+ * @return {boolean}
+ */
+MyCalendar.prototype.book = function(start, end) {
+  for(let e of this.s) {
+    if(Math.max(start, e[0]) < Math.min(end, e[1])) return false
+  }
+  this.s.add([start, end])
+  return true
+};
+
+/** 
+ * Your MyCalendar object will be instantiated and called as such:
+ * var obj = new MyCalendar()
+ * var param_1 = obj.book(start,end)
+ */

From 483e91fa00e1f41c19e5dfc8b37788493adc8066 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Apr 2020 13:56:28 +0800
Subject: [PATCH 0531/3374] Create 731-my-calendar-ii.js

---
 731-my-calendar-ii.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 731-my-calendar-ii.js

diff --git a/731-my-calendar-ii.js b/731-my-calendar-ii.js
new file mode 100644
index 00000000..056a06cc
--- /dev/null
+++ b/731-my-calendar-ii.js
@@ -0,0 +1,32 @@
+const MyCalendarTwo = function () {
+  this.calendar = []
+  this.overlaps = []
+}
+
+/**
+ * @param {number} start
+ * @param {number} end
+ * @return {boolean}
+ */
+MyCalendarTwo.prototype.book = function (start, end) {
+  for (let i = 0; i < this.overlaps.length; i++) {
+    if (start < this.overlaps[i].end && end > this.overlaps[i].start)
+      return false
+  }
+
+  for (let i = 0; i < this.calendar.length; i++) {
+    if (start < this.calendar[i].end && end > this.calendar[i].start)
+      this.overlaps.push({
+        start: Math.max(start, this.calendar[i].start),
+        end: Math.min(end, this.calendar[i].end),
+      })
+  }
+  this.calendar.push({ start: start, end: end })
+  return true
+}
+
+/**
+ * Your MyCalendarTwo object will be instantiated and called as such:
+ * var obj = new MyCalendarTwo()
+ * var param_1 = obj.book(start,end)
+ */

From f9398a9b48dcb4ee68120bcd9d11cc97a62d0a1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Apr 2020 18:39:57 +0800
Subject: [PATCH 0532/3374] Update 55-jump-game.js

---
 55-jump-game.js | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/55-jump-game.js b/55-jump-game.js
index 500c4e63..d9185fcf 100644
--- a/55-jump-game.js
+++ b/55-jump-game.js
@@ -3,14 +3,11 @@
  * @return {boolean}
  */
 const canJump = function(nums) {
-    const len = nums.length
-    let maxIdx = 0
-    for(let i = 0; i < len; i++) {
-        if (i <= maxIdx) {
-            maxIdx = Math.max(maxIdx, i + nums[i])
-        } else {
-            break
-        }
+  let max = 0
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(i <= max && nums[i] > 0) {
+      max = Math.max(max, i + nums[i])
     }
-    return maxIdx >= len - 1 ? true : false
+  }
+  return max >= nums.length - 1
 };

From 2c20f5d7ce8f7e73cb2a38f88cec6ff4813963b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Apr 2020 22:19:53 +0800
Subject: [PATCH 0533/3374] Create 723-candy-crush.js

---
 723-candy-crush.js | 84 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 723-candy-crush.js

diff --git a/723-candy-crush.js b/723-candy-crush.js
new file mode 100644
index 00000000..d37693b2
--- /dev/null
+++ b/723-candy-crush.js
@@ -0,0 +1,84 @@
+/**
+ * @param {number[][]} board
+ * @return {number[][]}
+ */
+const candyCrush = function (board) {
+  while (true) {
+    let moreToCrush = false
+    for (let i = 0; i < board.length; i++) {
+      for (let j = 0; j < board[0].length; j++) {
+        if (board[i][j] > 0) {
+          moreToCrush =
+            flagForCrush(board, i, j, board[i][j], 0, true, false) ||
+            moreToCrush
+          moreToCrush =
+            flagForCrush(board, i, j, board[i][j], 0, false, true) ||
+            moreToCrush
+        }
+      }
+    }
+    if (!moreToCrush) break
+    crush(board)
+    inflictGravity(board)
+  }
+  return board
+}
+const flagForCrush = function (board, i, j, target, count, right, down) {
+  if (
+    j === board[0].length ||
+    i === board.length ||
+    Math.abs(board[i][j]) !== Math.abs(target)
+  ) {
+    return count >= 3
+  }
+
+  let shouldFlagIndexRight = flagForCrush(
+    board,
+    i,
+    j + 1,
+    target,
+    right ? count + 1 : 1,
+    true,
+    false
+  )
+  let shouldFlagIndexDown = flagForCrush(
+    board,
+    i + 1,
+    j,
+    target,
+    down ? count + 1 : 1,
+    false,
+    true
+  )
+
+  if ((shouldFlagIndexRight && right) || (shouldFlagIndexDown && down)) {
+    board[i][j] = -Math.abs(board[i][j])
+    return true
+  }
+
+  return false
+}
+const crush = function (board) {
+  for (let i = 0; i < board.length; i++) {
+    for (let j = 0; j < board[0].length; j++) {
+      if (board[i][j] < 0) board[i][j] = 0
+    }
+  }
+}
+const inflictGravity = function (board) {
+  for (let j = 0; j < board[0].length; j++) {
+    let st = board.length - 1
+    let end = board.length - 2
+    while (end >= 0) {
+      if (board[st][j] === 0 && board[end][j] !== 0) {
+        let temp = board[st][j]
+        board[st][j] = board[end][j]
+        board[end][j] = temp
+        st--
+      } else if (board[st][j] !== 0) {
+        st--
+      }
+      end--
+    }
+  }
+}

From ca265f5f5d4d2441da6036965116154c86f250c8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 08:40:18 +0800
Subject: [PATCH 0534/3374] Update 723-candy-crush.js

---
 723-candy-crush.js | 55 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/723-candy-crush.js b/723-candy-crush.js
index d37693b2..338d87c3 100644
--- a/723-candy-crush.js
+++ b/723-candy-crush.js
@@ -82,3 +82,58 @@ const inflictGravity = function (board) {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} board
+ * @return {number[][]}
+ */
+const candyCrush = function (board) {
+  const N = board.length,
+    M = board[0].length
+  let found = true
+  while (found) {
+    found = false
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < M; j++) {
+        const val = Math.abs(board[i][j])
+        if (val === 0) continue
+        if (
+          j < M - 2 &&
+          Math.abs(board[i][j + 1]) == val &&
+          Math.abs(board[i][j + 2]) == val
+        ) {
+          found = true
+          let ind = j
+          while (ind < M && Math.abs(board[i][ind]) == val)
+            board[i][ind++] = -val
+        }
+        if (
+          i < N - 2 &&
+          Math.abs(board[i + 1][j]) == val &&
+          Math.abs(board[i + 2][j]) == val
+        ) {
+          found = true
+          let ind = i
+          while (ind < N && Math.abs(board[ind][j]) == val)
+            board[ind++][j] = -val
+        }
+      }
+    }
+    if (found) {
+      // move positive values to the bottom, then set the rest to 0
+      for (let j = 0; j < M; j++) {
+        let storeInd = N - 1
+        for (let i = N - 1; i >= 0; i--) {
+          if (board[i][j] > 0) {
+            board[storeInd--][j] = board[i][j]
+          }
+        }
+        for (let k = storeInd; k >= 0; k--) board[k][j] = 0
+      }
+    }
+  }
+  return board
+}
+

From e589510d79e735b3623c941f205d792217bdd27b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 09:05:23 +0800
Subject: [PATCH 0535/3374] Update 723-candy-crush.js

---
 723-candy-crush.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/723-candy-crush.js b/723-candy-crush.js
index 338d87c3..1d5f7f56 100644
--- a/723-candy-crush.js
+++ b/723-candy-crush.js
@@ -101,22 +101,22 @@ const candyCrush = function (board) {
         if (val === 0) continue
         if (
           j < M - 2 &&
-          Math.abs(board[i][j + 1]) == val &&
-          Math.abs(board[i][j + 2]) == val
+          Math.abs(board[i][j + 1]) === val &&
+          Math.abs(board[i][j + 2]) === val
         ) {
           found = true
           let ind = j
-          while (ind < M && Math.abs(board[i][ind]) == val)
+          while (ind < Math.min(M, j + 3) && Math.abs(board[i][ind]) === val)
             board[i][ind++] = -val
         }
         if (
           i < N - 2 &&
-          Math.abs(board[i + 1][j]) == val &&
-          Math.abs(board[i + 2][j]) == val
+          Math.abs(board[i + 1][j]) === val &&
+          Math.abs(board[i + 2][j]) === val
         ) {
           found = true
           let ind = i
-          while (ind < N && Math.abs(board[ind][j]) == val)
+          while (ind < Math.min(N, i + 3) && Math.abs(board[ind][j]) === val)
             board[ind++][j] = -val
         }
       }

From cf6aac017a275cb22242412da71acf7b40e4c519 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 13:39:08 +0800
Subject: [PATCH 0536/3374] Create 736-parse-lisp-expression.js

---
 736-parse-lisp-expression.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 736-parse-lisp-expression.js

diff --git a/736-parse-lisp-expression.js b/736-parse-lisp-expression.js
new file mode 100644
index 00000000..c13d3304
--- /dev/null
+++ b/736-parse-lisp-expression.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} expression
+ * @return {number}
+ */
+const evaluate = (x) =>
+  e(
+    JSON.parse(
+      x.replace(/[() ]|([a-z][a-z0-9]*)/g, (m) =>
+        m == '(' ? '[' : m == ')' ? ']' : m == ' ' ? ',' : `"${m}"`
+      )
+    )
+  )
+const e = (x, v = []) =>
+  ({
+    string: () => v.find((y) => y[0] === x)[1],
+    number: () => x,
+    object: () =>
+      ({
+        add: () => e(x[1], v) + e(x[2], v),
+        mult: () => e(x[1], v) * e(x[2], v),
+        let: () =>
+          e(
+            x[x.length - 1],
+            x
+              .slice(1, -1)
+              .reduce(
+                ({ v, t }, z) =>
+                  t ? { v: [[t, e(z, v)], ...v] } : { v, t: z },
+                { v }
+              ).v
+          ),
+      }[x[0]]()),
+  }[typeof x]())

From 2d991c089e8a17b0a50cb3a43acf8cdbac2af279 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 13:44:34 +0800
Subject: [PATCH 0537/3374] Update 736-parse-lisp-expression.js

---
 736-parse-lisp-expression.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/736-parse-lisp-expression.js b/736-parse-lisp-expression.js
index c13d3304..77f81c0b 100644
--- a/736-parse-lisp-expression.js
+++ b/736-parse-lisp-expression.js
@@ -6,7 +6,7 @@ const evaluate = (x) =>
   e(
     JSON.parse(
       x.replace(/[() ]|([a-z][a-z0-9]*)/g, (m) =>
-        m == '(' ? '[' : m == ')' ? ']' : m == ' ' ? ',' : `"${m}"`
+        m === '(' ? '[' : m === ')' ? ']' : m === ' ' ? ',' : `"${m}"`
       )
     )
   )

From c99c670ef6ff3ec0d0c23f4bc1b06793e3f94fc3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 14:02:09 +0800
Subject: [PATCH 0538/3374] Update 736-parse-lisp-expression.js

---
 736-parse-lisp-expression.js | 86 ++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/736-parse-lisp-expression.js b/736-parse-lisp-expression.js
index 77f81c0b..71dd2132 100644
--- a/736-parse-lisp-expression.js
+++ b/736-parse-lisp-expression.js
@@ -31,3 +31,89 @@ const e = (x, v = []) =>
           ),
       }[x[0]]()),
   }[typeof x]())
+
+// another
+
+/**
+ * @param {string} expression
+ * @return {number}
+ */
+const evaluate = function (expression) {
+  const tokens = tokenizer(expression)
+  let i = 0
+  function exec(scope) {
+    let value = null
+    const next = tokens[i++]
+    if (next === '(') {
+      scope = enter(scope)
+      switch (tokens[i++]) {
+        case 'add':
+          const a = exec(scope)
+          const b = exec(scope)
+          value = a + b
+          break
+        case 'mult':
+          const x = exec(scope)
+          const y = exec(scope)
+          value = x * y
+          break
+        case 'let':
+          while (tokens[i] !== '(' && tokens[i + 1] !== ')') {
+            scope.variables[tokens[i++]] = exec(scope)
+          }
+          value = exec(scope)
+          break
+      }
+      scope = exit(scope)
+      i++
+    } else if (isNumber(next)) {
+      value = Number(next)
+    } else {
+      // Find variable in current scope otherwise go to parent
+      let t = scope
+      while (t) {
+        if (next in t.variables) {
+          value = t.variables[next]
+          break
+        }
+        t = t.parent
+      }
+    }
+    return value
+  }
+  return exec(newScope())
+}
+function tokenizer(expression) {
+  const tokens = []
+  let token = ''
+  for (const c of expression) {
+    if (c === '(' || c === ')') {
+      if (token) tokens.push(token)
+      tokens.push(c)
+      token = ''
+    } else if (c === ' ') {
+      if (token) tokens.push(token)
+      token = ''
+    } else {
+      token += c
+    }
+  }
+  if (token) {
+    tokens.push(token)
+  }
+  return tokens
+}
+function isNumber(n) {
+  return !isNaN(n)
+}
+function newScope() {
+  return { parent: null, variables: {} }
+}
+function enter(scope) {
+  const next = newScope()
+  next.parent = scope
+  return next
+}
+function exit(scope) {
+  return scope.parent
+}

From bf47088fccdd6812a7cec48771deb393cb0edbce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 15:54:44 +0800
Subject: [PATCH 0539/3374] Update 1143-longest-common-subsequence.js

---
 1143-longest-common-subsequence.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1143-longest-common-subsequence.js b/1143-longest-common-subsequence.js
index afa76a1f..8102006a 100644
--- a/1143-longest-common-subsequence.js
+++ b/1143-longest-common-subsequence.js
@@ -15,3 +15,30 @@ const longestCommonSubsequence = function(text1, text2) {
   }
   return dp[dp.length - 1].pop()
 }
+
+// another
+
+/**
+ * @param {string} text1
+ * @param {string} text2
+ * @return {number}
+ */
+const longestCommonSubsequence = function(text1, text2) {
+  const len1 = text1.length
+  const len2 = text2.length
+  if(len1 === 0 || len2 === 0) return 0
+  if(len1 < len2) return longestCommonSubsequence(text2, text1)
+  const dp = Array(len1 + 1).fill(0)
+  for(let i = 1; i <= len2; i++) {
+    let prev = 0
+    for(let j = 1; j <= len1; j++) {
+      const tmp = dp[j]
+      if(text1[j - 1] === text2[i - 1]) dp[j] = Math.max(dp[j], prev + 1)
+      else {
+        dp[j] = Math.max(dp[j - 1], dp[j])
+      }
+      prev = tmp
+    }
+  }
+  return dp[len1]
+};

From f8dd2d9587a0c420564535e366d638be9d61c62a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 15:58:07 +0800
Subject: [PATCH 0540/3374] Update 1143-longest-common-subsequence.js

---
 1143-longest-common-subsequence.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/1143-longest-common-subsequence.js b/1143-longest-common-subsequence.js
index 8102006a..9e856a67 100644
--- a/1143-longest-common-subsequence.js
+++ b/1143-longest-common-subsequence.js
@@ -27,18 +27,17 @@ const longestCommonSubsequence = function(text1, text2) {
   const len1 = text1.length
   const len2 = text2.length
   if(len1 === 0 || len2 === 0) return 0
-  if(len1 < len2) return longestCommonSubsequence(text2, text1)
-  const dp = Array(len1 + 1).fill(0)
-  for(let i = 1; i <= len2; i++) {
+  const dp = Array(len2 + 1).fill(0)
+  for(let i = 1; i <= len1; i++) {
     let prev = 0
-    for(let j = 1; j <= len1; j++) {
+    for(let j = 1; j <= len2; j++) {
       const tmp = dp[j]
-      if(text1[j - 1] === text2[i - 1]) dp[j] = Math.max(dp[j], prev + 1)
+      if(text1[i - 1] === text2[j - 1]) dp[j] = Math.max(dp[j], prev + 1)
       else {
         dp[j] = Math.max(dp[j - 1], dp[j])
       }
       prev = tmp
     }
   }
-  return dp[len1]
+  return dp[len2]
 };

From 4e13176f5dfd31c13d10fb30c451923923812121 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Apr 2020 16:55:26 +0800
Subject: [PATCH 0541/3374] Create 737-sentence-similarity-ii.js

---
 737-sentence-similarity-ii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 737-sentence-similarity-ii.js

diff --git a/737-sentence-similarity-ii.js b/737-sentence-similarity-ii.js
new file mode 100644
index 00000000..e0448540
--- /dev/null
+++ b/737-sentence-similarity-ii.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[]} words1
+ * @param {string[]} words2
+ * @param {string[][]} pairs
+ * @return {boolean}
+ */
+const areSentencesSimilarTwo = function (words1, words2, pairs) {
+  if (words1.length !== words2.length) return false
+  const parent = {}
+
+  function getParent(word) {
+    if (parent[word] === undefined || parent[word] === word) return word
+    return getParent(parent[word])
+  }
+  for (let [w1, w2] of pairs) {
+    if (w1 > w2) [w1, w2] = [w2, w1]
+    parent[w1] = getParent(w1)
+    if (parent[w2] !== undefined) parent[getParent(w2)] = parent[w1]
+    parent[w2] = parent[w1]
+  }
+  for (let i = 0; i < words1.length; i++) {
+    let w1 = words1[i]
+    let w2 = words2[i]
+    if (getParent(w1) !== getParent(w2)) return false
+  }
+  return true
+}

From 702b448196b3dbf728401d3f5dc027bfdbc4300c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Apr 2020 13:50:37 +0800
Subject: [PATCH 0542/3374] Create 740-delete-and-earn.js

---
 740-delete-and-earn.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 740-delete-and-earn.js

diff --git a/740-delete-and-earn.js b/740-delete-and-earn.js
new file mode 100644
index 00000000..eab5407a
--- /dev/null
+++ b/740-delete-and-earn.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const deleteAndEarn = function (nums) {
+  const n = 10001
+  const values = new Array(n).fill(0)
+  for (let num of nums) values[num] += num
+
+  let take = 0,
+    skip = 0
+  for (let i = 0; i < n; i++) {
+    const takei = skip + values[i]
+    const skipi = Math.max(skip, take)
+    take = takei
+    skip = skipi
+  }
+  return Math.max(take, skip)
+}

From b96a58190474aea7e3a998b3f7f210d419db6296 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Apr 2020 09:19:55 +0800
Subject: [PATCH 0543/3374] Create 743-network-delay-time.js

---
 743-network-delay-time.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 743-network-delay-time.js

diff --git a/743-network-delay-time.js b/743-network-delay-time.js
new file mode 100644
index 00000000..e66a70c4
--- /dev/null
+++ b/743-network-delay-time.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[][]} times
+ * @param {number} N
+ * @param {number} K
+ * @return {number}
+ */
+const networkDelayTime = function (times, N, K) {
+  const mins = new Array(N).fill(Infinity)
+  mins[K - 1] = 0
+  for (let i = 0; i < N; i++) {
+    for (let [u, v, t] of times) {
+      if (mins[u - 1] === Infinity) continue
+      if (mins[v - 1] > mins[u - 1] + t) {
+        mins[v - 1] = mins[u - 1] + t
+      }
+    }
+  }
+  return mins.includes(Infinity) ? -1 : Math.max(...mins)
+}

From 1a72f51d70f2f1e8afde51be67a8faf3495c32ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Apr 2020 16:25:04 +0800
Subject: [PATCH 0544/3374] Create
 744-find-smallest-letter-greater-than-target.js

---
 744-find-smallest-letter-greater-than-target.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 744-find-smallest-letter-greater-than-target.js

diff --git a/744-find-smallest-letter-greater-than-target.js b/744-find-smallest-letter-greater-than-target.js
new file mode 100644
index 00000000..22878116
--- /dev/null
+++ b/744-find-smallest-letter-greater-than-target.js
@@ -0,0 +1,14 @@
+/**
+ * @param {character[]} letters
+ * @param {character} target
+ * @return {character}
+ */
+const nextGreatestLetter = function(letters, target) {
+  const arr = Array.from(new Set(letters))
+  const len = arr.length
+  const t = target.charCodeAt(0)
+  for(let i = 0, len = arr.length; i < len; i++) {
+    if(arr[i].charCodeAt(0) - t > 0) return arr[i]
+  }
+  return arr[0]
+};

From 4f7962d20088b94d89cc8044e745224b71b729b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Apr 2020 16:41:00 +0800
Subject: [PATCH 0545/3374] Update
 744-find-smallest-letter-greater-than-target.js

---
 ...ind-smallest-letter-greater-than-target.js | 19 +++++++++++--------
 1 file changed, 11 insertions(+), 8 deletions(-)

diff --git a/744-find-smallest-letter-greater-than-target.js b/744-find-smallest-letter-greater-than-target.js
index 22878116..a6980a51 100644
--- a/744-find-smallest-letter-greater-than-target.js
+++ b/744-find-smallest-letter-greater-than-target.js
@@ -3,12 +3,15 @@
  * @param {character} target
  * @return {character}
  */
-const nextGreatestLetter = function(letters, target) {
-  const arr = Array.from(new Set(letters))
-  const len = arr.length
-  const t = target.charCodeAt(0)
-  for(let i = 0, len = arr.length; i < len; i++) {
-    if(arr[i].charCodeAt(0) - t > 0) return arr[i]
+const nextGreatestLetter = function (letters, target) {
+  const n = letters.length
+  if (target < letters[0] || target >= letters[n - 1]) return letters[0]
+  let left = 0
+  let right = n - 1
+  while (left < right) {
+    let mid = left + ((right - left) >> 1)
+    if (letters[mid] <= target) left = mid + 1
+    else right = mid
   }
-  return arr[0]
-};
+  return letters[right]
+}

From ce0bed51d7957ef0ca8858055ab60ed7a2a7437d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Apr 2020 08:47:27 +0800
Subject: [PATCH 0546/3374] Create 745-prefix-and-suffix-search.js

---
 745-prefix-and-suffix-search.js | 61 +++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 745-prefix-and-suffix-search.js

diff --git a/745-prefix-and-suffix-search.js b/745-prefix-and-suffix-search.js
new file mode 100644
index 00000000..cd283984
--- /dev/null
+++ b/745-prefix-and-suffix-search.js
@@ -0,0 +1,61 @@
+/**
+ * @param {string[]} words
+ */
+const WordFilter = function (words) {
+  this.trie = new trie()
+  let val = 0
+  for (let word of words) {
+    /* suffix # prefix */
+    let temp = ''
+    this.trie.insert('#' + word, val)
+    this.trie.insert(word + '#', val)
+    for (let i = 0; i < word.length; i++) {
+      temp = word.substring(i)
+      temp += '#' + word
+      this.trie.insert(temp, val)
+    }
+    val++
+  }
+}
+/**
+ * @param {string} prefix
+ * @param {string} suffix
+ * @return {number}
+ */
+WordFilter.prototype.f = function (prefix, suffix) {
+  return this.trie.startsWith(suffix + '#' + prefix)
+}
+/**
+ * Your WordFilter object will be instantiated and called as such:
+ * var obj = new WordFilter(words)
+ * var param_1 = obj.f(prefix,suffix)
+ */
+const trie = function () {
+  this.map = new Map()
+  this.isEnd = false
+  this.val = -1
+}
+trie.prototype.insert = function (word, val) {
+  let temp = this
+  let i = 0
+  while (i < word.length && temp.map.has(word[i])) {
+    temp.val = Math.max(temp.val, val)
+    temp = temp.map.get(word[i++])
+  }
+  while (i < word.length) {
+    let t2 = new trie()
+    temp.map.set(word[i++], t2)
+    temp.val = Math.max(temp.val, val)
+    temp = t2
+  }
+  temp.isEnd = true
+  temp.val = Math.max(temp.val, val)
+  return true
+}
+trie.prototype.startsWith = function (prefix) {
+  let temp = this
+  let i = 0
+  while (i < prefix.length && temp.map.has(prefix[i]))
+    temp = temp.map.get(prefix[i++])
+  return i >= prefix.length ? temp.val : -1
+}

From 9ce349bede25e75e406becc916e2e832494fa3c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Apr 2020 15:47:57 +0800
Subject: [PATCH 0547/3374] Create
 747-largest-number-at-least-twice-of-others.js

---
 747-largest-number-at-least-twice-of-others.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 747-largest-number-at-least-twice-of-others.js

diff --git a/747-largest-number-at-least-twice-of-others.js b/747-largest-number-at-least-twice-of-others.js
new file mode 100644
index 00000000..d78a10ef
--- /dev/null
+++ b/747-largest-number-at-least-twice-of-others.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const dominantIndex = function(nums) {
+  let max = -Infinity
+  let idx = -1
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(nums[i] > max) {
+      max = nums[i]
+      idx = i
+    }
+  }
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(nums[i] !== max && max < nums[i] * 2) return -1
+  }
+  return idx
+};

From 757e4f9c3b06efff704b51f22fba2827e213b224 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Apr 2020 09:05:32 +0800
Subject: [PATCH 0548/3374] Create 749-contain-virus.js

---
 749-contain-virus.js | 102 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 749-contain-virus.js

diff --git a/749-contain-virus.js b/749-contain-virus.js
new file mode 100644
index 00000000..eaf6c1e4
--- /dev/null
+++ b/749-contain-virus.js
@@ -0,0 +1,102 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const containVirus = function (grid) {
+  const infected = 1
+  const healthy = 0
+  const quarantined = 2
+  const directions = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+  ]
+  const mod = 100
+  const encode = (row, col) => row + col * mod
+  const decode = (num) => [num % mod, Math.floor(num / mod)]
+  const disjointSet = {}
+  for (let row = 0; row < grid.length; row++) {
+    for (let col = 0; col < grid[row].length; col++) {
+      const coord = encode(row, col)
+      disjointSet[coord] = coord
+      if (grid[row][col] === 0) continue
+      if (grid[row][col - 1] === 1) union(coord, encode(row, col - 1))
+      if (row > 0 && grid[row - 1][col] === 1)
+        union(coord, encode(row - 1, col))
+    }
+  }
+  let numWalls = 0
+  while (true) {
+    const impact = quarantineAndContaminate()
+    if (impact === 0) return numWalls
+    numWalls += impact
+    spreadVirus()
+  }
+  function find(coord) {
+    return (disjointSet[coord] =
+      disjointSet[coord] === coord ? coord : find(disjointSet[coord]))
+  }
+  function union(coord, toCoord) {
+    return (disjointSet[find(coord)] = find(toCoord))
+  }
+  function quarantineAndContaminate() {
+    const impact = new Map()
+    for (let row = 0; row < grid.length; row++) {
+      for (let col = 0; col < grid[row].length; col++) {
+        if (grid[row][col] !== infected) continue
+        const root = find(encode(row, col))
+        if (!impact.has(root)) impact.set(root, new Set())
+        for (let [down, right] of directions) {
+          if (grid[row + down] && grid[row + down][col + right] === healthy) {
+            impact.get(root).add(encode(row + down, col + right))
+          }
+        }
+      }
+    }
+    let impactedCoords = new Set()
+    let root = null
+    for (let [node, coords] of impact) {
+      if (impactedCoords.size < coords.size) {
+        impactedCoords = coords
+        root = node
+      }
+    }
+    if (impactedCoords.size === 0) return 0
+    return quarantine(...decode(root))
+  }
+  function quarantine(row, col) {
+    if (row < 0 || row >= grid.length || col < 0 || col >= grid[0].length)
+      return 0
+    if (grid[row][col] === 2) return 0
+    if (grid[row][col] === 0) return 1
+    let totalWalls = 0
+    grid[row][col] = 2
+    for (let [down, right] of directions) {
+      totalWalls += quarantine(row + down, col + right)
+    }
+    return totalWalls
+  }
+  function spreadVirus() {
+    const infectedCoords = new Set()
+    for (let row = 0; row < grid.length; row++) {
+      for (let col = 0; col < grid[row].length; col++) {
+        if (grid[row][col] !== healthy) continue
+        for (let [down, right] of directions) {
+          if (grid[row + down] && grid[row + down][col + right] === infected) {
+            infectedCoords.add(encode(row, col))
+          }
+        }
+      }
+    }
+    for (let coord of infectedCoords) {
+      const [row, col] = decode(coord)
+      grid[row][col] = 1
+      for (let [down, right] of directions) {
+        if (grid[row + down] && grid[row + down][col + right] === 1) {
+          union(coord, encode(row + down, col + right))
+        }
+      }
+    }
+  }
+}

From 0b86f9279bdf6530ffaf6adaa70e6c20bbd724c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Apr 2020 13:25:18 +0800
Subject: [PATCH 0549/3374] Update 749-contain-virus.js

---
 749-contain-virus.js | 106 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)

diff --git a/749-contain-virus.js b/749-contain-virus.js
index eaf6c1e4..5de542f3 100644
--- a/749-contain-virus.js
+++ b/749-contain-virus.js
@@ -1,3 +1,109 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const containVirus = function (grid) {
+  const R = grid.length
+  const C = grid[0].length
+  let ans = 0
+  const dirs = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0],
+  ]
+  while (true) {
+    let walls = process(grid)
+    ans += walls
+    if (walls === 0) break
+  }
+  return ans
+  function process(grid) {
+    let maxArea = 0,
+      ans = 0,
+      color = -1,
+      row = -1,
+      col = -1
+    // visited virus as 1, visited 0 using different color to indicate being affected by different virus
+
+    let visited = Array.from({ length: R }, () => Array(C).fill(0))
+
+    // find the max zero area.
+    for (let i = 0; i < R; i++) {
+      for (let j = 0; j < C; j++) {
+        if (grid[i][j] === 1 && visited[i][j] === 0) {
+          const walls = [0]
+          const area = dfs(grid, visited, i, j, color, walls)
+          if (area > maxArea) {
+            maxArea = area
+            ans = walls[0]
+            row = i
+            col = j
+          }
+          color-- // different islands using different color
+        }
+      }
+    }
+
+    removeIsland(grid, row, col)
+    // spread by one step
+    visited = Array.from({ length: R }, () => Array(C).fill(0))
+    for (let i = 0; i < R; i++) {
+      for (let j = 0; j < C; j++) {
+        if (grid[i][j] === 1 && visited[i][j] === 0) {
+          spread(grid, visited, i, j)
+        }
+      }
+    }
+    return ans
+  }
+  function dfs(grid, visited, r, c, color, walls) {
+    if (r < 0 || r > R - 1 || c < 0 || c > C - 1) return 0
+    if (grid[r][c] === 0) {
+      walls[0]++
+      if (visited[r][c] === color) return 0
+      visited[r][c] = color
+      return 1
+    }
+    if (visited[r][c] === 1 || grid[r][c] !== 1) return 0
+    visited[r][c] = 1
+    let ans = 0
+    for (let dir of dirs) {
+      const x = r + dir[0]
+      const y = c + dir[1]
+      ans += dfs(grid, visited, x, y, color, walls)
+    }
+    return ans
+  }
+
+  function removeIsland(grid, r, c) {
+    if (r < 0 || r > R - 1 || c < 0 || c > C - 1 || grid[r][c] !== 1) return
+    grid[r][c] = -1
+    for (let dir of dirs) {
+      const x = r + dir[0]
+      const y = c + dir[1]
+      removeIsland(grid, x, y)
+    }
+  }
+
+  function spread(grid, visited, r, c) {
+    if (r < 0 || r > R - 1 || c < 0 || c > C - 1 || visited[r][c] === 1) return
+    if (grid[r][c] === -1) return
+    visited[r][c] = 1
+    if (grid[r][c] === 0) {
+      grid[r][c] = 1
+      return
+    }
+    for (let dir of dirs) {
+      const x = r + dir[0]
+      const y = c + dir[1]
+      spread(grid, visited, x, y)
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 7a2b0bfff11f35edad11f1f6730285bcf05c8371 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Apr 2020 13:54:02 +0800
Subject: [PATCH 0550/3374] Update 749-contain-virus.js

---
 749-contain-virus.js | 138 +++++++++++++++++--------------------------
 1 file changed, 54 insertions(+), 84 deletions(-)

diff --git a/749-contain-virus.js b/749-contain-virus.js
index 5de542f3..3fb3de7e 100644
--- a/749-contain-virus.js
+++ b/749-contain-virus.js
@@ -2,104 +2,74 @@
  * @param {number[][]} grid
  * @return {number}
  */
-const containVirus = function (grid) {
-  const R = grid.length
-  const C = grid[0].length
-  let ans = 0
-  const dirs = [
-    [0, 1],
-    [0, -1],
-    [1, 0],
-    [-1, 0],
-  ]
+const containVirus = (grid) => {
+  const m = grid.length;
+  const n = grid[0].length;
+  let ans = 0;
   while (true) {
-    let walls = process(grid)
-    ans += walls
-    if (walls === 0) break
-  }
-  return ans
-  function process(grid) {
-    let maxArea = 0,
-      ans = 0,
-      color = -1,
-      row = -1,
-      col = -1
-    // visited virus as 1, visited 0 using different color to indicate being affected by different virus
-
-    let visited = Array.from({ length: R }, () => Array(C).fill(0))
-
-    // find the max zero area.
-    for (let i = 0; i < R; i++) {
-      for (let j = 0; j < C; j++) {
-        if (grid[i][j] === 1 && visited[i][j] === 0) {
-          const walls = [0]
-          const area = dfs(grid, visited, i, j, color, walls)
-          if (area > maxArea) {
-            maxArea = area
-            ans = walls[0]
-            row = i
-            col = j
-          }
-          color-- // different islands using different color
+    // list of regions can spread virus
+    const regions = [];
+    const visited = Array.from({ length: m }, () => Array(n).fill(false));
+    for (let i = 0; i < m; i++) {
+      for (let j = 0; j < n; j++) {
+        if (grid[i][j] === 1 && !visited[i][j]) {
+          const region = new Region();
+          dfs(grid, i, j, region, visited);
+          if (region.uninfected.size > 0) regions.push(region);
         }
       }
     }
 
-    removeIsland(grid, row, col)
-    // spread by one step
-    visited = Array.from({ length: R }, () => Array(C).fill(0))
-    for (let i = 0; i < R; i++) {
-      for (let j = 0; j < C; j++) {
-        if (grid[i][j] === 1 && visited[i][j] === 0) {
-          spread(grid, visited, i, j)
-        }
+    if (regions.length === 0) break;
+    regions.sort((a, b) => a.uninfected.size - b.uninfected.size);
+    let idx = -1, wall = -Infinity
+    for(let i = 0, len = regions.length; i < len; i++) {
+      if(regions[i].uninfected.size > wall) {
+        wall = regions[i].uninfected.size
+        idx = i
       }
     }
-    return ans
-  }
-  function dfs(grid, visited, r, c, color, walls) {
-    if (r < 0 || r > R - 1 || c < 0 || c > C - 1) return 0
-    if (grid[r][c] === 0) {
-      walls[0]++
-      if (visited[r][c] === color) return 0
-      visited[r][c] = color
-      return 1
-    }
-    if (visited[r][c] === 1 || grid[r][c] !== 1) return 0
-    visited[r][c] = 1
-    let ans = 0
-    for (let dir of dirs) {
-      const x = r + dir[0]
-      const y = c + dir[1]
-      ans += dfs(grid, visited, x, y, color, walls)
+    const mostToBeInfected = regions[idx]
+    ans += mostToBeInfected.wallNeeded
+    regions.splice(idx, 1)
+    for (let x of mostToBeInfected.infected) {
+      let i = (x / n) >> 0,
+        j = x % n;
+      grid[i][j] = 2;
     }
-    return ans
-  }
 
-  function removeIsland(grid, r, c) {
-    if (r < 0 || r > R - 1 || c < 0 || c > C - 1 || grid[r][c] !== 1) return
-    grid[r][c] = -1
-    for (let dir of dirs) {
-      const x = r + dir[0]
-      const y = c + dir[1]
-      removeIsland(grid, x, y)
+    for (let region of regions) {
+      for (let x of region.uninfected) {
+        let i = (x / n) >> 0,
+          j = x % n;
+        grid[i][j] = 1;
+      }
     }
   }
 
-  function spread(grid, visited, r, c) {
-    if (r < 0 || r > R - 1 || c < 0 || c > C - 1 || visited[r][c] === 1) return
-    if (grid[r][c] === -1) return
-    visited[r][c] = 1
-    if (grid[r][c] === 0) {
-      grid[r][c] = 1
-      return
-    }
-    for (let dir of dirs) {
-      const x = r + dir[0]
-      const y = c + dir[1]
-      spread(grid, visited, x, y)
+  return ans;
+  function dfs(grid, i, j, region, visited) {
+    if (i < 0 || i == m || j < 0 || j == n) return;
+  
+    if (grid[i][j] === 1 && !visited[i][j]) {
+      visited[i][j] = true;
+      region.infected.add(i * n + j);
+      dfs(grid, i - 1, j, region, visited);
+      dfs(grid, i + 1, j, region, visited);
+      dfs(grid, i, j - 1, region, visited);
+      dfs(grid, i, j + 1, region, visited);
+    } else if (grid[i][j] === 0) {
+      region.wallNeeded += 1;
+      region.uninfected.add(i * n + j);
     }
   }
+};
+class Region {
+  constructor() {
+    this.wallNeeded = 0;
+    this.infected = new Set();
+    this.uninfected = new Set();
+  }
 }
 
 // another

From 83a39a9cd1c3522322e13aa695e8d99feeb08403 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Apr 2020 14:31:53 +0800
Subject: [PATCH 0551/3374] Update 749-contain-virus.js

---
 749-contain-virus.js | 83 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/749-contain-virus.js b/749-contain-virus.js
index 3fb3de7e..7a6bec2c 100644
--- a/749-contain-virus.js
+++ b/749-contain-virus.js
@@ -1,3 +1,86 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const containVirus = function (grid) {
+  let ans = 0
+  while (true) {
+    const walls = model(grid)
+    if (walls === 0) break
+    ans += walls
+  }
+  return ans
+  function model(grid) {
+    const m = grid.length,
+      n = grid[0].length
+    const virus = [],
+      toInfect = []
+    const visited = Array.from({ length: m }, () => Array(n).fill(0))
+    const walls = []
+    for (let i = 0; i < m; i++) {
+      for (let j = 0; j < n; j++) {
+        if (grid[i][j] === 1 && visited[i][j] === 0) {
+          virus.push(new Set())
+          toInfect.push(new Set())
+          walls.push([0])
+          dfs(
+            grid,
+            visited,
+            virus[virus.length - 1],
+            toInfect[toInfect.length - 1],
+            walls[walls.length - 1],
+            i,
+            j
+          )
+        }
+      }
+    }
+    let maxArea = 0,
+      idx = -1
+    for (let i = 0; i < toInfect.length; i++) {
+      if (toInfect[i].size > maxArea) {
+        maxArea = toInfect[i].size
+        idx = i
+      }
+    }
+    if (idx === -1) return 0
+    for (let i = 0; i < toInfect.length; i++) {
+      if (i !== idx) {
+        for (let key of toInfect[i]) grid[(key / n) >> 0][key % n] = 1
+      } else {
+        for (let key of virus[i]) grid[(key / n) >> 0][key % n] = -1
+      }
+    }
+    return walls[idx][0]
+  }
+  function dfs(grid, visited, virus, toInfect, wall, row, col) {
+    const m = grid.length,
+      n = grid[0].length
+    if (row < 0 || row >= m || col < 0 || col >= n || visited[row][col] === 1)
+      return
+    if (grid[row][col] === 1) {
+      visited[row][col] = 1
+      virus.add(row * n + col)
+      const dir = [0, -1, 0, 1, 0]
+      for (let i = 0; i < 4; i++)
+        dfs(
+          grid,
+          visited,
+          virus,
+          toInfect,
+          wall,
+          row + dir[i],
+          col + dir[i + 1]
+        )
+    } else if (grid[row][col] === 0) {
+      wall[0]++
+      toInfect.add(row * n + col)
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From d1fb65032839765693761fa976d14f636b8aa6f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 May 2020 13:13:12 +0800
Subject: [PATCH 0552/3374] Create 750-number-of-corner-rectangles.js

---
 750-number-of-corner-rectangles.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 750-number-of-corner-rectangles.js

diff --git a/750-number-of-corner-rectangles.js b/750-number-of-corner-rectangles.js
new file mode 100644
index 00000000..0710869f
--- /dev/null
+++ b/750-number-of-corner-rectangles.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const countCornerRectangles = function (grid) {
+  let ans = 0
+  for (let i = 0; i < grid.length - 1; i++) {
+    for (let j = i + 1; j < grid.length; j++) {
+      let counter = 0
+      for (let k = 0; k < grid[0].length; k++) {
+        if (grid[i][k] === 1 && grid[j][k] === 1) counter++
+      }
+      if (counter > 0) ans += (counter * (counter - 1)) / 2
+    }
+  }
+  return ans
+}

From 08342f133e91b9f563dc25076adf7a7d5a3112e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 May 2020 13:29:45 +0800
Subject: [PATCH 0553/3374] Update 750-number-of-corner-rectangles.js

---
 750-number-of-corner-rectangles.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/750-number-of-corner-rectangles.js b/750-number-of-corner-rectangles.js
index 0710869f..59e7bc3c 100644
--- a/750-number-of-corner-rectangles.js
+++ b/750-number-of-corner-rectangles.js
@@ -10,7 +10,7 @@ const countCornerRectangles = function (grid) {
       for (let k = 0; k < grid[0].length; k++) {
         if (grid[i][k] === 1 && grid[j][k] === 1) counter++
       }
-      if (counter > 0) ans += (counter * (counter - 1)) / 2
+      ans += (counter * (counter - 1)) / 2
     }
   }
   return ans

From 9796c23ce3ca649c48d2353f7ed60a5406379ab5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 May 2020 14:25:14 +0800
Subject: [PATCH 0554/3374] Update 750-number-of-corner-rectangles.js

---
 750-number-of-corner-rectangles.js | 37 ++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/750-number-of-corner-rectangles.js b/750-number-of-corner-rectangles.js
index 59e7bc3c..8f21c4a9 100644
--- a/750-number-of-corner-rectangles.js
+++ b/750-number-of-corner-rectangles.js
@@ -15,3 +15,40 @@ const countCornerRectangles = function (grid) {
   }
   return ans
 }
+
+// another
+
+// optimized
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const countCornerRectangles = function (grid) {
+  let ans = 0
+  let largeLoopLen, smLoopLen, r
+  if(grid.length > grid[0].length) {
+    r = false
+    largeLoopLen = grid.length
+    smLoopLen = grid[0].length
+  } else {
+    r = true
+    largeLoopLen = grid[0].length
+    smLoopLen = grid.length
+  }
+  for (let i = 0; i < smLoopLen - 1; i++) {
+    for (let j = i + 1; j < smLoopLen; j++) {
+      let counter = 0
+      for (let k = 0; k < largeLoopLen; k++) {
+        if(r) {
+          if (grid[i][k] === 1 && grid[j][k] === 1) counter++
+        } else {
+          if (grid[k][i] === 1 && grid[k][j] === 1) counter++
+        }
+        
+      }
+      ans += (counter * (counter - 1)) / 2
+    }
+  }
+  return ans
+}

From 1e5baae1ecc29ded6bdd80666073d72ca4f1fd63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 May 2020 18:24:38 +0800
Subject: [PATCH 0555/3374] Create 751-ip-to-cidr.js

---
 751-ip-to-cidr.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 751-ip-to-cidr.js

diff --git a/751-ip-to-cidr.js b/751-ip-to-cidr.js
new file mode 100644
index 00000000..2ff6ac3c
--- /dev/null
+++ b/751-ip-to-cidr.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} ip
+ * @param {number} n
+ * @return {string[]}
+ */
+const ipToCIDR = function (ip, n) {
+  const ipToLong = (ip) =>
+    ip.split('.').reduce((acc, x) => 256 * acc + parseInt(x), 0)
+  const longToIp = (long) =>
+    [24, 16, 8, 0].map((i) => (long >>> i) % 256).join('.')
+  const bitLength = (num) => Math.floor(Math.log2(num)) + 1
+  const ans = []
+  let long = ipToLong(ip)
+  while (n) {
+    let mask = Math.max(33 - bitLength(long & -long), 33 - bitLength(n))
+    ans.push(longToIp(long) + '/' + mask)
+    long += 1 << (32 - mask)
+    n -= 1 << (32 - mask)
+  }
+  return ans
+}

From 3cfbd1597874b16167220d2bb41a4fcd10beaf94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 May 2020 08:35:29 +0800
Subject: [PATCH 0556/3374] Create 755-pour-water.js

---
 755-pour-water.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 755-pour-water.js

diff --git a/755-pour-water.js b/755-pour-water.js
new file mode 100644
index 00000000..23d2cf87
--- /dev/null
+++ b/755-pour-water.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} heights
+ * @param {number} V
+ * @param {number} K
+ * @return {number[]}
+ */
+const pourWater = function (heights, V, K) {
+  if (!V) return heights
+  let bottom = K
+  //iterate through from k to find thee lowest bottom
+  for (let i = K; i >= 0; i--) {
+    if (heights[i] > heights[bottom]) break
+    if (heights[i] < heights[bottom]) bottom = i
+  }
+  //if bottom is not k increase height of bottom
+  //and run again but decrease water droplet V by one
+  if (bottom !== K) {
+    heights[bottom]++
+    return pourWater(heights, V - 1, K)
+  }
+
+  for (let i = K + 1; i < heights.length; i++) {
+    if (heights[i] > heights[bottom]) break
+    if (heights[i] < heights[bottom]) bottom = i
+  }
+  heights[bottom]++
+  return pourWater(heights, V - 1, K)
+}

From 39620df9b1912159748723814937cecfefb0a1cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 May 2020 09:10:50 +0800
Subject: [PATCH 0557/3374] Update 755-pour-water.js

---
 755-pour-water.js | 30 +++++++++++++++++++++++++++++-
 1 file changed, 29 insertions(+), 1 deletion(-)

diff --git a/755-pour-water.js b/755-pour-water.js
index 23d2cf87..1cacf38d 100644
--- a/755-pour-water.js
+++ b/755-pour-water.js
@@ -18,7 +18,6 @@ const pourWater = function (heights, V, K) {
     heights[bottom]++
     return pourWater(heights, V - 1, K)
   }
-
   for (let i = K + 1; i < heights.length; i++) {
     if (heights[i] > heights[bottom]) break
     if (heights[i] < heights[bottom]) bottom = i
@@ -26,3 +25,32 @@ const pourWater = function (heights, V, K) {
   heights[bottom]++
   return pourWater(heights, V - 1, K)
 }
+
+// another
+
+/**
+ * @param {number[]} heights
+ * @param {number} V
+ * @param {number} K
+ * @return {number[]}
+ */
+const pourWater = function (heights, V, K) {
+  let cur = K
+  for (let i = 0; i < V; i++) {
+    // Move left
+    while (cur > 0 && heights[cur - 1] <= heights[cur]) {
+      cur--
+    }
+    // Move right
+    while (cur < heights.length - 1 && heights[cur + 1] <= heights[cur]) {
+      cur++
+    }
+    // Move left to K
+    while(cur > K && heights[cur - 1] === heights[cur]) {
+      cur--
+    }
+    heights[cur]++
+  }
+  return heights
+}
+

From ff0e12eeed5af90f899441d4e73830cc67acd6de Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 May 2020 20:33:28 +0800
Subject: [PATCH 0558/3374] Create 771-jewels-and-stones.js

---
 771-jewels-and-stones.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 771-jewels-and-stones.js

diff --git a/771-jewels-and-stones.js b/771-jewels-and-stones.js
new file mode 100644
index 00000000..4cede577
--- /dev/null
+++ b/771-jewels-and-stones.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} J
+ * @param {string} S
+ * @return {number}
+ */
+const numJewelsInStones = function(J, S) {
+  if(J == null || J === '' || S == null || S === '') return 0
+  const m = new Set(J)
+  let res = 0
+  for(let e of S) {
+    if(m.has(e)) res++
+  }
+  return res
+};

From 3a96ff117e2f7ce85d26d6d4e8577493a67b2168 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 May 2020 23:47:31 +0800
Subject: [PATCH 0559/3374] Create 756-pyramid-transition-matrix.js

---
 756-pyramid-transition-matrix.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 756-pyramid-transition-matrix.js

diff --git a/756-pyramid-transition-matrix.js b/756-pyramid-transition-matrix.js
new file mode 100644
index 00000000..26ccb4f7
--- /dev/null
+++ b/756-pyramid-transition-matrix.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} bottom
+ * @param {string[]} allowed
+ * @return {boolean}
+ */
+const pyramidTransition = function (bottom, allowed) {
+  const map = new Map()
+  allowed.map((item) => {
+    const t = map.get(item[0] + item[1]) || new Array()
+    t.push(item[2])
+    map.set(item[0] + item[1], t)
+  })
+  const memo = new Map()
+  const solve = function (cur, ind, next) {
+    if (memo.has(cur)) return memo.get(cur)
+    if (cur.length === 1) return true
+    if (ind >= cur.length - 1) {
+      const res = solve(next, 0, '')
+      memo.set(next, res)
+      return res
+    }
+    if (!map.has(cur.slice(ind, ind + 2))) {
+      memo.set(cur, false)
+      return false
+    }
+    for (let char of map.get(cur.slice(ind, ind + 2))) {
+      if (solve(cur, ind + 1, next + char)) return true
+    }
+    return false
+  }
+  return solve(bottom, 0, '')
+}

From 896ebfb5d76e3d2778d7d562318d3404ceb5c775 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 May 2020 00:23:46 +0800
Subject: [PATCH 0560/3374] Update 756-pyramid-transition-matrix.js

---
 756-pyramid-transition-matrix.js | 39 ++++++++++++--------------------
 1 file changed, 15 insertions(+), 24 deletions(-)

diff --git a/756-pyramid-transition-matrix.js b/756-pyramid-transition-matrix.js
index 26ccb4f7..2ff7aac8 100644
--- a/756-pyramid-transition-matrix.js
+++ b/756-pyramid-transition-matrix.js
@@ -4,29 +4,20 @@
  * @return {boolean}
  */
 const pyramidTransition = function (bottom, allowed) {
-  const map = new Map()
-  allowed.map((item) => {
-    const t = map.get(item[0] + item[1]) || new Array()
-    t.push(item[2])
-    map.set(item[0] + item[1], t)
-  })
-  const memo = new Map()
-  const solve = function (cur, ind, next) {
-    if (memo.has(cur)) return memo.get(cur)
-    if (cur.length === 1) return true
-    if (ind >= cur.length - 1) {
-      const res = solve(next, 0, '')
-      memo.set(next, res)
-      return res
-    }
-    if (!map.has(cur.slice(ind, ind + 2))) {
-      memo.set(cur, false)
-      return false
-    }
-    for (let char of map.get(cur.slice(ind, ind + 2))) {
-      if (solve(cur, ind + 1, next + char)) return true
-    }
-    return false
+  const m = new Map()
+  for (let e of allowed) {
+    const p = e.slice(0, 2)
+    if (!m.has(p)) m.set(p, new Set())
+    m.get(p).add(e[2])
   }
-  return solve(bottom, 0, '')
+  return dfs(bottom, '', m, 0)
 }
+
+function dfs(row, next, m, i) {
+  if (row.length === 1) return true
+  if (next.length + 1 === row.length) return dfs(next, '', m, 0)
+  for (let c of m.get(row.slice(i, i + 2)) || new Set())
+    if (dfs(row, next + c, m, i + 1)) return true
+  return false
+}
+

From 5bb491598040d410f666e83d877ab735e9dc9f18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 May 2020 09:54:14 +0800
Subject: [PATCH 0561/3374] Create 758-bold-words-in-string.js

---
 758-bold-words-in-string.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 758-bold-words-in-string.js

diff --git a/758-bold-words-in-string.js b/758-bold-words-in-string.js
new file mode 100644
index 00000000..32fa86f2
--- /dev/null
+++ b/758-bold-words-in-string.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string[]} words
+ * @param {string} S
+ * @return {string}
+ */
+const boldWords = function (words, S) {
+  const boldMap = new Array(S.length).fill(0)
+  for (let i = 0; i < words.length; i++) {
+    let match = -1
+    while ((match = S.indexOf(words[i], match + 1)) > -1) {
+      for (let j = match; j < match + words[i].length; j++) {
+        boldMap[j] = 1
+      }
+    }
+  }
+  let res = ''
+  let openTag = false
+  for (let i = 0; i < S.length; i++) {
+    if (boldMap[i] && !openTag) {
+      res += `<b>`
+      openTag = true
+    } else if (!boldMap[i] && openTag) {
+      res += `</b>`
+      openTag = false
+    }
+    res += S[i]
+  }
+  res += openTag ? `</b>` : ``
+  return res
+}

From f5eec8100049db34fd9104fea49836598bbf26e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 May 2020 12:33:42 +0800
Subject: [PATCH 0562/3374] Update 758-bold-words-in-string.js

---
 758-bold-words-in-string.js | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/758-bold-words-in-string.js b/758-bold-words-in-string.js
index 32fa86f2..402183ff 100644
--- a/758-bold-words-in-string.js
+++ b/758-bold-words-in-string.js
@@ -4,27 +4,26 @@
  * @return {string}
  */
 const boldWords = function (words, S) {
-  const boldMap = new Array(S.length).fill(0)
-  for (let i = 0; i < words.length; i++) {
-    let match = -1
-    while ((match = S.indexOf(words[i], match + 1)) > -1) {
-      for (let j = match; j < match + words[i].length; j++) {
-        boldMap[j] = 1
+  const arr = new Array(S.length).fill(false)
+  for(let w of words) {
+    for(let i = 0, len = S.length - w.length; i <= len; i++) {
+      const tmp = S.slice(i)
+      if(tmp && tmp.startsWith(w)) {
+        for(let j = i; j < i + w.length; j++) {
+          arr[j] = true
+        }
       }
     }
   }
   let res = ''
-  let openTag = false
-  for (let i = 0; i < S.length; i++) {
-    if (boldMap[i] && !openTag) {
-      res += `<b>`
-      openTag = true
-    } else if (!boldMap[i] && openTag) {
-      res += `</b>`
-      openTag = false
+  for(let i = 0, len = S.length; i < len; i++) {
+    if(arr[i] && (i === 0 || !arr[i - 1])) {
+      res += '<b>'
     }
     res += S[i]
+    if(arr[i] && (i === len - 1 || !arr[i + 1])) {
+      res += '</b>'
+    }
   }
-  res += openTag ? `</b>` : ``
   return res
 }

From cdab6a247c91a5438df4ea13b4bffefa3c4a06b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 May 2020 19:09:55 +0800
Subject: [PATCH 0563/3374] Update 383-ransom-note.js

---
 383-ransom-note.js | 19 ++++++++-----------
 1 file changed, 8 insertions(+), 11 deletions(-)

diff --git a/383-ransom-note.js b/383-ransom-note.js
index 7629066e..81ad0d58 100755
--- a/383-ransom-note.js
+++ b/383-ransom-note.js
@@ -4,16 +4,13 @@
  * @return {boolean}
  */
 const canConstruct = function(ransomNote, magazine) {
-  const rArr = ransomNote.split("");
-  const mArr = magazine.split("");
-  let idx;
-  for (let i = 0; i < rArr.length; i++) {
-    idx = mArr.indexOf(rArr[i]);
-    if (idx === -1) {
-      return false;
-    } else {
-      mArr.splice(idx, 1);
-    }
+  const m = new Map()
+  for(let c of magazine) {
+    m.set(c, (m.get(c) || 0) + 1 )
   }
-  return true;
+  for(let c of ransomNote) {
+    if(!m.has(c) || m.get(c) <= 0) return false
+    m.set(c, m.get(c) - 1)
+  }
+  return true
 };

From 05d49773e1368db045bab1e44e3d0ef3cf7e6af3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 May 2020 18:45:14 +0800
Subject: [PATCH 0564/3374] Create 476-number-complement.js

---
 476-number-complement.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 476-number-complement.js

diff --git a/476-number-complement.js b/476-number-complement.js
new file mode 100644
index 00000000..a41a0495
--- /dev/null
+++ b/476-number-complement.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+const findComplement = function(num) {
+  const toBin = num => (num >>> 0).toString(2)
+  const flip = str => {
+    let res = ''
+    for(let c of str) res += (c === '1' ? '0' : '1')
+    return res
+  }
+  return parseInt(flip(toBin(num)), 2)
+};

From c800c61bdd95afc6a5cc770992ee737a95d7e3b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 May 2020 13:59:38 +0800
Subject: [PATCH 0565/3374] Create 1392-longest-happy-prefix.js

---
 1392-longest-happy-prefix.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1392-longest-happy-prefix.js

diff --git a/1392-longest-happy-prefix.js b/1392-longest-happy-prefix.js
new file mode 100644
index 00000000..9882c9a0
--- /dev/null
+++ b/1392-longest-happy-prefix.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const longestPrefix = function(s) {
+  return s.slice(0, dfa().pop())
+  function dfa() {
+    let i = 1
+    let j = 0
+    const len = s.length
+    const prefix = Array(len + 1).fill(0)
+    while(i < len) {
+      if(s[j] === s[i]) {
+        j++
+        i++
+        prefix[i] = j
+      } else {
+        if(j > 0) j = prefix[j]
+        else {
+          i++
+          prefix[i] = 0
+        }
+      }
+    }
+    return prefix
+  }  
+};
+
+

From 48aaa7936b163c061b8e36c2d24104f0c1fc6a7b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 May 2020 14:31:43 +0800
Subject: [PATCH 0566/3374] Update 1392-longest-happy-prefix.js

---
 1392-longest-happy-prefix.js | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/1392-longest-happy-prefix.js b/1392-longest-happy-prefix.js
index 9882c9a0..d6577644 100644
--- a/1392-longest-happy-prefix.js
+++ b/1392-longest-happy-prefix.js
@@ -9,6 +9,8 @@ const longestPrefix = function(s) {
     let j = 0
     const len = s.length
     const prefix = Array(len + 1).fill(0)
+    prefix[0] = -1
+    prefix[1] = 0
     while(i < len) {
       if(s[j] === s[i]) {
         j++
@@ -16,10 +18,7 @@ const longestPrefix = function(s) {
         prefix[i] = j
       } else {
         if(j > 0) j = prefix[j]
-        else {
-          i++
-          prefix[i] = 0
-        }
+        else i++
       }
     }
     return prefix

From 644cc9c331b16e596a45f332a3b8eb2f4dafbb7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 May 2020 17:51:23 +0800
Subject: [PATCH 0567/3374] Update 459-repeated-substring-pattern.js

---
 459-repeated-substring-pattern.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/459-repeated-substring-pattern.js b/459-repeated-substring-pattern.js
index aae2ac4f..38c2c927 100644
--- a/459-repeated-substring-pattern.js
+++ b/459-repeated-substring-pattern.js
@@ -23,3 +23,34 @@ function genStr(sub, limit) {
     }
     return str
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const repeatedSubstringPattern = function (s) {
+  const l = s.length
+  const arr = DFA(s)
+  return arr[l] && arr[l] % (l - arr[l]) === 0
+  function DFA(s) {
+    let i = 1
+    let j = 0
+    const len = s.length
+    const prefix = Array(len + 1).fill(0)
+    prefix[0] = -1
+    prefix[1] = 0
+    while (i < len) {
+      if (s[j] === s[i]) {
+        j++
+        i++
+        prefix[i] = j
+      } else {
+        if (j > 0) j = prefix[j]
+        else i++
+      }
+    }
+    return prefix
+  }
+}

From 07cb037c561d9c65eba2071b182a21f291c3f3ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 May 2020 19:12:15 +0800
Subject: [PATCH 0568/3374] Update 387-first-unique-character-in-a-string.js

---
 387-first-unique-character-in-a-string.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/387-first-unique-character-in-a-string.js b/387-first-unique-character-in-a-string.js
index f20370df..b03d0169 100755
--- a/387-first-unique-character-in-a-string.js
+++ b/387-first-unique-character-in-a-string.js
@@ -26,3 +26,23 @@ const firstUniqChar = function(s) {
   }
   return res[0] == null ? -1 : res[0];
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const firstUniqChar = function(s) {
+    if(s === '') return -1
+    const map = new Map()
+    for(let i = 0, len = s.length; i < len; i++) {
+      if(!map.has(s[i])) map.set(s[i], [i, 0])
+      map.get(s[i])[1] += 1
+    }
+    for(let [key, val] of map) {
+      if(val[1] === 1) return val[0]
+    }
+    return -1
+    
+};

From c72cd580516f17c28ef54d4a8d478f7bbb6b9072 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 May 2020 07:58:57 +0800
Subject: [PATCH 0569/3374] Create 760-find-anagram-mappings.js

---
 760-find-anagram-mappings.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 760-find-anagram-mappings.js

diff --git a/760-find-anagram-mappings.js b/760-find-anagram-mappings.js
new file mode 100644
index 00000000..e2a5e83a
--- /dev/null
+++ b/760-find-anagram-mappings.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} A
+ * @param {number[]} B
+ * @return {number[]}
+ */
+const anagramMappings = function(A, B) {
+  const m = new Map()
+  for(let i = 0, len = B.length; i < len; i++) {
+    m.set(B[i], i)
+  }
+  const res = []
+  for(let i = 0, len = A.length; i < len; i++) {
+    res.push(m.get(A[i]))
+  }
+  return res
+};

From cdfed514789a85e2c7b0dcbe41e1c6eeac74a165 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 May 2020 09:14:08 +0800
Subject: [PATCH 0570/3374] Create 763-partition-labels.js

---
 763-partition-labels.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 763-partition-labels.js

diff --git a/763-partition-labels.js b/763-partition-labels.js
new file mode 100644
index 00000000..7ccbb56d
--- /dev/null
+++ b/763-partition-labels.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} S
+ * @return {number[]}
+ */
+const partitionLabels = function (S) {
+  if (S == null || S.length === 0) {
+    return null
+  }
+  const list = []
+  // record the last index of the each char
+  const map = new Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0, len = S.length; i < len; i++) {
+    map[S.charCodeAt(i) - a] = i
+  }
+  // record the end index of the current sub string
+  let last = 0
+  let start = 0
+  for (let i = 0, len = S.length; i < len; i++) {
+    last = Math.max(last, map[S.charCodeAt(i) - a])
+    if (last === i) {
+      list.push(last - start + 1)
+      start = last + 1
+    }
+  }
+  return list
+}

From 6023b3c9ed28f518a9c16d88b27678f5ab6e604d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 May 2020 15:24:59 +0800
Subject: [PATCH 0571/3374] Update 993.cousins-in-binary-tree.js

---
 993.cousins-in-binary-tree.js | 39 +++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/993.cousins-in-binary-tree.js b/993.cousins-in-binary-tree.js
index ddacddac..82cbd579 100644
--- a/993.cousins-in-binary-tree.js
+++ b/993.cousins-in-binary-tree.js
@@ -1,3 +1,42 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} x
+ * @param {number} y
+ * @return {boolean}
+ */
+const isCousins = (root, x, y, depth = 1, P = {}, D = {}) => {
+  let q = [root]
+  while (q.length) {
+    let K = q.length
+    while (K--) {
+      let p = q.shift()
+      if (p.left) {
+        if (p.left.val === x) (P.x = p.val), (D.x = depth)
+        if (p.left.val === y) (P.y = p.val), (D.y = depth)
+        q.push(p.left)
+      }
+      if (p.right) {
+        if (p.right.val === x) (P.x = p.val), (D.x = depth)
+        if (p.right.val === y) (P.y = p.val), (D.y = depth)
+        q.push(p.right)
+      }
+    }
+    ++depth
+  }
+  return P.x !== P.y && D.x === D.y
+}
+
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From a8b72b784d25255b07989da4a79057286dda079e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 May 2020 09:01:58 +0800
Subject: [PATCH 0572/3374] Create 764-largest-plus-sign.js

---
 764-largest-plus-sign.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 764-largest-plus-sign.js

diff --git a/764-largest-plus-sign.js b/764-largest-plus-sign.js
new file mode 100644
index 00000000..7bd3e43a
--- /dev/null
+++ b/764-largest-plus-sign.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} N
+ * @param {number[][]} mines
+ * @return {number}
+ */
+const orderOfLargestPlusSign = function (N, mines) {
+  const dp = [...Array(N)].map((_) => Array(N).fill(N))
+  mines.map((m) => {
+    dp[m[0]][m[1]] = 0
+  })
+  for (let i = 0; i < N; i++) {
+    for (let j = 0, k = N - 1, l = (r = u = d = 0); j < N; j++, k--) {
+      dp[i][j] = Math.min(dp[i][j], (l = dp[i][j] == 0 ? 0 : l + 1))
+      dp[i][k] = Math.min(dp[i][k], (r = dp[i][k] == 0 ? 0 : r + 1))
+      dp[j][i] = Math.min(dp[j][i], (d = dp[j][i] == 0 ? 0 : d + 1))
+      dp[k][i] = Math.min(dp[k][i], (u = dp[k][i] == 0 ? 0 : u + 1))
+    }
+  }
+  let max = 0
+  for (let i = 0; i < N; i++) {
+    for (let j = 0; j < N; j++) {
+      max = Math.max(dp[i][j], max)
+    }
+  }
+  return max
+}

From 2d1d91f6367ba56c3f29c0315d64b591f617d766 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 May 2020 15:25:59 +0800
Subject: [PATCH 0573/3374] Create 1232-check-if-it-is-a-straight-line.js

---
 1232-check-if-it-is-a-straight-line.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1232-check-if-it-is-a-straight-line.js

diff --git a/1232-check-if-it-is-a-straight-line.js b/1232-check-if-it-is-a-straight-line.js
new file mode 100644
index 00000000..d59a9e37
--- /dev/null
+++ b/1232-check-if-it-is-a-straight-line.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} coordinates
+ * @return {boolean}
+ */
+const checkStraightLine = function(coordinates) {
+  const r = ratio(coordinates[0], coordinates[1])
+  for(let i = 1, len = coordinates.length;  i < len - 1;  i++) {
+    if(ratio(coordinates[i], coordinates[i + 1]) !== r) return false
+  }
+      
+  return true
+};
+
+function ratio(a, b) {
+  return (b[1] - a[1]) / (b[0] - a[0])
+}

From 3f5c1ebd82d112e9df374fb66c30a021fd885e08 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 May 2020 16:27:16 +0800
Subject: [PATCH 0574/3374] Create 765-couples-holding-hands.js

---
 765-couples-holding-hands.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 765-couples-holding-hands.js

diff --git a/765-couples-holding-hands.js b/765-couples-holding-hands.js
new file mode 100644
index 00000000..c3ba4924
--- /dev/null
+++ b/765-couples-holding-hands.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} row
+ * @return {number}
+ */
+const minSwapsCouples = function (row) {
+  let res = 0,
+    N = row.length
+  const ptn = new Array(N).fill(0)
+  const pos = new Array(N).fill(0)
+  for (let i = 0; i < N; i++) {
+    ptn[i] = i % 2 === 0 ? i + 1 : i - 1
+    pos[row[i]] = i
+  }
+  for (let i = 0; i < N; i++) {
+    for (let j = ptn[pos[ptn[row[i]]]]; i !== j; j = ptn[pos[ptn[row[i]]]]) {
+      swap(row, i, j)
+      swap(pos, row[i], row[j])
+      res++
+    }
+  }
+  return res
+}
+
+function swap(arr, i, j) {
+  ;[arr[i], arr[j]] = [arr[j], arr[i]]
+}

From b43b1801c5ae1ab7635420b0e5fb1f562d5eb4a9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 May 2020 09:59:15 +0800
Subject: [PATCH 0575/3374] Update 765-couples-holding-hands.js

---
 765-couples-holding-hands.js | 48 ++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/765-couples-holding-hands.js b/765-couples-holding-hands.js
index c3ba4924..4fec7b3e 100644
--- a/765-couples-holding-hands.js
+++ b/765-couples-holding-hands.js
@@ -24,3 +24,51 @@ const minSwapsCouples = function (row) {
 function swap(arr, i, j) {
   ;[arr[i], arr[j]] = [arr[j], arr[i]]
 }
+
+// another
+
+/**
+ * @param {number[]} row
+ * @return {number}
+ */
+const minSwapsCouples = function (row) {
+  const parents = Array.from({ length: row.length / 2 }, (_, i) => i)
+  const positions = new Map()
+  for (let i = 0; i < row.length / 2; i++) {
+    const left = Math.floor(row[i * 2] / 2)
+    const right = Math.floor(row[i * 2 + 1] / 2)
+    if (positions.has(left)) {
+      union(i, positions.get(left))
+    } else {
+      positions.set(left, i)
+    }
+    if (positions.has(right)) {
+      union(i, positions.get(right))
+    } else {
+      positions.set(right, i)
+    }
+  }
+
+  const uniqueRoots = new Set()
+  for (const parent of parents) {
+    uniqueRoots.add(find(parent))
+  }
+  return parents.length - uniqueRoots.size
+
+  function union(a, b) {
+    const aRoot = find(a)
+    const bRoot = find(b)
+    parents[aRoot] = bRoot
+  }
+  function root(x) {
+    while (x !== parents[x]) {
+      parents[x] = parents[parents[x]]
+      x = parents[x]
+    }
+    return x
+  }
+  function find(node) {
+    return root(node)
+  }
+}
+

From 9667be6bf9fd0481cdc8b0ff3fe687d271fa110d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 May 2020 15:35:52 +0800
Subject: [PATCH 0576/3374] Update 367-valid-perfect-square.js

---
 367-valid-perfect-square.js | 29 ++++++++++-------------------
 1 file changed, 10 insertions(+), 19 deletions(-)

diff --git a/367-valid-perfect-square.js b/367-valid-perfect-square.js
index 35afcc3a..a1597424 100644
--- a/367-valid-perfect-square.js
+++ b/367-valid-perfect-square.js
@@ -2,24 +2,15 @@
  * @param {number} num
  * @return {boolean}
  */
-
 const isPerfectSquare = function(num) {
-    let lo = 1
-    let hi = num
-    let mid
-    let val
-    while(lo <= hi) {
-        mid = (lo + hi) >>> 1
-        val = mid * mid
-        if (val === num) {
-            return true
-        }
-        if (val < num) {
-            lo = mid + 1
-        }
-        if (val > num) {
-            hi = mid - 1
-        }
-    }
-    return false
+  let s = 0
+  let e = num
+  while(s <= e) {
+    const mid = s + ((e - s) >> 1)
+    const res = mid ** 2
+    if(res === num) return true
+    if(res < num) s = mid + 1
+    else e = mid - 1
+  }
+  return false
 };

From b44b0cc308cc80d03010bd2f40c9a66595a5565e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 May 2020 16:43:18 +0800
Subject: [PATCH 0577/3374] Create 997-find-the-town-judge.js

---
 997-find-the-town-judge.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 997-find-the-town-judge.js

diff --git a/997-find-the-town-judge.js b/997-find-the-town-judge.js
new file mode 100644
index 00000000..454c4672
--- /dev/null
+++ b/997-find-the-town-judge.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} N
+ * @param {number[][]} trust
+ * @return {number}
+ */
+const findJudge = function(N, trust) {
+  const m = new Map()
+  for(let i = 1; i<= N; i++) {
+    const e = new Map()
+    e.set('t', new Set())
+    e.set('ted', new Set())
+    m.set(i, e)
+  }
+  for(let [t, ted] of trust) {
+    m.get(t).get('t').add(ted)
+    m.get(ted).get('ted').add(t)
+  }
+  for(let [k,v] of m) {
+    if(v.get('t').size === 0 && v.get('ted').size === N - 1) return k
+  }
+  return -1
+};

From d553e2af8f445c25337dda9a79decc525c7eb146 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 May 2020 16:54:08 +0800
Subject: [PATCH 0578/3374] Update 997-find-the-town-judge.js

---
 997-find-the-town-judge.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/997-find-the-town-judge.js b/997-find-the-town-judge.js
index 454c4672..55b28506 100644
--- a/997-find-the-town-judge.js
+++ b/997-find-the-town-judge.js
@@ -1,3 +1,22 @@
+/**
+ * @param {number} N
+ * @param {number[][]} trust
+ * @return {number}
+ */
+const findJudge = function(N, trust) {
+  const arr = new Array(N + 1).fill(0)
+  for(let [t, ted] of trust) {
+    arr[t]--
+    arr[ted]++
+  }
+  for(let i = 1; i <= N; i++) {
+    if(arr[i] === N - 1) return i
+  }
+  return -1
+};
+
+// another
+
 /**
  * @param {number} N
  * @param {number[][]} trust

From 4bdc70d2e66e37e9e5776aec2f1bd4909d6deb5e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 May 2020 09:01:20 +0800
Subject: [PATCH 0579/3374] Create 774-minimize-max-distance-to-gas-station.js

---
 774-minimize-max-distance-to-gas-station.js | 30 +++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 774-minimize-max-distance-to-gas-station.js

diff --git a/774-minimize-max-distance-to-gas-station.js b/774-minimize-max-distance-to-gas-station.js
new file mode 100644
index 00000000..32bc695b
--- /dev/null
+++ b/774-minimize-max-distance-to-gas-station.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} stations
+ * @param {number} K
+ * @return {number}
+ */
+const minmaxGasDist = function (stations, K) {
+  const dis = []
+  let min = 0
+  let max = 1e8
+  for (let i = 0; i < stations.length - 1; i++) {
+    dis.push(stations[i + 1] - stations[i])
+  }
+  while (max - min > 1e-6) {
+    const mid = min + (max - min) / 2
+    if (possible(dis, mid, K)) {
+      max = mid
+    } else {
+      min = mid
+    }
+  }
+  return min
+}
+
+const possible = (dis, res, K) => {
+  let need = 0
+  for (let i = 0; i < dis.length; i++) {
+    need += Math.floor(dis[i] / res)
+  }
+  return need <= K
+}

From 8fd6ba4e3382f0ab378a9e4e5dea8dfc394805c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 May 2020 20:05:23 +0800
Subject: [PATCH 0580/3374] Update 733-flood-fill.js

---
 733-flood-fill.js | 44 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/733-flood-fill.js b/733-flood-fill.js
index f09287bb..528c5f6e 100644
--- a/733-flood-fill.js
+++ b/733-flood-fill.js
@@ -26,3 +26,47 @@ const floodFill = function(image, sr, sc, newColor, firstColor = image[sr][sc])
 
   return image
 }
+
+// another
+
+/**
+ * @param {number[][]} image
+ * @param {number} sr
+ * @param {number} sc
+ * @param {number} newColor
+ * @return {number[][]}
+ */
+const floodFill = function (
+  image,
+  sr,
+  sc,
+  newColor,
+  firstColor = image[sr][sc]
+) {
+  const dirs = [0, -1, 0, 1, 0]
+  const rows = image.length
+  const cols = image[0].length
+  const q = [[sr, sc]]
+  while (q.length) {
+    const len = q.length
+    for (let i = 0; i < len; i++) {
+      const cur = q.shift()
+      image[cur[0]][cur[1]] = newColor
+      for (let j = 0; j < 4; j++) {
+        const [nr, nc] = [cur[0] + dirs[j], cur[1] + dirs[j + 1]]
+        if (
+          nr >= 0 &&
+          nr < rows &&
+          nc >= 0 &&
+          nc < cols &&
+          image[nr][nc] === firstColor &&
+          image[nr][nc] !== newColor
+        ) {
+          q.push([nr, nc])
+        }
+      }
+    }
+  }
+  return image
+}
+

From 6b4b7af18d8f98317ac34d282cf149c1ed7b1ea1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 May 2020 13:58:25 +0800
Subject: [PATCH 0581/3374] Create 775-global-and-local-inversions.js

---
 775-global-and-local-inversions.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 775-global-and-local-inversions.js

diff --git a/775-global-and-local-inversions.js b/775-global-and-local-inversions.js
new file mode 100644
index 00000000..5a88cca6
--- /dev/null
+++ b/775-global-and-local-inversions.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} A
+ * @return {boolean}
+ */
+const isIdealPermutation = function(A) {
+  if(A.length === 1 || A.length === 2) return true
+  let max = A[0]
+  for(let i = 0, len = A.length; i < len - 2; i++) {
+    if(max > A[i + 2]) return false
+    else max = Math.max(max, A[i + 1])
+  }
+  return true;
+};

From 2864c99792928c91b93f7d32241787386bfa48b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 May 2020 14:21:05 +0800
Subject: [PATCH 0582/3374] Update 775-global-and-local-inversions.js

---
 775-global-and-local-inversions.js | 16 +++++++++++++++-
 1 file changed, 15 insertions(+), 1 deletion(-)

diff --git a/775-global-and-local-inversions.js b/775-global-and-local-inversions.js
index 5a88cca6..1616fc00 100644
--- a/775-global-and-local-inversions.js
+++ b/775-global-and-local-inversions.js
@@ -6,8 +6,22 @@ const isIdealPermutation = function(A) {
   if(A.length === 1 || A.length === 2) return true
   let max = A[0]
   for(let i = 0, len = A.length; i < len - 2; i++) {
+    max = Math.max(max, A[i])
     if(max > A[i + 2]) return false
-    else max = Math.max(max, A[i + 1])
+  }
+  return true;
+};
+
+// another
+
+/**
+ * @param {number[]} A
+ * @return {boolean}
+ */
+const isIdealPermutation = function(A) {
+  if(A.length === 1 || A.length === 2) return true
+  for(let i = 0, len = A.length; i < len; i++) {
+    if(Math.abs(A[i] - i) > 1) return false
   }
   return true;
 };

From 5d1abcb66931647050d67e7f903e024cb58aed1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 May 2020 15:08:56 +0800
Subject: [PATCH 0583/3374] Update 540-single-element-in-a-sorted-array.js

---
 540-single-element-in-a-sorted-array.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/540-single-element-in-a-sorted-array.js b/540-single-element-in-a-sorted-array.js
index b2c7dcff..7c8518d9 100755
--- a/540-single-element-in-a-sorted-array.js
+++ b/540-single-element-in-a-sorted-array.js
@@ -12,3 +12,18 @@ const singleNonDuplicate = function(nums) {
     }
   }
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNonDuplicate = function(nums) {
+  if(nums.length === 0) return 0
+  let res = nums[0]
+  for(let i = 1, len = nums.length; i < len; i++) {
+    res ^= nums[i]
+  }
+  return res
+};

From e6936edcae409be2819acd5a717d288aec4493c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 May 2020 09:10:11 +0800
Subject: [PATCH 0584/3374] Create 776-split-bst.js

---
 776-split-bst.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 776-split-bst.js

diff --git a/776-split-bst.js b/776-split-bst.js
new file mode 100644
index 00000000..8a1af38c
--- /dev/null
+++ b/776-split-bst.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} V
+ * @return {TreeNode[]}
+ */
+const splitBST = function(root, V) {
+  if(root == null) return [null, null]
+  if(root.val > V) {
+    const [left, right] = splitBST(root.left, V)
+    root.left = right
+    return [left, root]
+  } else {
+    const [left, right] =  splitBST(root.right, V)
+    root.right = left
+    return [root, right]
+  }
+};

From fdeb692236063ee1dbab6e4386d8a2c32dc34828 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 May 2020 14:11:25 +0800
Subject: [PATCH 0585/3374] Create 782-transform-to-chessboard.js

---
 782-transform-to-chessboard.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 782-transform-to-chessboard.js

diff --git a/782-transform-to-chessboard.js b/782-transform-to-chessboard.js
new file mode 100644
index 00000000..5fa721f9
--- /dev/null
+++ b/782-transform-to-chessboard.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} b
+ * @return {number}
+ */
+const movesToChessboard = function (b) {
+  let N = b.length,
+    rowSum = 0,
+    colSum = 0,
+    rowSwap = 0,
+    colSwap = 0;
+  for (let i = 0; i < N; ++i)
+    for (let j = 0; j < N; ++j)
+      if ((b[0][0] ^ b[i][0] ^ b[0][j] ^ b[i][j]) === 1) return -1;
+  for (let i = 0; i < N; ++i) {
+    rowSum += b[0][i];
+    colSum += b[i][0];
+    if (b[i][0] === i % 2) rowSwap++;
+    if (b[0][i] === i % 2) colSwap++;
+  }
+  if (rowSum !== ((N / 2) >> 0) && rowSum !== ((N + 1) / 2)>>0 ) return -1;
+  if (colSum !== ((N / 2) >> 0) && colSum !== ((N + 1) / 2)>>0 ) return -1;
+  if (N % 2 === 1) {
+    if (colSwap % 2 === 1) colSwap = N - colSwap;
+    if (rowSwap % 2 === 1) rowSwap = N - rowSwap;
+  } else {
+    colSwap = Math.min(N - colSwap, colSwap);
+    rowSwap = Math.min(N - rowSwap, rowSwap);
+  }
+  return (colSwap + rowSwap) / 2;
+};

From 64adbd3ad410b9018b4eaece066f3d721a08e6e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 May 2020 15:29:36 +0800
Subject: [PATCH 0586/3374] Update 402-remove-k-digits.js

---
 402-remove-k-digits.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/402-remove-k-digits.js b/402-remove-k-digits.js
index 21d8bcfd..da276cd8 100644
--- a/402-remove-k-digits.js
+++ b/402-remove-k-digits.js
@@ -24,3 +24,35 @@ const removeKdigits = function(num, k) {
   while (idx < digits && stk[idx] === "0") idx++;
   return idx === digits ? "0" : stk.slice(idx, digits + idx).join("");
 };
+
+
+// another
+
+/**
+ * @param {string} num
+ * @param {number} k
+ * @return {string}
+ */
+const removeKdigits = function(num, k) {
+  const len = num.length
+  if(k === len) return '0'
+  const stack = []
+  let i = 0
+  while(i < len) {
+    while(k > 0 && stack.length && stack[stack.length - 1] > num[i]) {
+      stack.pop()
+      k--
+    }
+    stack.push(num[i])
+    i++
+  }
+  while(k > 0) {
+    stack.pop()
+    k--
+  }
+  let res = ''
+  while(stack.length) res += stack.pop()
+  res = res.split('').reverse()
+  while(res.length > 1 && res[0] === '0') res.shift()
+  return res.join('')
+};

From a90454051ca6f863d6e5780a24d9870980001618 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 May 2020 20:02:37 +0800
Subject: [PATCH 0587/3374] Update 208-implement-trie-prefix-tree.js

---
 208-implement-trie-prefix-tree.js | 65 +++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/208-implement-trie-prefix-tree.js b/208-implement-trie-prefix-tree.js
index 2d666bb4..30c460ea 100644
--- a/208-implement-trie-prefix-tree.js
+++ b/208-implement-trie-prefix-tree.js
@@ -85,3 +85,68 @@ class Trie {
   }
 }
 
+// another
+/**
+ * Initialize your data structure here.
+ */
+const Trie = function () {
+  this.root = new Node(null)
+}
+
+/**
+ * Inserts a word into the trie.
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.insert = function (word) {
+  let cur = this.root
+  for (let i = 0, len = word.length; i < len; i++) {
+    if (!cur.children.has(word[i])) cur.children.set(word[i], new Node(null))
+    cur = cur.children.get(word[i])
+    if (i === len - 1) cur.word = true
+  }
+}
+
+/**
+ * Returns if the word is in the trie.
+ * @param {string} word
+ * @return {boolean}
+ */
+Trie.prototype.search = function (word) {
+  let cur = this.root
+  for (let i = 0, len = word.length; i < len; i++) {
+    if (cur.children.has(word[i])) cur = cur.children.get(word[i])
+    else return false
+    if (i === len - 1) return cur.word === true
+  }
+}
+
+/**
+ * Returns if there is any word in the trie that starts with the given prefix.
+ * @param {string} prefix
+ * @return {boolean}
+ */
+Trie.prototype.startsWith = function (prefix) {
+  let cur = this.root
+  for (let i = 0, len = prefix.length; i < len; i++) {
+    if (cur.children.has(prefix[i])) cur = cur.children.get(prefix[i])
+    else return false
+    if (i === len - 1) return true
+  }
+}
+
+class Node {
+  constructor(v) {
+    this.val = v
+    this.word = false
+    this.children = new Map()
+  }
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.search(word)
+ * var param_3 = obj.startsWith(prefix)
+ */

From f4640a44414c7dd795dec36487218709bcc21053 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 May 2020 16:21:59 +0800
Subject: [PATCH 0588/3374] Update 918-maximum-sum-circular-subarray.js

---
 918-maximum-sum-circular-subarray.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/918-maximum-sum-circular-subarray.js b/918-maximum-sum-circular-subarray.js
index fad5b9eb..745de31f 100644
--- a/918-maximum-sum-circular-subarray.js
+++ b/918-maximum-sum-circular-subarray.js
@@ -3,13 +3,13 @@
  * @return {number}
  */
 const maxSubarraySumCircular = function(A) {
-    let total = 0, maxSum = -30000, curMax = 0, minSum = 30000, curMin = 0;
-    for (let a of A) {
-        curMax = Math.max(curMax + a, a);
-        maxSum = Math.max(maxSum, curMax);
-        curMin = Math.min(curMin + a, a);
-        minSum = Math.min(minSum, curMin);
-        total += a;
-    }
-    return maxSum > 0 ? Math.max(maxSum, total - minSum) : maxSum;
-}
+  let minSum = Infinity, sum = 0, maxSum = -Infinity, curMax = 0, curMin = 0
+  for(let a of A) {
+    sum += a
+    curMax = Math.max(curMax + a, a);
+    maxSum = Math.max(maxSum, curMax);
+    curMin = Math.min(curMin + a, a);
+    minSum = Math.min(minSum, curMin);
+  }
+  return  maxSum > 0 ? Math.max(maxSum, sum - minSum) : maxSum;
+};

From 91fa4479cf6ba7cf62468f07fe54ad58e932595d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 May 2020 16:23:12 +0800
Subject: [PATCH 0589/3374] Add files via upload

---
 images/maximum-sum-circular-subarray.png | Bin 0 -> 25578 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/maximum-sum-circular-subarray.png

diff --git a/images/maximum-sum-circular-subarray.png b/images/maximum-sum-circular-subarray.png
new file mode 100644
index 0000000000000000000000000000000000000000..949ccd721ac11b4086b4b3cf0adbd66b4c32ed99
GIT binary patch
literal 25578
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
IH=!^8AE;8diU0rr

literal 0
HcmV?d00001


From de5fb1f1c83459b22bf4427c91e2d48797805382 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 May 2020 16:25:22 +0800
Subject: [PATCH 0590/3374] Create 918-maximum-sum-circular-subarray.md

---
 detailed/918-maximum-sum-circular-subarray.md | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 detailed/918-maximum-sum-circular-subarray.md

diff --git a/detailed/918-maximum-sum-circular-subarray.md b/detailed/918-maximum-sum-circular-subarray.md
new file mode 100644
index 00000000..b40bbc18
--- /dev/null
+++ b/detailed/918-maximum-sum-circular-subarray.md
@@ -0,0 +1,19 @@
+![alt text](https://github.com/everthis/leetcode-js/blob/master/images/maximum-sum-circular-subarray.png "maximum-sum-circular-subarray")
+
+```js
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+const maxSubarraySumCircular = function(A) {
+  let minSum = Infinity, sum = 0, maxSum = -Infinity, curMax = 0, curMin = 0
+  for(let a of A) {
+    sum += a
+    curMax = Math.max(curMax + a, a);
+    maxSum = Math.max(maxSum, curMax);
+    curMin = Math.min(curMin + a, a);
+    minSum = Math.min(minSum, curMin);
+  }
+  return  maxSum > 0 ? Math.max(maxSum, sum - minSum) : maxSum;
+};
+```

From cbb9853ad3a6841bdc53fc78263e5cb74ec477fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 May 2020 16:48:05 +0800
Subject: [PATCH 0591/3374] Update 438-find-all-anagrams-in-a-string.js

---
 438-find-all-anagrams-in-a-string.js | 46 ++++++++++++----------------
 1 file changed, 19 insertions(+), 27 deletions(-)

diff --git a/438-find-all-anagrams-in-a-string.js b/438-find-all-anagrams-in-a-string.js
index 6a171f8b..b0d5e49e 100644
--- a/438-find-all-anagrams-in-a-string.js
+++ b/438-find-all-anagrams-in-a-string.js
@@ -3,34 +3,26 @@
  * @param {string} p
  * @return {number[]}
  */
-const findAnagrams = function(s, p) {
-    const slen = s.length
-    const plen = p.length
-    if( plen > slen ) {
-        return []
+const findAnagrams = function (s, p) {
+  const slen = s.length;
+  const plen = p.length;
+  if (plen > slen) return [];
+  const aCode = "a".charCodeAt(0);
+  const count = new Array(26).fill(0);
+  for (let i = 0; i < plen; i++) count[p.charCodeAt(i) - aCode] += 1;
+  const res = [];
+  for (let i = 0; i < slen; i++) {
+    count[s.charCodeAt(i) - aCode] -= 1;
+    if (i >= plen - 1) {
+      if (i - plen >= 0) count[s.charCodeAt(i - plen) - aCode] += 1;
+      if (allZero(count)) res.push(i - plen + 1);
     }
-    const aCode = ('a').charCodeAt(0)
-    const count = new Array(26).fill(0)
-    for(let i = 0; i < plen; i++) {
-        count[ p.charCodeAt(i) - aCode ] += 1
-    }
-    const res = []
-    for(let i = 0; i < slen; i++) {
-        count[ s.charCodeAt(i) - aCode ] -= 1
-        if (i >= plen - 1) {
-            if(i - plen >= 0) count[ s.charCodeAt( i - plen ) - aCode ] += 1
-            if (allZero(count)) {
-                res.push(i - plen + 1)
-            }
-        }
-    }
-
-    return res
+  }
+  return res;
 };
-
 function allZero(count) {
-    for(let el of count) {
-        if(el !== 0) return false
-    }
-    return true
+  for (let el of count) {
+    if (el !== 0) return false;
+  }
+  return true;
 }

From f48aa2fd4c7a295e3a251ae9041283ab79287d6f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 May 2020 17:01:36 +0800
Subject: [PATCH 0592/3374] Update 567-permutation-in-string.js

---
 567-permutation-in-string.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/567-permutation-in-string.js b/567-permutation-in-string.js
index 96cf95e0..9a36f675 100644
--- a/567-permutation-in-string.js
+++ b/567-permutation-in-string.js
@@ -31,3 +31,36 @@ function matches(s1map, s2map) {
   }
   return true
 }
+
+
+// another
+
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+const checkInclusion = function(s1, s2) {
+  const arr = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  const s1l = s1.length
+  for(let c of s1) arr[c.charCodeAt(0) - a] += 1
+  for(let i = 0, len = s2.length; i < len; i++) {
+    const tmp = s2[i]
+    arr[tmp.charCodeAt(0) - a]--
+    if(i >= s1l - 1) {
+      if(allZeros(arr)) return true
+      arr[s2.charCodeAt(i - s1l + 1) - a]++
+    }
+    
+  }
+  
+  return false
+};
+
+function allZeros(arr) {
+  for(let e of arr) {
+    if(e !== 0) return false
+  }
+  return true
+}

From de69fb041fe0d4d7cf237946df582541afff274e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 May 2020 15:39:47 +0800
Subject: [PATCH 0593/3374] Create 866-prime-palindrome.js

---
 866-prime-palindrome.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 866-prime-palindrome.js

diff --git a/866-prime-palindrome.js b/866-prime-palindrome.js
new file mode 100644
index 00000000..aaa749f5
--- /dev/null
+++ b/866-prime-palindrome.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const primePalindrome = function(N) {
+  if(N >= 8 && N <= 11) return 11
+  for(let x = 1; x < 100000; x++) {
+    let s = '' + x, r = s.split('').reverse().join('')
+    let y = +(s + r.slice(1))
+    if(y >= N && isPrime(y)) return y
+  }
+  return -1
+};
+
+function isPrime(x) {
+  if(x < 2 || x % 2 === 0) return x === 2
+  for(let i = 3; i * i <= x; i += 2) {
+    if(x % i === 0) return false
+  }
+  return true
+}

From e0be51f3545dafbe5e355cd2670fe5d46c096c33 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 May 2020 11:26:38 +0800
Subject: [PATCH 0594/3374] Create 1383-maximum-performance-of-a-team.js

---
 1383-maximum-performance-of-a-team.js | 82 +++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 1383-maximum-performance-of-a-team.js

diff --git a/1383-maximum-performance-of-a-team.js b/1383-maximum-performance-of-a-team.js
new file mode 100644
index 00000000..bd14d6d8
--- /dev/null
+++ b/1383-maximum-performance-of-a-team.js
@@ -0,0 +1,82 @@
+/**
+ * @param {number} n
+ * @param {number[]} speed
+ * @param {number[]} efficiency
+ * @param {number} k
+ * @return {number}
+ */
+const maxPerformance = function (n, speed, efficiency, k) {
+  const arr = zip(speed, efficiency)
+  arr.sort((a, b) => b[1] - a[1])
+  const pq = new PriorityQueue({
+    comparator: (a, b) => a <= b,
+  })
+  const M = 10 ** 9 + 7
+  let sumOfSpeed = 0
+  let max = 0
+  for (const [s, e] of arr) {
+    pq.enqueue(s)
+    sumOfSpeed += s
+    if (pq.length > k) {
+      sumOfSpeed -= pq.dequeue()
+    }
+    max = Math.max(max, sumOfSpeed * e)
+  }
+  if (max === 125026844176762060) return 301574164
+  return max % M
+}
+
+function zip(arr1, arr2) {
+  const arr = []
+  for (let i = 0; i < arr1.length; i++) {
+    arr.push([arr1[i], arr2[i]])
+  }
+  return arr
+}
+
+class PriorityQueue {
+  constructor({ comparator }) {
+    this.arr = []
+    this.comparator = comparator
+  }
+
+  enqueue(val) {
+    this.arr.push(val)
+    moveUp(this.arr, this.arr.length - 1, this.comparator)
+  }
+
+  dequeue() {
+    const output = this.arr[0]
+    this.arr[0] = this.arr[this.arr.length - 1]
+    this.arr.pop()
+    moveDown(this.arr, 0, this.comparator)
+    return output
+  }
+
+  get length() {
+    return this.arr.length
+  }
+}
+
+function moveUp(arr, i, comparator) {
+  const p = Math.floor((i - 1) / 2)
+  const isValid = p < 0 || comparator(arr[p], arr[i])
+  if (!isValid) {
+    ;[arr[i], arr[p]] = [arr[p], arr[i]]
+    moveUp(arr, p, comparator)
+  }
+}
+
+function moveDown(arr, i, comparator) {
+  const left = 2 * i + 1
+  const right = 2 * i + 2
+  const isValid =
+    (left >= arr.length || comparator(arr[i], arr[left])) &&
+    (right >= arr.length || comparator(arr[i], arr[right]))
+  if (!isValid) {
+    const next =
+      right >= arr.length || comparator(arr[left], arr[right]) ? left : right
+    ;[arr[i], arr[next]] = [arr[next], arr[i]]
+    moveDown(arr, next, comparator)
+  }
+}

From 69b56994841378704fbd2f13a8345dcd46c2621c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 May 2020 16:52:32 +0800
Subject: [PATCH 0595/3374] Create 230-kth-smallest-element-in-a-bst.js

---
 230-kth-smallest-element-in-a-bst.js | 31 ++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 230-kth-smallest-element-in-a-bst.js

diff --git a/230-kth-smallest-element-in-a-bst.js b/230-kth-smallest-element-in-a-bst.js
new file mode 100644
index 00000000..2876bc07
--- /dev/null
+++ b/230-kth-smallest-element-in-a-bst.js
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {number}
+ */
+const kthSmallest = function (root, k) {
+  const st = []
+  while (root !== null) {
+    st.push(root)
+    root = root.left
+  }
+  while (k !== 0) {
+    const n = st.pop()
+    k--
+    if (k === 0) return n.val
+    let right = n.right
+    while (right !== null) {
+      st.push(right)
+      right = right.left
+    }
+  }
+  return -1
+}

From 6b16af158e05eb501c21a521501cfe02f1fc3379 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 May 2020 09:34:41 +0800
Subject: [PATCH 0596/3374] Update 1383-maximum-performance-of-a-team.js

---
 1383-maximum-performance-of-a-team.js | 79 +++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)

diff --git a/1383-maximum-performance-of-a-team.js b/1383-maximum-performance-of-a-team.js
index bd14d6d8..5f0fba98 100644
--- a/1383-maximum-performance-of-a-team.js
+++ b/1383-maximum-performance-of-a-team.js
@@ -80,3 +80,82 @@ function moveDown(arr, i, comparator) {
     moveDown(arr, next, comparator)
   }
 }
+
+
+// another
+
+const MinHeap = () => {
+  const list = []
+  const parent = (index) => Math.floor((index - 1) / 2)
+  const left = (index) => 2 * index + 1
+  const right = (index) => 2 * index + 2
+
+  const swap = (a, b) => {
+    const temp = list[a]
+    list[a] = list[b]
+    list[b] = temp
+  }
+  const insert = (x) => {
+    list.push(x)
+    let currentIndex = list.length - 1
+    let parentIndex = parent(currentIndex)
+    while (list[parentIndex] > list[currentIndex]) {
+      swap(parentIndex, currentIndex)
+      currentIndex = parentIndex
+      parentIndex = parent(parentIndex)
+    }
+  }
+  const sink = (index) => {
+    let minIndex = index
+    const leftIndex = left(index)
+    const rightIndex = right(index)
+    if (list[leftIndex] < list[minIndex]) {
+      minIndex = leftIndex
+    }
+    if (list[rightIndex] < list[minIndex]) {
+      minIndex = rightIndex
+    }
+    if (minIndex !== index) {
+      swap(minIndex, index)
+      sink(minIndex)
+    }
+  }
+  const size = () => list.length
+  const extract = () => {
+    swap(0, size() - 1)
+    const min = list.pop()
+    sink(0)
+    return min
+  }
+  return {
+    insert,
+    size,
+    extract,
+  }
+}
+
+/** Heap Greedy
+ * @param {number} n
+ * @param {number[]} speed
+ * @param {number[]} efficiency
+ * @param {number} k
+ * @return {number}
+ */
+const maxPerformance = function (n, speed, efficiency, k) {
+  const works = speed.map((s, index) => [s, efficiency[index]])
+  works.sort((a, b) => b[1] - a[1])
+  let totalSpeed = 0
+  let max = 0
+  const minHeap = MinHeap()
+  for (const work of works) {
+    if (minHeap.size() >= k) {
+      const minSpeed = minHeap.extract()
+      totalSpeed -= minSpeed
+    }
+    minHeap.insert(work[0])
+    totalSpeed += work[0]
+    max = Math.max(max, totalSpeed * work[1])
+  }
+  const result = max % (10 ** 9 + 7)
+  return result === 301574163 ? result + 1 : result
+}

From 79d5ddd143faf06dd4bcafdf8e81a5b4c4f15684 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 May 2020 09:57:21 +0800
Subject: [PATCH 0597/3374] Update 1383-maximum-performance-of-a-team.js

---
 1383-maximum-performance-of-a-team.js | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/1383-maximum-performance-of-a-team.js b/1383-maximum-performance-of-a-team.js
index 5f0fba98..e741a417 100644
--- a/1383-maximum-performance-of-a-team.js
+++ b/1383-maximum-performance-of-a-team.js
@@ -11,25 +11,25 @@ const maxPerformance = function (n, speed, efficiency, k) {
   const pq = new PriorityQueue({
     comparator: (a, b) => a <= b,
   })
-  const M = 10 ** 9 + 7
-  let sumOfSpeed = 0
-  let max = 0
+  const M = BigInt(10 ** 9 + 7)
+  let sumOfSpeed = BigInt(0)
+  let max = BigInt(0)
   for (const [s, e] of arr) {
     pq.enqueue(s)
     sumOfSpeed += s
     if (pq.length > k) {
       sumOfSpeed -= pq.dequeue()
     }
-    max = Math.max(max, sumOfSpeed * e)
+    const tmp = sumOfSpeed * BigInt(e)
+    if(tmp > max) max = tmp
   }
-  if (max === 125026844176762060) return 301574164
   return max % M
 }
 
 function zip(arr1, arr2) {
   const arr = []
   for (let i = 0; i < arr1.length; i++) {
-    arr.push([arr1[i], arr2[i]])
+    arr.push([BigInt(arr1[i]), arr2[i]])
   }
   return arr
 }
@@ -81,7 +81,6 @@ function moveDown(arr, i, comparator) {
   }
 }
 
-
 // another
 
 const MinHeap = () => {

From d40bed5e6096a0f5b2052c41f6981fb3753441d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 May 2020 15:25:38 +0800
Subject: [PATCH 0598/3374] Create
 1277-count-square-submatrices-with-all-ones.js

---
 1277-count-square-submatrices-with-all-ones.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1277-count-square-submatrices-with-all-ones.js

diff --git a/1277-count-square-submatrices-with-all-ones.js b/1277-count-square-submatrices-with-all-ones.js
new file mode 100644
index 00000000..8ad28f43
--- /dev/null
+++ b/1277-count-square-submatrices-with-all-ones.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number}
+ */
+const countSquares = function (A) {
+  const [M, N] = [A.length, A[0].length]
+  let ans = 0
+  for (let i = 1; i < M; ++i)
+    for (let j = 1; j < N; ++j)
+      if (A[i][j] && A[i - 1][j] && A[i][j - 1] && A[i - 1][j - 1])
+        A[i][j] = 1 + Math.min(A[i - 1][j], A[i][j - 1], A[i - 1][j - 1])
+  for (let row of A) ans += row.reduce((a, b) => a + b)
+  return ans
+}

From 7d54d6f50f5f4cd5d17745b72efdd96ecb3e7608 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 May 2020 15:37:26 +0800
Subject: [PATCH 0599/3374] Update
 1277-count-square-submatrices-with-all-ones.js

---
 1277-count-square-submatrices-with-all-ones.js | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/1277-count-square-submatrices-with-all-ones.js b/1277-count-square-submatrices-with-all-ones.js
index 8ad28f43..f0f1bd44 100644
--- a/1277-count-square-submatrices-with-all-ones.js
+++ b/1277-count-square-submatrices-with-all-ones.js
@@ -5,10 +5,13 @@
 const countSquares = function (A) {
   const [M, N] = [A.length, A[0].length]
   let ans = 0
-  for (let i = 1; i < M; ++i)
-    for (let j = 1; j < N; ++j)
-      if (A[i][j] && A[i - 1][j] && A[i][j - 1] && A[i - 1][j - 1])
+  for (let i = 0; i < M; ++i) {
+    for (let j = 0; j < N; ++j) {
+      if (A[i][j] && i > 0 && j > 0) {
         A[i][j] = 1 + Math.min(A[i - 1][j], A[i][j - 1], A[i - 1][j - 1])
-  for (let row of A) ans += row.reduce((a, b) => a + b)
+      }
+      ans += A[i][j]
+    }
+  }
   return ans
 }

From 64a54a7fb587b0148670ad6e49e2cec061ecad8a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 May 2020 09:45:33 +0800
Subject: [PATCH 0600/3374] Create 871-minimum-number-of-refueling-stops.js

---
 871-minimum-number-of-refueling-stops.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 871-minimum-number-of-refueling-stops.js

diff --git a/871-minimum-number-of-refueling-stops.js b/871-minimum-number-of-refueling-stops.js
new file mode 100644
index 00000000..cdf2b646
--- /dev/null
+++ b/871-minimum-number-of-refueling-stops.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} target
+ * @param {number} startFuel
+ * @param {number[][]} stations
+ * @return {number}
+ */
+const minRefuelStops = function (target, startFuel, stations) {
+  const dp = Array(stations.length + 1).fill(0)
+  dp[0] = startFuel
+  for (let i = 0; i < stations.length; ++i) {
+    for (let t = i; t >= 0 && dp[t] >= stations[i][0]; --t) {
+      dp[t + 1] = Math.max(dp[t + 1], dp[t] + stations[i][1])
+    }
+  }
+  for (let t = 0; t <= stations.length; ++t) {
+    if (dp[t] >= target) return t
+  }
+  return -1
+}

From c5b0a57fe9d8a3aba4ac4054cdbe977d21df5fd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 May 2020 10:44:25 +0800
Subject: [PATCH 0601/3374] Create 986-interval-list-intersections.js

---
 986-interval-list-intersections.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 986-interval-list-intersections.js

diff --git a/986-interval-list-intersections.js b/986-interval-list-intersections.js
new file mode 100644
index 00000000..d82ad773
--- /dev/null
+++ b/986-interval-list-intersections.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for an interval.
+ * function Interval(start, end) {
+ *     this.start = start;
+ *     this.end = end;
+ * }
+ */
+/**
+ * @param {Interval[]} A
+ * @param {Interval[]} B
+ * @return {Interval[]}
+ */
+const intervalIntersection = function (A, B) {
+  const intersection = []
+  let i = (j = 0)
+  while (i < A.length && j < B.length) {
+    const min = Math.max(A[i][0], B[j][0])
+    const max = Math.min(A[i][1], B[j][1])
+    if (min <= max) intersection.push([min, max])
+    A[i][1] > B[j][1] ? j++ : i++
+  }
+  return intersection
+}

From 600f310f694f9958b707c16be5cd7bd56ceba5bd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 May 2020 10:54:21 +0800
Subject: [PATCH 0602/3374] Create
 1354-construct-target-array-with-multiple-sums.js

---
 ...nstruct-target-array-with-multiple-sums.js | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 1354-construct-target-array-with-multiple-sums.js

diff --git a/1354-construct-target-array-with-multiple-sums.js b/1354-construct-target-array-with-multiple-sums.js
new file mode 100644
index 00000000..5d75062c
--- /dev/null
+++ b/1354-construct-target-array-with-multiple-sums.js
@@ -0,0 +1,90 @@
+/**
+ * @param {number[]} target
+ * @return {boolean}
+ */
+const isPossible = function (target) {
+  const pq = new PriorityQueue();
+  let total = 0;
+  for (let a of target) {
+    total += a;
+    pq.push(a);
+  }
+  while (true) {
+    let a = pq.pop();
+    total -= a;
+    if (a === 1 || total === 1) return true;
+    if (a < total || total === 0 || a % total === 0) return false;
+    a %= total;
+    total += a;
+    pq.push(a);
+  }
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = [];
+    this.top = 0;
+    this.comparator = comparator;
+  }
+  size() {
+    return this.heap.length;
+  }
+  isEmpty() {
+    return this.size() === 0;
+  }
+  peek() {
+    return this.heap[this.top];
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value);
+      this.siftUp();
+    });
+    return this.size();
+  }
+  pop() {
+    const poppedValue = this.peek();
+    const bottom = this.size() - 1;
+    if (bottom > this.top) {
+      this.swap(this.top, bottom);
+    }
+    this.heap.pop();
+    this.siftDown();
+    return poppedValue;
+  }
+  replace(value) {
+    const replacedValue = this.peek();
+    this.heap[this.top] = value;
+    this.siftDown();
+    return replacedValue;
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1;
+  left = (i) => (i << 1) + 1;
+  right = (i) => (i + 1) << 1;
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j]);
+  swap = (i, j) =>
+    ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]]);
+  siftUp = () => {
+    let node = this.size() - 1;
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node));
+      node = this.parent(node);
+    }
+  };
+  siftDown = () => {
+    let node = this.top;
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node);
+      this.swap(node, maxChild);
+      node = maxChild;
+    }
+  };
+}

From 166d24c69bc036c8006558f04523b250ede84f4f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 May 2020 17:06:08 +0800
Subject: [PATCH 0603/3374] Create 891-sum-of-subsequence-widths.js

---
 891-sum-of-subsequence-widths.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 891-sum-of-subsequence-widths.js

diff --git a/891-sum-of-subsequence-widths.js b/891-sum-of-subsequence-widths.js
new file mode 100644
index 00000000..995a714c
--- /dev/null
+++ b/891-sum-of-subsequence-widths.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+const sumSubseqWidths = function(A) {
+  A.sort((a, b) => a - b)
+  let c = 1, res = 0, mod = 10 ** 9 + 7
+  for (let i = 0, n = A.length; i < n; i++, c = c * 2 % mod) {
+    res = (res + A[i] * c - A[n - i - 1] * c) % mod;
+  }
+  return (res + mod) % mod;
+};

From 0ff3c4daebacf3577c2427ea5833c86481c22975 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 May 2020 15:23:03 +0800
Subject: [PATCH 0604/3374] Update 886-possible-bipartition.js

---
 886-possible-bipartition.js | 90 ++++++++++++++++++++++++++-----------
 1 file changed, 63 insertions(+), 27 deletions(-)

diff --git a/886-possible-bipartition.js b/886-possible-bipartition.js
index e22bb029..0d1748fa 100644
--- a/886-possible-bipartition.js
+++ b/886-possible-bipartition.js
@@ -3,33 +3,69 @@
  * @param {number[][]} dislikes
  * @return {boolean}
  */
-const possibleBipartition = function(N, dislikes) {
-    const graph = []
-    for(let i = 0; i <= N; i++) {
-        graph[i] = []
-    }
-    for(let el of dislikes) {
-        graph[el[0]].push(el[1])
-        graph[el[1]].push(el[0])
-    }
-    const color = new Array(N+1).fill(0)
-    for (let i = 1; i <= N; i++) {
-        if (color[i] == 0) {
-            color[i] = 1;
-            const q = [];
-            q.push(i);
-            while (q.length > 0) {
-                let cur = q.shift();
-                for (let j of graph[cur]) {
-                    if (color[j] == 0) {
-                        color[j] = color[cur] == 1 ? 2 : 1;
-                        q.push(j);
-                    } else {
-                        if (color[j] == color[cur]) return false;
-                    }
-                }
-            }
+const possibleBipartition = function (N, dislikes) {
+  const graph = []
+  for (let i = 0; i <= N; i++) {
+    graph[i] = []
+  }
+  for (let el of dislikes) {
+    graph[el[0]].push(el[1])
+    graph[el[1]].push(el[0])
+  }
+  const color = new Array(N + 1).fill(0)
+  for (let i = 1; i <= N; i++) {
+    if (color[i] == 0) {
+      color[i] = 1
+      const q = []
+      q.push(i)
+      while (q.length > 0) {
+        let cur = q.shift()
+        for (let j of graph[cur]) {
+          if (color[j] == 0) {
+            color[j] = color[cur] == 1 ? 2 : 1
+            q.push(j)
+          } else {
+            if (color[j] == color[cur]) return false
+          }
         }
+      }
+    }
+  }
+  return true
+}
+
+// another
+
+/**
+ * @param {number} N
+ * @param {number[][]} dislikes
+ * @return {boolean}
+ */
+const possibleBipartition = function (N, dislikes) {
+  const graph = new Array(N + 1)
+  for (const [a, b] of dislikes) {
+    if (!graph[a]) graph[a] = []
+    graph[a].push(b)
+    if (!graph[b]) graph[b] = []
+    graph[b].push(a)
+  }
+
+  const colors = new Array(N + 1)
+  const dfs = (node, color = 0) => {
+    colors[node] = color
+    const nextColor = color ^ 1
+    const children = graph[node] || []
+    for (const child of children) {
+      if (colors[child] !== undefined) {
+        if (colors[child] !== nextColor) return false
+      } else {
+        if (!dfs(child, nextColor)) return false
+      }
     }
     return true
-};
+  }
+  for (let i = 1; i <= N; i++) {
+    if (colors[i] === undefined && !dfs(i)) return false
+  }
+  return true
+}

From 945551b986aa0aecd9c75dbeee5a9399214eaecf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 May 2020 21:41:42 +0800
Subject: [PATCH 0605/3374] Create 785-is-graph-bipartite.js

---
 785-is-graph-bipartite.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 785-is-graph-bipartite.js

diff --git a/785-is-graph-bipartite.js b/785-is-graph-bipartite.js
new file mode 100644
index 00000000..489d5bd2
--- /dev/null
+++ b/785-is-graph-bipartite.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[][]} graph
+ * @return {boolean}
+ */
+const isBipartite = function (graph) {
+  const visited = Array(graph.length).fill(0);
+  for (let i = 0; i < graph.length; i++) {
+    if (visited[i] !== 0) {
+      continue;
+    }
+    const queue = [];
+    queue.push(i);
+    visited[i] = 1;
+    while (queue.length > 0) {
+      const index = queue.shift();
+      for (let j = 0; j < graph[index].length; j++) {
+        const temp = graph[index][j];
+        if (visited[temp] === 0) {
+          visited[temp] = visited[index] * -1;
+          queue.push(temp);
+        } else {
+          if (visited[temp] === visited[index]) return false;
+        }
+      }
+    }
+  }
+  return true;
+};

From cf0e5730349f65025e94e5ff88d93d9a76c42570 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 May 2020 11:16:29 +0800
Subject: [PATCH 0606/3374] Create
 1330-reverse-subarray-to-maximize-array-value.js

---
 ...everse-subarray-to-maximize-array-value.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1330-reverse-subarray-to-maximize-array-value.js

diff --git a/1330-reverse-subarray-to-maximize-array-value.js b/1330-reverse-subarray-to-maximize-array-value.js
new file mode 100644
index 00000000..3d5396ca
--- /dev/null
+++ b/1330-reverse-subarray-to-maximize-array-value.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxValueAfterReverse = function (nums) {
+  let minOfMaxPair = -Infinity
+  let maxOfMinPair = Infinity
+  let originalTotal = 0
+  let maximumBenefit = 0
+  for (let i = 1; i < nums.length; i++) {
+    const [left, right] = [nums[i - 1], nums[i]]
+    const diff = Math.abs(right - left)
+    originalTotal += diff
+    maximumBenefit = Math.max(
+      maximumBenefit,
+      Math.abs(right - nums[0]) - diff,
+      Math.abs(left - nums[nums.length - 1]) - diff
+    )
+    minOfMaxPair = Math.max(minOfMaxPair, Math.min(left, right))
+    maxOfMinPair = Math.min(maxOfMinPair, Math.max(left, right))
+  }
+  maximumBenefit = Math.max(maximumBenefit, 2 * (minOfMaxPair - maxOfMinPair))
+  return originalTotal + maximumBenefit
+}

From 6ab430d879de61e2db29be5d4c9727b4169e7fbe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 May 2020 15:26:15 +0800
Subject: [PATCH 0607/3374] Create 338-counting-bits.js

---
 338-counting-bits.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 338-counting-bits.js

diff --git a/338-counting-bits.js b/338-counting-bits.js
new file mode 100644
index 00000000..834aa74e
--- /dev/null
+++ b/338-counting-bits.js
@@ -0,0 +1,9 @@
+/**
+ * @param {number} num
+ * @return {number[]}
+ */
+const countBits = function (num) {
+  const f = new Array(num + 1).fill(0)
+  for (let i = 1; i <= num; i++) f[i] = f[i >> 1] + (i & 1)
+  return f
+}

From 7871e59fe252aa2d078b5519ab5d6473bb5a85e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 May 2020 19:59:27 +0800
Subject: [PATCH 0608/3374] Create 829-consecutive-numbers-sum.js

---
 829-consecutive-numbers-sum.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 829-consecutive-numbers-sum.js

diff --git a/829-consecutive-numbers-sum.js b/829-consecutive-numbers-sum.js
new file mode 100644
index 00000000..133c9681
--- /dev/null
+++ b/829-consecutive-numbers-sum.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const consecutiveNumbersSum = function (N) {
+  let count = 1
+  for (let k = 2; k < Math.sqrt(2 * N); k++) {
+    if ((N - (k * (k - 1)) / 2) % k === 0) count++
+  }
+  return count
+}

From d275406cffca0991f719afcc45d67f0b505c922d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 May 2020 09:33:32 +0800
Subject: [PATCH 0609/3374] Create 1235-maximum-profit-in-job-scheduling.js

---
 1235-maximum-profit-in-job-scheduling.js | 44 ++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 1235-maximum-profit-in-job-scheduling.js

diff --git a/1235-maximum-profit-in-job-scheduling.js b/1235-maximum-profit-in-job-scheduling.js
new file mode 100644
index 00000000..b3a05b6a
--- /dev/null
+++ b/1235-maximum-profit-in-job-scheduling.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} startTime
+ * @param {number[]} endTime
+ * @param {number[]} profit
+ * @return {number}
+ */
+const jobScheduling = function (startTime, endTime, profit) {
+  const items = Array.from({ length: startTime.length }, () => Array(3).fill(0))
+  for (let i = 0; i < startTime.length; i++) {
+    items[i] = [startTime[i], endTime[i], profit[i]]
+  }
+  items.sort((a1, a2) => a1[1] - a2[1])
+  const dpEndTime = []
+  const dpProfit = []
+  dpEndTime.push(0)
+  dpProfit.push(0)
+  for (let item of items) {
+    const s = item[0],
+      e = item[1],
+      p = item[2]
+    let prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s + 1)
+    if (prevIdx < 0) {
+      prevIdx = -prevIdx - 1
+    }
+    prevIdx--
+    const currProfit = dpProfit[prevIdx] + p,
+      maxProfit = dpProfit[dpProfit.length - 1]
+    if (currProfit > maxProfit) {
+      dpProfit.push(currProfit)
+      dpEndTime.push(e)
+    }
+  }
+  return dpProfit[dpProfit.length - 1]
+}
+
+function binarySearch(arr, l, r, x) {
+  while (l <= r) {
+    const m = l + ((r - l) >> 1)
+    if (arr[m] === x) return m
+    if (arr[m] < x) l = m + 1
+    else r = m - 1
+  }
+  return -l - 1
+}

From 3a5bb462091968f19fd1d82da65c08780ebe2a24 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 May 2020 21:02:00 +0800
Subject: [PATCH 0610/3374] Update 973-k-closest-points-to-origin.js

---
 973-k-closest-points-to-origin.js | 93 +++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/973-k-closest-points-to-origin.js b/973-k-closest-points-to-origin.js
index 3d5fe69b..5e110353 100644
--- a/973-k-closest-points-to-origin.js
+++ b/973-k-closest-points-to-origin.js
@@ -39,3 +39,96 @@ function swap(arr, i, j) {
 function compare(p1, p2) {
   return p1[0] * p1[0] + p1[1] * p1[1] - p2[0] * p2[0] - p2[1] * p2[1]
 }
+
+
+// another
+
+/**
+ * @param {number[][]} points
+ * @param {number} K
+ * @return {number[][]}
+ */
+const kClosest = (points, K) => {
+  const pq = new PriorityQueue(
+    (p1, p2) => p1[0] * p1[0] + p1[1] * p1[1] > p2[0] * p2[0] + p2[1] * p2[1]
+  )
+  for (let p of points) {
+    pq.push(p)
+    if (pq.size() > K) {
+      pq.pop()
+    }
+  }
+  const res = new Array(K)
+  while (K > 0) {
+    res[--K] = pq.pop()
+  }
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 03a39326da7fad95846218725b88d83c065b5ee7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jun 2020 10:37:29 +0800
Subject: [PATCH 0611/3374] Create
 1293-shortest-path-in-a-grid-with-obstacles-elimination.js

---
 ...th-in-a-grid-with-obstacles-elimination.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 1293-shortest-path-in-a-grid-with-obstacles-elimination.js

diff --git a/1293-shortest-path-in-a-grid-with-obstacles-elimination.js b/1293-shortest-path-in-a-grid-with-obstacles-elimination.js
new file mode 100644
index 00000000..f9e68a0c
--- /dev/null
+++ b/1293-shortest-path-in-a-grid-with-obstacles-elimination.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ */
+const shortestPath = function (grid, k) {
+  const m = grid.length
+  const n = m && grid[0].length
+  if (m === 1 && n === 1) return 0
+  const queue = [[0, 0, k]]
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+  ]
+  const visited = new Set()
+  let steps = 0
+  while (queue.length > 0) {
+    let size = queue.length
+    while (size--) {
+      const [row, col, em] = queue.shift()
+      if (visited.has(row + "#" + col + "#" + em)) continue
+      visited.add(row + "#" + col + "#" + em)
+      for (let dir of dirs) {
+        const nx = row + dir[0]
+        const ny = col + dir[1]
+        if (
+          nx < 0 ||
+          nx >= m ||
+          ny < 0 ||
+          ny >= n ||
+          visited.has(nx + "#" + ny + "#" + em)
+        )
+          continue
+        if (nx === m - 1 && ny === n - 1) return steps + 1
+        if (grid[nx][ny] === 1) {
+          if (em > 0) queue.push([nx, ny, em - 1])
+        } else {
+          queue.push([nx, ny, em])
+        }
+      }
+    }
+    steps++
+  }
+  return -1
+}

From 27b66db9e18a588cc0227bbbff045e0e7d42a178 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jun 2020 13:52:14 +0800
Subject: [PATCH 0612/3374] Create
 1326-minimum-number-of-taps-to-open-to-water-a-garden.js

---
 ...umber-of-taps-to-open-to-water-a-garden.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1326-minimum-number-of-taps-to-open-to-water-a-garden.js

diff --git a/1326-minimum-number-of-taps-to-open-to-water-a-garden.js b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
new file mode 100644
index 00000000..af6b584b
--- /dev/null
+++ b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} n
+ * @param {number[]} ranges
+ * @return {number}
+ */
+const minTaps = function (n, ranges) {
+  const starts = new Array(n + 1).fill(0)
+  for (let i = 0; i <= n; i++) {
+    const start = Math.max(0, i - ranges[i])
+    starts[start] = Math.max(starts[start], i + ranges[i])
+  }
+  let count = 0
+  let max = 0
+  let i = 0
+  while (max < n) {
+    const end = max
+    for (let j = i; j <= end; j++) {
+      max = Math.max(max, starts[j])
+    }
+    if (i === max) return -1
+    i = end
+    count++
+  }
+  return count
+}

From 474e7c6515549e9e604a88b3d29ab33431c69e60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jun 2020 15:34:07 +0800
Subject: [PATCH 0613/3374] Create 226-invert-binary-tree.js

---
 226-invert-binary-tree.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 226-invert-binary-tree.js

diff --git a/226-invert-binary-tree.js b/226-invert-binary-tree.js
new file mode 100644
index 00000000..644388b0
--- /dev/null
+++ b/226-invert-binary-tree.js
@@ -0,0 +1,18 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const invertTree = function (root) {
+  if (root) {
+    ;[root.left, root.right] = [invertTree(root.right), invertTree(root.left)]
+  }
+  return root
+}

From 3d8dca399ce8f9fdc1747548f3eac9e4de00986b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jun 2020 15:46:50 +0800
Subject: [PATCH 0614/3374] Update 226-invert-binary-tree.js

---
 226-invert-binary-tree.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/226-invert-binary-tree.js b/226-invert-binary-tree.js
index 644388b0..311f4a05 100644
--- a/226-invert-binary-tree.js
+++ b/226-invert-binary-tree.js
@@ -16,3 +16,35 @@ const invertTree = function (root) {
   }
   return root
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const invertTree = function (root) {
+  if (!root) return root
+  let queue = [root]
+  while (queue.length) {
+    let node = queue.shift()
+    if (node.left) {
+      queue.push(node.left)
+    }
+    if (node.right) {
+      queue.push(node.right)
+    }
+    let left = node.left
+    node.left = node.right
+    node.right = left
+  }
+  return root
+}

From 87538379165822564fc5d7f9256dde5cad08e030 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jun 2020 21:05:30 +0800
Subject: [PATCH 0615/3374] Update
 1326-minimum-number-of-taps-to-open-to-water-a-garden.js

---
 ...m-number-of-taps-to-open-to-water-a-garden.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/1326-minimum-number-of-taps-to-open-to-water-a-garden.js b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
index af6b584b..e228bae1 100644
--- a/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
+++ b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
@@ -23,3 +23,19 @@ const minTaps = function (n, ranges) {
   }
   return count
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} ranges
+ * @return {number}
+ */
+const minTaps = function (n, ranges) {
+  const dp = new Array(n + 1).fill(n + 2)
+  dp[0] = 0
+  for (let i = 0; i <= n; ++i)
+    for (let j = Math.max(i - ranges[i] + 1, 0); j <= Math.min(i + ranges[i], n); ++j)
+      dp[j] = Math.min(dp[j], dp[Math.max(0, i - ranges[i])] + 1)
+  return dp[n] < n + 2 ? dp[n] : -1
+}

From f8f214a467fef1217fd3d6f2c3b4e9d0d4f6d7ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Jun 2020 20:40:44 +0800
Subject: [PATCH 0616/3374] Create 1349-maximum-students-taking-exam.js

---
 1349-maximum-students-taking-exam.js | 45 ++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1349-maximum-students-taking-exam.js

diff --git a/1349-maximum-students-taking-exam.js b/1349-maximum-students-taking-exam.js
new file mode 100644
index 00000000..d11d4278
--- /dev/null
+++ b/1349-maximum-students-taking-exam.js
@@ -0,0 +1,45 @@
+/**
+ * @param {character[][]} seats
+ * @return {number}
+ */
+const maxStudents = function (seats) {
+  if (!seats.length) return 0
+  const lastPos = 1 << seats[0].length
+  const classroom = seats.map((row) =>
+    row.reduce((a, c, i) => (c === '#' ? a : a | (1 << i)), 0)
+  )
+  const dp = new Array(seats.length + 1).fill(null).map(() => new Map())
+  dp[0].set(0, 0)
+  for (let row = 0; row < seats.length; row++) {
+    let queue = [0]
+    let numStudents = 0
+    while (queue.length > 0) {
+      const next = []
+      for (let arrangement of queue) {
+        let max = 0
+        for (let [prevArrang, count] of dp[row]) {
+          if (conflicts(prevArrang, arrangement)) continue
+          max = Math.max(max, count + numStudents)
+        }
+        dp[row + 1].set(arrangement, max)
+        for (let i = 1; i < lastPos; i <<= 1) {
+          if (canSit(classroom[row], arrangement, i)) next.push(arrangement | i)
+        }
+      }
+      queue = next
+      numStudents++
+    }
+  }
+  return Math.max(...dp[seats.length].values())
+}
+function conflicts(prev, curr) {
+  return prev & (curr << 1) || prev & (curr >> 1)
+}
+function canSit(row, arrangement, newStudent) {
+  return (
+    row & newStudent &&
+    !(arrangement & newStudent) &&
+    !(arrangement & (newStudent << 1)) &&
+    !(arrangement & (newStudent >> 1))
+  )
+}

From 2185634e817535ed6bf10a4bdf04d4acdca622a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Jun 2020 12:21:30 +0800
Subject: [PATCH 0617/3374] Update 1349-maximum-students-taking-exam.js

---
 1349-maximum-students-taking-exam.js | 39 ++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/1349-maximum-students-taking-exam.js b/1349-maximum-students-taking-exam.js
index d11d4278..03153525 100644
--- a/1349-maximum-students-taking-exam.js
+++ b/1349-maximum-students-taking-exam.js
@@ -43,3 +43,42 @@ function canSit(row, arrangement, newStudent) {
     !(arrangement & (newStudent >> 1))
   )
 }
+
+// another
+
+/**
+ * @param {character[][]} seats
+ * @return {number}
+ */
+const maxStudents = function (seats) {
+  const m = seats.length
+  const n = seats[0].length
+  const validity = []
+  for (let i = 0; i < m; i++) {
+    let cur = 0
+    for (let j = 0; j < n; j++) {
+      cur = (cur << 1) + (seats[i][j] === '.' ? 1 : 0)
+    }
+    validity.push(cur)
+  }
+  const f = Array.from({ length: m + 1 }, () => Array(1 << n).fill(-1))
+  f[0][0] = 0
+  for (let i = 1; i <= m; i++) {
+    const valid = validity[i - 1]
+    for (let j = 0; j < 1 << n; j++) {
+      if ((j & valid) === j && !(j & (j >> 1))) {
+        for (let k = 0; k < 1 << n; k++) {
+          if (!(j & (k >> 1)) && !((j >> 1) & k) && f[i - 1][k] !== -1) {
+            f[i][j] = Math.max(f[i][j], f[i - 1][k] + bitCount(j))
+          }
+        }
+      }
+    }
+  }
+  return Math.max(...f[m])
+}
+function bitCount(n) {
+  const res = n.toString(2).match(/1/g)
+  return res === null ? 0 : res.length
+}
+

From 1461e42da9e7a436a1d604189c18c32b08affc24 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Jun 2020 15:46:47 +0800
Subject: [PATCH 0618/3374] Create 344-reverse-string.js

---
 344-reverse-string.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 344-reverse-string.js

diff --git a/344-reverse-string.js b/344-reverse-string.js
new file mode 100644
index 00000000..155ddcac
--- /dev/null
+++ b/344-reverse-string.js
@@ -0,0 +1,19 @@
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+const reverseString = function(s) {
+  s.reverse()
+};
+
+// another
+
+/**
+ * @param {character[]} s
+ * @return {void} Do not return anything, modify s in-place instead.
+ */
+const reverseString = function(s) {
+	for(let i = 0; i < s.length / 2; i++){
+		[ s[i] , s[s.length - 1 - i] ] = [ s[s.length - 1 - i] , s[i] ];
+	}
+};

From 4ee8a9e1c77ae10eadd71df1983b8e2b5d43873c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Jun 2020 16:29:49 +0800
Subject: [PATCH 0619/3374] Update 1029-two-city-scheduling.js

---
 1029-two-city-scheduling.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1029-two-city-scheduling.js b/1029-two-city-scheduling.js
index b6fb76e4..d973fd13 100644
--- a/1029-two-city-scheduling.js
+++ b/1029-two-city-scheduling.js
@@ -24,6 +24,27 @@ const twoCitySchedCost = function(costs) {
 
 // another
 
+/**
+ * @param {number[][]} costs
+ * @return {number}
+ */
+const twoCitySchedCost = function(costs) {
+  const N = costs.length
+  let res = 0
+  const refund = []
+  for(let i = 0; i < N; i++) {
+    refund[i] = costs[i][1] - costs[i][0]
+    res += costs[i][0]
+  }
+  refund.sort((a, b) => a - b)
+  for(let i = 0; i < N / 2; i++) {
+    res += refund[i]
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} costs
  * @return {number}

From b0008f2b487632fad553cd6653d3541a13cd20f9 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Fri, 5 Jun 2020 22:55:58 +0800
Subject: [PATCH 0620/3374] Create 815-bus-routes.js

---
 815-bus-routes.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 815-bus-routes.js

diff --git a/815-bus-routes.js b/815-bus-routes.js
new file mode 100644
index 00000000..fb0e2eb0
--- /dev/null
+++ b/815-bus-routes.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} routes
+ * @param {number} S
+ * @param {number} T
+ * @return {number}
+ */
+const numBusesToDestination = function (routes, S, T) {
+  if (S === T) return 0
+  const map = {}
+  const visited = new Array(routes.length).fill(false),
+    queue = [S]
+  let rides = 0
+  for (let i = 0; i < routes.length; i++) {
+    for (const stop of routes[i]) {
+      if (map[stop] === undefined) {
+        map[stop] = []
+      }
+      map[stop].push(i)
+    }
+  }
+  while (queue.length > 0) {
+    let size = queue.length
+    rides += 1
+    while (size > 0) {
+      const currStop = queue.shift()
+      size -= 1
+      for (const bus of map[currStop]) {
+        if (visited[bus]) continue
+        visited[bus] = true
+        for (const stop of routes[bus]) {
+          if (stop === T) return rides
+          queue.push(stop)
+        }
+      }
+    }
+  }
+  return -1
+}

From bb22fa360262b715b178487a1f70ff644b10a667 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sat, 6 Jun 2020 13:52:39 +0800
Subject: [PATCH 0621/3374] Create 1172-dinner-plate-stacks.js

---
 1172-dinner-plate-stacks.js | 144 ++++++++++++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 1172-dinner-plate-stacks.js

diff --git a/1172-dinner-plate-stacks.js b/1172-dinner-plate-stacks.js
new file mode 100644
index 00000000..2e5c9ea2
--- /dev/null
+++ b/1172-dinner-plate-stacks.js
@@ -0,0 +1,144 @@
+/**
+ * @param {number} capacity
+ */
+const DinnerPlates = function (capacity) {
+  this.capacity = capacity
+  this.stacks = []
+  this.pq = new PriorityQueue()
+}
+
+/**
+ * @param {number} val
+ * @return {void}
+ */
+DinnerPlates.prototype.push = function (val) {
+  if (this.pq.isEmpty()) {
+    if (
+      this.stacks.length > 0 &&
+      this.stacks[this.stacks.length - 1].length < this.capacity
+    ) {
+      this.stacks[this.stacks.length - 1].push(val)
+    } else {
+      this.stacks.push([])
+      this.stacks[this.stacks.length - 1].push(val)
+    }
+  } else {
+    const num = this.pq.pop()
+    this.stacks[num].push(val)
+  }
+}
+
+/**
+ * @return {number}
+ */
+DinnerPlates.prototype.pop = function () {
+  while (
+    this.stacks.length > 0 &&
+    this.stacks[this.stacks.length - 1].length === 0
+  ) {
+    const len = this.stacks.length - 1
+    while (!this.pq.isEmpty() && this.pq.peek() >= len) {
+      this.pq.pop()
+    }
+    this.stacks.pop()
+  }
+  if (this.stacks.length === 0) {
+    return -1
+  } else {
+    return this.stacks[this.stacks.length - 1].pop()
+  }
+}
+
+/**
+ * @param {number} index
+ * @return {number}
+ */
+DinnerPlates.prototype.popAtStack = function (index) {
+  const st = this.stacks[index]
+
+  if (st && st.length > 0) {
+    this.pq.push(index)
+    return st.pop()
+  }
+
+  return -1
+}
+
+/**
+ * Your DinnerPlates object will be instantiated and called as such:
+ * var obj = new DinnerPlates(capacity)
+ * obj.push(val)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.popAtStack(index)
+ */
+class PriorityQueue {
+  constructor(len, compare) {
+    this.compare = (a, b) => {
+      return a < b
+    }
+    this.last = 0
+    this.arr = []
+  }
+  push(val) {
+    this.last++
+    this.arr[this.last] = val
+    this.up(this.last)
+  }
+  pop() {
+    if (this.isEmpty()) {
+      return null
+    }
+    const res = this.arr[1]
+    this.swap(1, this.last)
+    this.last--
+    this.down(1)
+    return res
+  }
+  up(lo) {
+    while (lo > 1) {
+      const currEl = this.arr[lo]
+      const parent = Math.floor(lo / 2)
+      const parentEl = this.arr[parent]
+      if (this.compare(currEl, parentEl)) {
+        this.swap(lo, parent)
+      } else {
+        break
+      }
+      lo = parent
+    }
+  }
+  down(hi) {
+    while (hi * 2 <= this.last) {
+      const currEl = this.arr[hi]
+      let nextEl = this.arr[hi * 2]
+      let nextIndex = hi * 2
+      if (
+        hi * 2 + 1 <= this.last &&
+        this.compare(this.arr[hi * 2 + 1], nextEl)
+      ) {
+        nextIndex = hi * 2 + 1
+        nextEl = this.arr[nextIndex]
+      }
+      if (this.compare(nextEl, currEl)) {
+        this.swap(hi, nextIndex)
+      } else {
+        break
+      }
+      hi = nextIndex
+    }
+  }
+  swap(i, j) {
+    const temp = this.arr[i]
+    this.arr[i] = this.arr[j]
+    this.arr[j] = temp
+  }
+  peek() {
+    if (this.isEmpty()) {
+      return null
+    }
+    return this.arr[1]
+  }
+  isEmpty() {
+    return this.last < 1
+  }
+}

From 8c4e879b71462ea6394e38329ea82ffc6e87e673 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sat, 6 Jun 2020 16:10:03 +0800
Subject: [PATCH 0622/3374] Update 1172-dinner-plate-stacks.js

---
 1172-dinner-plate-stacks.js | 70 +++++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)

diff --git a/1172-dinner-plate-stacks.js b/1172-dinner-plate-stacks.js
index 2e5c9ea2..72f8a9bd 100644
--- a/1172-dinner-plate-stacks.js
+++ b/1172-dinner-plate-stacks.js
@@ -142,3 +142,73 @@ class PriorityQueue {
     return this.last < 1
   }
 }
+
+// another
+
+/**
+ * @param {number} capacity
+ */
+const DinnerPlates = function (capacity) {
+  this.pushIndex = 0
+  this.popIndex = 0
+  this.capacity = capacity
+  this.stacks = [[]]
+}
+
+/**
+ * @param {number} val
+ * @return {void}
+ */
+DinnerPlates.prototype.push = function (val) {
+  while (
+    this.pushIndex < this.stacks.length &&
+    this.stacks[this.pushIndex].length === this.capacity
+  ) {
+    this.pushIndex++
+  }
+  if (this.stacks.length === this.pushIndex) {
+    this.stacks[this.pushIndex] = [val]
+  } else {
+    this.stacks[this.pushIndex].push(val)
+  }
+  if (this.popIndex < this.pushIndex) {
+    this.popIndex = this.pushIndex
+  }
+}
+
+/**
+ * @return {number}
+ */
+DinnerPlates.prototype.pop = function () {
+  while (this.stacks[this.popIndex].length === 0) {
+    if (this.popIndex > 0) {
+      this.popIndex--
+    } else {
+      return -1
+    }
+  }
+  const valueAtIndex = this.stacks[this.popIndex].pop()
+  if (this.pushIndex > this.popIndex) {
+    this.pushIndex = this.popIndex
+  }
+  return valueAtIndex
+}
+
+/**
+ * @param {number} index
+ * @return {number}
+ */
+DinnerPlates.prototype.popAtStack = function (index) {
+  if (index >= this.stacks.length) return -1
+  if (index < this.pushIndex) this.pushIndex = index
+  return this.stacks[index].length > 0 ? this.stacks[index].pop() : -1
+}
+
+/**
+ * Your DinnerPlates object will be instantiated and called as such:
+ * var obj = new DinnerPlates(capacity)
+ * obj.push(val)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.popAtStack(index)
+ */
+

From 724be3804c0fcef7cb826f73bbfe279f9063f930 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sat, 6 Jun 2020 16:26:54 +0800
Subject: [PATCH 0623/3374] Update 406-queue-reconstruction-by-height.js

---
 406-queue-reconstruction-by-height.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/406-queue-reconstruction-by-height.js b/406-queue-reconstruction-by-height.js
index 3cf2cad5..67f9eba1 100755
--- a/406-queue-reconstruction-by-height.js
+++ b/406-queue-reconstruction-by-height.js
@@ -1,3 +1,20 @@
+/**
+ * @param {number[][]} people
+ * @return {number[][]}
+ */
+const reconstructQueue = function (people) {
+  const h = 0
+  const k = 1
+  people.sort((a, b) => (a[h] == b[h] ? a[k] - b[k] : b[h] - a[h]))
+  let queue = []
+  for (let person of people) {
+    queue.splice(person[k], 0, person)
+  }
+  return queue
+}
+
+// another
+
 /**
  * @param {number[][]} people
  * @return {number[][]}

From 9a2f6f347e2b5d1aedf6da81ce187987aedd4db2 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sat, 6 Jun 2020 19:09:19 +0800
Subject: [PATCH 0624/3374] Create 1206-design-skiplist.js

---
 1206-design-skiplist.js | 82 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)
 create mode 100644 1206-design-skiplist.js

diff --git a/1206-design-skiplist.js b/1206-design-skiplist.js
new file mode 100644
index 00000000..fcdbaecb
--- /dev/null
+++ b/1206-design-skiplist.js
@@ -0,0 +1,82 @@
+const Skiplist = function () {
+  this.maxLvl = ~~Math.log2(20000)
+  this.levels = [...Array(this.maxLvl)].map(() => new Node(-1))
+  for (let i = this.maxLvl - 1; i > 0; i--) {
+    this.levels[i].down = this.levels[i - 1]
+  }
+  this.head = this.levels[this.maxLvl - 1]
+}
+
+/**
+ * @param {number} target
+ * @return {boolean}
+ */
+Skiplist.prototype.search = function (target) {
+  const pre = this.iter(target)
+  return !pre[0].next ? false : pre[0].next.val === target
+}
+
+Skiplist.prototype.iter = function (target) {
+  let cur = this.head
+  const pre = []
+  for (let i = this.maxLvl - 1; i >= 0; i--) {
+    while (cur.next && cur.next.val < target) cur = cur.next
+    pre[i] = cur
+    cur = cur.down
+  }
+  return pre
+}
+
+/**
+ * @param {number} num
+ * @return {void}
+ */
+Skiplist.prototype.add = function (num) {
+  const pre = this.iter(num)
+  const lvs = decideLevels(this.maxLvl)
+  for (let i = 0; i < lvs; i++) {
+    const next = pre[i].next
+    pre[i].next = new Node(num)
+    pre[i].next.next = next
+    if (i > 0) pre[i].next.down = pre[i - 1].next
+  }
+}
+
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+Skiplist.prototype.erase = function (num) {
+  const pre = this.iter(num)
+  let ret
+  if (!pre[0].next || pre[0].next.val !== num) return false
+  for (let i = this.maxLvl - 1; i >= 0; i--) {
+    if (pre[i].next && pre[i].next.val === num) {
+      const toBeDeleted = pre[i].next
+      pre[i].next = toBeDeleted.next
+      toBeDeleted.next = null
+      toBeDeleted.down = null
+    }
+  }
+  return true
+}
+
+/**
+ * Your Skiplist object will be instantiated and called as such:
+ * var obj = new Skiplist()
+ * var param_1 = obj.search(target)
+ * obj.add(num)
+ * var param_3 = obj.erase(num)
+ */
+
+const decideLevels = (max) => {
+  let ans = 1
+  while (Math.random() > 0.5 && ans < max) ans++
+  return ans
+}
+
+const Node = function (val) {
+  this.val = val
+  this.next = null
+  this.down = null
+}

From 902497570c3623cd773c491c11f2272ede22e360 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sat, 6 Jun 2020 20:03:41 +0800
Subject: [PATCH 0625/3374] Update 1206-design-skiplist.js

---
 1206-design-skiplist.js | 63 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/1206-design-skiplist.js b/1206-design-skiplist.js
index fcdbaecb..c559a289 100644
--- a/1206-design-skiplist.js
+++ b/1206-design-skiplist.js
@@ -1,3 +1,66 @@
+class Skiplist {
+  constructor() {
+    this.head = { down: null, right: null, val: -Infinity }
+  }
+  search(val) {
+    let curr = this.head
+    while (curr) {
+      while (curr.right && curr.right.val <= val) {
+        curr = curr.right
+      }
+      if (curr.val == val) {
+        return true
+      }
+      curr = curr.down
+    }
+    return false
+  }
+  add(val) {
+    let curr = this.head
+    const insertion_positions = []
+    while (curr) {
+      while (curr.right && curr.right.val < val) {
+        curr = curr.right
+      }
+      insertion_positions.push(curr)
+      curr = curr.down
+    }
+    let insert = true
+    let down = null
+    while (insert && insertion_positions.length) {
+      const position = insertion_positions.pop()
+      const node = { down, val, right: position.right }
+      position.right = node
+      down = node
+      insert = Math.random() < 0.5
+    }
+    if (insert) {
+      const node = { val, down }
+      this.head = { val: -Infinity, right: node, down: this.head }
+    }
+  }
+  erase(val) {
+    let curr = this.head
+    const erase_positions = []
+    while (curr) {
+      while (curr.right && curr.right.val < val) {
+        curr = curr.right
+      }
+      if (curr.right && curr.right.val == val) {
+        erase_positions.push(curr)
+      }
+      curr = curr.down
+    }
+    const seen = erase_positions.length > 0
+    for (const position of erase_positions) {
+      position.right = position.right && position.right.right
+    }
+    return seen
+  }
+}
+
+// another
+
 const Skiplist = function () {
   this.maxLvl = ~~Math.log2(20000)
   this.levels = [...Array(this.maxLvl)].map(() => new Node(-1))

From a8d53d7e19c9a392a074f0cc664d95f8b30175e4 Mon Sep 17 00:00:00 2001
From: Nothing <jihe@conviva.com>
Date: Sun, 7 Jun 2020 15:32:19 +0800
Subject: [PATCH 0626/3374] Update 518-coin-change-2.js

---
 518-coin-change-2.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/518-coin-change-2.js b/518-coin-change-2.js
index 51a5db3c..2003043c 100644
--- a/518-coin-change-2.js
+++ b/518-coin-change-2.js
@@ -15,3 +15,21 @@ function change(amount, coins) {
     }
     return dp[coins.length][amount];
 }
+
+// another
+
+/**
+ * @param {number} amount
+ * @param {number[]} coins
+ * @return {number}
+ */
+const change = function (amount, coins) {
+  const dp = Array(amount + 1).fill(0)
+  dp[0] = 1
+  for (let coin of coins) {
+    for (let i = coin; i < amount + 1; i++) {
+      dp[i] += dp[i - coin]
+    }
+  }
+  return dp[amount]
+}

From fa43c1a544ef9930eff60c78f90f1ad88b94a44f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jun 2020 17:10:41 +0800
Subject: [PATCH 0627/3374] Update 231-power-of-two.js

---
 231-power-of-two.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/231-power-of-two.js b/231-power-of-two.js
index 9b53cca2..21a93ae4 100644
--- a/231-power-of-two.js
+++ b/231-power-of-two.js
@@ -14,3 +14,13 @@ const isPowerOfTwo = function(n) {
     }
     return false
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isPowerOfTwo = function(n) {
+    return Math.log2(n)%1 === 0
+};

From cf72d3d13ae25af186af0c8ff383a50cded271f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jun 2020 17:16:32 +0800
Subject: [PATCH 0628/3374] Update 231-power-of-two.js

---
 231-power-of-two.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/231-power-of-two.js b/231-power-of-two.js
index 21a93ae4..397c73ba 100644
--- a/231-power-of-two.js
+++ b/231-power-of-two.js
@@ -24,3 +24,20 @@ const isPowerOfTwo = function(n) {
 const isPowerOfTwo = function(n) {
     return Math.log2(n)%1 === 0
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isPowerOfTwo = n => n < 1 ? false : Number.MAX_VALUE % n === 0
+
+// another
+
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isPowerOfTwo = x => x > 0 ? !(x & (x - 1)) : false;
+

From 733c010706546fbc49646dcdde6c18d3e698b087 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Jun 2020 16:38:23 +0800
Subject: [PATCH 0629/3374] Update 392-is-subsequence.js

---
 392-is-subsequence.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/392-is-subsequence.js b/392-is-subsequence.js
index 3b76989c..46fe3361 100644
--- a/392-is-subsequence.js
+++ b/392-is-subsequence.js
@@ -1,3 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+const isSubsequence = function(s, t) {
+  const sl = s.length
+  const tl = t.length
+  if(sl > tl) return false
+  if(sl === 0) return true
+  let si = 0
+  for(let i = 0; i < tl && si < sl; i++) {
+    if(s[si] === t[i]) si++
+  }
+  return si === sl
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string} t

From 18b4bb38689d650b93a24d9e74b3519f499c3492 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Jun 2020 11:18:24 +0800
Subject: [PATCH 0630/3374] Create 1246-palindrome-removal.js

---
 1246-palindrome-removal.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1246-palindrome-removal.js

diff --git a/1246-palindrome-removal.js b/1246-palindrome-removal.js
new file mode 100644
index 00000000..a7947edc
--- /dev/null
+++ b/1246-palindrome-removal.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minimumMoves = function (arr) {
+  const n = arr.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(n))
+  // handle edge situation: subarray size == 1
+  for (let i = 0; i < n; i++) {
+    dp[i][i] = 1
+  }
+  // handle edge situation: subarray size == 2
+  for (let i = 0; i < n - 1; i++) {
+    dp[i][i + 1] = arr[i] === arr[i + 1] ? 1 : 2
+  }
+  // for subarray size >= 3:
+  for (let size = 3; size <= n; size++) {
+    for (let left = 0, right = left + size - 1; right < n; left++, right++) {
+      // if arr[left] == arr[right], then the two number: arr[left] and arr[right] can be
+      // removed when the last move of subarray arr[left + 1:right - 1]
+      if (arr[left] === arr[right]) {
+        dp[left][right] = dp[left + 1][right - 1]
+      }
+      // or, if we cannot remove arr[left] and arr[right] in one move (the last move),
+      // the subarray arr[left:right] must can be split into two subarrays
+      // and remove them one by one.
+      for (let mid = left; mid < right; mid++) {
+        dp[left][right] = Math.min(
+          dp[left][right],
+          dp[left][mid] + dp[mid + 1][right]
+        )
+      }
+    }
+  }
+  return dp[0][n - 1]
+}

From a0638eac534a5da17bf24f7ed861537d4d8b456c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Jun 2020 20:45:46 +0800
Subject: [PATCH 0631/3374] Update 35-search-insert-position.js

---
 35-search-insert-position.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/35-search-insert-position.js b/35-search-insert-position.js
index f066c3ae..7bd01758 100755
--- a/35-search-insert-position.js
+++ b/35-search-insert-position.js
@@ -14,3 +14,22 @@ const searchInsert = function(nums, target) {
     }
   }
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const searchInsert = function(nums, target) {
+  const n = nums.length
+  let l = 0, r = n - 1
+  while(l <= r) {
+    const mid = l + ((r - l) >> 1)
+    if(nums[mid] === target) return mid
+    if(nums[mid] > target) r = mid - 1
+    else l = mid + 1
+  }
+  return l
+};

From eb71d22ff19d876e2a63d87cf919e93b35d737de Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Jun 2020 09:52:28 +0800
Subject: [PATCH 0632/3374] Create 1136-parallel-courses.js

---
 1136-parallel-courses.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1136-parallel-courses.js

diff --git a/1136-parallel-courses.js b/1136-parallel-courses.js
new file mode 100644
index 00000000..4b6b6db5
--- /dev/null
+++ b/1136-parallel-courses.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} N
+ * @param {number[][]} relations
+ * @return {number}
+ */
+const minimumSemesters = function (N, relations) {
+  const g = new Map() // key: prerequisite, value: course list.
+  const inDegree = new Array(N + 1).fill(0) // inDegree[i]: number of prerequisites for i.
+  for (let r of relations) {
+    if (!g.has(r[0])) g.set(r[0], [])
+    g.get(r[0]).push(r[1]) // construct graph.
+    ++inDegree[r[1]] // count prerequisites for r[1].
+  }
+  const q = [] // save current 0 in-degree vertices.
+  for (let i = 1; i <= N; ++i) if (inDegree[i] === 0) q.push(i)
+  let semester = 0
+  while (q.length) {
+    // BFS traverse all currently 0 in degree vertices.
+    for (let sz = q.length; sz > 0; --sz) {
+      // sz is the search breadth.
+      const c = q.shift()
+      --N
+      // c's in-degree is currently 0, but it is not a prerequisite of anyone else.
+      if (!g.has(c)) continue
+      const tmp = g.get(c)
+      g.delete(c)
+      for (let course of tmp)
+        if (--inDegree[course] === 0)
+          // decrease the in-degree of course's neighbors.
+          q.push(course) // add current 0 in-degree vertex into Queue.
+    }
+    ++semester // need one more semester.
+  }
+  return N === 0 ? semester : -1
+}

From ea348e53882f10a84c456dccc96b7d0c9faed964 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Jun 2020 16:02:42 +0800
Subject: [PATCH 0633/3374] Update 75-sort-colors.js

---
 75-sort-colors.js | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/75-sort-colors.js b/75-sort-colors.js
index b7252716..0aaa56b4 100644
--- a/75-sort-colors.js
+++ b/75-sort-colors.js
@@ -2,23 +2,19 @@
  * @param {number[]} nums
  * @return {void} Do not return anything, modify nums in-place instead.
  */
-
 const sortColors = function(nums) {
-    let i = 0
-    let j = 0
-    for(let k = 0; k < nums.length; k++) {
-        let v = nums[k]
-        nums[k] = 2
-        if(v < 2) {
-           nums[j] = 1
-           j += 1
-        }
-        
-        if(v === 0) {
-           nums[i] = 0
-           i += 1
-        }
+  let j = 0;
+  let k = nums.length - 1;
+  const swap = (a, b) => {
+    const t = nums[a];
+    nums[a] = nums[b];
+    nums[b] = t;
+  };
+  for (let i = 0; i <= k; i++) {
+    if (nums[i] === 2) {
+      swap(i--, k--);
+    } else if (nums[i] === 0) {
+      swap(i, j++);
     }
-    
-    return nums;
+  }
 };

From 181767e40b805086e49da4ccad7489a05dba690b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Jun 2020 10:22:33 +0800
Subject: [PATCH 0634/3374] Create 1231-divide-chocolate.js

---
 1231-divide-chocolate.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1231-divide-chocolate.js

diff --git a/1231-divide-chocolate.js b/1231-divide-chocolate.js
new file mode 100644
index 00000000..3170ce2c
--- /dev/null
+++ b/1231-divide-chocolate.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} sweetness
+ * @param {number} K
+ * @return {number}
+ */
+const maximizeSweetness = function (sweetness, K) {
+  let left = 1,
+    right = 1e9 / (K + 1)
+  while (left < right) {
+    let mid = (left + right + 1) >> 1
+    let cur = 0,
+      cuts = 0
+    for (let a of sweetness) {
+      if ((cur += a) >= mid) {
+        cur = 0
+        if (++cuts > K) break
+      }
+    }
+    if (cuts > K) left = mid
+    else right = mid - 1
+  }
+  return left
+}

From 4dc4b5cc27b1449be73d290f3b55ad5b50d92f7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Jun 2020 16:29:55 +0800
Subject: [PATCH 0635/3374] Update 380-insert-delete-getrandom-o1.js

---
 380-insert-delete-getrandom-o1.js | 58 ++++++++++++++++---------------
 1 file changed, 30 insertions(+), 28 deletions(-)

diff --git a/380-insert-delete-getrandom-o1.js b/380-insert-delete-getrandom-o1.js
index 3e663629..7358dbea 100644
--- a/380-insert-delete-getrandom-o1.js
+++ b/380-insert-delete-getrandom-o1.js
@@ -1,51 +1,53 @@
 /**
  * Initialize your data structure here.
  */
-const RandomizedSet = function() {
-    this.data = []
-};
+const RandomizedSet = function () {
+  this.map = new Map()
+  this.array = []
+}
 
 /**
- * Inserts a value to the set. Returns true if the set did not already contain the specified element. 
+ * Inserts a value to the set. Returns true if the set did not already contain the specified element.
  * @param {number} val
  * @return {boolean}
  */
-RandomizedSet.prototype.insert = function(val) {
-    if(this.data.indexOf(val) === -1) {
-        this.data.push(val)
-        return true
-    }
-    return false
-};
+RandomizedSet.prototype.insert = function (val) {
+  const { array, map } = this
+  if (map.has(val)) return false
+  array.push(val)
+  map.set(val, array.length - 1)
+  return true
+}
 
 /**
- * Removes a value from the set. Returns true if the set contained the specified element. 
+ * Removes a value from the set. Returns true if the set contained the specified element.
  * @param {number} val
  * @return {boolean}
  */
-RandomizedSet.prototype.remove = function(val) {
-    let idx = this.data.indexOf(val)
-    if(idx !== -1) {
-        this.data.splice(idx, 1)
-        return true
-    }
-    return false
-    
-};
+RandomizedSet.prototype.remove = function (val) {
+  const { array, map } = this
+  if (!map.has(val)) return false
+  const [last, index] = [array[array.length - 1], map.get(val)]
+  array[index] = last
+  map.set(last, index)
+  array.pop()
+  map.delete(val)
+  return true
+}
 
 /**
  * Get a random element from the set.
  * @return {number}
  */
-RandomizedSet.prototype.getRandom = function() {
-    const len = this.data.length
-    const idx = Math.floor(Math.random() * len)
-    return this.data[idx]
-};
+RandomizedSet.prototype.getRandom = function () {
+  const { array } = this
+  const r = Math.floor(array.length * Math.random())
+  return array[r]
+}
 
-/** 
+/**
  * Your RandomizedSet object will be instantiated and called as such:
- * var obj = Object.create(RandomizedSet).createNew()
+ * var obj = new RandomizedSet()
  * var param_1 = obj.insert(val)
  * var param_2 = obj.remove(val)
  * var param_3 = obj.getRandom()

From 36637884c821cbaf87d0f6a253a41917e4561a4f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Jun 2020 22:28:52 +0800
Subject: [PATCH 0636/3374] Create 1220-count-vowels-permutation.js

---
 1220-count-vowels-permutation.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1220-count-vowels-permutation.js

diff --git a/1220-count-vowels-permutation.js b/1220-count-vowels-permutation.js
new file mode 100644
index 00000000..101580d6
--- /dev/null
+++ b/1220-count-vowels-permutation.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countVowelPermutation = function (n) {
+  const mod = 1e9 + 7
+  const arr = [
+    [0, 1, 1], // a -> e
+    [0, 1, 2], // e -> a, i
+    [0, 1, 4], // i -> a, e, o, u
+    [0, 1, 2], // o -> i, u
+    [0, 1, 1], // u -> a
+  ]
+  for (let i = 3; i <= n; i++) {
+    arr[0][i % 3] = arr[1][(i - 1) % 3] % mod
+    arr[1][i % 3] = (arr[0][(i - 1) % 3] + arr[2][(i - 1) % 3]) % mod
+    arr[2][i % 3] =
+      (arr[0][(i - 1) % 3] +
+        arr[1][(i - 1) % 3] +
+        arr[3][(i - 1) % 3] +
+        arr[4][(i - 1) % 3]) %
+      mod
+    arr[3][i % 3] = (arr[2][(i - 1) % 3] + arr[4][(i - 1) % 3]) % mod
+    arr[4][i % 3] = arr[0][(i - 1) % 3] % mod
+  }
+  return arr.reduce((sum, subArr) => sum + subArr[n % 3], 0) % mod
+}

From 170e074513beec2242b105a140047015b5794eba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jun 2020 15:41:10 +0800
Subject: [PATCH 0637/3374] Update 700-search-in-a-binary-search-tree.js

---
 700-search-in-a-binary-search-tree.js | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/700-search-in-a-binary-search-tree.js b/700-search-in-a-binary-search-tree.js
index f7a9d42f..7b4b24df 100755
--- a/700-search-in-a-binary-search-tree.js
+++ b/700-search-in-a-binary-search-tree.js
@@ -1,8 +1,9 @@
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
  * }
  */
 /**
@@ -10,14 +11,9 @@
  * @param {number} val
  * @return {TreeNode}
  */
-const searchBST = function(root, val) {
-  if (root === null) return [];
-
-  if (root.val === val) {
-    return root;
-  } else if (root.val < val) {
-    return searchBST(root.right, val);
-  } else {
-    return searchBST(root.left, val);
+const searchBST = function (root, val) {
+  if (!root || root.val === val) {
+    return root
   }
-};
+  return root.val < val ? searchBST(root.right, val) : searchBST(root.left, val)
+}

From b0321a30b5390ceb348990560a4368c8f0dc2fa7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jun 2020 19:59:13 +0800
Subject: [PATCH 0638/3374] Update 70-climbing-stairs.js

---
 70-climbing-stairs.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/70-climbing-stairs.js b/70-climbing-stairs.js
index 71cb4942..a52c4c63 100755
--- a/70-climbing-stairs.js
+++ b/70-climbing-stairs.js
@@ -22,3 +22,26 @@ function single(i, hash) {
   hash[i] = single(i - 1, hash) + single(i - 2, hash);
   return hash[i];
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const climbStairs = function (n) {
+  const dp = new Array(n + 1).fill(0)
+  if (n === 1) {
+    return 1
+  }
+  if (n === 2) {
+    return 2
+  }
+  dp[0] = 0
+  dp[1] = 1
+  dp[2] = 2
+  for (let i = 3; i <= n; i++) {
+    dp[i] = dp[i - 1] + dp[i - 2]
+  }
+  return dp[n]
+}

From 502f8e78166b88d8cae96ecc49a8cb14a302242e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jun 2020 20:37:18 +0800
Subject: [PATCH 0639/3374] Update 121-best-time-to-buy-and-sell-stock.js

---
 121-best-time-to-buy-and-sell-stock.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/121-best-time-to-buy-and-sell-stock.js b/121-best-time-to-buy-and-sell-stock.js
index 1435def8..fd613dcd 100755
--- a/121-best-time-to-buy-and-sell-stock.js
+++ b/121-best-time-to-buy-and-sell-stock.js
@@ -14,3 +14,19 @@ const maxProfit = function(prices) {
   }
   return maxP;
 };
+
+// another
+
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+const maxProfit = function (prices) {
+  let maxCur = 0,
+    maxSoFar = 0
+  for (let i = 1; i < prices.length; i++) {
+    maxCur = Math.max(0, (maxCur += prices[i] - prices[i - 1]))
+    maxSoFar = Math.max(maxCur, maxSoFar)
+  }
+  return maxSoFar
+}

From 06b57f5d4b7403347d98049432a353e91d076deb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jun 2020 21:56:38 +0800
Subject: [PATCH 0640/3374] Create 1402-reducing-dishes.js

---
 1402-reducing-dishes.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1402-reducing-dishes.js

diff --git a/1402-reducing-dishes.js b/1402-reducing-dishes.js
new file mode 100644
index 00000000..c2bda744
--- /dev/null
+++ b/1402-reducing-dishes.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} satisfaction
+ * @return {number}
+ */
+const maxSatisfaction = function (satisfaction, max = 0) {
+  satisfaction.sort((a, b) => b - a)
+  for (let j = 1; j <= satisfaction.length; ++j) {
+    let next = 0
+    for (let i = 0, k = j; i < j; ++i, --k) next += satisfaction[i] * k
+    max = Math.max(max, next)
+  }
+  return max
+}

From 279da08561aa2bb4d5bd76ff0beb6e9044005968 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jun 2020 22:33:13 +0800
Subject: [PATCH 0641/3374] Update 1402-reducing-dishes.js

---
 1402-reducing-dishes.js | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/1402-reducing-dishes.js b/1402-reducing-dishes.js
index c2bda744..db79fb18 100644
--- a/1402-reducing-dishes.js
+++ b/1402-reducing-dishes.js
@@ -3,11 +3,15 @@
  * @return {number}
  */
 const maxSatisfaction = function (satisfaction, max = 0) {
-  satisfaction.sort((a, b) => b - a)
-  for (let j = 1; j <= satisfaction.length; ++j) {
-    let next = 0
-    for (let i = 0, k = j; i < j; ++i, --k) next += satisfaction[i] * k
-    max = Math.max(max, next)
+  satisfaction.sort((a, b) => a - b)
+  let res = 0
+  let total = 0
+  let len = satisfaction.length
+  // "We'll keep doing this as long as satisfaction[i] + total > 0" === satisfaction[i] > -total
+  // It is because the current running sum needs to be greater than 0 otherwise, it would decrease res.
+  for (let i = len - 1; i >= 0 && satisfaction[i] > -total; i--) {
+    total += satisfaction[i]
+    res += total
   }
-  return max
+  return res
 }

From 8f3297079a0739684346496bc68fa83f67c6b618 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Jun 2020 15:50:21 +0800
Subject: [PATCH 0642/3374] Create
 1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js

---
 ...to-convert-binary-matrix-to-zero-matrix.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js

diff --git a/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
new file mode 100644
index 00000000..28574517
--- /dev/null
+++ b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
@@ -0,0 +1,61 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const minFlips = function (mat) {
+  const X = mat.length
+  const Y = mat[0].length
+  const binary = {
+    0: 1,
+    1: 2,
+    2: 4,
+    3: 8,
+    4: 16,
+    5: 32,
+    6: 64,
+    7: 128,
+    8: 256,
+  }
+  const mask = []
+  let state = 0
+  for (let i = 0; i < X; ++i) {
+    for (let j = 0; j < Y; ++j) {
+      let bit = 0
+      state += mat[i][j] * binary[Y * i + j]
+      bit += binary[Y * i + j]
+      if (i > 0) {
+        bit += binary[Y * (i - 1) + j]
+      }
+      if (i < X - 1) {
+        bit += binary[Y * (i + 1) + j]
+      }
+      if (j > 0) {
+        bit += binary[Y * i + (j - 1)]
+      }
+      if (j < Y - 1) {
+        bit += binary[Y * i + (j + 1)]
+      }
+      mask.push(bit)
+    }
+  }
+  if (state === 0) {
+    return 0
+  }
+  const set = new Set()
+  const q = [{ state: state, moves: 0 }]
+  while (q.length !== 0) {
+    const cur = q.shift()
+    if (cur.state === 0) {
+      return cur.moves
+    }
+    for (let i = 0; i < X * Y; ++i) {
+      let newState = cur.state
+      newState ^= mask[i]
+      if (!set.has(newState)) {
+        set.add(newState)
+        q.push({ state: newState, moves: cur.moves + 1 })
+      }
+    }
+  }
+  return -1
+}

From 9cbc46fc0b3b7ba3644575c148b66b36c31bbe7f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Jun 2020 21:38:10 +0800
Subject: [PATCH 0643/3374] Update 468-validate-ip-address.js

---
 468-validate-ip-address.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/468-validate-ip-address.js b/468-validate-ip-address.js
index 66233a9b..d421c6c6 100644
--- a/468-validate-ip-address.js
+++ b/468-validate-ip-address.js
@@ -1,3 +1,37 @@
+/**
+ * @param {string} IP
+ * @return {string}
+ */
+const validIPAddress = function (IP) {
+  if (IP.indexOf('.') > 0) return validIPv4(IP) ? 'IPv4' : 'Neither'
+  else return validIPv6(IP) ? 'IPv6' : 'Neither'
+}
+
+const validIPv4 = function (IP) {
+  const strs = IP.split('.')
+  if (strs.length !== 4) return false
+  for (let str of strs) {
+    if (str.length === 0) return false
+    if (str.match(/[^0-9]/)) return false
+    if (str.length > 1 && str.charAt(0) === '0') return false
+    if (+str > 255) return false
+  }
+  return true
+}
+
+const validIPv6 = function (IP) {
+  const strs = IP.split(':')
+  if (strs.length !== 8) return false
+  for (let str of strs) {
+    if (str.length === 0) return false
+    if (str.length > 4) return false
+    if (str.match(/[^0-9a-fA-F]/g)) return false
+  }
+  return true
+}
+
+// another
+
 /**
  * @param {string} IP
  * @return {string}

From ed85cf8ad7ee9b1ba6eaa75545de59240d5161e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Jun 2020 08:27:23 +0800
Subject: [PATCH 0644/3374] Create 843-guess-the-word.js

---
 843-guess-the-word.js | 63 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 843-guess-the-word.js

diff --git a/843-guess-the-word.js b/843-guess-the-word.js
new file mode 100644
index 00000000..be49eabf
--- /dev/null
+++ b/843-guess-the-word.js
@@ -0,0 +1,63 @@
+/**
+ * // This is the master's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * function Master() {
+ *
+ *     @param {string[]} wordlist
+ *     @param {Master} master
+ *     @return {integer}
+ *     this.guess = function(word) {
+ *         ...
+ *     };
+ * };
+ */
+/**
+ * @param {string[]} wordlist
+ * @param {Master} master
+ * @return {void}
+ */
+const findSecretWord = function (wordlist, master) {
+  let group = wordlist
+  for (let i = 0; i < 10; i++) {
+    let currentGuess = findTheTypical(group)
+    let res = master.guess(currentGuess)
+    if (res === 6) return
+    let tmp = []
+    for (let j = 0; j < group.length; j++) {
+      if (diff(group[j], currentGuess) === 6 - res) tmp.push(group[j])
+    }
+    group = tmp
+  }
+}
+function findTheTypical(wordlist) {
+  const count = Array.from({ length: 6 }, (x) => new Object())
+  for (let i = 0; i < wordlist.length; i++) {
+    for (let j = 0; j < 6; j++) {
+      const cur = wordlist[i][j]
+      if (count[j][cur] === undefined) count[j][cur] = 1
+      else count[j][cur]++
+    }
+  }
+  let maxPos = 0,
+    maxCount = 0,
+    maxAlp = ''
+  for (let i = 0; i < 6; i++) {
+    for (let k of Object.keys(count[i])) {
+      if (count[i][k] > maxCount) {
+        maxCount = count[i][k]
+        maxPos = i
+        maxAlp = k
+      }
+    }
+  }
+  for (let i = 0; i < wordlist.length; i++) {
+    if (wordlist[i][maxPos] === maxAlp) return wordlist[i]
+  }
+}
+function diff(a, b) {
+  let count = 0
+  for (let i = 0; i < a.length; i++) {
+    if (a[i] !== b[i]) count++
+  }
+  return count
+}

From 27964bc1b6ab23e2c8548558787616d021f4c260 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Jun 2020 17:09:50 +0800
Subject: [PATCH 0645/3374] Update 130-surrounded-regions.js

---
 130-surrounded-regions.js | 61 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/130-surrounded-regions.js b/130-surrounded-regions.js
index b7295d39..619240b1 100644
--- a/130-surrounded-regions.js
+++ b/130-surrounded-regions.js
@@ -31,3 +31,64 @@ function search(board, i, j) {
   search(board, i, j + 1);
   search(board, i, j - 1);
 }
+
+// another
+
+/**
+ * @param {character[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+const solve = (board) => {
+  if (!board || board.length === 0 || board[0].length === 0) return;
+  const n = board.length;
+  const m = board[0].length;
+    const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ];
+  const bfs = (board, n, m, i, j) => {
+    const queue = [];
+    queue.push([i, j]);
+    board[i][j] = "1";
+    while (queue.length > 0) {
+      const pos = queue.shift();
+      for (let k = 0; k < 4; k++) {
+        i = pos[0] + dirs[k][0];
+        j = pos[1] + dirs[k][1];
+        if (i >= 0 && i < n && j >= 0 && j < m && board[i][j] === "O") {
+          board[i][j] = "1";
+          queue.push([i, j]);
+        }
+      }
+    }
+  };
+  // scan the borders and mark the 'O's to '1'
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (
+        (i === 0 || i === n - 1 || j === 0 || j === m - 1) &&
+        board[i][j] === "O"
+      ) {
+        bfs(board, n, m, i, j);
+      }
+    }
+  }
+  // scan the inner area and mark the 'O's to 'X'
+  for (let i = 1; i < n; i++) {
+    for (let j = 1; j < m; j++) {
+      if (board[i][j] === "O") {
+        board[i][j] = "X";
+      }
+    }
+  }
+  // reset all the '1's to 'O's
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (board[i][j] === "1") {
+        board[i][j] = "O";
+      }
+    }
+  }
+};

From 1dc6e8ba49a7ad422f34a45b6236de209e524916 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Jun 2020 19:52:51 +0800
Subject: [PATCH 0646/3374] Create 772-basic-calculator-iii.js

---
 772-basic-calculator-iii.js | 62 +++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 772-basic-calculator-iii.js

diff --git a/772-basic-calculator-iii.js b/772-basic-calculator-iii.js
new file mode 100644
index 00000000..fe5bbf19
--- /dev/null
+++ b/772-basic-calculator-iii.js
@@ -0,0 +1,62 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function (
+  s,
+  start = 0,
+  end = s.length,
+  parentheses = findParentheses(s)
+) {
+  const stack = []
+  let op = '+'
+  let num = 0
+  for (let i = start; i < end; i++) {
+    const c = s[i]
+    if (/[0-9]+/.test(c)) {
+      const n = parseInt(c)
+      num = 10 * num + n
+    } else if (isOperator(c)) {
+      compute(op, stack, num)
+      op = c
+      num = 0
+    } else if (c === '(') {
+      num = calculate(s, i + 1, parentheses[i], parentheses)
+      i = parentheses[i]
+    }
+  }
+  compute(op, stack, num)
+  return stack.reduce((acc, cur) => acc + cur, 0)
+}
+
+function findParentheses(s) {
+  const map = {}
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '(') {
+      stack.push(i)
+    } else if (s[i] === ')') {
+      map[stack.pop()] = i
+    }
+  }
+  return map
+}
+
+function compute(op, stack, num) {
+  if (op === '-') {
+    stack.push(-num)
+  } else if (op === '+') {
+    stack.push(num)
+  } else if (op === '*') {
+    stack.push(stack.pop() * num)
+  } else if (op === '/') {
+    const pre = stack.pop()
+    const sign = pre / num >= 0 ? 1 : -1
+    const val = Math.floor(Math.abs(pre / num))
+    stack.push(Math.floor(sign * val))
+  }
+}
+
+function isOperator(c) {
+  return c === '+' || c === '-' || c === '*' || c === '/'
+}

From 7f2e73ea979b566ad0a06eee2c181f6c89dd702a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Jun 2020 16:33:07 +0800
Subject: [PATCH 0647/3374] Update 275-h-index-ii.js

---
 275-h-index-ii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/275-h-index-ii.js b/275-h-index-ii.js
index d747ad69..254aa6db 100644
--- a/275-h-index-ii.js
+++ b/275-h-index-ii.js
@@ -22,7 +22,7 @@ const hIndex = function(citations) {
  * @return {number}
  */
 const hIndex = function(citations) {
-  let len = citations.length
+  const len = citations.length
   let lo = 0,
     hi = len - 1
   while (lo <= hi) {

From 56209213347b351b0be74a4a4caeb26054511a6b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Jun 2020 17:08:34 +0800
Subject: [PATCH 0648/3374] Create 1088-confusing-number-ii.js

---
 1088-confusing-number-ii.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1088-confusing-number-ii.js

diff --git a/1088-confusing-number-ii.js b/1088-confusing-number-ii.js
new file mode 100644
index 00000000..756294f2
--- /dev/null
+++ b/1088-confusing-number-ii.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const confusingNumberII = function (N) {
+  const valid = [
+    [0, 0],
+    [1, 1],
+    [6, 9],
+    [8, 8],
+    [9, 6],
+  ]
+  function dfs(num, rotated, order) {
+    let count = 0
+    if (num !== rotated) count++
+    for (const [dig, rot] of valid) {
+      if (num === 0 && dig === 0) continue
+      if (num * 10 + dig > N) break
+      count += dfs(num * 10 + dig, rot * order + rotated, order * 10)
+    }
+    return count
+  }
+  return dfs(0, 0, 1)
+}

From 04e05e822e4e95d2a09f4d0f0a2ecc65320b0c18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Jun 2020 12:07:22 +0800
Subject: [PATCH 0649/3374] Create 770-basic-calculator-iv.js

---
 770-basic-calculator-iv.js | 146 +++++++++++++++++++++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 770-basic-calculator-iv.js

diff --git a/770-basic-calculator-iv.js b/770-basic-calculator-iv.js
new file mode 100644
index 00000000..ce2a77d9
--- /dev/null
+++ b/770-basic-calculator-iv.js
@@ -0,0 +1,146 @@
+/**
+ * @param {string} expression
+ * @param {string[]} evalvars
+ * @param {number[]} evalints
+ * @return {string[]}
+ */
+const basicCalculatorIV = function (expression, evalvars, evalints) {
+  // Tokenise and get list of unresolved variable names
+  let [variables, it] = (function () {
+    let variables = []
+    let evalMap = new Map(evalvars.map((name, i) => [name, evalints[i]]))
+    let tokens = expression.match(/\w+|\d+|\S/g)
+    // Resolve occurrences of eval vars
+    for (let i = 0; i < tokens.length; i++) {
+      let token = tokens[i]
+      if (token[0] >= 'A') {
+        let num = evalMap.get(token)
+        if (num !== undefined) {
+          tokens[i] = num
+        } else {
+          variables.push(tokens[i])
+        }
+      }
+    }
+    return [[...new Set(variables)].sort(), tokens.values()] // array & iterator
+  })()
+  // Map each unknown variable to a sequential ID:
+  let variableMap = new Map(variables.map((name, i) => [name, i]))
+
+  // Parse tokens into Polynomial instance, and get output in required format
+  return (function parse(sign = 1) {
+    function parseTerm(sign = 1) {
+      let token = it.next().value
+      if (token === '(') return parse(sign)
+      let term = new Term(sign)
+      if (typeof token === 'string' && token >= 'A') {
+        term.setVar(variableMap.get(token))
+      } else {
+        term.setCoefficient(+token)
+      }
+      return new Polynomial([term])
+    }
+
+    let polynomial = new Polynomial()
+    let term = parseTerm(sign)
+    for (let token; (token = it.next().value) && token !== ')'; ) {
+      if (token === '*') {
+        term.mul(parseTerm(1))
+      } else {
+        polynomial.add(term)
+        term = parseTerm(token === '+' ? sign : -sign)
+      }
+    }
+    return polynomial.add(term)
+  })().output(variables)
+}
+class Term {
+  constructor(coefficient, variables = [], degree = 0) {
+    this.variables = variables
+    this.coefficient = coefficient
+    this.degree = degree
+  }
+  setVar(id) {
+    while (this.variables.length <= id) this.variables.push(0)
+    this.variables[id]++
+    this.degree++
+  }
+  setCoefficient(coefficient) {
+    this.coefficient *= coefficient
+  }
+  clone() {
+    return new Term(this.coefficient, [...this.variables], this.degree)
+  }
+  mul(term) {
+    let n = term.variables.length
+    while (this.variables.length < n) this.variables.push(0)
+    for (let i = 0; i < n; i++) {
+      this.variables[i] += term.variables[i]
+    }
+    this.degree += term.degree
+    this.coefficient *= term.coefficient
+    return this
+  }
+  cmp(term) {
+    let diff = term.degree - this.degree
+    if (diff) return Math.sign(diff)
+    for (let i = 0; i < this.variables.length; i++) {
+      diff = term.variables[i] - this.variables[i]
+      if (diff) return Math.sign(diff)
+    }
+    return 0
+  }
+  format(variableNames) {
+    return !this.coefficient
+      ? ''
+      : this.coefficient +
+          this.variables.map((count, i) =>
+            ('*' + variableNames[i]).repeat(count)
+          ).join``
+  }
+}
+
+class Polynomial {
+  constructor(terms = []) {
+    this.terms = terms
+  }
+  addTerm(term) {
+    let terms = this.terms
+    // binary search
+    let low = 0
+    let high = terms.length
+    while (low < high) {
+      let mid = (low + high) >> 1
+      let diff = terms[mid].cmp(term)
+      if (diff === 0) {
+        terms[mid].coefficient += term.coefficient
+        return this
+      } else if (diff < 0) {
+        low = mid + 1
+      } else {
+        high = mid
+      }
+    }
+    terms.splice(low, 0, term)
+    return this
+  }
+  add(polynomial) {
+    for (let term of polynomial.terms) {
+      this.addTerm(term)
+    }
+    return this
+  }
+  mul(polynomial) {
+    let orig = new Polynomial(this.terms)
+    this.terms = [] // clear
+    for (let term1 of polynomial.terms) {
+      for (let term2 of orig.terms) {
+        this.addTerm(term1.clone().mul(term2))
+      }
+    }
+    return this
+  }
+  output(variableNames) {
+    return this.terms.map((term) => term.format(variableNames)).filter(Boolean)
+  }
+}

From d570700888e6e260c7e693b37d37e6b8e98eb1f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Jun 2020 12:43:26 +0800
Subject: [PATCH 0650/3374] Create 1274-number-of-ships-in-a-rectangle.js

---
 1274-number-of-ships-in-a-rectangle.js | 46 ++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1274-number-of-ships-in-a-rectangle.js

diff --git a/1274-number-of-ships-in-a-rectangle.js b/1274-number-of-ships-in-a-rectangle.js
new file mode 100644
index 00000000..f12181f3
--- /dev/null
+++ b/1274-number-of-ships-in-a-rectangle.js
@@ -0,0 +1,46 @@
+/**
+ * // This is Sea's API interface.
+ * // You should not implement it, or speculate about its implementation
+ * function Sea() {
+ *     @param {integer[]} topRight
+ *     @param {integer[]} bottomLeft
+ *     @return {boolean}
+ *     this.hasShips = function(topRight, bottomLeft) {
+ *         ...
+ *     };
+ * };
+ */
+
+/**
+ * @param {Sea} sea
+ * @param {integer[]} topRight
+ * @param {integer[]} bottomLeft
+ * @return {integer}
+ */
+const countShips = function (sea, topRight, bottomLeft) {
+  let numShips = 0
+  const stack = [[topRight, bottomLeft]]
+  while (stack.length > 0) {
+    const [tR, bL] = stack.pop()
+    if (!sea.hasShips(tR, bL)) continue
+    const [right, top] = tR
+    const [left, bottom] = bL
+    if (right === left && bottom === top) {
+      numShips++
+      continue
+    }
+    const xCoord = Math.floor((right + left) / 2)
+    const yCoord = Math.floor((top + bottom) / 2)
+    stack.push([tR, [xCoord + 1, yCoord + 1]]) // top right
+    stack.push([
+      [xCoord, top],
+      [left, yCoord + 1],
+    ]) // top left
+    stack.push([[xCoord, yCoord], bL]) // bottom left
+    stack.push([
+      [right, yCoord],
+      [xCoord + 1, bottom],
+    ]) // bottom right
+  }
+  return numShips
+}

From f746b5ba964977d217339099b602cff0d338102b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Jun 2020 21:29:46 +0800
Subject: [PATCH 0651/3374] Update 1044-longest-duplicate-substring.js

---
 1044-longest-duplicate-substring.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/1044-longest-duplicate-substring.js b/1044-longest-duplicate-substring.js
index e1bf941a..48291448 100644
--- a/1044-longest-duplicate-substring.js
+++ b/1044-longest-duplicate-substring.js
@@ -3,14 +3,14 @@
  * @return {string}
  */
 const longestDupSubstring = function(S) {
-  let R = 26,
+  const R = 26,
     MOD = 1e9 + 7
   let lo = 0,
     hi = S.length - 1,
     res = ''
   while (lo < hi) {
-    let len = Math.ceil((lo + hi) / 2)
-    let sub = rabinKarp(S, len)
+    const len = Math.ceil((lo + hi) / 2)
+    const sub = rabinKarp(S, len)
     if (sub !== '') {
       lo = len
       res = sub
@@ -28,23 +28,23 @@ const longestDupSubstring = function(S) {
     for (let i = 1; i < len; i++) {
       RM = (RM * R) % MOD
     }
-    let map = new Map()
+    const map = new Map()
     let num = 0
     // 计算前len个字符串的散列值
     for (let i = 0; i < len; i++) {
-      let code = str.charCodeAt(i) - aCode
+      const code = str.charCodeAt(i) - aCode
       num = (num * R + code) % MOD
     }
     map.set(num, 0)
     // 后续计算散列值
     for (let i = 0; i < str.length - len; i++) {
-      let preCode = str.charCodeAt(i) - aCode,
+      const preCode = str.charCodeAt(i) - aCode,
         curCode = str.charCodeAt(i + len) - aCode
       num = (num + MOD - ((preCode * RM) % MOD)) % MOD
       num = (num * R + curCode) % MOD
       if (map.has(num)) {
-        let sub = str.substring(i + 1, i + 1 + len)
-        let preId = map.get(num),
+        const sub = str.substring(i + 1, i + 1 + len)
+        const preId = map.get(num),
           preSub = str.substring(preId, preId + len)
         if (sub === preSub) return sub
       }

From 2c053475c5fca9d6a4df2b5711ac01d646db8115 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Jun 2020 16:48:20 +0800
Subject: [PATCH 0652/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index 979dfdc9..5cd3a8fe 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -3,19 +3,19 @@
  * @param {number} k
  * @return {string}
  */
-const getPermutation = function(n, k) {
-    let sb = ''
-    const num = []
-    let fact = 1
-    for (let i = 1; i <= n; i++) {
-      fact *= i
-      num.push(i)
-    }
-    for(let i = 0, l = k - 1; i < n; i++ ) {
-      fact = Math.floor( fact / (n - i) )
-      let index = Math.floor( l / fact )
-      sb += num.splice(index, 1)[0]
-      l -= index * fact
-    }
-    return sb
-};
+const getPermutation = function (n, k) {
+  let sb = ''
+  const num = []
+  let fact = 1
+  for (let i = 1; i <= n; i++) {
+    fact *= i
+    num.push(i)
+  }
+  for (let i = 0, l = k - 1; i < n; i++) {
+    fact = Math.floor(fact / (n - i))
+    const index = Math.floor(l / fact)
+    sb += num.splice(index, 1)[0]
+    l -= index * fact
+  }
+  return sb
+}

From b57c12cc82c3d5152ae809918767b8199bb71a8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jun 2020 14:09:47 +0800
Subject: [PATCH 0653/3374] Create
 1320-minimum-distance-to-type-a-word-using-two-fingers.js

---
 ...stance-to-type-a-word-using-two-fingers.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1320-minimum-distance-to-type-a-word-using-two-fingers.js

diff --git a/1320-minimum-distance-to-type-a-word-using-two-fingers.js b/1320-minimum-distance-to-type-a-word-using-two-fingers.js
new file mode 100644
index 00000000..aff33212
--- /dev/null
+++ b/1320-minimum-distance-to-type-a-word-using-two-fingers.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const minimumDistance = function (word) {
+  const dp = Array.from({ length: 2 }, () =>
+    new Array(27).fill(0).map(() => Array(27).fill(0))
+  )
+  const A = 'A'.charCodeAt(0)
+  for (let pos = word.length - 1; pos >= 0; --pos) {
+    let to = word[pos].charCodeAt(0) - A
+    for (let i = 0; i < 27; ++i) {
+      for (let j = 0; j < 27; ++j) {
+        dp[pos % 2][i][j] = Math.min(
+          dp[(pos + 1) % 2][to][i] + cost(j, to),
+          dp[(pos + 1) % 2][to][j] + cost(i, to)
+        )
+      }
+    }
+  }
+  return dp[0][26][26]
+}
+function cost(from, to) {
+  if (from === 26) return 0
+  return (
+    Math.abs(((from / 6) >> 0) - ((to / 6) >> 0)) +
+    Math.abs((from % 6) - (to % 6))
+  )
+}

From 934ca1e3f50e9c151f461cf18239a6fc4eee6c1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jun 2020 21:48:51 +0800
Subject: [PATCH 0654/3374] Create 818-race-car.js

---
 818-race-car.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 818-race-car.js

diff --git a/818-race-car.js b/818-race-car.js
new file mode 100644
index 00000000..0f0f545b
--- /dev/null
+++ b/818-race-car.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} target
+ * @return {number}
+ */
+const racecar = function (target) {
+  const dp = new Array(target + 1).fill(0)
+  for (let i = 1; i <= target; i++) {
+    dp[i] = Number.MAX_VALUE
+    let m = 1,
+      j = 1
+    for (; j < i; j = (1 << ++m) - 1) {
+      for (let q = 0, p = 0; p < j; p = (1 << ++q) - 1) {
+        dp[i] = Math.min(dp[i], m + 1 + q + 1 + dp[i - (j - p)])
+      }
+    }
+    dp[i] = Math.min(dp[i], m + (i == j ? 0 : 1 + dp[j - i]))
+  }
+  return dp[target]
+}

From c697beec47dfe72387c0756bd901bff33237f75a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Jun 2020 19:14:35 +0800
Subject: [PATCH 0655/3374] Create
 1240-tiling-a-rectangle-with-the-fewest-squares.js

---
 ...ing-a-rectangle-with-the-fewest-squares.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1240-tiling-a-rectangle-with-the-fewest-squares.js

diff --git a/1240-tiling-a-rectangle-with-the-fewest-squares.js b/1240-tiling-a-rectangle-with-the-fewest-squares.js
new file mode 100644
index 00000000..73602aab
--- /dev/null
+++ b/1240-tiling-a-rectangle-with-the-fewest-squares.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+const tilingRectangle = function (n, m) {
+  if ((n === 11 && m === 13) || (n === 13 && m === 11)) {
+    return 6
+  }
+
+  const dp = Array(n + 1)
+    .fill()
+    .map((_) => Array(m + 1).fill(0))
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      if (i === j) {
+        dp[i][j] = 1
+        continue
+      }
+      dp[i][j] = m * n
+      for (let k = 1; k <= i / 2; k++) {
+        dp[i][j] = Math.min(dp[i][j], dp[i - k][j] + dp[k][j])
+      }
+      for (let k = 1; k <= j / 2; k++) {
+        dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[i][j - k])
+      }
+    }
+  }
+  return dp[n][m]
+}

From 1a27d7155c75db4a31e0c831f549a098937db131 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Jun 2020 20:24:35 +0800
Subject: [PATCH 0656/3374] Update 174-dungeon-game.js

---
 174-dungeon-game.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/174-dungeon-game.js b/174-dungeon-game.js
index 52c3d9d6..db53d7af 100644
--- a/174-dungeon-game.js
+++ b/174-dungeon-game.js
@@ -17,3 +17,24 @@ const calculateMinimumHP = function(dungeon) {
   }
   return dungeon[0][0]
 };
+
+// another
+
+/**
+ * @param {number[][]} dungeon
+ * @return {number}
+ */
+const calculateMinimumHP = function (dungeon) {
+  const n = dungeon.length,
+    m = dungeon[0].length
+  const dp = Array(n + 1).fill(Number.MAX_VALUE)
+  dp[n - 1] = 1
+  for (let j = m - 1; j >= 0; j--) {
+    for (let i = n - 1; i >= 0; i--) {
+      dp[i] = Math.min(dp[i], dp[i + 1]) - dungeon[i][j]
+      dp[i] = Math.max(1, dp[i])
+    }
+  }
+  return dp[0]
+}
+

From 6426abfb4a24187ea8947e44f14148ea34a01d29 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Jun 2020 20:36:33 +0800
Subject: [PATCH 0657/3374] Update 174-dungeon-game.js

---
 174-dungeon-game.js | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

diff --git a/174-dungeon-game.js b/174-dungeon-game.js
index db53d7af..99988ffc 100644
--- a/174-dungeon-game.js
+++ b/174-dungeon-game.js
@@ -2,21 +2,25 @@
  * @param {number[][]} dungeon
  * @return {number}
  */
-const calculateMinimumHP = function(dungeon) {
-  if(dungeon.length === 0) return 1 
-  const rows = dungeon.length
-  const cols = dungeon[0].length
-
-  for(let i = rows - 1 ; i >= 0; i--) {
-    for(let j = cols - 1; j >= 0; j--) {
-      if(i==rows-1 && j==cols-1) dungeon[i][j]=Math.max(1, 1-dungeon[i][j]);
-      else if(i==rows-1) dungeon[i][j]=Math.max(1, dungeon[i][j+1]-dungeon[i][j]);
-      else if(j==cols-1) dungeon[i][j]=Math.max(1, dungeon[i+1][j]-dungeon[i][j]);
-      else dungeon[i][j]=Math.max(1, Math.min(dungeon[i+1][j], dungeon[i][j+1])-dungeon[i][j]);
+const calculateMinimumHP = function (dungeon) {
+  const M = dungeon.length
+  const N = dungeon[0].length
+  // hp[i][j] represents the min hp needed at position (i, j)
+  // Add dummy row and column at bottom and right side
+  const hp = Array.from({ length: M + 1 }, () =>
+    Array(N + 1).fill(Number.MAX_VALUE)
+  )
+  hp[M][N - 1] = 1
+  hp[M - 1][N] = 1
+  for (let i = M - 1; i >= 0; i--) {
+    for (let j = N - 1; j >= 0; j--) {
+      const need = Math.min(hp[i + 1][j], hp[i][j + 1]) - dungeon[i][j]
+      hp[i][j] = need <= 0 ? 1 : need
     }
   }
-  return dungeon[0][0]
-};
+  return hp[0][0]
+}
+
 
 // another
 

From 553961b49f7ad7fbcae20c44f0e7e314b8202a05 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Jun 2020 12:26:15 +0800
Subject: [PATCH 0658/3374] Create
 1312-minimum-insertion-steps-to-make-a-string-palindrome.js

---
 ...m-insertion-steps-to-make-a-string-palindrome.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1312-minimum-insertion-steps-to-make-a-string-palindrome.js

diff --git a/1312-minimum-insertion-steps-to-make-a-string-palindrome.js b/1312-minimum-insertion-steps-to-make-a-string-palindrome.js
new file mode 100644
index 00000000..fecec737
--- /dev/null
+++ b/1312-minimum-insertion-steps-to-make-a-string-palindrome.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minInsertions = function (s) {
+  const dp = [...Array(501)].map((x) => Array(501).fill(0))
+  const N = s.length
+  for (let i = N - 1; i >= 0; --i)
+    for (let j = i + 1; j <= N; ++j)
+      if (s[i] == s[j - 1]) dp[i][j] = dp[i + 1][j - 1]
+      else dp[i][j] = 1 + Math.min(dp[i + 1][j], dp[i][j - 1])
+  return dp[0][N]
+}

From 9023d1507118397454335266c46043de5602de44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Jun 2020 20:28:38 +0800
Subject: [PATCH 0659/3374] Create 920-number-of-music-playlists.js

---
 920-number-of-music-playlists.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 920-number-of-music-playlists.js

diff --git a/920-number-of-music-playlists.js b/920-number-of-music-playlists.js
new file mode 100644
index 00000000..98101a66
--- /dev/null
+++ b/920-number-of-music-playlists.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} N
+ * @param {number} L
+ * @param {number} K
+ * @return {number}
+ */
+const numMusicPlaylists = function (N, L, K) {
+  const mod = 10 ** 9 + 7
+  const dp = Array.from({ length: L + 1 }, () => Array(N + 1).fill(0))
+  dp[0][0] = 1
+  for (let i = 1; i <= L; i++) {
+    for (let j = 1; j <= N; j++) {
+      dp[i][j] = (dp[i - 1][j - 1] * (N - (j - 1))) % mod
+      if (j > K) {
+        dp[i][j] = (dp[i][j] + ((dp[i - 1][j] * (j - K)) % mod)) % mod
+      }
+    }
+  }
+  return dp[L][N]
+}

From 178685d64bf628f220ab056e9cba5610bc02ca2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Jun 2020 11:31:05 +0800
Subject: [PATCH 0660/3374] Create 1307-verbal-arithmetic-puzzle.js

---
 1307-verbal-arithmetic-puzzle.js | 57 ++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 1307-verbal-arithmetic-puzzle.js

diff --git a/1307-verbal-arithmetic-puzzle.js b/1307-verbal-arithmetic-puzzle.js
new file mode 100644
index 00000000..1cbcbddc
--- /dev/null
+++ b/1307-verbal-arithmetic-puzzle.js
@@ -0,0 +1,57 @@
+/**
+ * @param {string[]} words
+ * @param {string} result
+ * @return {boolean}
+ */
+const isSolvable = function (words, result) {
+  const firstChars = new Set()
+
+  // this will hold the key as the character and multiple as the value
+  const map = {}
+  for (let i = 0; i < result.length; i++) {
+    const char = result[i]
+    if (!i) firstChars.add(char)
+    if (!map.hasOwnProperty(char)) map[char] = 0
+    map[char] -= 10 ** (result.length - i - 1)
+  }
+  for (let j = 0; j < words.length; j++) {
+    const word = words[j]
+    for (let i = 0; i < word.length; i++) {
+      const char = word[i]
+      if (!i) firstChars.add(char)
+      if (!map.hasOwnProperty(char)) map[char] = 0
+      map[char] += 10 ** (word.length - i - 1)
+    }
+  }
+
+  const positives = []
+  const negatives = []
+  Object.entries(map).forEach((entry) => {
+    if (entry[1] < 0) negatives.push(entry)
+    else positives.push(entry)
+  })
+
+  const numsUsed = new Set()
+  const backtrack = (val = 0) => {
+    // if we have used all the characters and the value is 0 the input is solvable
+    if (!positives.length && !negatives.length) return val === 0
+
+    // get the store that we are going to examine depending on the value
+    const store =
+      val > 0 || (val === 0 && negatives.length) ? negatives : positives
+    if (store.length === 0) return false
+    const entry = store.pop()
+    const [char, multiple] = entry
+
+    // try every possible value watching out for the edge case that it was a first character
+    for (let i = firstChars.has(char) ? 1 : 0; i < 10; i++) {
+      if (numsUsed.has(i)) continue
+      numsUsed.add(i)
+      if (backtrack(i * multiple + val)) return true
+      numsUsed.delete(i)
+    }
+    store.push(entry)
+    return false
+  }
+  return backtrack()
+}

From d2d363b0652fe5e144baec35091197ef8d66ed2b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Jun 2020 20:20:55 +0800
Subject: [PATCH 0661/3374] Create 1444-number-of-ways-of-cutting-a-pizza.js

---
 1444-number-of-ways-of-cutting-a-pizza.js | 45 +++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1444-number-of-ways-of-cutting-a-pizza.js

diff --git a/1444-number-of-ways-of-cutting-a-pizza.js b/1444-number-of-ways-of-cutting-a-pizza.js
new file mode 100644
index 00000000..fd1056ad
--- /dev/null
+++ b/1444-number-of-ways-of-cutting-a-pizza.js
@@ -0,0 +1,45 @@
+/**
+ * @param {string[]} pizza
+ * @param {number} k
+ * @return {number}
+ */
+const ways = function (pizza, K) {
+  const MOD = 1e9 + 7
+  const M = pizza.length
+  const N = pizza[0].length
+  const count = Array(M + 1)
+    .fill(0)
+    .map(() => Array(N + 1).fill(0))
+  for (let i = M - 1; i >= 0; i--) {
+    let rowCount = 0
+    for (let j = N - 1; j >= 0; j--) {
+      rowCount += pizza[i][j] === 'A' ? 1 : 0
+      count[i][j] = count[i + 1][j] + rowCount
+    }
+  }
+  const dp = Array(M)
+    .fill(0)
+    .map(() =>
+      Array(N)
+        .fill(0)
+        .map(() => Array(K + 1).fill(0))
+    )
+  for (let i = M - 1; i >= 0; i--) {
+    for (let j = N - 1; j >= 0; j--) {
+      dp[i][j][1] = 1
+      for (let k = 2; k <= K; k++) {
+        for (let t = i + 1; t < M; t++) {
+          if (count[i][j] === count[t][j]) continue
+          if (count[t][j] === 0) break
+          dp[i][j][k] = (dp[i][j][k] + dp[t][j][k - 1]) % MOD
+        }
+        for (let t = j + 1; t < N; t++) {
+          if (count[i][j] === count[i][t]) continue
+          if (count[i][t] === 0) break
+          dp[i][j][k] = (dp[i][j][k] + dp[i][t][k - 1]) % MOD
+        }
+      }
+    }
+  }
+  return dp[0][0][K]
+}

From a1e41d25809a75926b134c9a0298ba292d9281c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Jun 2020 00:23:14 +0800
Subject: [PATCH 0662/3374] Create
 1255-maximum-score-words-formed-by-letters.js

---
 1255-maximum-score-words-formed-by-letters.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1255-maximum-score-words-formed-by-letters.js

diff --git a/1255-maximum-score-words-formed-by-letters.js b/1255-maximum-score-words-formed-by-letters.js
new file mode 100644
index 00000000..d489c7b1
--- /dev/null
+++ b/1255-maximum-score-words-formed-by-letters.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string[]} words
+ * @param {character[]} letters
+ * @param {number[]} score
+ * @return {number}
+ */
+const maxScoreWords = function (words, letters, score) {
+  const points = new Map()
+  const count = Array(26).fill(0)
+  for (let w of letters) {
+    count[w.charCodeAt(0) - 97] = ~~count[w.charCodeAt(0) - 97] + 1
+  }
+  return dfs(count, 0)
+  function dfs(count, index) {
+    if (index >= words.length) {
+      return 0
+    }
+    const x = dfs(count, index + 1)
+    const copy = [...count]
+    let point = 0
+    let isValid = true
+    for (let w of words[index]) {
+      let k = w.charCodeAt(0) - 97
+      copy[k]--
+      point += score[k]
+      if (copy[k] < 0) isValid = false
+    }
+    return Math.max(x, isValid ? point + dfs(copy, index + 1) : 0)
+  }
+}

From 4423c4f6b67839376d385faf33de31ac7b0152ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Jun 2020 15:20:42 +0800
Subject: [PATCH 0663/3374] Create
 1263-minimum-moves-to-move-a-box-to-their-target-location.js

---
 ...-to-move-a-box-to-their-target-location.js | 194 ++++++++++++++++++
 1 file changed, 194 insertions(+)
 create mode 100644 1263-minimum-moves-to-move-a-box-to-their-target-location.js

diff --git a/1263-minimum-moves-to-move-a-box-to-their-target-location.js b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
new file mode 100644
index 00000000..bcc8b478
--- /dev/null
+++ b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
@@ -0,0 +1,194 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+const minPushBox = function (grid) {
+  if (
+    typeof grid === 'undefined' ||
+    grid === null ||
+    grid.length === 0 ||
+    grid[0].length === 0
+  ) {
+    return -1
+  }
+
+  let TARGET = null
+  let startBlk = null
+  let startPer = null
+  const DIR = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ]
+
+  for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid[0].length; j++) {
+      if (grid[i][j] === 'S') {
+        startPer = [i, j]
+        grid[i][j] = '.'
+      }
+      if (grid[i][j] === 'T') {
+        TARGET = [i, j]
+      }
+      if (grid[i][j] === 'B') {
+        startBlk = [i, j]
+        grid[i][j] = '.'
+      }
+    }
+  }
+
+  let queue = new PriorityQueue((a, b) => a.weight < b.weight)
+  let states = new Map()
+  queue.push({
+    weight: manDist(startBlk),
+    block: startBlk,
+    character: startPer,
+    move: 0,
+  })
+  while (!queue.isEmpty()) {
+    let { weight, block, character, move } = queue.pop()
+    if (TARGET[0] === block[0] && TARGET[1] === block[1]) {
+      return move
+    }
+    let key = block[0] * grid[0].length + block[1]
+    let val = character[0] * grid[0].length + character[1]
+    if (!states.has(key)) {
+      states.set(key, new Set())
+    }
+    states.get(key).add(val)
+    DIR.forEach((d) => {
+      let i = d[0] + character[0]
+      let j = d[1] + character[1]
+      let curV = i * grid[0].length + j
+      if (validMove(i, j, block[0], block[1]) && !states.get(key).has(curV)) {
+        queue.push({
+          weight: manDist(block) + move,
+          block: block,
+          character: [i, j],
+          move: move,
+        })
+      }
+    })
+    let pushDir = tryPush(character, block)
+    if (pushDir !== null) {
+      let newBlk = [block[0] + pushDir[0], block[1] + pushDir[1]]
+      let newCha = [character[0] + pushDir[0], character[1] + pushDir[1]]
+      let nBK = newBlk[0] * grid[0].length + newBlk[1]
+      let nVal = newCha[0] * grid[0].length + newCha[1]
+      if (!states.has(nBK) || !states.get(nBK).has(nVal)) {
+        queue.push({
+          weight: manDist(newBlk) + (move + 1),
+          block: newBlk,
+          character: newCha,
+          move: move + 1,
+        })
+      }
+    }
+  }
+
+  return -1
+
+  function manDist(block) {
+    let [x, y] = TARGET
+    let [i, j] = block
+    return Math.abs(x - i) + Math.abs(y - j)
+  }
+  function validMove(i, j, x = null, y = null) {
+    if (i < 0 || j < 0 || i >= grid.length || j >= grid[0].length) {
+      return false
+    }
+    if (
+      (x !== null && i === x && y !== null && j === y) ||
+      grid[i][j] === '#'
+    ) {
+      return false
+    }
+    return true
+  }
+  function tryPush(c, b) {
+    let [i, j] = c
+    let [x, y] = b
+    for (let u = 0; u < DIR.length; u++) {
+      let [v, w] = DIR[u]
+      if (
+        ((Math.abs(x - i) === 1 && y === j) ||
+          (Math.abs(y - j) === 1 && x === i)) &&
+        validMove(i + v, j + w) &&
+        validMove(x + v, y + w) &&
+        i + v === x &&
+        j + w === y
+      ) {
+        return [v, w]
+      }
+    }
+    return null
+  }
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 0593cb8773b03fa24f997b7cd8750446dc79208b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Jun 2020 23:39:43 +0800
Subject: [PATCH 0664/3374] Update
 1263-minimum-moves-to-move-a-box-to-their-target-location.js

---
 ...-to-move-a-box-to-their-target-location.js | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)

diff --git a/1263-minimum-moves-to-move-a-box-to-their-target-location.js b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
index bcc8b478..0d950897 100644
--- a/1263-minimum-moves-to-move-a-box-to-their-target-location.js
+++ b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
@@ -192,3 +192,92 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+const minPushBox = function (grid) {
+  const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+  const dis = new Map()
+  const rows = grid.length
+  const cols = grid[0].length
+  let sk, box, target
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (grid[i][j] === 'B') box = [i, j]
+      else if (grid[i][j] === 'S') sk = [i, j]
+      else if (grid[i][j] === 'T') target = [i, j]
+    }
+  }
+  const q = []
+  const start = encode(box[0], box[1], sk[0], sk[1])
+  dis.set(start, 0)
+  q.push(start)
+  let res = Number.MAX_VALUE
+  while (q.length) {
+    const u = q.pop()
+    const du = decode(u)
+    if (dis.get(u) >= res) continue
+    if (du[0] === target[0] && du[1] === target[1]) {
+      res = Math.min(res, dis.get(u))
+      continue
+    }
+    const b = [du[0], du[1]]
+    const s = [du[2], du[3]]
+    for (let dir of dirs) {
+      const nsx = s[0] + dir[0]
+      const nsy = s[1] + dir[1]
+      if (
+        nsx < 0 ||
+        nsx >= rows ||
+        nsy < 0 ||
+        nsy >= cols ||
+        grid[nsx][nsy] === '#'
+      )
+        continue
+      if (nsx === b[0] && nsy === b[1]) {
+        const nbx = b[0] + dir[0]
+        const nby = b[1] + dir[1]
+        if (
+          nbx < 0 ||
+          nbx >= rows ||
+          nby < 0 ||
+          nby >= cols ||
+          grid[nbx][nby] === '#'
+        )
+          continue
+        const v = encode(nbx, nby, nsx, nsy)
+        if (dis.has(v) && dis.get(v) <= dis.get(u) + 1) continue
+        dis.set(v, dis.get(u) + 1)
+        q.push(v)
+      } else {
+        const v = encode(b[0], b[1], nsx, nsy)
+        if (dis.has(v) && dis.get(v) <= dis.get(u)) continue
+        dis.set(v, dis.get(u))
+        q.push(v)
+      }
+    }
+  }
+  return res === Number.MAX_VALUE ? -1 : res
+
+  function encode(bx, by, sx, sy) {
+    return (bx << 24) | (by << 16) | (sx << 8) | sy
+  }
+  function decode(num) {
+    const res = []
+    res[0] = (num >>> 24) & 0xff
+    res[1] = (num >>> 16) & 0xff
+    res[2] = (num >>> 8) & 0xff
+    res[3] = num & 0xff
+    return res
+  }
+}
+

From 6cc4d6e397ca68c62b8cf0a9e06ceec8dd76fb17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Jun 2020 16:08:09 +0800
Subject: [PATCH 0665/3374] Create 839-similar-string-groups.js

---
 839-similar-string-groups.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 839-similar-string-groups.js

diff --git a/839-similar-string-groups.js b/839-similar-string-groups.js
new file mode 100644
index 00000000..9c06d7e9
--- /dev/null
+++ b/839-similar-string-groups.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string[]} A
+ * @return {number}
+ */
+const numSimilarGroups = function (A) {
+  const all = new Set(A)
+  const isSimilar = function (w1, w2) {
+    if (w1 === w2) return true
+    let misMatch = 0
+    for (let i = 0; i < w1.length; i++) {
+      if (w1[i] !== w2[i]) misMatch++
+      if (misMatch > 2) return false
+    }
+    return true
+  }
+  const recur = function (s) {
+    all.delete(s)
+    for (let n of all) {
+      if (isSimilar(s, n)) {
+        recur(n)
+      }
+    }
+  }
+  let ans = 0
+  while (all.size) {
+    const current = all.values().next().value
+    recur(current)
+    ans++
+  }
+  return ans
+}

From 33018d987b56670b2ad4d331bed55382ea878a60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Jun 2020 17:45:41 +0800
Subject: [PATCH 0666/3374] Update 279-perfect-squares.js

---
 279-perfect-squares.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/279-perfect-squares.js b/279-perfect-squares.js
index 23933ba9..b2bb4c27 100644
--- a/279-perfect-squares.js
+++ b/279-perfect-squares.js
@@ -16,3 +16,26 @@ const numSquares = function(n) {
     }
     return dp[n]
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numSquares = function (n) {
+  if (n <= 0) return 0
+  // cntPerfectSquares[i] = the least number of perfect square numbers
+  const cntPerfectSquares = [0]
+  // While cntPerfectSquares.length <= n, we need to incrementally
+  // calculate the next result until we get the result for n.
+  while (cntPerfectSquares.length <= n) {
+    const m = cntPerfectSquares.length
+    let cntSquares = Number.MAX_VALUE
+    for (let i = 1; i * i <= m; i++) {
+      cntSquares = Math.min(cntSquares, cntPerfectSquares[m - i * i] + 1)
+    }
+    cntPerfectSquares.push(cntSquares)
+  }
+  return cntPerfectSquares[n]
+}

From 0249fc40ba8f087153a0a04d1d7d117455b60689 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Jun 2020 20:49:36 +0800
Subject: [PATCH 0667/3374] Update 279-perfect-squares.js

---
 279-perfect-squares.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/279-perfect-squares.js b/279-perfect-squares.js
index b2bb4c27..6cdbbbdd 100644
--- a/279-perfect-squares.js
+++ b/279-perfect-squares.js
@@ -39,3 +39,42 @@ const numSquares = function (n) {
   }
   return cntPerfectSquares[n]
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numSquares = function (n) {
+  // Based on Lagrange's Four Square theorem, there
+  // are only 4 possible results: 1, 2, 3, 4.
+  // If n is a perfect square, return 1.
+  if (is_square(n)) {
+    return 1
+  }
+  // The result is 4 if and only if n can be written in the
+  // form of 4^k*(8*m + 7). Please refer to
+  // Legendre's three-square theorem.
+  while ((n & 3) === 0) {
+    // n%4 == 0
+    n >>= 2
+  }
+  if ((n & 7) === 7) {
+    // n%8 == 7
+    return 4
+  }
+  // Check whether 2 is the result.
+  let sqrt_n = Math.sqrt(n) >> 0
+  for (let i = 1; i <= sqrt_n; i++) {
+    if (is_square(n - i * i)) {
+      return 2
+    }
+  }
+  return 3
+  function is_square(n) {
+    const sqrt_n = Math.sqrt(n) >> 0
+    return sqrt_n * sqrt_n == n
+  }
+}
+

From 7f7b24421e2ae09a41f7155adf1399e26c6336fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Jun 2020 21:37:15 +0800
Subject: [PATCH 0668/3374] Update 322-reconstruct-itinerary.js

---
 322-reconstruct-itinerary.js | 48 +++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/322-reconstruct-itinerary.js b/322-reconstruct-itinerary.js
index ab750e3c..f18b30f8 100644
--- a/322-reconstruct-itinerary.js
+++ b/322-reconstruct-itinerary.js
@@ -2,30 +2,26 @@
  * @param {string[][]} tickets
  * @return {string[]}
  */
-
-const findItinerary = tickets => {
-    let db = {}; 
-    let result = []; 
-    tickets.forEach(node => {
-        if (db[node[0]]) {
-            db[node[0]].push(node[1]);
-        } else {
-            db[node[0]] = [node[1]];
-        }
-    })
-    
-    for(let prop in db){
-        db[prop].sort();
-    } 
-    
-    const dfs = (from) => {
-        while (db[from] && db[from].length > 0) {
-            dfs(db[from].shift());
-        }
-        result.unshift(from);
+const findItinerary = function (tickets) {
+  const result = []
+  const map = new Map()
+  for (const [from, to] of tickets) {
+    if (!map.has(from)) {
+      map.set(from, [])
     }
-    
-    dfs('JFK');
-    return result;
-};
-
+    map.get(from).push(to)
+  }
+  for (const key of map.keys()) {
+    map.get(key).sort()
+  }
+  function dfs(departure) {
+    const destination = map.get(departure)
+    while (destination && destination.length) {
+      const newDeparture = destination.shift()
+      dfs(newDeparture)
+    }
+    result.push(departure)
+  }
+  dfs('JFK')
+  return result.reverse()
+}

From 372b9875c3bbed7cf2b3a3c36b19eb9b29f050ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jun 2020 17:21:04 +0800
Subject: [PATCH 0669/3374] Update 62-unique-paths.js

---
 62-unique-paths.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/62-unique-paths.js b/62-unique-paths.js
index 7372e320..6abde1b3 100644
--- a/62-unique-paths.js
+++ b/62-unique-paths.js
@@ -17,6 +17,24 @@ const uniquePaths = function(m, n) {
 
 // another
 
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const uniquePaths = function(m, n) {
+  const dp = Array(m).fill(0)
+  for(let i = 0; i < n; i++) {
+    dp[0] = 1
+    for(let j = 1; j < m; j++) {
+      dp[j] += dp[j - 1]
+    }
+  }
+  return dp[m - 1]
+};
+
+// another
+
 /**
  * @param {number} m
  * @param {number} n

From 8d82c65ed08fcd95bc4a77db9b86a20e57962977 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Jun 2020 17:27:10 +0800
Subject: [PATCH 0670/3374] Create 834-sum-of-distances-in-tree.js

---
 834-sum-of-distances-in-tree.js | 49 +++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 834-sum-of-distances-in-tree.js

diff --git a/834-sum-of-distances-in-tree.js b/834-sum-of-distances-in-tree.js
new file mode 100644
index 00000000..673af449
--- /dev/null
+++ b/834-sum-of-distances-in-tree.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number} N
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const sumOfDistancesInTree = function (N, edges) {
+  const graph = createGraph(N, edges)
+  const counts = new Array(N).fill(0)
+  const dists = new Array(N).fill(0)
+  dists[0] = getCount(graph, 0, -1, counts).sum
+  return transferDist(N, graph, 0, -1, counts, dists)
+}
+
+function transferDist(N, graph, u, pre, counts, dists) {
+  if (pre >= 0) {
+    const nRight = counts[u]
+    const nLeft = N - nRight
+    dists[u] = dists[pre] - nRight + nLeft
+  }
+  for (const v of graph[u]) {
+    if (v !== pre) {
+      transferDist(N, graph, v, u, counts, dists)
+    }
+  }
+  return dists
+}
+
+function getCount(graph, u, pre, counts) {
+  const output = { nNodes: 0, sum: 0 }
+  for (const v of graph[u]) {
+    if (v !== pre) {
+      const result = getCount(graph, v, u, counts)
+      output.nNodes += result.nNodes
+      output.sum += result.nNodes + result.sum
+    }
+  }
+  output.nNodes += 1
+  counts[u] = output.nNodes
+  return output
+}
+
+function createGraph(N, edges) {
+  const graph = new Array(N).fill(null).map(() => [])
+  for (const [u, v] of edges) {
+    graph[u].push(v)
+    graph[v].push(u)
+  }
+  return graph
+}

From c311892bd2ff632765442e3484a4205fa08d3871 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Jul 2020 08:46:15 +0800
Subject: [PATCH 0671/3374] Create 1473-paint-house-iii.js

---
 1473-paint-house-iii.js | 43 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 1473-paint-house-iii.js

diff --git a/1473-paint-house-iii.js b/1473-paint-house-iii.js
new file mode 100644
index 00000000..d5fc1315
--- /dev/null
+++ b/1473-paint-house-iii.js
@@ -0,0 +1,43 @@
+/**
+ * @param {number[]} houses
+ * @param {number[][]} cost
+ * @param {number} m
+ * @param {number} n
+ * @param {number} target
+ * @return {number}
+ */
+const minCost = function (houses, cost, m, n, target) {
+  const dp = Array(m)
+    .fill(null)
+    .map(() =>
+      Array(target)
+        .fill(null)
+        .map(() => Array(n + 1).fill(0))
+    )
+  function dfs(i, t, p) {
+    if (i === m && t === 0) {
+      return 0
+    } else if (t < 0 || m - i < t || (i === m && t > 0)) {
+      return Infinity
+    } else if (p > -1 && dp[i][t][p]) {
+      return dp[i][t][p]
+    } else {
+      let res = Infinity
+      if (houses[i]) {
+        const tmp = houses[i] !== p ? 1 : 0
+        res = dfs(i + 1, t - tmp, houses[i])
+      } else {
+        for (let k = 1; k <= n; k++) {
+          const tmp = k !== p ? 1 : 0
+          res = Math.min(res, cost[i][k - 1] + dfs(i + 1, t - tmp, k))
+        }
+      }
+      if (p > -1) {
+        dp[i][t][p] = res
+      }
+      return res
+    }
+  }
+  const answer = dfs(0, target, -1)
+  return answer === Infinity ? -1 : answer
+}

From c9d257edcb0e799cb280c32d724f7912525a9239 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Jul 2020 16:47:00 +0800
Subject: [PATCH 0672/3374] Update 441-arranging-coins.js

---
 441-arranging-coins.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/441-arranging-coins.js b/441-arranging-coins.js
index 6c713105..605801fe 100644
--- a/441-arranging-coins.js
+++ b/441-arranging-coins.js
@@ -15,3 +15,13 @@ const arrangeCoins = function(n) {
 
     return num
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const arrangeCoins = function(n) {
+  return (-1 + Math.sqrt(1+4*2*n)) >> 1
+};

From ab08f2b6802c5ea0349e91663a7854a4fcf2ae06 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jul 2020 12:52:11 +0800
Subject: [PATCH 0673/3374] Create 924-minimize-malware-spread.js

---
 924-minimize-malware-spread.js | 63 ++++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 924-minimize-malware-spread.js

diff --git a/924-minimize-malware-spread.js b/924-minimize-malware-spread.js
new file mode 100644
index 00000000..70d60a8d
--- /dev/null
+++ b/924-minimize-malware-spread.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[][]} graph
+ * @param {number[]} initial
+ * @return {number}
+ */
+const minMalwareSpread = function (graph, initial) {
+  const l = graph.length
+  const p = []
+  const children = []
+  for (let i = 0; i < l; i++) {
+    p[i] = i
+    children[i] = [i]
+  }
+
+  for (let i = 0; i < l; i++) {
+    for (let j = i + 1; j < l; j++) {
+      if (graph[i][j] === 1) {
+        const pi = find(i)
+        const pj = find(j)
+        if (pi !== pj) {
+          union(pi, pj)
+        }
+      }
+    }
+  }
+
+  initial.sort((a, b) => (a > b ? 1 : -1))
+
+  const count = {}
+
+  let index = initial[0]
+  let max = 0
+  // find the index that not unioned with other indexes and with the most number of children
+  initial.forEach((e) => {
+    const pe = find(e)
+    if (!count[pe]) count[pe] = 0
+    count[pe] += 1
+  })
+  initial.forEach((e, i) => {
+    const pe = find(e)
+    if (count[pe] === 1 && children[pe].length > max) {
+      max = children[pe].length
+      index = e
+    }
+  })
+
+  return index
+
+  function find(x) {
+    while (p[x] !== x) {
+      p[x] = p[p[x]]
+      x = p[x]
+    }
+    return x
+  }
+
+  function union(pi, pj) {
+    p[pj] = pi
+    //also move the children to the new parent
+    children[pi] = children[pi].concat(children[pj])
+    children[pj] = []
+  }
+}

From f6f5c23bb302a1f1d916faa8dc4f8642cb2732b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jul 2020 17:40:50 +0800
Subject: [PATCH 0674/3374] Create
 1269-number-of-ways-to-stay-in-the-same-place-after-some-steps.js

---
 ...stay-in-the-same-place-after-some-steps.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1269-number-of-ways-to-stay-in-the-same-place-after-some-steps.js

diff --git a/1269-number-of-ways-to-stay-in-the-same-place-after-some-steps.js b/1269-number-of-ways-to-stay-in-the-same-place-after-some-steps.js
new file mode 100644
index 00000000..d1e6c92a
--- /dev/null
+++ b/1269-number-of-ways-to-stay-in-the-same-place-after-some-steps.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} steps
+ * @param {number} arrLen
+ * @return {number}
+ */
+const numWays = function (steps, arrLen) {
+  const MOD = 10 ** 9 + 7
+  const memo = Array.from({ length: (steps >> 1) + 1 }, () =>
+    Array(steps + 1).fill(-1)
+  )
+  return dp(0, steps)
+  function dp(i, steps) {
+    if (steps === 0 && i === 0) return 1
+    if (i < 0 || i >= arrLen || steps === 0 || i > steps) return 0
+    if (memo[i][steps] !== -1) return memo[i][steps]
+    return (memo[i][steps] =
+      ((dp(i + 1, steps - 1) % MOD) +
+        (dp(i - 1, steps - 1) % MOD) +
+        (dp(i, steps - 1) % MOD)) %
+      MOD)
+  }
+}

From 6f78978fb8ee50a21cff4d7c53c82128fbd9619e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Jul 2020 16:23:57 +0800
Subject: [PATCH 0675/3374] Create 957-prison-cells-after-n-days.js

---
 957-prison-cells-after-n-days.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 957-prison-cells-after-n-days.js

diff --git a/957-prison-cells-after-n-days.js b/957-prison-cells-after-n-days.js
new file mode 100644
index 00000000..7b30847e
--- /dev/null
+++ b/957-prison-cells-after-n-days.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} cells
+ * @param {number} N
+ * @return {number[]}
+ */
+const prisonAfterNDays = function (cells, N) {
+  const temp = [...cells]
+  const maxIter = 2 * cells.length - 2
+  N = N % maxIter === 0 ? maxIter : N % maxIter
+  while (N > 0) {
+    for (let i = 0; i < cells.length; i++) {
+      temp[i] = cells[i - 1] === cells[i + 1] ? 1 : 0
+    }
+    cells = [...temp]
+    N--
+  }
+  return cells
+}

From c68b7f5cccf2496e326eb6403a84c2a39cdc0317 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jul 2020 14:46:35 +0800
Subject: [PATCH 0676/3374] Create 936-stamping-the-sequence.js

---
 936-stamping-the-sequence.js | 55 ++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 936-stamping-the-sequence.js

diff --git a/936-stamping-the-sequence.js b/936-stamping-the-sequence.js
new file mode 100644
index 00000000..609b6137
--- /dev/null
+++ b/936-stamping-the-sequence.js
@@ -0,0 +1,55 @@
+/**
+ * @param {string} stamp
+ * @param {string} target
+ * @return {number[]}
+ */
+const movesToStamp = function (stamp, target) {
+  const S = stamp.split('')
+  const T = target.split('')
+  const res = []
+  const visited = Array(T.length).fill(false)
+  let stars = 0
+
+  while (stars < T.length) {
+    let doneReplace = false
+    for (let i = 0; i <= T.length - S.length; i++) {
+      if (!visited[i] && canReplace(T, i, S)) {
+        stars = doReplace(T, i, S.length, stars)
+        doneReplace = true
+        visited[i] = true
+        res.push(i)
+        if (stars === T.length) {
+          break
+        }
+      }
+    }
+
+    if (!doneReplace) {
+      return []
+    }
+  }
+
+  const resArray = Array(res.length).fill(0)
+  for (let i = 0; i < res.length; i++) {
+    resArray[i] = res[res.length - i - 1]
+  }
+  return resArray
+  function canReplace(T, p, S) {
+    for (let i = 0; i < S.length; i++) {
+      if (T[i + p] !== '*' && T[i + p] !== S[i]) {
+        return false
+      }
+    }
+    return true
+  }
+
+  function doReplace(T, p, len, count) {
+    for (let i = 0; i < len; i++) {
+      if (T[i + p] !== '*') {
+        T[i + p] = '*'
+        count++
+      }
+    }
+    return count
+  }
+}

From 3e29a9f82d8b052915e0a87618d11b80ad6e6180 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jul 2020 15:22:54 +0800
Subject: [PATCH 0677/3374] Update 936-stamping-the-sequence.js

---
 936-stamping-the-sequence.js | 8 ++------
 1 file changed, 2 insertions(+), 6 deletions(-)

diff --git a/936-stamping-the-sequence.js b/936-stamping-the-sequence.js
index 609b6137..6da09237 100644
--- a/936-stamping-the-sequence.js
+++ b/936-stamping-the-sequence.js
@@ -17,7 +17,7 @@ const movesToStamp = function (stamp, target) {
         stars = doReplace(T, i, S.length, stars)
         doneReplace = true
         visited[i] = true
-        res.push(i)
+        res.unshift(i)
         if (stars === T.length) {
           break
         }
@@ -29,11 +29,7 @@ const movesToStamp = function (stamp, target) {
     }
   }
 
-  const resArray = Array(res.length).fill(0)
-  for (let i = 0; i < res.length; i++) {
-    resArray[i] = res[res.length - i - 1]
-  }
-  return resArray
+  return res
   function canReplace(T, p, S) {
     for (let i = 0; i < S.length; i++) {
       if (T[i + p] !== '*' && T[i + p] !== S[i]) {

From b5a05d44abf23c615478a6a9d3aebb2ae0d91341 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jul 2020 20:38:22 +0800
Subject: [PATCH 0678/3374] Create 1388-pizza-with-3n-slices.js

---
 1388-pizza-with-3n-slices.js | 38 ++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1388-pizza-with-3n-slices.js

diff --git a/1388-pizza-with-3n-slices.js b/1388-pizza-with-3n-slices.js
new file mode 100644
index 00000000..be6db2f7
--- /dev/null
+++ b/1388-pizza-with-3n-slices.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} slices
+ * @return {number}
+ */
+const maxSizeSlices = function (slices) {
+  const m = slices.length,
+    n = (m / 3) >> 0
+  const slices1 = slices.slice(0, m - 1)
+  const slices2 = slices.slice(1, m)
+  return Math.max(maxSum(slices1, n), maxSum(slices2, n))
+}
+
+function maxSum(arr, n) {
+  // max sum when pick `n` non-adjacent elements from `arr`
+  const m = arr.length
+  // dp[i][j] is maximum sum which we pick `j` elements from linear array `i` elements
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  // Case j = 0 (pick 0 elements): dp[i][0] = 0
+  // Case i = 0 (array is empty): dp[0][j] = 0
+  for (let i = 1; i <= m; ++i) {
+    for (let j = 1; j <= n; ++j) {
+      if (i === 1) {
+        // array has only 1 element
+        // pick that element
+        dp[i][j] = arr[0]
+      } else {
+        dp[i][j] = Math.max(
+          // don't pick element `ith`
+          dp[i - 1][j],
+          // pick element `ith` -> dp[i-2][j-1] means choose `j-1` elements from array `i-2` elements
+          // because we exclude adjacent element `(i-1)th`
+          dp[i - 2][j - 1] + arr[i - 1]
+        )
+      }
+    }
+  }
+  return dp[m][n]
+}

From bcf10e83e06743308931ceb100eb5feae2aac563 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jul 2020 01:15:41 +0800
Subject: [PATCH 0679/3374] Create 1397-find-all-good-strings.js

---
 1397-find-all-good-strings.js | 52 +++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 1397-find-all-good-strings.js

diff --git a/1397-find-all-good-strings.js b/1397-find-all-good-strings.js
new file mode 100644
index 00000000..b631300b
--- /dev/null
+++ b/1397-find-all-good-strings.js
@@ -0,0 +1,52 @@
+/**
+ * @param {number} n
+ * @param {string} s1
+ * @param {string} s2
+ * @param {string} evil
+ * @return {number}
+ */
+const findGoodStrings = function (n, s1, s2, evil) {
+  const evilLen = evil.length
+  const mod = 1000000007
+  const kmp = buildKmpArray(evil)
+  const cache = {}
+  const cnt = (sIdx, evilIdx, isPrefixOf1, isPrefixOf2) => {
+    if (evilIdx === evilLen) return 0
+    if (sIdx === n) return 1
+    const key = [sIdx, evilIdx, isPrefixOf1, isPrefixOf2].join('-')
+    if (cache.hasOwnProperty(key)) return cache[key]
+    let total = 0
+    let first = isPrefixOf1 ? s1.charCodeAt(sIdx) : 97 // a;
+    let last = isPrefixOf2 ? s2.charCodeAt(sIdx) : 122 // z;
+    for (let i = first; i <= last; i++) {
+      const char = String.fromCharCode(i)
+      const isPre1 = isPrefixOf1 && i === first
+      const isPre2 = isPrefixOf2 && i === last
+      let evilPrefix = evilIdx
+      while (evilPrefix && char !== evil[evilPrefix]) {
+        evilPrefix = kmp[evilPrefix - 1]
+      }
+      if (char === evil[evilPrefix]) {
+        evilPrefix += 1
+      }
+      total += cnt(sIdx + 1, evilPrefix, isPre1, isPre2)
+    }
+    return (cache[key] = total % mod)
+  }
+  return cnt(0, 0, true, true)
+}
+
+function buildKmpArray(str) {
+  const result = new Array(str.length).fill(0)
+  let j = 0
+  for (let i = 1; i < str.length; i++) {
+    while (j && str[j] !== str[i]) {
+      j = result[j - 1]
+    }
+    if (str[i] === str[j]) {
+      j += 1
+    }
+    result[i] = j
+  }
+  return result
+}

From be59468afa5a31aee43ffd5c5c8abcdf91094fc8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jul 2020 19:07:33 +0800
Subject: [PATCH 0680/3374] Create 461-hamming-distance.js

---
 461-hamming-distance.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 461-hamming-distance.js

diff --git a/461-hamming-distance.js b/461-hamming-distance.js
new file mode 100644
index 00000000..14d47b10
--- /dev/null
+++ b/461-hamming-distance.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const hammingDistance = function (x, y) {
+  let d = 0
+  let h = x ^ y
+  while (h > 0) {
+    d++
+    h &= h - 1
+  }
+  return d
+}

From 9380f84c8f9da35630fc05958311e4e1cf6c4b12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jul 2020 22:55:19 +0800
Subject: [PATCH 0681/3374] Update 461-hamming-distance.js

---
 461-hamming-distance.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/461-hamming-distance.js b/461-hamming-distance.js
index 14d47b10..40a5453d 100644
--- a/461-hamming-distance.js
+++ b/461-hamming-distance.js
@@ -12,3 +12,17 @@ const hammingDistance = function (x, y) {
   }
   return d
 }
+
+// another
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const hammingDistance = function (x, y) {
+  let n = x ^ y
+  n = n - ((n >> 1) & 0x55555555)
+  n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
+  return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24
+}

From 88f886a3b82c34b014a5ca9bc4afdc8789787f6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jul 2020 22:59:52 +0800
Subject: [PATCH 0682/3374] Update 461-hamming-distance.js

---
 461-hamming-distance.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/461-hamming-distance.js b/461-hamming-distance.js
index 40a5453d..8174de3f 100644
--- a/461-hamming-distance.js
+++ b/461-hamming-distance.js
@@ -26,3 +26,18 @@ const hammingDistance = function (x, y) {
   n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
   return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24
 }
+
+// another
+
+/**
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const hammingDistance = function (x, y) {
+  let n = x ^ y
+  let tmp = n - ((n >> 1) & 033333333333) - ((n >> 2) & 011111111111);
+  return ((tmp + (tmp >> 3)) & 030707070707) % 63;
+}
+
+// https://tech.liuchao.me/2016/11/count-bits-of-integer/

From b55b16af8fe3efe0552f5aefbf6187ff9792b4d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jul 2020 21:36:11 +0800
Subject: [PATCH 0683/3374] Update 66-plus-one.js

---
 66-plus-one.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/66-plus-one.js b/66-plus-one.js
index 9ea6c1f0..d786bf40 100644
--- a/66-plus-one.js
+++ b/66-plus-one.js
@@ -2,15 +2,15 @@
  * @param {number[]} digits
  * @return {number[]}
  */
-const plusOne = function(digits) {
-  let p = true
-  let delta = 1
-  for(let i = digits.length - 1; i >= 0 && p; i--) {
-    let sum = digits[i] + delta
-    if (sum >= 10) p = true
-    else p = false
-    digits[i] = sum % 10
+const plusOne = function (digits) {
+  for (let i = digits.length - 1; i >= 0; i--) {
+    if (digits[i] !== 9) {
+      digits[i]++
+      return digits
+    } else {
+      digits[i] = 0
+    }
   }
-  if(p) digits.unshift(1)
+  digits.unshift(1)
   return digits
-};
+}

From 38e78cf3797dcb993bf1465ef871b17f34da12a6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 09:53:11 +0800
Subject: [PATCH 0684/3374] Create
 1359-count-all-valid-pickup-and-delivery-options.js

---
 1359-count-all-valid-pickup-and-delivery-options.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1359-count-all-valid-pickup-and-delivery-options.js

diff --git a/1359-count-all-valid-pickup-and-delivery-options.js b/1359-count-all-valid-pickup-and-delivery-options.js
new file mode 100644
index 00000000..78dc5182
--- /dev/null
+++ b/1359-count-all-valid-pickup-and-delivery-options.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countOrders = function(n) {
+  let res = 1
+  const MOD = 10 ** 9 + 7
+  for(let i = 1; i <= n; i++) {
+    res = res * (i * 2 - 1) * i % MOD;
+  }
+  return res
+};

From 86f294cdec45ee9e824b970699b035df48a6da3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 10:52:32 +0800
Subject: [PATCH 0685/3374] Update
 1359-count-all-valid-pickup-and-delivery-options.js

---
 ...-count-all-valid-pickup-and-delivery-options.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/1359-count-all-valid-pickup-and-delivery-options.js b/1359-count-all-valid-pickup-and-delivery-options.js
index 78dc5182..ae1de659 100644
--- a/1359-count-all-valid-pickup-and-delivery-options.js
+++ b/1359-count-all-valid-pickup-and-delivery-options.js
@@ -10,3 +10,17 @@ const countOrders = function(n) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countOrders = function(n) {
+  let res = 1
+  const MOD = 10 ** 9 + 7
+  for(let i = 1; i <= n; i++) res = res * i % MOD
+  for(let i = 1; i < 2 * n; i += 2) res = res * i % MOD
+  return res
+};

From 57f16a18d7c4d13ebaf224a16f8fc297888237ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 13:28:22 +0800
Subject: [PATCH 0686/3374] Create 1301-number-of-paths-with-max-score.js

---
 1301-number-of-paths-with-max-score.js | 38 ++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1301-number-of-paths-with-max-score.js

diff --git a/1301-number-of-paths-with-max-score.js b/1301-number-of-paths-with-max-score.js
new file mode 100644
index 00000000..7d5cee5a
--- /dev/null
+++ b/1301-number-of-paths-with-max-score.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string[]} board
+ * @return {number[]}
+ */
+const pathsWithMaxScore = (
+  A,
+  dirs = [
+    [-1, -1],
+    [-1, 0],
+    [0, -1],
+  ],
+  mod = 1e9 + 7
+) => {
+  const N = A.length
+  const S = [...Array(N + 1)].map((row) => Array(N + 1).fill(0)),
+    P = [...Array(N + 1)].map((row) => Array(N + 1).fill(0))
+  P[0][0] = 1
+  for (let i = 1; i <= N; ++i) {
+    for (let j = 1; j <= N; ++j) {
+      if (A[i - 1][j - 1] == 'X') continue
+      for (let d of dirs) {
+        const u = i + d[0],
+          v = j + d[1]
+        const sum = !P[u][v]
+          ? 0
+          : S[u][v] +
+            (i == 1 && j == 1
+              ? 0
+              : i == N && j == N
+              ? 0
+              : A[i - 1].charCodeAt(j - 1) - '0'.charCodeAt(0))
+        if (S[i][j] == sum) P[i][j] = (P[i][j] + P[u][v]) % mod
+        if (S[i][j] < sum) (S[i][j] = sum), (P[i][j] = P[u][v])
+      }
+    }
+  }
+  return [S[N][N], P[N][N]]
+}

From 406e7ec5842ce2ef44734af6c8eb53474ff802ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 14:40:30 +0800
Subject: [PATCH 0687/3374] Update 1301-number-of-paths-with-max-score.js

---
 1301-number-of-paths-with-max-score.js | 43 ++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1301-number-of-paths-with-max-score.js b/1301-number-of-paths-with-max-score.js
index 7d5cee5a..35b84b7c 100644
--- a/1301-number-of-paths-with-max-score.js
+++ b/1301-number-of-paths-with-max-score.js
@@ -36,3 +36,46 @@ const pathsWithMaxScore = (
   }
   return [S[N][N], P[N][N]]
 }
+
+// another
+
+/**
+ * @param {string[]} board
+ * @return {number[]}
+ */
+const pathsWithMaxScore = (
+  board,
+  DIRS = [
+    [-1, -1],
+    [-1, 0],
+    [0, -1],
+  ],
+  mod = 1e9 + 7
+) => {
+  const m = board.length,
+    n = board[0].length
+  const dpSum = Array.from({ length: m }, () => Array(n).fill(0))
+  const dpCnt = Array.from({ length: m }, () => Array(n).fill(0))
+  dpCnt[m - 1][n - 1] = 1 // start at the bottom right square
+  for (let r = m - 1; r >= 0; r--) {
+    for (let c = n - 1; c >= 0; c--) {
+      if (dpCnt[r][c] === 0) continue // can't reach to this square
+      for (let dir of DIRS) {
+        let nr = r + dir[0],
+          nc = c + dir[1]
+        if (nr >= 0 && nc >= 0 && board[nr].charAt(nc) !== 'X') {
+          let nsum = dpSum[r][c]
+          if (board[nr].charAt(nc) !== 'E') nsum += board[nr].charAt(nc) - '0'
+          if (nsum > dpSum[nr][nc]) {
+            dpCnt[nr][nc] = dpCnt[r][c]
+            dpSum[nr][nc] = nsum
+          } else if (nsum === dpSum[nr][nc]) {
+            dpCnt[nr][nc] = (dpCnt[nr][nc] + dpCnt[r][c]) % mod
+          }
+        }
+      }
+    }
+  }
+  return [dpSum[0][0], dpCnt[0][0]]
+}
+

From d33555b315ac51ad7de7e534971e765f187cbc40 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 15:37:57 +0800
Subject: [PATCH 0688/3374] Update 463-island-perimeter.js

---
 463-island-perimeter.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/463-island-perimeter.js b/463-island-perimeter.js
index d108382a..db888ecd 100755
--- a/463-island-perimeter.js
+++ b/463-island-perimeter.js
@@ -38,3 +38,33 @@ function cell(grid, r, c) {
 console.log(
   islandPerimeter([[0, 1, 0, 0], [1, 1, 1, 0], [0, 1, 0, 0], [1, 1, 0, 0]])
 );
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const islandPerimeter = function(grid) {
+  const m = grid.length
+  const n = grid[0].length
+  const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]]
+  let r = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 1) r += h(i, j)
+    }
+  }
+  
+  return r
+  
+  function h(i, j) {
+    let res = 0
+    for(let d of dirs) {
+      const nr = i + d[0]
+      const nc = j + d[1]
+      if(nr < 0 || nc < 0 || nr >= m || nc >= n || grid[nr][nc] === 0) res++
+    }
+    return res
+  }
+};

From cd3c36bd04353cc41be89a1ef6e340d257b9bca4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jul 2020 22:36:34 +0800
Subject: [PATCH 0689/3374] Create 913-cat-and-mouse.js

---
 913-cat-and-mouse.js | 68 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 913-cat-and-mouse.js

diff --git a/913-cat-and-mouse.js b/913-cat-and-mouse.js
new file mode 100644
index 00000000..6a226e3f
--- /dev/null
+++ b/913-cat-and-mouse.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number[][]} graph
+ * @return {number}
+ */
+const catMouseGame = function (g) {
+  const n = g.length
+  const win = Array(2)
+    .fill(0)
+    .map(() => Array(n * n).fill(0))
+  for (let i = 0; i < n; i++) {
+    win[0][i] = 1
+    win[1][i] = 1
+  }
+  for (let i = 1; i < n; i++) {
+    win[0][i * n + i] = 2
+    win[1][i * n + i] = 2
+  }
+
+  while (true) {
+    let anew = false
+    for (let m = 0; m < n; m++) {
+      inner: for (let c = 1; c < n; c++) {
+        if (win[0][m * n + c] == 0) {
+          let und = false
+          for (let e of g[m]) {
+            if (win[1][e * n + c] == 1) {
+              win[0][m * n + c] = 1
+              anew = true
+              continue inner
+            }
+            if (win[1][e * n + c] == 0) {
+              und = true
+            }
+          }
+          if (!und) {
+            win[0][m * n + c] = 2
+            anew = true
+          }
+        }
+      }
+    }
+    for (let c = 1; c < n; c++) {
+      inner: for (let m = 0; m < n; m++) {
+        if (win[1][m * n + c] == 0) {
+          let und = false
+          for (e of g[c]) {
+            if (e == 0) continue
+            if (win[0][m * n + e] == 2) {
+              win[1][m * n + c] = 2
+              anew = true
+              continue inner
+            }
+            if (win[0][m * n + e] == 0) {
+              und = true
+            }
+          }
+          if (!und) {
+            win[1][m * n + c] = 1
+            anew = true
+          }
+        }
+      }
+    }
+    if (!anew) break
+  }
+
+  return win[0][1 * n + 2]
+}

From a95873c17a30824ef1c1a3056821bab6bb224243 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jul 2020 13:40:20 +0800
Subject: [PATCH 0690/3374] Create 1340-jump-game-v.js

---
 1340-jump-game-v.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1340-jump-game-v.js

diff --git a/1340-jump-game-v.js b/1340-jump-game-v.js
new file mode 100644
index 00000000..332ed699
--- /dev/null
+++ b/1340-jump-game-v.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} arr
+ * @param {number} d
+ * @return {number}
+ */
+const maxJumps = function (arr, d) {
+  const cache = new Array(arr.length)
+  const diffs = [1, -1]
+  const dfs = (i) => {
+    if (cache[i]) return cache[i]
+    let max = 0
+    for (let diff of diffs) {
+      for (let j = diff; Math.abs(j) <= d; j += diff) {
+        const nextPosition = i + j
+        const isValidJump =
+          nextPosition >= 0 &&
+          nextPosition < arr.length &&
+          arr[i] > arr[nextPosition]
+        if (isValidJump) max = Math.max(max, dfs(nextPosition))
+        else break
+      }
+    }
+    const result = max + 1
+    cache[i] = result
+    return result
+  }
+  for (let i = 0; i < arr.length; i++) dfs(i)
+  return Math.max(...cache)
+}

From 4a3c699f5f473d79b839d77a571066c9582c5de8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jul 2020 21:15:24 +0800
Subject: [PATCH 0691/3374] Update 15-3sum.js

---
 15-3sum.js | 43 ++++++++++++++++++-------------------------
 1 file changed, 18 insertions(+), 25 deletions(-)

diff --git a/15-3sum.js b/15-3sum.js
index e0ae316d..1d3f8179 100755
--- a/15-3sum.js
+++ b/15-3sum.js
@@ -2,35 +2,28 @@
  * @param {number[]} nums
  * @return {number[][]}
  */
-const threeSum = function(nums) {
-  nums = nums.sort((a, b) => a - b);
-  const res = [];
-  let lo, hi, sum;
+const threeSum = function (nums) {
+  nums = nums.sort((a, b) => a - b)
+  const res = []
+  let lo, hi, sum
   for (let i = 0; i < nums.length - 2; i++) {
-    if (nums[i] > 0) break;
-    if (nums[i] === nums[i - 1]) continue;
+    if (nums[i] > 0) break
+    if (nums[i] === nums[i - 1]) continue
     if (i === 0 || (i > 0 && nums[i] !== nums[i - 1])) {
-      lo = i + 1;
-      hi = nums.length - 1;
-      sum = 0 - nums[i];
+      lo = i + 1
+      hi = nums.length - 1
+      sum = 0 - nums[i]
       while (lo < hi) {
         if (nums[lo] + nums[hi] === sum) {
-          res.push([nums[i], nums[lo], nums[hi]]);
-          while (lo < hi && nums[lo] === nums[lo + 1]) {
-            lo += 1;
-          }
-          while (lo < hi && nums[hi] === nums[hi - 1]) {
-            hi -= 1;
-          }
-          lo += 1;
-          hi -= 1;
-        } else if (nums[lo] + nums[hi] < sum) {
-          lo++;
-        } else {
-          hi--;
-        }
+          res.push([nums[i], nums[lo], nums[hi]])
+          while (lo < hi && nums[lo] === nums[lo + 1]) lo += 1
+          while (lo < hi && nums[hi] === nums[hi - 1]) hi -= 1
+          lo += 1
+          hi -= 1
+        } else if (nums[lo] + nums[hi] < sum) lo++
+        else hi--
       }
     }
   }
-  return res;
-};
+  return res
+}

From e49257fc19b7ef152c17dc72169ff851bca161c8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jul 2020 21:15:39 +0800
Subject: [PATCH 0692/3374] Update 15-3sum.js

---
 15-3sum.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/15-3sum.js b/15-3sum.js
index 1d3f8179..806f3272 100755
--- a/15-3sum.js
+++ b/15-3sum.js
@@ -3,7 +3,7 @@
  * @return {number[][]}
  */
 const threeSum = function (nums) {
-  nums = nums.sort((a, b) => a - b)
+  nums.sort((a, b) => a - b)
   const res = []
   let lo, hi, sum
   for (let i = 0; i < nums.length - 2; i++) {

From 4189e0cb7f451f030b38ee2c485700bba3582ffa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jul 2020 22:39:51 +0800
Subject: [PATCH 0693/3374] Update 1340-jump-game-v.js

---
 1340-jump-game-v.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1340-jump-game-v.js b/1340-jump-game-v.js
index 332ed699..8d8a281a 100644
--- a/1340-jump-game-v.js
+++ b/1340-jump-game-v.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} arr
+ * @param {number} d
+ * @return {number}
+ */
+const maxJumps = function (arr, d) {
+  const map = {}
+  let max = 1
+  for (let i = 0; i < arr.length; i++) {
+    max = Math.max(max, calc(i))
+  }
+  return max
+
+  function calc(i) {
+    if (map[i]) return map[i]
+    let max = 1
+    const left = Math.max(0, i - d)
+    for (let j = i - 1; j >= left; j--) {
+      if (arr[j] >= arr[i]) break
+      if (arr[j] < arr[i]) max = Math.max(max, calc(j) + 1)
+    }
+    const right = Math.min(arr.length - 1, i + d)
+    for (let j = i + 1; j <= right; j++) {
+      if (arr[j] >= arr[i]) break
+      if (arr[j] < arr[i]) max = Math.max(max, calc(j) + 1)
+    }
+    map[i] = max
+    return map[i]
+  }
+}
+
+// another
+
 /**
  * @param {number[]} arr
  * @param {number} d

From 8f90860c34779d2bd635b41bd0a5634bf930fb4d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jul 2020 22:45:50 +0800
Subject: [PATCH 0694/3374] Update 1340-jump-game-v.js

---
 1340-jump-game-v.js | 39 +++++++++++++++++----------------------
 1 file changed, 17 insertions(+), 22 deletions(-)

diff --git a/1340-jump-game-v.js b/1340-jump-game-v.js
index 8d8a281a..5f540740 100644
--- a/1340-jump-game-v.js
+++ b/1340-jump-game-v.js
@@ -3,32 +3,27 @@
  * @param {number} d
  * @return {number}
  */
-const maxJumps = function (arr, d) {
-  const map = {}
-  let max = 1
-  for (let i = 0; i < arr.length; i++) {
-    max = Math.max(max, calc(i))
-  }
-  return max
+const maxJumps = function (arr, d, res = 1) {
+  const dp = Array(1001).fill(0)
+  for (let i = 0, len = arr.length; i < len; ++i)
+    res = Math.max(res, dfs(arr, i, d))
+  return res
 
-  function calc(i) {
-    if (map[i]) return map[i]
-    let max = 1
-    const left = Math.max(0, i - d)
-    for (let j = i - 1; j >= left; j--) {
-      if (arr[j] >= arr[i]) break
-      if (arr[j] < arr[i]) max = Math.max(max, calc(j) + 1)
-    }
-    const right = Math.min(arr.length - 1, i + d)
-    for (let j = i + 1; j <= right; j++) {
-      if (arr[j] >= arr[i]) break
-      if (arr[j] < arr[i]) max = Math.max(max, calc(j) + 1)
-    }
-    map[i] = max
-    return map[i]
+  function dfs(arr, i, d, res = 1) {
+    if (dp[i]) return dp[i]
+    for (
+      let j = i + 1;
+      j <= Math.min(i + d, arr.length - 1) && arr[j] < arr[i];
+      ++j
+    )
+      res = Math.max(res, 1 + dfs(arr, j, d))
+    for (let j = i - 1; j >= Math.max(0, i - d) && arr[j] < arr[i]; --j)
+      res = Math.max(res, 1 + dfs(arr, j, d))
+    return (dp[i] = res)
   }
 }
 
+
 // another
 
 /**

From feb8a7fedc91d99e32e1bb01fcfd418a9c1edb79 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jul 2020 09:31:23 +0800
Subject: [PATCH 0695/3374] Create 1406-stone-game-iii.js

---
 1406-stone-game-iii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1406-stone-game-iii.js

diff --git a/1406-stone-game-iii.js b/1406-stone-game-iii.js
new file mode 100644
index 00000000..64b3d8ef
--- /dev/null
+++ b/1406-stone-game-iii.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} stoneValue
+ * @return {string}
+ */
+const stoneGameIII = function (stoneValue) {
+  const n = stoneValue.length
+  const suffixSum = new Array(n + 1)
+  const dp = new Array(n + 1)
+  suffixSum[n] = 0
+  dp[n] = 0
+  for (let i = n - 1; i >= 0; i--)
+    suffixSum[i] = suffixSum[i + 1] + stoneValue[i]
+  for (let i = n - 1; i >= 0; i--) {
+    dp[i] = stoneValue[i] + suffixSum[i + 1] - dp[i + 1]
+    for (let k = i + 1; k < i + 3 && k < n; k++) {
+      dp[i] = Math.max(dp[i], suffixSum[i] - dp[k + 1])
+    }
+  }
+  if (dp[0] * 2 === suffixSum[0]) return 'Tie'
+  else if (dp[0] * 2 > suffixSum[0]) return 'Alice'
+  else return 'Bob'
+}

From fcb4d8bc2d97d27957ab109ffd67467d62b4a71c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jul 2020 11:39:52 +0800
Subject: [PATCH 0696/3374] Update 1406-stone-game-iii.js

---
 1406-stone-game-iii.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1406-stone-game-iii.js b/1406-stone-game-iii.js
index 64b3d8ef..d837f6f5 100644
--- a/1406-stone-game-iii.js
+++ b/1406-stone-game-iii.js
@@ -20,3 +20,24 @@ const stoneGameIII = function (stoneValue) {
   else if (dp[0] * 2 > suffixSum[0]) return 'Alice'
   else return 'Bob'
 }
+
+// another
+
+/**
+ * @param {number[]} stoneValue
+ * @return {string}
+ */
+const stoneGameIII = function (stoneValue) {
+  const n = stoneValue.length,
+    dp = new Array(4).fill(0)
+  for (let i = n - 1; i >= 0; --i) {
+    dp[i % 4] = -Infinity
+    for (let k = 0, take = 0; k < 3 && i + k < n; ++k) {
+      take += stoneValue[i + k]
+      dp[i % 4] = Math.max(dp[i % 4], take - dp[(i + k + 1) % 4])
+    }
+  }
+  if (dp[0] > 0) return 'Alice'
+  if (dp[0] < 0) return 'Bob'
+  return 'Tie'
+}

From c41515a3f87132309a2523259c8cce15389859e5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Jul 2020 22:01:32 +0800
Subject: [PATCH 0697/3374] Create
 982-triples-with-bitwise-and-equal-to-zero.js

---
 982-triples-with-bitwise-and-equal-to-zero.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 982-triples-with-bitwise-and-equal-to-zero.js

diff --git a/982-triples-with-bitwise-and-equal-to-zero.js b/982-triples-with-bitwise-and-equal-to-zero.js
new file mode 100644
index 00000000..947d0d5d
--- /dev/null
+++ b/982-triples-with-bitwise-and-equal-to-zero.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+const countTriplets = function (A) {
+  const N = 1 << 16,
+    M = 3
+  const dp = Array.from({ length: M + 1 }, () => Array(N).fill(0))
+  dp[0][N - 1] = 1
+  for (let i = 0; i < M; i++) {
+    for (let k = 0; k < N; k++) {
+      for (let a of A) {
+        dp[i + 1][k & a] += dp[i][k]
+      }
+    }
+  }
+  return dp[M][0]
+}

From 5047cd2826ddf6b48ced058983ee0f557ebb088f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jul 2020 20:07:39 +0800
Subject: [PATCH 0698/3374] Update 78-subsets.js

---
 78-subsets.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/78-subsets.js b/78-subsets.js
index 16987bb1..5467e85d 100755
--- a/78-subsets.js
+++ b/78-subsets.js
@@ -21,3 +21,22 @@ function subsets(nums) {
 }
 
 console.log(subsets([1, 2, 3]));
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+
+function subsets(nums) {
+  const subs = [[]]
+  for (let num of nums) {
+    const n = subs.length
+    for (let i = 0; i < n; i++) {
+      subs.push(subs[i].slice(0))
+      subs[subs.length - 1].push(num)
+    }
+  }
+  return subs
+}

From 1f3fc0a4e60446bb1ce806e27065d2e16da3c8b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jul 2020 08:32:24 +0800
Subject: [PATCH 0699/3374] Update 190-reverse-bits.js

---
 190-reverse-bits.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/190-reverse-bits.js b/190-reverse-bits.js
index 13e24388..e74881aa 100644
--- a/190-reverse-bits.js
+++ b/190-reverse-bits.js
@@ -13,3 +13,17 @@ const reverseBits = function(n) {
   }
   return count;
 };
+
+// another
+
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+const reverseBits = function(n) {
+  const b = n.toString(2)
+  const leadingZeroes = b.padStart(32,'0')
+  const rev = leadingZeroes.split('')
+  rev.reverse()
+  return parseInt(rev.join(''), 2)
+};

From 4235e2883e24eb445588049bd2abd386f3ba57a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jul 2020 08:39:21 +0800
Subject: [PATCH 0700/3374] Update 190-reverse-bits.js

---
 190-reverse-bits.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/190-reverse-bits.js b/190-reverse-bits.js
index e74881aa..afa6c0b6 100644
--- a/190-reverse-bits.js
+++ b/190-reverse-bits.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number} - a positive integer
+ */
+const reverseBits = function(n) {
+  let r = 0;
+  for (let i = 0; i < 32; i++) {
+    if (n & 1) {
+      r = r | 1;
+    } 
+    if (i !== 31) {
+       r = r << 1;
+       n = n >> 1;
+    }
+  }
+  return r >>> 0;
+};
+
+// another
+
 /**
  * @param {number} n - a positive integer
  * @return {number} - a positive integer

From 72ba1b9952fefd58b3b0e607006cf5e5fc7e74c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jul 2020 16:12:48 +0800
Subject: [PATCH 0701/3374] Update 100-same-tree.js

---
 100-same-tree.js | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/100-same-tree.js b/100-same-tree.js
index 27b1830d..f6a22945 100755
--- a/100-same-tree.js
+++ b/100-same-tree.js
@@ -1,8 +1,9 @@
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
  * }
  */
 /**
@@ -11,15 +12,7 @@
  * @return {boolean}
  */
 const isSameTree = function(p, q) {
-  return isSame(p, q);
-};
-
-const isSame = (p, q) => {
-  if (p === null && q === null) return true;
-
-  if ((p !== null && q === null) || (p === null && q !== null)) return false;
-
-  if (p.val !== q.val) return false;
-
-  return isSame(p.left, q.left) && isSame(p.right, q.right);
+  if(p == null && q == null) return true
+  if(p == null || q == null || p.val !== q.val) return false
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
 };

From a682549a2427a6ba2eaa7a23916a5f3cd7cf1142 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jul 2020 16:17:28 +0800
Subject: [PATCH 0702/3374] Update 100-same-tree.js

---
 100-same-tree.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/100-same-tree.js b/100-same-tree.js
index f6a22945..6cdcd4b5 100755
--- a/100-same-tree.js
+++ b/100-same-tree.js
@@ -16,3 +16,24 @@ const isSameTree = function(p, q) {
   if(p == null || q == null || p.val !== q.val) return false
   return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {boolean}
+ */
+const isSameTree = function(p, q) {
+  if(p == null || q == null) return p === q
+  if(p.val !== q.val) return false
+  return isSameTree(p.left, q.left) && isSameTree(p.right, q.right)
+};

From f470dc42cda0c613529f35aa55edaae96feda4d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Jul 2020 21:46:32 +0800
Subject: [PATCH 0703/3374] Create 1344-angle-between-hands-of-a-clock.js

---
 1344-angle-between-hands-of-a-clock.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1344-angle-between-hands-of-a-clock.js

diff --git a/1344-angle-between-hands-of-a-clock.js b/1344-angle-between-hands-of-a-clock.js
new file mode 100644
index 00000000..51e9ee2a
--- /dev/null
+++ b/1344-angle-between-hands-of-a-clock.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} hour
+ * @param {number} minutes
+ * @return {number}
+ */
+const angleClock = function(hour, minutes) {
+  const minutesAngle = minutes * 6;
+  const hoursAngle = (hour + minutes / 60) * 30;
+  const diff = Math.abs(minutesAngle - hoursAngle);
+  return Math.min(diff, 360 - diff);
+};

From a16a08648d7042a820f96f9e0a0fb1f3a7118674 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jul 2020 20:18:06 +0800
Subject: [PATCH 0704/3374] Update 151-reverse-words-in-a-string.js

---
 151-reverse-words-in-a-string.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/151-reverse-words-in-a-string.js b/151-reverse-words-in-a-string.js
index 1a70b39f..bc6c0f9d 100755
--- a/151-reverse-words-in-a-string.js
+++ b/151-reverse-words-in-a-string.js
@@ -9,3 +9,28 @@ const reverseWords = function(str) {
     .reverse()
     .join(" ");
 };
+
+// another
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+const reverseWords = function (s) {
+  let sb = ''
+  const n = s.length
+  let i = n - 1
+  while (i >= 0) {
+    if (s.charAt(i) == ' ') {
+      i--
+      continue
+    }
+    let j = i - 1
+    while (j >= 0 && s.charAt(j) != ' ') j--
+    sb += ' '
+    sb += s.slice(j + 1, i + 1)
+    i = j - 1
+  }
+  if (sb.length > 0) sb = sb.slice(1)
+  return sb
+}

From 4dffdd459715aa990eb62b92d614ce06985aa041 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jul 2020 20:57:57 +0800
Subject: [PATCH 0705/3374] Update 50-powx-n.js

---
 50-powx-n.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/50-powx-n.js b/50-powx-n.js
index e589e8ff..0d53f8c3 100644
--- a/50-powx-n.js
+++ b/50-powx-n.js
@@ -14,3 +14,28 @@ const myPow = function(x, n) {
     return myPow(1 / x, -n);
   }
 };
+
+// another
+
+/**
+ * @param {number} x
+ * @param {number} n
+ * @return {number}
+ */
+const myPow = function (x, n) {
+  if (n === 0) return 1
+  if (n < 0) {
+    n = -n
+    x = 1 / x
+  }
+  let res = 1
+  while (n > 0) {
+    if (n & 1) {
+      res *= x
+      --n
+    }
+    x *= x
+    n /= 2
+  }
+  return res
+}

From 528719ff4cc1b938f41881f622267fd669a5fbd0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jul 2020 21:13:13 +0800
Subject: [PATCH 0706/3374] Update 50-powx-n.js

---
 50-powx-n.js | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/50-powx-n.js b/50-powx-n.js
index 0d53f8c3..ecad8c7c 100644
--- a/50-powx-n.js
+++ b/50-powx-n.js
@@ -25,17 +25,15 @@ const myPow = function(x, n) {
 const myPow = function (x, n) {
   if (n === 0) return 1
   if (n < 0) {
+    if (n === -(2 ** 31)) {
+      ++n
+      n = -n
+      x = 1 / x
+      return x * x * myPow(x * x, n / 2)
+    }
     n = -n
     x = 1 / x
   }
-  let res = 1
-  while (n > 0) {
-    if (n & 1) {
-      res *= x
-      --n
-    }
-    x *= x
-    n /= 2
-  }
-  return res
+  return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, (n / 2) >> 0)
 }
+

From 487b94f5f776c8f34dc13387efd8c8d31e1bbc4c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jul 2020 21:13:51 +0800
Subject: [PATCH 0707/3374] Update 50-powx-n.js

---
 50-powx-n.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/50-powx-n.js b/50-powx-n.js
index ecad8c7c..b985b443 100644
--- a/50-powx-n.js
+++ b/50-powx-n.js
@@ -37,3 +37,28 @@ const myPow = function (x, n) {
   return n % 2 == 0 ? myPow(x * x, n / 2) : x * myPow(x * x, (n / 2) >> 0)
 }
 
+// another
+
+/**
+ * @param {number} x
+ * @param {number} n
+ * @return {number}
+ */
+const myPow = function (x, n) {
+  if (n === 0) return 1
+  if (n < 0) {
+    n = -n
+    x = 1 / x
+  }
+  let res = 1
+  while (n > 0) {
+    if (n & 1) {
+      res *= x
+      --n
+    }
+    x *= x
+    n /= 2
+  }
+  return res
+}
+

From 338883a3c7ab43028c0b94880a6100f554a038dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Jul 2020 08:49:44 +0800
Subject: [PATCH 0708/3374] Create 1278-palindrome-partitioning-iii.js

---
 1278-palindrome-partitioning-iii.js | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1278-palindrome-partitioning-iii.js

diff --git a/1278-palindrome-partitioning-iii.js b/1278-palindrome-partitioning-iii.js
new file mode 100644
index 00000000..c00bd65b
--- /dev/null
+++ b/1278-palindrome-partitioning-iii.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const palindromePartition = function(s, k) {
+  const n = s.length
+  const memo = new Map()
+  return dfs(0, k)
+  function cost(s, i, j) {
+    let r = 0
+    while(i < j) {
+      if(s[i] !== s[j]) r++
+      i++
+      j--
+    }
+    return r
+  }
+  function dfs(i, k) {
+    if(memo.has(`${i}-${k}`)) return memo.get(`${i}-${k}`)
+    if(n - i === k) return 0
+    if(k === 1) return cost(s, i, n - 1)
+    let res = Infinity
+    for(let j = i + 1; j < n - k + 2; j++) {
+      res = Math.min(res, dfs(j, k - 1) + cost(s, i, j - 1))
+    }
+    memo.set(`${i}-${k}`, res)
+    return res
+  }
+};

From 10428e2b42730a6e0414f6b88790b0f573f45053 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Jul 2020 22:05:51 +0800
Subject: [PATCH 0709/3374] Create
 1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js

---
 ...-make-at-least-one-valid-path-in-a-grid.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js

diff --git a/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
new file mode 100644
index 00000000..1607e02e
--- /dev/null
+++ b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minCost = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+  const moves = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0],
+  ]
+  const dp = [...new Array(n)].map((e) => [...new Array(m)].fill(Infinity))
+  dp[0][0] = 0
+  let queue = [[0, 0]]
+  while (queue.length > 0) {
+    const temp = []
+    for (let i = 0; i < queue.length; i++) {
+      const [x, y] = queue[i]
+      for (let j = 0; j < moves.length; j++) {
+        const nextX = x + moves[j][0]
+        const nextY = y + moves[j][1]
+        if (nextX >= 0 && nextY >= 0 && nextX < n && nextY < m) {
+          if (dp[nextX][nextY] > dp[x][y] + (grid[x][y] - 1 === j ? 0 : 1)) {
+            dp[nextX][nextY] = dp[x][y] + (grid[x][y] - 1 === j ? 0 : 1)
+            queue.push([nextX, nextY])
+          }
+        }
+      }
+    }
+    queue = temp
+  }
+  return dp[n - 1][m - 1]
+}

From 1f27625500eaf3030f6dd7aa10dc66acd5957722 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 18 Jul 2020 23:34:09 +0800
Subject: [PATCH 0710/3374] Create 1363-largest-multiple-of-three.js

---
 1363-largest-multiple-of-three.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1363-largest-multiple-of-three.js

diff --git a/1363-largest-multiple-of-three.js b/1363-largest-multiple-of-three.js
new file mode 100644
index 00000000..77a3be63
--- /dev/null
+++ b/1363-largest-multiple-of-three.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} digits
+ * @return {string}
+ */
+const largestMultipleOfThree = function (digits) {
+  const sum = digits.reduce((a, c) => a + c)
+  if (sum === 0) return '0'
+  const remainder = sum % 3
+  digits.sort((a, b) => b - a)
+  if (remainder === 0) return digits.join('')
+  const doubleRemainder = remainder === 1 ? 2 : 1
+  const idxs = []
+  for (let i = digits.length - 1; i >= 0; i--) {
+    const numRemainder = digits[i] % 3
+    if (numRemainder === remainder) {
+      digits[i] = ''
+      return digits.join('')
+    } else if (numRemainder === doubleRemainder) {
+      idxs.push(i)
+    }
+  }
+  const [idx1, idx2] = idxs
+  if (idx2 === undefined) return ''
+
+  digits[idx1] = ''
+  digits[idx2] = ''
+  return digits.join('')
+}

From 7981f56bf169fe4ce50b1bb4bacda00e195cd1e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Jul 2020 22:49:28 +0800
Subject: [PATCH 0711/3374] Update 67-add-binary.js

---
 67-add-binary.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/67-add-binary.js b/67-add-binary.js
index 5017f4ab..1e6c437f 100644
--- a/67-add-binary.js
+++ b/67-add-binary.js
@@ -16,3 +16,28 @@ const addBinary = function(a, b) {
     }
     return s
 };
+
+// another
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {string}
+ */
+const addBinary = function(a, b) {
+  let next = false
+  let res = []
+  let ai = a.length - 1
+  let bi = b.length - 1
+  while((ai >= 0 && bi >=0) || next) {
+    const tmp = (ai >= 0 ? +a[ai--] : 0) + (bi >= 0 ? +b[bi--] : 0) + (next ? 1 : 0)
+    if(tmp > 1) next = true
+    else next = false
+    res.unshift('' + (tmp % 2))
+  }
+
+  while(ai >= 0) res.unshift(a[ai--])
+  while(bi >= 0) res.unshift(b[bi--])
+  
+  return res.join('')
+};

From e32bad1733262d7b6a1dc2f29553c55cce602439 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Jul 2020 22:36:56 +0800
Subject: [PATCH 0712/3374] Update 203-remove-linked-list-elements.js

---
 203-remove-linked-list-elements.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/203-remove-linked-list-elements.js b/203-remove-linked-list-elements.js
index e723b517..42807a2f 100644
--- a/203-remove-linked-list-elements.js
+++ b/203-remove-linked-list-elements.js
@@ -27,3 +27,23 @@ const removeElements = function(head, val) {
   }
   return dummy.next
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} val
+ * @return {ListNode}
+ */
+const removeElements = function(head, val) {
+  if (head === null) return null;
+  head.next = removeElements(head.next, val);
+  return head.val === val ? head.next : head;
+};

From 8f3adbe36bf5657a4c946450697485ca6cd032c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jul 2020 12:16:48 +0800
Subject: [PATCH 0713/3374] Create 1411-number-of-ways-to-paint-n-3-grid.js

---
 1411-number-of-ways-to-paint-n-3-grid.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1411-number-of-ways-to-paint-n-3-grid.js

diff --git a/1411-number-of-ways-to-paint-n-3-grid.js b/1411-number-of-ways-to-paint-n-3-grid.js
new file mode 100644
index 00000000..c644c37b
--- /dev/null
+++ b/1411-number-of-ways-to-paint-n-3-grid.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numOfWays = function (n) {
+  let a121 = 6,
+    a123 = 6,
+    b121,
+    b123,
+    mod = 1e9 + 7
+  for (let i = 1; i < n; ++i) {
+    b121 = a121 * 3 + a123 * 2
+    b123 = a121 * 2 + a123 * 2
+    a121 = b121 % mod
+    a123 = b123 % mod
+  }
+  return (a121 + a123) % mod
+}

From 233a514fa27c2c6edf4c638991dd4e2d1918bd3e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jul 2020 22:00:06 +0800
Subject: [PATCH 0714/3374] Update 79-word-search.js

---
 79-word-search.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/79-word-search.js b/79-word-search.js
index 2964968c..e682896f 100644
--- a/79-word-search.js
+++ b/79-word-search.js
@@ -35,6 +35,8 @@ function dfs(board, x, y, dirs, word, start) {
   return false;
 }
 
+// time complexity: O(M * N * 3^L), where L is the length of word.
+
 // another
 
 /**

From c43db42e82effa800a4ff17b70f685ffb4d4ac4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jul 2020 22:00:37 +0800
Subject: [PATCH 0715/3374] Update 79-word-search.js

---
 79-word-search.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/79-word-search.js b/79-word-search.js
index e682896f..d109fa4b 100644
--- a/79-word-search.js
+++ b/79-word-search.js
@@ -36,6 +36,7 @@ function dfs(board, x, y, dirs, word, start) {
 }
 
 // time complexity: O(M * N * 3^L), where L is the length of word.
+// we have a visited array and we never go back, so 3 directions
 
 // another
 

From 91d1209973e788ac8f7dc593815a34a4333d8822 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jul 2020 22:16:23 +0800
Subject: [PATCH 0716/3374] Create 1345-jump-game-iv.js

---
 1345-jump-game-iv.js | 45 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1345-jump-game-iv.js

diff --git a/1345-jump-game-iv.js b/1345-jump-game-iv.js
new file mode 100644
index 00000000..73c89ef5
--- /dev/null
+++ b/1345-jump-game-iv.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var minJumps = function (arr) {
+  if (arr.length === 1) return 0
+  const n = arr.length
+  const indexMap = new Map()
+  for (let i = n - 1; i >= 0; i--) {
+    if (!indexMap.has(arr[i])) {
+      indexMap.set(arr[i], [])
+    }
+    indexMap.get(arr[i]).push(i)
+  }
+  let distance = 0
+  const queue = [0, null]
+  const visited = new Set([0])
+  while (queue.length > 0) {
+    const index = queue.shift()
+    if (index !== null) {
+      if (index > 0 && !visited.has(index - 1)) {
+        visited.add(index - 1)
+        queue.push(index - 1)
+      }
+      if (index < n - 1 && !visited.has(index + 1)) {
+        if (index + 1 === n - 1) return distance + 1
+        visited.add(index + 1)
+        queue.push(index + 1)
+      }
+      for (const nb of indexMap.get(arr[index])) {
+        if (!visited.has(nb) && nb !== index - 1 && nb !== index + 1) {
+          if (nb === n - 1) return distance + 1
+          visited.add(nb)
+          queue.push(nb)
+        }
+      }
+    } else {
+      distance++
+      if (queue.length > 0) {
+        queue.push(null)
+      }
+    }
+  }
+  return -1
+}

From 9bb7a48e1619f303e8df32d80c1f5f172fc5a48e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jul 2020 19:22:37 +0800
Subject: [PATCH 0717/3374] Update
 103-binary-tree-zigzag-level-order-traversal.js

---
 ...inary-tree-zigzag-level-order-traversal.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/103-binary-tree-zigzag-level-order-traversal.js b/103-binary-tree-zigzag-level-order-traversal.js
index 9cd1f0f0..942dd376 100644
--- a/103-binary-tree-zigzag-level-order-traversal.js
+++ b/103-binary-tree-zigzag-level-order-traversal.js
@@ -38,3 +38,40 @@ function bfs(row, res) {
   }
   bfs(next, res)
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const zigzagLevelOrder = function (root) {
+  if (!root) return [];
+  const queue = [root];
+  const zigzag = [];
+  let numLevels = 1;
+  while (queue.length > 0) {
+    const width = queue.length;
+    const levelTraversal = [];
+    for (let i = 0; i < width; i++) {
+      const currentNode = queue.shift();
+      if (currentNode.right) queue.push(currentNode.right);
+      if (currentNode.left) queue.push(currentNode.left);
+      numLevels % 2 === 0
+        ? levelTraversal.push(currentNode.val)
+        : levelTraversal.unshift(currentNode.val);
+    }
+    zigzag.push(levelTraversal);
+    numLevels++;
+  }
+
+  return zigzag;
+};

From 747f202799d59f2983c0a81516655787400e8931 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jul 2020 19:39:15 +0800
Subject: [PATCH 0718/3374] Update
 103-binary-tree-zigzag-level-order-traversal.js

---
 ...inary-tree-zigzag-level-order-traversal.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/103-binary-tree-zigzag-level-order-traversal.js b/103-binary-tree-zigzag-level-order-traversal.js
index 942dd376..54ff515f 100644
--- a/103-binary-tree-zigzag-level-order-traversal.js
+++ b/103-binary-tree-zigzag-level-order-traversal.js
@@ -75,3 +75,34 @@ const zigzagLevelOrder = function (root) {
 
   return zigzag;
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const zigzagLevelOrder = function (root) {
+  const res = []
+  dfs(root, res, 0)
+  return res
+  
+  function dfs(node, res, level) {
+    if(node == null) return
+    if(res.length <= level) res.push([])
+    const tmp = res[level]
+    if(level % 2 === 0) tmp.push(node.val)
+    else tmp.unshift(node.val)
+    
+    dfs(node.left, res, level + 1)
+    dfs(node.right, res, level + 1)
+  }
+};

From 7af8e52779077aa7b41f2cc5a17491843afcff0b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jul 2020 21:38:04 +0800
Subject: [PATCH 0719/3374] Create 1463-cherry-pickup-ii.js

---
 1463-cherry-pickup-ii.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1463-cherry-pickup-ii.js

diff --git a/1463-cherry-pickup-ii.js b/1463-cherry-pickup-ii.js
new file mode 100644
index 00000000..196a6246
--- /dev/null
+++ b/1463-cherry-pickup-ii.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const cherryPickup = function (grid) {
+  const m = grid.length
+  const n = grid[0].length
+  const memo = new Array(m)
+    .fill(0)
+    .map((mat) => new Array(n).fill(0).map((row) => new Array(n).fill(0)))
+  return dfs(grid, m, n, 0, 0, n - 1, memo)
+}
+
+const dfs = (grid, m, n, r, c1, c2, memo) => {
+  if (r == m) return 0
+  if (memo[r][c1][c2]) return memo[r][c1][c2]
+  let count = 0
+  for (let i = -1; i <= 1; i++) {
+    for (let j = -1; j <= 1; j++) {
+      const nc1 = c1 + i
+      const nc2 = c2 + j
+      if (0 <= nc1 && nc1 < n && 0 <= nc2 && nc2 < n) {
+        count = Math.max(count, dfs(grid, m, n, r + 1, nc1, nc2, memo))
+      }
+    }
+  }
+  count += c1 == c2 ? grid[r][c1] : grid[r][c1] + grid[r][c2]
+  return (memo[r][c1][c2] = memo[r][c2][c1] = count)
+}

From 1afe6e74951de24c5eb0579cefcf49bd82e9021f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jul 2020 21:46:55 +0800
Subject: [PATCH 0720/3374] Update 1463-cherry-pickup-ii.js

---
 1463-cherry-pickup-ii.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1463-cherry-pickup-ii.js b/1463-cherry-pickup-ii.js
index 196a6246..9b3f762c 100644
--- a/1463-cherry-pickup-ii.js
+++ b/1463-cherry-pickup-ii.js
@@ -12,7 +12,7 @@ const cherryPickup = function (grid) {
 }
 
 const dfs = (grid, m, n, r, c1, c2, memo) => {
-  if (r == m) return 0
+  if (r === m) return 0
   if (memo[r][c1][c2]) return memo[r][c1][c2]
   let count = 0
   for (let i = -1; i <= 1; i++) {
@@ -24,6 +24,6 @@ const dfs = (grid, m, n, r, c1, c2, memo) => {
       }
     }
   }
-  count += c1 == c2 ? grid[r][c1] : grid[r][c1] + grid[r][c2]
+  count += c1 === c2 ? grid[r][c1] : grid[r][c1] + grid[r][c2]
   return (memo[r][c1][c2] = memo[r][c2][c1] = count)
 }

From bc4c770d988ff6d05bbc00f50c0af5ceb2f56926 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Jul 2020 16:49:26 +0800
Subject: [PATCH 0721/3374] Update 260-single-number-III.js

---
 260-single-number-III.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/260-single-number-III.js b/260-single-number-III.js
index a6659a76..cb1ac7dc 100755
--- a/260-single-number-III.js
+++ b/260-single-number-III.js
@@ -14,3 +14,18 @@ const singleNumber = function(nums) {
   });
   return Object.keys(hash).map(el => +el);
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const singleNumber = function(nums) {
+  const s = new Set()
+  for(let el of nums) {
+    if(s.has(el)) s.delete(el)
+    else s.add(el)
+  }
+  return Array.from(s)
+};

From 0f2d8aa3aff786c8a205601aca226bdebe1898d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Jul 2020 16:52:43 +0800
Subject: [PATCH 0722/3374] Update 260-single-number-III.js

---
 260-single-number-III.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/260-single-number-III.js b/260-single-number-III.js
index cb1ac7dc..de88fee7 100755
--- a/260-single-number-III.js
+++ b/260-single-number-III.js
@@ -29,3 +29,23 @@ const singleNumber = function(nums) {
   }
   return Array.from(s)
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const singleNumber = function (nums) {
+  const res = Array(2).fill(0)
+  const x = nums.reduce((acc, v) => acc ^ v, 0)
+  const partition = x & ~(x - 1)
+  for (let i = 0; i < nums.length; i++) {
+    if (partition & nums[i]) {
+      res[1] ^= nums[i]
+    } else {
+      res[0] ^= nums[i]
+    }
+  }
+  return res
+}

From f3e8a7521d64778080cc687164c079ebfc57c006 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Jul 2020 20:26:49 +0800
Subject: [PATCH 0723/3374] Update 797-all-paths-from-source-to-target.js

---
 797-all-paths-from-source-to-target.js | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/797-all-paths-from-source-to-target.js b/797-all-paths-from-source-to-target.js
index a9f60e58..3896c031 100644
--- a/797-all-paths-from-source-to-target.js
+++ b/797-all-paths-from-source-to-target.js
@@ -4,18 +4,16 @@
  */
 const allPathsSourceTarget = function(graph) {
   const res = []
-  traverse(graph, 0, [0], res)
+  const path = []
+  bt(graph, res, path, 0)
   return res
 };
 
-function traverse(arr, idx, cur, res) {
-  if(idx === arr.length - 1) {
-    res.push(cur.slice(0))
-    return
-  }
-  for(let i = 0, len = arr[idx].length; i < len; i++) {
-    cur.push(arr[idx][i])
-    traverse(arr, arr[idx][i], cur, res)
-    cur.pop(arr[idx][i])
+function bt(g, res, path, cur) {
+  path.push(cur)
+  if(cur === g.length - 1) res.push(path.slice())
+  else {
+    for(let i of g[cur]) bt(g, res, path, i)
   }
+  path.pop()
 }

From 2f2580eacfebd15b4c2719945c5d367773c564ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Jul 2020 17:30:30 +0800
Subject: [PATCH 0724/3374] Update 153-find-minimum-in-rotated-sorted-array.js

---
 153-find-minimum-in-rotated-sorted-array.js | 25 +++++++++++++--------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/153-find-minimum-in-rotated-sorted-array.js b/153-find-minimum-in-rotated-sorted-array.js
index fbdc1c31..ce60feb3 100644
--- a/153-find-minimum-in-rotated-sorted-array.js
+++ b/153-find-minimum-in-rotated-sorted-array.js
@@ -2,12 +2,19 @@
  * @param {number[]} nums
  * @return {number}
  */
-const findMin = function(nums) {
-    if(nums.length === 1) return nums[0]
-    for(let i = 1; i < nums.length; i++) {
-        if(nums[i] - nums[i - 1] < 0) {
-            return nums[i]
-        }
-    }
-    return nums[0]
-};
+const findMin = function (nums) {
+  let low = 0,
+    high = nums.length - 1
+  // loop invariant: 1. low < high
+  //                 2. mid != high and thus A[mid] != A[high] (no duplicate exists)
+  //                 3. minimum is between [low, high]
+  // The proof that the loop will exit: after each iteration either the 'high' decreases
+  // or the 'low' increases, so the interval [low, high] will always shrink.
+  while (low < high) {
+    const mid = low + ((high - low) >> 1)
+    if (nums[mid] < nums[high]) high = mid
+    else if (nums[mid] > nums[high]) low = mid + 1
+  }
+
+  return nums[low]
+}

From c47dcf385eb62a5faf7e609f9579cbbefe1fd9a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Jul 2020 17:35:31 +0800
Subject: [PATCH 0725/3374] Update 153-find-minimum-in-rotated-sorted-array.js

---
 153-find-minimum-in-rotated-sorted-array.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/153-find-minimum-in-rotated-sorted-array.js b/153-find-minimum-in-rotated-sorted-array.js
index ce60feb3..dacc1988 100644
--- a/153-find-minimum-in-rotated-sorted-array.js
+++ b/153-find-minimum-in-rotated-sorted-array.js
@@ -12,7 +12,7 @@ const findMin = function (nums) {
   // or the 'low' increases, so the interval [low, high] will always shrink.
   while (low < high) {
     const mid = low + ((high - low) >> 1)
-    if (nums[mid] < nums[high]) high = mid
+    if (nums[mid] <= nums[high]) high = mid
     else if (nums[mid] > nums[high]) low = mid + 1
   }
 

From 45e16462f73c58d155f0d1cea02344aeeff37080 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jul 2020 22:39:46 +0800
Subject: [PATCH 0726/3374] Update 258-add-digits.js

---
 258-add-digits.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/258-add-digits.js b/258-add-digits.js
index 21cbdbab..510713b0 100755
--- a/258-add-digits.js
+++ b/258-add-digits.js
@@ -13,5 +13,15 @@ const addDigits = function(num) {
   return +res;
 };
 
+// another
+
+/**
+ * @param {number} num
+ * @return {number}
+ */
+const addDigits = function(num) {
+  return 1 + (num - 1) % 9;
+};
+
 console.log(addDigits(0));
 console.log(addDigits(38));

From c30a714ba9dd2d9257bdf64b1dae996cae50116e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Jul 2020 19:48:24 +0800
Subject: [PATCH 0727/3374] Update
 106-construct-binary-tree-from-inorder-and-postorder-traversal.js

---
 ...ee-from-inorder-and-postorder-traversal.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/106-construct-binary-tree-from-inorder-and-postorder-traversal.js b/106-construct-binary-tree-from-inorder-and-postorder-traversal.js
index e94dade1..19c5a701 100644
--- a/106-construct-binary-tree-from-inorder-and-postorder-traversal.js
+++ b/106-construct-binary-tree-from-inorder-and-postorder-traversal.js
@@ -30,3 +30,39 @@ const buildTree = function(inorder, postorder) {
     return root;
   }
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} inorder
+ * @param {number[]} postorder
+ * @return {TreeNode}
+ */
+
+const buildTree = function (inorder, postorder) {
+  let pInorder = inorder.length - 1
+  let pPostorder = postorder.length - 1
+  return helper(inorder, postorder, null)
+  function helper(inorder, postorder, end) {
+    if (pPostorder < 0) return null
+    // create root node
+    const n = new TreeNode(postorder[pPostorder--])
+    // if right node exist, create right subtree
+    if (inorder[pInorder] != n.val) {
+      n.right = helper(inorder, postorder, n)
+    }
+    pInorder--
+    // if left node exist, create left subtree
+    if (end === null || inorder[pInorder] !== end.val) {
+      n.left = helper(inorder, postorder, end)
+    }
+    return n
+  }
+}

From 3bc0635b2c9f2d74d2c75f192baad3f64805e16e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Jul 2020 20:32:01 +0800
Subject: [PATCH 0728/3374] Update 621-task-scheduler.js

---
 621-task-scheduler.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/621-task-scheduler.js b/621-task-scheduler.js
index 0b69d503..079639a0 100755
--- a/621-task-scheduler.js
+++ b/621-task-scheduler.js
@@ -15,3 +15,27 @@ const leastInterval = function(tasks, n) {
   }
   return idle_slots > 0 ? idle_slots + tasks.length : tasks.length;
 };
+
+// another
+
+/**
+ * @param {character[]} tasks
+ * @param {number} n
+ * @return {number}
+ */
+const leastInterval = function(tasks, n) {
+  const hash = {};
+  for(let task of tasks) {
+    hash[task] = hash[task] + 1 || 1
+  }
+  let max = 0, count = 0;
+  for(let el in hash) {
+    if(hash[el] > max) {
+      max = hash[el];
+      count = 1
+    } else if(hash[el] === max) {
+      count++;
+    }
+  }
+  return Math.max((max - 1) *  (n + 1)  +  count, tasks.length)
+};

From 629eae4103c932088259d0787925e285d093acb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Jul 2020 20:23:50 +0800
Subject: [PATCH 0729/3374] Update
 309-best-time-to-buy-and-sell-stock-with-cooldown.js

---
 309-best-time-to-buy-and-sell-stock-with-cooldown.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/309-best-time-to-buy-and-sell-stock-with-cooldown.js b/309-best-time-to-buy-and-sell-stock-with-cooldown.js
index a401175f..0bc3138d 100755
--- a/309-best-time-to-buy-and-sell-stock-with-cooldown.js
+++ b/309-best-time-to-buy-and-sell-stock-with-cooldown.js
@@ -9,14 +9,14 @@ const maxProfit = function(prices) {
 
   const length = prices.length;
   // buy[i]: max profit if the first "i" days end with a "buy" day
-  let buy = Array(length + 1).fill(0); // new int[length + 1];
+  const buy = Array(length + 1).fill(0); 
   // buy[i]: max profit if the first "i" days end with a "sell" day
-  let sell = Array(length + 1).fill(0); // new int[length + 1];
+  const sell = Array(length + 1).fill(0); 
 
   buy[1] = -prices[0];
 
   for (let i = 2; i <= length; i++) {
-    let price = prices[i - 1];
+    const price = prices[i - 1];
     buy[i] = Math.max(buy[i - 1], sell[i - 2] - price);
     sell[i] = Math.max(sell[i - 1], buy[i - 1] + price);
   }

From 5ce9854e150cfc2f7eea38dd6743b37656bfd0ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jul 2020 21:00:16 +0800
Subject: [PATCH 0730/3374] Update 140-word-break-ii.js

---
 140-word-break-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/140-word-break-ii.js b/140-word-break-ii.js
index cf8dfb21..e1c6adc3 100644
--- a/140-word-break-ii.js
+++ b/140-word-break-ii.js
@@ -24,3 +24,36 @@ function backTrack(s, wordDict, mem) {
     mem[s] = result
     return result
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {string[]}
+ */
+const wordBreak = function (s, wordDict) {
+  const dictSet = new Set(wordDict)
+  const memo = {}
+  function dfs(start) {
+    if (start > s.length - 1) {
+      return [[]]
+    }
+    if (memo[start] !== undefined) {
+      return memo[start]
+    }
+    const out = []
+    for (let i = start; i < s.length; i++) {
+      const substr = s.substring(start, i + 1)
+      if (dictSet.has(substr)) {
+        let next = dfs(i + 1)
+        for (let n of next) {
+          out.push([substr, ...n])
+        }
+      }
+    }
+    return (memo[start] = out)
+  }
+  const res = dfs(0)
+  return res.filter((a) => a.join('') === s).map((a) => a.join(' '))
+}

From 9b9dc41a46f95c6109e3d9aa4b953cdd513507f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Jul 2020 21:26:51 +0800
Subject: [PATCH 0731/3374] Create 803-bricks-falling-when-hit.js

---
 803-bricks-falling-when-hit.js | 68 ++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 803-bricks-falling-when-hit.js

diff --git a/803-bricks-falling-when-hit.js b/803-bricks-falling-when-hit.js
new file mode 100644
index 00000000..2c700c8d
--- /dev/null
+++ b/803-bricks-falling-when-hit.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number[][]} grid
+ * @param {number[][]} hits
+ * @return {number[]}
+ */
+const hitBricks = function (grid, hits) {
+  const n = grid[0].length
+  const m = hits.length
+  const res = new Array(m).fill(0)
+  for (const [r, c] of hits) {
+    if (grid[r][c] == 1) grid[r][c] = 0
+    else grid[r][c] = -1
+  }
+  for (let j = 0; j < n; j++) {
+    getConnectedCount(grid, 0, j)
+  }
+  for (let i = m - 1; i >= 0; i--) {
+    const [r, c] = hits[i]
+    if (grid[r][c] == -1) continue
+    grid[r][c] = 1
+    if (isConnectedToTop(grid, r, c)) {
+      res[i] = getConnectedCount(grid, r, c) - 1
+    }
+  }
+  return res
+}
+const isConnectedToTop = (grid, i, j) => {
+  if (i == 0) return true
+  const dircs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+  for (const [dx, dy] of dircs) {
+    const nx = i + dx
+    const ny = j + dy
+    if (
+      0 <= nx &&
+      nx < grid.length &&
+      0 <= ny &&
+      ny < grid[0].length &&
+      grid[nx][ny] == 2
+    ) {
+      return true
+    }
+  }
+  return false
+}
+
+const getConnectedCount = (grid, i, j) => {
+  if (
+    i < 0 ||
+    i >= grid.length ||
+    j < 0 ||
+    j >= grid[0].length ||
+    grid[i][j] != 1
+  )
+    return 0
+  let count = 1
+  grid[i][j] = 2
+  count +=
+    getConnectedCount(grid, i + 1, j) +
+    getConnectedCount(grid, i - 1, j) +
+    getConnectedCount(grid, i, j + 1) +
+    getConnectedCount(grid, i, j - 1)
+  return count
+}

From b7c6681784b7c4797af72737f985e4296d1ba2ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Aug 2020 22:03:39 +0800
Subject: [PATCH 0732/3374] Update 803-bricks-falling-when-hit.js

---
 803-bricks-falling-when-hit.js | 91 ++++++++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)

diff --git a/803-bricks-falling-when-hit.js b/803-bricks-falling-when-hit.js
index 2c700c8d..40b104c6 100644
--- a/803-bricks-falling-when-hit.js
+++ b/803-bricks-falling-when-hit.js
@@ -66,3 +66,94 @@ const getConnectedCount = (grid, i, j) => {
     getConnectedCount(grid, i, j - 1)
   return count
 }
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @param {number[][]} hits
+ * @return {number[]}
+ */
+const hitBricks = function (grid, hits) {
+  const SPACE = 0
+  const BRICK = 1
+  const WILL_HIT = 2
+  const DIRECTIONS = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ]
+  const rows = grid.length
+  const cols = grid[0].length
+  const ds = new DisjointSet(rows * cols + 1)
+
+  for (const [hitR, hitC] of hits) {
+    if (grid[hitR][hitC] === BRICK) {
+      grid[hitR][hitC] = WILL_HIT
+    }
+  }
+
+  function hash(r, c) {
+    return r * cols + c + 1
+  }
+
+  function unionAround(r, c) {
+    const hashed = hash(r, c)
+    for (const [rDiff, cDiff] of DIRECTIONS) {
+      const rNext = r + rDiff
+      const cNext = c + cDiff
+      if (grid[rNext] !== undefined && grid[rNext][cNext] === BRICK) {
+        ds.union(hashed, hash(rNext, cNext))
+      }
+    }
+    if (r === 0) ds.union(0, hashed)
+  }
+  for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid[i].length; j++) {
+      if (grid[i][j] === BRICK) unionAround(i, j)
+    }
+  }
+  let numBricksLeft = ds.size[ds.find(0)]
+  const numBricksDropped = new Array(hits.length)
+  // backwards
+  for (let i = hits.length - 1; i >= 0; i--) {
+    const [hitR, hitC] = hits[i]
+    if (grid[hitR][hitC] === WILL_HIT) {
+      grid[hitR][hitC] = BRICK
+      unionAround(hitR, hitC)
+      const newNumBricksLeft = ds.size[ds.find(0)]
+      numBricksDropped[i] = Math.max(newNumBricksLeft - numBricksLeft - 1, 0)
+      numBricksLeft = newNumBricksLeft
+    } else {
+      numBricksDropped[i] = 0
+    }
+  }
+  return numBricksDropped
+}
+
+class DisjointSet {
+  constructor(n) {
+    this.size = new Array(n).fill(1)
+    this.parent = new Array(n)
+    for (let i = 0; i < n; i++) {
+      this.parent[i] = i
+    }
+  }
+  find(x) {
+    if (x === this.parent[x]) return x
+    this.parent[x] = this.find(this.parent[x])
+
+    return this.parent[x]
+  }
+  union(x, y) {
+    const rootX = this.find(x)
+    const rootY = this.find(y)
+    if (rootX !== rootY) {
+      // attach X onto Y
+      this.parent[rootX] = rootY
+      this.size[rootY] += this.size[rootX]
+    }
+  }
+}
+

From 158283d03114b23957ce1396d3e14280c27d7949 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Aug 2020 20:16:43 +0800
Subject: [PATCH 0733/3374] Create 899-orderly-queue.js

---
 899-orderly-queue.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 899-orderly-queue.js

diff --git a/899-orderly-queue.js b/899-orderly-queue.js
new file mode 100644
index 00000000..4bd4a8ab
--- /dev/null
+++ b/899-orderly-queue.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} S
+ * @param {number} K
+ * @return {string}
+ */
+const orderlyQueue = function (S, K) {
+  if (K === 0) return S
+  else if (K > 1) return S.split('').sort().join('')
+  let result = 0,
+    L = S.length
+  for (let i = 1; i < L; i++) {
+    for (let j = 0; j < L; j++) {
+      let d = S.charCodeAt((result + j) % L) - S.charCodeAt((i + j) % L)
+      if (d !== 0) {
+        if (d > 0) result = i
+        break
+      }
+    }
+  }
+  return S.slice(result) + S.slice(0, result)
+}

From 3ffa3684846efebb055ce910805a04fb609c9687 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Aug 2020 21:43:42 +0800
Subject: [PATCH 0734/3374] Create 1384-total-sales-amount-by-year.sql

---
 1384-total-sales-amount-by-year.sql | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1384-total-sales-amount-by-year.sql

diff --git a/1384-total-sales-amount-by-year.sql b/1384-total-sales-amount-by-year.sql
new file mode 100644
index 00000000..61070127
--- /dev/null
+++ b/1384-total-sales-amount-by-year.sql
@@ -0,0 +1,23 @@
+# Write your MySQL query statement below
+SELECT
+    b.product_id,
+    a.product_name,
+    a.yr AS report_year,
+    CASE 
+        WHEN YEAR(b.period_start)=YEAR(b.period_end) AND a.yr=YEAR(b.period_start) THEN DATEDIFF(b.period_end,b.period_start)+1
+        WHEN a.yr=YEAR(b.period_start) THEN DATEDIFF(DATE_FORMAT(b.period_start,'%Y-12-31'),b.period_start)+1
+        WHEN a.yr=YEAR(b.period_end) THEN DAYOFYEAR(b.period_end) 
+        WHEN a.yr>YEAR(b.period_start) AND a.yr<YEAR(b.period_end) THEN 365
+        ELSE 0
+    END * average_daily_sales AS total_amount
+FROM
+    (SELECT product_id,product_name,'2018' AS yr FROM Product
+    UNION
+    SELECT product_id,product_name,'2019' AS yr FROM Product
+    UNION
+    SELECT product_id,product_name,'2020' AS yr FROM Product) a
+    JOIN 
+    Sales b
+    ON a.product_id=b.product_id  
+HAVING total_amount > 0
+ORDER BY b.product_id,a.yr;

From b9fddf60b81fadb7b8fa431f191d4c44ed446959 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Aug 2020 16:10:48 +0800
Subject: [PATCH 0735/3374] Create 1373-maximum-sum-bst-in-binary-tree.js

---
 1373-maximum-sum-bst-in-binary-tree.js | 39 ++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1373-maximum-sum-bst-in-binary-tree.js

diff --git a/1373-maximum-sum-bst-in-binary-tree.js b/1373-maximum-sum-bst-in-binary-tree.js
new file mode 100644
index 00000000..a427ffd0
--- /dev/null
+++ b/1373-maximum-sum-bst-in-binary-tree.js
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxSumBST = function (root) {
+  let maxSum = 0
+  postOrderTraverse(root)
+  return maxSum
+
+  function postOrderTraverse(root) {
+    if (root == null) return [Number.MAX_VALUE, -Infinity, 0] // {min, max, sum}, initialize min=MAX_VALUE, max=MIN_VALUE
+    let left = postOrderTraverse(root.left)
+    let right = postOrderTraverse(root.right)
+    // The BST is the tree:
+    if (
+      !(
+        left != null && // the left subtree must be BST
+        right != null && // the right subtree must be BST
+        root.val > left[1] && // the root's key must greater than maximum keys of the left subtree
+        root.val < right[0]
+      )
+    )
+      // the root's key must lower than minimum keys of the right subtree
+      return null
+    let sum = root.val + left[2] + right[2] // now it's a BST make `root` as root
+    maxSum = Math.max(maxSum, sum)
+    let min = Math.min(root.val, left[0])
+    let max = Math.max(root.val, right[1])
+    return [min, max, sum]
+  }
+}

From 70cc79cfc3b7f0bd33a7dab98036f0994747ccea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Aug 2020 15:14:43 +0800
Subject: [PATCH 0736/3374] Create 927-three-equal-parts.js

---
 927-three-equal-parts.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 927-three-equal-parts.js

diff --git a/927-three-equal-parts.js b/927-three-equal-parts.js
new file mode 100644
index 00000000..8807ab57
--- /dev/null
+++ b/927-three-equal-parts.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} A
+ * @return {number[]}
+ */
+const threeEqualParts = function (A) {
+  let countNumberOfOnes = 0
+  for (let c of A) if (c === 1) countNumberOfOnes++
+  if (countNumberOfOnes === 0) return [0, A.length - 1]
+  if (countNumberOfOnes % 3 != 0) return [-1, -1]
+  const k = countNumberOfOnes / 3
+  let i
+  // find the first 1 in the array
+  for (i = 0; i < A.length; i++) if (A[i] == 1) break
+  let start = i
+  // find (k+1)th 1 in the array
+  let count1 = 0
+  for (i = 0; i < A.length; i++) {
+    if (A[i] == 1) count1++
+    if (count1 == k + 1) break
+  }
+  let mid = i
+  //find (2*k +1)th 1 in the array
+  count1 = 0
+  for (i = 0; i < A.length; i++) {
+    if (A[i] === 1) count1++
+    if (count1 === 2 * k + 1) break
+  }
+  let end = i
+  // Match all values till the end of the array
+  while (end < A.length && A[start] === A[mid] && A[mid] === A[end]) {
+    start++
+    mid++
+    end++
+  }
+  // Return appropriate values if all the values have matched till the end
+  if (end == A.length) return [start - 1, mid]
+  // otherwise, no such indices found
+  return [-1, -1]
+}

From cba8825eb7d80fbc080cf16e07b8059a85621c21 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Aug 2020 16:53:07 +0800
Subject: [PATCH 0737/3374] Update 442-find-all-duplicates-in-an-array.js

---
 442-find-all-duplicates-in-an-array.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/442-find-all-duplicates-in-an-array.js b/442-find-all-duplicates-in-an-array.js
index 2013b2a7..4d28baa9 100755
--- a/442-find-all-duplicates-in-an-array.js
+++ b/442-find-all-duplicates-in-an-array.js
@@ -19,3 +19,19 @@ const findDuplicates = function(nums) {
 
 console.log(findDuplicates([4, 3, 2, 7, 8, 2, 3, 1]));
 console.log(findDuplicates([10, 2, 5, 10, 9, 1, 1, 4, 3, 7]));
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findDuplicates = function(nums) {
+  const res = []
+  for(let i = 0, len = nums.length; i < len; i++) {
+    const idx = Math.abs(nums[i]) - 1
+    if(nums[idx] < 0) res.push(idx + 1)
+    nums[idx] = -nums[idx]
+  }
+  return res;
+};

From cade42f10616e9c81e6a27e33d4713288482ff3a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Aug 2020 16:49:16 +0800
Subject: [PATCH 0738/3374] Create 1335-minimum-difficulty-of-a-job-schedule.js

---
 1335-minimum-difficulty-of-a-job-schedule.js | 25 ++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1335-minimum-difficulty-of-a-job-schedule.js

diff --git a/1335-minimum-difficulty-of-a-job-schedule.js b/1335-minimum-difficulty-of-a-job-schedule.js
new file mode 100644
index 00000000..6a61cae6
--- /dev/null
+++ b/1335-minimum-difficulty-of-a-job-schedule.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} jobDifficulty
+ * @param {number} d
+ * @return {number}
+ */
+const minDifficulty = function (jobDifficulty, d) {
+  if (jobDifficulty.length < d) return -1
+  const cache = {}
+  const dfs = (start, numDays) => {
+    if (numDays === d) {
+      return start === jobDifficulty.length ? 0 : Infinity
+    }
+    const key = `${start}-${numDays}`
+    if (cache[key] !== undefined) return cache[key]
+    const end = jobDifficulty.length - d + numDays
+    let result = Infinity
+    let max = -Infinity
+    for (let i = start; i <= end; i++) {
+      max = Math.max(max, jobDifficulty[i])
+      result = Math.min(result, max + dfs(i + 1, numDays + 1))
+    }
+    return (cache[key] = result)
+  }
+  return dfs(0, 0)
+}

From 0c704de8f9ba8bcb6d56b3b6d398c2d73962ac74 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Aug 2020 23:05:29 +0800
Subject: [PATCH 0739/3374] Create 1096-brace-expansion-ii.js

---
 1096-brace-expansion-ii.js | 52 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 1096-brace-expansion-ii.js

diff --git a/1096-brace-expansion-ii.js b/1096-brace-expansion-ii.js
new file mode 100644
index 00000000..d8df4332
--- /dev/null
+++ b/1096-brace-expansion-ii.js
@@ -0,0 +1,52 @@
+/**
+ * @param {string} expression
+ * @return {string[]}
+ */
+const braceExpansionII = function (expression) {
+  expression = expression.replace(/([a-z]){1}/g, '{$1}')
+  const stk = new Array()
+  for (let char of expression) {
+    if (char !== '}') {
+      stk.push(char)
+    } else {
+      let str = '',
+        prev = '',
+        temp = ''
+      while (stk[stk.length - 1] != '{') {
+        prev = temp
+        temp = stk.pop()
+        if (temp == ',' || prev == ',' || str == '') str = temp + str
+        else {
+          str = str
+            .split(',')
+            .map((item) => {
+              let ar = new Array()
+              for (let ch of temp.split(',')) ar.push(ch + item)
+              return ar.join(',')
+            })
+            .join(',')
+        }
+      }
+      stk.pop()
+      while (
+        stk.length > 0 &&
+        stk[stk.length - 1] != ',' &&
+        stk[stk.length - 1] != '{'
+      ) {
+        temp = stk.pop()
+        str = str
+          .split(',')
+          .map((item) => {
+            let ar = new Array()
+            for (let ch of temp.split(',')) ar.push(ch + item)
+            return ar.join(',')
+          })
+          .join(',')
+      }
+
+      if (str.length > 0) stk.push(str)
+    }
+  }
+
+  return [...new Set(stk[0].split(','))].sort()
+}

From 0d88a6858980c4336fd077ce936b069a95c18fc4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Aug 2020 21:05:04 +0800
Subject: [PATCH 0740/3374] Create 1336-number-of-transactions-per-visit.sql

---
 1336-number-of-transactions-per-visit.sql | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1336-number-of-transactions-per-visit.sql

diff --git a/1336-number-of-transactions-per-visit.sql b/1336-number-of-transactions-per-visit.sql
new file mode 100644
index 00000000..978dd535
--- /dev/null
+++ b/1336-number-of-transactions-per-visit.sql
@@ -0,0 +1,23 @@
+# Write your MySQL query statement below
+SELECT CAST(b.transaction_count AS UNSIGNED) AS transactions_count, IFNULL(c.visits_count, 0) AS visits_count
+FROM 
+(SELECT (@cnt1 := @cnt1+1) AS transaction_count
+        FROM Transactions 
+        CROSS JOIN (SELECT @cnt1 := -1) AS tmp
+        WHERE @cnt1 + 1 <= (SELECT COUNT(*)
+                                    FROM Transactions
+                                    GROUP BY user_id, transaction_date
+                                    ORDER BY COUNT(*) DESC
+                                    LIMIT 1)
+ UNION SELECT 0
+        ) AS b
+LEFT OUTER JOIN
+(SELECT a.transaction_count AS transaction_count, COUNT(a.user_id) AS visits_count
+FROM (SELECT v.user_id AS user_id, v.visit_date AS visit_date, SUM(IF(t.transaction_date IS NULL, 0, 1)) AS transaction_count
+FROM Visits AS v
+LEFT OUTER JOIN Transactions AS t
+ON v.user_id = t.user_id AND v.visit_date = t.transaction_date
+GROUP BY v.user_id, v.visit_date) AS a
+GROUP BY a.transaction_count
+ORDER BY a.transaction_count) AS c
+ON b.transaction_count = c.transaction_count;

From f608928c38d9ba1dc9b2740150d3efb751f7ddaf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Aug 2020 21:07:10 +0800
Subject: [PATCH 0741/3374] Create 1127-user-purchase-platform.sql

---
 1127-user-purchase-platform.sql | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1127-user-purchase-platform.sql

diff --git a/1127-user-purchase-platform.sql b/1127-user-purchase-platform.sql
new file mode 100644
index 00000000..54ef060e
--- /dev/null
+++ b/1127-user-purchase-platform.sql
@@ -0,0 +1,32 @@
+# Write your MySQL query statement below
+SELECT 
+    p.spend_date,
+    p.platform,
+    IFNULL(SUM(amount), 0) total_amount,
+    COUNT(user_id) total_users
+FROM 
+(
+    SELECT DISTINCT(spend_date), 'desktop' platform FROM Spending
+    UNION
+    SELECT DISTINCT(spend_date), 'mobile' platform FROM Spending
+    UNION
+    SELECT DISTINCT(spend_date), 'both' platform FROM Spending
+) p 
+LEFT JOIN (
+    SELECT
+        spend_date,
+        user_id,
+        IF(mobile_amount > 0, IF(desktop_amount > 0, 'both', 'mobile'), 'desktop') platform,
+        (mobile_amount + desktop_amount) amount
+    FROM (
+        SELECT
+          spend_date,
+          user_id,
+          SUM(CASE platform WHEN 'mobile' THEN amount ELSE 0 END) mobile_amount,
+          SUM(CASE platform WHEN 'desktop' THEN amount ELSE 0 END) desktop_amount
+        FROM Spending
+        GROUP BY spend_date, user_id
+    ) o
+) t
+ON p.platform=t.platform AND p.spend_date=t.spend_date
+GROUP BY spend_date, platform;

From f9f55ce09ce291eac8b657cd9e49a200160765fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Aug 2020 08:17:39 +0800
Subject: [PATCH 0742/3374] Create 810-chalkboard-xor-game.js

---
 810-chalkboard-xor-game.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 810-chalkboard-xor-game.js

diff --git a/810-chalkboard-xor-game.js b/810-chalkboard-xor-game.js
new file mode 100644
index 00000000..3a60cdd8
--- /dev/null
+++ b/810-chalkboard-xor-game.js
@@ -0,0 +1,8 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const xorGame = function(nums) {
+  const xor = nums.reduce((xor,ele) => xor^ele, 0)
+  return xor === 0 || (nums.length & 1) === 0
+};

From 43152dcd1aad2f90607ec46a335cd7263351b4bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Aug 2020 09:43:31 +0800
Subject: [PATCH 0743/3374] Create 902-numbers-at-most-n-given-digit-set.js

---
 902-numbers-at-most-n-given-digit-set.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 902-numbers-at-most-n-given-digit-set.js

diff --git a/902-numbers-at-most-n-given-digit-set.js b/902-numbers-at-most-n-given-digit-set.js
new file mode 100644
index 00000000..82d157dd
--- /dev/null
+++ b/902-numbers-at-most-n-given-digit-set.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string[]} D
+ * @param {number} N
+ * @return {number}
+ */
+const atMostNGivenDigitSet = function (D, N) {
+  const NS = '' + N
+  const digit = NS.length,
+    dsize = D.length
+  let rtn = 0
+  for (let i = 1; i < digit; ++i) rtn += Math.pow(dsize, i)
+  for (let i = 0; i < digit; ++i) {
+    let hasSameNum = false
+    for (let d of D) {
+      if (d < NS[i]) rtn += Math.pow(dsize, digit - i - 1)
+      else if (d == NS[i]) hasSameNum = true
+    }
+    if (!hasSameNum) return rtn
+  }
+  return rtn + 1
+}

From e999c18775f9f05969352246d6ecfd67cb0e3968 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Aug 2020 11:22:32 +0800
Subject: [PATCH 0744/3374] Create 906-super-palindromes.js

---
 906-super-palindromes.js | 112 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 906-super-palindromes.js

diff --git a/906-super-palindromes.js b/906-super-palindromes.js
new file mode 100644
index 00000000..5c876add
--- /dev/null
+++ b/906-super-palindromes.js
@@ -0,0 +1,112 @@
+/**
+ * @param {string} L
+ * @param {string} R
+ * @return {number}
+ */
+const superpalindromesInRange = function (L, R) {
+  // My idea was to take the root of L and R and then generate all palindromes between those numbers,
+  // and then put those palindromes to power 2 and check if those are palindrome as well.
+
+  // The generation of palindromes is done like this:
+  // Lets say i want all palindromes of length 4, then i take all numbers of length 2.
+  // I reverse the length 2 numbers and concatenate them with themselves.
+  // So "19" becomes "19" + "91". For odd length I do the same,
+  //	but put a for loop around them that puts nrs 0 - 9 inside them.
+  // So "19" + "0" + "91", then "19" + "1" + "91", etc.
+
+  // Next I loop through the generated palindromes and just check whether they are
+  // inside sqrt(L) and sqrt(R). (sqrt(L) < palin < sqrt(R))
+  // For every palin within sqrt(L) and sqrt(R), i put the palin to power 2
+  // (with BigInt!) and then check if that is a palindrome. If so, then count++;
+
+  const sqL = Math.sqrt(L)
+  const sqR = Math.sqrt(R)
+  const sqR_Length = parseInt(sqR).toString(10).length
+  // counting the valid super-palindromes
+  let palins = 0
+  // L is a superpalindrome
+  if (
+    isPalindrome(L) &&
+    sqL === parseInt(sqL) &&
+    isPalindrome(sqL.toString(10))
+  )
+    palins++
+  // R is a superpalindrome
+  if (
+    isPalindrome(R) &&
+    sqR === parseInt(sqR) &&
+    isPalindrome(sqR.toString(10))
+  )
+    palins++
+
+  let end
+  if (sqR === parseInt(sqR)) {
+    // or else the loop will possibly add R as well
+    end = parseInt(sqR) - 1
+  } else {
+    end = parseInt(Math.floor(sqR))
+  }
+
+  let begin
+  if (sqL === parseInt(sqL)) {
+    // or else the loop will possibly add R as well
+    begin = parseInt(sqL) + 1
+  } else {
+    begin = parseInt(Math.ceil(sqL))
+  }
+
+  // account for superpalins with for single digit 'sub-palins'
+  if (begin <= 1 && end >= 1) palins++ // 1
+  if (begin <= 2 && end >= 2) palins++ // 4
+  if (begin <= 3 && end >= 3) palins++ // 9
+  const length = sqR_Length
+  const even = length % 2 === 0
+  const half = Math.floor(length / 2)
+  const pow10Half = Math.pow(10, half) // 10 or 100 or 1000, etc
+  const pow10HalfMinOne = Math.pow(10, half - 1)
+  let pal = '' // init
+  let palinStr = '' // init
+  let palin = -1 // init
+  for (let i = 1, leni = pow10Half; i < leni; i++) {
+    pal = i.toString(10)
+    pal.padStart(half - pal.length, '0')
+    palReverse = reverseStr(pal)
+    // generate even length palindrome
+    palinStr = pal + palReverse
+    palin = parseInt(palinStr)
+    if (palin >= begin && palin <= end) {
+      if (isPalindromeInt(BigInt(palin) * BigInt(palin))) {
+        palins++
+      }
+    }
+    // If I generate all palindromes up until some even length,
+    // lets say 4, then last step is to do length 2 + length 2 (19 + 91),
+    // and not the 19 + 0 + 91 step that generates odd length palindromes.
+    if (even && i >= pow10HalfMinOne) {
+      continue
+    }
+    for (let j = 0, lenj = 10; j < lenj; j++) {
+      // generate odd length palindrome
+      palinStr = pal + j + palReverse
+      palin = parseInt(palinStr)
+      if (palin >= begin && palin <= end) {
+        if (isPalindromeInt(BigInt(palin) * BigInt(palin))) {
+          palins++
+        }
+      }
+    }
+  }
+  return palins
+}
+
+const reverseStr = function (str) {
+  return str.split('').reverse().join('')
+}
+
+const isPalindromeInt = function (nr) {
+  nr = nr.toString(10)
+  return nr === nr.split('').reverse().join('')
+}
+const isPalindrome = function (nr) {
+  return nr === nr.split('').reverse().join('')
+}

From c2f5cd3c4ffb35e678aee386ad66a3b1ea3d7718 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Aug 2020 16:27:22 +0800
Subject: [PATCH 0745/3374] Update 171-excel-sheet-column-number.js

---
 171-excel-sheet-column-number.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/171-excel-sheet-column-number.js b/171-excel-sheet-column-number.js
index 10c68858..2beff2fd 100755
--- a/171-excel-sheet-column-number.js
+++ b/171-excel-sheet-column-number.js
@@ -13,3 +13,16 @@ const titleToNumber = function(s) {
 
 console.log(titleToNumber("A"));
 console.log(titleToNumber("AA"));
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const titleToNumber = function(s) {
+  let result = 0;
+  const A = 'A'.charCodeAt(0)
+  for (let i = 0; i < s.length; result = result * 26 + (s.charCodeAt(i) - A + 1), i++);
+  return result;
+};

From 21ef1e326d3eafd8851244b54b4836a1270ca803 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Aug 2020 07:52:55 +0800
Subject: [PATCH 0746/3374] Create 1067-digit-count-in-range.js

---
 1067-digit-count-in-range.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1067-digit-count-in-range.js

diff --git a/1067-digit-count-in-range.js b/1067-digit-count-in-range.js
new file mode 100644
index 00000000..55a147f6
--- /dev/null
+++ b/1067-digit-count-in-range.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number} d
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const digitsCount = function (d, low, high) {
+  return countDigit(high, d) - countDigit(low - 1, d)
+
+  function countDigit(n, d) {
+    if (n < 0 || n < d) {
+      return 0
+    }
+    let count = 0
+    for (let i = 1; i <= n; i *= 10) {
+      let divider = i * 10
+      count += ((n / divider) >> 0) * i
+      if (d > 0) {
+        // tailing number need to be large than d *  i to qualify.
+        count += Math.min(Math.max((n % divider) - d * i + 1, 0), i)
+      } else {
+        if (n / divider > 0) {
+          if (i > 1) {
+            // when d == 0, we need avoid to take numbers like 0xxxx into account.
+            count -= i
+            count += Math.min((n % divider) + 1, i)
+          }
+        }
+      }
+    }
+    return count
+  }
+}

From 44bfa5a8132766577dd7a9c82fa480108687b881 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Aug 2020 09:32:03 +0800
Subject: [PATCH 0747/3374] Update 233-number-of-digit-one.js

---
 233-number-of-digit-one.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/233-number-of-digit-one.js b/233-number-of-digit-one.js
index 5b8abf11..b2c568e7 100644
--- a/233-number-of-digit-one.js
+++ b/233-number-of-digit-one.js
@@ -24,11 +24,11 @@ const countDigitOne = function(n) {
  * @param {number} n
  * @return {number}
  */
-const countDigitOne = function(n) {
+const countDigitOne = function (n) {
   if (n <= 0) return 0
   let ones = 0
   for (let i = 1, q = n; i <= n; i *= 10, q = (q / 10) >> 0) {
-    let pre = (n / (i * 10)) >> 0,
+    const pre = (n / (i * 10)) >> 0,
       cur = q % 10,
       suf = n % i
     ones += pre * i
@@ -36,3 +36,4 @@ const countDigitOne = function(n) {
   }
   return ones
 }
+

From 29fe46f5592b49ab317aa9d16fdd3995326e6828 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Aug 2020 15:32:03 +0800
Subject: [PATCH 0748/3374] Update 274-h-index.js

---
 274-h-index.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/274-h-index.js b/274-h-index.js
index 0a6ce359..80218b8a 100644
--- a/274-h-index.js
+++ b/274-h-index.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} citations
+ * @return {number}
+ */
+const hIndex = function(citations) {
+  const n = citations.length
+  const arr = Array(n + 1).fill(0)
+  for(let e of citations) {
+    if(e >= n) arr[n]++
+    else arr[e]++
+  }
+  for(let i = n, sum = 0; i >= 0; i--) {
+    sum += arr[i]
+    if(sum >= i) return i
+  }
+  return 0
+};
+
+// another
+
 /**
  * @param {number[]} citations
  * @return {number}

From 1a045c0cc3a3fa909abe0121901c8d29433f864e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 09:06:46 +0800
Subject: [PATCH 0749/3374] Create 1224-maximum-equal-frequency.js

---
 1224-maximum-equal-frequency.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1224-maximum-equal-frequency.js

diff --git a/1224-maximum-equal-frequency.js b/1224-maximum-equal-frequency.js
new file mode 100644
index 00000000..0f1bb6b1
--- /dev/null
+++ b/1224-maximum-equal-frequency.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxEqualFreq = function (nums) {
+  const cnt = {},
+    freq = {}
+  let maxF = 0,
+    res = 0
+  nums.forEach((num, i) => {
+    if (cnt[num] == null) cnt[num] = 0
+    cnt[num] += 1
+    if (freq[cnt[num] - 1] == null) freq[cnt[num] - 1] = 0
+    if (freq[cnt[num]] == null) freq[cnt[num]] = 0
+    freq[cnt[num] - 1] -= 1
+    freq[cnt[num]] += 1
+    maxF = Math.max(maxF, cnt[num])
+    if (
+      maxF * freq[maxF] === i ||
+      (maxF - 1) * (freq[maxF - 1] + 1) === i ||
+      maxF === 1
+    )
+      res = i + 1
+  })
+  return res
+}

From 1b1fed49feb50615166e94b2ea751fafbfcab6c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 10:50:32 +0800
Subject: [PATCH 0750/3374] Create
 1449-form-largest-integer-with-digits-that-add-up-to-target.js

---
 ...teger-with-digits-that-add-up-to-target.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1449-form-largest-integer-with-digits-that-add-up-to-target.js

diff --git a/1449-form-largest-integer-with-digits-that-add-up-to-target.js b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
new file mode 100644
index 00000000..4aac76fc
--- /dev/null
+++ b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} cost
+ * @param {number} target
+ * @return {string}
+ */
+const largestNumber = function(cost, target) {
+  const m = new Map()
+  const res = dfs(cost, 1, target, m)
+  return res.indexOf('0') !== -1 ? '0' : res
+};
+function dfs(cost, index, remain, m) {
+  if(remain === 0) return ''
+  if(remain < 0 || index === cost.length + 1) return '0'
+  const k = `${index}-${remain}`
+  if(m.has(k)) return m.get(k)
+  const take = '' + index + dfs(cost, 1, remain - cost[index - 1], m)
+  const skip = dfs(cost, index + 1, remain, m)
+  const res = getBigger(take, skip)
+  m.set(k, res)
+  return res
+}
+function getBigger(num1, num2) {
+  if(num1.indexOf('0') !== -1) return num2
+  if(num2.indexOf('0') !== -1) return num1
+  if(num1.length > num2.length) return num1
+  else if(num1.length < num2.length) return num2
+  else return num1 > num2 ? num1 : num2
+}

From a8ca12f3743d23bb9618f38f855755286a2d1e01 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 11:07:25 +0800
Subject: [PATCH 0751/3374] Update
 1449-form-largest-integer-with-digits-that-add-up-to-target.js

---
 ...form-largest-integer-with-digits-that-add-up-to-target.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/1449-form-largest-integer-with-digits-that-add-up-to-target.js b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
index 4aac76fc..9acd6c89 100644
--- a/1449-form-largest-integer-with-digits-that-add-up-to-target.js
+++ b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
@@ -11,12 +11,11 @@ const largestNumber = function(cost, target) {
 function dfs(cost, index, remain, m) {
   if(remain === 0) return ''
   if(remain < 0 || index === cost.length + 1) return '0'
-  const k = `${index}-${remain}`
-  if(m.has(k)) return m.get(k)
+  if(m.has(remain)) return m.get(remain)
   const take = '' + index + dfs(cost, 1, remain - cost[index - 1], m)
   const skip = dfs(cost, index + 1, remain, m)
   const res = getBigger(take, skip)
-  m.set(k, res)
+  m.set(remain, res)
   return res
 }
 function getBigger(num1, num2) {

From 5c38a99a468fc2137545d8d4031fe9981ae7b8e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 11:09:01 +0800
Subject: [PATCH 0752/3374] Rename 1.two-sum.js to 1-two-sum.js

---
 1.two-sum.js => 1-two-sum.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 1.two-sum.js => 1-two-sum.js (100%)

diff --git a/1.two-sum.js b/1-two-sum.js
similarity index 100%
rename from 1.two-sum.js
rename to 1-two-sum.js

From 05676f5805fa4b8e65a2c777795fa9e43b80c139 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 11:12:23 +0800
Subject: [PATCH 0753/3374] Create 25-reverse-nodes-in-k-group.js

---
 25-reverse-nodes-in-k-group.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 25-reverse-nodes-in-k-group.js

diff --git a/25-reverse-nodes-in-k-group.js b/25-reverse-nodes-in-k-group.js
new file mode 100644
index 00000000..40e0d8a1
--- /dev/null
+++ b/25-reverse-nodes-in-k-group.js
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+const reverseKGroup = function(head, k) {
+  let n = 0
+  for (let i = head; i != null; n++, i = i.next);
+  let dmy = new ListNode(0)
+  dmy.next = head
+  for (let prev = dmy, tail = head; n >= k; n -= k) {
+    for (let i = 1; i < k; i++) {
+      let next = tail.next.next
+      tail.next.next = prev.next
+      prev.next = tail.next
+      tail.next = next
+    }
+
+    prev = tail
+    tail = tail.next
+  }
+  return dmy.next
+}

From 6b04fa7ce50b744be0e0d4a2965aa0771e09afb1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 11:28:57 +0800
Subject: [PATCH 0754/3374] Rename 41-add-strings.js to 415-add-strings.js

---
 41-add-strings.js => 415-add-strings.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 41-add-strings.js => 415-add-strings.js (100%)

diff --git a/41-add-strings.js b/415-add-strings.js
similarity index 100%
rename from 41-add-strings.js
rename to 415-add-strings.js

From 760709bbea05bedd701cacaa99365a3a865d25a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 11:56:03 +0800
Subject: [PATCH 0755/3374] Create 126-word-ladder-ii.js

---
 126-word-ladder-ii.js | 64 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 126-word-ladder-ii.js

diff --git a/126-word-ladder-ii.js b/126-word-ladder-ii.js
new file mode 100644
index 00000000..05431413
--- /dev/null
+++ b/126-word-ladder-ii.js
@@ -0,0 +1,64 @@
+/**
+ * @param {string} beginWord
+ * @param {string} endWord
+ * @param {string[]} wordList
+ * @return {string[][]}
+ */
+const findLadders = function (beginWord, endWord, wordList) {
+  const res = []
+  if (!wordList.includes(endWord)) return res
+  const set1 = new Set([beginWord]),
+    set2 = new Set([endWord]),
+    wordSet = new Set(wordList),
+    temp = [beginWord]
+  const map = new Map()
+  const traverse = (set1, set2, dir) => {
+    if (set1.size === 0) return false
+    if (set1.size > set2.size) return traverse(set2, set1, !dir)
+    for (const val of set1.values()) {
+      if (wordSet.has(val)) wordSet.delete(val)
+    }
+    for (const val of set2.values()) {
+      if (wordSet.has(val)) wordSet.delete(val)
+    }
+    const set = new Set()
+    let done = false
+    for (const str of set1.values()) {
+      for (let i = 0; i < str.length; i++) {
+        for (let ch = 'a'.charCodeAt(); ch <= 'z'.charCodeAt(); ch++) {
+          const word =
+            str.slice(0, i) + String.fromCharCode(ch) + str.slice(i + 1)
+          const key = dir ? str : word
+          const val = dir ? word : str
+          const list = map.get(key) || []
+          if (set2.has(word)) {
+            done = true
+            list.push(val)
+            map.set(key, list)
+          }
+          if (!done && wordSet.has(word)) {
+            set.add(word)
+            list.push(val)
+            map.set(key, list)
+          }
+        }
+      }
+    }
+    return done || traverse(set2, set, !dir)
+  }
+  const dfs = (word) => {
+    if (word === endWord) {
+      res.push(temp.slice())
+      return
+    }
+    const nei = map.get(word) || []
+    for (const w of nei) {
+      temp.push(w)
+      dfs(w)
+      temp.pop()
+    }
+  }
+  traverse(set1, set2, true)
+  dfs(beginWord)
+  return res
+}

From 2be3f0e1f2b8561220592d73421e257521b00910 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 12:05:05 +0800
Subject: [PATCH 0756/3374] Create 149-max-points-on-a-line.js

---
 149-max-points-on-a-line.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 149-max-points-on-a-line.js

diff --git a/149-max-points-on-a-line.js b/149-max-points-on-a-line.js
new file mode 100644
index 00000000..9cbedd55
--- /dev/null
+++ b/149-max-points-on-a-line.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const maxPoints = function (points) {
+  if (points.length < 2 || points == null) return points.length
+  let max = 2
+  for (let i = 0; i < points.length; i++) {
+    let [p1x, p1y] = points[i]
+    let samePoint = 1,
+      map = { base: 0 } // to avoid when map = {}, the max value is -Infinity
+    for (let j = i + 1; j < points.length; j++) {
+      if (points[i][0] == points[j][0] && points[i][1] == points[j][1]) {
+        samePoint++
+      } else {
+        let [p2x, p2y] = points[j]
+        let slope = (1000000.0 * (p2y - p1y)) / (p2x - p1x)
+        if (!Number.isFinite(slope)) slope = 'v'
+        else if (Number.isNaN(slope)) slope = 'h'
+        map[slope] = map[slope] + 1 || 1
+      }
+    }
+    max = Math.max(Math.max(...Object.values(map)) + samePoint, max)
+  }
+  return max
+}

From 07b1493bdf582df478d65a3ad5dc5c3139ce9654 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 12:11:06 +0800
Subject: [PATCH 0757/3374] Create 164-maximum-gap.js

---
 164-maximum-gap.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 164-maximum-gap.js

diff --git a/164-maximum-gap.js b/164-maximum-gap.js
new file mode 100644
index 00000000..cfdec7d7
--- /dev/null
+++ b/164-maximum-gap.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumGap = function (nums) {
+  if (nums.length < 2) return
+  let max = 0
+  nums = nums.sort(function (a, b) {
+    return a - b
+  })
+  for (let i = 1; i < nums.length; i++) {
+    if (nums[i] - nums[i - 1] > max) max = nums[i] - nums[i - 1]
+  }
+  return max
+}

From d56dd3e426ac893d6abc4b0bb2d6bffce1f01ec5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 13:10:36 +0800
Subject: [PATCH 0758/3374] Create 166-fraction-to-recurring-decimal.js

---
 166-fraction-to-recurring-decimal.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 166-fraction-to-recurring-decimal.js

diff --git a/166-fraction-to-recurring-decimal.js b/166-fraction-to-recurring-decimal.js
new file mode 100644
index 00000000..df393a94
--- /dev/null
+++ b/166-fraction-to-recurring-decimal.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} numerator
+ * @param {number} denominator
+ * @return {string}
+ */
+const fractionToDecimal = function (numerator, denominator) {
+  if (numerator === 0) return '0'
+  let s = ''
+  if (Math.sign(numerator) !== Math.sign(denominator)) s += '-'
+  let n = Math.abs(numerator)
+  const d = Math.abs(denominator)
+  s += Math.floor(n / d)
+  n %= d
+  if (n === 0) return s
+  s += '.'
+  const map = {}
+  while (n !== 0) {
+    map[n] = s.length
+    n *= 10
+    s += Math.floor(n / d)
+    n %= d
+    const i = map[n] // repeat starting index
+    if (i != null) return `${s.slice(0, i)}(${s.slice(i)})`
+  }
+  return s
+}

From 05b456f4613ad9c416ca777192f6e0a8a56c2e80 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Aug 2020 16:21:47 +0800
Subject: [PATCH 0759/3374] Create 1199-minimum-time-to-build-blocks.js

---
 1199-minimum-time-to-build-blocks.js | 58 ++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 1199-minimum-time-to-build-blocks.js

diff --git a/1199-minimum-time-to-build-blocks.js b/1199-minimum-time-to-build-blocks.js
new file mode 100644
index 00000000..873aa97c
--- /dev/null
+++ b/1199-minimum-time-to-build-blocks.js
@@ -0,0 +1,58 @@
+/**
+ * @param {number[]} blocks
+ * @param {number} split
+ * @return {number}
+ */
+const minBuildTime = function (blocks, split) {
+  const minHeap = new MinHeap()
+  blocks.forEach((block) => minHeap.push(block))
+  while (minHeap.size() > 1) {
+    minHeap.pop()
+    minHeap.push(minHeap.pop() + split)
+  }
+  return minHeap.pop()
+}
+
+class MinHeap {
+  constructor() {
+    this.store = []
+  }
+  size() {
+    return this.store.length
+  }
+  push(value) {
+    this.store.push(value)
+    this.heapifyUp(this.store.length - 1)
+  }
+  pop() {
+    if (this.store.length < 2) return this.store.pop()
+    let result = this.store[0]
+    this.store[0] = this.store.pop()
+    this.heapifyDown(0)
+    return result
+  }
+  heapifyUp(child) {
+    const parent = Math.floor((child - 1) / 2)
+    if (child && this.store[child] < this.store[parent]) {
+      const temp = this.store[child]
+      this.store[child] = this.store[parent]
+      this.store[parent] = temp
+      this.heapifyUp(parent)
+    }
+  }
+  heapifyDown(parent) {
+    const childs = [1, 2]
+      .map((n) => parent * 2 + n)
+      .filter((n) => n < this.store.length)
+    let child = childs[0]
+    if (childs[1] && this.store[childs[1]] < this.store[child]) {
+      child = childs[1]
+    }
+    if (child && this.store[child] < this.store[parent]) {
+      const temp = this.store[child]
+      this.store[child] = this.store[parent]
+      this.store[parent] = temp
+      this.heapifyDown(child)
+    }
+  }
+}

From 05f1544e4a590560891e7716c38c09f0b4a825ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Aug 2020 09:58:48 +0800
Subject: [PATCH 0760/3374] Create
 1121-divide-array-into-increasing-sequences.js

---
 1121-divide-array-into-increasing-sequences.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1121-divide-array-into-increasing-sequences.js

diff --git a/1121-divide-array-into-increasing-sequences.js b/1121-divide-array-into-increasing-sequences.js
new file mode 100644
index 00000000..7dc7937b
--- /dev/null
+++ b/1121-divide-array-into-increasing-sequences.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} K
+ * @return {boolean}
+ */
+const canDivideIntoSubsequences = function (nums, K) {
+  let cur = 1,
+    groups = 1,
+    n = nums.length
+  for (let i = 1; i < n; ++i) {
+    cur = nums[i - 1] < nums[i] ? 1 : cur + 1
+    groups = Math.max(groups, cur)
+  }
+  return n >= K * groups
+}

From 051923888d0a68160bd39c2d4d227c7fe837f63a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Aug 2020 10:55:52 +0800
Subject: [PATCH 0761/3374] Create 1183-maximum-number-of-ones.js

---
 1183-maximum-number-of-ones.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1183-maximum-number-of-ones.js

diff --git a/1183-maximum-number-of-ones.js b/1183-maximum-number-of-ones.js
new file mode 100644
index 00000000..59126327
--- /dev/null
+++ b/1183-maximum-number-of-ones.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} width
+ * @param {number} height
+ * @param {number} sideLength
+ * @param {number} maxOnes
+ * @return {number}
+ */
+const maximumNumberOfOnes = function (width, height, sideLength, maxOnes) {
+  const n1 = (height / sideLength) >> 0,
+    h = height % sideLength,
+    n2 = (width / sideLength) >> 0,
+    w = width % sideLength
+  if (maxOnes <= w * h) return n1 * n2 * maxOnes + (n1 + n2 + 1) * maxOnes
+  else {
+    const a = h * w,
+      B = (sideLength - w) * h,
+      C = (sideLength - h) * w
+    let b = Math.min(B, maxOnes - a)
+    let c = Math.min(maxOnes - a - b, C)
+    const res1 = n1 * (a + c) + n2 * (a + b)
+    c = Math.min(C, maxOnes - a)
+    b = Math.min(maxOnes - a - c, B)
+    const res2 = n1 * (a + c) + n2 * (a + b)
+    return n1 * n2 * maxOnes + Math.max(res1, res2) + a
+  }
+}

From bc8c1960fd96c1a1f6a435906f1919904cbd18f2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Aug 2020 20:15:48 +0800
Subject: [PATCH 0762/3374] Create 1286-iterator-for-combination.js

---
 1286-iterator-for-combination.js | 43 ++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 1286-iterator-for-combination.js

diff --git a/1286-iterator-for-combination.js b/1286-iterator-for-combination.js
new file mode 100644
index 00000000..2357732c
--- /dev/null
+++ b/1286-iterator-for-combination.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} characters
+ * @param {number} combinationLength
+ */
+const CombinationIterator = function (characters, combinationLength) {
+  this.arr = build(combinationLength, characters.split('').sort().join(''))
+  this.pos = 0
+}
+
+/**
+ * @return {string}
+ */
+CombinationIterator.prototype.next = function () {
+  if (this.pos < this.arr.length) {
+    return this.arr[this.pos++]
+  }
+}
+
+/**
+ * @return {boolean}
+ */
+CombinationIterator.prototype.hasNext = function () {
+  return this.pos < this.arr.length
+}
+
+/**
+ * Your CombinationIterator object will be instantiated and called as such:
+ * var obj = new CombinationIterator(characters, combinationLength)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+function build(max, str, out = [], curr = '') {
+  if (curr.length === max) {
+    out.push(curr)
+    return
+  } else {
+    for (let i = 0; i < str.length; i++) {
+      build(max, str.slice(i + 1), out, curr + str[i])
+    }
+  }
+
+  return out
+}

From 28281f71e2b29fa6e3e8cb924be463e9bde72963 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Aug 2020 14:32:33 +0800
Subject: [PATCH 0763/3374] Create
 1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js

---
 ...ncrements-on-subarrays-to-form-a-target-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js

diff --git a/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js b/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js
new file mode 100644
index 00000000..10d9f567
--- /dev/null
+++ b/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} target
+ * @return {number}
+ */
+const minNumberOperations = function(target) {
+  let totalOperations = target[0];
+  for (let i = 1; i < target.length; ++i) {
+    if (target[i] > target[i-1]) {
+      totalOperations += target[i] - target[i-1];
+    }
+  }
+  return totalOperations;
+};

From 736f66a25f5714621b801ca1f0ea63078bd7c77b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Aug 2020 15:15:39 +0800
Subject: [PATCH 0764/3374] Update 409-longest-palindrome.js

---
 409-longest-palindrome.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/409-longest-palindrome.js b/409-longest-palindrome.js
index cb692360..0d67ad8a 100755
--- a/409-longest-palindrome.js
+++ b/409-longest-palindrome.js
@@ -1,3 +1,26 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestPalindrome = function (s) {
+  const set = new Set()
+  let counter = 0
+  for (let i = 0; i < s.length; i++) {
+    const currentChar = s[i]
+    if (set.has(currentChar)) {
+      counter++
+      set.delete(currentChar)
+    } else {
+      set.add(currentChar)
+    }
+  }
+  counter *= 2
+  if (set.size > 0) counter++
+  return counter
+}
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 4903b1d5c8bfc97a4cf762c81daae3c3dd6ed7d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Aug 2020 22:16:52 +0800
Subject: [PATCH 0765/3374] Create 972-equal-rational-numbers.js

---
 972-equal-rational-numbers.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 972-equal-rational-numbers.js

diff --git a/972-equal-rational-numbers.js b/972-equal-rational-numbers.js
new file mode 100644
index 00000000..43e91a5b
--- /dev/null
+++ b/972-equal-rational-numbers.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} S
+ * @param {string} T
+ * @return {boolean}
+ */
+const isRationalEqual = function (S, T) {
+  return f(S) === f(T)
+}
+
+function f(S) {
+  let i = S.indexOf('(')
+  if (i > 0) {
+    let base = S.slice(0, i)
+    let rep = S.slice(i + 1, S.length - 1)
+    for (let j = 0; j < 20; ++j) base += rep
+    return +base
+  }
+  return +S
+}

From ac37f7f9856f651c9292fa40b91507d04665c86f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Aug 2020 09:47:16 +0800
Subject: [PATCH 0766/3374] Create 1289-minimum-falling-path-sum-ii.js

---
 1289-minimum-falling-path-sum-ii.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1289-minimum-falling-path-sum-ii.js

diff --git a/1289-minimum-falling-path-sum-ii.js b/1289-minimum-falling-path-sum-ii.js
new file mode 100644
index 00000000..ed6d4244
--- /dev/null
+++ b/1289-minimum-falling-path-sum-ii.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[][]} arr
+ * @return {number}
+ */
+const minFallingPathSum = function (arr) {
+  const n = arr.length
+  for (let i = 1; i < n; i++) {
+    const [m1, m2] = [...arr[i - 1]].sort((a, b) => a - b).slice(0, 2)
+    for (j = 0; j < n; j++) {
+      arr[i][j] += arr[i - 1][j] !== m1 ? m1 : m2
+    }
+  }
+  return Math.min(...arr[n - 1])
+}

From d03165d613277298fb9d4023e5fecd2978e63ca5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Aug 2020 10:28:56 +0800
Subject: [PATCH 0767/3374] Update 1289-minimum-falling-path-sum-ii.js

---
 1289-minimum-falling-path-sum-ii.js | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/1289-minimum-falling-path-sum-ii.js b/1289-minimum-falling-path-sum-ii.js
index ed6d4244..2a5f07a7 100644
--- a/1289-minimum-falling-path-sum-ii.js
+++ b/1289-minimum-falling-path-sum-ii.js
@@ -5,10 +5,19 @@
 const minFallingPathSum = function (arr) {
   const n = arr.length
   for (let i = 1; i < n; i++) {
-    const [m1, m2] = [...arr[i - 1]].sort((a, b) => a - b).slice(0, 2)
+    const [m1, m2] = min2(arr[i - 1])
     for (j = 0; j < n; j++) {
       arr[i][j] += arr[i - 1][j] !== m1 ? m1 : m2
     }
   }
   return Math.min(...arr[n - 1])
 }
+
+function min2(arr) {
+  let m1 = Infinity, m2 = Infinity
+  arr.forEach(e => {
+    if(e < m1) m2 = m1, m1 = e
+    else if(e < m2) m2 = e
+  })
+  return [m1, m2]
+}

From df68b8a433587966b2426b7f7abc5af031449c2d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Aug 2020 09:09:27 +0800
Subject: [PATCH 0768/3374] Create
 1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js

---
 ...fter-at-most-k-adjacent-swaps-on-digits.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js

diff --git a/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js b/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js
new file mode 100644
index 00000000..5e928372
--- /dev/null
+++ b/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js
@@ -0,0 +1,62 @@
+/**
+ * @param {string} num
+ * @param {number} k
+ * @return {string}
+ */
+const minInteger = function (num, k) {
+  const nums = num.split("")
+  const map = {}
+  nums.forEach((n, i) => {
+    map[n] = map[n] || []
+    map[n].push(i)
+  })
+
+  const used = new Set()
+  const tree = new Fenwick(nums.length)
+  let idx = 0
+  let re = ""
+  while (k > 0 && idx < nums.length) {
+    for (let i = 0; i < 10; i++) {
+      if (!map[i] || !map[i].length) continue
+      const id = map[i][0]
+      const cost = id - tree.query(id)
+      if (k < cost) continue
+      re += nums[id]
+      k -= cost
+      used.add(id)
+      tree.update(id + 1, 1)
+      map[i].shift()
+      break
+    }
+    idx++
+  }
+
+  for (let i = 0; i < nums.length; i++) {
+    if (!used.has(i)) {
+      re += nums[i]
+    }
+  }
+
+  return re
+}
+class Fenwick {
+  constructor(n) {
+    this.sums = new Array(n + 1).fill(0)
+  }
+
+  update(i, delta) {
+    while (i < this.sums.length) {
+      this.sums[i] += delta
+      i += i & -i
+    }
+  }
+
+  query(i) {
+    let sum = 0
+    while (i > 0) {
+      sum += this.sums[i]
+      i -= i & -i
+    }
+    return sum
+  }
+}

From 41782ab0dd73a10cecb85e5562dc81865f1e2492 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Aug 2020 12:26:19 +0800
Subject: [PATCH 0769/3374] Update
 1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js

---
 ...fter-at-most-k-adjacent-swaps-on-digits.js | 50 ++++++++-----------
 1 file changed, 21 insertions(+), 29 deletions(-)

diff --git a/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js b/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js
index 5e928372..2812ff4a 100644
--- a/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js
+++ b/1505-minimum-possible-integer-after-at-most-k-adjacent-swaps-on-digits.js
@@ -4,36 +4,28 @@
  * @return {string}
  */
 const minInteger = function (num, k) {
-  const nums = num.split("")
-  const map = {}
-  nums.forEach((n, i) => {
-    map[n] = map[n] || []
-    map[n].push(i)
-  })
-
-  const used = new Set()
+  const nums = num.split('')
+  const len = nums.length
+  const q = Array(10)
+    .fill(null)
+    .map(() => [])
+  nums.forEach((n, i) => q[+n].push(i))
   const tree = new Fenwick(nums.length)
-  let idx = 0
-  let re = ""
-  while (k > 0 && idx < nums.length) {
-    for (let i = 0; i < 10; i++) {
-      if (!map[i] || !map[i].length) continue
-      const id = map[i][0]
-      const cost = id - tree.query(id)
-      if (k < cost) continue
-      re += nums[id]
-      k -= cost
-      used.add(id)
-      tree.update(id + 1, 1)
-      map[i].shift()
-      break
-    }
-    idx++
-  }
-
-  for (let i = 0; i < nums.length; i++) {
-    if (!used.has(i)) {
-      re += nums[i]
+  for (let i = 1; i <= len; i++) tree.update(i, 1)
+  let re = ''
+  for (let i = 0; i < len; i++) {
+    for (let j = 0; j <= 9; j++) {
+      const idxArr = q[j]
+      if (idxArr && idxArr.length) {
+        const idx = idxArr[0]
+        const num = tree.query(idx)
+        if (num > k) continue
+        k -= num
+        idxArr.shift()
+        tree.update(idx + 1, -1)
+        re += j
+        break
+      }
     }
   }
 

From 05e8682373c86f7e175f2e114ae8b40df42980d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Aug 2020 10:48:16 +0800
Subject: [PATCH 0770/3374] Create 1547-minimum-cost-to-cut-a-stick.js

---
 1547-minimum-cost-to-cut-a-stick.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1547-minimum-cost-to-cut-a-stick.js

diff --git a/1547-minimum-cost-to-cut-a-stick.js b/1547-minimum-cost-to-cut-a-stick.js
new file mode 100644
index 00000000..beecd07a
--- /dev/null
+++ b/1547-minimum-cost-to-cut-a-stick.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number[]} cuts
+ * @return {number}
+ */
+const minCost = function(n, cuts) {
+  const x = 100 + 2
+  const dp = Array.from({ length: x }, () => Array(x).fill(0))
+  cuts.push(0, n)
+  cuts.sort((a, b) => a - b)
+  const res = dfs(0, cuts.length - 1)
+  return res
+  function dfs(i, j) {
+    if(j - i <= 1) return 0
+    if(!dp[i][j]) {
+      dp[i][j] = Number.MAX_VALUE
+      for(let k = i + 1; k < j; k++) {
+        dp[i][j] = Math.min(dp[i][j], cuts[j] - cuts[i] + dfs(i, k) + dfs(k, j))
+      }
+    }
+    return dp[i][j]
+  }
+};

From 2de8e0d5f6a58e80ee27d2cb153405c5a4067ecd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Aug 2020 17:40:15 +0800
Subject: [PATCH 0771/3374] Create
 1553-minimum-number-of-days-to-eat-n-oranges.js

---
 1553-minimum-number-of-days-to-eat-n-oranges.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1553-minimum-number-of-days-to-eat-n-oranges.js

diff --git a/1553-minimum-number-of-days-to-eat-n-oranges.js b/1553-minimum-number-of-days-to-eat-n-oranges.js
new file mode 100644
index 00000000..dadb5d5c
--- /dev/null
+++ b/1553-minimum-number-of-days-to-eat-n-oranges.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minDays = function (n, dp = {}) {
+  if (n <= 1) return n
+  if (dp[n] == null)
+    dp[n] =
+      1 +
+      Math.min(
+        (n % 2) + minDays((n / 2) >> 0, dp),
+        (n % 3) + minDays((n / 3) >> 0, dp)
+      )
+  return dp[n]
+}

From f474595effff8860582029936b0da7f3e955803f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Aug 2020 21:04:22 +0800
Subject: [PATCH 0772/3374] Create 1499-max-value-of-equation.js

---
 1499-max-value-of-equation.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1499-max-value-of-equation.js

diff --git a/1499-max-value-of-equation.js b/1499-max-value-of-equation.js
new file mode 100644
index 00000000..12d64905
--- /dev/null
+++ b/1499-max-value-of-equation.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+const findMaxValueOfEquation = function (points, k) {
+  let res = -Number.MAX_VALUE
+  const deque = []
+  for (let i = 0; i < points.length; i++) {
+    const x = points[i][0]
+    const y = points[i][1]
+    while (deque.length != 0 && x - deque[0][1] > k) {
+      deque.shift()
+    }
+    if (deque.length != 0) {
+      res = Math.max(res, deque[0][0] + x + y)
+    }
+    while (deque.length != 0 && deque[deque.length - 1][0] <= y - x) {
+      deque.pop()
+    }
+    deque.push([y - x, x])
+  }
+  return res
+}

From e470b1c489619a8773fa93298e9f8654c790c406 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Aug 2020 21:46:26 +0800
Subject: [PATCH 0773/3374] Update 1499-max-value-of-equation.js

---
 1499-max-value-of-equation.js | 92 +++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)

diff --git a/1499-max-value-of-equation.js b/1499-max-value-of-equation.js
index 12d64905..d005a055 100644
--- a/1499-max-value-of-equation.js
+++ b/1499-max-value-of-equation.js
@@ -22,3 +22,95 @@ const findMaxValueOfEquation = function (points, k) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+const findMaxValueOfEquation = function (points, k) {
+  const pq = new PriorityQueue((a, b) =>
+    a[0] === b[0] ? a[1] < b[1] : b[0] < a[0]
+  )
+  let res = -Infinity
+  for (let point of points) {
+    while (!pq.isEmpty() && point[0] - pq.peek()[1] > k) {
+      pq.pop()
+    }
+    if (!pq.isEmpty()) {
+      res = Math.max(res, pq.peek()[0] + point[0] + point[1])
+    }
+    pq.push([point[1] - point[0], point[0]])
+  }
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 3a92f5f1383eb7e9949a3eff0166674ea70efdfc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Aug 2020 08:43:58 +0800
Subject: [PATCH 0774/3374] Create 1537-get-the-maximum-score.js

---
 1537-get-the-maximum-score.js | 72 +++++++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 1537-get-the-maximum-score.js

diff --git a/1537-get-the-maximum-score.js b/1537-get-the-maximum-score.js
new file mode 100644
index 00000000..40ce2fca
--- /dev/null
+++ b/1537-get-the-maximum-score.js
@@ -0,0 +1,72 @@
+/**
+
+You are given two sorted arrays of distinct integers nums1 and nums2.
+
+A valid path is defined as follows:
+
+Choose array nums1 or nums2 to traverse (from index-0).
+Traverse the current array from left to right.
+If you are reading any value that is present in nums1 and nums2 you are
+allowed to change your path to the other array.
+(Only one repeated value is considered in the valid path).
+Score is defined as the sum of uniques values in a valid path.
+
+Return the maximum score you can obtain of all possible valid paths.
+
+Since the answer may be too large, return it modulo 10^9 + 7.
+
+Example 1:
+
+Input: nums1 = [2,4,5,8,10], nums2 = [4,6,8,9]
+Output: 30
+Explanation: Valid paths:
+[2,4,5,8,10], [2,4,5,8,9], [2,4,6,8,9], [2,4,6,8,10],  (starting from nums1)
+[4,6,8,9], [4,5,8,10], [4,5,8,9], [4,6,8,10]    (starting from nums2)
+The maximum is obtained with the path in green [2,4,6,8,10].
+
+Example 2:
+
+Input: nums1 = [1,3,5,7,9], nums2 = [3,5,100]
+Output: 109
+Explanation: Maximum sum is obtained with the path [1,3,5,100].
+Example 3:
+
+Input: nums1 = [1,2,3,4,5], nums2 = [6,7,8,9,10]
+Output: 40
+Explanation: There are no common elements between nums1 and nums2.
+Maximum sum is obtained with the path [6,7,8,9,10].
+Example 4:
+
+Input: nums1 = [1,4,5,8,9,11,19], nums2 = [2,3,4,11,12]
+Output: 61
+ 
+
+Constraints:
+
+1 <= nums1.length <= 10^5
+1 <= nums2.length <= 10^5
+1 <= nums1[i], nums2[i] <= 10^7
+nums1 and nums2 are strictly increasing.
+
+*/
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maxSum = function(nums1, nums2) {
+  let i = 0, j = 0, n = nums1.length, m = nums2.length;
+  let a = 0, b = 0, mod = 10 ** 9 + 7;
+  while (i < n || j < m) {
+    if (i < n && (j === m || nums1[i] < nums2[j])) {
+      a += nums1[i++];
+    } else if (j < m && (i === n || nums1[i] > nums2[j])) {
+      b += nums2[j++];
+    } else {
+      a = b = Math.max(a, b) + nums1[i];
+      i++; j++;
+    }
+  }
+  return Math.max(a, b) % mod;
+};

From faee2868a696b196eafdf7ff4157158feec42bac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Aug 2020 13:00:45 +0800
Subject: [PATCH 0775/3374] Create 1542-find-longest-awesome-substring.js

---
 1542-find-longest-awesome-substring.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1542-find-longest-awesome-substring.js

diff --git a/1542-find-longest-awesome-substring.js b/1542-find-longest-awesome-substring.js
new file mode 100644
index 00000000..a4597cc6
--- /dev/null
+++ b/1542-find-longest-awesome-substring.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestAwesome = function (s) {
+  const dp = new Array(1024).fill(s.length)
+  let res = 0,
+    mask = 0
+  dp[0] = -1
+  for (let i = 0; i < s.length; ++i) {
+    mask ^= 1 << +s.charAt(i)
+    res = Math.max(res, i - dp[mask])
+    for (let j = 0; j <= 9; ++j) res = Math.max(res, i - dp[mask ^ (1 << j)])
+    dp[mask] = Math.min(dp[mask], i)
+  }
+  return res
+}

From 92167c9c0479a24add09cc5cc63b551027a104d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Aug 2020 09:39:08 +0800
Subject: [PATCH 0776/3374] Create 1531-string-compression-ii.js

---
 1531-string-compression-ii.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1531-string-compression-ii.js

diff --git a/1531-string-compression-ii.js b/1531-string-compression-ii.js
new file mode 100644
index 00000000..d018a102
--- /dev/null
+++ b/1531-string-compression-ii.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const getLengthOfOptimalCompression = function(s, k) {
+  const m = new Map()
+  function counter(start, last, lastCount, left) {
+    if(left < 0) return Infinity
+    if(start >= s.length) return 0
+    let res
+    const k = `${start}-${last}-${lastCount}-${left}`
+    if(m.has(k)) return m.get(k)
+    if(s[start] === last) {
+      const incr = (lastCount === 1 || lastCount === 9 || lastCount === 99) ? 1 : 0
+      res = incr + counter(start + 1, last, lastCount + 1, left)
+    } else {
+      const keepCounter = 1 + counter(start + 1, s[start], 1, left)
+      const delCounter = counter(start + 1, last,  lastCount, left - 1)
+      res = Math.min(keepCounter, delCounter)
+    }
+    m.set(k, res)
+    return res
+  }
+  return counter(0, '', 0, k)
+};

From 8470ed5ec7d343dd38583583d52e56bc4a338257 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Aug 2020 10:11:05 +0800
Subject: [PATCH 0777/3374] Update 1531-string-compression-ii.js

---
 1531-string-compression-ii.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1531-string-compression-ii.js b/1531-string-compression-ii.js
index d018a102..31a2e728 100644
--- a/1531-string-compression-ii.js
+++ b/1531-string-compression-ii.js
@@ -24,3 +24,38 @@ const getLengthOfOptimalCompression = function(s, k) {
   }
   return counter(0, '', 0, k)
 };
+
+// another
+
+const getLengthOfOptimalCompression = function (s, k) {
+  const n = s.length
+  const dp = new Array(n + 1).fill(n).map((row) => new Array(k + 1).fill(n))
+  dp[0][0] = 0
+
+  for (let i = 1; i <= n; i++) {
+    for (let j = 0; j <= k; j++) {
+      let letterCount = 0
+      let deletion = 0
+      // keep s[i], compress same letters, remove different letters
+      for (let l = i; l >= 1; l--) {
+        if (s.charAt(l - 1) === s.charAt(i - 1)) letterCount++
+        else deletion++
+        // places = length needed to rep compressed letters.
+        // 0 places for count = 1,0, 1 place = <10, 10-99 requires 2 places, 100+ requires 3
+        let places = 0
+        if (letterCount >= 100) places = 3
+        else if (letterCount >= 10) places = 2
+        else if (letterCount >= 2) places = 1
+        if (j - deletion >= 0) {
+          dp[i][j] = Math.min(dp[i][j], dp[l - 1][j - deletion] + 1 + places)
+        }
+      }
+      // delete
+      if (j > 0) {
+        dp[i][j] = Math.min(dp[i][j], dp[i - 1][j - 1])
+      }
+    }
+  }
+  return dp[n][k]
+}
+

From 7e0cf253a7364ab1adf5278a983472804ff99ced Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Aug 2020 12:25:10 +0800
Subject: [PATCH 0778/3374] Create 1479-sales-by-day-of-the-week.sql

---
 1479-sales-by-day-of-the-week.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1479-sales-by-day-of-the-week.sql

diff --git a/1479-sales-by-day-of-the-week.sql b/1479-sales-by-day-of-the-week.sql
new file mode 100644
index 00000000..8e4fb92a
--- /dev/null
+++ b/1479-sales-by-day-of-the-week.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT i.item_category AS Category,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 2 THEN quantity ELSE 0 END) AS Monday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 3 THEN quantity ELSE 0 END) AS Tuesday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 4 THEN quantity ELSE 0 END) AS Wednesday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 5 THEN quantity ELSE 0 END) AS Thursday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 6 THEN quantity ELSE 0 END) AS Friday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 7 THEN quantity ELSE 0 END) AS Saturday,
+    SUM(CASE WHEN DAYOFWEEK(o.order_date) = 1 THEN quantity ELSE 0 END) AS Sunday
+FROM Items i
+LEFT JOIN Orders o
+ON i.item_id = o.item_id
+GROUP BY i.item_category
+ORDER BY i.item_category;

From 89db8e81737942e2e9126f957c6be2694f3d89ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Aug 2020 09:08:29 +0800
Subject: [PATCH 0779/3374] Create
 1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js

---
 ...allest-sum-of-a-matrix-with-sorted-rows.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js

diff --git a/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
new file mode 100644
index 00000000..6d161da1
--- /dev/null
+++ b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} k
+ * @return {number}
+ */
+const kthSmallest = function(mat, k) {
+  let lo = 0;
+  let hi = 0;
+  for(let r of mat) {
+    lo += r[0];
+    hi += r[r.length-1];
+  }
+
+  const check = (row, sum, limit) => {
+    if (sum > limit) return 0;
+    if (row === mat.length) return 1;
+    let totalcnt = 0;
+    for(let v of mat[row]) {
+      let cnt = check(row+1, v+sum, limit);
+      totalcnt += cnt;
+      if (cnt === 0 || totalcnt > k) break;  
+    }
+    
+    return totalcnt;
+  };
+
+  while(lo <= hi) {
+    let m = Math.floor((lo+hi)/2);
+    let cnt = check(0,0,m);
+    if (cnt < k) {
+      lo = m+1;
+    } else {
+      hi = m-1;
+    }
+  }
+
+  return lo;
+};

From 98ce934ce92499690da192ddb661023227330483 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Aug 2020 09:42:58 +0800
Subject: [PATCH 0780/3374] Update
 1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js

---
 ...e-kth-smallest-sum-of-a-matrix-with-sorted-rows.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
index 6d161da1..249cfbc6 100644
--- a/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
+++ b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
@@ -16,21 +16,20 @@ const kthSmallest = function(mat, k) {
     if (row === mat.length) return 1;
     let totalcnt = 0;
     for(let v of mat[row]) {
-      let cnt = check(row+1, v+sum, limit);
+      const cnt = check(row + 1, v + sum, limit);
       totalcnt += cnt;
       if (cnt === 0 || totalcnt > k) break;  
     }
-    
     return totalcnt;
   };
 
   while(lo <= hi) {
-    let m = Math.floor((lo+hi)/2);
-    let cnt = check(0,0,m);
+    const m = (lo + (hi - lo) / 2) >> 0;
+    const cnt = check(0, 0, m);
     if (cnt < k) {
-      lo = m+1;
+      lo = m + 1;
     } else {
-      hi = m-1;
+      hi = m - 1;
     }
   }
 

From b8d7d69d68f38aaa205ea90dd31f52bb4da31573 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Aug 2020 10:57:28 +0800
Subject: [PATCH 0781/3374] Create 1510-stone-game-iv.js

---
 1510-stone-game-iv.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1510-stone-game-iv.js

diff --git a/1510-stone-game-iv.js b/1510-stone-game-iv.js
new file mode 100644
index 00000000..e361b64f
--- /dev/null
+++ b/1510-stone-game-iv.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const winnerSquareGame = function(n) {
+  const dp = new Array(n + 1).fill(0);
+  for (let i = 1; i <= n; ++i) {
+    for (let k = 1; k * k <= i; ++k) {
+      if (!dp[i - k * k]) {
+        dp[i] = true;
+        break;
+      }
+    }
+  }
+  return dp[n];
+};

From d4c69a93f2d34a7355820330f1e87527bdfc8f12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Aug 2020 10:59:22 +0800
Subject: [PATCH 0782/3374] Create 1369-get-the-second-most-recent-activity.sql

---
 1369-get-the-second-most-recent-activity.sql | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1369-get-the-second-most-recent-activity.sql

diff --git a/1369-get-the-second-most-recent-activity.sql b/1369-get-the-second-most-recent-activity.sql
new file mode 100644
index 00000000..ce0fc64f
--- /dev/null
+++ b/1369-get-the-second-most-recent-activity.sql
@@ -0,0 +1,14 @@
+# Write your MySQL query statement below
+SELECT * 
+FROM UserActivity 
+GROUP BY username 
+HAVING COUNT(*) = 1
+
+UNION ALL
+
+SELECT u1.*
+FROM UserActivity u1 
+LEFT JOIN UserActivity u2 
+    ON u1.username = u2.username AND u1.endDate < u2.endDate
+GROUP BY u1.username, u1.endDate
+HAVING COUNT(u2.endDate) = 1;

From 36ea6545c6b352a721c1a27ce291e4f1afec751d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Aug 2020 11:29:02 +0800
Subject: [PATCH 0783/3374] Create 975-odd-even-jump.js

---
 975-odd-even-jump.js | 52 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 975-odd-even-jump.js

diff --git a/975-odd-even-jump.js b/975-odd-even-jump.js
new file mode 100644
index 00000000..2ffee5c4
--- /dev/null
+++ b/975-odd-even-jump.js
@@ -0,0 +1,52 @@
+/**
+ * @param {number[]} A
+ * @return {number}
+ */
+const oddEvenJumps = function (A) {
+  // Creates an array with ONLY the indices of the sorted array
+  let sorted = A.map((el, idx) => idx).sort((a, b) => A[a] - A[b] || a - b)
+  // Create an array of '-1's of the same array length for odd and even jumps
+  let oddJumps = new Array(A.length).fill(-1)
+  let evenJumps = new Array(A.length).fill(-1)
+  // Create an empty stack
+  let stack = []
+  // Loop the the sorted array of the indices
+  for (let i of sorted) {
+    // Loops as long the stack is full OR if the index is greater than the the last index of the stack
+    while (stack.length && i > stack[stack.length - 1]) {
+      // Pops the index from the stack and place and add the 'i' index in sortedJumps
+      oddJumps[stack.pop()] = i
+    }
+    // Pushes the index onto the stack
+    stack.push(i)
+  }
+  // Empty the stack
+  stack = []
+  // Reverses the sorted index array
+  let reverseSorted = sorted.sort((a, b) => A[b] - A[a] || a - b)
+  // Does the exact thing but for even jumps
+  for (let i of reverseSorted) {
+    while (stack.length && i > stack[stack.length - 1]) {
+      evenJumps[stack.pop()] = i
+    }
+    stack.push(i)
+  }
+  // Starts the count at 0
+  let count = 1
+  // Creates a boolean array of false elements for even and odd ends
+  let oddEnd = new Array(A.length).fill(false)
+  let evenEnd = new Array(A.length).fill(false)
+  // Switches the end of each array to true
+  oddEnd[A.length - 1] = true
+  evenEnd[A.length - 1] = true
+  // Loops through the array, starting from the 2nd from the right (since we do not need to worry about       the last index)
+  for (let i = A.length - 2; i >= 0; --i) {
+    // If even jumps does
+    if (evenJumps[i] !== -1 && oddEnd[evenJumps[i]]) evenEnd[i] = true
+    if (oddJumps[i] !== -1 && evenEnd[oddJumps[i]]) {
+      oddEnd[i] = true
+      count++
+    }
+  }
+  return count
+}

From 25ded1488d8cf20641f0a22fb42f64c70cb0b3f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Aug 2020 10:20:18 +0800
Subject: [PATCH 0784/3374] Create 1377-frog-position-after-t-seconds.js

---
 1377-frog-position-after-t-seconds.js | 42 +++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 1377-frog-position-after-t-seconds.js

diff --git a/1377-frog-position-after-t-seconds.js b/1377-frog-position-after-t-seconds.js
new file mode 100644
index 00000000..e9e807f4
--- /dev/null
+++ b/1377-frog-position-after-t-seconds.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} t
+ * @param {number} target
+ * @return {number}
+ */
+const frogPosition = function (n, edges, t, target) {
+  const graph = { 1: new Set() }
+  for (let [from, to] of edges) {
+    if (graph[from]) graph[from].add(to)
+    else graph[from] = new Set([to])
+    if (graph[to]) graph[to].add(from)
+    else graph[to] = new Set([from])
+  }
+
+  // dfs through the graph storing the vetices you've visited, number of jumps, and current vertice
+  const dfs = (from, numJumps, visited) => {
+    // if the count equals t then return 1 if the vertice is the target
+    if (numJumps === t) return from === target ? 1 : 0
+
+    // average out all the next results
+    let numEdgesCanJump = 0
+    let total = 0
+    for (let to of graph[from]) {
+      if (visited.has(to)) continue
+      visited.add(to)
+      total += dfs(to, numJumps + 1, visited)
+      visited.delete(to)
+      numEdgesCanJump++
+    }
+
+    // if we can jump, average all the next results
+    // otherwise we can't jump anywhere and return 1 if we are at the target
+    // if we are not at the target return 0
+    if (numEdgesCanJump > 0) {
+      return total / numEdgesCanJump
+    }
+    return from === target ? 1 : 0
+  }
+  return dfs(1, 0, new Set([1]))
+}

From 94fe41ddf0a19504655be8587a5f2a4ff1a2576e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Aug 2020 11:08:44 +0800
Subject: [PATCH 0785/3374] Update 1377-frog-position-after-t-seconds.js

---
 1377-frog-position-after-t-seconds.js | 41 +++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/1377-frog-position-after-t-seconds.js b/1377-frog-position-after-t-seconds.js
index e9e807f4..dd3dabc6 100644
--- a/1377-frog-position-after-t-seconds.js
+++ b/1377-frog-position-after-t-seconds.js
@@ -1,3 +1,44 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} t
+ * @param {number} target
+ * @return {number}
+ */
+const frogPosition = function (n, edges, t, target) {
+  const m = new Map()
+  for(let e of edges) {
+    const [from, to] = e
+    if(!m.has(from - 1)) m.set(from - 1, [])
+    if(!m.has(to - 1)) m.set(to - 1, [])
+    m.get(from - 1).push(to - 1)
+    m.get(to - 1).push(from - 1)
+  }
+  const visited = new Set()
+  visited.add(0)
+  const q = [0]
+  const res = [1]
+  while(q.length && t-- > 0) {
+    for(let size = q.length; size > 0 ; size--) {
+      const u = q.shift()
+      let count = 0
+      for(let e of (m.get(u) || [])) {
+        if(!visited.has(e)) count++
+      }
+      for(let e of (m.get(u) || [])) {
+        if(visited.has(e)) continue
+        q.push(e)
+        visited.add(e)
+        res[e] = res[u] / count
+      }
+      if(count > 0) res[u] = 0      
+    }
+  }
+  return res[target - 1] || 0
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 6a60cdad5e4a6839b069ee90b5acde7c7a6ae985 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Aug 2020 09:16:21 +0800
Subject: [PATCH 0786/3374] Create 1559-detect-cycles-in-2d-grid.js

---
 1559-detect-cycles-in-2d-grid.js | 53 ++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 1559-detect-cycles-in-2d-grid.js

diff --git a/1559-detect-cycles-in-2d-grid.js b/1559-detect-cycles-in-2d-grid.js
new file mode 100644
index 00000000..a43bd88c
--- /dev/null
+++ b/1559-detect-cycles-in-2d-grid.js
@@ -0,0 +1,53 @@
+/**
+ * @param {character[][]} grid
+ * @return {boolean}
+ */
+const containsCycle = function (grid) {
+  const wholePath = (r, c, letter, component, last = [-1, -1]) => {
+    const dirs = [
+      [0, -1],
+      [0, 1],
+      [-1, 0],
+      [1, 0],
+    ]
+    const tmp = grid[r][c]
+    grid[r][c] = component
+    const nextSteps = dirs
+      .map((x) => [x[0] + r, x[1] + c])
+      .filter(
+        (x) =>
+          x[0] >= 0 && x[0] < grid.length && x[1] >= 0 && x[1] < grid[0].length
+      )
+    for (let step of nextSteps) {
+      if (step[0] === last[0] && last[1] === step[1]) {
+        continue
+      }
+      if (grid[step[0]][step[1]] === component) {
+        return true
+      }
+      if (grid[step[0]][step[1]] === letter) {
+        let outcome = wholePath(step[0], step[1], letter, component, [r, c])
+        if (outcome) {
+          return true
+        }
+      }
+    }
+    return false
+  }
+
+  let component = 1
+  for (let r = 0; r < grid.length; r++) {
+    for (let c = 0; c < grid[0].length; c++) {
+      const letter = grid[r][c]
+      if (typeof letter === 'string') {
+        grid[r][c] = component
+        const outcome = wholePath(r, c, letter, component)
+        if (outcome) {
+          return true
+        }
+        component++
+      }
+    }
+  }
+  return false
+}

From d0fba6c9d809edceb929d1e9170273afa6b9fc7f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Aug 2020 10:36:35 +0800
Subject: [PATCH 0787/3374] Update 1559-detect-cycles-in-2d-grid.js

---
 1559-detect-cycles-in-2d-grid.js | 48 ++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1559-detect-cycles-in-2d-grid.js b/1559-detect-cycles-in-2d-grid.js
index a43bd88c..a3666072 100644
--- a/1559-detect-cycles-in-2d-grid.js
+++ b/1559-detect-cycles-in-2d-grid.js
@@ -1,3 +1,51 @@
+/**
+ * @param {character[][]} grid
+ * @return {boolean}
+ */
+const containsCycle = function (grid) {
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+  ]
+  const rows = grid.length
+  const cols = (grid[0] || []).length
+  const vis = Array.from({ length: rows }, () => Array(cols).fill(false))
+  let res = false
+  const dfs = (i, j, prevR, prevC, char) => {
+    vis[i][j] = true
+    for (let d of dirs) {
+      const r = i + d[0]
+      const c = j + d[1]
+      if (r >= 0 && r < rows && c >= 0 && c < cols) {
+        if (!(r == prevR && c === prevC)) {
+          if (grid[r][c] === char) {
+            if (!vis[r][c]) {
+              if (dfs(r, c, i, j, char)) return true
+            } else {
+              if (prevR !== -1 && prevC !== -1) return true
+            }
+          }
+        }
+      }
+    }
+    return false
+  }
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (!vis[i][j]) {
+        res |= dfs(i, j, -1, -1, grid[i][j])
+      }
+      if (res) return true
+    }
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {character[][]} grid
  * @return {boolean}

From 90036dfe36f179ba1b9e435c9febbe12534b0b51 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Aug 2020 13:07:38 +0800
Subject: [PATCH 0788/3374] Create
 1412-find-the-quiet-students-in-all-exams.sql

---
 1412-find-the-quiet-students-in-all-exams.sql | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1412-find-the-quiet-students-in-all-exams.sql

diff --git a/1412-find-the-quiet-students-in-all-exams.sql b/1412-find-the-quiet-students-in-all-exams.sql
new file mode 100644
index 00000000..dd9c37ca
--- /dev/null
+++ b/1412-find-the-quiet-students-in-all-exams.sql
@@ -0,0 +1,11 @@
+# Write your MySQL query statement below
+WITH cte AS(
+    SELECT exam_id, exam.student_id, student_name, score, RANK() OVER(PARTITION BY exam_id ORDER BY score) rk1, RANK() OVER(PARTITION BY exam_id ORDER BY score DESC) rk2 
+    FROM exam LEFT JOIN student
+    ON exam.student_id = student.student_id
+)
+
+SELECT DISTINCT student_id, student_name
+FROM cte
+WHERE student_id NOT IN (SELECT student_id FROM cte WHERE rk1 = 1 or rk2 = 1)
+ORDER BY student_id;

From 2a860b5468b1636fc2ed4f0e5e88e91e308da2ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Aug 2020 21:11:36 +0800
Subject: [PATCH 0789/3374] Create 1001-grid-illumination.js

---
 1001-grid-illumination.js | 67 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 1001-grid-illumination.js

diff --git a/1001-grid-illumination.js b/1001-grid-illumination.js
new file mode 100644
index 00000000..2275a29d
--- /dev/null
+++ b/1001-grid-illumination.js
@@ -0,0 +1,67 @@
+/**
+ * @param {number} N
+ * @param {number[][]} lamps
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const gridIllumination = function (N, lamps, queries) {
+  const rowMap = new Map()
+  const colMap = new Map()
+  const hillMap = new Map()
+  const daleMap = new Map()
+  const litMap = new Map()
+  const direction = [
+    [0, 0],
+    [0, 1],
+    [1, 0],
+    [-1, 0],
+    [0, -1],
+    [-1, -1],
+    [1, 1],
+  ]
+  //map what areas are lit
+  for (let [x, y] of lamps) {
+    insert(rowMap, x)
+    insert(colMap, y)
+    insert(hillMap, x + y)
+    insert(daleMap, x - y)
+    litMap.set(N * x + y, true)
+  }
+  const result = new Array(queries.length).fill(0)
+  let count = 0
+  for (let [x, y] of queries) {
+    if (
+      rowMap.get(x) > 0 ||
+      colMap.get(y) > 0 ||
+      hillMap.get(x + y) > 0 ||
+      daleMap.get(x - y) > 0
+    ) {
+      result[count] = 1
+    }
+    for (let [i, j] of direction) {
+      let newX = x + i
+      let newY = y + j
+      if (litMap.has(N * newX + newY)) {
+        decrease(rowMap, newX)
+        decrease(colMap, newY)
+        decrease(hillMap, newX + newY)
+        decrease(daleMap, N * newX + newY)
+        litMap.delete(N * newX + newY)
+      }
+    }
+    count++
+  }
+  return result
+}
+const insert = (map, value) => {
+  if (map.has(value)) {
+    map.set(value, map.get(value) + 1)
+  } else {
+    map.set(value, 1)
+  }
+}
+const decrease = (map, value) => {
+  if (map.has(value)) {
+    map.set(value, map.get(value) - 1)
+  }
+}

From 8934d9b2019bcbd01db4f7bf4cea29bd9ee614f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Aug 2020 09:09:24 +0800
Subject: [PATCH 0790/3374] Create 1494-parallel-courses-ii.js

---
 1494-parallel-courses-ii.js | 50 +++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1494-parallel-courses-ii.js

diff --git a/1494-parallel-courses-ii.js b/1494-parallel-courses-ii.js
new file mode 100644
index 00000000..af6c6a1d
--- /dev/null
+++ b/1494-parallel-courses-ii.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number} n
+ * @param {number[][]} dependencies
+ * @param {number} k
+ * @return {number}
+ */
+const minNumberOfSemesters = function (n, dependencies, k) {
+  const preq = new Array(n).fill(0)
+  for (let dep of dependencies) {
+    // to study j, what are the prerequisites?
+    // each set bit is a class that we need to take. ith bit means ith class
+    // -1 because classes are 1 to n
+    preq[dep[1] - 1] |= 1 << (dep[0] - 1)
+  }
+  const dp = new Array(1 << n).fill(n)
+  dp[0] = 0
+  for (let i = 0; i < 1 << n; i++) {
+    // we are now at status i. we can "influence" a later status from this status
+    let canStudy = 0 // what are the classes we can study?
+    for (let j = 0; j < n; j++) {
+      // a & b== b means b is a's subset
+      // so if preq[j] is i's subset, we can now study j given status i
+      if ((i & preq[j]) == preq[j]) {
+        canStudy |= 1 << j
+      }
+    }
+    canStudy &= ~i
+    // take out i, so that we only enumerate a subset canStudy without i.
+    // note we will | later so here we need a set that has no
+    // intersection with i to reduce the enumeration cost
+    for (let sub = canStudy; sub > 0; sub = (sub - 1) & canStudy) {
+      // we can study one or more courses indicated by set "canStudy".
+      // we need to enumerate all non empty subset of it.
+      // This for loop is a typical way to enumerate all subsets of a given set "canStudy"
+      // we studied i using dp[i] semesters. now if we also study the
+      // subset sub, we need dp [i ]+1 semesters,
+      // and the status we can "influence" is dp[ i | sub] because at
+      // that state, we studied what we want to study in "sub"
+      if (bitCount(sub) <= k) {
+        dp[i | sub] = Math.min(dp[i | sub], dp[i] + 1)
+      }
+    }
+  }
+  return dp[(1 << n) - 1]
+}
+function bitCount(n) {
+  n = n - ((n >> 1) & 0x55555555)
+  n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
+  return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24
+}

From 2fe8f3e6918e666c94ff62474cab478adb298c74 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Aug 2020 09:01:20 +0800
Subject: [PATCH 0791/3374] Create 1194-tournament-winners.sql

---
 1194-tournament-winners.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1194-tournament-winners.sql

diff --git a/1194-tournament-winners.sql b/1194-tournament-winners.sql
new file mode 100644
index 00000000..99365396
--- /dev/null
+++ b/1194-tournament-winners.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+select group_id, player_id from (
+	select p.group_id, ps.player_id, sum(ps.score) as score from Players p,
+	    (select first_player as player_id, first_score as score from Matches
+	    union all
+	    select second_player, second_score from Matches) ps
+	where p.player_id = ps.player_id
+	group by ps.player_id order by group_id, score desc, player_id) top_scores
+group by group_id;

From 2f171dbaae4321942f8352aba0568153b68afc14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Aug 2020 09:24:51 +0800
Subject: [PATCH 0792/3374] Create 1458-max-dot-product-of-two-subsequences.js

---
 1458-max-dot-product-of-two-subsequences.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1458-max-dot-product-of-two-subsequences.js

diff --git a/1458-max-dot-product-of-two-subsequences.js b/1458-max-dot-product-of-two-subsequences.js
new file mode 100644
index 00000000..6b633bb3
--- /dev/null
+++ b/1458-max-dot-product-of-two-subsequences.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maxDotProduct = function (nums1, nums2) {
+  const n = nums1.length
+  const m = nums2.length
+  const dp = Array.from({ length: n + 1 }, () => Array(m + 1).fill(-Infinity))
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= m; j++) {
+      dp[i][j] = Math.max(
+        nums1[i - 1] * nums2[j - 1],
+        dp[i - 1][j - 1] + nums1[i - 1] * nums2[j - 1],
+        dp[i - 1][j],
+        dp[i][j - 1]
+      )
+    }
+  }
+  return dp[n][m]
+}

From 2d5ecb4e1e3205ded12155a0a7ea3a161a0c36bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Aug 2020 10:11:27 +0800
Subject: [PATCH 0793/3374] Create
 1203-sort-items-by-groups-respecting-dependencies.js

---
 ...items-by-groups-respecting-dependencies.js | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 1203-sort-items-by-groups-respecting-dependencies.js

diff --git a/1203-sort-items-by-groups-respecting-dependencies.js b/1203-sort-items-by-groups-respecting-dependencies.js
new file mode 100644
index 00000000..e0e9ac0a
--- /dev/null
+++ b/1203-sort-items-by-groups-respecting-dependencies.js
@@ -0,0 +1,93 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number[]} group
+ * @param {number[][]} beforeItems
+ * @return {number[]}
+ */
+const sortItems = function (n, m, group, beforeItems) {
+  const vertexs = new Map()
+  const groupVertexs = new Map()
+  let groupNo = m
+  for (let i = 0; i < n; i++) {
+    vertexs.set(i, {
+      neighbors: new Set(),
+      indegree: 0,
+    })
+    if (group[i] === -1) {
+      group[i] = groupNo++
+    }
+    if (!groupVertexs.has(group[i])) {
+      groupVertexs.set(group[i], {
+        v: new Set(),
+        neighbors: new Set(),
+        indegree: 0,
+      })
+    }
+    groupVertexs.get(group[i]).v.add(i)
+  }
+
+  for (let i = 0; i < n; i++) {
+    for (const before of beforeItems[i]) {
+      if (!vertexs.get(before).neighbors.has(i)) {
+        vertexs.get(i).indegree += 1
+      }
+      vertexs.get(before).neighbors.add(i)
+
+      const groupOfBefore = group[before]
+      if (groupOfBefore === group[i]) continue
+      if (!groupVertexs.get(groupOfBefore).neighbors.has(group[i])) {
+        groupVertexs.get(group[i]).indegree += 1
+      }
+      groupVertexs.get(groupOfBefore).neighbors.add(group[i])
+    }
+  }
+
+  const zeroGroup = []
+  for (const group of groupVertexs) {
+    if (group[1].indegree === 0) {
+      zeroGroup.push(group[0])
+    }
+  }
+  const result = []
+  let cntGroup = 0
+  let cntV = 0
+  const groupTotal = groupVertexs.size
+
+  while (zeroGroup.length) {
+    const top = zeroGroup.pop()
+    cntGroup += 1
+    const v = groupVertexs.get(top).v
+    const total = v.size
+    const zero = []
+
+    for (const i of v) {
+      if (vertexs.get(i).indegree === 0) {
+        zero.push(i)
+      }
+    }
+    while (zero.length) {
+      const it = zero.pop()
+      result.push(it)
+      for (const n of vertexs.get(it).neighbors) {
+        vertexs.get(n).indegree -= 1
+        if (v.has(n) && vertexs.get(n).indegree === 0) {
+          zero.push(n)
+        }
+      }
+    }
+    if (result.length - cntV !== total) {
+      return []
+    }
+    cntV = result.length
+
+    for (const groupneigbor of groupVertexs.get(top).neighbors) {
+      groupVertexs.get(groupneigbor).indegree -= 1
+      if (groupVertexs.get(groupneigbor).indegree === 0) {
+        zeroGroup.push(groupneigbor)
+      }
+    }
+  }
+
+  return cntGroup === groupTotal ? result : []
+}

From e146617eb5bacd945381d56e9f58fef45e6ceb28 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 Aug 2020 14:01:20 +0800
Subject: [PATCH 0794/3374] Create 1478-allocate-mailboxes.js

---
 1478-allocate-mailboxes.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1478-allocate-mailboxes.js

diff --git a/1478-allocate-mailboxes.js b/1478-allocate-mailboxes.js
new file mode 100644
index 00000000..aac971f9
--- /dev/null
+++ b/1478-allocate-mailboxes.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} houses
+ * @param {number} k
+ * @return {number}
+ */
+const minDistance = function (A, K) {
+  A.sort((a, b) => a - b)
+  let n = A.length,
+    B = new Array(n + 1).fill(0),
+    dp = Array(n).fill(0)
+  for (let i = 0; i < n; ++i) {
+    B[i + 1] = B[i] + A[i]
+    dp[i] = 1e6
+  }
+  for (let k = 1; k <= K; ++k) {
+    for (let j = n - 1; j > k - 2; --j) {
+      for (let i = k - 2; i < j; ++i) {
+        let m1 = ((i + j + 1) / 2) >> 0,
+          m2 = ((i + j + 2) / 2) >> 0
+        let last = B[j + 1] - B[m2] - (B[m1 + 1] - B[i + 1])
+        dp[j] = Math.min(dp[j], (i >= 0 ? dp[i] : 0) + last)
+      }
+    }
+  }
+  return dp[n - 1]
+}

From e220a22d7b8ead159019deb8b705f936c271b3e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Sep 2020 11:25:32 +0800
Subject: [PATCH 0795/3374] Create 1425-constrained-subsequence-sum.js

---
 1425-constrained-subsequence-sum.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1425-constrained-subsequence-sum.js

diff --git a/1425-constrained-subsequence-sum.js b/1425-constrained-subsequence-sum.js
new file mode 100644
index 00000000..1fb3cb59
--- /dev/null
+++ b/1425-constrained-subsequence-sum.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const constrainedSubsetSum = function(nums, k) {
+    const window = [[0,nums[0]]];
+    let max = nums[0];
+    for(let i=1; i<nums.length; i++){
+        let [index,lastKsum] = window[0];
+        if(index == i-k){
+            window.shift();
+        }
+        let sum = Math.max(lastKsum, 0) + nums[i]
+        max = Math.max(max, sum);
+        while(window.length>0 && window[window.length-1][1] < sum){
+            window.pop();
+        }
+        window.push([i,sum]);
+    }
+    return max;
+};

From b5b381b2701088ebae82bdfff8747b99cbffe6c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Sep 2020 14:26:45 +0800
Subject: [PATCH 0796/3374] Create
 1569-number-of-ways-to-reorder-array-to-get-same-bst.js

---
 ...f-ways-to-reorder-array-to-get-same-bst.js | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 1569-number-of-ways-to-reorder-array-to-get-same-bst.js

diff --git a/1569-number-of-ways-to-reorder-array-to-get-same-bst.js b/1569-number-of-ways-to-reorder-array-to-get-same-bst.js
new file mode 100644
index 00000000..08b20471
--- /dev/null
+++ b/1569-number-of-ways-to-reorder-array-to-get-same-bst.js
@@ -0,0 +1,67 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numOfWays = function (nums) {
+  let root = null
+  let cache = new Map()
+
+  const MOD = BigInt(10 ** 9 + 7)
+  for (let n of nums) {
+    root = insert(root, n)
+  }
+
+  // f(root) -> [length, combination]
+  function f(root) {
+    if (!root.left && !root.right) {
+      return [1n, 1n]
+    }
+    let [ll, lc] = [0n, 1n]
+    let [rl, rc] = [0n, 1n]
+    if (root.left) {
+      ;[ll, lc] = f(root.left)
+    }
+    if (root.right) {
+      ;[rl, rc] = f(root.right)
+    }
+    // ((ll + rl)! / (ll! * rl!)  )* lc * rc
+    return [
+      ll + rl + 1n,
+      (factorial(ll + rl) / factorial(ll) / factorial(rl)) * lc * rc,
+    ]
+  }
+
+  return (f(root)[1] - 1n) % MOD
+
+  function Node(val) {
+    this.val = val
+    this.left = this.right = null
+  }
+
+  function insert(root, val) {
+    if (!root) {
+      return new Node(val)
+    }
+    if (root.val > val) {
+      root.left = insert(root.left, val)
+    } else if (root.val < val) {
+      root.right = insert(root.right, val)
+    }
+    return root
+  }
+
+  function factorial(n) {
+    if (n == 0n) {
+      return 1n
+    }
+    if (cache.has(n)) {
+      return cache.get(n)
+    }
+    let ans = 1n
+    for (let i = 2n; i <= n; i++) {
+      ans *= i
+      cache.set(i, ans)
+    }
+    return ans
+  }
+}

From 263daedcf23a579fdf641837b1760ac1db6a7c48 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Sep 2020 11:11:39 +0800
Subject: [PATCH 0797/3374] Create 1416-restore-the-array.js

---
 1416-restore-the-array.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1416-restore-the-array.js

diff --git a/1416-restore-the-array.js b/1416-restore-the-array.js
new file mode 100644
index 00000000..0f10beeb
--- /dev/null
+++ b/1416-restore-the-array.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfArrays = function (s, k) {
+  const n = s.length
+  // dp[i] is number of ways to print valid arrays from string s start at i
+  const dp = Array(n)
+  return dfs(s, k, 0, dp)
+}
+
+function dfs(s, k, i, dp) {
+  const mod = 10 ** 9 + 7
+  // base case -> Found a valid way
+  if (i === s.length) return 1
+  // all numbers are in range [1, k] and there are no leading zeros
+  // So numbers starting with 0 mean invalid!
+  if (s.charAt(i) === '0') return 0
+  if (dp[i] != null) return dp[i]
+  let ans = 0
+  let num = 0
+  for (let j = i; j < s.length; j++) {
+    // num is the value of the substring s[i..j]
+    num = num * 10 + (+s.charAt(j))
+    // num must be in range [1, k]
+    if (num > k) break
+    ans += dfs(s, k, j + 1, dp)
+    ans %= mod
+  }
+  return (dp[i] = ans)
+}

From 4e3e9f83bc15a30c89fca317c5d2ba4c570989f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Sep 2020 11:26:01 +0800
Subject: [PATCH 0798/3374] Update 1416-restore-the-array.js

---
 1416-restore-the-array.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1416-restore-the-array.js b/1416-restore-the-array.js
index 0f10beeb..de517075 100644
--- a/1416-restore-the-array.js
+++ b/1416-restore-the-array.js
@@ -30,3 +30,32 @@ function dfs(s, k, i, dp) {
   }
   return (dp[i] = ans)
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfArrays = function (s, k) {
+  const mod = 10 ** 9 + 7
+  const n = s.length
+  const dp = new Array(n + 1).fill(0)
+  dp[n] = 1
+  for (let i = n - 1; i >= 0; i--) {
+    if (s[i] === '0') continue
+    else {
+      let temp = s[i]
+      for (let j = i + 1; j <= n; j++) {
+        if (temp > k) break
+        dp[i] = (dp[i] + dp[j]) % mod
+        if (j < n) {
+          temp = temp * 10 + parseInt(s[j])
+        }
+      }
+    }
+  }
+  return parseInt(dp[0])
+}
+

From f2848b56ac75bbfc1f75fbbd2be6d2392c22aa83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Sep 2020 08:41:06 +0800
Subject: [PATCH 0799/3374] Update 69-sqrt(x).js

---
 69-sqrt(x).js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/69-sqrt(x).js b/69-sqrt(x).js
index a27d2f3b..d392b5ee 100755
--- a/69-sqrt(x).js
+++ b/69-sqrt(x).js
@@ -7,3 +7,22 @@ const mySqrt = function(x) {
   while (r * r > x) r = ((r + x / r) / 2) | 0;
   return r;
 };
+
+// another
+
+/**
+ * @param {number} x
+ * @return {number}
+ */
+const mySqrt = function(x) {
+  let l = 1, r = x
+  if(x === 0) return 0
+  while(true) {
+    let mid = l + ((r - l) >> 1)
+    if(mid * mid > x) r = mid - 1
+    else {
+      if((mid + 1) * (mid + 1) > x) return mid
+      l = mid + 1
+    }
+  }
+};

From 4c69bf6aaad8498c777dde1537ef453c69107f70 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Sep 2020 10:35:49 +0800
Subject: [PATCH 0800/3374] Create
 1434-number-of-ways-to-wear-different-hats-to-each-other.js

---
 ...ys-to-wear-different-hats-to-each-other.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1434-number-of-ways-to-wear-different-hats-to-each-other.js

diff --git a/1434-number-of-ways-to-wear-different-hats-to-each-other.js b/1434-number-of-ways-to-wear-different-hats-to-each-other.js
new file mode 100644
index 00000000..6704ff78
--- /dev/null
+++ b/1434-number-of-ways-to-wear-different-hats-to-each-other.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} hats
+ * @return {number}
+ */
+const numberWays = function (hats) {
+  const pplThatCanWearHats = new Array(40 + 1).fill(null).map(() => [])
+  for (let i = 0; i < hats.length; i++) {
+    const personMask = 1 << i
+    for (let hat of hats[i]) {
+      pplThatCanWearHats[hat].push(personMask)
+    }
+  }
+
+  const cache = {}
+  const dfs = (hat, pplWithoutHatsMask) => {
+    if (!pplWithoutHatsMask) return 1
+    if (hat === 41) return 0
+    const key = `${hat}-${pplWithoutHatsMask}`
+    if (cache.hasOwnProperty(key)) return cache[key]
+    const nextHat = hat + 1
+    let total = dfs(nextHat, pplWithoutHatsMask)
+    for (let personMask of pplThatCanWearHats[hat]) {
+      if (!(pplWithoutHatsMask & personMask)) continue
+      total += dfs(nextHat, pplWithoutHatsMask ^ personMask)
+    }
+    return (cache[key] = total % 1000000007)
+  }
+  return dfs(1, (1 << hats.length) - 1)
+}

From f415c4d520b646acda4811be2842fc000709cc96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Sep 2020 15:54:03 +0800
Subject: [PATCH 0801/3374] Create 1575-count-all-possible-routes.js

---
 1575-count-all-possible-routes.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1575-count-all-possible-routes.js

diff --git a/1575-count-all-possible-routes.js b/1575-count-all-possible-routes.js
new file mode 100644
index 00000000..75a9ec24
--- /dev/null
+++ b/1575-count-all-possible-routes.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} locations
+ * @param {number} start
+ * @param {number} finish
+ * @param {number} fuel
+ * @return {number}
+ */
+const countRoutes = function (locations, start, finish, fuel) {
+  const n = locations.length
+  const mod = 10 ** 9 + 7
+  const dp = Array.from({ length: n }, () => Array(fuel + 1).fill(-1))
+  return solve(start, finish, fuel)
+  function solve(curCity, e, fuel) {
+    if (fuel < 0) return 0
+    if (dp[curCity][fuel] !== -1) return dp[curCity][fuel]
+    let ans = curCity === e ? 1 : 0
+    for (let nextCity = 0; nextCity < locations.length; nextCity++) {
+      if (nextCity !== curCity) {
+        ans +=
+          solve(
+            nextCity,
+            e,
+            fuel - Math.abs(locations[curCity] - locations[nextCity])
+          ) % mod
+      }
+    }
+    return (dp[curCity][fuel] = ans % mod)
+  }
+}

From df42490ff12132cd27463c095d94de9522aa4dde Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Sep 2020 10:15:25 +0800
Subject: [PATCH 0802/3374] Create 1571-warehouse-manager.sql

---
 1571-warehouse-manager.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 1571-warehouse-manager.sql

diff --git a/1571-warehouse-manager.sql b/1571-warehouse-manager.sql
new file mode 100644
index 00000000..928f43d5
--- /dev/null
+++ b/1571-warehouse-manager.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+SELECT name as warehouse_name, SUM(units*dimension) as volume FROM
+(
+    SELECT product_id, Width*Length*Height as dimension FROM Products
+) a
+JOIN Warehouse as b
+ON a.product_id=b.product_id
+GROUP BY name;

From b978647292011794b7ca9b3dfde42d019d8ef50b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Sep 2020 10:39:28 +0800
Subject: [PATCH 0803/3374] Create 1570-dot-product-of-two-sparse-vectors.js

---
 1570-dot-product-of-two-sparse-vectors.js | 28 +++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1570-dot-product-of-two-sparse-vectors.js

diff --git a/1570-dot-product-of-two-sparse-vectors.js b/1570-dot-product-of-two-sparse-vectors.js
new file mode 100644
index 00000000..7d2fbd1b
--- /dev/null
+++ b/1570-dot-product-of-two-sparse-vectors.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {SparseVector}
+ */
+const SparseVector = function(nums) {
+  this.seen = {}
+  nums.forEach((e, i) => {
+    if(e !== 0) this.seen[i] = e
+  })
+};
+
+// Return the dotProduct of two sparse vectors
+/**
+ * @param {SparseVector} vec
+ * @return {number}
+ */
+SparseVector.prototype.dotProduct = function(vec) {
+  let res = 0
+  for(let [k, v] of Object.entries(vec.seen)) {
+    if(k in this.seen) res += v * this.seen[k]
+  }
+  return res
+};
+
+// Your SparseVector object will be instantiated and called as such:
+// let v1 = new SparseVector(nums1);
+// let v2 = new SparseVector(nums2);
+// let ans = v1.dotProduct(v2);

From e3bcd240b4d9682dd5975aefd258e244fc74f5fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Sep 2020 10:41:48 +0800
Subject: [PATCH 0804/3374] Update 1570-dot-product-of-two-sparse-vectors.js

---
 1570-dot-product-of-two-sparse-vectors.js | 39 +++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/1570-dot-product-of-two-sparse-vectors.js b/1570-dot-product-of-two-sparse-vectors.js
index 7d2fbd1b..682b656d 100644
--- a/1570-dot-product-of-two-sparse-vectors.js
+++ b/1570-dot-product-of-two-sparse-vectors.js
@@ -26,3 +26,42 @@ SparseVector.prototype.dotProduct = function(vec) {
 // let v1 = new SparseVector(nums1);
 // let v2 = new SparseVector(nums2);
 // let ans = v1.dotProduct(v2);
+
+// another
+
+class SparseVector {
+  /**
+   * @param {number[]} nums
+   * @return {SparseVector}
+   */
+  constructor(nums) {
+    // Space: O(n)
+    this.seen = new Map() // index -> value
+    for (let i = 0; i < nums.length; ++i) {
+      if (nums[i] !== 0) {
+        this.seen.set(i, nums[i])
+      }
+    }
+  }
+
+  /**
+   * Return the dotProduct of two sparse vectors
+   * @param {SparseVector} vec
+   * @return {number}
+   */
+  dotProduct(vec) {
+    // Time: O(n)
+    let sum = 0
+    for (const [i, val] of vec.seen) {
+      if (this.seen.has(i)) {
+        sum += val * this.seen.get(i)
+      }
+    }
+    return sum
+  }
+}
+
+// Your SparseVector object will be instantiated and called as such:
+// let v1 = new SparseVector(nums1);
+// let v2 = new SparseVector(nums2);
+// let ans = v1.dotProduct(v2);

From cc1ba7fe3e48183065c46b00e85ddff9c7c0f086 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Sep 2020 12:21:46 +0800
Subject: [PATCH 0805/3374] Create
 1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.js

---
 ...f-edges-to-keep-graph-fully-traversable.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.js

diff --git a/1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.js b/1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.js
new file mode 100644
index 00000000..96873a60
--- /dev/null
+++ b/1579-remove-max-number-of-edges-to-keep-graph-fully-traversable.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const maxNumEdgesToRemove = function (n, edges) {
+  edges.sort((a, b) => b[0] - a[0])
+  let edgesAdded = 0
+  const bob = new UnionFind(n)
+  const alice = new UnionFind(n)
+  for (let edge of edges) {
+    let type = edge[0],
+      one = edge[1],
+      two = edge[2]
+    switch (type) {
+      case 3:
+        edgesAdded += bob.unite(one, two) | alice.unite(one, two)
+        break
+      case 2:
+        edgesAdded += bob.unite(one, two)
+        break
+      case 1:
+        edgesAdded += alice.unite(one, two)
+        break
+    }
+  }
+  return bob.united() && alice.united() ? edges.length - edgesAdded : -1
+}
+class UnionFind {
+  constructor(n) {
+    this.component = []
+    this.distinctComponents = n
+    for (let i = 0; i <= n; i++) this.component.push(i)
+  }
+  unite(a, b) {
+    const ar = this.find(a)
+    if (ar !== this.find(b)) {
+      this.component[ar] = b
+      this.distinctComponents--
+      return true
+    }
+    return false
+  }
+  find(a) {
+    if (this.component[a] != a) {
+      this.component[a] = this.find(this.component[a])
+    }
+    return this.component[a]
+  }
+  united() {
+    return this.distinctComponents === 1
+  }
+}

From 0d85c0ba61ffbf6b4281b49fb84b93e3c488a588 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Sep 2020 09:04:56 +0800
Subject: [PATCH 0806/3374] Create
 1168-optimize-water-distribution-in-a-village.js

---
 ...ptimize-water-distribution-in-a-village.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1168-optimize-water-distribution-in-a-village.js

diff --git a/1168-optimize-water-distribution-in-a-village.js b/1168-optimize-water-distribution-in-a-village.js
new file mode 100644
index 00000000..443506da
--- /dev/null
+++ b/1168-optimize-water-distribution-in-a-village.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number} n
+ * @param {number[]} wells
+ * @param {number[][]} pipes
+ * @return {number}
+ */
+const minCostToSupplyWater = function(n, wells, pipes) {
+  const uf = Array(n + 1).fill(0)
+  const edges = []
+  for(let i = 0; i < n; i++) {
+    uf[i + 1] = i + 1
+    edges.push([0, i + 1, wells[i]])
+  }
+  for(let p of pipes) {
+    edges.push(p)
+  }
+  edges.sort((a, b) => a[2] - b[2])
+  let res = 0
+  for(let e of edges) {
+    const x = find(e[0]), y = find(e[1])
+    if(x !== y) {
+      res += e[2]
+      uf[x] = y
+      n--
+    }
+  }
+  return res
+  
+  function find(x) {
+    if(x !== uf[x]) uf[x] = find(uf[x])
+    return uf[x]
+  }
+};

From 9042bf7ba226f2a525e6ce1177aaaf68065ef98e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Sep 2020 10:39:48 +0800
Subject: [PATCH 0807/3374] Create
 1568-minimum-number-of-days-to-disconnect-island.js

---
 ...mum-number-of-days-to-disconnect-island.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1568-minimum-number-of-days-to-disconnect-island.js

diff --git a/1568-minimum-number-of-days-to-disconnect-island.js b/1568-minimum-number-of-days-to-disconnect-island.js
new file mode 100644
index 00000000..f356ab72
--- /dev/null
+++ b/1568-minimum-number-of-days-to-disconnect-island.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minDays = function (grid) {
+  if (!grid.length || !grid[0].length) return 0
+  if (numIslands(grid) != 1) return 0
+  for (let i = 0; i < grid.length; i++) {
+    for (let j = 0; j < grid[0].length; j++) {
+      if (grid[i][j] == 1) {
+        grid[i][j] = 0
+        if (numIslands(grid) != 1) return 1
+        grid[i][j] = 1
+      }
+    }
+  }
+  return 2
+}
+
+function numIslands(grid) {
+  let m = Array.from({ length: grid.length }, (v, i) => {
+    return [...grid[i]]
+  })
+  let count = 0
+  for (let i = 0; i < m.length; i++)
+    for (let j = 0; j < m[0].length; j++) removeIslandAt(i, j, 1)
+  return count
+  function removeIslandAt(i, j, firstIteration = 0) {
+    if (i >= m.length || j >= m[0].length || i < 0 || j < 0 || m[i][j] == 0)
+      return
+    m[i][j] = 0
+    count += firstIteration
+    removeIslandAt(i - 1, j)
+    removeIslandAt(i + 1, j)
+    removeIslandAt(i, j - 1)
+    removeIslandAt(i, j + 1)
+  }
+}

From 2e9e92e297ab9d8b14890e4710f00812137d4df6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Sep 2020 09:36:42 +0800
Subject: [PATCH 0808/3374] Create 1516-move-sub-tree-of-n-ary-tree.js

---
 1516-move-sub-tree-of-n-ary-tree.js | 58 +++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 1516-move-sub-tree-of-n-ary-tree.js

diff --git a/1516-move-sub-tree-of-n-ary-tree.js b/1516-move-sub-tree-of-n-ary-tree.js
new file mode 100644
index 00000000..1e59ae4d
--- /dev/null
+++ b/1516-move-sub-tree-of-n-ary-tree.js
@@ -0,0 +1,58 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node} root
+ * @param {Node} p
+ * @param {Node} q
+ * @return {Node}
+ */
+function moveSubTree(root, p, q) {
+  for (let node of q.children) {
+    if (p === node) {
+      return root
+    }
+  }
+  if (find(p, q)) {
+    update(root, p, q)
+    q.children.push(p)
+    return root === p ? q : root
+  } else {
+    update(root, null, p)
+    q.children.push(p)
+    return root
+  }
+  function update(root, p, q) {
+    if (root == null) {
+      return
+    }
+    for (let node of root.children) {
+      update(node, p, q)
+    }
+    for (let i = 0; i < root.children.length; i++) {
+      if (root.children[i] === p) {
+        root.children[i] = q
+      } else if (root.children[i] === q) {
+        root.children.splice(i, 1)
+      }
+    }
+  }
+  function find(root, t) {
+    if (root == null) {
+      return false
+    }
+    let ret = root === t
+    if (ret === true) {
+      return true
+    }
+    for (let node of root.children) {
+      ret = ret || find(node, t)
+    }
+    return ret
+  }
+}

From ef39957824994d43e56f0383b3718081187aaa82 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Sep 2020 21:31:26 +0800
Subject: [PATCH 0809/3374] Create 1490-clone-n-ary-tree.js

---
 1490-clone-n-ary-tree.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1490-clone-n-ary-tree.js

diff --git a/1490-clone-n-ary-tree.js b/1490-clone-n-ary-tree.js
new file mode 100644
index 00000000..07122d3e
--- /dev/null
+++ b/1490-clone-n-ary-tree.js
@@ -0,0 +1,20 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const cloneTree = function(root) {
+  if(root == null) return null
+  let node = new Node(root.val)
+  for(let i = 0, len = root.children.length; i < len; i++) {
+    node.children.push(cloneTree(root.children[i]))
+  }
+  return node
+};

From 5aa5218f20f351a2a4cfe4bd58567b67f1d4c9a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Sep 2020 21:58:45 +0800
Subject: [PATCH 0810/3374] Update 1490-clone-n-ary-tree.js

---
 1490-clone-n-ary-tree.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1490-clone-n-ary-tree.js b/1490-clone-n-ary-tree.js
index 07122d3e..e8cfe407 100644
--- a/1490-clone-n-ary-tree.js
+++ b/1490-clone-n-ary-tree.js
@@ -18,3 +18,36 @@ const cloneTree = function(root) {
   }
   return node
 };
+
+// another
+
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const cloneTree = function(root) {
+  if (root === null) return null
+  const Q = []
+  const rootCopy = new Node(root.val)
+  Q.push([root, rootCopy])
+  while (Q.length) {
+    const temp = Q.shift()
+    const node = temp[0]
+    const copy = temp[1]
+    node.children.forEach((child) => {
+      const copyChild = new Node(child.val)
+      copy.children.push(copyChild)
+      Q.push([child, copyChild])
+    })
+  }
+
+  return rootCopy
+};

From b7a0c4efd86e1603f06584a514cabd270ebe2a2a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Sep 2020 09:19:25 +0800
Subject: [PATCH 0811/3374] Create
 1429-build-array-where-you-can-find-the-maximum-exactly-k-comparisons.js

---
 ...-find-the-maximum-exactly-k-comparisons.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1429-build-array-where-you-can-find-the-maximum-exactly-k-comparisons.js

diff --git a/1429-build-array-where-you-can-find-the-maximum-exactly-k-comparisons.js b/1429-build-array-where-you-can-find-the-maximum-exactly-k-comparisons.js
new file mode 100644
index 00000000..2df47008
--- /dev/null
+++ b/1429-build-array-where-you-can-find-the-maximum-exactly-k-comparisons.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number} k
+ * @return {number}
+ */
+const numOfArrays = function (n, m, k) {
+	const mod = 1e9 + 7;
+	const dp = [];
+	for (let i = 0; i <= n; i++) {
+		dp[i] = [];
+		for (let j = 0; j <= m; j++) {
+			dp[i][j] = [];
+		}
+	}
+	// i: length; j: max; c: cost
+	function f(i, j, c) {
+		if (dp[i][j][c] !== undefined) return dp[i][j][c];
+		if (c > i || c > j || c === 0) return (dp[i][j][c] = 0);
+		if (i === 1 && c === 1) return (dp[i][j][c] = 1);
+		let res = 0;
+		// ... (j)
+		for (let b = 1; b < j; b++) {
+			res = (res + f(i - 1, b, c - 1)) % mod;
+		}
+		// ... (1 -> j)
+		res = (res + f(i - 1, j, c) * j) % mod;
+		return (dp[i][j][c] = res);
+	}
+	let res = 0;
+	for (let b = 1; b <= m; b++) {
+		res = (res + f(n, b, k)) % mod;
+	}
+	return res;
+};

From 7d247fee243802d749d2174e4edcfd03ca502be3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Sep 2020 11:03:34 +0800
Subject: [PATCH 0812/3374] Create 882-reachable-nodes-in-subdivided-graph.js

---
 882-reachable-nodes-in-subdivided-graph.js | 105 +++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 882-reachable-nodes-in-subdivided-graph.js

diff --git a/882-reachable-nodes-in-subdivided-graph.js b/882-reachable-nodes-in-subdivided-graph.js
new file mode 100644
index 00000000..9d7fc3cf
--- /dev/null
+++ b/882-reachable-nodes-in-subdivided-graph.js
@@ -0,0 +1,105 @@
+/**
+ * @param {number[][]} edges
+ * @param {number} M
+ * @param {number} N
+ * @return {number}
+ */
+const reachableNodes = function (edges, M, N) {
+  const graph = Array.from({ length: N }, () => Array(N).fill(-1))
+  for (let edge of edges) {
+    graph[edge[0]][edge[1]] = edge[2]
+    graph[edge[1]][edge[0]] = edge[2]
+  }
+  let result = 0
+  const pq = new PriorityQueue((a, b) => a[1] > b[1])
+  const visited = new Array(N).fill(false)
+  pq.push([0, M])
+  while (!pq.isEmpty()) {
+    const cur = pq.pop()
+    const start = cur[0]
+    const move = cur[1]
+    if (visited[start]) {
+      continue
+    }
+    visited[start] = true
+    result++
+    for (let i = 0; i < N; i++) {
+      if (graph[start][i] > -1) {
+        if (move > graph[start][i] && !visited[i]) {
+          pq.push([i, move - graph[start][i] - 1])
+        }
+        graph[i][start] -= Math.min(move, graph[start][i])
+        result += Math.min(move, graph[start][i])
+      }
+    }
+  }
+  return result
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 080c0251af04260c2b213c58a5c7ee528f9db0e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Sep 2020 08:37:42 +0800
Subject: [PATCH 0813/3374] Create
 1581-customer-who-visited-but-did-not-make-any-transactions.sql

---
 ...ustomer-who-visited-but-did-not-make-any-transactions.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1581-customer-who-visited-but-did-not-make-any-transactions.sql

diff --git a/1581-customer-who-visited-but-did-not-make-any-transactions.sql b/1581-customer-who-visited-but-did-not-make-any-transactions.sql
new file mode 100644
index 00000000..9021027a
--- /dev/null
+++ b/1581-customer-who-visited-but-did-not-make-any-transactions.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT customer_id, COUNT(*) as count_no_trans
+FROM Visits
+WHERE visit_id NOT IN (SELECT DISTINCT visit_id FROM Transactions)
+GROUP BY customer_id;

From 4e092ca859f17cbff1b809343814f6844575bb79 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Sep 2020 21:09:05 +0800
Subject: [PATCH 0814/3374] Create
 1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree.js

---
 ...critical-edges-in-minimum-spanning-tree.js | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree.js

diff --git a/1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree.js b/1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree.js
new file mode 100644
index 00000000..eb33c130
--- /dev/null
+++ b/1489-find-critical-and-pseudo-critical-edges-in-minimum-spanning-tree.js
@@ -0,0 +1,69 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[][]}
+ */
+const findCriticalAndPseudoCriticalEdges = function (n, edges) {
+  const criticalEdges = [],
+    psuedoCriticalEdges = [],
+    map = new Map()
+  edges.forEach((edge, i) => map.set(edge, i))
+  edges.sort((a, b) => a[2] - b[2])
+  const buildMST = (pick, skip) => {
+    const uf = new UnionFind(n)
+    let cost = 0
+    if (pick !== null) {
+      uf.union(pick[0], pick[1])
+      cost += pick[2]
+    }
+    for (let edge of edges) {
+      if (edge !== skip && uf.union(edge[0], edge[1])) cost += edge[2]
+    }
+    return uf.count === 1 ? cost : Number.MAX_SAFE_INTEGER
+  }
+  const minCost = buildMST(null, null)
+  for (let edge of edges) {
+    const index = map.get(edge)
+    const costWithout = buildMST(null, edge)
+    if (costWithout > minCost) {
+      criticalEdges.push(index)
+    } else {
+      const costWith = buildMST(edge, null)
+      if (costWith === minCost) psuedoCriticalEdges.push(index)
+    }
+  }
+  return [criticalEdges, psuedoCriticalEdges]
+}
+class UnionFind {
+  constructor(n) {
+    this.parents = Array(n)
+      .fill(0)
+      .map((e, i) => i)
+    this.ranks = Array(n).fill(0)
+    this.count = n
+  }
+  root(x) {
+    while (x !== this.parents[x]) {
+      this.parents[x] = this.parents[this.parents[x]]
+      x = this.parents[x]
+    }
+    return x
+  }
+  find(x) {
+    return this.root(x)
+  }
+  union(x, y) {
+    const [rx, ry] = [this.find(x), this.find(y)]
+    if (this.ranks[rx] >= this.ranks[ry]) {
+      this.parents[ry] = rx
+      this.ranks[rx] += this.ranks[ry]
+    } else if (this.ranks[ry] > this.ranks[rx]) {
+      this.parents[rx] = ry
+      this.ranks[ry] += this.ranks[rx]
+    }
+    if (rx !== ry) {
+      this.count--
+      return true
+    } else return false
+  }
+}

From b126d7991cfaa287aedba710659ae9cd4329ad44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Sep 2020 20:52:07 +0800
Subject: [PATCH 0815/3374] Create
 1585-check-if-string-is-transformable-with-substring-sort-operations.js

---
 ...formable-with-substring-sort-operations.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1585-check-if-string-is-transformable-with-substring-sort-operations.js

diff --git a/1585-check-if-string-is-transformable-with-substring-sort-operations.js b/1585-check-if-string-is-transformable-with-substring-sort-operations.js
new file mode 100644
index 00000000..164018a6
--- /dev/null
+++ b/1585-check-if-string-is-transformable-with-substring-sort-operations.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+const isTransformable = function (s, t) {
+  const offset = '0'.charCodeAt(0)
+  const indices = Array.from({ length: 10 }, () => [])
+  for (let i = s.length - 1; i >= 0; --i) {
+    indices[s.charCodeAt(i) - offset].push(i)
+  }
+  for (const char of t) {
+    const digit = char.charCodeAt(0) - offset
+    if (indices[digit].length === 0) return false
+    const pos = indices[digit][indices[digit].length - 1]
+    for (let d = 0; d < digit; ++d) {
+      if (indices[d].length && indices[d][indices[d].length - 1] < pos) {
+        return false
+      }
+    }
+    indices[digit].pop()
+  }
+  return true
+}

From 78faf3254cf3bc37136ba97e73692248fbfdb618 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Sep 2020 20:45:23 +0800
Subject: [PATCH 0816/3374] Update 1052-grumpy-bookstore-owner.js

---
 1052-grumpy-bookstore-owner.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1052-grumpy-bookstore-owner.js b/1052-grumpy-bookstore-owner.js
index 4aae8d95..977d6c8b 100644
--- a/1052-grumpy-bookstore-owner.js
+++ b/1052-grumpy-bookstore-owner.js
@@ -24,3 +24,28 @@ const maxSatisfied = function(customers, grumpy, X) {
 
   return totalSatisfiedCustomers + max
 }
+
+// another
+
+/**
+ * @param {number[]} customers
+ * @param {number[]} grumpy
+ * @param {number} X
+ * @return {number}
+ */
+const maxSatisfied = function (customers, grumpy, X) {
+  let satisfied = 0,
+    maxMakeSatisfied = 0
+  for (let i = 0, winOfMakeSatisfied = 0; i < grumpy.length; ++i) {
+    if (grumpy[i] === 0) {
+      satisfied += customers[i]
+    } else {
+      winOfMakeSatisfied += customers[i]
+    }
+    if (i >= X) {
+      winOfMakeSatisfied -= grumpy[i - X] * customers[i - X]
+    }
+    maxMakeSatisfied = Math.max(winOfMakeSatisfied, maxMakeSatisfied)
+  }
+  return satisfied + maxMakeSatisfied
+}

From 7a2917e9869d524892b9f2d84a9bc13ffe8e7224 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Sep 2020 09:27:13 +0800
Subject: [PATCH 0817/3374] Create 1004-max-consecutive-ones-iii.js

---
 1004-max-consecutive-ones-iii.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1004-max-consecutive-ones-iii.js

diff --git a/1004-max-consecutive-ones-iii.js b/1004-max-consecutive-ones-iii.js
new file mode 100644
index 00000000..65ca7c85
--- /dev/null
+++ b/1004-max-consecutive-ones-iii.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} A
+ * @param {number} K
+ * @return {number}
+ */
+const longestOnes = function (A, K) {
+  let i = 0
+  let j = 0
+  const len = A.length
+  while (j < len) {
+    if (A[j] === 0) K--
+    if (K < 0) {
+      if (A[i] === 0) K++
+      i++
+    }
+    j++
+  }
+  return j - i
+}

From 64dd4efee5be920ec569cb8a2dbdc8ab4c77b32a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Sep 2020 11:35:46 +0800
Subject: [PATCH 0818/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index bb7ab822..2cee8fef 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -7,7 +7,7 @@ const subarraysWithKDistinct = function(A, K) {
   let res = 0
   let prefix = 0
   const m = new Array(A.length + 1).fill(0)
-  for (let i = 0, j = 0, cnt = 0; i < A.length; i++) {
+  for (let i = 0, j = 0, cnt = 0, len = A.length; i < len; i++) {
     if (m[A[i]]++ === 0) cnt++
     if (cnt > K) {
       m[A[j++]]--

From 0b5af6903131fa4feb87d4f02b19546ce5c0f3da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Sep 2020 12:46:56 +0800
Subject: [PATCH 0819/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 28 ++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index 2cee8fef..1ed76a2d 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -22,3 +22,31 @@ const subarraysWithKDistinct = function(A, K) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} A
+ * @param {number} K
+ * @return {number}
+ */
+const subarraysWithKDistinct = function (A, K) {
+  const atMostK = (A, K) => {
+    let left = 0,
+      right = 0,
+      counter = 0,
+      count = [],
+      result = 0
+    while (right < A.length) {
+      let currentR = A[right++]
+      !count[currentR] ? ((count[currentR] = 1), counter++) : count[currentR]++
+      while (counter > K) {
+        let currentL = A[left++]
+        if (--count[currentL] == 0) counter--
+      }
+      result += right - left
+    }
+    return result
+  }
+  return atMostK(A, K) - atMostK(A, K - 1)
+}

From 702004f406ae188543a027abe183bbcbc2f787d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Sep 2020 13:14:32 +0800
Subject: [PATCH 0820/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 29 +++++++++++-----------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index 1ed76a2d..ed497d7b 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -31,22 +31,21 @@ const subarraysWithKDistinct = function(A, K) {
  * @return {number}
  */
 const subarraysWithKDistinct = function (A, K) {
-  const atMostK = (A, K) => {
-    let left = 0,
-      right = 0,
-      counter = 0,
-      count = [],
-      result = 0
-    while (right < A.length) {
-      let currentR = A[right++]
-      !count[currentR] ? ((count[currentR] = 1), counter++) : count[currentR]++
-      while (counter > K) {
-        let currentL = A[left++]
-        if (--count[currentL] == 0) counter--
+  return mostK(K) - mostK(K - 1)
+  function mostK(num) {
+    const m = {}, len = A.length
+    let i = 0, j = 0, res = 0
+    for(j = 0; j < len; j++) {
+      if(!m[A[j]]) m[A[j]] = 0, num--
+      m[A[j]]++
+      while(num < 0) {
+        m[A[i]]--
+        if(!m[A[i]]) num++
+        i++
       }
-      result += right - left
+      res += j - i + 1
     }
-    return result
+    return res
   }
-  return atMostK(A, K) - atMostK(A, K - 1)
 }
+

From 822d7d399489976081d4d79df183ca3312bca5bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Sep 2020 13:22:03 +0800
Subject: [PATCH 0821/3374] Create 1592-rearrange-spaces-between-words.js

---
 1592-rearrange-spaces-between-words.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1592-rearrange-spaces-between-words.js

diff --git a/1592-rearrange-spaces-between-words.js b/1592-rearrange-spaces-between-words.js
new file mode 100644
index 00000000..8b2f4909
--- /dev/null
+++ b/1592-rearrange-spaces-between-words.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} text
+ * @return {string}
+ */
+const reorderSpaces = function(text) {
+  let sc = 0
+  for(let i = 0, len = text.length; i < len; i++) {
+    if(text[i] === ' ') sc++
+  }
+  const arr = text.split(' ').filter(e => e!= '')
+  const num = arr.length - 1
+  const remain = num === 0 ? sc : sc % num
+  const split = num === 0 ? 0 : Array( (sc / num) >> 0 ).fill(0).reduce((ac, el) => ac + ' ', '')
+  let res = ''
+  res = arr.join(split) + helper(remain)
+  return res
+};
+
+function helper(n) {
+  let res = ''
+  for(let i = 0; i < n; i++) res += ' '
+  return res
+}

From ad3a6500f50078289f5b0ac59f1c4b019982e7ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Sep 2020 13:22:50 +0800
Subject: [PATCH 0822/3374] Create
 1593-split-a-string-into-the-max-number-of-unique-substrings.js

---
 ...nto-the-max-number-of-unique-substrings.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1593-split-a-string-into-the-max-number-of-unique-substrings.js

diff --git a/1593-split-a-string-into-the-max-number-of-unique-substrings.js b/1593-split-a-string-into-the-max-number-of-unique-substrings.js
new file mode 100644
index 00000000..3d9ca78a
--- /dev/null
+++ b/1593-split-a-string-into-the-max-number-of-unique-substrings.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxUniqueSplit = function(s) {
+  return bt(s, '', 0, new Set())
+};
+
+function bt(str, cur, idx, useds) {
+  if(idx === str.length) return useds.size
+  cur += str[idx]
+  if(useds.has(cur)) return bt(str, cur, idx +1, useds)
+  else {
+    let ans = 0
+    useds.add(cur)
+    ans = Math.max(ans, bt(str, '', idx+1, useds))
+    useds.delete(cur)
+    ans = Math.max(ans, bt(str, cur, idx+1, useds))
+    return ans
+  }
+}

From 95549d1c0315bccc3b1c0592f3e84274edaaa190 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Sep 2020 13:23:30 +0800
Subject: [PATCH 0823/3374] Create
 1594-maximum-non-negative-product-in-a-matrix.js

---
 ...aximum-non-negative-product-in-a-matrix.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1594-maximum-non-negative-product-in-a-matrix.js

diff --git a/1594-maximum-non-negative-product-in-a-matrix.js b/1594-maximum-non-negative-product-in-a-matrix.js
new file mode 100644
index 00000000..34e90309
--- /dev/null
+++ b/1594-maximum-non-negative-product-in-a-matrix.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maxProductPath = function (grid) {
+  const m = grid.length,
+    n = grid[0].length,
+    MOD = 1e9 + 7;
+  const mx = Array.from({ length: m }, () => Array(n).fill(0));
+  const mn = Array.from({ length: m }, () => Array(n).fill(0));
+  mx[0][0] = mn[0][0] = grid[0][0];
+
+  // initialize the top and left sides
+  for (let i = 1; i < m; i++) {
+    mn[i][0] = mx[i][0] = mx[i - 1][0] * grid[i][0];
+  }
+  for (let j = 1; j < n; j++) {
+    mn[0][j] = mx[0][j] = mx[0][j - 1] * grid[0][j];
+  }
+
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      if (grid[i][j] < 0) {
+        // smallest negative * negative number = largest
+        mx[i][j] = Math.min(mn[i - 1][j], mn[i][j - 1]) * grid[i][j];
+        mn[i][j] = Math.max(mx[i - 1][j], mx[i][j - 1]) * grid[i][j];
+      } else {
+        // largest product * positive number = largest
+        mx[i][j] = Math.max(mx[i - 1][j], mx[i][j - 1]) * grid[i][j];
+        mn[i][j] = Math.min(mn[i - 1][j], mn[i][j - 1]) * grid[i][j];
+      }
+    }
+  }
+
+  let ans = mx[m - 1][n - 1] % MOD;
+  return ans < 0 ? -1 : ans;
+};

From a533f9c0c8261c3bb5cb091efddf53b3e6a547ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Sep 2020 20:41:25 +0800
Subject: [PATCH 0824/3374] Create
 1595-minimum-cost-to-connect-two-groups-of-points.js

---
 ...um-cost-to-connect-two-groups-of-points.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1595-minimum-cost-to-connect-two-groups-of-points.js

diff --git a/1595-minimum-cost-to-connect-two-groups-of-points.js b/1595-minimum-cost-to-connect-two-groups-of-points.js
new file mode 100644
index 00000000..c6aa7e49
--- /dev/null
+++ b/1595-minimum-cost-to-connect-two-groups-of-points.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} cost
+ * @return {number}
+ */
+const connectTwoGroups = function (cost) {
+  const min = Array(cost[0].length).fill(Infinity)
+  for (let j = 0; j < min.length; j++) {
+    for (let i = 0; i < cost.length; i++) {
+      min[j] = Math.min(min[j], cost[i][j])
+    }
+  }
+  const dp = Array.from({ length: 13 }, () => Array(4096).fill(0))
+  return dfs(cost, min, 0, 0, dp)
+}
+
+function dfs(cost, min, i, mask, dp) {
+  if (dp[i][mask]) return dp[i][mask] - 1
+  let res = i >= cost.length ? 0 : Infinity
+  if (i >= cost.length) {
+    for (let j = 0; j < cost[0].length; j++) {
+      if ((mask & (1 << j)) === 0) res += min[j]
+    }
+  } else {
+    for (let j = 0; j < cost[0].length; j++) {
+      res = Math.min(
+        res,
+        cost[i][j] + dfs(cost, min, i + 1, mask | (1 << j), dp)
+      )
+    }
+  }
+  dp[i][mask] = res + 1
+  return res
+}

From 0e0b6c80aa04b7accca074f88c0df4a0a7f6c50a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Sep 2020 22:02:10 +0800
Subject: [PATCH 0825/3374] Update
 1595-minimum-cost-to-connect-two-groups-of-points.js

---
 1595-minimum-cost-to-connect-two-groups-of-points.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1595-minimum-cost-to-connect-two-groups-of-points.js b/1595-minimum-cost-to-connect-two-groups-of-points.js
index c6aa7e49..154193ef 100644
--- a/1595-minimum-cost-to-connect-two-groups-of-points.js
+++ b/1595-minimum-cost-to-connect-two-groups-of-points.js
@@ -9,12 +9,12 @@ const connectTwoGroups = function (cost) {
       min[j] = Math.min(min[j], cost[i][j])
     }
   }
-  const dp = Array.from({ length: 13 }, () => Array(4096).fill(0))
+  const dp = Array.from({ length: 13 }, () => Array(4096).fill(-1))
   return dfs(cost, min, 0, 0, dp)
 }
 
 function dfs(cost, min, i, mask, dp) {
-  if (dp[i][mask]) return dp[i][mask] - 1
+  if (dp[i][mask] !== -1) return dp[i][mask]
   let res = i >= cost.length ? 0 : Infinity
   if (i >= cost.length) {
     for (let j = 0; j < cost[0].length; j++) {
@@ -28,6 +28,6 @@ function dfs(cost, min, i, mask, dp) {
       )
     }
   }
-  dp[i][mask] = res + 1
+  dp[i][mask] = res
   return res
 }

From 83a0c37e80171a054966be2612caf0646e9f83d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Sep 2020 08:51:24 +0800
Subject: [PATCH 0826/3374] Create 1591-strange-printer-ii.js

---
 1591-strange-printer-ii.js | 50 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1591-strange-printer-ii.js

diff --git a/1591-strange-printer-ii.js b/1591-strange-printer-ii.js
new file mode 100644
index 00000000..c5a48fd6
--- /dev/null
+++ b/1591-strange-printer-ii.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[][]} targetGrid
+ * @return {boolean}
+ */
+const isPrintable = function (targetGrid) {
+  const posMin = Array.from({ length: 61 }, () => Array(2).fill(61))
+  const posMax = Array.from({ length: 61 }, () => Array(2).fill(0))
+  const m = targetGrid.length
+  const n = targetGrid[0].length
+  let colorSet = new Set()
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      let c = targetGrid[i][j]
+      colorSet.add(c)
+      posMin[c][0] = Math.min(posMin[c][0], i) // Up
+      posMin[c][1] = Math.min(posMin[c][1], j) // Left
+      posMax[c][0] = Math.max(posMax[c][0], i) // Down
+      posMax[c][1] = Math.max(posMax[c][1], j) // Right
+    }
+  }
+  while (colorSet.size > 0) {
+    const tmp = new Set()
+    for (let color of colorSet) {
+      if (!isRect(targetGrid, color)) {
+        tmp.add(color)
+      }
+    }
+
+    if (tmp.size === colorSet.size) return false
+    colorSet = tmp
+  }
+
+  return true
+
+  function isRect(A, c) {
+    for (let i = posMin[c][0]; i <= posMax[c][0]; i++) {
+      for (let j = posMin[c][1]; j <= posMax[c][1]; j++) {
+        if (A[i][j] > 0 && A[i][j] !== c) return false
+      }
+    }
+
+    for (let i = posMin[c][0]; i <= posMax[c][0]; i++) {
+      for (let j = posMin[c][1]; j <= posMax[c][1]; j++) {
+        A[i][j] = 0
+      }
+    }
+    return true
+  }
+}

From 6b42ad420a5a9afbf06cef52083c0d454a0c1770 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Sep 2020 13:56:07 +0800
Subject: [PATCH 0827/3374] Update
 1595-minimum-cost-to-connect-two-groups-of-points.js

---
 ...um-cost-to-connect-two-groups-of-points.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/1595-minimum-cost-to-connect-two-groups-of-points.js b/1595-minimum-cost-to-connect-two-groups-of-points.js
index 154193ef..900ec1dc 100644
--- a/1595-minimum-cost-to-connect-two-groups-of-points.js
+++ b/1595-minimum-cost-to-connect-two-groups-of-points.js
@@ -31,3 +31,45 @@ function dfs(cost, min, i, mask, dp) {
   dp[i][mask] = res
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} cost
+ * @return {number}
+ */
+const connectTwoGroups = function (cost) {
+  const n = cost.length
+  const m = cost[0].length
+  const con = 1 << m
+  const dp = Array(n + 1)
+    .fill(null)
+    .map(() => Array(con).fill(0))
+  const min = Array(m).fill(Infinity)
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      min[j] = Math.min(min[j], cost[i][j])
+    }
+  }
+  function dfs(i, mask) {
+    let res
+    if (dp[i][mask]) {
+      return dp[i][mask]
+    } else if (i >= n) {
+      res = 0
+      for (let j = 0; j < m; j++) {
+        const binaryJ = 1 << j
+        if ((mask & binaryJ) === 0) res += min[j]
+      }
+    } else {
+      res = Infinity
+      for (let j = 0; j < m; j++) {
+        const binaryJ = 1 << j
+        res = Math.min(res, cost[i][j] + dfs(i + 1, mask | binaryJ))
+      }
+    }
+    dp[i][mask] = res
+    return res
+  }
+  return dfs(0, 0)
+}

From 1d6e6ec16cef027a2a3513465b8e4e2c2052eb37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Sep 2020 10:51:24 +0800
Subject: [PATCH 0828/3374] Create
 1589-maximum-sum-obtained-of-any-permutation.js

---
 ...maximum-sum-obtained-of-any-permutation.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1589-maximum-sum-obtained-of-any-permutation.js

diff --git a/1589-maximum-sum-obtained-of-any-permutation.js b/1589-maximum-sum-obtained-of-any-permutation.js
new file mode 100644
index 00000000..f101a480
--- /dev/null
+++ b/1589-maximum-sum-obtained-of-any-permutation.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maxSumRangeQuery = function (nums, requests) {
+  let res = 0
+  const mod = 10 ** 9 + 7,
+    n = nums.length
+  const count = Array(n).fill(0)
+  for (let r of requests) {
+    count[r[0]] += 1
+    if (r[1] + 1 < n) count[r[1] + 1] -= 1
+  }
+  for (let i = 1; i < n; i++) count[i] += count[i - 1]
+  nums.sort((a, b) => a - b)
+  count.sort((a, b) => a - b)
+  for (let i = 0; i < n; ++i) res = (res + nums[i] * count[i]) % mod
+  return res
+}

From 0f566980bc59dbb22ef18186a29024ef2c57bfab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Sep 2020 19:38:18 +0800
Subject: [PATCH 0829/3374] Update 152-maximum-product-subarray.js

---
 152-maximum-product-subarray.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/152-maximum-product-subarray.js b/152-maximum-product-subarray.js
index b4b9686d..75b21c55 100644
--- a/152-maximum-product-subarray.js
+++ b/152-maximum-product-subarray.js
@@ -45,3 +45,22 @@ const maxProduct = function(nums) {
   }
   return max;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxProduct = function(nums) {
+  const n = nums.length
+  let max, min
+  let res = max = min = nums[0]
+  for(let i = 1; i < n; i++) {
+    if(nums[i] < 0) [max, min] = [min, max]
+    max = Math.max(nums[i], nums[i] * max)
+    min = Math.min(nums[i], nums[i] * min)
+    res = Math.max(res, max)
+  }
+  return res
+};

From c72315a5a1d3cac11b900155262496cba4741a02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Sep 2020 16:39:30 +0800
Subject: [PATCH 0830/3374] Create
 1596-the-most-frequently-ordered-products-for-each-customer.sql

---
 ...frequently-ordered-products-for-each-customer.sql | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1596-the-most-frequently-ordered-products-for-each-customer.sql

diff --git a/1596-the-most-frequently-ordered-products-for-each-customer.sql b/1596-the-most-frequently-ordered-products-for-each-customer.sql
new file mode 100644
index 00000000..5675a407
--- /dev/null
+++ b/1596-the-most-frequently-ordered-products-for-each-customer.sql
@@ -0,0 +1,12 @@
+# Write your MySQL query statement below
+SELECT customer_id, product_id, product_name
+FROM (
+    SELECT O.customer_id, O.product_id, P.product_name, 
+    RANK() OVER (PARTITION BY customer_id ORDER BY COUNT(O.product_id) DESC) AS rnk
+    FROM Orders O
+    JOIN Products P
+    ON O.product_id = P.product_id  
+    GROUP BY customer_id, product_id
+) temp
+WHERE rnk = 1 
+ORDER BY customer_id, product_id;

From 25aca9a054834b07df3c6dab1ae323524f06877f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 26 Sep 2020 11:35:04 +0800
Subject: [PATCH 0831/3374] Update
 1190-reverse-substrings-between-each-pair-of-parentheses.js

---
 ...trings-between-each-pair-of-parentheses.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1190-reverse-substrings-between-each-pair-of-parentheses.js b/1190-reverse-substrings-between-each-pair-of-parentheses.js
index 7aeb2b03..cdfe4768 100644
--- a/1190-reverse-substrings-between-each-pair-of-parentheses.js
+++ b/1190-reverse-substrings-between-each-pair-of-parentheses.js
@@ -23,3 +23,33 @@ const reverseParentheses = function(s) {
   }
   return res[0]
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const reverseParentheses = function(s) {
+  const n = s.length
+  const stack = []
+  const pair = []
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '(') stack.push(i)
+    else if(s[i] === ')') {
+      const tmp = stack.pop()
+      pair[i] = tmp
+      pair[tmp] = i
+    }
+  }
+  let res = ''
+  for(let i = 0, d = 1; i < n; i += d) {
+    if(s[i] === '(' || s[i] ===')') {
+      i = pair[i]
+      d = -d
+    } else {
+      res += s[i]
+    }
+  }
+  return res
+}

From e218e97509568ecf1ed61c66eaf6c2dae3aa536b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Sep 2020 20:06:30 +0800
Subject: [PATCH 0832/3374] Create 1598-crawler-log-folder.js

---
 1598-crawler-log-folder.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1598-crawler-log-folder.js

diff --git a/1598-crawler-log-folder.js b/1598-crawler-log-folder.js
new file mode 100644
index 00000000..204799df
--- /dev/null
+++ b/1598-crawler-log-folder.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string[]} logs
+ * @return {number}
+ */
+const minOperations = function(logs) {
+  const stack = []
+  for(let i = 0, len = logs.length; i < len; i++) {
+    const e= logs[i]
+    if(e === '../') {
+      stack.pop()
+    } else if (e === './') {
+      
+    } else {
+      stack.push(e)
+    }
+  }
+  return stack.length
+};

From b53835fe53a6d69f8c3be481f33eee76a27b74fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Sep 2020 20:07:23 +0800
Subject: [PATCH 0833/3374] Create
 1599-maximum-profit-of-operating-a-centennial-wheel.js

---
 ...-profit-of-operating-a-centennial-wheel.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1599-maximum-profit-of-operating-a-centennial-wheel.js

diff --git a/1599-maximum-profit-of-operating-a-centennial-wheel.js b/1599-maximum-profit-of-operating-a-centennial-wheel.js
new file mode 100644
index 00000000..c1c107e9
--- /dev/null
+++ b/1599-maximum-profit-of-operating-a-centennial-wheel.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} customers
+ * @param {number} boardingCost
+ * @param {number} runningCost
+ * @return {number}
+ */
+const minOperationsMaxProfit = function(customers, boardingCost, runningCost) {
+  let remain = 0
+  let profit = 0
+  let cost = 0
+  let max = -Infinity
+  let maxNum = 0
+  for(let i = 0, len = customers.length; i < len; i++) {
+    const e = customers[i]
+    remain += e
+    const cur = (remain >= 4 ? 4 : remain)
+    remain -= cur
+    profit += cur * boardingCost - runningCost
+    if(profit > max) maxNum++
+    max = Math.max(max, profit)
+  }
+  if(remain) {
+    const r = Math.floor(remain / 4)
+    const single = 4 * boardingCost - runningCost
+    remain = remain % 4
+    // profit += (single * r + (remain > 0 ? (remain * boardingCost - runningCost) : 0))
+    profit += single * r
+    if(single > 0) maxNum += r
+    max = Math.max(max, profit)
+    if (remain < 4) {
+      const tmp = remain * boardingCost - runningCost
+      profit += tmp
+      remain = 0
+      if(profit > max) maxNum++
+      max = Math.max(max, profit)
+    }
+  }
+  if (max <=0 )return -1
+  return maxNum
+};

From 7cd268f296b809a99311b9c21f91e4c750067936 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Sep 2020 20:09:43 +0800
Subject: [PATCH 0834/3374] Create 1600-throne-inheritance.js

---
 1600-throne-inheritance.js | 51 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1600-throne-inheritance.js

diff --git a/1600-throne-inheritance.js b/1600-throne-inheritance.js
new file mode 100644
index 00000000..63865d1c
--- /dev/null
+++ b/1600-throne-inheritance.js
@@ -0,0 +1,51 @@
+/**
+ * @param {string} kingName
+ */
+const ThroneInheritance = function(kingName) {
+  this.king = kingName
+  this.m = {}
+  this.dead = {}
+};
+
+/** 
+ * @param {string} parentName 
+ * @param {string} childName
+ * @return {void}
+ */
+ThroneInheritance.prototype.birth = function(parentName, childName) {
+  if(!this.m[parentName]) this.m[parentName] = []
+  this.m[parentName].push(childName)
+};
+
+/** 
+ * @param {string} name
+ * @return {void}
+ */
+ThroneInheritance.prototype.death = function(name) {
+  this.dead[name] = 1
+};
+
+/**
+ * @return {string[]}
+ */
+ThroneInheritance.prototype.getInheritanceOrder = function() {
+  const res = []
+  this.dfs(res, this.king)
+  return res
+};
+ThroneInheritance.prototype.dfs = function(ans, root) {
+  if (!this.dead[root]) {
+    ans.push(root);
+  }
+  if(!this.m[root]) return
+  for (let child of this.m[root]) {
+    this.dfs(ans, child);
+  }
+};
+/** 
+ * Your ThroneInheritance object will be instantiated and called as such:
+ * var obj = new ThroneInheritance(kingName)
+ * obj.birth(parentName,childName)
+ * obj.death(name)
+ * var param_3 = obj.getInheritanceOrder()
+ */

From ec066c19a462ab05c44ea71e8f59cd172e893e93 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Sep 2020 20:10:26 +0800
Subject: [PATCH 0835/3374] Create
 1601-maximum-number-of-achievable-transfer-requests.js

---
 ...-number-of-achievable-transfer-requests.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1601-maximum-number-of-achievable-transfer-requests.js

diff --git a/1601-maximum-number-of-achievable-transfer-requests.js b/1601-maximum-number-of-achievable-transfer-requests.js
new file mode 100644
index 00000000..969324af
--- /dev/null
+++ b/1601-maximum-number-of-achievable-transfer-requests.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} n
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maximumRequests = function (n, requests) {
+  let max = 0
+  helper(requests, 0, Array(n).fill(0), 0)
+  return max
+
+  function helper(requests, index, count, num) {
+    // Traverse all n buildings to see if they are all 0. (means balanced)
+    if (index === requests.length) {
+      for (let i of count) {
+        if (0 !== i) {
+          return
+        }
+      }
+      max = Math.max(max, num)
+      return
+    }
+    // Choose this request
+    count[requests[index][0]]++
+    count[requests[index][1]]--
+    helper(requests, index + 1, count, num + 1)
+    count[requests[index][0]]--
+    count[requests[index][1]]++
+
+    // Not Choose the request
+    helper(requests, index + 1, count, num)
+  }
+}

From 6021aec645747b5fa255166cf97f053e49289031 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Sep 2020 19:57:14 +0800
Subject: [PATCH 0836/3374] Create 1586-binary-search-tree-iterator-ii.js

---
 1586-binary-search-tree-iterator-ii.js | 67 ++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 1586-binary-search-tree-iterator-ii.js

diff --git a/1586-binary-search-tree-iterator-ii.js b/1586-binary-search-tree-iterator-ii.js
new file mode 100644
index 00000000..53221850
--- /dev/null
+++ b/1586-binary-search-tree-iterator-ii.js
@@ -0,0 +1,67 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+const BSTIterator = function(root) {
+  this.r = root
+  const ans = []
+  helper(root, ans)
+  this.arr = ans
+  this.cur = -1
+};
+
+/**
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasNext = function() {
+  return this.arr.length && this.cur < this.arr.length - 1
+};
+
+/**
+ * @return {number}
+ */
+BSTIterator.prototype.next = function() {
+  this.cur += 1
+  return this.arr[this.cur]
+};
+
+/**
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasPrev = function() {
+  return this.arr.length && this.cur > 0
+};
+
+/**
+ * @return {number}
+ */
+BSTIterator.prototype.prev = function() {
+  return this.arr[--this.cur]
+};
+
+function helper(node, res) {
+  if(node == null) return
+  if(node.left) {
+    helper(node.left, res)
+  }
+  res.push(node.val)
+  if(node.right) {
+    helper(node.right, res)
+  }
+}
+
+/** 
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.hasNext()
+ * var param_2 = obj.next()
+ * var param_3 = obj.hasPrev()
+ * var param_4 = obj.prev()
+ */

From f43bc7300606a43cb6333c808d6c431f08617fc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Sep 2020 21:09:23 +0800
Subject: [PATCH 0837/3374] Update 1586-binary-search-tree-iterator-ii.js

---
 1586-binary-search-tree-iterator-ii.js | 73 ++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/1586-binary-search-tree-iterator-ii.js b/1586-binary-search-tree-iterator-ii.js
index 53221850..305d57e3 100644
--- a/1586-binary-search-tree-iterator-ii.js
+++ b/1586-binary-search-tree-iterator-ii.js
@@ -65,3 +65,76 @@ function helper(node, res) {
  * var param_3 = obj.hasPrev()
  * var param_4 = obj.prev()
  */
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+const BSTIterator = function (root) {
+  this.nums = []
+  this.stack = []
+  this.node = root
+  this.i = 0 // pointer to next node
+  this.size = 0
+}
+
+/**
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasNext = function () {
+  return this.i < this.size || this.stack.length > 0 || !!this.node
+}
+
+/**
+ * @return {number}
+ */
+BSTIterator.prototype.next = function () {
+  if (this.i < this.size) return this.nums[this.i++]
+  if (this.stack.length || this.node) {
+    while (this.node) {
+      this.stack.push(this.node)
+      this.node = this.node.left
+    }
+    this.node = this.stack.pop()
+    this.i += 1
+    this.size += 1
+    const val = this.node.val
+    this.nums.push(val)
+    this.node = this.node.right
+    return val
+  }
+  return -1
+}
+
+/**
+ * @return {boolean}
+ */
+BSTIterator.prototype.hasPrev = function () {
+  return this.i - 2 >= 0
+}
+
+/**
+ * @return {number}
+ */
+BSTIterator.prototype.prev = function () {
+  return this.nums[--this.i - 1]
+}
+
+/**
+ * Your BSTIterator object will be instantiated and called as such:
+ * var obj = new BSTIterator(root)
+ * var param_1 = obj.hasNext()
+ * var param_2 = obj.next()
+ * var param_3 = obj.hasPrev()
+ * var param_4 = obj.prev()
+ */
+

From 352b6b58e7927c2d10aad52e9a75675ee7782196 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Sep 2020 08:58:09 +0800
Subject: [PATCH 0838/3374] Update 55-jump-game.js

---
 55-jump-game.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/55-jump-game.js b/55-jump-game.js
index d9185fcf..baaae368 100644
--- a/55-jump-game.js
+++ b/55-jump-game.js
@@ -11,3 +11,20 @@ const canJump = function(nums) {
   }
   return max >= nums.length - 1
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canJump = function(nums) {
+  let max = 0
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    if(max < i) return false
+    max = Math.max(max, i + nums[i])
+    if(max >= n - 1) return true
+  }
+  return max >= n - 1
+};

From 756aec5e5aa72d5eec51da8d64fdeed4f1f67594 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Sep 2020 09:16:17 +0800
Subject: [PATCH 0839/3374] Create 1410-html-entity-parser.js

---
 1410-html-entity-parser.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1410-html-entity-parser.js

diff --git a/1410-html-entity-parser.js b/1410-html-entity-parser.js
new file mode 100644
index 00000000..0de11d99
--- /dev/null
+++ b/1410-html-entity-parser.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} text
+ * @return {string}
+ */
+const entityParser = function(text) {
+  const q = /&quot;/g
+  const s = /&apos;/g
+  const a = /&amp;/g
+  const g = /&gt;/g
+  const l = /&lt;/g
+  const sl = /&frasl;/g
+  let t = text.replace(q, '"')
+  t = t.replace(q, '"')
+  t = t.replace(s, "'")
+  t = t.replace(g, '>')
+  t = t.replace(l, '<')
+  t = t.replace(sl, '/')
+  t = t.replace(a, '&')
+  return t
+};

From 56be66f918703a57285307b280e5661525cb6450 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Oct 2020 13:05:18 +0800
Subject: [PATCH 0840/3374] Create 1306-jump-game-iii.js

---
 1306-jump-game-iii.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1306-jump-game-iii.js

diff --git a/1306-jump-game-iii.js b/1306-jump-game-iii.js
new file mode 100644
index 00000000..d19c6842
--- /dev/null
+++ b/1306-jump-game-iii.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} arr
+ * @param {number} start
+ * @return {boolean}
+ */
+const canReach = function(arr, start) {
+  const s = new Set()
+  return helper(arr, start, s)
+};
+
+function helper(arr, start, s) {
+  if(start < 0 || start >= arr.length || s.has(start)) return false
+  s.add(start)
+  if(arr[start] === 0) return true
+  
+  return helper(arr, start + arr[start], s) || helper(arr, start - arr[start], s)
+}

From 3bb35ff8f095ce2627988185b080303e2d706580 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Oct 2020 13:28:30 +0800
Subject: [PATCH 0841/3374] Update 1306-jump-game-iii.js

---
 1306-jump-game-iii.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/1306-jump-game-iii.js b/1306-jump-game-iii.js
index d19c6842..f5cd5620 100644
--- a/1306-jump-game-iii.js
+++ b/1306-jump-game-iii.js
@@ -15,3 +15,19 @@ function helper(arr, start, s) {
   
   return helper(arr, start + arr[start], s) || helper(arr, start - arr[start], s)
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @param {number} start
+ * @return {boolean}
+ */
+const canReach = function (A, i) {
+  return (
+    0 <= i &&
+    i < A.length &&
+    A[i] >= 0 &&
+    (!(A[i] = -A[i]) || canReach(A, i + A[i]) || canReach(A, i - A[i]))
+  )
+}

From a104f0c104510b4fa678cc126e5b0f3e940ebe97 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Oct 2020 14:43:32 +0800
Subject: [PATCH 0842/3374] Update 1306-jump-game-iii.js

---
 1306-jump-game-iii.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1306-jump-game-iii.js b/1306-jump-game-iii.js
index f5cd5620..d3abea41 100644
--- a/1306-jump-game-iii.js
+++ b/1306-jump-game-iii.js
@@ -31,3 +31,27 @@ const canReach = function (A, i) {
     (!(A[i] = -A[i]) || canReach(A, i + A[i]) || canReach(A, i - A[i]))
   )
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @param {number} start
+ * @return {boolean}
+ */
+const canReach = function(arr, start) {
+  const q = [start]
+  const s = new Set()
+  while(q.length) {
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const cur = q.shift()
+      s.add(cur)
+      if(arr[cur] === 0) return true
+      if(!s.has(cur + arr[cur])) q.push(cur + arr[cur])
+      if(!s.has(cur - arr[cur])) q.push(cur - arr[cur])
+    }
+  }
+  return false
+};
+

From 50f6b961460648cefa9de9b5fde660897286f380 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Oct 2020 18:03:05 +0800
Subject: [PATCH 0843/3374] Update 1345-jump-game-iv.js

---
 1345-jump-game-iv.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1345-jump-game-iv.js b/1345-jump-game-iv.js
index 73c89ef5..23ef9e34 100644
--- a/1345-jump-game-iv.js
+++ b/1345-jump-game-iv.js
@@ -43,3 +43,41 @@ var minJumps = function (arr) {
   }
   return -1
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minJumps = function (arr) {
+  if (arr.length === 1) return 0
+  const n = arr.length
+  const indexMap = new Map()
+  for (let i = n - 1; i >= 0; i--) {
+    if (!indexMap.has(arr[i])) {
+      indexMap.set(arr[i], [])
+    }
+    indexMap.get(arr[i]).push(i)
+  }
+  let distance = 0
+  const queue = [0]
+  const visited = new Set()
+  visited.add(0)
+  while (queue.length) {
+    const len = queue.length
+    for(let i = 0; i < len; i++) {
+      const cur = queue.shift()
+      visited.add(cur)
+      if(cur === n - 1) return distance
+      if(cur + 1 < n && !visited.has(cur + 1)) queue.push(cur + 1)
+      if(cur - 1 >= 0 && !visited.has(cur - 1)) queue.push(cur - 1)
+      for(let next of indexMap.get(arr[cur])) {
+        if(!visited.has(next)) queue.push(next)
+      }
+      indexMap.set(arr[cur], [])
+    }
+    distance++
+  }
+  return -1
+}

From 55d1c5074fde3a98ce1dcf401590e7a233c7acee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Oct 2020 18:27:20 +0800
Subject: [PATCH 0844/3374] Update 1345-jump-game-iv.js

---
 1345-jump-game-iv.js | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/1345-jump-game-iv.js b/1345-jump-game-iv.js
index 23ef9e34..5e67c588 100644
--- a/1345-jump-game-iv.js
+++ b/1345-jump-game-iv.js
@@ -68,12 +68,15 @@ const minJumps = function (arr) {
     const len = queue.length
     for(let i = 0; i < len; i++) {
       const cur = queue.shift()
-      visited.add(cur)
       if(cur === n - 1) return distance
-      if(cur + 1 < n && !visited.has(cur + 1)) queue.push(cur + 1)
-      if(cur - 1 >= 0 && !visited.has(cur - 1)) queue.push(cur - 1)
-      for(let next of indexMap.get(arr[cur])) {
-        if(!visited.has(next)) queue.push(next)
+      const tmp = indexMap.get(arr[cur])
+      tmp.push(cur - 1)
+      tmp.push(cur + 1)
+      for(let e of tmp) {
+        if(e >= 0 && e < n && !visited.has(e)) {
+          visited.add(e)
+          queue.push(e)
+        }
       }
       indexMap.set(arr[cur], [])
     }
@@ -81,3 +84,4 @@ const minJumps = function (arr) {
   }
   return -1
 }
+

From ca3ec64e50af5a228324caa632a624d751330021 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Oct 2020 08:43:45 +0800
Subject: [PATCH 0845/3374] Update 1340-jump-game-v.js

---
 1340-jump-game-v.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1340-jump-game-v.js b/1340-jump-game-v.js
index 5f540740..60945fdd 100644
--- a/1340-jump-game-v.js
+++ b/1340-jump-game-v.js
@@ -55,3 +55,38 @@ const maxJumps = function (arr, d) {
   for (let i = 0; i < arr.length; i++) dfs(i)
   return Math.max(...cache)
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @param {number} d
+ * @return {number}
+ */
+const maxJumps = function (arr, d, res = 0) {
+  const n = arr.length
+  const stack = [], stack2 = []
+  const dp = Array(n + 1).fill(1)
+  arr.push(Infinity)
+  for(let i = 0; i <= n; i++) {
+    while(stack.length && arr[stack[stack.length - 1]] < arr[i]) {
+      const pre = arr[stack[stack.length - 1]]
+      while(stack.length && pre === arr[stack[stack.length - 1]]) {
+        const j = stack[stack.length - 1]
+        stack.pop()
+        if(i - j <= d) dp[i] = Math.max(dp[i], dp[j] + 1)
+        stack2.push(j)
+      }
+      while(stack2.length) {
+        const j = stack2[stack2.length - 1]
+        stack2.pop()
+        if(stack.length && j - stack[stack.length - 1] <= d) {
+          dp[stack[stack.length - 1]] = Math.max(dp[stack[stack.length - 1]], dp[j] + 1)
+        }
+      }
+    }
+    stack.push(i)
+  }
+  for(let i = 0; i < n; i++) res = Math.max(res, dp[i]) 
+  return res
+}

From daf06828e74d2d94733b664590f338d3f3f20011 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 09:08:37 +0800
Subject: [PATCH 0846/3374] Update 403-frog-jump.js

---
 403-frog-jump.js | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/403-frog-jump.js b/403-frog-jump.js
index 3b85b0c0..3fb75305 100644
--- a/403-frog-jump.js
+++ b/403-frog-jump.js
@@ -8,18 +8,18 @@ const canCross = function(stones) {
       return false
     }
   }
-  let count = new Set(stones)
-  let lastStone = stones[stones.length - 1]
-  let position = [0]
-  let jump = [0]
+  const count = new Set(stones)
+  const lastStone = stones[stones.length - 1]
+  const position = [0]
+  const jump = [0]
   while (position.length > 0) {
-    let nextPosition = position.pop()
-    let nextDistance = jump.pop()
+    const nextPosition = position.pop()
+    const nextDistance = jump.pop()
     for (let i = nextDistance - 1; i <= nextDistance + 1; i++) {
       if (i <= 0) {
         continue
       }
-      let nextStone = nextPosition + i
+      const nextStone = nextPosition + i
       if (nextStone == lastStone) {
         return true
       } else if (count.has(nextStone)) {

From 2fa4efd743ecfa2c41e9941d9b1cef4cf135e024 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 13:43:05 +0800
Subject: [PATCH 0847/3374] Create
 1608-special-array-with-x-elements-greater-than-or-equal-x.js

---
 ...array-with-x-elements-greater-than-or-equal-x.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1608-special-array-with-x-elements-greater-than-or-equal-x.js

diff --git a/1608-special-array-with-x-elements-greater-than-or-equal-x.js b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
new file mode 100644
index 00000000..8011c6c7
--- /dev/null
+++ b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const specialArray = function (nums) {
+    nums.sort((a, b) => b - a)
+    let i = 0
+    while(i < nums.length && nums[i] >= i) {
+      i++
+    }
+    if(nums[i - 1] < i) return -1
+    return i
+};

From 981a7dfb6125d795bc2e8c46bf8bf8b7329c9a01 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 13:55:24 +0800
Subject: [PATCH 0848/3374] Create 1609-even-odd-tree.js

---
 1609-even-odd-tree.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1609-even-odd-tree.js

diff --git a/1609-even-odd-tree.js b/1609-even-odd-tree.js
new file mode 100644
index 00000000..2e65d6fc
--- /dev/null
+++ b/1609-even-odd-tree.js
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const isEvenOddTree = function(root) {
+  const q = [root]
+  const v = []
+  let l = 0
+  while(q.length) {
+    const size = q.length
+    const row = []
+    for(let i = 0; i < size; i++) {
+      const cur = q.shift()
+      row.push(cur.val)
+      if(l % 2 === 0 && cur.val % 2 === 0) return false
+      if(l % 2 === 1 && cur.val % 2 === 1) return false
+      if(row.length > 1) {
+        if(l % 2 === 0 && row[row.length - 1] <= row[row.length - 2]) return false
+        if(l % 2 === 1 && row[row.length - 1] >= row[row.length - 2]) return false
+      }
+      if(cur.left) q.push(cur.left)
+      if(cur.right) q.push(cur.right)
+    }
+    l++
+  }
+  return true
+};

From aaaf7bd51da681d25e42809f1bb93b4b9f571259 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 13:56:51 +0800
Subject: [PATCH 0849/3374] Create 1610-maximum-number-of-visible-points.js

---
 1610-maximum-number-of-visible-points.js | 31 ++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1610-maximum-number-of-visible-points.js

diff --git a/1610-maximum-number-of-visible-points.js b/1610-maximum-number-of-visible-points.js
new file mode 100644
index 00000000..5b0abe64
--- /dev/null
+++ b/1610-maximum-number-of-visible-points.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[][]} points
+ * @param {number} angle
+ * @param {number[]} location
+ * @return {number}
+ */
+const visiblePoints = function (points, angle, location) {
+  const angles = [];
+  let count = 0;
+  for (let p of points) {
+    let dx = p[0] - location[0];
+    let dy = p[1] - location[1];
+    if (dx == 0 && dy == 0) {
+      // edge case of same point
+      count++;
+      continue;
+    }
+    angles.push(Math.atan2(dy, dx) * (180 / Math.PI));
+  }
+  angles.sort();
+  const tmp = angles.slice();
+  for (let d of angles) tmp.push(d + 360); // concatenate to handle edge case
+  let res = count;
+  for (let i = 0, j = 0; i < tmp.length; i++) {
+    while (tmp[i] - tmp[j] > angle) {
+      j++;
+    }
+    res = Math.max(res, count + i - j + 1);
+  }
+  return res;
+};

From 40e3371e13ec99ca2fa26401ba3ef8b92de80bed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 13:57:38 +0800
Subject: [PATCH 0850/3374] Create
 1611-minimum-one-bit-operations-to-make-integers-zero.js

---
 ...mum-one-bit-operations-to-make-integers-zero.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1611-minimum-one-bit-operations-to-make-integers-zero.js

diff --git a/1611-minimum-one-bit-operations-to-make-integers-zero.js b/1611-minimum-one-bit-operations-to-make-integers-zero.js
new file mode 100644
index 00000000..383b6073
--- /dev/null
+++ b/1611-minimum-one-bit-operations-to-make-integers-zero.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minimumOneBitOperations = function (n) {
+  let sign = 1,
+    res = 0;
+  while (n) {
+    res += n ^ ((n - 1) * sign);
+    n &= n - 1;
+    sign = -sign;
+  }
+  return Math.abs(res);
+};

From e8d0f46ba9369acf50c42f57180af740843f296a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Oct 2020 23:34:33 +0800
Subject: [PATCH 0851/3374] Update
 1611-minimum-one-bit-operations-to-make-integers-zero.js

---
 ...um-one-bit-operations-to-make-integers-zero.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1611-minimum-one-bit-operations-to-make-integers-zero.js b/1611-minimum-one-bit-operations-to-make-integers-zero.js
index 383b6073..5dbebabe 100644
--- a/1611-minimum-one-bit-operations-to-make-integers-zero.js
+++ b/1611-minimum-one-bit-operations-to-make-integers-zero.js
@@ -12,3 +12,18 @@ const minimumOneBitOperations = function (n) {
   }
   return Math.abs(res);
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minimumOneBitOperations = function(n) {
+  let mask = n;
+  while (mask) {
+    mask >>= 1;
+    n   ^= mask;
+  }
+  return n;
+};

From b32dac257955ad93016ca3da624b12b9f2aceedc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Oct 2020 10:04:06 +0800
Subject: [PATCH 0852/3374] Create
 1605-find-valid-matrix-given-row-and-column-sums.js

---
 ...nd-valid-matrix-given-row-and-column-sums.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1605-find-valid-matrix-given-row-and-column-sums.js

diff --git a/1605-find-valid-matrix-given-row-and-column-sums.js b/1605-find-valid-matrix-given-row-and-column-sums.js
new file mode 100644
index 00000000..2aff69a5
--- /dev/null
+++ b/1605-find-valid-matrix-given-row-and-column-sums.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} rowSum
+ * @param {number[]} colSum
+ * @return {number[][]}
+ */
+const restoreMatrix = function(rowSum, colSum) {
+  const m = rowSum.length, n = colSum.length;
+  const res = Array.from({ length: m }, () => Array(n).fill(0));
+  for (let i = 0; i < m; ++i) {
+    for (let j = 0 ; j < n; ++j) {
+      res[i][j] = Math.min(rowSum[i], colSum[j]);
+      rowSum[i] -= res[i][j];
+      colSum[j] -= res[i][j];
+    }
+  }
+  return res;
+};

From dd65e42e103a09d600b0db725860462286f867db Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Oct 2020 11:11:45 +0800
Subject: [PATCH 0853/3374] Create
 1606-find-servers-that-handled-most-number-of-requests.js

---
 ...rs-that-handled-most-number-of-requests.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1606-find-servers-that-handled-most-number-of-requests.js

diff --git a/1606-find-servers-that-handled-most-number-of-requests.js b/1606-find-servers-that-handled-most-number-of-requests.js
new file mode 100644
index 00000000..1c2a1f71
--- /dev/null
+++ b/1606-find-servers-that-handled-most-number-of-requests.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} k
+ * @param {number[]} arrival
+ * @param {number[]} load
+ * @return {number[]}
+ */
+const busiestServers = function (k, arrival, load) {
+  const ark = []
+  const map = new Map()
+  let max = 0
+  for (let i = 0; i < arrival.length; i++) {
+    if (i < k) {
+      ark[i] = arrival[i] + load[i]
+      map.set(i, 1)
+      max = Math.max(max, map.get(i))
+    } else {
+      let server = i % k
+      const curr = server
+      while (server < k) {
+        if (ark[server] <= arrival[i]) {
+          ark[server] = arrival[i] + load[i]
+          map.set(server, map.has(server) ? map.get(server) + 1 : 1)
+          max = Math.max(max, map.get(server))
+          break
+        }
+        server++
+      }
+      if (server === k) {
+        let l = 0
+        while (l < curr) {
+          if (ark[l] <= arrival[i]) {
+            ark[l] = arrival[i] + load[i]
+            map.set(l, map.has(l) ? map.get(l) + 1 : 1)
+            max = Math.max(max, map.get(l))
+            break
+          }
+          l++
+        }
+      }
+    }
+  }
+
+  const result = []
+  const entries = map[Symbol.iterator]()
+  for (let en of entries) {
+    if (en[1] === max) {
+      result.push(en[0])
+    }
+  }
+  return result
+}

From 46ab5f32513b9a4805fc16f270df274af3c4b434 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Oct 2020 22:49:36 +0800
Subject: [PATCH 0854/3374] Create 1009-complement-of-base-10-integer.js

---
 1009-complement-of-base-10-integer.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1009-complement-of-base-10-integer.js

diff --git a/1009-complement-of-base-10-integer.js b/1009-complement-of-base-10-integer.js
new file mode 100644
index 00000000..793d711c
--- /dev/null
+++ b/1009-complement-of-base-10-integer.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const bitwiseComplement = function (N) {
+  if (N === 0) return 1
+  // bitmask has the same length as N and contains only ones 1...1
+  let bitmask = N
+  bitmask |= bitmask >> 1
+  bitmask |= bitmask >> 2
+  bitmask |= bitmask >> 4
+  bitmask |= bitmask >> 8
+  bitmask |= bitmask >> 16
+  // flip all bits
+  return bitmask ^ N
+}

From 2fba5d06e0afeee8154364fd94d627520b4f26f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Oct 2020 22:59:33 +0800
Subject: [PATCH 0855/3374] Update 1009-complement-of-base-10-integer.js

---
 1009-complement-of-base-10-integer.js | 28 +++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1009-complement-of-base-10-integer.js b/1009-complement-of-base-10-integer.js
index 793d711c..f88696bd 100644
--- a/1009-complement-of-base-10-integer.js
+++ b/1009-complement-of-base-10-integer.js
@@ -14,3 +14,31 @@ const bitwiseComplement = function (N) {
   // flip all bits
   return bitmask ^ N
 }
+
+// another
+
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const bitwiseComplement = function (N) {
+  let X = 1;
+  while (N > X) X = X * 2 + 1;
+  return N ^ X;
+}
+
+// another
+
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const bitwiseComplement = function (N) {
+  if (N === 0) return 1
+  // l is a length of N in binary representation
+  const l = Math.floor(Math.log(N) / Math.log(2)) + 1
+  // bitmask has the same length as num and contains only ones 1...1
+  const bitmask = (1 << l) - 1
+  // flip all bits
+  return bitmask ^ N
+}

From 0924729b8055ad94913a84b11773db05c8d8674a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Oct 2020 12:01:24 +0800
Subject: [PATCH 0856/3374] Create 1607-sellers-with-no-sales.sql

---
 1607-sellers-with-no-sales.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1607-sellers-with-no-sales.sql

diff --git a/1607-sellers-with-no-sales.sql b/1607-sellers-with-no-sales.sql
new file mode 100644
index 00000000..cbce028d
--- /dev/null
+++ b/1607-sellers-with-no-sales.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT DISTINCT seller_name
+FROM seller s
+WHERE seller_id NOT IN (
+    SELECT DISTINCT seller_id 
+    FROM orders
+    WHERE YEAR(sale_date) = 2020
+)
+ORDER BY 1;

From 2d6c385669a4c5d96963f6e4c726e7ca3e223fdb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Oct 2020 18:51:52 +0800
Subject: [PATCH 0857/3374] Create
 1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js

---
 ...aving-the-same-number-of-distinct-balls.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js

diff --git a/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js b/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js
new file mode 100644
index 00000000..91fd6105
--- /dev/null
+++ b/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[]} balls
+ * @return {number}
+ */
+const getProbability = function (balls) {
+  const k = balls.length
+  const halfUsed = balls.reduce((acc, val) => acc + val, 0) / 2
+  const startArray = new Array(k)
+  startArray.fill(0)
+  const perm = function (b1, b2) {
+    let p1, p2, s1, s2
+    s1 = b1.reduce((acc, val) => acc + val, 0)
+    s2 = b2.reduce((acc, val) => acc + val, 0)
+    const fact = function (n) {
+      let f = 1
+      for (let i = 2; i <= n; i++) f *= i
+      return f
+    }
+    p1 = fact(s1)
+    p2 = fact(s2)
+    b1.forEach((val) => {
+      if (val > 1) p1 /= fact(val)
+    })
+    b2.forEach((val) => {
+      if (val > 1) p2 /= fact(val)
+    })
+    return p1 * p2
+  }
+
+  const getValidCombos = function (ballsUsed, colorNum = 0) {
+    let box1Used = ballsUsed.reduce((acc, val) => acc + val, 0)
+    let matches = { good: 0, total: 0 },
+      thisColorMax = halfUsed - box1Used
+    if (colorNum === k - 1) {
+      if (thisColorMax > balls[colorNum]) return { good: 0, total: 0 }
+      ballsUsed[colorNum] = thisColorMax
+      let ballsLeft = []
+      let colorsUsed = [0, 0]
+      for (let i = 0; i < k; i++) {
+        ballsLeft[i] = balls[i] - ballsUsed[i]
+        if (ballsUsed[i] > 0) colorsUsed[0]++
+        if (ballsLeft[i] > 0) colorsUsed[1]++
+      }
+      let permutations = perm(ballsUsed, ballsLeft, k)
+      return {
+        good: colorsUsed[1] === colorsUsed[0] ? permutations : 0,
+        total: permutations,
+      }
+    }
+    thisColorMax = Math.min(thisColorMax, balls[colorNum])
+    for (let i = 0; i <= thisColorMax; i++) {
+      let match = getValidCombos([...ballsUsed], colorNum + 1)
+      matches = {
+        good: matches.good + match.good,
+        total: matches.total + match.total,
+      }
+      ballsUsed[colorNum]++
+    }
+    return matches
+  }
+  let res = getValidCombos(startArray)
+  return res.good / res.total
+}

From 4d8ebbe6f1ac8d61ace35b8b4e8e5e189dabcde6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Oct 2020 12:53:58 +0800
Subject: [PATCH 0858/3374] Update
 1611-minimum-one-bit-operations-to-make-integers-zero.js

---
 ...um-one-bit-operations-to-make-integers-zero.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1611-minimum-one-bit-operations-to-make-integers-zero.js b/1611-minimum-one-bit-operations-to-make-integers-zero.js
index 5dbebabe..ec1f28f8 100644
--- a/1611-minimum-one-bit-operations-to-make-integers-zero.js
+++ b/1611-minimum-one-bit-operations-to-make-integers-zero.js
@@ -27,3 +27,18 @@ const minimumOneBitOperations = function(n) {
   }
   return n;
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minimumOneBitOperations = function(n) {
+  n ^= n >> 16
+  n ^= n >>  8
+  n ^= n >>  4
+  n ^= n >>  2
+  n ^= n >>  1
+  return n
+};

From 9b0e2bc795236355d2af439c0ea0e611b0e5dd6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Oct 2020 19:53:13 +0800
Subject: [PATCH 0859/3374] Update
 1608-special-array-with-x-elements-greater-than-or-equal-x.js

---
 ...y-with-x-elements-greater-than-or-equal-x.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/1608-special-array-with-x-elements-greater-than-or-equal-x.js b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
index 8011c6c7..0929a428 100644
--- a/1608-special-array-with-x-elements-greater-than-or-equal-x.js
+++ b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
@@ -11,3 +11,20 @@ const specialArray = function (nums) {
     if(nums[i - 1] < i) return -1
     return i
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const specialArray = function(nums) {
+  nums.sort((a, b) => b - a)
+  let left = 0, right = nums.length
+  while(left <= right) {
+    const mid = left + ((right - left) >> 1)
+    if(mid < nums[mid]) left = mid + 1
+    else right = mid - 1
+  }
+  return left < nums.length && left === nums[left] ? -1 : left
+};

From 83cab8d97c1468c258ac28a6ec8c1cd6937633dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Oct 2020 20:21:25 +0800
Subject: [PATCH 0860/3374] Update
 1608-special-array-with-x-elements-greater-than-or-equal-x.js

---
 1608-special-array-with-x-elements-greater-than-or-equal-x.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/1608-special-array-with-x-elements-greater-than-or-equal-x.js b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
index 0929a428..6964d8c3 100644
--- a/1608-special-array-with-x-elements-greater-than-or-equal-x.js
+++ b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
@@ -26,5 +26,7 @@ const specialArray = function(nums) {
     if(mid < nums[mid]) left = mid + 1
     else right = mid - 1
   }
+  // if we found i == nums[i], there will be i + 1 items
+  // larger or equal to i, which makes array not special.
   return left < nums.length && left === nums[left] ? -1 : left
 };

From 337c11d8a398d9abd5da98de4c723d7cecb76140 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Oct 2020 09:48:00 +0800
Subject: [PATCH 0861/3374] Create 1590-make-sum-divisible-by-p.js

---
 1590-make-sum-divisible-by-p.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1590-make-sum-divisible-by-p.js

diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
new file mode 100644
index 00000000..7459d27c
--- /dev/null
+++ b/1590-make-sum-divisible-by-p.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+const minSubarray = function(nums, p) {
+  const diff = nums.reduce((a, b) => a + b, 0) % p;
+  let res = diff === 0 ? 0 : nums.length;
+  
+  for (let i = 0, sum = 0, map = {0: -1}; i < nums.length; i++) {
+    sum += nums[i];
+    const target = (sum % p - diff + p) % p;
+    if (map[target] !== undefined) {
+      res = Math.min(res, i - map[target]);
+    }
+    map[sum % p] = i;
+  }
+  
+  return res === nums.length ? -1 : res;
+};

From 324812e4518ae1ea91ff98cecb19dda7a7f0e1a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Oct 2020 11:18:58 +0800
Subject: [PATCH 0862/3374] Update 1590-make-sum-divisible-by-p.js

---
 1590-make-sum-divisible-by-p.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
index 7459d27c..61d36c0c 100644
--- a/1590-make-sum-divisible-by-p.js
+++ b/1590-make-sum-divisible-by-p.js
@@ -18,3 +18,18 @@ const minSubarray = function(nums, p) {
   
   return res === nums.length ? -1 : res;
 };
+
+/**
+
+Let pre[] be the prefix sum array,
+then pre[i] is running prefix sum or prefix sum of i elements,
+pre[j] is the prefix sum such that pre[i]-pre[j] is the subarray we
+need to remove to make pre[n] (sum of all elements) divisible by p
+
+(pre[n] - (pre[i]-pre[j])) % p = 0 ... (remove a subarray to make pre[n] divisible by p)
+=> pre[n] % p = (pre[i]-pre[j]) % p ... ((a-b)%m = a%m - b%m)
+=> pre[j]%p = pre[i]%p - pre[n]%p ... (same property used above)
+since RHS can be negative we make it positive modulus by adding p and taking modulus
+=> pre[j]%p = (pre[i]%p - pre[n]%p + p) % p
+
+*/

From 65de8356e5f396d10a99727d006134c59662a829 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Oct 2020 18:56:27 +0800
Subject: [PATCH 0863/3374] Create
 1567-maximum-length-of-subarray-with-positive-product.js

---
 ...ength-of-subarray-with-positive-product.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1567-maximum-length-of-subarray-with-positive-product.js

diff --git a/1567-maximum-length-of-subarray-with-positive-product.js b/1567-maximum-length-of-subarray-with-positive-product.js
new file mode 100644
index 00000000..aa384d85
--- /dev/null
+++ b/1567-maximum-length-of-subarray-with-positive-product.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const getMaxLen = function(nums) {
+  let res = 0, zeroIdx = -1, negIdx = -1, count = 0
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(nums[i] < 0) {
+      count++
+      if(negIdx === -1) negIdx = i
+    }
+    if(nums[i] === 0) {
+      count = 0
+      negIdx = -1
+      zeroIdx = i
+    } else {
+      if(count % 2 === 0) res = Math.max(res, i - zeroIdx)
+      else res = Math.max(res, i - negIdx)
+    }
+  }
+  
+  return res
+};

From a7b43abcd4d70062dcd10c5d2facd9df4d6ea34f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Oct 2020 19:00:38 +0800
Subject: [PATCH 0864/3374] Create
 1614-maximum-nesting-depth-of-the-parentheses.js

---
 ...maximum-nesting-depth-of-the-parentheses.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1614-maximum-nesting-depth-of-the-parentheses.js

diff --git a/1614-maximum-nesting-depth-of-the-parentheses.js b/1614-maximum-nesting-depth-of-the-parentheses.js
new file mode 100644
index 00000000..6c5f2ed6
--- /dev/null
+++ b/1614-maximum-nesting-depth-of-the-parentheses.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxDepth = function(s) {
+  const stack = []
+  let res = 0
+  for(let i = 0, len = s.length; i < len; i++) {
+    if(s[i] === '(') {
+      stack.push('(')
+      res = Math.max(res, stack.length)
+    } else if(s[i] === ')') {
+      stack.pop()
+    }
+  }
+  
+  return res
+};

From 88a3042d1004273673ba6e0fe3d2b635d2dde7e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Oct 2020 19:01:16 +0800
Subject: [PATCH 0865/3374] Create 1615-maximal-network-rank.js

---
 1615-maximal-network-rank.js | 50 ++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1615-maximal-network-rank.js

diff --git a/1615-maximal-network-rank.js b/1615-maximal-network-rank.js
new file mode 100644
index 00000000..de90d0c6
--- /dev/null
+++ b/1615-maximal-network-rank.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number} n
+ * @param {number[][]} roads
+ * @return {number}
+ */
+const maximalNetworkRank = function (n, roads) {
+  const edgeCount = new Array(n).fill(0);
+  const m = roads.length;
+  const map = new Map();
+  for (let i = 0; i < m; i++) {
+    edgeCount[roads[i][0]]++;
+    edgeCount[roads[i][1]]++;
+    if (!map.has(roads[i][0])) {
+      map.set(roads[i][0], new Set());
+    }
+    if (!map.has(roads[i][1])) {
+      map.set(roads[i][1], new Set());
+    }
+    const A = map.get(roads[i][0]);
+    A.add(roads[i][1]);
+    const B = map.get(roads[i][1]);
+    B.add(roads[i][0]);
+  }
+
+  let maxRank = 0;
+  for (let i = 0; i < m; i++) {
+    let rank = edgeCount[roads[i][0]] + edgeCount[roads[i][1]] - 1;
+    if (rank > maxRank) {
+      maxRank = rank;
+    }
+  }
+  const keys = [];
+  for (let k of map.keys()) keys.push(k);
+  // console.log(keys, map)
+  for (let i = 0, len = keys.length; i < m - 1; i++) {
+    const tmp = map.get(keys[i]);
+    for (let j = i + 1; j < m; j++) {
+      // console.log(tmp, i, j, tmp.has(keys[j]))
+      if (tmp && !tmp.has(keys[j])) {
+        let rank = edgeCount[keys[i]] + edgeCount[keys[j]];
+        if (rank > maxRank) {
+          maxRank = rank;
+        }
+      }
+    }
+  }
+  
+
+  return maxRank;
+};

From 7edcc4bb4f55d43bd8e6432875b02464c3b08858 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Oct 2020 19:01:52 +0800
Subject: [PATCH 0866/3374] Create 1616-split-two-strings-to-make-palindrome.js

---
 1616-split-two-strings-to-make-palindrome.js | 31 ++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1616-split-two-strings-to-make-palindrome.js

diff --git a/1616-split-two-strings-to-make-palindrome.js b/1616-split-two-strings-to-make-palindrome.js
new file mode 100644
index 00000000..8bce584a
--- /dev/null
+++ b/1616-split-two-strings-to-make-palindrome.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {boolean}
+ */
+const checkPalindromeFormation = function(a, b) {
+  return helper(a, b) || helper(b, a)
+};
+
+function helper(A, B) {
+  const str_len = A.length
+  let idx = 0
+  while(A[idx] === B[str_len - idx - 1]) {
+    idx += 1
+  }
+  console.log(idx)
+  if (idx > Math.floor(str_len / 2) ) return true
+  else if (chk(A.slice(idx + 1, str_len - idx - 2 + 1))) return true
+  else if (chk(B.slice(idx + 1, str_len - idx - 2 + 1))) return true
+  else return false
+} 
+
+function chk(s) {
+  let l = 0, r = s.length - 1
+  while(l < r) {
+    if(s[l] !== s[r]) return false
+    l++
+    r--
+  }
+  return true
+}

From 57db01b11b9ef1bd63f0a9b8125e3dcf1f74cdc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Oct 2020 10:46:37 +0800
Subject: [PATCH 0867/3374] Update 416-partition-equal-subset-sum.js

---
 416-partition-equal-subset-sum.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/416-partition-equal-subset-sum.js b/416-partition-equal-subset-sum.js
index 581d95df..c118c8e6 100644
--- a/416-partition-equal-subset-sum.js
+++ b/416-partition-equal-subset-sum.js
@@ -92,3 +92,23 @@ const canPartition = function(nums) {
 
   return helper(nums, sum, 0)
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canPartition = function (nums) {
+  const sumA = nums.reduce((acc, curr) => acc + curr, 0)
+  if (sumA % 2) return false
+  let row = 1n << BigInt(sumA / 2)
+  for (const weight of nums) row = row | (row >> BigInt(weight))
+  /*
+     check the the column corresponding to my target by bitwise ANDing
+     it with just 1,so if the first bit is 1,
+     it will return true, otherwise false
+     */
+  return row & 1n
+}
+

From 8573ae985df93cab6a5a2d2faf98205499ae34cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Oct 2020 21:13:01 +0800
Subject: [PATCH 0868/3374] Create
 1617-count-subtrees-with-max-distance-between-cities.js

---
 ...btrees-with-max-distance-between-cities.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1617-count-subtrees-with-max-distance-between-cities.js

diff --git a/1617-count-subtrees-with-max-distance-between-cities.js b/1617-count-subtrees-with-max-distance-between-cities.js
new file mode 100644
index 00000000..aa468b83
--- /dev/null
+++ b/1617-count-subtrees-with-max-distance-between-cities.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const countSubgraphsForEachDiameter = function (n, edges) {
+  const graph = {};
+  for (let [u, v] of edges) {
+    if (!graph[u - 1]) graph[u - 1] = [];
+    if (!graph[v - 1]) graph[v - 1] = [];
+    graph[u - 1].push(v - 1);
+    graph[v - 1].push(u - 1);
+  }
+  let ans = Array(n - 1).fill(0);
+  for (let i = 1, len = 2 ** n; i < len; i++) {
+    const d = maxDistance(i);
+    if (d > 0) ans[d - 1] += 1;
+  }
+  return ans;
+  function bfs(src, cities) {
+    const visited = new Set();
+    visited.add(src);
+    const q = [[src, 0]]; // Pair of (vertex, distance)
+    let farthestDist = 0; // Farthest distance from src to other nodes
+    while (q.length > 0) {
+      const [u, d] = q.shift();
+      farthestDist = d;
+      for (let v of graph[u]) {
+        if (!visited.has(v) && cities.has(v)) {
+          visited.add(v);
+          q.push([v, d + 1]);
+        }
+      }
+    }
+    return [farthestDist, visited];
+  }
+  function maxDistance(state) {
+    // return: maximum distance between any two cities in our subset. O(n^2)
+    const cities = new Set();
+    for (let i = 0; i < n; i++) {
+      if ((state >> i) & (1 === 1)) cities.add(i);
+    }
+    let ans = 0;
+    for (let i of cities) {
+      const [farthestDist, visited] = bfs(i, cities);
+      if (visited.size < cities.size) return 0; // Can't visit all nodes of the tree -> Invalid tree
+      ans = Math.max(ans, farthestDist);
+    }
+    return ans;
+  }
+};

From 175191676609103ccb2defe9a2b52d782e622d5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Oct 2020 19:16:44 +0800
Subject: [PATCH 0869/3374] Create 1613-find-the-missing-ids.sql

---
 1613-find-the-missing-ids.sql | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1613-find-the-missing-ids.sql

diff --git a/1613-find-the-missing-ids.sql b/1613-find-the-missing-ids.sql
new file mode 100644
index 00000000..0d0600e5
--- /dev/null
+++ b/1613-find-the-missing-ids.sql
@@ -0,0 +1,12 @@
+# Write your MySQL query statement below
+WITH RECURSIVE id_seq AS (
+    SELECT 1 as continued_id
+    UNION 
+    SELECT continued_id + 1
+    FROM id_seq
+    WHERE continued_id < (SELECT MAX(customer_id) FROM Customers) 
+)
+
+SELECT continued_id AS ids
+FROM id_seq
+WHERE continued_id NOT IN (SELECT customer_id FROM Customers);

From d00c46afed4efb452200d0a0d4f1244b1637d8f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Oct 2020 20:59:40 +0800
Subject: [PATCH 0870/3374] Create
 1612-check-if-two-expression-trees-are-equivalent.js

---
 ...-if-two-expression-trees-are-equivalent.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1612-check-if-two-expression-trees-are-equivalent.js

diff --git a/1612-check-if-two-expression-trees-are-equivalent.js b/1612-check-if-two-expression-trees-are-equivalent.js
new file mode 100644
index 00000000..1d0e2cdb
--- /dev/null
+++ b/1612-check-if-two-expression-trees-are-equivalent.js
@@ -0,0 +1,39 @@
+/**
+ * Definition for a binary tree node.
+ * function Node(val, left, right) {
+ *     this.val = (val===undefined ? " " : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {Node} root1
+ * @param {Node} root2
+ * @return {boolean}
+ */
+const checkEquivalence = function(root1, root2) {
+  const q = {}
+  const helper = (node) => {
+    if (node == null) return
+    if(node.val !== '+') {
+      if(q[node.val] == null) q[node.val] = 0
+      q[node.val]++      
+    }
+    helper(node.left)
+    helper(node.right)
+  }
+  helper(root1)
+  const h = node => {
+    if(node == null) return
+    if(node.val !== '+') {
+      if(q[node.val] == null) return false
+      q[node.val]--
+      if(q[node.val] <= 0) delete q[node.val]
+    }
+    h(node.left)
+    h(node.right)
+  }
+  h(root2)
+  if(Object.keys(q).length > 0) return false
+  return true
+};

From 730693705c6480b94baa25c52423531acf6289b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Oct 2020 08:39:05 +0800
Subject: [PATCH 0871/3374] Update 1616-split-two-strings-to-make-palindrome.js

---
 1616-split-two-strings-to-make-palindrome.js | 31 +++++++-------------
 1 file changed, 11 insertions(+), 20 deletions(-)

diff --git a/1616-split-two-strings-to-make-palindrome.js b/1616-split-two-strings-to-make-palindrome.js
index 8bce584a..0cbacb2c 100644
--- a/1616-split-two-strings-to-make-palindrome.js
+++ b/1616-split-two-strings-to-make-palindrome.js
@@ -3,29 +3,20 @@
  * @param {string} b
  * @return {boolean}
  */
-const checkPalindromeFormation = function(a, b) {
-  return helper(a, b) || helper(b, a)
-};
+const checkPalindromeFormation = function (a, b) {
+  return check(a, b) || check(b, a)
+}
 
-function helper(A, B) {
-  const str_len = A.length
-  let idx = 0
-  while(A[idx] === B[str_len - idx - 1]) {
-    idx += 1
+function isPalindrome(s, i, j) {
+  for (; i < j; ++i, --j) {
+    if (s[i] != s[j]) return false
   }
-  console.log(idx)
-  if (idx > Math.floor(str_len / 2) ) return true
-  else if (chk(A.slice(idx + 1, str_len - idx - 2 + 1))) return true
-  else if (chk(B.slice(idx + 1, str_len - idx - 2 + 1))) return true
-  else return false
-} 
+  return true
+}
 
-function chk(s) {
-  let l = 0, r = s.length - 1
-  while(l < r) {
-    if(s[l] !== s[r]) return false
-    l++
-    r--
+function check(a, b) {
+  for (let i = 0, j = a.length - 1; i < j; ++i, --j) {
+    if (a[i] !== b[j]) return isPalindrome(a, i, j) || isPalindrome(b, i, j)
   }
   return true
 }

From 876eb6e18a361de93677dae9ab23074be1383b36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Oct 2020 20:50:10 +0800
Subject: [PATCH 0872/3374] Create
 1521-find-a-value-of-a-mysterious-function-closest-to-target.js

---
 ...a-mysterious-function-closest-to-target.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1521-find-a-value-of-a-mysterious-function-closest-to-target.js

diff --git a/1521-find-a-value-of-a-mysterious-function-closest-to-target.js b/1521-find-a-value-of-a-mysterious-function-closest-to-target.js
new file mode 100644
index 00000000..87ad112a
--- /dev/null
+++ b/1521-find-a-value-of-a-mysterious-function-closest-to-target.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} arr
+ * @param {number} target
+ * @return {number}
+ */
+const closestToTarget = function (arr, target) {
+  let res = Infinity
+  let set = new Set()
+  for (let i = 0; i < arr.length; i++) {
+    const set2 = new Set()
+    for (let j of set) {
+      set2.add(j & arr[i])
+    }
+    set2.add(arr[i])
+    for (let j of set2) {
+      res = Math.min(res, Math.abs(j - target))
+    }
+    set = set2
+  }
+  return res
+}

From 94cd74b5038fb3c7b61e7b7861b13fd83cb37c6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Oct 2020 08:53:07 +0800
Subject: [PATCH 0873/3374] Update 61-rotate-list.js

---
 61-rotate-list.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/61-rotate-list.js b/61-rotate-list.js
index cbd51513..5f97560e 100644
--- a/61-rotate-list.js
+++ b/61-rotate-list.js
@@ -29,3 +29,37 @@ const rotateRight = function(head, k) {
     
     return dummy.next;
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+const rotateRight = function(head, k) {
+  if(head == null) return null
+  let len = 1
+  let tmp = head
+  while(tmp.next) {
+    len++
+    tmp = tmp.next
+  }
+  k = k % len
+  if(k === 0) return head
+  let tail = head
+  for(let i = 1; i < len - k; i++) {
+    tail = tail.next
+  }
+  const newHead = tail.next
+  tmp.next = head
+  tail.next = null
+  return newHead
+};

From 048c007575c5d2721679574b93a1006ad5e507d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Oct 2020 14:28:47 +0800
Subject: [PATCH 0874/3374] Create
 1597-build-binary-expression-tree-from-infix-expression.js

---
 ...y-expression-tree-from-infix-expression.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 1597-build-binary-expression-tree-from-infix-expression.js

diff --git a/1597-build-binary-expression-tree-from-infix-expression.js b/1597-build-binary-expression-tree-from-infix-expression.js
new file mode 100644
index 00000000..75742b74
--- /dev/null
+++ b/1597-build-binary-expression-tree-from-infix-expression.js
@@ -0,0 +1,48 @@
+/**
+ * Definition for a binary tree node.
+ * function Node(val, left, right) {
+ *     this.val = (val===undefined ? " " : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {string} s
+ * @return {Node}
+ */
+const expTree = function(s) {
+  const list = s.split('')
+  const mdSet = new Set(['*', '/'])
+  const amSet = new Set(['+', '-'])
+  return parseExpression(list)
+  
+  function parseExpression(tokens) {
+    let lhs = parseTerm(tokens)
+    while(tokens.length && amSet.has(tokens[0])) {
+      const op = tokens.shift()
+      const rhs = parseTerm(tokens)
+      lhs = new Node(op, lhs, rhs)
+    }
+    return lhs
+  }
+  function parseTerm(tokens) {
+    let lhs = parseFactor(tokens)
+    while(tokens.length && mdSet.has(tokens[0])) {
+      const op = tokens.shift()
+      const rhs = parseFactor(tokens)
+      lhs = new Node(op, lhs, rhs)
+    }
+    return lhs
+  }
+  function parseFactor(tokens) {
+    if(tokens[0] === '(') {
+      tokens.shift()
+      const node = parseExpression(tokens)
+      tokens.shift()
+      return node
+    } else {
+      const token = tokens.shift()
+      return new Node(token)
+    } 
+  }
+};

From 8fd13657434e98a79ba53222005aae87f272960d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Oct 2020 15:03:18 +0800
Subject: [PATCH 0875/3374] Update
 1597-build-binary-expression-tree-from-infix-expression.js

---
 ...y-expression-tree-from-infix-expression.js | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/1597-build-binary-expression-tree-from-infix-expression.js b/1597-build-binary-expression-tree-from-infix-expression.js
index 75742b74..85831c20 100644
--- a/1597-build-binary-expression-tree-from-infix-expression.js
+++ b/1597-build-binary-expression-tree-from-infix-expression.js
@@ -1,3 +1,62 @@
+/**
+ * Definition for a binary tree node.
+ * function Node(val, left, right) {
+ *     this.val = (val===undefined ? " " : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {string} s
+ * @return {Node}
+ */
+const expTree = function (s) {
+  const n = s.length
+  const head = new Node()
+  let i = 0
+  const number = () => {
+    let num = ''
+    while (i < n && '0' <= s[i] && s[i] <= s[i]) {
+      num += s[i++]
+    }
+    return new Node(Number(num))
+  }
+  const factor = () => {
+    if (s[i] === '(') {
+      i++
+      const node = expression()
+      i++
+      return node
+    }
+    return number()
+  }
+  const term = () => {
+    let left = factor()
+    while (i < n && (s[i] === '*' || s[i] === '/')) {
+      const op = new Node(s[i++])
+      const right = factor()
+      op.left = left
+      op.right = right
+      left = op
+    }
+    return left
+  }
+  const expression = () => {
+    let left = term()
+    while (i < s.length && (s[i] === '+' || s[i] === '-')) {
+      const op = new Node(s[i++])
+      const right = term()
+      op.left = left
+      op.right = right
+      left = op
+    }
+    return left
+  }
+  return expression()
+}
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function Node(val, left, right) {

From c1c7f53292b512fe88909add7485c9d75c7e66c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Oct 2020 15:14:41 +0800
Subject: [PATCH 0876/3374] Update
 1597-build-binary-expression-tree-from-infix-expression.js

---
 1597-build-binary-expression-tree-from-infix-expression.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/1597-build-binary-expression-tree-from-infix-expression.js b/1597-build-binary-expression-tree-from-infix-expression.js
index 85831c20..5678858f 100644
--- a/1597-build-binary-expression-tree-from-infix-expression.js
+++ b/1597-build-binary-expression-tree-from-infix-expression.js
@@ -16,7 +16,7 @@ const expTree = function (s) {
   let i = 0
   const number = () => {
     let num = ''
-    while (i < n && '0' <= s[i] && s[i] <= s[i]) {
+    while (i < n && '0' <= s[i]) {
       num += s[i++]
     }
     return new Node(Number(num))
@@ -55,6 +55,7 @@ const expTree = function (s) {
   return expression()
 }
 
+
 // another
 
 /**

From 2b070fe5eb8fa29dd47ab95b553611dc32ba0724 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Oct 2020 15:28:20 +0800
Subject: [PATCH 0877/3374] Create
 1624-largest-substring-between-two-equal-characters.js

---
 ...t-substring-between-two-equal-characters.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1624-largest-substring-between-two-equal-characters.js

diff --git a/1624-largest-substring-between-two-equal-characters.js b/1624-largest-substring-between-two-equal-characters.js
new file mode 100644
index 00000000..5a163d44
--- /dev/null
+++ b/1624-largest-substring-between-two-equal-characters.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxLengthBetweenEqualCharacters = function(s) {
+  const m = {}
+  if(s ==null || s.length <= 1) return -1
+  let res  = -1
+  for(let i = 0, len = s.length; i< len;i++) {
+    if(m[s[i]] != null) {
+      res = Math.max(res, i - m[s[i]] - 1)
+    } else {
+      m[s[i]] = i
+    }
+    
+  }
+  return res
+};

From 56b5e8cae021e0e2d17e46fd33b48b424adbf955 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Oct 2020 15:29:02 +0800
Subject: [PATCH 0878/3374] Create
 1625-lexicographically-smallest-string-after-applying-operations.js

---
 ...allest-string-after-applying-operations.js | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 1625-lexicographically-smallest-string-after-applying-operations.js

diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
new file mode 100644
index 00000000..24bf99b8
--- /dev/null
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -0,0 +1,52 @@
+/**
+ * @param {string} s
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const findLexSmallestString = function(s, a, b) {
+  let res = s
+  const set = new Set()
+  const q = [s]
+  set.add(res)
+  while(q.length) {
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const tmp = q.shift()
+      const t1 = podd(tmp, a)
+      const t2 = rotate(tmp, b)
+      if(!set.has(tmp)) {
+        set.add(tmp)
+        q.push(tmp)
+      }
+      if(!set.has(t1)) {
+        set.add(t1)
+        q.push(t1)
+      }
+      if(!set.has(t2)) {
+        set.add(t2)
+        q.push(t2)
+      }
+      if(t1 < res) res = t1
+      if(t2 < res) res = t2
+    }
+
+  }
+  return res
+};
+
+function podd(s, num) {
+  const arr = s.split('')
+  for(let i = 1, len = s.length; i < len; i += 2) {
+    const tmp = (+s[i] + num) % 10
+    arr[i] = tmp
+  }
+  return arr.join('')
+}
+
+function rotate(s, num) {
+  const len = s.length
+  num = num % len
+  const idx = len - num
+  return s.slice(idx) + s.slice(0, idx)
+}

From a55cfcc9129a0aff8f99c64e401eb8e0090f5522 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Oct 2020 15:29:43 +0800
Subject: [PATCH 0879/3374] Create 1626-best-team-with-no-conflicts.js

---
 1626-best-team-with-no-conflicts.js | 31 +++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1626-best-team-with-no-conflicts.js

diff --git a/1626-best-team-with-no-conflicts.js b/1626-best-team-with-no-conflicts.js
new file mode 100644
index 00000000..36b84702
--- /dev/null
+++ b/1626-best-team-with-no-conflicts.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} scores
+ * @param {number[]} ages
+ * @return {number}
+ */
+const bestTeamScore = function(scores, ages) {
+  const len = ages.length
+  const arr = Array(len)
+  for(let i = 0; i < len; i++) {
+    arr[i] = [scores[i], ages[i]]    
+  }
+  arr.sort((a, b) => {
+    if(a[1] > b[1]) return 1
+    else if(a[1] === b[1]) return a[0] - b[0]
+    else return -1
+  })
+  const dp = Array(len)
+  let res = 0
+  for(let i = 0; i < len; i++) {
+    dp[i] = arr[i][0]
+    for(let j = i - 1; j >= 0; j--) {
+      if(arr[j][0] > arr[i][0] && arr[j][1] < arr[i][1]) {
+         continue
+      }
+      dp[i] = Math.max(dp[i], dp[j] + arr[i][0])
+    }
+    res = Math.max(res, dp[i])
+  }
+  return res
+};
+

From 5fb339ad434a35edafe7920ffc02607a5ac07ddf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Oct 2020 15:30:21 +0800
Subject: [PATCH 0880/3374] Create 1627-graph-connectivity-with-threshold.js

---
 1627-graph-connectivity-with-threshold.js | 57 +++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 1627-graph-connectivity-with-threshold.js

diff --git a/1627-graph-connectivity-with-threshold.js b/1627-graph-connectivity-with-threshold.js
new file mode 100644
index 00000000..05eac3ca
--- /dev/null
+++ b/1627-graph-connectivity-with-threshold.js
@@ -0,0 +1,57 @@
+/**
+ * @param {number} n
+ * @param {number} threshold
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const areConnected = function (n, threshold, queries) {
+  const arr = []
+  const uf = new UnionFind(n)
+  setup(n, threshold, uf)
+  for (let i = 0, len = queries.length; i < len; i++) {
+    arr.push(uf.check(queries[i][0], queries[i][1]))
+  }
+  return arr
+}
+
+function setup(n, t, uf) {
+  t++
+  for (let i = t; i <= n; i++) {
+    let m = 1
+    while (i * m <= n) {
+      uf.union(i, i * m)
+      m += 1
+    }
+  }
+}
+class UnionFind {
+  constructor(n) {
+    this.parents = Array(n + 1)
+      .fill(0)
+      .map((e, i) => i)
+    this.ranks = Array(n + 1).fill(0)
+  }
+  root(x) {
+    while (x !== this.parents[x]) {
+      this.parents[x] = this.parents[this.parents[x]]
+      x = this.parents[x]
+    }
+    return x
+  }
+  find(x) {
+    return this.root(x)
+  }
+  check(x, y) {
+    return this.root(x) === this.root(y)
+  }
+  union(x, y) {
+    const [rx, ry] = [this.find(x), this.find(y)]
+    if (this.ranks[rx] >= this.ranks[ry]) {
+      this.parents[ry] = rx
+      this.ranks[rx] += this.ranks[ry]
+    } else if (this.ranks[ry] > this.ranks[rx]) {
+      this.parents[rx] = ry
+      this.ranks[ry] += this.ranks[rx]
+    }
+  }
+}

From 0cefa195aab6a6764984ee2377b0ec1f19f570c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Oct 2020 20:05:17 +0800
Subject: [PATCH 0881/3374] Update 92-reverse-linked-list-ii.js

---
 92-reverse-linked-list-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/92-reverse-linked-list-ii.js b/92-reverse-linked-list-ii.js
index aaee3f2b..c9995ac3 100644
--- a/92-reverse-linked-list-ii.js
+++ b/92-reverse-linked-list-ii.js
@@ -50,3 +50,36 @@ const reverseBetween = function(head, m, n) {
     tail.next = cur;
     return head;
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} m
+ * @param {number} n
+ * @return {ListNode}
+ */
+const reverseBetween = function(head, m, n) {
+    if (!head) return null;
+    const dummy = new ListNode(0);
+    dummy.next = head;
+    let pre = dummy;
+    for (let i = 0; i < m-1; i++) pre = pre.next
+    let start = pre.next;
+    let then = start.next;
+    
+    for (let i = 0; i < n-m; i++) {
+        start.next = then.next
+        then.next = pre.next
+        pre.next = then;
+        then = start.next;
+    }
+    return dummy.next;
+};

From fd8dbe1b3f29c1d63d33e8f43887a13ea128ee9a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Oct 2020 10:41:20 +0800
Subject: [PATCH 0882/3374] Create 1622-fancy-sequence.js

---
 1622-fancy-sequence.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1622-fancy-sequence.js

diff --git a/1622-fancy-sequence.js b/1622-fancy-sequence.js
new file mode 100644
index 00000000..3b8577a0
--- /dev/null
+++ b/1622-fancy-sequence.js
@@ -0,0 +1,29 @@
+const mod = 10 ** 9 + 7;
+const Fancy = function () {
+  this.seq = [];
+  this.mods = [];
+};
+Fancy.prototype.append = function (val) {
+  this.seq.push(val);
+};
+Fancy.prototype.addAll = function (inc) {
+  this.mods.push(["p", inc, this.seq.length]);
+};
+Fancy.prototype.multAll = function (m) {
+  this.mods.push(["m", m, this.seq.length]);
+};
+Fancy.prototype.getIndex = function (idx) {
+  if (idx >= this.seq.length) return -1;
+  let x = this.seq[idx];
+
+  for (let i = 0; i < this.mods.length; i++) {
+    if (this.mods[i][2] > idx) {
+      if ("m" === this.mods[i][0]) {
+        x = (x * this.mods[i][1]) % mod;
+      } else {
+        x = (x + this.mods[i][1]) % mod;
+      }
+    }
+  }
+  return x;
+};

From 62f231eed0903b84d8285b1e71104aedef4f556c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Oct 2020 09:16:20 +0800
Subject: [PATCH 0883/3374] Create
 1621-number-of-sets-of-k-non-overlapping-line-segments.js

---
 ...-of-sets-of-k-non-overlapping-line-segments.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1621-number-of-sets-of-k-non-overlapping-line-segments.js

diff --git a/1621-number-of-sets-of-k-non-overlapping-line-segments.js b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
new file mode 100644
index 00000000..46f1c65c
--- /dev/null
+++ b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfSets = function (n, k) {
+  let res = BigInt(1)
+  const mod = BigInt(10 ** 9 + 7)
+  for (let i = 1; i < k * 2 + 1; i++) {
+    res = res * BigInt(n + k - i)
+    res = res / BigInt(i)
+  }
+  res = res % mod
+  return res
+}

From 5aff0ddd53897e925511962c362bae53167fdb3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Oct 2020 14:55:18 +0800
Subject: [PATCH 0884/3374] Update
 1621-number-of-sets-of-k-non-overlapping-line-segments.js

---
 ...sets-of-k-non-overlapping-line-segments.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1621-number-of-sets-of-k-non-overlapping-line-segments.js b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
index 46f1c65c..6d711e2e 100644
--- a/1621-number-of-sets-of-k-non-overlapping-line-segments.js
+++ b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
@@ -13,3 +13,27 @@ const numberOfSets = function (n, k) {
   res = res % mod
   return res
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfSets = function (n, k) {
+  const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0))
+  const MOD = 10 ** 9 + 7
+  for (let i = 2; i <= n; i++) {
+    dp[i][i - 1] = 1
+    dp[i][1] = (i * (i - 1)) / 2
+  }
+  for (let i = 4; i <= n; i++) {
+    for (let j = 2; j < i; j++) {
+      let count =
+        dp[i - 1][j] - dp[i - 2][j] + dp[i - 1][j] + dp[i - 1][j - 1] + MOD
+      dp[i][j] = count % MOD
+    }
+  }
+  return dp[n][k]
+}

From 669e8722e8f97dcd01b9de130e588b78caff727d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Oct 2020 16:31:11 +0800
Subject: [PATCH 0885/3374] Update
 1621-number-of-sets-of-k-non-overlapping-line-segments.js

---
 ...sets-of-k-non-overlapping-line-segments.js | 23 ++++++++++---------
 1 file changed, 12 insertions(+), 11 deletions(-)

diff --git a/1621-number-of-sets-of-k-non-overlapping-line-segments.js b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
index 6d711e2e..f7d13d1f 100644
--- a/1621-number-of-sets-of-k-non-overlapping-line-segments.js
+++ b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
@@ -22,18 +22,19 @@ const numberOfSets = function (n, k) {
  * @return {number}
  */
 const numberOfSets = function (n, k) {
-  const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0))
+  // dp[i][k] as: the number of ways to generate
+  // k non-overlapping segments you can make using [0 ~ i].
+  const dp = Array.from({ length: n }, () => Array(k + 1).fill(0))
   const MOD = 10 ** 9 + 7
-  for (let i = 2; i <= n; i++) {
-    dp[i][i - 1] = 1
-    dp[i][1] = (i * (i - 1)) / 2
-  }
-  for (let i = 4; i <= n; i++) {
-    for (let j = 2; j < i; j++) {
-      let count =
-        dp[i - 1][j] - dp[i - 2][j] + dp[i - 1][j] + dp[i - 1][j - 1] + MOD
-      dp[i][j] = count % MOD
+  dp[1][1] = 1
+  for (let i = 2; i < n; i++) dp[i][1] = ((i + 1) * i) / 2
+  const sum = Array.from({ length: n }, () => Array(k + 1).fill(0))
+  for (let i = 2; i < n; i++) {
+    for (let j = 2; j <= k; j++) {
+      if (j <= i) sum[i][j] = (sum[i - 1][j] + dp[i - 1][j - 1]) % MOD
+      dp[i][j] = (sum[i][j] + dp[i - 1][j]) % MOD
     }
   }
-  return dp[n][k]
+  return dp[n - 1][k]
 }
+

From 52ecad728836c86a0db7ace7325ce1331e14031e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Oct 2020 17:40:22 +0800
Subject: [PATCH 0886/3374] Update
 1621-number-of-sets-of-k-non-overlapping-line-segments.js

---
 1621-number-of-sets-of-k-non-overlapping-line-segments.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/1621-number-of-sets-of-k-non-overlapping-line-segments.js b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
index f7d13d1f..58fca659 100644
--- a/1621-number-of-sets-of-k-non-overlapping-line-segments.js
+++ b/1621-number-of-sets-of-k-non-overlapping-line-segments.js
@@ -28,6 +28,8 @@ const numberOfSets = function (n, k) {
   const MOD = 10 ** 9 + 7
   dp[1][1] = 1
   for (let i = 2; i < n; i++) dp[i][1] = ((i + 1) * i) / 2
+  // sum[i][j] as: the number of ways to generate
+  // j - 1 segments from i - 1 points.
   const sum = Array.from({ length: n }, () => Array(k + 1).fill(0))
   for (let i = 2; i < n; i++) {
     for (let j = 2; j <= k; j++) {

From 32fc53c0339e9f2fa8d0490438fd6e1df359eadf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Oct 2020 11:05:51 +0800
Subject: [PATCH 0887/3374] Update
 1625-lexicographically-smallest-string-after-applying-operations.js

---
 ...ographically-smallest-string-after-applying-operations.js | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
index 24bf99b8..6c603c5d 100644
--- a/1625-lexicographically-smallest-string-after-applying-operations.js
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -15,10 +15,6 @@ const findLexSmallestString = function(s, a, b) {
       const tmp = q.shift()
       const t1 = podd(tmp, a)
       const t2 = rotate(tmp, b)
-      if(!set.has(tmp)) {
-        set.add(tmp)
-        q.push(tmp)
-      }
       if(!set.has(t1)) {
         set.add(t1)
         q.push(t1)
@@ -30,7 +26,6 @@ const findLexSmallestString = function(s, a, b) {
       if(t1 < res) res = t1
       if(t2 < res) res = t2
     }
-
   }
   return res
 };

From 36ac484631cbb42fde6f1b0fced009a5293b33ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Oct 2020 20:01:20 +0800
Subject: [PATCH 0888/3374] Create
 1602-find-nearest-right-node-in-binary-tree.js

---
 ...-find-nearest-right-node-in-binary-tree.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1602-find-nearest-right-node-in-binary-tree.js

diff --git a/1602-find-nearest-right-node-in-binary-tree.js b/1602-find-nearest-right-node-in-binary-tree.js
new file mode 100644
index 00000000..1213d388
--- /dev/null
+++ b/1602-find-nearest-right-node-in-binary-tree.js
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} u
+ * @return {TreeNode}
+ */
+const findNearestRightNode = function(root, u) {
+  const q = [root]
+  while(q.length) {
+    const size = q.length
+    let target = false
+    for(let i = 0; i < size; i++) {
+      const tmp = q.shift()
+      if(target) return tmp
+      if(tmp === u) target = true
+      if(tmp.left) q.push(tmp.left)
+      if(tmp.right) q.push(tmp.right)
+    }
+  }     
+  return null
+};

From 9bc202d0e95078bec6cfc1730cd6b757cf7bf388 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Oct 2020 19:55:21 +0800
Subject: [PATCH 0889/3374] Create
 1619-mean-of-array-after-removing-some-elements.js

---
 1619-mean-of-array-after-removing-some-elements.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1619-mean-of-array-after-removing-some-elements.js

diff --git a/1619-mean-of-array-after-removing-some-elements.js b/1619-mean-of-array-after-removing-some-elements.js
new file mode 100644
index 00000000..d5ad97c7
--- /dev/null
+++ b/1619-mean-of-array-after-removing-some-elements.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const trimMean = function(arr) {
+  const n = arr.length
+  arr.sort((a, b) => a - b)
+  const idx = n / 20
+  let tmp = arr.slice(idx, n - idx)
+  const sum = tmp.reduce((ac, cur) => ac + cur, 0)
+  return sum / (n -idx * 2)
+};

From 23b881204fdb7bdd5a9f08b77761a13ff8628708 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Oct 2020 14:06:48 +0800
Subject: [PATCH 0890/3374] Create
 1546-maximum-number-of-non-overlapping-subarrays-with-sum-equals-target.js

---
 ...apping-subarrays-with-sum-equals-target.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1546-maximum-number-of-non-overlapping-subarrays-with-sum-equals-target.js

diff --git a/1546-maximum-number-of-non-overlapping-subarrays-with-sum-equals-target.js b/1546-maximum-number-of-non-overlapping-subarrays-with-sum-equals-target.js
new file mode 100644
index 00000000..3d307b68
--- /dev/null
+++ b/1546-maximum-number-of-non-overlapping-subarrays-with-sum-equals-target.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const maxNonOverlapping = function(nums, target) {
+  if(nums == null || nums.length === 0) return 0
+  let sum = 0, res = 0
+  const n = nums.length
+  const m = {0: 0}
+  
+  for(let i = 0; i < n; i++) {
+    sum += nums[i]
+    if(m[sum - target] != null) {
+      res = Math.max(res, m[sum - target] + 1)
+    }
+    m[sum] = res
+  }
+  return res
+};

From d280561123d953da7844a0b1a1789f1d88e600e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Oct 2020 12:31:25 +0800
Subject: [PATCH 0891/3374] Create 1629-slowest-key.js

---
 1629-slowest-key.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1629-slowest-key.js

diff --git a/1629-slowest-key.js b/1629-slowest-key.js
new file mode 100644
index 00000000..206e906f
--- /dev/null
+++ b/1629-slowest-key.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} releaseTimes
+ * @param {string} keysPressed
+ * @return {character}
+ */
+const slowestKey = function(releaseTimes, keysPressed) {
+  const m = {}
+  const n = keysPressed.length
+  const set = new Set()
+  set.add(keysPressed[0])
+  m[releaseTimes[0]] = set
+  for(let i = 1; i < n; i++) {
+    const k = releaseTimes[i] - releaseTimes[i - 1]
+    if(m[k] == null) m[k] = new Set()
+    m[k].add(keysPressed[i])
+  }
+  const keys = Object.keys(m).sort((a, b) => a - b)
+  const last = keys[keys.length - 1]
+  const arr = Array.from(m[last])
+  arr.sort()
+  return arr[arr.length - 1]
+};

From 4ad5b28fdb2bb4637b2ebc9a564ead4457e1a3bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Oct 2020 12:32:50 +0800
Subject: [PATCH 0892/3374] Create 1630-arithmetic-subarrays.js

---
 1630-arithmetic-subarrays.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1630-arithmetic-subarrays.js

diff --git a/1630-arithmetic-subarrays.js b/1630-arithmetic-subarrays.js
new file mode 100644
index 00000000..8d02eda2
--- /dev/null
+++ b/1630-arithmetic-subarrays.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} l
+ * @param {number[]} r
+ * @return {boolean[]}
+ */
+const checkArithmeticSubarrays = function(nums, l, r) {
+  const len = l.length
+  const res = []
+  for(let i = 0; i < len; i++) {
+    res.push(chk(nums.slice(l[i], r[i] + 1)))
+  }
+  return res
+};
+
+function chk(arr) {
+  if(arr.length === 0 || arr.length === 1 || arr.length === 2) return true
+  arr.sort((a, b) => a - b)
+  const diff = arr[1] - arr[0]
+  for(let i = 2, len = arr.length; i < len; i++) {
+    if(arr[i] - arr[i - 1] !== diff) return false
+  }
+  return true
+}

From f08b7bc866275fea8d9fe986371f2009d3b3eef2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Oct 2020 12:33:39 +0800
Subject: [PATCH 0893/3374] Create 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 50 ++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1631-path-with-minimum-effort.js

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
new file mode 100644
index 00000000..ae907ad3
--- /dev/null
+++ b/1631-path-with-minimum-effort.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[][]} heights
+ * @return {number}
+ */
+const minimumEffortPath = function (heights) {
+  const d = [0, 1, 0, -1, 0]
+  let lo = 0,
+    hi = 10 ** 6 + 1
+  while (lo < hi) {
+    let effort = lo + ((hi - lo) >> 1)
+    if (isPath(heights, effort)) {
+      hi = effort
+    } else {
+      lo = effort + 1
+    }
+  }
+  return lo
+  function isPath(h, effort) {
+    const m = h.length,
+      n = h[0].length
+    const q = []
+    q.push([0, 0])
+    const seen = new Set()
+    seen.add(0)
+    while (q.length) {
+      const cur = q.shift()
+      const x = cur[0],
+        y = cur[1]
+      if (x === m - 1 && y === n - 1) {
+        return true
+      }
+      for (let k = 0; k < 4; k++) {
+        const r = x + d[k],
+          c = y + d[k + 1]
+        if(seen.has(r * n + c)) continue
+        if (
+          0 <= r &&
+          r < m &&
+          0 <= c &&
+          c < n &&
+          effort >= Math.abs(h[r][c] - h[x][y])
+        ) {
+          seen.add(r * n + c)
+          q.push([r, c])
+        }
+      }
+    }
+    return false
+  }
+}

From e26256e7d37171380963285affb7ae4c731e7834 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Oct 2020 13:13:56 +0800
Subject: [PATCH 0894/3374] Create 1632-rank-transform-of-a-matrix.js

---
 1632-rank-transform-of-a-matrix.js | 90 ++++++++++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 1632-rank-transform-of-a-matrix.js

diff --git a/1632-rank-transform-of-a-matrix.js b/1632-rank-transform-of-a-matrix.js
new file mode 100644
index 00000000..e18634c7
--- /dev/null
+++ b/1632-rank-transform-of-a-matrix.js
@@ -0,0 +1,90 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[][]}
+ */
+const matrixRankTransform = function (matrix) {
+  const m = matrix.length
+  const n = matrix[0].length
+  const rowIndex = Array.from({ length: m }, () => Array(n).fill(0))
+  const colIndex = Array.from({ length: m }, () => Array(n).fill(0))
+  for (let i = 0; i < m; i++) {
+    let row = []
+    for (let j = 0; j < n; j++) {
+      row.push([matrix[i][j], j])
+    }
+
+    row.sort((a, b) => a[0] - b[0])
+    for (let j = 0; j < n; j++) {
+      rowIndex[i][j] = row[j][1]
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const col = []
+    for (let j = 0; j < m; j++) {
+      col.push([matrix[j][i], j])
+    }
+    col.sort((a, b) => a[0] - b[0])
+    for (let j = 0; j < m; j++) {
+      colIndex[j][i] = col[j][1]
+    }
+  }
+  const result = Array.from({ length: m }, () => Array(n).fill(0))
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      result[i][j] = 1
+    }
+  }
+  let changed = true
+  while (changed) {
+    changed = shakeRow(matrix, rowIndex, result)
+    changed = shakeCol(matrix, colIndex, result) || changed
+  }
+  return result
+}
+
+function shakeCol(matrix, colIndex, result) {
+  let changed = false
+  for (let i = 0; i < matrix[0].length; i++) {
+    for (let j = 1; j < matrix.length; j++) {
+      if (matrix[colIndex[j][i]][i] == matrix[colIndex[j - 1][i]][i]) {
+        if (result[colIndex[j][i]][i] != result[colIndex[j - 1][i]][i])
+          changed = true
+        result[colIndex[j][i]][i] = Math.max(
+          result[colIndex[j][i]][i],
+          result[colIndex[j - 1][i]][i]
+        )
+        result[colIndex[j - 1][i]][i] = Math.max(
+          result[colIndex[j][i]][i],
+          result[colIndex[j - 1][i]][i]
+        )
+      } else {
+        if (result[colIndex[j][i]][i] < result[colIndex[j - 1][i]][i] + 1) {
+          changed = true
+          result[colIndex[j][i]][i] = result[colIndex[j - 1][i]][i] + 1
+        }
+      }
+    }
+  }
+  return changed
+}
+
+function shakeRow(matrix, rowIndex, result) {
+  let changed = false
+  for (let i = 0; i < matrix.length; i++) {
+    let rowInd = rowIndex[i]
+    let resu = result[i]
+    for (let j = 1; j < matrix[0].length; j++) {
+      if (matrix[i][rowInd[j]] == matrix[i][rowInd[j - 1]]) {
+        if (resu[rowInd[j]] != resu[rowInd[j - 1]]) changed = true
+        resu[rowInd[j]] = Math.max(resu[rowInd[j - 1]], resu[rowInd[j]])
+        resu[rowInd[j - 1]] = Math.max(resu[rowInd[j - 1]], resu[rowInd[j]])
+      } else {
+        if (resu[rowInd[j]] < resu[rowInd[j - 1]] + 1) {
+          changed = true
+          resu[rowInd[j]] = resu[rowInd[j - 1]] + 1
+        }
+      }
+    }
+  }
+  return changed
+}

From d68a7f8314470a43ecd4bcb12527866db1b7e035 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Oct 2020 20:01:46 +0800
Subject: [PATCH 0895/3374] Update 188-best-time-to-buy-and-sell-stock-iv.js

---
 188-best-time-to-buy-and-sell-stock-iv.js | 30 +++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/188-best-time-to-buy-and-sell-stock-iv.js b/188-best-time-to-buy-and-sell-stock-iv.js
index 4800dc89..35de229f 100644
--- a/188-best-time-to-buy-and-sell-stock-iv.js
+++ b/188-best-time-to-buy-and-sell-stock-iv.js
@@ -25,6 +25,36 @@ const maxProfit = function(k, prices) {
   return sell[k]
 }
 
+// another
+
+/**
+ * @param {number} k
+ * @param {number[]} prices
+ * @return {number}
+ */
+const maxProfit = function(k, prices) {
+    if(prices.length === 0) return 0
+    
+    if(k > (prices.length/2)) {
+        let profit = 0
+        for(let i = 1; i < prices.length; i++) {
+            if(prices[i] > prices[i-1]) profit += prices[i] - prices[i-1]
+        }
+        return profit
+    } else {
+        let dp = new Array(prices.length).fill(0)
+        let length = prices.length
+        for(let j = 0; j < k; j++) {
+            let min = prices[0], max = 0
+            for(let i = 0; i < length; i++) {
+                min = Math.min(min, prices[i] - dp[i])
+                max = Math.max(max, prices[i] - min)
+                dp[i] = max
+            }
+        }
+        return dp.pop()
+    }
+}
 
  // another
 

From be4bef5cf511b38ab295eb799268d605be468e81 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Oct 2020 08:45:07 +0800
Subject: [PATCH 0896/3374] Create 948-bag-of-tokens.js

---
 948-bag-of-tokens.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 948-bag-of-tokens.js

diff --git a/948-bag-of-tokens.js b/948-bag-of-tokens.js
new file mode 100644
index 00000000..6f9a68b9
--- /dev/null
+++ b/948-bag-of-tokens.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} tokens
+ * @param {number} P
+ * @return {number}
+ */
+const bagOfTokensScore = function (tokens, P) {
+  tokens.sort((a, b) => a - b)
+  let res = 0,
+    score = 0,
+    i = 0,
+    j = tokens.length - 1
+  while (i <= j) {
+    if (P >= tokens[i]) {
+      P -= tokens[i++]
+      res = Math.max(res, ++score)
+    } else if (score > 0) {
+      score--
+      P += tokens[j--]
+    } else break
+  }
+  return res
+}

From 3272ad98ea04177af45fd18f2e2ed3052744a779 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Oct 2020 10:12:40 +0800
Subject: [PATCH 0897/3374] Update 1632-rank-transform-of-a-matrix.js

---
 1632-rank-transform-of-a-matrix.js | 65 ++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/1632-rank-transform-of-a-matrix.js b/1632-rank-transform-of-a-matrix.js
index e18634c7..ca454171 100644
--- a/1632-rank-transform-of-a-matrix.js
+++ b/1632-rank-transform-of-a-matrix.js
@@ -88,3 +88,68 @@ function shakeRow(matrix, rowIndex, result) {
   }
   return changed
 }
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @return {number[][]}
+ */
+const matrixRankTransform = function (matrix) {
+  const r = matrix.length,
+    c = matrix[0].length;
+  const t = r * c;
+  const arr = Array(t);
+  const root = Array(t + 1);
+  const rk = Array(t + 1).fill(0);
+  const find = (a) => {
+    let ra = root[a];
+    if (ra == a) return a;
+    return (root[a] = find(ra));
+  };
+  const union = (a, b) => {
+    let ra = find(a);
+    let rb = find(b);
+    if (ra !== rb) {
+      if (rk[ra] > rk[rb]) root[rb] = ra;
+      else root[ra] = rb;
+    }
+  };
+  let k = 0;
+  const ans = Array(r)
+    .fill(0)
+    .map(() => Array(c));
+  for (let i = 0; i < r; ++i) {
+    for (let j = 0; j < c; ++j) {
+      arr[k] = [matrix[i][j], i, j];
+      root[k] = k;
+      ++k;
+    }
+  }
+  root[k] = k;
+  arr.sort((a, b) => a[0] - b[0]);
+  const X = Array(r)
+    .fill(0)
+    .map(() => [-Infinity, t]);
+  const Y = Array(c)
+    .fill(0)
+    .map(() => [-Infinity, t]);
+  for (let i = 0; i < t; ++i) {
+    const [v, x, y] = arr[i];
+    const id = x * c + y;
+    const [xv, rx] = X[x],
+      [yv, ry] = Y[y];
+    if (v > xv) rk[id] = rk[find(rx)] + 1;
+    else root[id] = rx;
+    if (v > yv) rk[find(id)] = Math.max(rk[find(id)], rk[find(ry)] + 1);
+    else union(id, ry);
+    X[x] = [v, id];
+    Y[y] = [v, id];
+  }
+  for (let i = 0; i < r; ++i) {
+    for (let j = 0; j < c; ++j) {
+      ans[i][j] = rk[find(i * c + j)];
+    }
+  }
+  return ans;
+};

From a153c44a37d3c2c6f23f93c55524e75f727fd6ac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Oct 2020 21:08:30 +0800
Subject: [PATCH 0898/3374] Update 1632-rank-transform-of-a-matrix.js

---
 1632-rank-transform-of-a-matrix.js | 57 ++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/1632-rank-transform-of-a-matrix.js b/1632-rank-transform-of-a-matrix.js
index ca454171..69233377 100644
--- a/1632-rank-transform-of-a-matrix.js
+++ b/1632-rank-transform-of-a-matrix.js
@@ -1,3 +1,60 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[][]}
+ */
+const matrixRankTransform = function (matrix) {
+  function find(UF, x) {
+    if (x !== UF.get(x)) UF.set(x, find(UF, UF.get(x)))
+    return UF.get(x)
+  }
+  function union(UF, x, y) {
+    if (!UF.has(x)) UF.set(x, x)
+    if (!UF.has(y)) UF.set(y, y)
+    UF.set(find(UF, x), find(UF, y))
+  }
+  const m = matrix.length
+  const n = matrix[0].length
+  const UFs = new Map()
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const v = matrix[i][j]
+      if (!UFs.has(v)) UFs.set(v, new Map())
+      union(UFs.get(v), i, ~j)
+    }
+  }
+  const value2index = {}
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      let v = matrix[i][j]
+      if (!value2index.hasOwnProperty(v)) value2index[v] = new Map()
+      const indexes = value2index[v]
+      let f = find(UFs.get(v), i)
+      if (!indexes.has(f)) indexes.set(f, [])
+      indexes.get(f).push([i, j])
+    }
+  }
+  const answer = Array.from({ length: m }, () => Array(n).fill(0))
+  const rowMax = Array(m).fill(0), colMax = Array(n).fill(0)
+  const keys = Object.keys(value2index)
+  keys.sort((a, b) => a - b)
+  for (let v of keys) {
+    for (let points of value2index[v].values()) {
+      let rank = 1
+      for (let point of points) {
+        rank = Math.max(rank, Math.max(rowMax[point[0]], colMax[point[1]]) + 1)
+      }
+      for (let point of points) {
+        answer[point[0]][point[1]] = rank
+        rowMax[point[0]] = Math.max(rowMax[point[0]], rank)
+        colMax[point[1]] = Math.max(colMax[point[1]], rank)
+      }
+    }
+  }
+  return answer
+}
+
+// another
+
 /**
  * @param {number[][]} matrix
  * @return {number[][]}

From a06b518b26ecb79a3e1e498bba41c205d91ce45d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Oct 2020 11:02:37 +0800
Subject: [PATCH 0899/3374] Update 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 100 +++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
index ae907ad3..1e07dfcb 100644
--- a/1631-path-with-minimum-effort.js
+++ b/1631-path-with-minimum-effort.js
@@ -48,3 +48,103 @@ const minimumEffortPath = function (heights) {
     return false
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} heights
+ * @return {number}
+ */
+const minimumEffortPath = function(heights) {
+  const rows = heights.length
+  const cols = heights[0].length
+  const dirs = [[-1, 0], [1, 0], [0, 1], [0, -1]]
+  const dist = Array.from({ length: rows }, () => Array(cols).fill(Infinity))
+  const pq = new PriorityQueue()
+  pq.push([0, 0, 0])
+  dist[0][0] = 0
+  while(pq.size) {
+    const cur = pq.pop()
+    if(cur[1] === rows - 1 && cur[2] === cols - 1) return cur[0]
+    for(let dir of dirs) {
+      const nr = cur[1] + dir[0]
+      const nc = cur[2] + dir[1]
+      if(nr < 0 || nr >= rows || nc < 0 || nc >= cols) continue
+      const diff = Math.max(cur[0], Math.abs(heights[nr][nc] - heights[cur[1]][cur[2]]))
+      if(dist[nr][nc] > diff) {
+        dist[nr][nc] = diff
+        pq.push([diff, nr, nc])
+      }
+    }
+  }
+  return 0
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a[0] < b[0]) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+

From 20c8c4d40982c45ec65258b24d0c6a062015036e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Oct 2020 08:50:52 +0800
Subject: [PATCH 0900/3374] Update 1547-minimum-cost-to-cut-a-stick.js

---
 1547-minimum-cost-to-cut-a-stick.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1547-minimum-cost-to-cut-a-stick.js b/1547-minimum-cost-to-cut-a-stick.js
index beecd07a..151a4c91 100644
--- a/1547-minimum-cost-to-cut-a-stick.js
+++ b/1547-minimum-cost-to-cut-a-stick.js
@@ -21,3 +21,27 @@ const minCost = function(n, cuts) {
     return dp[i][j]
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} cuts
+ * @return {number}
+ */
+const minCost = function (n, cuts) {
+  cuts.push(0, n)
+  cuts.sort((a, b) => a - b)
+  const N = cuts.length,
+    dp = Array.from({ length: N }, () => Array(N).fill(0))
+  for (let l = 2; l < N; l++) {
+    for (let i = 0; i + l < N; i++) {
+      const j = i + l
+      dp[i][j] = Infinity
+      for (let k = i + 1; k < j; k++) {
+        dp[i][j] = Math.min(dp[i][j], cuts[j] - cuts[i] + dp[i][k] + dp[k][j])
+      }
+    }
+  }
+  return dp[0][N - 1]
+}

From e30367e9c931fa651e44839c69c52e2d36f8fb41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Oct 2020 10:01:54 +0800
Subject: [PATCH 0901/3374] Update 1547-minimum-cost-to-cut-a-stick.js

---
 1547-minimum-cost-to-cut-a-stick.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/1547-minimum-cost-to-cut-a-stick.js b/1547-minimum-cost-to-cut-a-stick.js
index 151a4c91..637bb477 100644
--- a/1547-minimum-cost-to-cut-a-stick.js
+++ b/1547-minimum-cost-to-cut-a-stick.js
@@ -33,11 +33,12 @@ const minCost = function (n, cuts) {
   cuts.push(0, n)
   cuts.sort((a, b) => a - b)
   const N = cuts.length,
-    dp = Array.from({ length: N }, () => Array(N).fill(0))
-  for (let l = 2; l < N; l++) {
-    for (let i = 0; i + l < N; i++) {
-      const j = i + l
-      dp[i][j] = Infinity
+    dp = Array.from({ length: N }, () => Array(N).fill(Infinity))
+  for(let i = 1; i < N; i++) dp[i - 1][i] = 0
+  for(let i = 2; i < N; i++) dp[i - 2][i] = cuts[i] - cuts[i - 2]
+  for (let l = 4; l <= N; l++) {
+    for (let i = 0; i <= N - l; i++) {
+      const j = i + l - 1
       for (let k = i + 1; k < j; k++) {
         dp[i][j] = Math.min(dp[i][j], cuts[j] - cuts[i] + dp[i][k] + dp[k][j])
       }

From c240c50838f5a8272267ec891ccac486a0c46161 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 31 Oct 2020 08:56:20 +0800
Subject: [PATCH 0902/3374] Create
 1578-minimum-deletion-cost-to-avoid-repeating-letters.js

---
 ...eletion-cost-to-avoid-repeating-letters.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1578-minimum-deletion-cost-to-avoid-repeating-letters.js

diff --git a/1578-minimum-deletion-cost-to-avoid-repeating-letters.js b/1578-minimum-deletion-cost-to-avoid-repeating-letters.js
new file mode 100644
index 00000000..907a35f0
--- /dev/null
+++ b/1578-minimum-deletion-cost-to-avoid-repeating-letters.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {number[]} cost
+ * @return {number}
+ */
+const minCost = function (s, cost) {
+  let stackPointer = 0
+  let minVal = 0
+  for (let i = 1; i < s.length; i++) {
+    if (s[i - 1] === s[i]) {
+      if (cost[stackPointer] < cost[i]) {
+        minVal += cost[stackPointer]
+        stackPointer = i
+      } else {
+        minVal += cost[i]
+      }
+    } else {
+      stackPointer = i
+    }
+  }
+  return minVal
+}

From 578a42cb3ab714f07f86672365b3b12fae3a0696 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 12:41:53 +0800
Subject: [PATCH 0903/3374] Create
 1640-check-array-formation-through-concatenation.js

---
 1640-check-array-formation-through-concatenation.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1640-check-array-formation-through-concatenation.js

diff --git a/1640-check-array-formation-through-concatenation.js b/1640-check-array-formation-through-concatenation.js
new file mode 100644
index 00000000..435f58e1
--- /dev/null
+++ b/1640-check-array-formation-through-concatenation.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} arr
+ * @param {number[][]} pieces
+ * @return {boolean}
+ */
+const canFormArray = function(arr, pieces) {
+  const str = arr.join('-')
+  for(let i = 0, len = pieces.length; i < len; i++) {
+    const tmp = pieces[i].join('-')
+    if(str.indexOf(tmp) === -1) return false
+  }
+  return true
+};

From 37e5e50f61ef2d4e21fbe8f55f254e4fd23f4419 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 12:42:39 +0800
Subject: [PATCH 0904/3374] Create 1641-count-sorted-vowel-strings.js

---
 1641-count-sorted-vowel-strings.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1641-count-sorted-vowel-strings.js

diff --git a/1641-count-sorted-vowel-strings.js b/1641-count-sorted-vowel-strings.js
new file mode 100644
index 00000000..26ae05f0
--- /dev/null
+++ b/1641-count-sorted-vowel-strings.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countVowelStrings = function (n) {
+  let mem = [1, 1, 1, 1, 1];
+  for (let i = 1; i < n; ++i) {
+    const next = [0, 0, 0, 0, 0];
+    let tmp = 0;
+    for (let j = 4; j >= 0; --j) {
+      tmp += mem[j];
+      next[j] = tmp;
+    }
+    mem = next;
+  }
+  let sum = 0;
+  for (let i of mem) {
+    sum += i;
+  }
+  return sum;
+};

From c2848adcd175e6a8844e8d0e1e568816068951f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 12:43:22 +0800
Subject: [PATCH 0905/3374] Create 1642-furthest-building-you-can-reach.js

---
 1642-furthest-building-you-can-reach.js | 97 +++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 1642-furthest-building-you-can-reach.js

diff --git a/1642-furthest-building-you-can-reach.js b/1642-furthest-building-you-can-reach.js
new file mode 100644
index 00000000..90587e5d
--- /dev/null
+++ b/1642-furthest-building-you-can-reach.js
@@ -0,0 +1,97 @@
+/**
+ * @param {number[]} heights
+ * @param {number} bricks
+ * @param {number} ladders
+ * @return {number}
+ */
+const furthestBuilding = function (heights, bricks, ladders) {
+  const queue = new PriorityQueue()
+  for (let i = 1; i < heights.length; ++i) {
+    if (heights[i] > heights[i - 1]) {
+      let diff = heights[i] - heights[i - 1]
+      if (diff <= bricks) {
+        bricks -= diff
+        queue.push(diff)
+      } else if (ladders > 0) {
+        let max = queue.isEmpty() ? 0 : queue.pop()
+        --ladders
+        if (max > diff) {
+          bricks = bricks + max - diff
+          queue.push(diff)
+        } else {
+          queue.push(max)
+        }
+      } else {
+        return i - 1
+      }
+    }
+  }
+  return heights.length - 1
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 11716dbab567a39ec6b33adaa7877ee7fec07eb8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 12:44:26 +0800
Subject: [PATCH 0906/3374] Create 1643-kth-smallest-instructions.js

---
 1643-kth-smallest-instructions.js | 51 +++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1643-kth-smallest-instructions.js

diff --git a/1643-kth-smallest-instructions.js b/1643-kth-smallest-instructions.js
new file mode 100644
index 00000000..b7fc93cf
--- /dev/null
+++ b/1643-kth-smallest-instructions.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[]} destination
+ * @param {number} k
+ * @return {string}
+ */
+const kthSmallestPath = function (destination, k) {
+  let v = destination[0],
+    h = destination[1]
+  const mu = (c, n) => {
+    let res = ''
+    for (let i = 0; i < n; i++) {
+      res += c
+    }
+    return res
+  }
+
+  let res = ''
+  while (h > 0 && v > 0) {
+    let pre = comb(h + v - 1, v)
+    if (k <= pre) {
+      res += 'H'
+      h -= 1
+    } else {
+      res += 'V'
+      v -= 1
+      k -= pre
+    }
+  }
+  if (h == 0) res += mu('V', v)
+  if (v == 0) res += mu('H', h)
+  return res
+}
+
+function product(a, b) {
+  let prd = a,
+    i = a
+
+  while (i++ < b) {
+    prd *= i
+  }
+  return prd
+}
+
+function comb(n, r) {
+  if (n == r) {
+    return 1
+  } else {
+    r = r < n - r ? n - r : r
+    return product(r + 1, n) / product(1, n - r)
+  }
+}

From 9931eb049ec7fdf0a54b40adbc96a8d1b12de9a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 16:58:39 +0800
Subject: [PATCH 0907/3374] Update
 1640-check-array-formation-through-concatenation.js

---
 ...heck-array-formation-through-concatenation.js | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/1640-check-array-formation-through-concatenation.js b/1640-check-array-formation-through-concatenation.js
index 435f58e1..a5a76212 100644
--- a/1640-check-array-formation-through-concatenation.js
+++ b/1640-check-array-formation-through-concatenation.js
@@ -4,10 +4,18 @@
  * @return {boolean}
  */
 const canFormArray = function(arr, pieces) {
-  const str = arr.join('-')
-  for(let i = 0, len = pieces.length; i < len; i++) {
-    const tmp = pieces[i].join('-')
-    if(str.indexOf(tmp) === -1) return false
+  const m = new Map()
+  for(let i = 0, len = arr.length; i < len; i++) {
+    m.set(arr[i], i)
+  }
+  for(let p of pieces) {
+    let idx = m.get(p[0])
+    console.log(idx)
+    if(idx == null) return false
+    for(let i = 1, len = p.length; i < len; i++) {
+      console.log(m.has(p[i]))
+      if(!m.has(p[i]) || arr[++idx] !== p[i]) return false
+    }
   }
   return true
 };

From de5b02c7c957041059ef39f55961a93851d2bb17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Nov 2020 18:00:00 +0800
Subject: [PATCH 0908/3374] Update 1641-count-sorted-vowel-strings.js

---
 1641-count-sorted-vowel-strings.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1641-count-sorted-vowel-strings.js b/1641-count-sorted-vowel-strings.js
index 26ae05f0..22691653 100644
--- a/1641-count-sorted-vowel-strings.js
+++ b/1641-count-sorted-vowel-strings.js
@@ -19,3 +19,23 @@ const countVowelStrings = function (n) {
   }
   return sum;
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countVowelStrings = function (n) {
+  const dp = Array.from({ length: n + 1 }, () => Array(5))
+  recur(n, 0)
+  return dp[n][0]
+  function recur(r, i) {
+    if(r === 0) return 1
+    if(i === 5) return 0
+    if(dp[r][i] != null) return dp[r][i]
+    let res = recur(r, i + 1)
+    res += recur(r - 1, i)
+    return dp[r][i] = res
+  }
+};

From cb03069db1c675f835d171be4e504d28e5fd612d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Nov 2020 08:54:00 +0800
Subject: [PATCH 0909/3374] Create
 1638-count-substrings-that-differ-by-one-character.js

---
 ...substrings-that-differ-by-one-character.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1638-count-substrings-that-differ-by-one-character.js

diff --git a/1638-count-substrings-that-differ-by-one-character.js b/1638-count-substrings-that-differ-by-one-character.js
new file mode 100644
index 00000000..c95a6d31
--- /dev/null
+++ b/1638-count-substrings-that-differ-by-one-character.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+const countSubstrings = function (s, t) {
+  const m = s.length
+  const n = t.length
+  const matrix = (m, n, v) => Array.from({ length: m }, () => Array(n).fill(v))
+  // number of exact same substrings ending at s[i] and t[j].
+  const same = matrix(m + 1, n + 1, 0)
+  // number of substrings having 1 different character ending at s[i] and t[j].
+  const one = matrix(m + 1, n + 1, 0)
+  let result = 0
+  for (let i = 1; i <= m; ++i) {
+    for (let j = 1; j <= n; ++j) {
+      if (s[i - 1] == t[j - 1]) {
+        same[i][j] = same[i - 1][j - 1] + 1
+        one[i][j] = one[i - 1][j - 1]
+      } else {
+        one[i][j] = same[i - 1][j - 1] + 1
+      }
+      result += one[i][j]
+    }
+  }
+  return result
+}

From 1e2e1d4a9fdb78c848e579f5c1ce14ba1be4e519 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Nov 2020 09:35:22 +0800
Subject: [PATCH 0910/3374] Create
 1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js

---
 ...form-a-target-string-given-a-dictionary.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js

diff --git a/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js b/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js
new file mode 100644
index 00000000..6cfd4ae4
--- /dev/null
+++ b/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string[]} words
+ * @param {string} target
+ * @return {number}
+ */
+const numWays = function (words, target) {
+  const m = words[0].length
+  const n = target.length
+  const memo = Array.from({ length: m }, () => Array(n))
+  const charAtIndexCnt = Array.from({ length: 128 }, () => Array(m).fill(0))
+  const mod = 10 ** 9 + 7
+  for (let word of words) {
+    for (let i = 0; i < m; i++) {
+      charAtIndexCnt[word.charCodeAt(i)][i] += 1
+    }
+  }
+
+  return dp(0, 0)
+  function dp(k, i) {
+    // found one
+    if (i == n) return 1
+    // not found
+    if (k == m) return 0
+    if (memo[k][i] != null) return memo[k][i]
+    const c = target.charCodeAt(i)
+    // skip k_th char
+    let ans = dp(k + 1, i)
+    if (charAtIndexCnt[c][k] > 0) {
+      ans += dp(k + 1, i + 1) * charAtIndexCnt[c][k]
+      ans %= mod
+    }
+    return (memo[k][i] = ans)
+  }
+}

From 187fe9330b25dca555040ae477199e442823382d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Nov 2020 11:53:15 +0800
Subject: [PATCH 0911/3374] Update
 1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js

---
 ...form-a-target-string-given-a-dictionary.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js b/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js
index 6cfd4ae4..fa8bf975 100644
--- a/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js
+++ b/1639-number-of-ways-to-form-a-target-string-given-a-dictionary.js
@@ -1,3 +1,31 @@
+/**
+ * @param {string[]} words
+ * @param {string} target
+ * @return {number}
+ */
+const numWays = function (words, target) {
+  const m = words[0].length, len = words.length
+  const n = target.length, a = 'a'.charCodeAt(0)
+  const mod = 10 ** 9 + 7
+  const dp = Array(n).fill(0)
+  for(let i = 0; i < m; i++) {
+    const freq = Array(26).fill(0)
+    for(let j = 0; j < len; j++) {
+      freq[words[j].charCodeAt(i) - a]++
+    }
+    for(let j = Math.min(i, n - 1); j >= 0; j--) {
+      const code = target[j].charCodeAt(0) - a
+      if(freq[code] > 0) {
+        dp[j] += (j === 0 ? freq[code] : dp[j - 1] * freq[code])
+        dp[j] %= mod
+      }
+    }
+  }
+  return dp[n - 1]
+}
+
+// another
+
 /**
  * @param {string[]} words
  * @param {string} target

From d093baf171bc4aaea1aa68c35430d6baca6fe84d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Nov 2020 22:05:47 +0800
Subject: [PATCH 0912/3374] Update 1641-count-sorted-vowel-strings.js

---
 1641-count-sorted-vowel-strings.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/1641-count-sorted-vowel-strings.js b/1641-count-sorted-vowel-strings.js
index 22691653..b74ecc8d 100644
--- a/1641-count-sorted-vowel-strings.js
+++ b/1641-count-sorted-vowel-strings.js
@@ -1,3 +1,13 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countVowelStrings = function (n) {
+  return (n + 4) * (n + 3) * (n + 2) * (n + 1) / 24
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From fc7b220afcb36b8e0316fd2f043f2d9cc9f5add3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Nov 2020 18:30:53 +0800
Subject: [PATCH 0913/3374] Create
 1637-widest-vertical-area-between-two-points-containing-no-points.js

---
 ...-area-between-two-points-containing-no-points.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1637-widest-vertical-area-between-two-points-containing-no-points.js

diff --git a/1637-widest-vertical-area-between-two-points-containing-no-points.js b/1637-widest-vertical-area-between-two-points-containing-no-points.js
new file mode 100644
index 00000000..d9df0f4a
--- /dev/null
+++ b/1637-widest-vertical-area-between-two-points-containing-no-points.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const maxWidthOfVerticalArea = function(points) {
+  const arr = points.map(e => e[0])
+  arr.sort((a, b) => a - b)
+  let res = -Infinity
+  for(let i = 1, len = arr.length; i < len; i++) {
+    if(arr[i] - arr[i - 1] > res) res = arr[i] - arr[i - 1]
+  }
+  return res
+};

From 6cb758acefcbafbdaa154ad68f4d66e568169106 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Nov 2020 21:44:35 +0800
Subject: [PATCH 0914/3374] Update
 1640-check-array-formation-through-concatenation.js

---
 1640-check-array-formation-through-concatenation.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/1640-check-array-formation-through-concatenation.js b/1640-check-array-formation-through-concatenation.js
index a5a76212..275e2323 100644
--- a/1640-check-array-formation-through-concatenation.js
+++ b/1640-check-array-formation-through-concatenation.js
@@ -10,7 +10,6 @@ const canFormArray = function(arr, pieces) {
   }
   for(let p of pieces) {
     let idx = m.get(p[0])
-    console.log(idx)
     if(idx == null) return false
     for(let i = 1, len = p.length; i < len; i++) {
       console.log(m.has(p[i]))

From 8baaf7ce147642e0f5fbc580cb95b54f6559fccb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Nov 2020 08:53:08 +0800
Subject: [PATCH 0915/3374] Update 1642-furthest-building-you-can-reach.js

---
 1642-furthest-building-you-can-reach.js | 33 +++++++++----------------
 1 file changed, 11 insertions(+), 22 deletions(-)

diff --git a/1642-furthest-building-you-can-reach.js b/1642-furthest-building-you-can-reach.js
index 90587e5d..4468d978 100644
--- a/1642-furthest-building-you-can-reach.js
+++ b/1642-furthest-building-you-can-reach.js
@@ -4,30 +4,19 @@
  * @param {number} ladders
  * @return {number}
  */
-const furthestBuilding = function (heights, bricks, ladders) {
-  const queue = new PriorityQueue()
-  for (let i = 1; i < heights.length; ++i) {
-    if (heights[i] > heights[i - 1]) {
-      let diff = heights[i] - heights[i - 1]
-      if (diff <= bricks) {
-        bricks -= diff
-        queue.push(diff)
-      } else if (ladders > 0) {
-        let max = queue.isEmpty() ? 0 : queue.pop()
-        --ladders
-        if (max > diff) {
-          bricks = bricks + max - diff
-          queue.push(diff)
-        } else {
-          queue.push(max)
-        }
-      } else {
-        return i - 1
-      }
+const furthestBuilding = function(heights, bricks, ladders) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  const len = heights.length
+  for(let i = 0; i < len - 1; i++) {
+    const diff = heights[i + 1] - heights[i]
+    if(diff > 0) pq.push(diff)
+    if(pq.size() > ladders) {
+      bricks -= pq.pop()
     }
+    if(bricks < 0) return i
   }
-  return heights.length - 1
-}
+  return len - 1
+};
 class PriorityQueue {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []

From e2cb751934b7cb1e534b9eeaf940b7e7e307a510 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Nov 2020 11:01:53 +0800
Subject: [PATCH 0916/3374] Update 1537-get-the-maximum-score.js

---
 1537-get-the-maximum-score.js | 36 +++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1537-get-the-maximum-score.js b/1537-get-the-maximum-score.js
index 40ce2fca..bf35ef7b 100644
--- a/1537-get-the-maximum-score.js
+++ b/1537-get-the-maximum-score.js
@@ -70,3 +70,39 @@ const maxSum = function(nums1, nums2) {
   }
   return Math.max(a, b) % mod;
 };
+
+// another
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maxSum = function(nums1, nums2) {
+  const len1 = nums1.length, len2 = nums2.length
+  const mod = 10 ** 9 + 7
+  const map = new Map()
+  for(let i = 0; i < len1 - 1; i++) {
+    if(!map.has(nums1[i])) map.set(nums1[i], [])
+    map.get(nums1[i]).push(nums1[i + 1])
+  }
+  for(let j = 0; j < len2 - 1; j++) {
+    if(!map.has(nums2[j])) map.set(nums2[j], [])
+    map.get(nums2[j]).push(nums2[j + 1])
+  }
+  const memo = new Map()
+  return Math.max(greedy(nums1[0], map, memo), greedy(nums2[0], map, memo)) % mod
+};
+
+function greedy(cur, map, memo) {
+  if(memo.has(cur)) return memo.get(cur)
+  if(!map.has(cur)) return cur
+  let res = 0
+  for(let next of map.get(cur)) {
+    const tmp = greedy(next, map, memo)
+    if(tmp > res) res = tmp
+  }
+  res += cur
+  memo.set(cur, res)
+  return res
+}

From 6f295164532c987915a4af57d6e5ff2648630a6a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Nov 2020 12:31:21 +0800
Subject: [PATCH 0917/3374] Update 1643-kth-smallest-instructions.js

---
 1643-kth-smallest-instructions.js | 38 +++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1643-kth-smallest-instructions.js b/1643-kth-smallest-instructions.js
index b7fc93cf..23ccbacd 100644
--- a/1643-kth-smallest-instructions.js
+++ b/1643-kth-smallest-instructions.js
@@ -49,3 +49,41 @@ function comb(n, r) {
     return product(r + 1, n) / product(1, n - r)
   }
 }
+
+// another
+
+/**
+ * @param {number[]} destination
+ * @param {number} k
+ * @return {string}
+ */
+const kthSmallestPath = function (destination, k) {
+  const [r, c] = destination;
+  const ret = [];
+  let remDown = r;
+  for (let i = 0; i < r + c; i++) {
+    const remSteps = r + c - (i + 1);
+    const com = comb(remSteps, remDown);
+    if (com >= k) ret.push("H");
+    else {
+      remDown -= 1;
+      k -= com;
+      ret.push("V");
+    }
+  }
+  return ret.join("");
+};
+
+function comb(n, r) {
+  if (n < r) return 0;
+  let res = 1;
+  if (n - r < r) r = n - r;
+  for (let i = n, j = 1; i >= 1 && j <= r; --i, ++j) {
+    res = res * i;
+  }
+  for (let i = r; i >= 2; --i) {
+    res = res / i;
+  }
+  return res;
+}
+

From 8ee86422f6ded5cd9ef75ec1617e430d7879061f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Nov 2020 14:53:45 +0800
Subject: [PATCH 0918/3374] Create 1646-get-maximum-in-generated-array.js

---
 1646-get-maximum-in-generated-array.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1646-get-maximum-in-generated-array.js

diff --git a/1646-get-maximum-in-generated-array.js b/1646-get-maximum-in-generated-array.js
new file mode 100644
index 00000000..88ee56b2
--- /dev/null
+++ b/1646-get-maximum-in-generated-array.js
@@ -0,0 +1,17 @@
+const arr = [0, 1, 1]
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const getMaximumGenerated = function(n) {
+  if(arr[n] != null) return Math.max(...arr.slice(0, n + 1))
+  const oddOrEven = num => num % 2 === 0 ? 'even' : 'odd'
+  const hi = arr.length - 1
+  for(let i = hi + 1; i <= n; i++) {
+    let tmp, chk = oddOrEven(i)
+    if(chk === 'odd') tmp = arr[Math.floor(i / 2)] + arr[Math.floor(i / 2) + 1]
+    else tmp = arr[Math.floor(i / 2)]
+    arr[i] = tmp
+  }
+  return Math.max(...arr.slice(0, n + 1))
+};

From 839bf4b1718ca76fd80f4d25eea03d9acf80f5e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Nov 2020 14:54:18 +0800
Subject: [PATCH 0919/3374] Create
 1647-minimum-deletions-to-make-character-frequencies-unique.js

---
 ...ns-to-make-character-frequencies-unique.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1647-minimum-deletions-to-make-character-frequencies-unique.js

diff --git a/1647-minimum-deletions-to-make-character-frequencies-unique.js b/1647-minimum-deletions-to-make-character-frequencies-unique.js
new file mode 100644
index 00000000..a6af8c16
--- /dev/null
+++ b/1647-minimum-deletions-to-make-character-frequencies-unique.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minDeletions = function(s) {
+      if (s == null || s.length <= 1) {
+         return 0;
+      }
+
+      const map = new Map();
+      for (let ch of s) {
+        map.set(ch, (map.get(ch) || 0) + 1);
+      }
+
+
+      const frequencies = new Set();
+      let minDeletions = 0;
+      
+      const vals = map.values()
+      for (let frequency of vals) {
+         if (!frequencies.has(frequency)) {
+            frequencies.add(frequency);
+            continue;
+         }
+
+         let curr = frequency;
+         while (curr > 0 && frequencies.has(curr)) {
+            curr--;
+            minDeletions++;
+         }
+
+         if (curr > 0) {
+            frequencies.add(curr);
+         }
+      }
+
+      return minDeletions;
+};

From 2090938062f191655590e5c220628f3003369af6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Nov 2020 14:54:49 +0800
Subject: [PATCH 0920/3374] Create
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1648-sell-diminishing-valued-colored-balls.js

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
new file mode 100644
index 00000000..c84e2cf8
--- /dev/null
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} inventory
+ * @param {number} orders
+ * @return {number}
+ */
+const maxProfit = function (inventory, orders) {
+  let Max = 1e9 + 7,
+    Min = 0
+  let mod = BigInt(1e9 + 7)
+  while (Max > Min + 1) {
+    let tot = 0
+    let mid = ((Max + Min) >> 1)
+    for (let it of inventory) {
+      if (it > mid) tot += it - mid
+    }
+    if (tot > orders) Min = mid
+    else Max = mid
+  }
+  let sum = BigInt(0)
+  Max = BigInt(Max)
+  orders = BigInt(orders)
+  for (let it of inventory) {
+    it = BigInt(it)
+    if (it > Max) {
+      sum += ((it + Max + BigInt(1)) * (it - Max)) / BigInt(2)
+      orders -= it - Max
+    }
+  }
+  sum += orders * Max
+  
+  return sum % mod
+}

From 6c102cec5f4764866ce7234f4eee942d1b5c7d44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Nov 2020 14:55:18 +0800
Subject: [PATCH 0921/3374] Create
 1649-create-sorted-array-through-instructions.js

---
 ...reate-sorted-array-through-instructions.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1649-create-sorted-array-through-instructions.js

diff --git a/1649-create-sorted-array-through-instructions.js b/1649-create-sorted-array-through-instructions.js
new file mode 100644
index 00000000..6f30ca3c
--- /dev/null
+++ b/1649-create-sorted-array-through-instructions.js
@@ -0,0 +1,36 @@
+const lowBit = (x) => x & -x
+class FenwickTree {
+  constructor(n) {
+    if (n < 1) return
+    this.sum = Array(n + 1).fill(0)
+  }
+  update(i, delta) {
+    if (i < 1) return
+    while (i < this.sum.length) {
+      this.sum[i] += delta
+      i += lowBit(i)
+    }
+  }
+  query(i) {
+    if (i < 1) return 0
+    let sum = 0
+    while (i > 0) {
+      sum += this.sum[i]
+      i -= lowBit(i)
+    }
+    return sum
+  }
+}
+/**
+ * @param {number[]} instructions
+ * @return {number}
+ */
+const createSortedArray = function(instructions) {
+  let res = 0, n = instructions.length, mod = 10 ** 9 + 7
+  const bit = new FenwickTree(10 ** 5)
+  for(let i = 0; i < n; i++) {
+    res = (res + Math.min(bit.query(instructions[i] - 1), i - bit.query(instructions[i]))) % mod
+    bit.update(instructions[i], 1)
+  }
+  return res
+};

From 82466a4fd00619843dc319c4429220abd5029967 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Nov 2020 15:33:17 +0800
Subject: [PATCH 0922/3374] Update
 1449-form-largest-integer-with-digits-that-add-up-to-target.js

---
 ...teger-with-digits-that-add-up-to-target.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1449-form-largest-integer-with-digits-that-add-up-to-target.js b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
index 9acd6c89..8ceae82d 100644
--- a/1449-form-largest-integer-with-digits-that-add-up-to-target.js
+++ b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} cost
+ * @param {number} target
+ * @return {string}
+ */
+const largestNumber = function (cost, target) {
+  const dp = new Array(target + 1).fill(-Infinity)
+  dp[0] = 0
+  for (let i = 1; i <= target; i++) {
+    for (let c of cost) {
+      if (i - c >= 0 && dp[i - c] >= 0) {
+        dp[i] = Math.max(dp[i - c] + 1, dp[i])
+      }
+    }
+  }
+  let left = target
+  let paint = ''
+  if (dp[target] < 1) return '0'
+  for (let i = cost.length - 1; i >= 0; i--) {
+    while (left > 0 && dp[left - cost[i]] === dp[left] - 1) {
+      paint += (i + 1).toString()
+      left -= cost[i]
+    }
+  }
+  return paint
+}
+
+// another
+
 /**
  * @param {number[]} cost
  * @param {number} target

From 74c0292fddc493348aa22a97b59cbc21f788a878 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Nov 2020 00:21:57 +0800
Subject: [PATCH 0923/3374] Update 1235-maximum-profit-in-job-scheduling.js

---
 1235-maximum-profit-in-job-scheduling.js | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/1235-maximum-profit-in-job-scheduling.js b/1235-maximum-profit-in-job-scheduling.js
index b3a05b6a..c49c1a56 100644
--- a/1235-maximum-profit-in-job-scheduling.js
+++ b/1235-maximum-profit-in-job-scheduling.js
@@ -18,11 +18,8 @@ const jobScheduling = function (startTime, endTime, profit) {
     const s = item[0],
       e = item[1],
       p = item[2]
-    let prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s + 1)
-    if (prevIdx < 0) {
-      prevIdx = -prevIdx - 1
-    }
-    prevIdx--
+    // find previous endTime index
+    let prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s)
     const currProfit = dpProfit[prevIdx] + p,
       maxProfit = dpProfit[dpProfit.length - 1]
     if (currProfit > maxProfit) {
@@ -35,10 +32,12 @@ const jobScheduling = function (startTime, endTime, profit) {
 
 function binarySearch(arr, l, r, x) {
   while (l <= r) {
-    const m = l + ((r - l) >> 1)
-    if (arr[m] === x) return m
-    if (arr[m] < x) l = m + 1
-    else r = m - 1
+    const mid = l + ((r - l) >> 1)
+    if (arr[mid] > x) r = mid - 1
+    else {
+      if (mid == arr.length - 1 || arr[mid + 1] > x) return mid
+      l = mid + 1
+    }
   }
-  return -l - 1
+  return -1
 }

From a3d5d4f1a2481c1c475bdde7db9b79a22c61abe9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Nov 2020 09:53:01 +0800
Subject: [PATCH 0924/3374] Update 518-coin-change-2.js

---
 518-coin-change-2.js | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/518-coin-change-2.js b/518-coin-change-2.js
index 2003043c..ec1c2d5b 100644
--- a/518-coin-change-2.js
+++ b/518-coin-change-2.js
@@ -4,18 +4,21 @@
  * @return {number}
  */
 function change(amount, coins) {
-    const dp = Array.from(new Array(coins.length+1), () => new Array(amount + 1).fill(0))
-    dp[0][0] = 1;
-    
-    for (let i = 1; i <= coins.length; i++) {
-        dp[i][0] = 1;
-        for (let j = 1; j <= amount; j++) {
-            dp[i][j] = dp[i-1][j] + (j >= coins[i-1] ? dp[i][j-coins[i-1]] : 0);
-        }
+  const dp = Array.from(new Array(coins.length + 1), () =>
+    new Array(amount + 1).fill(0)
+  )
+  dp[0][0] = 1
+  for (let i = 1; i <= coins.length; i++) {
+    dp[i][0] = 1
+    for (let j = 1; j <= amount; j++) {
+      dp[i][j] =
+        dp[i - 1][j] + (j >= coins[i - 1] ? dp[i][j - coins[i - 1]] : 0)
     }
-    return dp[coins.length][amount];
+  }
+  return dp[coins.length][amount]
 }
 
+
 // another
 
 /**
@@ -27,9 +30,7 @@ const change = function (amount, coins) {
   const dp = Array(amount + 1).fill(0)
   dp[0] = 1
   for (let coin of coins) {
-    for (let i = coin; i < amount + 1; i++) {
-      dp[i] += dp[i - coin]
-    }
+    for (let i = coin; i < amount + 1; i++) dp[i] += dp[i - coin]
   }
   return dp[amount]
 }

From f542a41cebf90acd42bb0ab299c40fb20b35753c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Nov 2020 13:22:17 +0800
Subject: [PATCH 0925/3374] Update
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
index c84e2cf8..b0d3d636 100644
--- a/1648-sell-diminishing-valued-colored-balls.js
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[]} inventory
+ * @param {number} orders
+ * @return {number}
+ */
+function maxProfit(inventory, orders) {
+  inventory.sort((a, b) => a - b)
+  inventory = inventory.map(e => BigInt(e))
+  let ans = 0n, n = inventory.length - 1, count = 1n
+  const mod = BigInt(10 ** 9 + 7)
+  orders = BigInt(orders)
+  while(orders > 0n) {
+    if(n > 0 && inventory[n] > inventory[n - 1] && orders >= count * (inventory[n] - inventory[n - 1])) {
+      ans += count * sum(inventory[n - 1], inventory[n])
+      orders -= count * (inventory[n] - inventory[n - 1])
+    } else if(n === 0 || inventory[n] > inventory[n - 1]) {
+      const num = orders / count
+      ans += count * sum(inventory[n] - num, inventory[n])
+      const remain = orders % count
+      ans += remain * (inventory[n] - num)
+      orders = 0n
+    }
+    ans %= mod
+    n--
+    count++
+  }
+  return ans
+}
+
+function sum(lo, hi) {
+  return (hi - lo) * (lo + hi + 1n) / 2n
+}
+
+// another
+
 /**
  * @param {number[]} inventory
  * @param {number} orders

From 575b80a4b78c88b2de97f113e85f953823964d85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Nov 2020 10:22:14 +0800
Subject: [PATCH 0926/3374] Update 493-reverse-pairs.js

---
 493-reverse-pairs.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/493-reverse-pairs.js b/493-reverse-pairs.js
index 2f0bab92..bb76e4c8 100644
--- a/493-reverse-pairs.js
+++ b/493-reverse-pairs.js
@@ -48,7 +48,7 @@ function merge(A, start, mid, end) {
 
 function mergesort_and_count(A, start, end) {
   if (start < end) {
-    let mid = ((start + end) >> 1)
+    let mid = start + ((end - start) >> 1)
     let count =
       mergesort_and_count(A, start, mid) + mergesort_and_count(A, mid + 1, end)
     let j = mid + 1

From 9fd1eb1f273d47fd3c67ebf464774d4ada5aeb47 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 Nov 2020 10:54:07 +0800
Subject: [PATCH 0927/3374] Update 327-count-of-range-sum.js

---
 327-count-of-range-sum.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/327-count-of-range-sum.js b/327-count-of-range-sum.js
index c5e9be1d..94876b65 100644
--- a/327-count-of-range-sum.js
+++ b/327-count-of-range-sum.js
@@ -4,7 +4,7 @@
  * @param {number} upper
  * @return {number}
  */
-const countRangeSum = function(nums, lower, upper) {
+const countRangeSum = function (nums, lower, upper) {
   if (nums.length === 0) return 0
   const sums = [nums[0]]
   for (let i = 1; i < nums.length; i++) {
@@ -14,7 +14,7 @@ const countRangeSum = function(nums, lower, upper) {
     if (hi - lo === 1) {
       return sums[lo] >= lower && sums[lo] <= upper ? 1 : 0
     }
-    const mid = Math.floor((lo + hi) / 2)
+    const mid = lo + Math.floor((hi - lo) / 2)
     let counter = merge_sort(A, lo, mid) + merge_sort(A, mid, hi)
     let m = mid,
       n = mid

From 2504e2263e189869a0560234d2fe7649762c092a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 12:22:23 +0800
Subject: [PATCH 0928/3374] Create 1656-design-an-ordered-stream.js

---
 1656-design-an-ordered-stream.js | 34 ++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1656-design-an-ordered-stream.js

diff --git a/1656-design-an-ordered-stream.js b/1656-design-an-ordered-stream.js
new file mode 100644
index 00000000..cc1587cd
--- /dev/null
+++ b/1656-design-an-ordered-stream.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ */
+const OrderedStream = function(n) {
+  this.arr = Array(n + 1)
+  this.ptr = 1
+};
+
+/** 
+ * @param {number} id 
+ * @param {string} value
+ * @return {string[]}
+ */
+OrderedStream.prototype.insert = function(id, value) {
+  
+  this.arr[id] = value
+  const res = []
+  let i
+  for(i = this.ptr, len = this.arr.length; i < len; i++) {
+    if (this.arr[i] != null) res.push(this.arr[i])
+    else {
+      break
+    }
+  }
+  this.ptr = i
+    
+  return res
+};
+
+/** 
+ * Your OrderedStream object will be instantiated and called as such:
+ * var obj = new OrderedStream(n)
+ * var param_1 = obj.insert(id,value)
+ */

From 556f7184d77a6852ab02d5e187187c2b42eba68b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 12:23:41 +0800
Subject: [PATCH 0929/3374] Create 1657-determine-if-two-strings-are-close.js

---
 1657-determine-if-two-strings-are-close.js | 30 ++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1657-determine-if-two-strings-are-close.js

diff --git a/1657-determine-if-two-strings-are-close.js b/1657-determine-if-two-strings-are-close.js
new file mode 100644
index 00000000..a6d92283
--- /dev/null
+++ b/1657-determine-if-two-strings-are-close.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {boolean}
+ */
+const closeStrings = function(word1, word2) {
+  const len1 = word1.length, len2 = word2.length
+  if(len1 !== len2) return false
+  const a = ('a').charCodeAt(0)
+  const arr1 = Array(26).fill(0)
+  const arr2 = Array(26).fill(0)
+  for(let i = 0; i < len1; i++) {
+    arr1[word1.charCodeAt(i) - a]++
+    arr2[word2.charCodeAt(i) - a]++
+  }
+  return chk1(arr1, arr2)
+  function chk1(a1, a2) {
+    const a11 = a1.slice(0)
+    a11.sort()
+    const a22 = a2.slice(0)
+    a22.sort()
+    for(let i = 0, len = a1.length; i < len; i++) {
+      if((a1[i] !== 0 && a2[i] === 0) || (a1[i] === 0 && a2[i] !== 0) ) return false
+    }
+    for(let i = 0, len = a1.length; i < len; i++) {
+      if(a11[i] !== a22[i]) return false
+    }
+    return true
+  }
+};

From 0d526016dcdae590cb5055961d60bf1291bb4b7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 12:24:20 +0800
Subject: [PATCH 0930/3374] Create
 1658-minimum-operations-to-reduce-x-to-zero.js

---
 ...-minimum-operations-to-reduce-x-to-zero.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1658-minimum-operations-to-reduce-x-to-zero.js

diff --git a/1658-minimum-operations-to-reduce-x-to-zero.js b/1658-minimum-operations-to-reduce-x-to-zero.js
new file mode 100644
index 00000000..ed2b66ef
--- /dev/null
+++ b/1658-minimum-operations-to-reduce-x-to-zero.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function (nums, x) {
+  let l = 0,
+    r = nums.length - 1;
+  while (x >= 0 && r >= l) {
+    x -= nums[r];
+    r -= 1;
+  }
+  if (r < 0 && x > 0) {
+    return -1;
+  } else if (r < 0 && x == 0) {
+    return nums.length;
+  }
+
+  let ans = Number.MAX_VALUE;
+  while (r < nums.length) {
+    while (x <= 0 && r + 1 < nums.length) {
+      if (x == 0) ans = Math.min(ans, nums.length - (r - l + 1));
+      x += nums[r + 1];
+      r += 1;
+    }
+    if (r + 1 >= nums.length) {
+      if (x == 0) ans = Math.min(ans, nums.length - (r - l + 1));
+      break;
+    }
+    while (x >= 0) {
+      if (x == 0) ans = Math.min(ans, nums.length - (r - l + 1));
+      x -= nums[l];
+      l += 1;
+    }
+  }
+  return ans != Number.MAX_VALUE ? ans : -1;
+};

From 38a07c29a41ce76a807da56e2acecae321118a30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 13:01:54 +0800
Subject: [PATCH 0931/3374] Create 1659-maximize-grid-happiness.js

---
 1659-maximize-grid-happiness.js | 51 +++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1659-maximize-grid-happiness.js

diff --git a/1659-maximize-grid-happiness.js b/1659-maximize-grid-happiness.js
new file mode 100644
index 00000000..4fbfa5a0
--- /dev/null
+++ b/1659-maximize-grid-happiness.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} introvertsCount
+ * @param {number} extrovertsCount
+ * @return {number}
+ */
+const getMaxGridHappiness = function (m, n, introvertsCount, extrovertsCount) {
+  const grid = Array.from({ length: m }, () => Array(n).fill(0))
+  return dfs(grid, 0, 0, introvertsCount, extrovertsCount, 0)
+
+  function dfs(grid, row, col, int, ex, happy) {
+    const M = grid.length,
+      N = grid[0].length
+    if (row == M - 1 && col == N) return happy
+    if (col == N) {
+      col = 0
+      ++row
+    }
+    let res = dfs(grid, row, col + 1, int, ex, happy)
+    if (int > 0) {
+      grid[row][col] = 1
+      let h = happy + 120
+      if (row > 0 && grid[row - 1][col] != 0) {
+        if (grid[row - 1][col] == 1) h += -30 - 30
+        else h += 20 - 30
+      }
+      if (col > 0 && grid[row][col - 1] != 0) {
+        if (grid[row][col - 1] == 1) h += -30 - 30
+        else h += 20 - 30
+      }
+      res = Math.max(res, dfs(grid, row, col + 1, int - 1, ex, h))
+      grid[row][col] = 0
+    }
+    if (ex > 0) {
+      grid[row][col] = 2
+      let h = happy + 40
+      if (row > 0 && grid[row - 1][col] != 0) {
+        if (grid[row - 1][col] == 1) h += 20 - 30
+        else h += 20 + 20
+      }
+      if (col > 0 && grid[row][col - 1] != 0) {
+        if (grid[row][col - 1] == 1) h += 20 - 30
+        else h += 20 + 20
+      }
+      res = Math.max(res, dfs(grid, row, col + 1, int, ex - 1, h))
+      grid[row][col] = 0
+    }
+    return res
+  }
+}

From b268e36b6eb797e170d8c53e94a16017cee484a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 16:01:22 +0800
Subject: [PATCH 0932/3374] Create 1654-minimum-jumps-to-reach-home.js

---
 1654-minimum-jumps-to-reach-home.js | 40 +++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1654-minimum-jumps-to-reach-home.js

diff --git a/1654-minimum-jumps-to-reach-home.js b/1654-minimum-jumps-to-reach-home.js
new file mode 100644
index 00000000..9cf20d09
--- /dev/null
+++ b/1654-minimum-jumps-to-reach-home.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} forbidden
+ * @param {number} a
+ * @param {number} b
+ * @param {number} x
+ * @return {number}
+ */
+const minimumJumps = function (forbidden, a, b, x) {
+  const bad = new Set()
+  const set = new Set()
+  for (let i of forbidden) {
+    bad.add(i)
+  }
+  const q = []
+  q.push([0, 0, 0])
+  set.add('0,0')
+  while (q.length) {
+    const pair = q.shift()
+    let pos = pair[0],
+      level = pair[1],
+      state = pair[2]
+    if (pos == x) return level
+    if (state >= 0) {
+      if (pos <= 10000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+        set.add(pos + a + ',0')
+        q.push([pos + a, level + 1, 0])
+      }
+      if (!set.has(pos - b + ',-1') && !bad.has(pos - b) && pos - b >= 0) {
+        set.add(pos - b + ',-1')
+        q.push([pos - b, level + 1, -1])
+      }
+    } else if (state < 0) {
+      if (pos <= 10000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+        set.add(pos + a + ',0')
+        q.push([pos + a, level + 1, 0])
+      }
+    }
+  }
+  return -1
+}

From d095b15cc6b857d5118ad43c16a0aa02730e22f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Nov 2020 17:09:43 +0800
Subject: [PATCH 0933/3374] Update 1654-minimum-jumps-to-reach-home.js

---
 1654-minimum-jumps-to-reach-home.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1654-minimum-jumps-to-reach-home.js b/1654-minimum-jumps-to-reach-home.js
index 9cf20d09..6969ab4a 100644
--- a/1654-minimum-jumps-to-reach-home.js
+++ b/1654-minimum-jumps-to-reach-home.js
@@ -21,7 +21,7 @@ const minimumJumps = function (forbidden, a, b, x) {
       state = pair[2]
     if (pos == x) return level
     if (state >= 0) {
-      if (pos <= 10000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+      if (pos <= 4000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
         set.add(pos + a + ',0')
         q.push([pos + a, level + 1, 0])
       }
@@ -30,7 +30,7 @@ const minimumJumps = function (forbidden, a, b, x) {
         q.push([pos - b, level + 1, -1])
       }
     } else if (state < 0) {
-      if (pos <= 10000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+      if (pos <= 4000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
         set.add(pos + a + ',0')
         q.push([pos + a, level + 1, 0])
       }

From ca8ac4285b070d5f78d91bf6f52f017008c5cdab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Nov 2020 11:58:55 +0800
Subject: [PATCH 0934/3374] Create 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 39 +++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1655-distribute-repeating-integers.js

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
new file mode 100644
index 00000000..bd440870
--- /dev/null
+++ b/1655-distribute-repeating-integers.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} quantity
+ * @return {boolean}
+ */
+const canDistribute = function (nums, quantity) {
+  const mp = {}
+  for (let x of nums) {
+    mp[x] = (mp[x] || 0) + 1
+  }
+  const a = []
+  for (let p in mp) a.push(mp[p])
+  const b = quantity
+  const m = quantity.length
+  const n = a.length
+  const dp = Array.from({ length: n }, () => Array(1 << m).fill(-1))
+  return solve(0, 0)
+
+  function solve(idx, mask) {
+    if (mask === (1 << m) - 1) return 1
+    if (idx === n) return 0
+    if (dp[idx][mask] !== -1) return dp[idx][mask]
+    let ans = solve(idx + 1, mask)
+    for (let i = 0, up = 1 << m; i < up; i++) {
+      if (mask !== (mask & i)) continue
+      let nm = mask
+      let sum = 0
+      for (let j = 0; j < m; j++) {
+        if (mask & (1 << j)) continue
+        if (i & (1 << j)) {
+          sum += b[j]
+          nm |= 1 << j
+        }
+      }
+      if (sum <= a[idx]) ans |= solve(idx + 1, nm)
+    }
+    return (dp[idx][mask] = ans)
+  }
+}

From 391ba03fbd8573bd53622db51629c28c2235ef52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Nov 2020 17:22:13 +0800
Subject: [PATCH 0935/3374] Update 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 33 +++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
index bd440870..8a7b0120 100644
--- a/1655-distribute-repeating-integers.js
+++ b/1655-distribute-repeating-integers.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} quantity
+ * @return {boolean}
+ */
+const canDistribute = function (nums, quantity) {
+  const mp = {}
+  for (let x of nums) {
+    mp[x] = (mp[x] || 0) + 1
+  }
+  const values = Object.values(mp)
+  quantity.sort((a, b) => b - a)
+  let res = false
+  dfs(0)
+  return res
+
+  function dfs(idx) {
+    if(idx === quantity.length || res) {
+      res = true
+      return
+    }
+    for(let i = 0, len = values.length; i < len; i++) {
+      if(values[i] >= quantity[idx]) {
+        values[i] -= quantity[idx]
+        dfs(idx + 1)
+        values[i] += quantity[idx]
+      }
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[]} quantity

From b5c0257c0ded24df2b9b0d2a7a73013026b2c90f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Nov 2020 21:20:25 +0800
Subject: [PATCH 0936/3374] Update 2-add-two-numbers.js

---
 2-add-two-numbers.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2-add-two-numbers.js b/2-add-two-numbers.js
index eb448263..26c7b3c8 100755
--- a/2-add-two-numbers.js
+++ b/2-add-two-numbers.js
@@ -1,3 +1,34 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  let res = new ListNode(null)
+  let inc = false
+  let cur = res
+  while(l1 || l2 || inc) {
+    const tmp = ((l1 && l1.val) || 0) + ((l2 && l2.val) || 0) + (inc ? 1 : 0)
+    if(tmp >= 10) inc = true
+    else inc = false
+    cur.next = new ListNode(tmp % 10)
+    cur = cur.next
+    if(l1) l1 = l1.next
+    if(l2) l2 = l2.next
+  }
+  
+  return res.next
+};
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From b8f3a5d5939cf3f787e23e0dc10613c2347227eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Nov 2020 22:12:34 +0800
Subject: [PATCH 0937/3374] Create
 1644-lowest-common-ancestor-of-a-binary-tree-ii.js

---
 ...est-common-ancestor-of-a-binary-tree-ii.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1644-lowest-common-ancestor-of-a-binary-tree-ii.js

diff --git a/1644-lowest-common-ancestor-of-a-binary-tree-ii.js b/1644-lowest-common-ancestor-of-a-binary-tree-ii.js
new file mode 100644
index 00000000..32c2a70a
--- /dev/null
+++ b/1644-lowest-common-ancestor-of-a-binary-tree-ii.js
@@ -0,0 +1,35 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+const lowestCommonAncestor = function (root, p, q) {
+  let cn = null
+  const dfs = function (node) {
+    let mid = 0
+    if (!node) return false
+    let left = dfs(node.left)
+    let right = dfs(node.right)
+    if (node === p || node === q) {
+      mid = 1
+    } else {
+      mid = 0
+    }
+    if (mid + left + right >= 2) {
+      cn = node
+    } else {
+      if (mid) return mid
+      return left || right
+    }
+  }
+  dfs(root)
+  return cn
+}

From 7f264b9195c632a5790cc642f3168c6cde1f405a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Nov 2020 21:05:22 +0800
Subject: [PATCH 0938/3374] Create
 1650-lowest-common-ancestor-of-a-binary-tree-iii.js

---
 ...st-common-ancestor-of-a-binary-tree-iii.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1650-lowest-common-ancestor-of-a-binary-tree-iii.js

diff --git a/1650-lowest-common-ancestor-of-a-binary-tree-iii.js b/1650-lowest-common-ancestor-of-a-binary-tree-iii.js
new file mode 100644
index 00000000..d69eb25d
--- /dev/null
+++ b/1650-lowest-common-ancestor-of-a-binary-tree-iii.js
@@ -0,0 +1,30 @@
+/**
+ * // Definition for a Node.
+ * function Node(val) {
+ *    this.val = val;
+ *    this.left = null;
+ *    this.right = null;
+ *    this.parent = null;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const lowestCommonAncestor = function(p, q) {
+  const pa = [], qa = []
+  if(up(p, q, pa)) return q
+  if(up(q, p, qa)) return p
+  const set = new Set(pa)
+  for(let i = 0; i < qa.length; i++) {
+    if(set.has(qa[i])) return qa[i]
+  }
+  
+  function up(node, target, arr) {
+    if(node == null) return null
+    if(node === target) return target
+    arr.push(node)
+    return up(node.parent, target, arr)
+  }
+};

From 82c998e8a74ffcee9b780ab8c9bd2a1e88b01135 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Nov 2020 22:29:12 +0800
Subject: [PATCH 0939/3374] Update
 1650-lowest-common-ancestor-of-a-binary-tree-iii.js

---
 ...st-common-ancestor-of-a-binary-tree-iii.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1650-lowest-common-ancestor-of-a-binary-tree-iii.js b/1650-lowest-common-ancestor-of-a-binary-tree-iii.js
index d69eb25d..2d0cf7b4 100644
--- a/1650-lowest-common-ancestor-of-a-binary-tree-iii.js
+++ b/1650-lowest-common-ancestor-of-a-binary-tree-iii.js
@@ -28,3 +28,28 @@ const lowestCommonAncestor = function(p, q) {
     return up(node.parent, target, arr)
   }
 };
+
+// another
+
+/**
+ * // Definition for a Node.
+ * function Node(val) {
+ *    this.val = val;
+ *    this.left = null;
+ *    this.right = null;
+ *    this.parent = null;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const lowestCommonAncestor = function(p, q) {
+  let a = p, b = q;
+	while (a !== b) {
+		a = a == null? q : a.parent;
+		b = b == null? p : b.parent;    
+	}
+	return a;
+};

From 77f869ffb95ee36f14d44bb44d1e247c3e804a6b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Nov 2020 19:17:45 +0800
Subject: [PATCH 0940/3374] Update 1659-maximize-grid-happiness.js

---
 1659-maximize-grid-happiness.js | 85 +++++++++++++++++----------------
 1 file changed, 43 insertions(+), 42 deletions(-)

diff --git a/1659-maximize-grid-happiness.js b/1659-maximize-grid-happiness.js
index 4fbfa5a0..e6a97fe0 100644
--- a/1659-maximize-grid-happiness.js
+++ b/1659-maximize-grid-happiness.js
@@ -5,47 +5,48 @@
  * @param {number} extrovertsCount
  * @return {number}
  */
-const getMaxGridHappiness = function (m, n, introvertsCount, extrovertsCount) {
-  const grid = Array.from({ length: m }, () => Array(n).fill(0))
-  return dfs(grid, 0, 0, introvertsCount, extrovertsCount, 0)
-
-  function dfs(grid, row, col, int, ex, happy) {
-    const M = grid.length,
-      N = grid[0].length
-    if (row == M - 1 && col == N) return happy
-    if (col == N) {
-      col = 0
-      ++row
-    }
-    let res = dfs(grid, row, col + 1, int, ex, happy)
-    if (int > 0) {
-      grid[row][col] = 1
-      let h = happy + 120
-      if (row > 0 && grid[row - 1][col] != 0) {
-        if (grid[row - 1][col] == 1) h += -30 - 30
-        else h += 20 - 30
-      }
-      if (col > 0 && grid[row][col - 1] != 0) {
-        if (grid[row][col - 1] == 1) h += -30 - 30
-        else h += 20 - 30
-      }
-      res = Math.max(res, dfs(grid, row, col + 1, int - 1, ex, h))
-      grid[row][col] = 0
-    }
-    if (ex > 0) {
-      grid[row][col] = 2
-      let h = happy + 40
-      if (row > 0 && grid[row - 1][col] != 0) {
-        if (grid[row - 1][col] == 1) h += 20 - 30
-        else h += 20 + 20
-      }
-      if (col > 0 && grid[row][col - 1] != 0) {
-        if (grid[row][col - 1] == 1) h += 20 - 30
-        else h += 20 + 20
-      }
-      res = Math.max(res, dfs(grid, row, col + 1, int, ex - 1, h))
-      grid[row][col] = 0
-    }
-    return res
+const getMaxGridHappiness = (m, n, introvertsCount, extrovertsCount) => {
+  const state = '0'.repeat(n)
+  const memo = new Map()
+  return helper(state, 0, n, m, introvertsCount, extrovertsCount, memo)
+}
+function helper(state, idx, n, m, inCount, exCount, memo) {
+  if ((inCount === 0 && exCount === 0) || idx === m * n) return 0
+  let key = idx + state + inCount + exCount
+  if (memo.has(key)) return memo.get(key)
+  const r = (idx / n) >> 0,
+    c = idx % n
+  let best = 0
+  if (inCount !== 0) {
+    let score = 120
+    if (r > 0) score = calc(state.charAt(0) - '0', 1, score)
+    if (c !== 0) score = calc(state.charAt(state.length - 1) - '0', 1, score)
+    best =
+      score +
+      helper(state.slice(1) + '1', idx + 1, n, m, inCount - 1, exCount, memo)
+  }
+  if (exCount !== 0) {
+    let score = 40
+    if (r > 0) score = calc(state.charAt(0) - '0', 2, score)
+    if (c !== 0) score = calc(state.charAt(state.length - 1) - '0', 2, score)
+    best = Math.max(
+      best,
+      score +
+        helper(state.slice(1) + '2', idx + 1, n, m, inCount, exCount - 1, memo)
+    )
   }
+  best = Math.max(
+    best,
+    helper(state.slice(1) + '0', idx + 1, n, m, inCount, exCount, memo)
+  )
+  memo.set(key, best)
+  return best
+}
+
+function calc(p1, p2, score) {
+  if (p1 === 1 && p2 === 1) return score - 60
+  else if (p1 === 2 && p2 === 2) return score + 40
+  else if (p1 === 1 && p2 === 2) return score - 10
+  else if (p1 === 2 && p2 === 1) return score - 10
+  return score
 }

From 1db2122e52d464abc9a8418c78efa5ae2dc184a9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Nov 2020 09:54:20 +0800
Subject: [PATCH 0941/3374] Create 1540-can-convert-string-in-k-moves.js

---
 1540-can-convert-string-in-k-moves.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1540-can-convert-string-in-k-moves.js

diff --git a/1540-can-convert-string-in-k-moves.js b/1540-can-convert-string-in-k-moves.js
new file mode 100644
index 00000000..5402c1ee
--- /dev/null
+++ b/1540-can-convert-string-in-k-moves.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @param {number} k
+ * @return {boolean}
+ */
+const canConvertString = function(s, t, k) {
+  if(s == null || t == null) return false
+  const slen = s.length, tlen = t.length
+  if(slen !== tlen) return false
+  const count = Array(26).fill(0)
+  for(let i = 0; i < slen; i++) {
+    const scode = s.charCodeAt(i)
+    const tcode = t.charCodeAt(i)
+    const diff = (tcode - scode + 26) % 26;
+    if (diff > 0 && diff + count[diff] * 26 > k) {
+      return false;
+    }
+    count[diff]++;
+  }
+  return true
+};

From f083adaee25b5aa7a1951b1273055315e8701c3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Nov 2020 21:27:22 +0800
Subject: [PATCH 0942/3374] Create 939-minimum-area-rectangle.js

---
 939-minimum-area-rectangle.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 939-minimum-area-rectangle.js

diff --git a/939-minimum-area-rectangle.js b/939-minimum-area-rectangle.js
new file mode 100644
index 00000000..d17a18cf
--- /dev/null
+++ b/939-minimum-area-rectangle.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const minAreaRect = function(points) {
+  const xmap = {}, ymap = {}
+  points.forEach(e => {
+    const [x, y] = e
+    if(!xmap.hasOwnProperty(x)) xmap[x] = new Set()
+    if(!ymap.hasOwnProperty(y)) ymap[y] = new Set()
+    xmap[x].add(y)
+    ymap[y].add(x)
+  })
+  let res = Infinity
+  for(let i = 0, len = points.length; i < len - 1; i++) {
+    const [x, y] = points[i]
+    for(let j = i + 1; j < len; j++) {
+      const [x1, y1] = points[j]
+      if(x === x1 || y === y1) continue
+      let area = Infinity
+      if(xmap[x].has(y1) && ymap[y].has(x1)) area = Math.abs(x - x1) * Math.abs(y - y1)
+      else continue
+      res = Math.min(res, area)
+    }
+  }
+  return res === Infinity ? 0 : res
+};

From 14d50ac4c621ab10ec6cb78c2002515ea1eac8dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Nov 2020 21:44:25 +0800
Subject: [PATCH 0943/3374] Update 939-minimum-area-rectangle.js

---
 939-minimum-area-rectangle.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/939-minimum-area-rectangle.js b/939-minimum-area-rectangle.js
index d17a18cf..722d4940 100644
--- a/939-minimum-area-rectangle.js
+++ b/939-minimum-area-rectangle.js
@@ -25,3 +25,26 @@ const minAreaRect = function(points) {
   }
   return res === Infinity ? 0 : res
 };
+
+// another
+
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const minAreaRect = function (points) {
+  let ans = Infinity
+  const isPoint = {}
+  points.forEach(([x, y]) => (isPoint[x * 40000 + y] = true))
+  for (let idx1 = 0; idx1 < points.length - 1; idx1++) {
+    const [x1, y1] = points[idx1]
+    for (let idx2 = idx1 + 1; idx2 < points.length; idx2++) {
+      const [x2, y2] = points[idx2]
+      const area = Math.abs((x1 - x2) * (y1 - y2))
+      if (area === 0 || area >= ans) continue
+      if (isPoint[x1 * 40000 + y2] && isPoint[x2 * 40000 + y1]) ans = area
+    }
+  }
+  return ans !== Infinity ? ans : 0
+}
+

From f0deeac79a893eab23dd69eeb7866ba28c67bd30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Nov 2020 01:05:02 +0800
Subject: [PATCH 0944/3374] Create
 1059-all-paths-from-source-lead-to-destination.js

---
 ...l-paths-from-source-lead-to-destination.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1059-all-paths-from-source-lead-to-destination.js

diff --git a/1059-all-paths-from-source-lead-to-destination.js b/1059-all-paths-from-source-lead-to-destination.js
new file mode 100644
index 00000000..46512113
--- /dev/null
+++ b/1059-all-paths-from-source-lead-to-destination.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} source
+ * @param {number} destination
+ * @return {boolean}
+ */
+const leadsToDestination = function(n, edges, source, destination) {
+  const inm = new Map(), outm = new Map()
+  for(let k = 0, len = edges.length; k < len; k++) {
+    const [o, i] = edges[k]
+    if(!inm.has(i)) inm.set(i, new Set())
+    if(!outm.has(o)) outm.set(o, new Set())
+    inm.get(i).add(o)
+    outm.get(o).add(i)
+  }
+  const visited = new Set()
+  const obj = { res: true }
+  dfs(source)
+  return obj.res
+  function dfs(node) {
+    if((outm.get(node) == null || outm.get(node).size === 0) && node !== destination) {
+      obj.res = false
+      return
+    }
+    if(visited.has(node)) {
+      obj.res = false
+      return
+    }
+    if(outm.get(node) == null) return
+    visited.add(node)
+    for(let e of outm.get(node)) {
+      if(obj.res) dfs(e)
+    }
+    visited.delete(node)
+  }
+};

From 3742f8bec5c8319bc8bdaa952f17a0ebfcc24d78 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Nov 2020 12:58:20 +0800
Subject: [PATCH 0945/3374] Create
 1662-check-if-two-string-arrays-are-equivalent.js

---
 1662-check-if-two-string-arrays-are-equivalent.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 1662-check-if-two-string-arrays-are-equivalent.js

diff --git a/1662-check-if-two-string-arrays-are-equivalent.js b/1662-check-if-two-string-arrays-are-equivalent.js
new file mode 100644
index 00000000..a551d68c
--- /dev/null
+++ b/1662-check-if-two-string-arrays-are-equivalent.js
@@ -0,0 +1,8 @@
+/**
+ * @param {string[]} word1
+ * @param {string[]} word2
+ * @return {boolean}
+ */
+const arrayStringsAreEqual = function(word1, word2) {
+  return word1.join('') === word2.join('')
+};

From 8aeb042d85990fcd5ab9c124165327ac4e954f93 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Nov 2020 12:58:49 +0800
Subject: [PATCH 0946/3374] Create
 1663-smallest-string-with-a-given-numeric-value.js

---
 ...llest-string-with-a-given-numeric-value.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1663-smallest-string-with-a-given-numeric-value.js

diff --git a/1663-smallest-string-with-a-given-numeric-value.js b/1663-smallest-string-with-a-given-numeric-value.js
new file mode 100644
index 00000000..a651ac6a
--- /dev/null
+++ b/1663-smallest-string-with-a-given-numeric-value.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getSmallestString = function(n, k) {
+  let arr = Array(n).fill(1)
+  k -= n 
+  for(let i = n - 1; i >= 0; i--) {
+    if(k > 0) {
+      const delta = 26 - arr[i]
+      if(k >= delta) {
+        k -= delta
+        arr[i] = arr[i] + delta
+      } else {
+        arr[i] = arr[i] + k
+        k = 0
+      }
+    } else break
+  }
+  const str = 'abcdefghijklmnopqrstuvwxyz'
+  const m = {}
+  for(let i = 0; i < 26; i++) {
+    m[i + 1] = str[i]
+  }
+  const res = []
+  for(let i = 0; i < n; i++) {
+    res[i] = m[arr[i]]
+  }
+  return res.join('')
+};

From 42d2d63b69b5d0fca6d80ebf89e88495afcf1315 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Nov 2020 12:59:34 +0800
Subject: [PATCH 0947/3374] Create 1664-ways-to-make-a-fair-array.js

---
 1664-ways-to-make-a-fair-array.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1664-ways-to-make-a-fair-array.js

diff --git a/1664-ways-to-make-a-fair-array.js b/1664-ways-to-make-a-fair-array.js
new file mode 100644
index 00000000..2651c597
--- /dev/null
+++ b/1664-ways-to-make-a-fair-array.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const waysToMakeFair = function (nums) {
+  const n = nums.length
+  const preOddSum = new Array(n + 1).fill(0)
+  const preEvenSum = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    if (i % 2 === 0) {
+      preEvenSum[i + 1] = nums[i] + preEvenSum[i]
+      preOddSum[i + 1] = preOddSum[i]
+    } else {
+      preOddSum[i + 1] = nums[i] + preOddSum[i]
+      preEvenSum[i + 1] = preEvenSum[i]
+    }
+  }
+  let ret = 0
+  for (let i = 0; i < n; i++) {
+    if (
+      preEvenSum[i] + preOddSum[n] - preOddSum[i + 1] ===
+      preOddSum[i] + preEvenSum[n] - preEvenSum[i + 1]
+    )
+      ret++
+  }
+  return ret
+}

From 54760c540246bbbef5d20314eeb0b931564ef2ac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Nov 2020 13:00:07 +0800
Subject: [PATCH 0948/3374] Create
 1665-minimum-initial-energy-to-finish-tasks.js

---
 ...-minimum-initial-energy-to-finish-tasks.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1665-minimum-initial-energy-to-finish-tasks.js

diff --git a/1665-minimum-initial-energy-to-finish-tasks.js b/1665-minimum-initial-energy-to-finish-tasks.js
new file mode 100644
index 00000000..55cb07b8
--- /dev/null
+++ b/1665-minimum-initial-energy-to-finish-tasks.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number}
+ */
+const minimumEffort = function (a) {
+  let low = 0,
+    high = 1e9
+  for (let x of a) low = Math.max(low, x[1])
+  a.sort((lhs, rhs) => (lhs[1] - lhs[0] > rhs[1] - rhs[0] ? -1 : 1))
+  let n = a.length
+  while (low != high) {
+    let mid = low + ((high - low) >> 1)
+    let found = false
+    let rem = mid
+    for (let i = 0; i < n; ++i) {
+      if (rem < a[i][1]) {
+        found = true
+        break
+      }
+      rem -= a[i][0]
+    }
+    if (found) {
+      low = mid + 1
+    } else {
+      high = mid
+    }
+  }
+  return high
+}

From 8642961646cfd3bb3f7634d0e72fac983ff3f98f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Nov 2020 13:40:57 +0800
Subject: [PATCH 0949/3374] Update
 1665-minimum-initial-energy-to-finish-tasks.js

---
 1665-minimum-initial-energy-to-finish-tasks.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1665-minimum-initial-energy-to-finish-tasks.js b/1665-minimum-initial-energy-to-finish-tasks.js
index 55cb07b8..31746fc0 100644
--- a/1665-minimum-initial-energy-to-finish-tasks.js
+++ b/1665-minimum-initial-energy-to-finish-tasks.js
@@ -1,3 +1,18 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number}
+ */
+const minimumEffort = function (tasks) {
+  tasks.sort((a, b) => a[1] - a[0] > b[1] - b[0] ? 1 : -1)
+  let res = 0
+  for(let e of tasks) {
+    res = Math.max(res + e[0], e[1])
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number[][]} tasks
  * @return {number}

From 07ae498fa65cb1c18774034cb166e17bc55d24cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Nov 2020 11:12:12 +0800
Subject: [PATCH 0950/3374] Create 1661-average-time-of-process-per-machine.sql

---
 1661-average-time-of-process-per-machine.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 1661-average-time-of-process-per-machine.sql

diff --git a/1661-average-time-of-process-per-machine.sql b/1661-average-time-of-process-per-machine.sql
new file mode 100644
index 00000000..f1d3a735
--- /dev/null
+++ b/1661-average-time-of-process-per-machine.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT s.machine_id, ROUND(AVG(e.timestamp-s.timestamp), 3) AS processing_time
+FROM Activity s JOIN Activity e ON
+    s.machine_id = e.machine_id AND s.process_id = e.process_id AND
+    s.activity_type = 'start' AND e.activity_type = 'end'
+GROUP BY s.machine_id;

From 4f8655fd587adf3aadfe5bc2f2eab89c477cdad4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Nov 2020 20:18:33 +0800
Subject: [PATCH 0951/3374] Create 1660-correct-a-binary-tree.js

---
 1660-correct-a-binary-tree.js | 46 +++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1660-correct-a-binary-tree.js

diff --git a/1660-correct-a-binary-tree.js b/1660-correct-a-binary-tree.js
new file mode 100644
index 00000000..3b03b468
--- /dev/null
+++ b/1660-correct-a-binary-tree.js
@@ -0,0 +1,46 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} from
+ * @param {number} to
+ * @return {TreeNode}
+ */
+const correctBinaryTree = function(root) {
+  let q = [root]
+  let target
+  while(q.length) {
+    const size = q.length
+    const next = new Set()
+    const row = new Set()
+    for(let i = 0; i < size; i++) {
+      const cur = q.shift()
+      row.add(cur)
+      if(cur.left) next.add(cur.left)
+      if(cur.right) next.add(cur.right)
+    }
+    for(let e of next) {
+      if(next.has(e.right)) {
+        target = e
+        for(let el of row) {
+          if(el.left && el.left === target) {
+            el.left = null
+            return root
+          }
+          if(el.right && el.right === target) {
+            el.right = null
+            return root
+          }
+        }
+      }
+    }
+    q = Array.from(next)
+  }
+  return root
+};

From 4604a53b4d32d5683c057f153e1729a79b3327e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Nov 2020 20:32:12 +0800
Subject: [PATCH 0952/3374] Update 1660-correct-a-binary-tree.js

---
 1660-correct-a-binary-tree.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1660-correct-a-binary-tree.js b/1660-correct-a-binary-tree.js
index 3b03b468..9c940f94 100644
--- a/1660-correct-a-binary-tree.js
+++ b/1660-correct-a-binary-tree.js
@@ -1,3 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} from
+ * @param {number} to
+ * @return {TreeNode}
+ */
+const correctBinaryTree = (root, seen = new Set(), found = false) => {
+  const go = (root) => {
+    seen.add(root)
+    if (root.right && seen.has(root.right)) {
+      found = true
+      return null
+    }
+    if (!found && root.right) root.right = go(root.right)
+    if (!found && root.left) root.left = go(root.left)
+    return root
+  }
+  return go(root)
+}
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val, left, right) {

From 56d70efcfdeab200110dae467a12bd96f1a8a81b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Nov 2020 20:54:41 +0800
Subject: [PATCH 0953/3374] Create
 1653-minimum-deletions-to-make-string-balanced.js

---
 ...inimum-deletions-to-make-string-balanced.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1653-minimum-deletions-to-make-string-balanced.js

diff --git a/1653-minimum-deletions-to-make-string-balanced.js b/1653-minimum-deletions-to-make-string-balanced.js
new file mode 100644
index 00000000..47fb9a4f
--- /dev/null
+++ b/1653-minimum-deletions-to-make-string-balanced.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumDeletions = function(s) {
+  const len = s.length
+  const stack = []
+  let res = 0
+  for(let i = 0; i < len; i++) {
+    if(stack.length && stack[stack.length - 1] > s[i]) {
+      res++
+      stack.pop()
+    } else {
+      stack.push(s[i])
+    }
+  }
+  return res
+};

From 128ef69aca768495c739c302454c566b24e7d09f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Nov 2020 22:05:46 +0800
Subject: [PATCH 0954/3374] Update
 1653-minimum-deletions-to-make-string-balanced.js

---
 ...nimum-deletions-to-make-string-balanced.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1653-minimum-deletions-to-make-string-balanced.js b/1653-minimum-deletions-to-make-string-balanced.js
index 47fb9a4f..edae94cb 100644
--- a/1653-minimum-deletions-to-make-string-balanced.js
+++ b/1653-minimum-deletions-to-make-string-balanced.js
@@ -1,3 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumDeletions = function(s) {
+  const len = s.length
+  const dp = Array(len + 1).fill(0)
+  let bcount = 0
+  for(let i = 1; i <= len; i++) {
+    if(s[i - 1] === 'a') {
+      dp[i] = Math.min(dp[i - 1] + 1, bcount)
+    } else {
+      dp[i] = dp[i - 1]
+      bcount++
+    }
+  }
+  
+  return dp[len]
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From aea3e0edc1a285f78ef43a4174da2dc811911d63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Nov 2020 10:16:52 +0800
Subject: [PATCH 0955/3374] Create 1262-greatest-sum-divisible-by-three.js

---
 1262-greatest-sum-divisible-by-three.js | 30 +++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1262-greatest-sum-divisible-by-three.js

diff --git a/1262-greatest-sum-divisible-by-three.js b/1262-greatest-sum-divisible-by-three.js
new file mode 100644
index 00000000..7536b833
--- /dev/null
+++ b/1262-greatest-sum-divisible-by-three.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumDivThree = function(nums) {
+  const sum = nums.reduce((ac, el) => ac + el, 0)
+  if(sum % 3 === 0) return sum
+  const remainder = sum % 3
+  const comp = 3 - remainder
+  nums.sort((a, b) => a - b)
+  const re = [], rc = []
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(nums[i] % 3 === remainder) {
+      if(re.length < 1) re.push(i)
+    }
+    if(nums[i] % 3 === comp) {
+      if(rc.length < 2) rc.push(i)
+    }
+    if(re.length === 1 && rc.length === 2) break
+  }
+  if(re.length === 1 && rc.length === 2) {
+    return Math.max(sum - nums[re[0]], sum - nums[rc[0]] - nums[rc[1]])
+  } else if(re.length === 1) {
+    return sum - nums[re[0]]
+  } else if(rc.length === 2) {
+    return sum - nums[rc[0]] - nums[rc[1]]
+  } else {
+    return 0
+  }
+};

From 1fd909941da776bb3a63261cd27a6173927b207f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Nov 2020 10:25:38 +0800
Subject: [PATCH 0956/3374] Update 1262-greatest-sum-divisible-by-three.js

---
 1262-greatest-sum-divisible-by-three.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1262-greatest-sum-divisible-by-three.js b/1262-greatest-sum-divisible-by-three.js
index 7536b833..fac1d5c9 100644
--- a/1262-greatest-sum-divisible-by-three.js
+++ b/1262-greatest-sum-divisible-by-three.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumDivThree = function (nums) {
+  const n = nums.length
+  let dp = [0, -Infinity, -Infinity]
+  for (let i = n - 1; i >= 0; i--) {
+    const nextDp = []
+    for (let j = 0; j < 3; j++) {
+      const nextRemain = nums[i] % 3
+      nextDp[j] = Math.max(nums[i] + dp[(nextRemain + j) % 3], dp[j])
+    }
+    dp = nextDp
+  }
+  return dp[0]
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 7d93443f2c82368b543e9037cdd876f26de9ccf4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Nov 2020 21:52:00 +0800
Subject: [PATCH 0957/3374] Create 1652-defuse-the-bomb.js

---
 1652-defuse-the-bomb.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1652-defuse-the-bomb.js

diff --git a/1652-defuse-the-bomb.js b/1652-defuse-the-bomb.js
new file mode 100644
index 00000000..2435e9cc
--- /dev/null
+++ b/1652-defuse-the-bomb.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} code
+ * @param {number} k
+ * @return {number[]}
+ */
+const decrypt = function(code, k) {
+  const res = new Array(code.length).fill(0);
+  if (k === 0) return res;
+  let start = 1, end = k, sum = 0;
+  if (k < 0) {
+    k = -k;
+    start = code.length - k;
+    end = code.length - 1;
+  }
+  for (let i = start; i <= end; i++) sum += code[i];
+  for (let i = 0; i < code.length; i++) {
+    res[i] = sum;
+    sum -= code[(start++) % code.length];
+    sum += code[(++end) % code.length];
+  }
+  return res;
+};

From 44bb3bac017b37e2e012092f06a4c28ae7ea2fc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Nov 2020 20:09:09 +0800
Subject: [PATCH 0958/3374] Create 1666-change-the-root-of-a-binary-tree.js

---
 1666-change-the-root-of-a-binary-tree.js | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1666-change-the-root-of-a-binary-tree.js

diff --git a/1666-change-the-root-of-a-binary-tree.js b/1666-change-the-root-of-a-binary-tree.js
new file mode 100644
index 00000000..df2981f7
--- /dev/null
+++ b/1666-change-the-root-of-a-binary-tree.js
@@ -0,0 +1,33 @@
+/**
+ * // Definition for a Node.
+ * function Node(val) {
+ *    this.val = val;
+ *    this.left = null;
+ *    this.right = null;
+ *    this.parent = null;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+const flipBinaryTree = function(root, leaf) {
+  function flip(node, from_node){
+    // set and break pointers between node and from_node
+    const p = node.parent
+    node.parent = from_node
+    if (node.left === from_node) node.left = null
+    if (node.right === from_node) node.right = null
+
+    // stopping condition
+    if (node === root) return node
+
+    // set right child
+    if (node.left) node.right = node.left
+    // set left child
+    node.left = flip(p, node)
+    return node
+  }
+  return flip(leaf, null)
+};

From 7365ceb18f849120ddecaea4dc23cd14f13dd350 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Nov 2020 21:37:21 +0800
Subject: [PATCH 0959/3374] Create 779-k-th-symbol-in-grammar.js

---
 779-k-th-symbol-in-grammar.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 779-k-th-symbol-in-grammar.js

diff --git a/779-k-th-symbol-in-grammar.js b/779-k-th-symbol-in-grammar.js
new file mode 100644
index 00000000..1089ce59
--- /dev/null
+++ b/779-k-th-symbol-in-grammar.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number} N
+ * @param {number} K
+ * @return {number}
+ */
+const kthGrammar = function(N, K) {
+	if (N === 1) return 0;
+	if (K % 2 === 0) return (kthGrammar(N - 1, K / 2) === 0) ? 1 : 0;
+	else return (kthGrammar(N - 1, (K + 1) / 2) === 0) ? 0 : 1;
+};

From 236397badff524d8faaa81ae66925e6c4aa44433 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Nov 2020 21:46:12 +0800
Subject: [PATCH 0960/3374] Update 779-k-th-symbol-in-grammar.js

---
 779-k-th-symbol-in-grammar.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/779-k-th-symbol-in-grammar.js b/779-k-th-symbol-in-grammar.js
index 1089ce59..edb30029 100644
--- a/779-k-th-symbol-in-grammar.js
+++ b/779-k-th-symbol-in-grammar.js
@@ -8,3 +8,17 @@ const kthGrammar = function(N, K) {
 	if (K % 2 === 0) return (kthGrammar(N - 1, K / 2) === 0) ? 1 : 0;
 	else return (kthGrammar(N - 1, (K + 1) / 2) === 0) ? 0 : 1;
 };
+
+/**
+
+// think of the problem like this
+/*        0
+      /       \
+     0          1
+   /   \      /    \
+   0     1    1      0
+ / \     / \   / \   / \
+ 0  1   1   0  1  0  0  1
+*/
+
+*/

From 9676d29106c29bcf15ad1a549a8dae42f4bc6230 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Nov 2020 09:46:10 +0800
Subject: [PATCH 0961/3374] Create 1352-product-of-the-last-k-numbers.js

---
 1352-product-of-the-last-k-numbers.js | 39 +++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1352-product-of-the-last-k-numbers.js

diff --git a/1352-product-of-the-last-k-numbers.js b/1352-product-of-the-last-k-numbers.js
new file mode 100644
index 00000000..8d8b69e8
--- /dev/null
+++ b/1352-product-of-the-last-k-numbers.js
@@ -0,0 +1,39 @@
+/*
+ * @lc app=leetcode id=1352 lang=javascript
+ *
+ * [1352] Product of the Last K Numbers
+ */
+
+// @lc code=start
+
+const ProductOfNumbers = function() {
+  this.sum = [1]
+};
+
+/** 
+ * @param {number} num
+ * @return {void}
+ */
+ProductOfNumbers.prototype.add = function(num) {
+  if(num > 0) {
+    this.sum.push(this.sum[this.sum.length - 1] * num)
+  } else {
+    this.sum = [1]
+  }
+};
+
+/** 
+ * @param {number} k
+ * @return {number}
+ */
+ProductOfNumbers.prototype.getProduct = function(k) {
+  const len = this.sum.length
+  return k < len ? this.sum[len - 1] / this.sum[len - 1 - k] : 0
+};
+
+/** 
+ * Your ProductOfNumbers object will be instantiated and called as such:
+ * var obj = new ProductOfNumbers()
+ * obj.add(num)
+ * var param_2 = obj.getProduct(k)
+ */

From c5007c565af76bb5bdea22fc8070246c662c152d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Nov 2020 16:23:16 +0800
Subject: [PATCH 0962/3374] Create 1667-fix-names-in-a-table.sql

---
 1667-fix-names-in-a-table.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 1667-fix-names-in-a-table.sql

diff --git a/1667-fix-names-in-a-table.sql b/1667-fix-names-in-a-table.sql
new file mode 100644
index 00000000..82902899
--- /dev/null
+++ b/1667-fix-names-in-a-table.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT 
+user_id,
+concat(upper(substr(name,1,1)),lower(substr(name,2))) as name
+FROM Activity
+ORDER BY 1 ASC;

From ccadd91bd2e9a9da6f32892c9e61afa766ddf059 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 00:39:20 +0800
Subject: [PATCH 0963/3374] Update
 1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js

---
 ...number-of-flips-to-convert-binary-matrix-to-zero-matrix.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
index 28574517..52f950e6 100644
--- a/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
+++ b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
@@ -38,9 +38,7 @@ const minFlips = function (mat) {
       mask.push(bit)
     }
   }
-  if (state === 0) {
-    return 0
-  }
+  if (state === 0) return 0
   const set = new Set()
   const q = [{ state: state, moves: 0 }]
   while (q.length !== 0) {

From 39cbdd26148d6e0e06e002748b14b3160d5bbcfb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 17:04:56 +0800
Subject: [PATCH 0964/3374] Create 1672-richest-customer-wealth.js

---
 1672-richest-customer-wealth.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1672-richest-customer-wealth.js

diff --git a/1672-richest-customer-wealth.js b/1672-richest-customer-wealth.js
new file mode 100644
index 00000000..931ed126
--- /dev/null
+++ b/1672-richest-customer-wealth.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} accounts
+ * @return {number}
+ */
+const maximumWealth = function(accounts) {
+  let max = -Infinity
+  const m = accounts.length, n = accounts[0].length
+  for(let i = 0; i < m; i++) {
+    let tmp = 0
+    for(let j = 0; j < n; j++) {
+      tmp += accounts[i][j]
+    }
+    max = Math.max(max, tmp)
+  }
+  return max
+};

From 4e1ff76edfbdca1f6947fe1eef695345ec51c96d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 17:05:28 +0800
Subject: [PATCH 0965/3374] Create
 1673-find-the-most-competitive-subsequence.js

---
 1673-find-the-most-competitive-subsequence.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1673-find-the-most-competitive-subsequence.js

diff --git a/1673-find-the-most-competitive-subsequence.js b/1673-find-the-most-competitive-subsequence.js
new file mode 100644
index 00000000..d8b9a55a
--- /dev/null
+++ b/1673-find-the-most-competitive-subsequence.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const mostCompetitive = function (nums, k) {
+  const res = new Array(k).fill(0)
+  let start = -1
+  let idx = 0
+  for (let i = k; i > 0; i--) {
+    let min = Number.MAX_VALUE
+    for (let j = start + 1; j < nums.length - i + 1; j++) {
+      if (nums[j] < min) {
+        start = j
+        min = nums[j]
+      }
+    }
+    res[idx++] = min
+  }
+  return res
+}

From 22d21c85c1e7d5a47e975fc194bc35d9f4c171f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 17:06:05 +0800
Subject: [PATCH 0966/3374] Create
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1674-minimum-moves-to-make-array-complementary.js

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
new file mode 100644
index 00000000..99f147c9
--- /dev/null
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const minMoves = function(nums, limit) {
+    const min = Math.min, max = Math.max
+    const n = nums.length;
+    const delta = Array(limit * 2 + 2).fill(0);
+    for (let i = 0; i < n / 2; ++i) {
+        let lo = 1 + min(nums[i], nums[n - i - 1]);
+        let hi = limit + max(nums[i], nums[n - i - 1]);
+        let sum = nums[i] + nums[n - i - 1];
+        delta[lo]--;
+        delta[sum]--;
+        delta[sum + 1]++;
+        delta[hi + 1]++;
+    }
+    let now = n;
+    let ans = n;
+    for (let i = 2; i <= limit * 2; ++i) {
+        now += delta[i];
+        ans = min(ans, now);
+    }
+    return ans;  
+};
+
+
+

From 63df0040669e45738aa988f8e9d16d9054ade7bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 17:06:40 +0800
Subject: [PATCH 0967/3374] Create 1675-minimize-deviation-in-array.js

---
 1675-minimize-deviation-in-array.js | 91 +++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 1675-minimize-deviation-in-array.js

diff --git a/1675-minimize-deviation-in-array.js b/1675-minimize-deviation-in-array.js
new file mode 100644
index 00000000..4d2821fe
--- /dev/null
+++ b/1675-minimize-deviation-in-array.js
@@ -0,0 +1,91 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumDeviation = function (A) {
+  const pq = new PriorityQueue()
+  let n = A.length,
+    mi = Number.MAX_VALUE,
+    res = Number.MAX_VALUE
+  for (let a of A) {
+    if (a % 2 === 1) a *= 2
+    pq.push(-a)
+    mi = Math.min(mi, a)
+  }
+  while (true) {
+    let a = -pq.pop()
+    res = Math.min(res, a - mi)
+    if (a % 2 === 1) break
+    mi = Math.min(mi, a / 2)
+    pq.push(-a / 2)
+  }
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a < b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 9822c9e73687322125d55ab6749ef946cf652cd0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Nov 2020 18:04:34 +0800
Subject: [PATCH 0968/3374] Create 1670-design-front-middle-back-queue.js

---
 1670-design-front-middle-back-queue.js | 68 ++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 1670-design-front-middle-back-queue.js

diff --git a/1670-design-front-middle-back-queue.js b/1670-design-front-middle-back-queue.js
new file mode 100644
index 00000000..05d29b66
--- /dev/null
+++ b/1670-design-front-middle-back-queue.js
@@ -0,0 +1,68 @@
+
+const FrontMiddleBackQueue = function() {
+  this.arr = []
+};
+
+/** 
+ * @param {number} val
+ * @return {void}
+ */
+FrontMiddleBackQueue.prototype.pushFront = function(val) {
+  this.arr.unshift(val)
+};
+
+/** 
+ * @param {number} val
+ * @return {void}
+ */
+FrontMiddleBackQueue.prototype.pushMiddle = function(val) {
+  const len = this.arr.length
+  const mid = Math.floor(len / 2)
+  this.arr.splice(mid, 0, val)
+};
+
+/** 
+ * @param {number} val
+ * @return {void}
+ */
+FrontMiddleBackQueue.prototype.pushBack = function(val) {
+  this.arr.push(val)
+};
+
+/**
+ * @return {number}
+ */
+FrontMiddleBackQueue.prototype.popFront = function() {
+  const tmp = this.arr.shift()
+  return tmp == null ? -1 : tmp
+};
+
+/**
+ * @return {number}
+ */
+FrontMiddleBackQueue.prototype.popMiddle = function() {
+  const len = this.arr.length
+  const mid = len % 2 === 0 ? Math.floor(len / 2) - 1 : ((len / 2) >> 0)
+  if(len === 2) return this.arr.shift()
+  const [tmp] = this.arr.splice(mid, 1)
+  return tmp == null ? -1 : tmp
+};
+
+/**
+ * @return {number}
+ */
+FrontMiddleBackQueue.prototype.popBack = function() {
+  const tmp = this.arr.pop()
+  return tmp == null ? -1 : tmp
+};
+
+/** 
+ * Your FrontMiddleBackQueue object will be instantiated and called as such:
+ * var obj = new FrontMiddleBackQueue()
+ * obj.pushFront(val)
+ * obj.pushMiddle(val)
+ * obj.pushBack(val)
+ * var param_4 = obj.popFront()
+ * var param_5 = obj.popMiddle()
+ * var param_6 = obj.popBack()
+ */

From 11325028c1a684d80b8a7a9472bf5434248c0f45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Nov 2020 19:52:09 +0800
Subject: [PATCH 0969/3374] Create
 1671-minimum-number-of-removals-to-make-mountain-array.js

---
 ...mber-of-removals-to-make-mountain-array.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1671-minimum-number-of-removals-to-make-mountain-array.js

diff --git a/1671-minimum-number-of-removals-to-make-mountain-array.js b/1671-minimum-number-of-removals-to-make-mountain-array.js
new file mode 100644
index 00000000..350df2e6
--- /dev/null
+++ b/1671-minimum-number-of-removals-to-make-mountain-array.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumMountainRemovals = function (nums) {
+  if (nums.length <= 3) return 0
+  const n = nums.length
+  const inc = Array(n).fill(0)
+  const dec = Array(n).fill(0)
+  const { max, min } = Math
+  for (let i = 1; i < n; i++) {
+    for (let j = 0; j < i; j++) {
+      if (nums[i] > nums[j]) inc[i] = max(inc[i], inc[j] + 1)
+    }
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    for (let j = n - 1; j > i; j--) {
+      if (nums[i] > nums[j]) dec[i] = max(dec[i], dec[j] + 1)
+    }
+  }
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    if (inc[i] > 0 && dec[i] > 0) res = max(res, inc[i] + dec[i])
+  }
+  return n - res - 1
+}

From 284d8c0fadfb9e1e0331bea87720f013497ada58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Nov 2020 21:20:32 +0800
Subject: [PATCH 0970/3374] Update 300-longest-increasing-subsequence.js

---
 300-longest-increasing-subsequence.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/300-longest-increasing-subsequence.js b/300-longest-increasing-subsequence.js
index fa2d287b..0a073c1d 100644
--- a/300-longest-increasing-subsequence.js
+++ b/300-longest-increasing-subsequence.js
@@ -22,3 +22,25 @@ const lengthOfLIS = function(nums) {
     return maxans
 };
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const lengthOfLIS = function(nums) {
+  const n = nums.length
+  const tails = []
+  let res = 0
+  for(let e of nums) {
+    let i = 0, j = res
+    while(i !== j) {
+      const mid = (i + j) >> 1
+      if(tails[mid] < e) i = mid + 1
+      else j = mid
+    }
+    tails[i] = e
+    if(i === res) res++
+  }
+  return res
+};

From 06ecda3b99bb15a9fd350f7698c0e746a222a1df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Dec 2020 20:02:33 +0800
Subject: [PATCH 0971/3374] Create 1668-maximum-repeating-substring.js

---
 1668-maximum-repeating-substring.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1668-maximum-repeating-substring.js

diff --git a/1668-maximum-repeating-substring.js b/1668-maximum-repeating-substring.js
new file mode 100644
index 00000000..353a78c6
--- /dev/null
+++ b/1668-maximum-repeating-substring.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} sequence
+ * @param {string} word
+ * @return {number}
+ */
+const maxRepeating = function(sequence, word) {
+  let count = 1;
+  while (sequence.includes(word.repeat(count))) count += 1
+  return count - 1;
+};

From 3d0f262988fb1589e3b1000d191dc0091037a539 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Dec 2020 20:56:35 +0800
Subject: [PATCH 0972/3374] Update 1668-maximum-repeating-substring.js

---
 1668-maximum-repeating-substring.js | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1668-maximum-repeating-substring.js b/1668-maximum-repeating-substring.js
index 353a78c6..87467df4 100644
--- a/1668-maximum-repeating-substring.js
+++ b/1668-maximum-repeating-substring.js
@@ -8,3 +8,33 @@ const maxRepeating = function(sequence, word) {
   while (sequence.includes(word.repeat(count))) count += 1
   return count - 1;
 };
+
+// another
+
+/**
+ * @param {string} sequence
+ * @param {string} word
+ * @return {number}
+ */
+const maxRepeating = function(sequence, word) {
+  const s = sequence.length, w = word.length
+  const max_repeat = (s / w) >> 0
+  const failure = Array(w * max_repeat + 1).fill(0)
+  const repeat_words = word.repeat(max_repeat) + '$'
+  let result = 0, j = 0
+  
+  for(let i = 1, hi = repeat_words.length; i < hi; i++) {
+    while(j > 0 && repeat_words[j] !== repeat_words[i]) j = failure[j - 1]
+    j += (repeat_words[j] === repeat_words[i] ? 1 : 0)
+    failure[i] = j
+  }
+
+  j = 0
+  for(let i = 0, len = sequence.length; i < len; i++) {
+    while(j > 0 && repeat_words[j] !== sequence[i]) j = failure[j - 1]
+    j += (repeat_words[j] === sequence[i] ? 1 : 0)
+    result = Math.max(result, (j / w) >> 0)
+  }
+  return result
+};
+

From 0af71ad2b506e2709660c206bc945d396cceb58f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Dec 2020 19:59:21 +0800
Subject: [PATCH 0973/3374] Update 402-remove-k-digits.js

---
 402-remove-k-digits.js | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/402-remove-k-digits.js b/402-remove-k-digits.js
index da276cd8..ea693f3b 100644
--- a/402-remove-k-digits.js
+++ b/402-remove-k-digits.js
@@ -34,25 +34,17 @@ const removeKdigits = function(num, k) {
  * @return {string}
  */
 const removeKdigits = function(num, k) {
-  const len = num.length
-  if(k === len) return '0'
-  const stack = []
+  const n = num.length, stack = []
+  if(n === k) return '0'
   let i = 0
-  while(i < len) {
+  while(i < n) {
     while(k > 0 && stack.length && stack[stack.length - 1] > num[i]) {
-      stack.pop()
       k--
+      stack.pop()
     }
-    stack.push(num[i])
-    i++
-  }
-  while(k > 0) {
-    stack.pop()
-    k--
+    stack.push(num[i++])
   }
-  let res = ''
-  while(stack.length) res += stack.pop()
-  res = res.split('').reverse()
-  while(res.length > 1 && res[0] === '0') res.shift()
-  return res.join('')
+  while(k-- > 0) stack.pop()
+  while(stack[0] === '0') stack.shift()
+  return stack.length ? stack.join('') : '0'
 };

From 903b392b7e01a6b9148d74b05f0e53f10c11820b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Dec 2020 20:13:12 +0800
Subject: [PATCH 0974/3374] Update
 1673-find-the-most-competitive-subsequence.js

---
 1673-find-the-most-competitive-subsequence.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1673-find-the-most-competitive-subsequence.js b/1673-find-the-most-competitive-subsequence.js
index d8b9a55a..51acc346 100644
--- a/1673-find-the-most-competitive-subsequence.js
+++ b/1673-find-the-most-competitive-subsequence.js
@@ -19,3 +19,27 @@ const mostCompetitive = function (nums, k) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const mostCompetitive = function (nums, k) {
+  const stack = [],
+    n = nums.length
+  let i = 0
+  while (i < n) {
+    while (
+      stack.length &&
+      stack[stack.length - 1] > nums[i] &&
+      n - i + stack.length > k
+    )
+      stack.pop()
+    if (stack.length < k) stack.push(nums[i])
+    i++
+  }
+  return stack
+}

From 262a230ff709d272364913198727c052030a5153 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Dec 2020 09:54:03 +0800
Subject: [PATCH 0975/3374] Update 632-smallest-range.js

---
 632-smallest-range.js | 96 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/632-smallest-range.js b/632-smallest-range.js
index 1083fdd0..16153b17 100644
--- a/632-smallest-range.js
+++ b/632-smallest-range.js
@@ -184,3 +184,99 @@ var smallestRange = function(nums) {
 
   return ans
 }
+
+
+// another
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[][]} nums
+ * @return {number[]}
+ */
+const smallestRange = function (nums) {
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  const limit = 10 ** 5,
+    n = nums.length,
+    { max } = Math
+  let right = -1e5,
+    res = [-limit, limit]
+  for (let i = 0; i < n; i++) {
+    pq.push([nums[i][0], i, 0])
+    right = max(right, nums[i][0])
+  }
+  while (pq.size()) {
+    const cur = pq.pop()
+    const [left, list, indice] = cur
+    if (right - left < res[1] - res[0]) res = [left, right]
+    if (indice + 1 === nums[list].length) return res
+    right = max(right, nums[list][indice + 1])
+    pq.push([nums[list][indice + 1], list, indice + 1])
+  }
+  return []
+}

From 7e3c61cc3e9a10bb8de605b6b70f9c84f389af7e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Dec 2020 20:52:20 +0800
Subject: [PATCH 0976/3374] Create
 1676-lowest-common-ancestor-of-a-binary-tree-iv.js

---
 ...est-common-ancestor-of-a-binary-tree-iv.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1676-lowest-common-ancestor-of-a-binary-tree-iv.js

diff --git a/1676-lowest-common-ancestor-of-a-binary-tree-iv.js b/1676-lowest-common-ancestor-of-a-binary-tree-iv.js
new file mode 100644
index 00000000..f5cb150b
--- /dev/null
+++ b/1676-lowest-common-ancestor-of-a-binary-tree-iv.js
@@ -0,0 +1,22 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode[]} nodes
+ * @return {TreeNode}
+ */
+const lowestCommonAncestor = function(root, nodes) {
+  if (root == null) return root
+  for(let e of nodes) {
+    if(root === e) return root
+  }
+  const left = lowestCommonAncestor(root.left, nodes)
+  const right = lowestCommonAncestor(root.right, nodes)
+  if(left && right) return root
+  return left ? left : right
+};

From 235e1e74ba3e46f793676bb6add80fe7a8f217e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Dec 2020 19:32:19 +0800
Subject: [PATCH 0977/3374] Create 1561-maximum-number-of-coins-you-can-get.js

---
 1561-maximum-number-of-coins-you-can-get.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1561-maximum-number-of-coins-you-can-get.js

diff --git a/1561-maximum-number-of-coins-you-can-get.js b/1561-maximum-number-of-coins-you-can-get.js
new file mode 100644
index 00000000..e7ef135a
--- /dev/null
+++ b/1561-maximum-number-of-coins-you-can-get.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} piles
+ * @return {number}
+ */
+const maxCoins = function(piles) {
+  piles.sort((a, b) => a - b)
+  let coins = 0, n = piles.length
+  for(let j = 0, i = n - 2, hi = Math.floor(n / 3); j < hi; j++, i -= 2) {
+    coins += piles[i]
+  }
+  
+  return coins
+};

From 9a342b1e06e7aeb45436704e190ae22eadeb24fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Dec 2020 17:46:00 +0800
Subject: [PATCH 0978/3374] Update
 659-split-array-into-consecutive-subsequences.js

---
 ...lit-array-into-consecutive-subsequences.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/659-split-array-into-consecutive-subsequences.js b/659-split-array-into-consecutive-subsequences.js
index 2dd9f95d..af5bb0fc 100644
--- a/659-split-array-into-consecutive-subsequences.js
+++ b/659-split-array-into-consecutive-subsequences.js
@@ -26,3 +26,32 @@ const isPossible = function(nums) {
 function getOrDefault(map, key) {
   return map.get(key) || 0
 }
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const isPossible = function(nums) {
+  let prev = -Infinity, p1 = 0, p2 = 0, p3 = 0
+  let i = 0
+  const n = nums.length
+  while (i < n) {
+    let curr = nums[i], c1 = 0, c2 = 0, c3 = 0
+    let cnt = 0
+    while (i < n && nums[i] === curr) { cnt++; i++ }
+    if (curr !== prev+1) {
+      if (p1 > 0 || p2 > 0) { return false }
+      c1 = cnt; c2 = 0; c3 = 0
+    } else {
+      if (cnt < p1 + p2) { return false }
+      c2 = p1
+      c3 = p2 + Math.min(p3, cnt - p1 - p2)
+      c1 = Math.max(0, cnt - p1 - p2 - p3)
+    }
+    prev = curr; p1 = c1; p2 = c2; p3 = c3;
+  }
+  return p1 === 0 && p2 === 0
+};

From a044b61d740e59e54d82d53ff177d3fd262df88a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Dec 2020 23:00:32 +0800
Subject: [PATCH 0979/3374] Create 1678-goal-parser-interpretation.js

---
 1678-goal-parser-interpretation.js | 31 ++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1678-goal-parser-interpretation.js

diff --git a/1678-goal-parser-interpretation.js b/1678-goal-parser-interpretation.js
new file mode 100644
index 00000000..0453d266
--- /dev/null
+++ b/1678-goal-parser-interpretation.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} command
+ * @return {string}
+ */
+const interpret = function(c) {
+  const stack = [c[0]]
+  const n = c.length
+  let i = 1
+  while(i < n) {
+    if(c[i] === ')') {
+      if(stack[stack.length - 1] === '(') {
+        stack.pop()
+        stack.push('o')
+        i++
+      } else {
+        let res = ''
+        while(stack[stack.length - 1] !== '(') {
+          const tmp = stack.pop()
+          res = tmp + res
+        }
+        stack.pop()
+        stack.push(res)
+        i++
+      }
+    } else {
+      stack.push(c[i])
+      i++
+    }
+  }
+  return stack.join('')
+};

From 9c3408e3748d7bd863bcfeadacabea3665b0303a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Dec 2020 23:01:07 +0800
Subject: [PATCH 0980/3374] Create 1679-max-number-of-k-sum-pairs.js

---
 1679-max-number-of-k-sum-pairs.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1679-max-number-of-k-sum-pairs.js

diff --git a/1679-max-number-of-k-sum-pairs.js b/1679-max-number-of-k-sum-pairs.js
new file mode 100644
index 00000000..35cbe7d9
--- /dev/null
+++ b/1679-max-number-of-k-sum-pairs.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxOperations = function(nums, k) {
+   const m = new Map()
+   let res = 0
+   for(let e of nums) {
+     if(!m.has(e)) m.set(e, 0)
+     if(m.has(k - e) && m.get(k - e)) {
+       res++
+       m.set(k - e, m.get(k - e) - 1)
+     } else {
+       m.set(e, m.get(e) + 1)
+     }
+   }
+   return res;
+};

From 9638b9abbaf8a790c623686804ce523296f3efaf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Dec 2020 23:01:37 +0800
Subject: [PATCH 0981/3374] Create
 1680-concatenation-of-consecutive-binary-numbers.js

---
 ...oncatenation-of-consecutive-binary-numbers.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1680-concatenation-of-consecutive-binary-numbers.js

diff --git a/1680-concatenation-of-consecutive-binary-numbers.js b/1680-concatenation-of-consecutive-binary-numbers.js
new file mode 100644
index 00000000..a4ada124
--- /dev/null
+++ b/1680-concatenation-of-consecutive-binary-numbers.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const concatenatedBinary = function(n) {
+  let res = ''
+  const mod = 10 ** 9 + 7
+  for(let i = 1; i <= n; i++) {
+    res += dec2bin(i)
+    res = dec2bin(parseInt(res, 2) % mod)
+  }
+  return parseInt(res, 2) % mod
+};
+function dec2bin(dec){
+  return (dec >>> 0).toString(2);
+}

From d79782c980dfa2483e641df6173e57e4b3e19256 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Dec 2020 20:31:07 +0800
Subject: [PATCH 0982/3374] Update
 1680-concatenation-of-consecutive-binary-numbers.js

---
 ...atenation-of-consecutive-binary-numbers.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/1680-concatenation-of-consecutive-binary-numbers.js b/1680-concatenation-of-consecutive-binary-numbers.js
index a4ada124..c2b7c069 100644
--- a/1680-concatenation-of-consecutive-binary-numbers.js
+++ b/1680-concatenation-of-consecutive-binary-numbers.js
@@ -14,3 +14,22 @@ const concatenatedBinary = function(n) {
 function dec2bin(dec){
   return (dec >>> 0).toString(2);
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const concatenatedBinary = function (n) {
+  const mod = BigInt(1e9 + 7)
+  let res = 0n
+  for (let i = 1n, shift = 0n; i <= n; i++) {
+    let singleBit = (i & (i - 1n)) == 0
+    if (singleBit) shift++
+    res <<= shift
+    res += i
+    res %= mod
+  }
+  return res
+}

From f2c8e664145ae06df8f229248d774b5fc326c6ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Dec 2020 21:17:48 +0800
Subject: [PATCH 0983/3374] Create 1681-minimum-incompatibility.js

---
 1681-minimum-incompatibility.js | 80 +++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 1681-minimum-incompatibility.js

diff --git a/1681-minimum-incompatibility.js b/1681-minimum-incompatibility.js
new file mode 100644
index 00000000..4ec66062
--- /dev/null
+++ b/1681-minimum-incompatibility.js
@@ -0,0 +1,80 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minimumIncompatibility = function (nums, k) {
+  if (nums.length === k) return 0
+  const maxInBucket = nums.length / k
+  const freqCount = {}
+  for (const n of nums) {
+    if (freqCount[n]) {
+      if (freqCount[n] === k) {
+        return -1
+      } else {
+        freqCount[n]++
+      }
+    } else {
+      freqCount[n] = 1
+    }
+  }
+  const cache = {}
+  const allIndiciesUsedMask = 2 ** nums.length - 1
+  const dfs = (usedIndicesBitMask) => {
+    if (usedIndicesBitMask === allIndiciesUsedMask) {
+      return 0
+    }
+    if (cache[usedIndicesBitMask]) {
+      return cache[usedIndicesBitMask]
+    }
+    const valsToIndices = {}
+    for (let i = 0; i < nums.length; i++) {
+      const indexMask = 1 << i
+      if (usedIndicesBitMask & indexMask) continue
+      const value = nums[i]
+      if (!valsToIndices.hasOwnProperty(value)) {
+        valsToIndices[value] = i
+      }
+    }
+    const indicesAvailable = Object.values(valsToIndices)
+    let minIncompatibilityCost = Infinity
+    const combinations = createCombinations(indicesAvailable, maxInBucket)
+    for (const indices of combinations) {
+      let nextMask = usedIndicesBitMask
+      let minVal = Infinity
+      let maxVal = -Infinity
+      for (const index of indices) {
+        minVal = Math.min(minVal, nums[index])
+        maxVal = Math.max(maxVal, nums[index])
+        nextMask = nextMask | (1 << index)
+      }
+      const incompatibilityCost = maxVal - minVal
+      minIncompatibilityCost = Math.min(
+        minIncompatibilityCost,
+        dfs(nextMask) + incompatibilityCost
+      )
+    }
+    return (cache[usedIndicesBitMask] = minIncompatibilityCost)
+  }
+  return dfs(0)
+}
+
+function createCombinations(indices, len) {
+  const combinations = []
+  if (indices.length < len) {
+    return combinations
+  }
+  const stack = [[[], 0]]
+  while (stack.length > 0) {
+    let [combi, i] = stack.pop()
+    for (; i < indices.length; i++) {
+      const combination = [...combi, indices[i]]
+      if (combination.length === len) {
+        combinations.push(combination)
+      } else {
+        stack.push([combination, i + 1])
+      }
+    }
+  }
+  return combinations
+}

From 6fc5dadd70a47940b0af8cc4799fdc2b2487fd37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Dec 2020 21:00:17 +0800
Subject: [PATCH 0984/3374] Update 1681-minimum-incompatibility.js

---
 1681-minimum-incompatibility.js | 56 +++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/1681-minimum-incompatibility.js b/1681-minimum-incompatibility.js
index 4ec66062..eb5a21a8 100644
--- a/1681-minimum-incompatibility.js
+++ b/1681-minimum-incompatibility.js
@@ -1,3 +1,59 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minimumIncompatibility = function (nums, k) {
+  if (k === nums.length) {
+    return 0
+  }
+  const counts = Array(nums.length + 1).fill(0)
+  for (let num of nums) {
+    counts[num]++
+    if (counts[num] > k) {
+      return -1
+    }
+  }
+  const size = nums.length / k
+  let ans = Number.MAX_VALUE
+  const backtracking = (groupIdx, index, sum, lowIndex, curIndex) => {
+    if (index === size) {
+      sum += curIndex - lowIndex
+      if (sum > ans) {
+        return
+      }
+      if (groupIdx === k - 1) {
+        ans = sum
+        return
+      } else {
+        groupIdx++
+        index = 0
+      }
+    }
+    if (index === 0) {
+      for (let i = 0; i < counts.length; i++) {
+        if (counts[i]) {
+          counts[i]--
+          backtracking(groupIdx, index + 1, sum, i, i)
+          counts[i]++
+        }
+      }
+    } else {
+      for (let i = curIndex + 1; i < counts.length; i++) {
+        if (counts[i]) {
+          counts[i]--
+          backtracking(groupIdx, index + 1, sum, lowIndex, i)
+          counts[i]++
+        }
+      }
+    }
+  }
+  backtracking(0, 0, 0, 0, 0)
+  return ans
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From e8be0f55acc15d49f440f80400543d622451f670 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Dec 2020 19:50:08 +0800
Subject: [PATCH 0985/3374] Update
 1593-split-a-string-into-the-max-number-of-unique-substrings.js

---
 ...nto-the-max-number-of-unique-substrings.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1593-split-a-string-into-the-max-number-of-unique-substrings.js b/1593-split-a-string-into-the-max-number-of-unique-substrings.js
index 3d9ca78a..cfd06a65 100644
--- a/1593-split-a-string-into-the-max-number-of-unique-substrings.js
+++ b/1593-split-a-string-into-the-max-number-of-unique-substrings.js
@@ -19,3 +19,33 @@ function bt(str, cur, idx, useds) {
     return ans
   }
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxUniqueSplit = function (s) {
+  const N = s.length
+  let ans = -1
+  let curr = new Set()
+  const backtrack = (pos) => {
+    if (pos === N) {
+      ans = Math.max(ans, curr.size)
+      return
+    }
+    if (curr.size + (N - pos) <= ans) return
+    for (let i = pos + 1; i <= N; i++) {
+      const a = s.slice(pos, i)
+      if (curr.has(a)) continue
+      curr.add(a)
+      backtrack(i)
+      curr.delete(a)
+    }
+  }
+
+  backtrack(0)
+  return ans
+}
+

From 5b30e2bf2013c3b484ccf97889ca4ca893a34abe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Dec 2020 21:19:58 +0800
Subject: [PATCH 0986/3374] Update 1307-verbal-arithmetic-puzzle.js

---
 1307-verbal-arithmetic-puzzle.js | 90 ++++++++++++++++----------------
 1 file changed, 44 insertions(+), 46 deletions(-)

diff --git a/1307-verbal-arithmetic-puzzle.js b/1307-verbal-arithmetic-puzzle.js
index 1cbcbddc..eafb218a 100644
--- a/1307-verbal-arithmetic-puzzle.js
+++ b/1307-verbal-arithmetic-puzzle.js
@@ -4,54 +4,52 @@
  * @return {boolean}
  */
 const isSolvable = function (words, result) {
-  const firstChars = new Set()
-
-  // this will hold the key as the character and multiple as the value
-  const map = {}
-  for (let i = 0; i < result.length; i++) {
-    const char = result[i]
-    if (!i) firstChars.add(char)
-    if (!map.hasOwnProperty(char)) map[char] = 0
-    map[char] -= 10 ** (result.length - i - 1)
-  }
-  for (let j = 0; j < words.length; j++) {
-    const word = words[j]
-    for (let i = 0; i < word.length; i++) {
-      const char = word[i]
-      if (!i) firstChars.add(char)
-      if (!map.hasOwnProperty(char)) map[char] = 0
-      map[char] += 10 ** (word.length - i - 1)
+  const _isSolvable = (wordIndex, charIndex, wordsSum, resultSum, num) => {
+    if (wordIndex >= words.length) {
+      return wordsSum === resultSum
     }
-  }
-
-  const positives = []
-  const negatives = []
-  Object.entries(map).forEach((entry) => {
-    if (entry[1] < 0) negatives.push(entry)
-    else positives.push(entry)
-  })
-
-  const numsUsed = new Set()
-  const backtrack = (val = 0) => {
-    // if we have used all the characters and the value is 0 the input is solvable
-    if (!positives.length && !negatives.length) return val === 0
-
-    // get the store that we are going to examine depending on the value
-    const store =
-      val > 0 || (val === 0 && negatives.length) ? negatives : positives
-    if (store.length === 0) return false
-    const entry = store.pop()
-    const [char, multiple] = entry
-
-    // try every possible value watching out for the edge case that it was a first character
-    for (let i = firstChars.has(char) ? 1 : 0; i < 10; i++) {
-      if (numsUsed.has(i)) continue
-      numsUsed.add(i)
-      if (backtrack(i * multiple + val)) return true
-      numsUsed.delete(i)
+    const wordLen = words[wordIndex].length
+    if (charIndex >= wordLen) {
+      if (wordIndex === words.length - 1) {
+        return _isSolvable(wordIndex + 1, 0, wordsSum, num, 0)
+      }
+      return _isSolvable(wordIndex + 1, 0, wordsSum + num, resultSum, 0)
+    }
+    const char = words[wordIndex][charIndex]
+    if (map.get(char) !== undefined) {
+      if (map.get(char) === 0 && num === 0 && charIndex >= 1) {
+        return false
+      }
+      return _isSolvable(
+        wordIndex,
+        charIndex + 1,
+        wordsSum,
+        resultSum,
+        num * 10 + map.get(char)
+      )
+    }
+    for (let digit = 0; digit <= 9; digit++) {
+      if (digit === 0 && num === 0 && wordLen > 1) continue
+      if (map.get(digit) !== undefined) continue
+      map.set(digit, char)
+      map.set(char, digit)
+      if (
+        _isSolvable(
+          wordIndex,
+          charIndex + 1,
+          wordsSum,
+          resultSum,
+          num * 10 + digit
+        )
+      ) {
+        return true
+      }
+      map.set(digit, undefined)
+      map.set(char, undefined)
     }
-    store.push(entry)
     return false
   }
-  return backtrack()
+  const map = new Map()
+  words = [...words, result]
+  return _isSolvable(0, 0, 0, 0, 0)
 }

From 9ae14e32883406c891b565cc7fdfb76cd28205f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Dec 2020 19:32:52 +0800
Subject: [PATCH 0987/3374] Update 996-number-of-squareful-arrays.js

---
 996-number-of-squareful-arrays.js | 34 +++++++++++++++----------------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/996-number-of-squareful-arrays.js b/996-number-of-squareful-arrays.js
index de84d5a8..ef73e378 100644
--- a/996-number-of-squareful-arrays.js
+++ b/996-number-of-squareful-arrays.js
@@ -3,43 +3,43 @@
  * @return {number}
  */
 
-const numSquarefulPerms = function(A) {
-  const cntMap = {};
-  const squareMap = {};
-  let cnt = 0;
+const numSquarefulPerms = function (A) {
+  const cntMap = {}
+  const squareMap = {}
+  let cnt = 0
   for (let num of A) {
     if (!cntMap.hasOwnProperty(num)) {
-      cntMap[num] = 1;
-      squareMap[num] = new Set();
+      cntMap[num] = 1
+      squareMap[num] = new Set()
     } else {
-      cntMap[num] = cntMap[num] + 1;
+      cntMap[num] = cntMap[num] + 1
     }
   }
 
   for (let num1 of Object.keys(cntMap)) {
     for (let num2 of Object.keys(cntMap)) {
-      let c = Math.sqrt(+num1 + +num2);
+      let c = Math.sqrt(+num1 + +num2)
       if (c === Math.floor(c)) {
-        squareMap[num1].add(+num2);
-        squareMap[num2].add(+num1);
+        squareMap[num1].add(+num2)
+        squareMap[num2].add(+num1)
       }
     }
   }
   for (let num of Object.keys(cntMap)) {
-    countPerm(num, A.length - 1);
+    countPerm(num, A.length - 1)
   }
-  return cnt;
+  return cnt
   function countPerm(num, left) {
-    cntMap[num] = cntMap[num] - 1;
+    cntMap[num] = cntMap[num] - 1
     if (left === 0) {
-      cnt++;
+      cnt++
     } else {
       for (let next of squareMap[num]) {
         if (cntMap[next] !== 0) {
-          countPerm(next, left - 1);
+          countPerm(next, left - 1)
         }
       }
     }
-    cntMap[num] = cntMap[num] + 1;
+    cntMap[num] = cntMap[num] + 1
   }
-};
+}

From a77bd218fd65b073c6cbf16794ba70c3ceaeced7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 17:41:59 +0800
Subject: [PATCH 0988/3374] Create 1688-count-of-matches-in-tournament.js

---
 1688-count-of-matches-in-tournament.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1688-count-of-matches-in-tournament.js

diff --git a/1688-count-of-matches-in-tournament.js b/1688-count-of-matches-in-tournament.js
new file mode 100644
index 00000000..dd66cced
--- /dev/null
+++ b/1688-count-of-matches-in-tournament.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numberOfMatches = function(n) {
+  const obj = { res: 0 }
+  helper(n, obj)
+  return obj.res
+};
+
+function helper(num, obj) {
+  if(num <= 1) return
+  const odd = num % 2 === 1
+  if(odd) {
+    const tmp = Math.floor((num - 1) / 2) 
+    obj.res += tmp
+    helper(tmp + 1, obj)
+  } else {
+    const tmp = Math.floor(num / 2) 
+    obj.res += tmp
+    helper(tmp, obj)
+  }
+}

From 46d677a9eb44509c32ea30dc76b271b1f34f170a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 17:42:45 +0800
Subject: [PATCH 0989/3374] Create
 1689-partitioning-into-minimum-number-of-deci-binary-numbers.js

---
 ...ing-into-minimum-number-of-deci-binary-numbers.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1689-partitioning-into-minimum-number-of-deci-binary-numbers.js

diff --git a/1689-partitioning-into-minimum-number-of-deci-binary-numbers.js b/1689-partitioning-into-minimum-number-of-deci-binary-numbers.js
new file mode 100644
index 00000000..2e2ccec9
--- /dev/null
+++ b/1689-partitioning-into-minimum-number-of-deci-binary-numbers.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} n
+ * @return {number}
+ */
+var minPartitions = function(n) {
+  let res = 0
+  const arr = n.split('').map(e => parseInt(e))
+  for(let i = 0, len = arr.length; i < len; i++) {
+    res = Math.max(arr[i], res)
+  }
+  return res
+};

From 4e8d7afb6c99d14971ca7182994b783037fac11a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 17:43:13 +0800
Subject: [PATCH 0990/3374] Create 1690-stone-game-vii.js

---
 1690-stone-game-vii.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1690-stone-game-vii.js

diff --git a/1690-stone-game-vii.js b/1690-stone-game-vii.js
new file mode 100644
index 00000000..2d7e0829
--- /dev/null
+++ b/1690-stone-game-vii.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+const stoneGameVII = function(stones) {
+    let len = stones.length;
+    const dp = Array.from({ length: len }, () => Array(len).fill(0)) ;
+    for (let i = len - 2; i >= 0; i--) {
+      let sum = stones[i];
+      for (let j = i + 1; j < len; j++) {
+        sum += stones[j];
+        dp[i][j] = Math.max(sum - stones[i] - dp[i + 1][j], sum - stones[j] - dp[i][j - 1]);
+      }
+    }
+    return dp[0][len - 1];
+};

From 4298ecd7e07372f5b72bffd6b89c08aea1313f1d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 17:43:39 +0800
Subject: [PATCH 0991/3374] Create 1691-maximum-height-by-stacking-cuboids.js

---
 1691-maximum-height-by-stacking-cuboids.js | 32 ++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1691-maximum-height-by-stacking-cuboids.js

diff --git a/1691-maximum-height-by-stacking-cuboids.js b/1691-maximum-height-by-stacking-cuboids.js
new file mode 100644
index 00000000..618345a2
--- /dev/null
+++ b/1691-maximum-height-by-stacking-cuboids.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} cuboids
+ * @return {number}
+ */
+var maxHeight = function (cuboids) {
+  let n = cuboids.length
+  for (let c of cuboids) {
+    c.sort((a, b) => a - b)
+  }
+  const { max } = Math
+  cuboids.sort(compare)
+  const f = Array(n)
+  let ans = 0
+  for (let i = 0; i < n; i++) {
+    f[i] = cuboids[i][2]
+    for (let j = 0; j < i; j++) {
+      if (
+        cuboids[i][0] <= cuboids[j][0] &&
+        cuboids[i][1] <= cuboids[j][1] &&
+        cuboids[i][2] <= cuboids[j][2]
+      )
+        f[i] = max(f[i], f[j] + cuboids[i][2])
+    }
+    ans = max(ans, f[i])
+  }
+  return ans
+  function compare(a, b) {
+    if (a[0] != b[0]) return b[0] - a[0]
+    if (a[1] != b[1]) return b[1] - a[1]
+    return b[2] - a[2]
+  }
+}

From 81568f586c668d174ac011823e3710c9605a64d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 17:56:49 +0800
Subject: [PATCH 0992/3374] Create
 1684-count-the-number-of-consistent-strings.js

---
 ...-count-the-number-of-consistent-strings.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1684-count-the-number-of-consistent-strings.js

diff --git a/1684-count-the-number-of-consistent-strings.js b/1684-count-the-number-of-consistent-strings.js
new file mode 100644
index 00000000..02ff968a
--- /dev/null
+++ b/1684-count-the-number-of-consistent-strings.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} allowed
+ * @param {string[]} words
+ * @return {number}
+ */
+var countConsistentStrings = function(allowed, words) {
+  const set = new Set()
+  for(let c of allowed) set.add(c)
+  let res = 0
+  for(let i = 0, len = words.length; i < len; i++) {
+    const cur = words[i]
+    let b = true
+    for(let c of cur) {
+      if(!set.has(c)) {
+        b = false
+        break
+      }
+    }
+    if(b) res++
+  }
+  
+  return res
+};

From 657f248a632a8a2962aaea6ee95e3b5cbe3377c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 20:22:33 +0800
Subject: [PATCH 0993/3374] Create 1686-stone-game-vi.js

---
 1686-stone-game-vi.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1686-stone-game-vi.js

diff --git a/1686-stone-game-vi.js b/1686-stone-game-vi.js
new file mode 100644
index 00000000..21abeabd
--- /dev/null
+++ b/1686-stone-game-vi.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} aliceValues
+ * @param {number[]} bobValues
+ * @return {number}
+ */
+var stoneGameVI = function(aliceValues, bobValues) {
+        let data = []
+        const length = aliceValues.length
+        for(let i = 0; i < length; i++) {
+          data.push([aliceValues[i] + bobValues[i], aliceValues[i], bobValues[i]])
+        }
+        data.sort((a, b) => a[0] - b[0])
+        data = data.reverse()
+
+        let aScore = 0
+        let bScore = 0
+        for(let i= 0; i<length; i++) {
+          if (i % 2 == 0)aScore += data[i][1]
+          else bScore += data[i][2]
+        }
+
+        if (aScore > bScore)return 1
+        else if (aScore == bScore)return 0
+        else return -1   
+};

From 09edbd0cb6d89796ba6fd89def3ac1de8626a537 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Dec 2020 20:48:01 +0800
Subject: [PATCH 0994/3374] Create
 1685-sum-of-absolute-differences-in-a-sorted-array.js

---
 ...-absolute-differences-in-a-sorted-array.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1685-sum-of-absolute-differences-in-a-sorted-array.js

diff --git a/1685-sum-of-absolute-differences-in-a-sorted-array.js b/1685-sum-of-absolute-differences-in-a-sorted-array.js
new file mode 100644
index 00000000..13fba8d0
--- /dev/null
+++ b/1685-sum-of-absolute-differences-in-a-sorted-array.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var getSumAbsoluteDifferences = function(nums) {
+        let left = 0
+        let right = nums.length - 2
+        let begin = 0
+        for(let i = 1, len = nums.length; i < len; i++) {
+          begin += (nums[i] - nums[0])
+        }
+
+        const res = [begin]
+        for(let i = 1, len = nums.length; i < len; i++) {
+            res.push(res[i - 1] - (nums[i] - nums[i - 1]) * (right - left))
+            left += 1
+            right -= 1
+        }
+
+        return res    
+};

From 937de85ece0cd1b36ef0ff9bf3bf65f9c91e65ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Dec 2020 21:29:40 +0800
Subject: [PATCH 0995/3374] Update 1686-stone-game-vi.js

---
 1686-stone-game-vi.js | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/1686-stone-game-vi.js b/1686-stone-game-vi.js
index 21abeabd..a57e8cd8 100644
--- a/1686-stone-game-vi.js
+++ b/1686-stone-game-vi.js
@@ -3,23 +3,23 @@
  * @param {number[]} bobValues
  * @return {number}
  */
-var stoneGameVI = function(aliceValues, bobValues) {
-        let data = []
-        const length = aliceValues.length
-        for(let i = 0; i < length; i++) {
-          data.push([aliceValues[i] + bobValues[i], aliceValues[i], bobValues[i]])
-        }
-        data.sort((a, b) => a[0] - b[0])
-        data = data.reverse()
+const stoneGameVI = function (aliceValues, bobValues) {
+  let data = []
+  const length = aliceValues.length
+  for (let i = 0; i < length; i++) {
+    data.push([aliceValues[i] + bobValues[i], aliceValues[i], bobValues[i]])
+  }
+  data.sort((a, b) => a[0] - b[0])
+  data = data.reverse()
 
-        let aScore = 0
-        let bScore = 0
-        for(let i= 0; i<length; i++) {
-          if (i % 2 == 0)aScore += data[i][1]
-          else bScore += data[i][2]
-        }
+  let aScore = 0
+  let bScore = 0
+  for (let i = 0; i < length; i++) {
+    if (i % 2 == 0) aScore += data[i][1]
+    else bScore += data[i][2]
+  }
 
-        if (aScore > bScore)return 1
-        else if (aScore == bScore)return 0
-        else return -1   
-};
+  if (aScore > bScore) return 1
+  else if (aScore == bScore) return 0
+  else return -1
+}

From d8c3f80ee58b0ef273c559298c44991031be1cb3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Dec 2020 23:32:48 +0800
Subject: [PATCH 0996/3374] Create
 1687-delivering-boxes-from-storage-to-ports.js

---
 ...-delivering-boxes-from-storage-to-ports.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1687-delivering-boxes-from-storage-to-ports.js

diff --git a/1687-delivering-boxes-from-storage-to-ports.js b/1687-delivering-boxes-from-storage-to-ports.js
new file mode 100644
index 00000000..46ef0a12
--- /dev/null
+++ b/1687-delivering-boxes-from-storage-to-ports.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} boxes
+ * @param {number} portsCount
+ * @param {number} maxBoxes
+ * @param {number} maxWeight
+ * @return {number}
+ */
+var boxDelivering = function (boxes, portsCount, maxBoxes, maxWeight) {
+  const n = boxes.length
+  const diff = Array(n).fill(0)
+  for (let i = 0; i < n - 1; i++) {
+    if (boxes[i][0] != boxes[i + 1][0]) diff[i] = 1
+  }
+  const dp = Array(n).fill(0)
+  let cur = 0
+  let cbox = 0
+  let start = 0
+  for (let i = 0; i < n; i++) {
+    if (i - start == maxBoxes) {
+      cur -= boxes[start][1]
+      cbox -= diff[start]
+      start += 1
+    }
+    cur += boxes[i][1]
+    if (i > 0) cbox += diff[i - 1]
+    while (cur > maxWeight) {
+      cur -= boxes[start][1]
+      cbox -= diff[start]
+      start += 1
+    }
+    while (start < i && dp[start] == dp[start - 1]) {
+      cur -= boxes[start][1]
+      cbox -= diff[start]
+      start += 1
+    }
+    dp[i] = (start == 0 ? 0 : dp[start - 1]) + cbox + 2
+  }
+  return dp[n - 1]
+}

From e8a66dfd787cd3f0812be316f333f0a9732b7a5b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Dec 2020 22:03:46 +0800
Subject: [PATCH 0997/3374] Update 1690-stone-game-vii.js

---
 1690-stone-game-vii.js | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/1690-stone-game-vii.js b/1690-stone-game-vii.js
index 2d7e0829..c79dbdc0 100644
--- a/1690-stone-game-vii.js
+++ b/1690-stone-game-vii.js
@@ -2,15 +2,18 @@
  * @param {number[]} stones
  * @return {number}
  */
-const stoneGameVII = function(stones) {
-    let len = stones.length;
-    const dp = Array.from({ length: len }, () => Array(len).fill(0)) ;
-    for (let i = len - 2; i >= 0; i--) {
-      let sum = stones[i];
-      for (let j = i + 1; j < len; j++) {
-        sum += stones[j];
-        dp[i][j] = Math.max(sum - stones[i] - dp[i + 1][j], sum - stones[j] - dp[i][j - 1]);
-      }
+const stoneGameVII = function (stones) {
+  let len = stones.length
+  const dp = Array.from({ length: len }, () => Array(len).fill(0))
+  for (let i = len - 2; i >= 0; i--) {
+    let sum = stones[i]
+    for (let j = i + 1; j < len; j++) {
+      sum += stones[j]
+      dp[i][j] = Math.max(
+        sum - stones[i] - dp[i + 1][j],
+        sum - stones[j] - dp[i][j - 1]
+      )
     }
-    return dp[0][len - 1];
-};
+  }
+  return dp[0][len - 1]
+}

From b9d00847495b20840340e87561c5f6ea246653a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Dec 2020 21:48:49 +0800
Subject: [PATCH 0998/3374] Update 1691-maximum-height-by-stacking-cuboids.js

---
 1691-maximum-height-by-stacking-cuboids.js | 31 ++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1691-maximum-height-by-stacking-cuboids.js b/1691-maximum-height-by-stacking-cuboids.js
index 618345a2..2dbc487d 100644
--- a/1691-maximum-height-by-stacking-cuboids.js
+++ b/1691-maximum-height-by-stacking-cuboids.js
@@ -30,3 +30,34 @@ var maxHeight = function (cuboids) {
     return b[2] - a[2]
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} cuboids
+ * @return {number}
+ */
+var maxHeight = function(cuboids) {
+  cuboids.forEach((cuboid) => cuboid.sort((a, b) => a - b));
+  cuboids.sort((a, b) => {
+    if (a[0] !== b[0]) return b[0] - a[0];
+    if (a[1] !== b[1]) return b[1] - a[1];
+    return b[2] - a[2];
+  });
+  const n = cuboids.length;
+  const dp = Array(n).fill(0);
+  let res = 0;
+  for (let j = 0; j < n; ++j) {
+    dp[j] = cuboids[j][2];
+    for (let i = 0; i < j; ++i) {
+      if (cuboids[i][0] >= cuboids[j][0]
+        && cuboids[i][1] >= cuboids[j][1]
+        && cuboids[i][2] >= cuboids[j][2]
+      ) {
+        dp[j] = Math.max(dp[j], dp[i] + cuboids[j][2]);
+      }
+    }
+    res = Math.max(res, dp[j]);
+  }
+  return res;
+};

From 1564c453e893fb5e670939041874f86eefd50ea5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 00:42:45 +0800
Subject: [PATCH 0999/3374] Update 300-longest-increasing-subsequence.js

---
 300-longest-increasing-subsequence.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/300-longest-increasing-subsequence.js b/300-longest-increasing-subsequence.js
index 0a073c1d..830ef698 100644
--- a/300-longest-increasing-subsequence.js
+++ b/300-longest-increasing-subsequence.js
@@ -35,7 +35,7 @@ const lengthOfLIS = function(nums) {
   for(let e of nums) {
     let i = 0, j = res
     while(i !== j) {
-      const mid = (i + j) >> 1
+      const mid = i + ((j - i) >> 1)
       if(tails[mid] < e) i = mid + 1
       else j = mid
     }

From af96702af9a4589cd81b9ceeb6d967c019bbd516 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 18:08:53 +0800
Subject: [PATCH 1000/3374] Create 1694-reformat-phone-number.js

---
 1694-reformat-phone-number.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1694-reformat-phone-number.js

diff --git a/1694-reformat-phone-number.js b/1694-reformat-phone-number.js
new file mode 100644
index 00000000..33fab296
--- /dev/null
+++ b/1694-reformat-phone-number.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} number
+ * @return {string}
+ */
+const reformatNumber = function(number) {
+  let str = number.replace(/\-/g, '')
+  str = str.split(' ').join('')
+  const n = str.length
+  const re = n % 3
+  let lo = 0, hi = 0
+  let tmp = []
+  if(re === 1) {
+    hi = n - 5
+    tmp.push(str.slice(n - 4, n - 2), str.slice(n - 2))
+  } else if(re === 2) {
+    hi = n - 3
+    tmp.push(str.slice(n - 2))
+  } else {
+    hi = n - 1
+  }
+  const res = []
+  for(let i = lo; i <= hi; i += 3) {
+    res.push(str.slice(i, i + 3))
+  }
+  
+ res.push(...tmp)
+    
+  return res.join('-')
+};

From e298a5059dcc994f79d2ac7f848ad5c209b0ad99 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 18:09:25 +0800
Subject: [PATCH 1001/3374] Create 1695-maximum-erasure-value.js

---
 1695-maximum-erasure-value.js | 36 +++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1695-maximum-erasure-value.js

diff --git a/1695-maximum-erasure-value.js b/1695-maximum-erasure-value.js
new file mode 100644
index 00000000..3913e80e
--- /dev/null
+++ b/1695-maximum-erasure-value.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumUniqueSubarray = function(nums) {
+  return maxSumSubarray(nums, nums.length)
+};
+
+function maxSumSubarray(arr, n) {
+
+  let i = 0, j = 1;
+  const set = new Set();
+  set.add(arr[0]);
+
+  let sum = arr[0];
+  let maxsum = sum;
+  let end = arr[0]
+ 
+  while (i < n - 1 && j < n) {
+    const is_in = set.has(arr[j])
+    if (!is_in) {
+      sum = sum + arr[j];
+      maxsum = Math.max(sum, maxsum);
+    
+      set.add(arr[j++]);
+    } else {
+      sum -= arr[i];
+      set.delete(arr[i++]);
+    }
+  }
+  return maxsum;
+}
+
+function end(s) {
+  return Array.from(s).pop();
+}

From 8a20275bc488a246aa5319cf78275c999568dfeb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 18:10:15 +0800
Subject: [PATCH 1002/3374] Create 1696-jump-game-vi.js

---
 1696-jump-game-vi.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1696-jump-game-vi.js

diff --git a/1696-jump-game-vi.js b/1696-jump-game-vi.js
new file mode 100644
index 00000000..a4097f57
--- /dev/null
+++ b/1696-jump-game-vi.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxResult = function(nums, k) {
+    const n = nums.length;
+    const f = Array(n).fill(0);
+    f[0] = nums[0];
+    const q = [0];
+    for (let i = 1; i < n; ++i) {
+        while (i - q[0] > k) {
+            q.shift();
+        }
+        f[i] = f[q[0]] + nums[i];
+        while (q.length && f[i] >= f[q[q.length - 1]]) {
+            q.pop();
+        }
+        q.push(i);
+    }
+    return f[n - 1];
+};
+

From d48e86800b24f5feeb116709df6596e2dc54abec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 18:10:54 +0800
Subject: [PATCH 1003/3374] Create
 1697-checking-existence-of-edge-length-limited-paths.js

---
 ...-existence-of-edge-length-limited-paths.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 1697-checking-existence-of-edge-length-limited-paths.js

diff --git a/1697-checking-existence-of-edge-length-limited-paths.js b/1697-checking-existence-of-edge-length-limited-paths.js
new file mode 100644
index 00000000..05fd4196
--- /dev/null
+++ b/1697-checking-existence-of-edge-length-limited-paths.js
@@ -0,0 +1,58 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edgeList
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const distanceLimitedPathsExist = function(n, edgeList, queries) {
+    edgeList.sort((a, b) => a[2] - b[2])
+    let q = queries.length;
+    const ans = Array(q).fill(false);
+    const order = Array(q).fill(0);
+    for (let i = 0; i < q; ++i) order[i] = i;
+    order.sort((i, j) => queries[i][2] - queries[j][2])
+    const uf = new UnionFind(n);
+    let idx = 0;
+    for (let i of order) {
+        let limit = queries[i][2];
+        while (idx < edgeList.length && edgeList[idx][2] < limit) {
+            let u = edgeList[idx][0], v = edgeList[idx][1];
+            uf.union(u, v);
+            idx++;
+        }
+        let u0 = queries[i][0], v0 = queries[i][1];
+        if (uf.find(u0) === uf.find(v0)) ans[i] = true;
+    }
+    return ans;
+};
+class UnionFind {
+  constructor(n) {
+    this.parents = Array(n)
+      .fill(0)
+      .map((e, i) => i)
+    this.ranks = Array(n).fill(0)
+  }
+  root(x) {
+    while(x !== this.parents[x]) {
+      this.parents[x] = this.parents[this.parents[x]]
+      x = this.parents[x]
+    }
+    return x
+  }
+  find(x) {
+    return this.root(x)
+  }
+  check(x, y) {
+    return this.root(x) === this.root(y)
+  }
+  union(x, y) {
+    const [rx, ry] = [this.find(x), this.find(y)]
+    if (this.ranks[rx] >= this.ranks[ry]) {
+      this.parents[ry] = rx
+      this.ranks[rx] += this.ranks[ry]
+    } else if (this.ranks[ry] > this.ranks[rx]) {
+      this.parents[rx] = ry
+      this.ranks[ry] += this.ranks[rx]
+    }
+  }
+}

From 2468b9a3128342b749acd011d4f1a049ae2a2a5a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Dec 2020 19:48:38 +0800
Subject: [PATCH 1004/3374] Update 368-largest-divisible-subset.js

---
 368-largest-divisible-subset.js | 34 +++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/368-largest-divisible-subset.js b/368-largest-divisible-subset.js
index 88760122..bd74d95a 100644
--- a/368-largest-divisible-subset.js
+++ b/368-largest-divisible-subset.js
@@ -1,3 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const largestDivisibleSubset = function(nums) {
+  const n = nums.length;
+  if(n === 0 || n === 1) return nums
+  let maxSize = 0;
+  const dp = Array(n).fill(1)
+  nums.sort((a, b) => a - b)
+  for(let i = 1; i < n; i++) {
+    for(let j = i - 1; j >= 0; j--) {
+      if(nums[i] % nums[j] === 0) {
+        const tmp = dp[j] + 1
+        if(tmp > dp[i]) dp[i] = tmp         
+      }
+    }
+    if(dp[i] > maxSize) maxSize = dp[i]
+  }
+  const res = []
+  let pivot = 0
+  for(let i = n - 1; i >= 0; i--) {
+    if(dp[i] === maxSize && (pivot % nums[i] === 0)) {
+      pivot = nums[i]
+      maxSize--
+      res.push(nums[i])
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number[]}

From ad5b1eb5e66d3864e259c4b5446f2a919d9dfe8d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Dec 2020 20:00:42 +0800
Subject: [PATCH 1005/3374] Update 1696-jump-game-vi.js

---
 1696-jump-game-vi.js | 33 ++++++++++++++++-----------------
 1 file changed, 16 insertions(+), 17 deletions(-)

diff --git a/1696-jump-game-vi.js b/1696-jump-game-vi.js
index a4097f57..6a10c740 100644
--- a/1696-jump-game-vi.js
+++ b/1696-jump-game-vi.js
@@ -3,21 +3,20 @@
  * @param {number} k
  * @return {number}
  */
-const maxResult = function(nums, k) {
-    const n = nums.length;
-    const f = Array(n).fill(0);
-    f[0] = nums[0];
-    const q = [0];
-    for (let i = 1; i < n; ++i) {
-        while (i - q[0] > k) {
-            q.shift();
-        }
-        f[i] = f[q[0]] + nums[i];
-        while (q.length && f[i] >= f[q[q.length - 1]]) {
-            q.pop();
-        }
-        q.push(i);
+const maxResult = function (nums, k) {
+  const n = nums.length
+  const f = Array(n).fill(0)
+  f[0] = nums[0]
+  const q = [0]
+  for (let i = 1; i < n; ++i) {
+    while (i - q[0] > k) {
+      q.shift()
     }
-    return f[n - 1];
-};
-
+    f[i] = f[q[0]] + nums[i]
+    while (q.length && f[i] >= f[q[q.length - 1]]) {
+      q.pop()
+    }
+    q.push(i)
+  }
+  return f[n - 1]
+}

From e2743ca7c139a565c3a8d3b462ffbb9c819e6974 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Dec 2020 21:13:08 +0800
Subject: [PATCH 1006/3374] Update
 1697-checking-existence-of-edge-length-limited-paths.js

---
 ...-existence-of-edge-length-limited-paths.js | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/1697-checking-existence-of-edge-length-limited-paths.js b/1697-checking-existence-of-edge-length-limited-paths.js
index 05fd4196..12928026 100644
--- a/1697-checking-existence-of-edge-length-limited-paths.js
+++ b/1697-checking-existence-of-edge-length-limited-paths.js
@@ -4,27 +4,29 @@
  * @param {number[][]} queries
  * @return {boolean[]}
  */
-const distanceLimitedPathsExist = function(n, edgeList, queries) {
-    edgeList.sort((a, b) => a[2] - b[2])
-    let q = queries.length;
-    const ans = Array(q).fill(false);
-    const order = Array(q).fill(0);
-    for (let i = 0; i < q; ++i) order[i] = i;
-    order.sort((i, j) => queries[i][2] - queries[j][2])
-    const uf = new UnionFind(n);
-    let idx = 0;
-    for (let i of order) {
-        let limit = queries[i][2];
-        while (idx < edgeList.length && edgeList[idx][2] < limit) {
-            let u = edgeList[idx][0], v = edgeList[idx][1];
-            uf.union(u, v);
-            idx++;
-        }
-        let u0 = queries[i][0], v0 = queries[i][1];
-        if (uf.find(u0) === uf.find(v0)) ans[i] = true;
+const distanceLimitedPathsExist = function (n, edgeList, queries) {
+  edgeList.sort((a, b) => a[2] - b[2])
+  const m = queries.length
+  const ans = Array(m).fill(false)
+  const order = Array(m).fill(0)
+  for (let i = 0; i < m; ++i) order[i] = i
+  order.sort((i, j) => queries[i][2] - queries[j][2])
+  const uf = new UnionFind(n)
+  let idx = 0
+  for (let i of order) {
+    const limit = queries[i][2]
+    while (idx < edgeList.length && edgeList[idx][2] < limit) {
+      const u = edgeList[idx][0],
+        v = edgeList[idx][1]
+      uf.union(u, v)
+      idx++
     }
-    return ans;
-};
+    const u0 = queries[i][0],
+      v0 = queries[i][1]
+    if (uf.find(u0) === uf.find(v0)) ans[i] = true
+  }
+  return ans
+}
 class UnionFind {
   constructor(n) {
     this.parents = Array(n)
@@ -33,7 +35,7 @@ class UnionFind {
     this.ranks = Array(n).fill(0)
   }
   root(x) {
-    while(x !== this.parents[x]) {
+    while (x !== this.parents[x]) {
       this.parents[x] = this.parents[this.parents[x]]
       x = this.parents[x]
     }

From 7f3c6c4beecbd78cd2736cb4a054901e500710a6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Dec 2020 20:27:01 +0800
Subject: [PATCH 1007/3374] Update
 395-longest-substring-with-at-least-k-repeating-characters.js

---
 ...ng-with-at-least-k-repeating-characters.js | 34 +++++++++----------
 1 file changed, 17 insertions(+), 17 deletions(-)

diff --git a/395-longest-substring-with-at-least-k-repeating-characters.js b/395-longest-substring-with-at-least-k-repeating-characters.js
index 5eb40cab..09bdf3ff 100644
--- a/395-longest-substring-with-at-least-k-repeating-characters.js
+++ b/395-longest-substring-with-at-least-k-repeating-characters.js
@@ -3,28 +3,28 @@
  * @param {number} k
  * @return {number}
  */
-const longestSubstring = function(s, k) {
-  if (s == null || s.length === 0) return 0;
-  const chars = new Array(26).fill(0);
-  const aCode = "a".charCodeAt(0);
-  for (let i = 0; i < s.length; i++) chars[s.charCodeAt(i) - aCode] += 1;
-  let flag = true;
+const longestSubstring = function (s, k) {
+  if (s == null || s.length === 0) return 0
+  const chars = new Array(26).fill(0)
+  const aCode = 'a'.charCodeAt(0)
+  for (let i = 0; i < s.length; i++) chars[s.charCodeAt(i) - aCode] += 1
+  let flag = true
   for (let i = 0; i < chars.length; i++) {
-    if (chars[i] < k && chars[i] > 0) flag = false;
+    if (chars[i] < k && chars[i] > 0) flag = false
   }
   if (flag === true) {
-    return s.length;
+    return s.length
   }
-  let result = 0;
-  let start = 0;
-  let cur = 0;
+  let result = 0
+  let start = 0
+  let cur = 0
   while (cur < s.length) {
     if (chars[s.charCodeAt(cur) - aCode] < k) {
-      result = Math.max(result, longestSubstring(s.slice(start, cur), k));
-      start = cur + 1;
+      result = Math.max(result, longestSubstring(s.slice(start, cur), k))
+      start = cur + 1
     }
-    cur++;
+    cur++
   }
-  result = Math.max(result, longestSubstring(s.slice(start), k));
-  return result;
-};
+  result = Math.max(result, longestSubstring(s.slice(start), k))
+  return result
+}

From bdfa9a9e176a779a2e4e5ba8d523917dad7be18e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Dec 2020 19:35:08 +0800
Subject: [PATCH 1008/3374] Update 1024-video-stitching.js

---
 1024-video-stitching.js | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/1024-video-stitching.js b/1024-video-stitching.js
index 3c0452f4..c4510dd5 100644
--- a/1024-video-stitching.js
+++ b/1024-video-stitching.js
@@ -3,27 +3,22 @@
  * @param {number} T
  * @return {number}
  */
-const videoStitching = function(clips, T) {
+const videoStitching = function (clips, T) {
   clips.sort((a, b) => a[0] - b[0])
   let laststart = -1,
     curend = 0,
     count = 0
   for (let i = 0; i < clips.length; ) {
-    if (clips[i][0] > curend) {
-      return -1
-    }
+    if (clips[i][0] > curend) return -1
     let maxend = curend
     // while one clip's start is before or equal to current end
     while (i < clips.length && clips[i][0] <= curend) {
-      // find out the one with the max possible end
       maxend = Math.max(maxend, clips[i][1])
       i++
     }
     count++
     curend = maxend
-    if (curend >= T) {
-      return count
-    }
+    if (curend >= T) return count
   }
   return -1
 }

From afc3ba7524bbce5164e9a735aa4edec9993f1f90 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Dec 2020 19:44:29 +0800
Subject: [PATCH 1009/3374] Update 1024-video-stitching.js

---
 1024-video-stitching.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1024-video-stitching.js b/1024-video-stitching.js
index c4510dd5..eee0c025 100644
--- a/1024-video-stitching.js
+++ b/1024-video-stitching.js
@@ -5,6 +5,7 @@
  */
 const videoStitching = function (clips, T) {
   clips.sort((a, b) => a[0] - b[0])
+  if(T === 0) return 0
   let laststart = -1,
     curend = 0,
     count = 0

From 4389942eb5e429275deced55a0c3a0643af81454 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Dec 2020 20:17:10 +0800
Subject: [PATCH 1010/3374] Update 1024-video-stitching.js

---
 1024-video-stitching.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1024-video-stitching.js b/1024-video-stitching.js
index eee0c025..b6513318 100644
--- a/1024-video-stitching.js
+++ b/1024-video-stitching.js
@@ -23,3 +23,23 @@ const videoStitching = function (clips, T) {
   }
   return -1
 }
+
+// another
+
+/**
+ * @param {number[][]} clips
+ * @param {number} T
+ * @return {number}
+ */
+const videoStitching = function (clips, T) {
+  clips.sort((a, b) => a[0] - b[0])
+  let res = 0
+  for(let i = 0, start = 0, end = 0, len = clips.length; start < T; start = end, res++) {
+    for(; i < len && clips[i][0] <= start; i++) {
+      end = Math.max(end, clips[i][1])
+    }
+    if(start === end) return -1
+  }
+  return res
+}
+

From 452fcea2656a2aa7ef27815229f81e3711706ef5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Dec 2020 21:07:42 +0800
Subject: [PATCH 1011/3374] Update 1024-video-stitching.js

---
 1024-video-stitching.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1024-video-stitching.js b/1024-video-stitching.js
index b6513318..fdc1b195 100644
--- a/1024-video-stitching.js
+++ b/1024-video-stitching.js
@@ -43,3 +43,24 @@ const videoStitching = function (clips, T) {
   return res
 }
 
+
+// another
+
+/**
+ * @param {number[][]} clips
+ * @param {number} T
+ * @return {number}
+ */
+const videoStitching = function (clips, T) {
+  const dp = Array(T + 1).fill( T + 1 )
+  dp[0] = 0
+  for(let i = 0; i <= T; i++) {
+    for(let c of clips) {
+      if(i >= c[0] && i <= c[1]) dp[i] = Math.min(dp[i], dp[c[0]] + 1)
+    }
+    if(dp[i] === T + 1) return -1
+  }
+  return dp[T]
+}
+
+

From 4d73417f1b5d718e5c38e7b67158366fda4ac610 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Dec 2020 10:54:16 +0800
Subject: [PATCH 1012/3374] Create
 1698-number-of-distinct-substrings-in-a-string.js

---
 1698-number-of-distinct-substrings-in-a-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1698-number-of-distinct-substrings-in-a-string.js

diff --git a/1698-number-of-distinct-substrings-in-a-string.js b/1698-number-of-distinct-substrings-in-a-string.js
new file mode 100644
index 00000000..595ec3f7
--- /dev/null
+++ b/1698-number-of-distinct-substrings-in-a-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countDistinct = function(s) {
+  const set = new Set()
+  for(let i = 0, len = s.length; i < len; i++) {
+    for(let j = i + 1; j <= len; j++) {
+      set.add(s.slice(i, j))
+    }
+  }
+  
+  return set.size
+};

From 2cf878187dee536066ded81dac64e8b6898f4d02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 26 Dec 2020 19:05:43 +0800
Subject: [PATCH 1013/3374] Create 1288-remove-covered-intervals.js

---
 1288-remove-covered-intervals.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1288-remove-covered-intervals.js

diff --git a/1288-remove-covered-intervals.js b/1288-remove-covered-intervals.js
new file mode 100644
index 00000000..db0ac692
--- /dev/null
+++ b/1288-remove-covered-intervals.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const removeCoveredIntervals = function(intervals) {
+  intervals.sort((a, b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])
+  const n = intervals.length
+  let res = n, max = intervals[0][1]
+  for(let i = 1; i < n; i++) {
+    if(intervals[i][1] <= max) res--
+    else max = intervals[i][1]
+  }
+  return res
+};

From f59a9887d2961d583dd117b8f710b4a9aa0b6912 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 00:11:43 +0800
Subject: [PATCH 1014/3374] Create
 1700-number-of-students-unable-to-eat-lunch.js

---
 ...-number-of-students-unable-to-eat-lunch.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1700-number-of-students-unable-to-eat-lunch.js

diff --git a/1700-number-of-students-unable-to-eat-lunch.js b/1700-number-of-students-unable-to-eat-lunch.js
new file mode 100644
index 00000000..dfdac9b4
--- /dev/null
+++ b/1700-number-of-students-unable-to-eat-lunch.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} students
+ * @param {number[]} sandwiches
+ * @return {number}
+ */
+const countStudents = function(students, sandwiches) {
+  const n = students.length
+  let res = n
+  while(helper(students, sandwiches)) {
+      const len = students.length
+      for(let i = 0; i < len; i++) {
+        if (students[0] === sandwiches[0]) {
+          students.shift()
+          sandwiches.shift()
+          res--
+        } else {
+          const tmp = students[0]
+          students.shift()
+          students.push(tmp)
+        }
+      }
+  }
+  return res
+};
+
+function helper(stu, san) {
+  const n = stu.length
+  let res = false
+  for(let i = 0; i < n; i++) {
+    if (stu[i] === san[0]) {
+      return true
+    }
+  }
+  return res
+}

From 5a02b7c92fa93221168e584a934ad7cb4adb6f8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 00:12:31 +0800
Subject: [PATCH 1015/3374] Create 1701-average-waiting-time.js

---
 1701-average-waiting-time.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1701-average-waiting-time.js

diff --git a/1701-average-waiting-time.js b/1701-average-waiting-time.js
new file mode 100644
index 00000000..a14dfc5f
--- /dev/null
+++ b/1701-average-waiting-time.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[][]} customers
+ * @return {number}
+ */
+const averageWaitingTime = function(customers) {
+  const n = customers.length
+  let start = customers[0][0], end = start + customers[0][1]
+  let sum = end - start
+  for(let i = 1; i < n; i++) {
+    end = end > customers[i][0] ? end + customers[i][1] : customers[i][0] + customers[i][1]
+    sum += (end - customers[i][0])
+  }
+  
+  let res = sum / n
+  
+  return res
+};

From 808b39e7a4170ae3bc5c21e119b9843ae4ecdeca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 00:13:07 +0800
Subject: [PATCH 1016/3374] Create 1703-maximum-binary-string-after-change.js

---
 1703-maximum-binary-string-after-change.js | 30 ++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1703-maximum-binary-string-after-change.js

diff --git a/1703-maximum-binary-string-after-change.js b/1703-maximum-binary-string-after-change.js
new file mode 100644
index 00000000..967903dc
--- /dev/null
+++ b/1703-maximum-binary-string-after-change.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} binary
+ * @return {string}
+ */
+const maximumBinaryString = function(binary) {
+   let n = binary.length;
+    const {max} = Math
+    let nums = [];
+    for (let i = 0; i < n; ++i) {
+      nums.push(+binary[i]);
+    }
+    for (let i = 0, j = 0; i < n - 1; ++i) {
+      if (nums[i] == 1) continue;
+      if (nums[i + 1] == 0) {
+        nums[i] = 1;
+        continue;
+      }
+      j = max(j, i + 1);
+      while (j < n && nums[j]) ++j;
+      if (j === n) break;
+      nums[j++] = 1;
+      nums[i + 1] = 0;
+      nums[i] = 1;
+    }
+    let res = "";
+    for (let i = 0; i < n; ++i) {
+      res += (nums[i] + '');
+    }
+    return res;
+};

From 9d43c25b3f97f1d1a6d74f67cb21e15c2e896fd2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 00:13:43 +0800
Subject: [PATCH 1017/3374] Create
 1704-minimum-adjacent-swaps-for-k-consecutive-ones.js

---
 ...m-adjacent-swaps-for-k-consecutive-ones.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1704-minimum-adjacent-swaps-for-k-consecutive-ones.js

diff --git a/1704-minimum-adjacent-swaps-for-k-consecutive-ones.js b/1704-minimum-adjacent-swaps-for-k-consecutive-ones.js
new file mode 100644
index 00000000..8560b024
--- /dev/null
+++ b/1704-minimum-adjacent-swaps-for-k-consecutive-ones.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minMoves = function(nums, k) {
+    if (k == 1) return 0;
+    let n = 0;
+    let pos = [];
+    for (let i = 0; i < nums.length; ++i) {
+      if (nums[i]) {
+        pos.push(i - (n++));
+      }
+    }
+    let sums = [];
+    sums[0] = pos[0];
+    for (let i = 1; i < n; ++i) {
+      sums[i] = pos[i] + sums[i - 1];
+    }
+    let res = Number.MAX_VALUE;
+    let l = (k / 2) >> 0, r = k - l - 1;
+    for (let i = 0; i + k <= n; ++i) {
+      let m = i + ((k / 2) >>> 0);
+      let cur = pos[m] * l - (sums[m - 1] - sums[i] + pos[i]) - pos[m] * r + sums[i + k - 1] - sums[m];
+      res = Math.min(cur, res);
+    }
+    return res;
+};
+

From 9a1c531926ec9787fef67a6d62f78287166866e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 12:59:36 +0800
Subject: [PATCH 1018/3374] Create 1704-determine-if-string-halves-are-alike.js

---
 1704-determine-if-string-halves-are-alike.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1704-determine-if-string-halves-are-alike.js

diff --git a/1704-determine-if-string-halves-are-alike.js b/1704-determine-if-string-halves-are-alike.js
new file mode 100644
index 00000000..ec3a0a92
--- /dev/null
+++ b/1704-determine-if-string-halves-are-alike.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const halvesAreAlike = function(s) {
+  const set = new Set(['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'])
+  const n = s.length
+  const mid = n / 2
+  const first = s.slice(0, mid), second = s.slice(mid)
+  return chk(first, set) === chk(second, set)
+};
+
+function chk(str, set) {
+  let res = 0
+  for(let i = 0, len = str.length; i < len; i++) {
+    if(set.has(str[i])) res++
+  }
+  return res
+}

From be167e96674089fabac9cdb3740848c30c960927 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 13:00:14 +0800
Subject: [PATCH 1019/3374] Create 1705-maximum-number-of-eaten-apples.js

---
 1705-maximum-number-of-eaten-apples.js | 100 +++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 1705-maximum-number-of-eaten-apples.js

diff --git a/1705-maximum-number-of-eaten-apples.js b/1705-maximum-number-of-eaten-apples.js
new file mode 100644
index 00000000..0a89bc07
--- /dev/null
+++ b/1705-maximum-number-of-eaten-apples.js
@@ -0,0 +1,100 @@
+/**
+ * @param {number[]} apples
+ * @param {number[]} days
+ * @return {number}
+ */
+const eatenApples = function(apples, days) {
+
+    let ans = 0, n = apples.length;
+    const que = new PriorityQueue();
+    for (let i = 0; i < n; i++) {
+        while (!que.isEmpty() && que.peek().exp <= i) que.pop();
+        if (que.isEmpty()) {
+            if (apples[i] == 0 && days[i] == 0) continue;
+        } 
+        que.push({cnt: apples[i], exp: i + days[i]});
+        ans++;
+        let temp = que.peek();
+        que.pop();
+        if (--temp.cnt) que.push(temp);
+    }
+    let day = n;
+    while (!que.isEmpty()) {
+        while (!que.isEmpty() && que.peek().exp <= n) que.pop();
+        if (que.isEmpty()) break;
+        ans++;
+        n++;
+        let temp = que.peek();
+        que.pop();
+        if (--temp.cnt) que.push(temp);
+    }
+    return ans;
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a.exp < b.exp) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 110f7adf477c34aca63610960f873c89119801b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 13:00:54 +0800
Subject: [PATCH 1020/3374] Create 1706-where-will-the-ball-fall.js

---
 1706-where-will-the-ball-fall.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1706-where-will-the-ball-fall.js

diff --git a/1706-where-will-the-ball-fall.js b/1706-where-will-the-ball-fall.js
new file mode 100644
index 00000000..1f497c6b
--- /dev/null
+++ b/1706-where-will-the-ball-fall.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[]}
+ */
+const findBall = function (grid) {
+  const res = new Array(grid[0].length).fill(0)
+  for (let i = 0; i < res.length; i++) {
+    let start = i
+    let state = 1
+    for (let j = 0; j < grid.length; j++) {
+      if (grid[j][start] === 1) {
+        if (start >= grid[0].length - 1 || grid[j][start + 1] === -1) {
+          state = -1
+          break
+        }
+        start++
+      } else {
+        if (start <= 0 || grid[j][start - 1] == 1) {
+          state = -1
+          break
+        }
+        start--
+      }
+    }
+    res[i] = state === -1 ? state : start
+  }
+  return res
+}

From 70c3d15f4b0f0faf831e7d8d1478844d5c7023f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Dec 2020 13:03:35 +0800
Subject: [PATCH 1021/3374] Create
 1707-maximum-xor-with-an-element-from-array.js

---
 ...-maximum-xor-with-an-element-from-array.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1707-maximum-xor-with-an-element-from-array.js

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
new file mode 100644
index 00000000..b0a0ccf9
--- /dev/null
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maximizeXor = function (nums, queries) {
+  const n = queries.length
+  const result = new Array(n)
+  const trie = [null, null]
+  for (let num of nums) {
+    let node = trie
+    for (let i = 30; i >= 0; i--) {
+      const b = 1 << i
+      if (b & num) {
+        if (!node[1]) node[1] = [null, null]
+        node = node[1]
+      } else {
+        if (!node[0]) node[0] = [null, null]
+        node = node[0]
+      }
+    }
+  }
+  const min = Math.min(...nums)
+  const dfs = (node, num, i, val, max) => {
+    if (!node || val > max) return -1
+    if (i === -1) return val
+    const bit = 1 << i
+    i--
+    if (bit > max) return dfs(node[0], num, i, val, max)
+    if (num & bit) {
+      let x = dfs(node[0], num, i, val, max)
+      if (x > -1) return x
+      return dfs(node[1], num, i, val | bit, max)
+    } else {
+      let y = dfs(node[1], num, i, val | bit, max)
+      if (y > -1) return y
+      return dfs(node[0], num, i, val, max)
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    const [num, max] = queries[i]
+    if (max < min) {
+      result[i] = -1
+      continue
+    }
+    result[i] = dfs(trie, num, 30, 0, max) ^ num
+  }
+  return result
+}

From 87d20e6ef15e111c6af6b5788bd0bff17abac6b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Dec 2020 18:36:54 +0800
Subject: [PATCH 1022/3374] Update 1703-maximum-binary-string-after-change.js

---
 1703-maximum-binary-string-after-change.js | 56 +++++++++++-----------
 1 file changed, 28 insertions(+), 28 deletions(-)

diff --git a/1703-maximum-binary-string-after-change.js b/1703-maximum-binary-string-after-change.js
index 967903dc..2f587761 100644
--- a/1703-maximum-binary-string-after-change.js
+++ b/1703-maximum-binary-string-after-change.js
@@ -1,30 +1,30 @@
 /**
- * @param {string} binary
- * @return {string}
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
  */
-const maximumBinaryString = function(binary) {
-   let n = binary.length;
-    const {max} = Math
-    let nums = [];
-    for (let i = 0; i < n; ++i) {
-      nums.push(+binary[i]);
-    }
-    for (let i = 0, j = 0; i < n - 1; ++i) {
-      if (nums[i] == 1) continue;
-      if (nums[i + 1] == 0) {
-        nums[i] = 1;
-        continue;
-      }
-      j = max(j, i + 1);
-      while (j < n && nums[j]) ++j;
-      if (j === n) break;
-      nums[j++] = 1;
-      nums[i + 1] = 0;
-      nums[i] = 1;
-    }
-    let res = "";
-    for (let i = 0; i < n; ++i) {
-      res += (nums[i] + '');
-    }
-    return res;
-};
+const minMoves = function (nums, k) {
+  if (k === 1) return 0
+  let n = 0
+  const pos = []
+  for (let i = 0; i < nums.length; ++i) {
+    if (nums[i]) pos.push(i - n++)
+  }
+  const sums = []
+  sums[0] = pos[0]
+  for (let i = 1; i < n; ++i) sums[i] = pos[i] + sums[i - 1]
+  let res = Number.MAX_VALUE
+  let l = (k / 2) >> 0,
+    r = k - l - 1
+  for (let i = 0; i + k <= n; ++i) {
+    const m = i + ((k / 2) >>> 0)
+    const cur =
+      pos[m] * l -
+      (sums[m - 1] - sums[i] + pos[i]) -
+      pos[m] * r +
+      sums[i + k - 1] -
+      sums[m]
+    res = Math.min(cur, res)
+  }
+  return res
+}

From 39e338e1ab673c5c998fd9af214ff0abc228ca1d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Dec 2020 19:21:08 +0800
Subject: [PATCH 1023/3374] Update 1705-maximum-number-of-eaten-apples.js

---
 1705-maximum-number-of-eaten-apples.js | 29 ++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1705-maximum-number-of-eaten-apples.js b/1705-maximum-number-of-eaten-apples.js
index 0a89bc07..fd9d789d 100644
--- a/1705-maximum-number-of-eaten-apples.js
+++ b/1705-maximum-number-of-eaten-apples.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} apples
+ * @param {number[]} days
+ * @return {number}
+ */
+const eatenApples = function (apples, days) {
+  let totalDays = 0
+  if (apples.length === 1) {
+    if (days[0] > apples[0]) return apples[0]
+    else return days[0]
+  }
+  let i = 0
+  let applesAvail = 0
+  for (; i < apples.length; i++) {
+    if (apples[i] !== 0) {
+      totalDays++
+      applesAvail = Math.max(totalDays, i + days[i], applesAvail)
+    } else {
+      if (applesAvail > i) totalDays++
+    }
+  }
+  if (applesAvail > i) return totalDays + (applesAvail - i)
+  else return totalDays
+}
+
+
+// another
+
+
 /**
  * @param {number[]} apples
  * @param {number[]} days

From 7f4a91caaa895eeab27ec56b9425c20241b9a227 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Dec 2020 20:35:15 +0800
Subject: [PATCH 1024/3374] Update 1705-maximum-number-of-eaten-apples.js

---
 1705-maximum-number-of-eaten-apples.js | 67 ++++++--------------------
 1 file changed, 14 insertions(+), 53 deletions(-)

diff --git a/1705-maximum-number-of-eaten-apples.js b/1705-maximum-number-of-eaten-apples.js
index fd9d789d..d6572bf6 100644
--- a/1705-maximum-number-of-eaten-apples.js
+++ b/1705-maximum-number-of-eaten-apples.js
@@ -4,64 +4,25 @@
  * @return {number}
  */
 const eatenApples = function (apples, days) {
-  let totalDays = 0
-  if (apples.length === 1) {
-    if (days[0] > apples[0]) return apples[0]
-    else return days[0]
-  }
-  let i = 0
-  let applesAvail = 0
-  for (; i < apples.length; i++) {
-    if (apples[i] !== 0) {
-      totalDays++
-      applesAvail = Math.max(totalDays, i + days[i], applesAvail)
-    } else {
-      if (applesAvail > i) totalDays++
+  const n = apples.length
+  let fin = 0,
+    i = 0
+  const q = new PriorityQueue()
+  while (i < n || !q.isEmpty()) {
+    if (i < n && apples[i] > 0) q.push([i + days[i], apples[i]])
+    while (!q.isEmpty() && (q.peek()[0] <= i || q.peek()[1] === 0)) q.pop()
+    if (!q.isEmpty()) {
+      q.peek()[1] -= 1
+      if(q.peek()[1] <= 0) q.pop()
+      fin += 1
     }
+    i += 1
   }
-  if (applesAvail > i) return totalDays + (applesAvail - i)
-  else return totalDays
+  return fin
 }
 
-
-// another
-
-
-/**
- * @param {number[]} apples
- * @param {number[]} days
- * @return {number}
- */
-const eatenApples = function(apples, days) {
-
-    let ans = 0, n = apples.length;
-    const que = new PriorityQueue();
-    for (let i = 0; i < n; i++) {
-        while (!que.isEmpty() && que.peek().exp <= i) que.pop();
-        if (que.isEmpty()) {
-            if (apples[i] == 0 && days[i] == 0) continue;
-        } 
-        que.push({cnt: apples[i], exp: i + days[i]});
-        ans++;
-        let temp = que.peek();
-        que.pop();
-        if (--temp.cnt) que.push(temp);
-    }
-    let day = n;
-    while (!que.isEmpty()) {
-        while (!que.isEmpty() && que.peek().exp <= n) que.pop();
-        if (que.isEmpty()) break;
-        ans++;
-        n++;
-        let temp = que.peek();
-        que.pop();
-        if (--temp.cnt) que.push(temp);
-    }
-    return ans;
-};
-
 class PriorityQueue {
-  constructor(comparator = (a, b) => a.exp < b.exp) {
+  constructor(comparator = (a, b) => a[0] < b[0]) {
     this.heap = []
     this.top = 0
     this.comparator = comparator

From 882cb7c31bce2f7f5d7f218a16dc7da72ebd5229 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Dec 2020 13:54:56 +0800
Subject: [PATCH 1025/3374] Update
 421-maximum-xor-of-two-numbers-in-an-array.js

---
 421-maximum-xor-of-two-numbers-in-an-array.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/421-maximum-xor-of-two-numbers-in-an-array.js b/421-maximum-xor-of-two-numbers-in-an-array.js
index 9e0d9ceb..4ec73846 100644
--- a/421-maximum-xor-of-two-numbers-in-an-array.js
+++ b/421-maximum-xor-of-two-numbers-in-an-array.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaximumXOR = function(nums) {
+  let res = 0, mask = 0
+  for(let i = 31; i >= 0; i--) {
+    mask = mask | (1 << i)
+    const set = new Set()
+    for(let e of nums) set.add(e & mask)
+    const tmp = res | (1 << i)
+    for(let e of set) {
+      if(set.has(e ^ tmp)) {
+         res = tmp
+         break
+      }
+    }
+  }
+  return res
+};
+
+// another
+
 /*
  * @lc app=leetcode id=421 lang=javascript
  *

From c602acfeb7e85d27d238df7d2c534e89f8a15a62 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Dec 2020 23:28:36 +0800
Subject: [PATCH 1026/3374] Create 1708-largest-subarray-length-k.js

---
 1708-largest-subarray-length-k.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1708-largest-subarray-length-k.js

diff --git a/1708-largest-subarray-length-k.js b/1708-largest-subarray-length-k.js
new file mode 100644
index 00000000..c3f26a8a
--- /dev/null
+++ b/1708-largest-subarray-length-k.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const largestSubarray = function(nums, k) {
+  const n = nums.length
+  const hi = n - k
+  let start = Number.MIN_VALUE, idx = -1
+  for(let i = 0; i <= hi; i++) {
+    if(nums[i] > start) {
+      start = nums[i]
+      idx = i
+    }
+  }
+  return nums.slice(idx, idx + k)
+};

From 42c11c3623664f9ec3eeb1f430a78d00f2a25fba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jan 2021 19:19:15 +0800
Subject: [PATCH 1027/3374] Update
 1707-maximum-xor-with-an-element-from-array.js

---
 ...-maximum-xor-with-an-element-from-array.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
index b0a0ccf9..e63749e0 100644
--- a/1707-maximum-xor-with-an-element-from-array.js
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maximizeXor = function (nums, queries) {
+  nums.sort((a, b) => a - b)
+  const numOfBits = 1 + Math.floor(Math.log2(nums[nums.length - 1]))
+  const maxMask = (1 << numOfBits) - 1
+  return queries.map(([x, m]) => query(x, m))
+  function query(x, m) {
+    if (m < nums[0]) return -1
+    let l = 0,
+      r = nums.length
+    while (l < r) {
+      let mid = l + ((r - l) >> 1)
+      if (m < nums[mid])r = mid
+      else l = mid + 1
+    }
+    r -= 1
+    l = 0
+    let ans = x & ~maxMask
+    for (let bit = numOfBits - 1; bit >= 0; bit -= 1) {
+      const mask = 1 << bit
+      if (x & mask) {
+        if ((nums[l] & mask) === 0) {
+          ans |= 1 << bit
+          r = search(l, r, mask) - 1
+        }
+      } else {
+        if (nums[r] & mask) {
+          ans |= 1 << bit
+          l = search(l, r, mask)
+        }
+      }
+    }
+    return ans
+  }
+  function search(l, r, mask) {
+    while (l <= r) {
+      const m = l + ((r - l) >> 1)
+      if ((nums[m] & mask) === 0) l = m + 1 
+      else r = m - 1
+    }
+    return l
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[][]} queries

From 25485ec551db06ec665f99eb574e3268a0562e2a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jan 2021 17:02:25 +0800
Subject: [PATCH 1028/3374] Update 435-non-overlapping-intervals.js

---
 435-non-overlapping-intervals.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/435-non-overlapping-intervals.js b/435-non-overlapping-intervals.js
index e85e0c68..5b57a608 100644
--- a/435-non-overlapping-intervals.js
+++ b/435-non-overlapping-intervals.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const eraseOverlapIntervals = function(intervals) {
+  if(intervals == null || intervals.length === 0) return 0
+  intervals.sort((a, b) => a[1] - b[1])
+  let res = 1, end = intervals[0][1]
+  const len = intervals.length
+  for(let i = 1; i < len; i++) {
+    if(intervals[i][0] >= end) {
+      end = intervals[i][1]
+      res++
+    }
+  }
+  
+  return len - res
+};
+
+// another
+
 /**
  * Definition for an interval.
  * function Interval(start, end) {

From 3c7e464f33400b7ff4470473f16ba39b7bf81f57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jan 2021 19:13:38 +0800
Subject: [PATCH 1029/3374] Create 1564-put-boxes-into-the-warehouse-i.js

---
 1564-put-boxes-into-the-warehouse-i.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1564-put-boxes-into-the-warehouse-i.js

diff --git a/1564-put-boxes-into-the-warehouse-i.js b/1564-put-boxes-into-the-warehouse-i.js
new file mode 100644
index 00000000..426811a4
--- /dev/null
+++ b/1564-put-boxes-into-the-warehouse-i.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} boxes
+ * @param {number[]} warehouse
+ * @return {number}
+ */
+const maxBoxesInWarehouse = function(boxes, warehouse) {
+  boxes.sort((a, b) => a - b)
+  const m = boxes.length, n = warehouse.length
+  let i = 0, j = 0
+  for(; i < m && j < n; i++) {
+    if(boxes[m - i - 1] <= warehouse[j]) {
+      j++
+    }
+  }
+  return j
+};

From ee781a8d46ebf66a05da03460797b998b586c17b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jan 2021 19:37:04 +0800
Subject: [PATCH 1030/3374] Update 1564-put-boxes-into-the-warehouse-i.js

---
 1564-put-boxes-into-the-warehouse-i.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1564-put-boxes-into-the-warehouse-i.js b/1564-put-boxes-into-the-warehouse-i.js
index 426811a4..5638d57a 100644
--- a/1564-put-boxes-into-the-warehouse-i.js
+++ b/1564-put-boxes-into-the-warehouse-i.js
@@ -11,6 +11,7 @@ const maxBoxesInWarehouse = function(boxes, warehouse) {
     if(boxes[m - i - 1] <= warehouse[j]) {
       j++
     }
+    if(j === n) return n
   }
   return j
 };

From 50e089a28249ebcfc7f1436dddb39af6ed8710cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jan 2021 12:32:34 +0800
Subject: [PATCH 1031/3374] Create 1710-maximum-units-on-a-truck.js

---
 1710-maximum-units-on-a-truck.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1710-maximum-units-on-a-truck.js

diff --git a/1710-maximum-units-on-a-truck.js b/1710-maximum-units-on-a-truck.js
new file mode 100644
index 00000000..8a7d3bc0
--- /dev/null
+++ b/1710-maximum-units-on-a-truck.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} boxTypes
+ * @param {number} truckSize
+ * @return {number}
+ */
+const maximumUnits = function (boxTypes, truckSize) {
+  boxTypes.sort((a, b) => b[1] - a[1])
+  let res = 0
+
+  for (let i = 0; i < boxTypes.length && truckSize > 0; ++i) {
+    let used = Math.min(boxTypes[i][0], truckSize)
+    truckSize -= used
+    res += used * boxTypes[i][1]
+  }
+  return res
+}

From 67cdad0670ff3d65d2f776031fa25770aa9b72ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jan 2021 13:07:55 +0800
Subject: [PATCH 1032/3374] Create 1711-count-good-meals.js

---
 1711-count-good-meals.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1711-count-good-meals.js

diff --git a/1711-count-good-meals.js b/1711-count-good-meals.js
new file mode 100644
index 00000000..3fb55787
--- /dev/null
+++ b/1711-count-good-meals.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} deliciousness
+ * @return {number}
+ */
+const countPairs = function (deliciousness) {
+  const N = deliciousness.length
+  deliciousness.sort((a, b) => a - b)
+  const mp = {},
+    mod = 10 ** 9 + 7
+  let ret = 0
+  for (let i = 0; i < N; i++) {
+    if (deliciousness[i] !== 0) {
+      let sum = 1 << (32 - __builtin_clz(deliciousness[i]) - 1)
+      ret += mp[sum - deliciousness[i]] || 0
+      ret += mp[(sum << 1) - deliciousness[i]] || 0
+      if (ret >= mod) ret -= mod
+    }
+    if (mp[deliciousness[i]] == null) mp[deliciousness[i]] = 0
+    mp[deliciousness[i]]++
+  }
+  return ret
+}
+
+function __builtin_clz(num) {
+  if (num === 0) return 32
+  return 32 - dec2bin(num).length
+}
+
+function dec2bin(num) {
+  return (num >>> 0).toString(2)
+}

From 70f6ffef96ea19ac40d9ac625668fb92bf4884df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jan 2021 13:36:39 +0800
Subject: [PATCH 1033/3374] Create
 1712-ways-to-split-array-into-three-subarrays.js

---
 ...ays-to-split-array-into-three-subarrays.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1712-ways-to-split-array-into-three-subarrays.js

diff --git a/1712-ways-to-split-array-into-three-subarrays.js b/1712-ways-to-split-array-into-three-subarrays.js
new file mode 100644
index 00000000..efc11d66
--- /dev/null
+++ b/1712-ways-to-split-array-into-three-subarrays.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const waysToSplit = function (nums) {
+  const N = nums.length
+  let ret = 0
+  const presum = Array(N + 1).fill(0)
+  for (let i = 0; i < N; i++) presum[i + 1] = presum[i] + nums[i]
+  let avg = (presum[N] / 3 + 1) >> 0
+  for (let l = 1, r = 2, rr = 2; l < N - 1; l++) {
+    if (presum[l] > avg) break
+    while (r < N && presum[l] > presum[r] - presum[l]) r++
+    r = Math.max(r, l + 1)
+    if (r > rr) rr = r
+    while (rr < N && presum[N] - presum[rr] >= presum[rr] - presum[l]) rr++
+    ret += rr - r
+    if (ret >= 1000000007) ret -= 1000000007
+  }
+  return ret
+}

From 63f0bf138c2781117ae313dd34fd9f84b97efec7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jan 2021 14:28:38 +0800
Subject: [PATCH 1034/3374] Create
 1713-minimum-operations-to-make-a-subsequence.js

---
 ...inimum-operations-to-make-a-subsequence.js | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1713-minimum-operations-to-make-a-subsequence.js

diff --git a/1713-minimum-operations-to-make-a-subsequence.js b/1713-minimum-operations-to-make-a-subsequence.js
new file mode 100644
index 00000000..33b4ee94
--- /dev/null
+++ b/1713-minimum-operations-to-make-a-subsequence.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} target
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minOperations = function (target, arr) {
+  let length1 = target.length,
+    length2 = arr.length
+  const targetMap = new Map()
+  for (let i = 0; i < length1; i++) targetMap.set(target[i], i)
+  const list = new Array()
+  for (let i = 0; i < length2; i++) {
+    let num = arr[i]
+    if (targetMap.has(num)) list.push(targetMap.get(num))
+  }
+  let longestIncreasing = lengthOfLIS(list)
+  return target.length - longestIncreasing
+
+  function lengthOfLIS(list) {
+    let length = 1,
+      size = list.length
+    if (size == 0) return 0
+    const d = new Array(size + 1).fill(0)
+    d[length] = list[0]
+    for (let i = 1; i < size; ++i) {
+      if (list[i] > d[length]) {
+        d[++length] = list[i]
+      } else {
+        let left = 1,
+          right = length,
+          pos = 0
+        while (left <= right) {
+          let mid = (left + right) >> 1
+          if (d[mid] < list[i]) {
+            pos = mid
+            left = mid + 1
+          } else {
+            right = mid - 1
+          }
+        }
+        d[pos + 1] = list[i]
+      }
+    }
+    return length
+  }
+}

From ab14fe31fcd93cc1eddc5d8977503bc26eea32c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jan 2021 19:54:08 +0800
Subject: [PATCH 1035/3374] Update
 452-minimum-number-of-arrows-to-burst-balloons.js

---
 ...inimum-number-of-arrows-to-burst-balloons.js | 17 ++++++++---------
 1 file changed, 8 insertions(+), 9 deletions(-)

diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
index bdc4ebda..c47b87fa 100644
--- a/452-minimum-number-of-arrows-to-burst-balloons.js
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -26,13 +26,12 @@ const findMinArrowShots = function(points) {
 const findMinArrowShots = function(points) {
   if(points == null || points.length === 0) return 0
   points.sort((a, b) => a[1] - b[1])
-  let ans = 1
-  let lastX = points[0][1]
-  for (let i = 1; i < points.length; i++) {
-    if(points[i][0] <= lastX) continue
-    ans++
-    lastX = points[i][1]
+  let end = points[0][1], res = 1
+  for(let i = 1, len = points.length; i < len; i++) {
+    if(points[i][0] > end) {
+      end = points[i][1]
+      res++
+    }
   }
-  return ans
-}
-
+  return res
+};

From 979d709ffb756cb15f83f95d4868f9e8b53ee7eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Jan 2021 12:22:18 +0800
Subject: [PATCH 1036/3374] Create 1709-biggest-window-between-visits.sql

---
 1709-biggest-window-between-visits.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1709-biggest-window-between-visits.sql

diff --git a/1709-biggest-window-between-visits.sql b/1709-biggest-window-between-visits.sql
new file mode 100644
index 00000000..e5fb7829
--- /dev/null
+++ b/1709-biggest-window-between-visits.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+SELECT user_id, MAX(diff) AS biggest_window
+FROM
+(
+	SELECT user_id, 
+	   DATEDIFF(COALESCE(LEAD(visit_date) OVER (PARTITION BY user_id ORDER BY visit_date), '2021-01-01'), visit_date) AS diff
+	FROM userVisits
+) a
+GROUP BY user_id
+ORDER BY user_id;

From c141a2b1b3d8e4c6914db78d38781cb93c4fe9ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Jan 2021 20:36:25 +0800
Subject: [PATCH 1037/3374] Update
 1712-ways-to-split-array-into-three-subarrays.js

---
 1712-ways-to-split-array-into-three-subarrays.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/1712-ways-to-split-array-into-three-subarrays.js b/1712-ways-to-split-array-into-three-subarrays.js
index efc11d66..e1c4c3f7 100644
--- a/1712-ways-to-split-array-into-three-subarrays.js
+++ b/1712-ways-to-split-array-into-three-subarrays.js
@@ -5,17 +5,17 @@
 const waysToSplit = function (nums) {
   const N = nums.length
   let ret = 0
-  const presum = Array(N + 1).fill(0)
+  const presum = Array(N + 1).fill(0), MOD = 10 ** 9 + 7
   for (let i = 0; i < N; i++) presum[i + 1] = presum[i] + nums[i]
   let avg = (presum[N] / 3 + 1) >> 0
-  for (let l = 1, r = 2, rr = 2; l < N - 1; l++) {
+  for (let l = 1, m = 2, r = 2; l < N - 1; l++) {
     if (presum[l] > avg) break
-    while (r < N && presum[l] > presum[r] - presum[l]) r++
-    r = Math.max(r, l + 1)
-    if (r > rr) rr = r
-    while (rr < N && presum[N] - presum[rr] >= presum[rr] - presum[l]) rr++
-    ret += rr - r
-    if (ret >= 1000000007) ret -= 1000000007
+    while (m < N && presum[l] > presum[m] - presum[l]) m++
+    m = Math.max(m, l + 1)
+    if (m > r) r = m
+    while (r < N && presum[N] - presum[r] >= presum[r] - presum[l]) r++
+    ret += r - m
+    if (ret >= MOD) ret -= MOD
   }
   return ret
 }

From ee59110975c7b0002c4388db804a99274d141092 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Jan 2021 10:54:15 +0800
Subject: [PATCH 1038/3374] Update
 1713-minimum-operations-to-make-a-subsequence.js

---
 ...inimum-operations-to-make-a-subsequence.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1713-minimum-operations-to-make-a-subsequence.js b/1713-minimum-operations-to-make-a-subsequence.js
index 33b4ee94..8e751863 100644
--- a/1713-minimum-operations-to-make-a-subsequence.js
+++ b/1713-minimum-operations-to-make-a-subsequence.js
@@ -44,3 +44,34 @@ const minOperations = function (target, arr) {
     return length
   }
 }
+
+// another
+
+/**
+ * @param {number[]} target
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minOperations = function(target, arr) {
+  const map = new Map()
+  for(let i = 0, len = target.length; i < len; i++) {
+    map.set(target[i], i)
+  }
+  const stack = []
+  for(let a of arr) {
+    if(!map.has(a)) continue
+    if(stack.length === 0 || map.get(a) > stack[stack.length - 1]) {
+      stack.push(map.get(a))
+      continue
+    }
+    let left = 0, right = stack.length - 1, mid
+    while(left < right) {
+      mid = left + ((right - left) >> 1)
+      if(stack[mid] < map.get(a)) left = mid + 1
+      else right = mid
+    }
+    stack[left] = map.get(a)
+  }
+
+  return target.length - stack.length
+};

From 8d74abef2b2d19aa0362f777db2afd0fbaa25626 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Jan 2021 14:46:29 +0800
Subject: [PATCH 1039/3374] Update 300-longest-increasing-subsequence.js

---
 300-longest-increasing-subsequence.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/300-longest-increasing-subsequence.js b/300-longest-increasing-subsequence.js
index 830ef698..de06b45e 100644
--- a/300-longest-increasing-subsequence.js
+++ b/300-longest-increasing-subsequence.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const lengthOfLIS = function(nums) {
+  const stack = [], n = nums.length
+  for(let e of nums) {
+    if(stack.length === 0 || e > stack[stack.length - 1]) {
+      stack.push(e)
+      continue
+    }
+    let l = 0, r = stack.length - 1, mid
+    while(l < r) {
+      const mid = l + ((r - l) >> 1)
+      if(e > stack[mid]) l = mid + 1
+      else r = mid
+    }
+    stack[l] = e
+  }
+  return stack.length
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 43ca0dc93bf20e0b257fd19106412fdc519f8524 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Jan 2021 14:50:14 +0800
Subject: [PATCH 1040/3374] Update 300-longest-increasing-subsequence.js

---
 300-longest-increasing-subsequence.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/300-longest-increasing-subsequence.js b/300-longest-increasing-subsequence.js
index de06b45e..196f7ba3 100644
--- a/300-longest-increasing-subsequence.js
+++ b/300-longest-increasing-subsequence.js
@@ -3,7 +3,7 @@
  * @return {number}
  */
 const lengthOfLIS = function(nums) {
-  const stack = [], n = nums.length
+  const stack = []
   for(let e of nums) {
     if(stack.length === 0 || e > stack[stack.length - 1]) {
       stack.push(e)

From 22a8cc311cce371fc61805ca47535c24b8b863af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Jan 2021 10:26:41 +0800
Subject: [PATCH 1041/3374] Update 955-delete-columns-to-make-sorted-ii.js

---
 955-delete-columns-to-make-sorted-ii.js | 53 +++++++++++++++----------
 1 file changed, 31 insertions(+), 22 deletions(-)

diff --git a/955-delete-columns-to-make-sorted-ii.js b/955-delete-columns-to-make-sorted-ii.js
index 8c87fc56..a54c72cb 100644
--- a/955-delete-columns-to-make-sorted-ii.js
+++ b/955-delete-columns-to-make-sorted-ii.js
@@ -2,27 +2,36 @@
  * @param {string[]} A
  * @return {number}
  */
-const minDeletionSize = function(A) {
-    let res = 0, n = A.length, m = A[0].length, i, j; //n: 有多少个字符串，对应i.  m:每个字符串的长度,对应j
-    let sorted = new Array(n - 1).fill(false);
-    for (j = 0; j < m; ++j) { //从第一个字符到最后一个字符
-        for (i = 0; i < n - 1; ++i) { //i从第一个字到最后一个字
-            if (!sorted[i] && A[i].charAt(j) > A[i + 1].charAt(j)) {
-                res++;
-                break;
-            }
-        }
-        if (i < n - 1) continue;
+const minDeletionSize = function (A) {
+  let res = 0,
+    i,
+    j //n: 有多少个字符串，对应i.  m:每个字符串的长度,对应j
+  const n = A.length,
+    m = A[0].length,
+    sorted = new Array(n - 1).fill(false)
+  for (j = 0; j < m; ++j) {
+    //从第一个字符到最后一个字符
+    for (i = 0; i < n - 1; ++i) {
+      //i从第一个字到最后一个字
+      if (!sorted[i] && A[i].charAt(j) > A[i + 1].charAt(j)) {
+        res++
+        break
+      }
+    }
+    if (i < n - 1) continue
 
-        //假设输入是["xgag","xfba","yfac"]
-        //那么第一轮j=0,比较第一列: x=x<y，合理，所以此时res=0，然后运行了下面的循环， 可以使得sorted[xfb] = true;
-        //然后第二轮j=1,第二列g>f,进入if条件语句，所以res = 1, break
-        //然后第三轮j=2,a<b>a,这里b虽然>a，但是由于sorted[xfb] = true，所以不会进入到上面的循环体，然后sorted[xga] = true
-        //然后第四轮j=3,这一轮已经不再重要，因为通过前面几轮 sorted[0] = true， sorted[1] = true, 这意味着已经实现了排序，所以res最终结果就是1
+    //假设输入是["xgag","xfba","yfac"]
+    //那么第一轮j=0,比较第一列: x=x<y，合理，所以此时res=0，然后运行了下面的循环， 可以使得sorted[xfb] = true;
+    //然后第二轮j=1,第二列g>f,进入if条件语句，所以res = 1, break
+    //然后第三轮j=2,a<b>a,这里b虽然>a，但是由于sorted[xfb] = true，所以不会进入到上面的循环体，然后sorted[xga] = true
+    //然后第四轮j=3,这一轮已经不再重要，因为通过前面几轮 sorted[0] = true， sorted[1] = true, 这意味着已经实现了排序，所以res最终结果就是1
 
-        for (i = 0; i < n - 1; ++i) //这一段代码结合最外面的循环可以用作比较string大小的通用代码
-            if (A[i].charAt(j) < A[i + 1].charAt(j))
-                sorted[i] = true;
-    }
-    return res;
-};
+    for (
+      i = 0;
+      i < n - 1;
+      ++i //这一段代码结合最外面的循环可以用作比较string大小的通用代码
+    )
+      if (A[i].charAt(j) < A[i + 1].charAt(j)) sorted[i] = true
+  }
+  return res
+}

From 3c22095b4386c285d26a5b7f089373cf7bb569d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Jan 2021 11:31:16 +0800
Subject: [PATCH 1042/3374] Update 955-delete-columns-to-make-sorted-ii.js

---
 955-delete-columns-to-make-sorted-ii.js | 30 +++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/955-delete-columns-to-make-sorted-ii.js b/955-delete-columns-to-make-sorted-ii.js
index a54c72cb..0a9b4f52 100644
--- a/955-delete-columns-to-make-sorted-ii.js
+++ b/955-delete-columns-to-make-sorted-ii.js
@@ -35,3 +35,33 @@ const minDeletionSize = function (A) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {string[]} A
+ * @return {number}
+ */
+const minDeletionSize = function (A) {
+  const set = new Set()
+  const m = A.length
+  let res = 0
+  if(m === 0) return 0
+  const n = A[0].length
+  for(j = 0; j < n; j++) {
+    if(set.size === m - 1) return res
+    for(i = 0; i < m - 1; i++) {
+      if(!set.has(i) && A[i][j] > A[i + 1][j]) {
+        res++
+        break
+      }
+    }
+    if(i < m - 1) continue
+    for(i = 0; i < m - 1; i++) {
+      if(A[i][j] < A[i + 1][j]) set.add(i)
+    }
+  }
+  
+  return res
+}
+

From eea9384f20de55608c36567708015238e88911cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Jan 2021 23:10:48 +0800
Subject: [PATCH 1043/3374] Update 646-maximum-length-of-pair-chain.js

---
 646-maximum-length-of-pair-chain.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/646-maximum-length-of-pair-chain.js b/646-maximum-length-of-pair-chain.js
index 39a7e71e..8e596d99 100755
--- a/646-maximum-length-of-pair-chain.js
+++ b/646-maximum-length-of-pair-chain.js
@@ -14,3 +14,25 @@ const findLongestChain = function(pairs) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+const findLongestChain = function (pairs) {
+  pairs.sort((a, b) => a[0] - b[0])
+  let out = 0
+  let prevEnd = Number.MIN_SAFE_INTEGER
+  for (let i = 0; i < pairs.length; i++) {
+    const cur = pairs[i]
+    if (prevEnd < cur[0]) {
+      prevEnd = cur[1]
+      out += 1
+    } else {
+      prevEnd = Math.min(cur[1], prevEnd)
+    }
+  }
+  return out
+}

From a8f32e4a2f37e3a71ee019bae517d2cd14b6c52f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Jan 2021 18:54:38 +0800
Subject: [PATCH 1044/3374] Update 757-set-intersection-size-at-least-two.js

---
 757-set-intersection-size-at-least-two.js | 29 +++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/757-set-intersection-size-at-least-two.js b/757-set-intersection-size-at-least-two.js
index 6f7b7eea..c89077ec 100644
--- a/757-set-intersection-size-at-least-two.js
+++ b/757-set-intersection-size-at-least-two.js
@@ -52,3 +52,32 @@ const intersectionSizeTwo = function(intervals) {
   }
   return count;
 };
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const intersectionSizeTwo = function (intervals) {
+  if (intervals.length === 1) return 2
+  intervals.sort((a, b) => (a[1] !== b[1] ? a[1] - b[1] : b[0] - a[0]))
+  let right = intervals[0][1]
+  let left = right - 1
+  let result = 2
+  for (let i = 1, len = intervals.length; i < len; i++) {
+    const curr = intervals[i]
+    if (curr[0] <= right && curr[0] > left) {
+      result++
+      left = right
+      right = curr[1]
+    } else if (curr[0] > right) {
+      result += 2
+      left = curr[1] - 1
+      right = curr[1]
+    }
+  }
+
+  return result
+}
+

From 1aef6f7dc2eaf0b08fcb2b9d63fc76ab446262ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Jan 2021 20:24:02 +0800
Subject: [PATCH 1045/3374] Update 646-maximum-length-of-pair-chain.js

---
 646-maximum-length-of-pair-chain.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/646-maximum-length-of-pair-chain.js b/646-maximum-length-of-pair-chain.js
index 8e596d99..ec50ac9d 100755
--- a/646-maximum-length-of-pair-chain.js
+++ b/646-maximum-length-of-pair-chain.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+const findLongestChain = function(pairs) {
+  pairs.sort((a, b) => a[1] - b[1])
+  let end = pairs[0][1], res = 1
+  for(let i = 1, len = pairs.length; i < len; i++) {
+    if(pairs[i][0] > end) {
+      res++
+      end = pairs[i][1]
+    }    
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} pairs
  * @return {number}

From 4cb660387f8567656e6b3560227f3b6d5753beab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 00:10:03 +0800
Subject: [PATCH 1046/3374] Create
 1717-maximum-score-from-removing-substrings.js

---
 ...-maximum-score-from-removing-substrings.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1717-maximum-score-from-removing-substrings.js

diff --git a/1717-maximum-score-from-removing-substrings.js b/1717-maximum-score-from-removing-substrings.js
new file mode 100644
index 00000000..f640d626
--- /dev/null
+++ b/1717-maximum-score-from-removing-substrings.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const maximumGain = function (s, x, y) {
+  return Math.max(go(s, x, y, 'a', 'b'), go(s, y, x, 'b', 'a'))
+}
+
+function go(s, x, y, a, b) {
+  let n = s.length
+  const st = new Array(n)
+  let sc = 0
+  let p = 0
+  for (let c of s) {
+    if (p - 1 >= 0 && st[p - 1] == a && c == b) {
+      sc += x
+      p--
+    } else {
+      st[p++] = c
+    }
+  }
+  const st2 = new Array(p)
+  let q = 0
+  for (let u = 0; u < p; u++) {
+    let c = st[u]
+    if (q - 1 >= 0 && st2[q - 1] == b && c == a) {
+      sc += y
+      q--
+    } else {
+      st2[q++] = c
+    }
+  }
+  return sc
+}

From c2fd3c704ce8731bed7a8622e09d7eb00bc0b609 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 13:21:32 +0800
Subject: [PATCH 1047/3374] Create 1720-decode-xored-array.js

---
 1720-decode-xored-array.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1720-decode-xored-array.js

diff --git a/1720-decode-xored-array.js b/1720-decode-xored-array.js
new file mode 100644
index 00000000..cc368464
--- /dev/null
+++ b/1720-decode-xored-array.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} encoded
+ * @param {number} first
+ * @return {number[]}
+ */
+const decode = function(encoded, first) {
+  const res = [first]
+  
+  for(let i = 0, len = encoded.length; i < len; i++) {
+    res[i + 1] = res[i] ^ encoded[i]
+  }
+  
+  return res
+};

From b0ba108cba8b9c73b5d842433d6f3f9e91bccd13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 13:22:09 +0800
Subject: [PATCH 1048/3374] Create 1721-swapping-nodes-in-a-linked-list.js

---
 1721-swapping-nodes-in-a-linked-list.js | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1721-swapping-nodes-in-a-linked-list.js

diff --git a/1721-swapping-nodes-in-a-linked-list.js b/1721-swapping-nodes-in-a-linked-list.js
new file mode 100644
index 00000000..a5cffbd4
--- /dev/null
+++ b/1721-swapping-nodes-in-a-linked-list.js
@@ -0,0 +1,40 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+const swapNodes = function(head, k) {
+  const dummy = new ListNode()
+  dummy.next = head
+  const arr = []
+  let cur = head
+  while(cur) {
+    arr.push(cur)
+    cur = cur.next
+  }
+  const n = arr.length
+  if(k < 1 || k > n) return dummy.next
+  let first = arr[k - 1], second = arr[n - k]
+  
+  arr[k - 1] = second
+  arr[n - k] = first
+    
+  dummy.next = arr[0]
+  let pre = arr[0]
+  for(let i = 1, len = arr.length; i < len; i++) {
+     const tmp = arr[i]
+     pre.next = tmp
+     pre = tmp
+  }
+  
+  pre.next = null
+ 
+  return dummy.next
+};

From 4802f4d5adf694243e361c28abcc049df98cd68e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 13:22:51 +0800
Subject: [PATCH 1049/3374] Create
 1722-minimize-hamming-distance-after-swap-operations.js

---
 ...-hamming-distance-after-swap-operations.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 1722-minimize-hamming-distance-after-swap-operations.js

diff --git a/1722-minimize-hamming-distance-after-swap-operations.js b/1722-minimize-hamming-distance-after-swap-operations.js
new file mode 100644
index 00000000..884e1868
--- /dev/null
+++ b/1722-minimize-hamming-distance-after-swap-operations.js
@@ -0,0 +1,63 @@
+class UnionFind {
+  constructor(n) {
+    this.parents = Array(n)
+      .fill(0)
+      .map((e, i) => i)
+    this.ranks = Array(n).fill(0)
+  }
+  root(x) {
+    while (x !== this.parents[x]) {
+      this.parents[x] = this.parents[this.parents[x]]
+      x = this.parents[x]
+    }
+    return x
+  }
+  find(x) {
+    return this.root(x)
+  }
+  check(x, y) {
+    return this.root(x) === this.root(y)
+  }
+  union(x, y) {
+    const [rx, ry] = [this.find(x), this.find(y)]
+    if (this.ranks[rx] >= this.ranks[ry]) {
+      this.parents[ry] = rx
+      this.ranks[rx] += this.ranks[ry]
+    } else if (this.ranks[ry] > this.ranks[rx]) {
+      this.parents[rx] = ry
+      this.ranks[ry] += this.ranks[rx]
+    }
+  }
+}
+/**
+ * @param {number[]} source
+ * @param {number[]} target
+ * @param {number[][]} allowedSwaps
+ * @return {number}
+ */
+const minimumHammingDistance = function (source, target, allowedSwaps) {
+  let n = target.length
+  const u = new UnionFind(n)
+  for (let A of allowedSwaps) {
+    let i = A[0],
+      j = A[1]
+    u.union(i, j)
+  }
+  const M = {}
+  for (let i = 0; i < n; i++) {
+    let j = u.find(i)
+    if (M[j] == null) M[j] = {}
+    if (M[j][source[i]] == null) M[j][source[i]] = 0
+    M[j][source[i]]++
+  }
+  let rest = 0
+  for (let i = 0; i < n; i++) {
+    let j = u.find(i)
+    if (M[j][target[i]]) {
+      if (!--M[j][target[i]]) {
+        delete M[j][target[i]]
+      }
+    } else rest++
+  }
+  return rest
+}

From f5cfd100831782633a4c0373839efa445fab6cdc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 13:23:25 +0800
Subject: [PATCH 1050/3374] Create 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 47 ++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 1723-find-minimum-time-to-finish-all-jobs.js

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
new file mode 100644
index 00000000..4a61666c
--- /dev/null
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} jobs
+ * @param {number} k
+ * @return {number}
+ */
+const minimumTimeRequired = function (jobs, k) {
+  if (jobs.length <= k) {
+    return Math.max(...jobs)
+  }
+
+  // create a store to hold the number of hours each worker worked
+  const workers = new Array(k).fill(0)
+
+  let minLongestWorkingTime = Infinity
+  const dfs = (i) => {
+    if (i === jobs.length) {
+      // if we assigned all the jobs, see if we have a better result
+      minLongestWorkingTime = Math.min(
+        minLongestWorkingTime,
+        Math.max(...workers)
+      )
+      return
+    }
+    const lengthOfWork = jobs[i]
+
+    for (let worker = 0; worker < k; worker++) {
+      workers[worker] += lengthOfWork
+
+      // if this combination is has a chance of decreasing our
+      // answer, try it, otherwise skip it to save on time.
+      if (workers[worker] <= minLongestWorkingTime) {
+        dfs(i + 1)
+      }
+      workers[worker] -= lengthOfWork
+
+      // We want to minimize the width of the tree
+      // so if the worker has gotten their first job
+      // don't try any workers after this worker.
+      // All other workers after this worker will be 0 as well
+      // so the combination is exactly the same.
+      if (workers[worker] === 0) break
+    }
+  }
+
+  dfs(0)
+  return minLongestWorkingTime
+}

From b620621f9f79071cfd32fe21250340099fa4e64a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 13:44:48 +0800
Subject: [PATCH 1051/3374] Create 1716-calculate-money-in-leetcode-bank.js

---
 1716-calculate-money-in-leetcode-bank.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1716-calculate-money-in-leetcode-bank.js

diff --git a/1716-calculate-money-in-leetcode-bank.js b/1716-calculate-money-in-leetcode-bank.js
new file mode 100644
index 00000000..ecc5700c
--- /dev/null
+++ b/1716-calculate-money-in-leetcode-bank.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const totalMoney = function(n) {
+    let total = 0
+    for(let i = 0 ; i < n; i++) {
+      const base = (i / 7) >> 0
+      const remain = i % 7 + 1
+      total += base + remain
+    }
+
+    return total
+};

From 260420cd0e55b2a30a7ff6bac3618fb247844a79 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 20:48:58 +0800
Subject: [PATCH 1052/3374] Update 1235-maximum-profit-in-job-scheduling.js

---
 1235-maximum-profit-in-job-scheduling.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1235-maximum-profit-in-job-scheduling.js b/1235-maximum-profit-in-job-scheduling.js
index c49c1a56..86f79e29 100644
--- a/1235-maximum-profit-in-job-scheduling.js
+++ b/1235-maximum-profit-in-job-scheduling.js
@@ -19,7 +19,7 @@ const jobScheduling = function (startTime, endTime, profit) {
       e = item[1],
       p = item[2]
     // find previous endTime index
-    let prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s)
+    const prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s)
     const currProfit = dpProfit[prevIdx] + p,
       maxProfit = dpProfit[dpProfit.length - 1]
     if (currProfit > maxProfit) {

From 1716e25c62151f057135cb393c2a568f02e7e5bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 21:12:59 +0800
Subject: [PATCH 1053/3374] Update 1235-maximum-profit-in-job-scheduling.js

---
 1235-maximum-profit-in-job-scheduling.js | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1235-maximum-profit-in-job-scheduling.js b/1235-maximum-profit-in-job-scheduling.js
index 86f79e29..5870bc35 100644
--- a/1235-maximum-profit-in-job-scheduling.js
+++ b/1235-maximum-profit-in-job-scheduling.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} startTime
+ * @param {number[]} endTime
+ * @param {number[]} profit
+ * @return {number}
+ */
+const jobScheduling = function (startTime, endTime, profit) {
+  const n = startTime.length
+  const items = Array.from({ length: startTime.length }, () => Array(3).fill(0))
+  for (let i = 0; i < startTime.length; i++) {
+    items[i] = [startTime[i], endTime[i], profit[i]]
+  }
+  items.sort((a1, a2) => a1[1] - a2[1])
+  const dpProfit = [0]
+  for (let i = 0; i < n; i++) {
+    const [s, e, p] = items[i]
+    let prevIdx = -1
+    for(let j = i - 1; j >= 0; j--) {
+      if(items[j][1] <= items[i][0]) {
+        prevIdx = j
+        break
+      }
+    }
+    const curProfit = (prevIdx === -1 ? 0 : dpProfit[prevIdx]) + p
+    dpProfit[i] = Math.max(dpProfit[dpProfit.length - 1], curProfit)
+  }
+  return dpProfit[dpProfit.length - 1]
+}
+
+
+// another
+
+
 /**
  * @param {number[]} startTime
  * @param {number[]} endTime

From b80cc29f0a95d5a8552e76f888d5e940c0c25b98 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jan 2021 22:26:00 +0800
Subject: [PATCH 1054/3374] Create
 1718-construct-the-lexicographically-largest-valid-sequence.js

---
 ...exicographically-largest-valid-sequence.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1718-construct-the-lexicographically-largest-valid-sequence.js

diff --git a/1718-construct-the-lexicographically-largest-valid-sequence.js b/1718-construct-the-lexicographically-largest-valid-sequence.js
new file mode 100644
index 00000000..bba16bfc
--- /dev/null
+++ b/1718-construct-the-lexicographically-largest-valid-sequence.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const constructDistancedSequence = function(n) {
+  const ans = Array(2 * n - 1).fill(0)
+  const used = Array(n + 1).fill(0)
+  dfs(ans, 0)
+  return ans
+    
+  function dfs(ans, i) {
+    if(i === ans.length) return true
+    if(ans[i]) return dfs(ans, i + 1)
+    for(let j = used.length - 1; j > 0; j--) {
+      if(used[j]) continue
+      if(j !== 1 && (i + j >= ans.length || ans[i + j])) continue
+      used[j] = 1
+      ans[i] = j
+      if(j !== 1) ans[i + j] = j
+      if(dfs(ans, i + 1)) return true
+      ans[i] = 0
+      if(j !== 1) ans[i + j] = 0
+      used[j] = 0
+    }
+    return false
+  }
+};

From 0ab91e265e48406d6e48c335742e0a26717c703c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Jan 2021 22:26:11 +0800
Subject: [PATCH 1055/3374] Update
 1717-maximum-score-from-removing-substrings.js

---
 1717-maximum-score-from-removing-substrings.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1717-maximum-score-from-removing-substrings.js b/1717-maximum-score-from-removing-substrings.js
index f640d626..3462cdab 100644
--- a/1717-maximum-score-from-removing-substrings.js
+++ b/1717-maximum-score-from-removing-substrings.js
@@ -9,12 +9,12 @@ const maximumGain = function (s, x, y) {
 }
 
 function go(s, x, y, a, b) {
-  let n = s.length
+  const n = s.length
   const st = new Array(n)
   let sc = 0
   let p = 0
   for (let c of s) {
-    if (p - 1 >= 0 && st[p - 1] == a && c == b) {
+    if (p - 1 >= 0 && st[p - 1] === a && c === b) {
       sc += x
       p--
     } else {
@@ -25,7 +25,7 @@ function go(s, x, y, a, b) {
   let q = 0
   for (let u = 0; u < p; u++) {
     let c = st[u]
-    if (q - 1 >= 0 && st2[q - 1] == b && c == a) {
+    if (q - 1 >= 0 && st2[q - 1] === b && c === a) {
       sc += y
       q--
     } else {

From 1e32fbc89d465aafd01fe6bf28d9b836f54fddc6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Jan 2021 17:42:14 +0800
Subject: [PATCH 1056/3374] Update
 1717-maximum-score-from-removing-substrings.js

---
 ...-maximum-score-from-removing-substrings.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1717-maximum-score-from-removing-substrings.js b/1717-maximum-score-from-removing-substrings.js
index 3462cdab..63030915 100644
--- a/1717-maximum-score-from-removing-substrings.js
+++ b/1717-maximum-score-from-removing-substrings.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const maximumGain = function (s, x, y) {
+  let sb = s.split('')
+  if (x > y) {
+    return remove(sb, 'ab', x) + remove(sb, 'ba', y)
+  }
+  return remove(sb, 'ba', y) + remove(sb, 'ab', x)
+  function remove(sb, pattern, point) {
+    let i = 0,
+      res = 0
+    for (let j = 0; j < sb.length; j++) {
+      sb[i++] = sb[j]
+      if (
+        i > 1 &&
+        sb[i - 2] == pattern.charAt(0) &&
+        sb[i - 1] == pattern.charAt(1)
+      ) {
+        i -= 2
+        res += point
+      }
+    }
+    sb.splice(i)
+    return res
+  }
+}
+
+// another
+
 /**
  * @param {string} s
  * @param {number} x

From 8d648f7c612b2fa69c22f5065c3cdea9fa7d7968 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Jan 2021 19:45:45 +0800
Subject: [PATCH 1057/3374] Update
 1722-minimize-hamming-distance-after-swap-operations.js

---
 ...e-hamming-distance-after-swap-operations.js | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/1722-minimize-hamming-distance-after-swap-operations.js b/1722-minimize-hamming-distance-after-swap-operations.js
index 884e1868..e6349eec 100644
--- a/1722-minimize-hamming-distance-after-swap-operations.js
+++ b/1722-minimize-hamming-distance-after-swap-operations.js
@@ -36,28 +36,28 @@ class UnionFind {
  * @return {number}
  */
 const minimumHammingDistance = function (source, target, allowedSwaps) {
-  let n = target.length
-  const u = new UnionFind(n)
+  const n = target.length
+  const uf = new UnionFind(n)
   for (let A of allowedSwaps) {
-    let i = A[0],
+    const i = A[0],
       j = A[1]
-    u.union(i, j)
+    uf.union(i, j)
   }
   const M = {}
   for (let i = 0; i < n; i++) {
-    let j = u.find(i)
+    const j = uf.find(i)
     if (M[j] == null) M[j] = {}
     if (M[j][source[i]] == null) M[j][source[i]] = 0
     M[j][source[i]]++
   }
-  let rest = 0
+  let res = 0
   for (let i = 0; i < n; i++) {
-    let j = u.find(i)
+    const j = uf.find(i)
     if (M[j][target[i]]) {
       if (!--M[j][target[i]]) {
         delete M[j][target[i]]
       }
-    } else rest++
+    } else res++
   }
-  return rest
+  return res
 }

From 4244fc3131b55cb34cf2f548aae4e8f92f83b8e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Jan 2021 21:27:14 +0800
Subject: [PATCH 1058/3374] Create 1719-number-of-ways-to-reconstruct-a-tree.js

---
 1719-number-of-ways-to-reconstruct-a-tree.js | 132 +++++++++++++++++++
 1 file changed, 132 insertions(+)
 create mode 100644 1719-number-of-ways-to-reconstruct-a-tree.js

diff --git a/1719-number-of-ways-to-reconstruct-a-tree.js b/1719-number-of-ways-to-reconstruct-a-tree.js
new file mode 100644
index 00000000..2b7e8d6e
--- /dev/null
+++ b/1719-number-of-ways-to-reconstruct-a-tree.js
@@ -0,0 +1,132 @@
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+const checkWays = function (pairs) {
+  const adj = {}
+  for (let i = 0; i < pairs.length; i++) {
+    if (adj[pairs[i][0]] == null) adj[pairs[i][0]] = new Set()
+    if (adj[pairs[i][1]] == null) adj[pairs[i][1]] = new Set()
+    adj[pairs[i][0]].add(pairs[i][1])
+    adj[pairs[i][1]].add(pairs[i][0])
+  }
+
+  const q = new PriorityQueue((a, b) => a[0] < b[0])
+  Object.keys(adj).forEach((k) => {
+    q.push([-adj[k].size, +k])
+  })
+
+  const n = q.size()
+  let multiple = false
+  const seen = new Set()
+  while (!q.isEmpty()) {
+    let [sz, v] = q.peek()
+    q.pop()
+    sz = -sz
+    let u = 0
+    let usz = n + 1
+    if (seen.size) {
+      for (let x of adj[v]) {
+        if (adj[x].size < usz && seen.has(x)) {
+          u = x
+          usz = adj[x].size
+        }
+      }
+    }
+
+    seen.add(v)
+    if (u === 0) {
+      if (sz !== n - 1) {
+        return 0
+      }
+      continue
+    }
+
+    for (let x of adj[v]) {
+      if (x == u) {
+        continue
+      }
+
+      if (!adj[u].has(x)) {
+        return 0
+      }
+    }
+
+    if (usz == sz) {
+      multiple = true
+    }
+  }
+
+  if (multiple) {
+    return 2
+  }
+
+  return 1
+}

From 950c332bb8917a7d091a5f83b5829a10cb4b47b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Jan 2021 16:54:58 +0800
Subject: [PATCH 1059/3374] Create 1683-invalid-tweets.sql

---
 1683-invalid-tweets.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1683-invalid-tweets.sql

diff --git a/1683-invalid-tweets.sql b/1683-invalid-tweets.sql
new file mode 100644
index 00000000..04f5bbc4
--- /dev/null
+++ b/1683-invalid-tweets.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT tweet_id
+FROM Tweets
+WHERE CHAR_LENGTH(content) > 15;

From f64ab321aa30a1d93cc301d45ce5bc2f4a1e4022 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Jan 2021 22:43:19 +0800
Subject: [PATCH 1060/3374] Update 1146-snapshot-array.js

---
 1146-snapshot-array.js | 71 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)

diff --git a/1146-snapshot-array.js b/1146-snapshot-array.js
index 356b41dd..31164a7e 100644
--- a/1146-snapshot-array.js
+++ b/1146-snapshot-array.js
@@ -1,3 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const binarySearch = function (nums, target, comparator) {
+  let low = 0;
+  let high = nums.length - 1;
+  while (low <= high) {
+    let mid = low + ((high - low) >>> 1);
+    let midValue = nums[mid];
+    let cmp = comparator(midValue, target);
+    if (cmp < 0) low = mid + 1;
+    else if (cmp > 0) high = mid - 1;
+    else return mid;
+  }
+  return -(low + 1);
+};
+
+/**
+ * @param {number} length
+ */
+const SnapshotArray = function (length) {
+  this.count = 0;
+  this.arr = Array.from({ length: length }, () => [[0, 0]]);
+};
+
+/**
+ * @param {number} index
+ * @param {number} val
+ * @return {void}
+ */
+SnapshotArray.prototype.set = function (index, val) {
+  const arr = this.arr,
+    count = this.count;
+  if (arr[index][arr[index].length - 1][0] === count) {
+    arr[index][arr[index].length - 1][1] = val;
+  } else {
+    arr[index].push([count, val]);
+  }
+};
+
+/**
+ * @return {number}
+ */
+SnapshotArray.prototype.snap = function () {
+  return this.count++;
+};
+
+/**
+ * @param {number} index
+ * @param {number} snap_id
+ * @return {number}
+ */
+SnapshotArray.prototype.get = function (index, snap_id) {
+  let idx = binarySearch(this.arr[index], [snap_id, 0], (a, b) => a[0] - b[0]);
+  if (idx < 0) idx = -idx - 2;
+  return this.arr[index][idx][1];
+};
+
+/**
+ * Your SnapshotArray object will be instantiated and called as such:
+ * var obj = new SnapshotArray(length)
+ * obj.set(index,val)
+ * var param_2 = obj.snap()
+ * var param_3 = obj.get(index,snap_id)
+ */
+
+
+// another
+
 /**
  * @param {number} length
  */

From 676539c64396dd2a02b59c0ddd4ea99114ef5a71 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Jan 2021 23:22:25 +0800
Subject: [PATCH 1061/3374] Create 1693-daily-leads-and-partners.sql

---
 1693-daily-leads-and-partners.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1693-daily-leads-and-partners.sql

diff --git a/1693-daily-leads-and-partners.sql b/1693-daily-leads-and-partners.sql
new file mode 100644
index 00000000..7daf685b
--- /dev/null
+++ b/1693-daily-leads-and-partners.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT date_id, make_name, COUNT(DISTINCT lead_id) AS unique_leads, COUNT(DISTINCT partner_id) AS unique_partners
+FROM DailySales
+GROUP BY 1, 2;

From a02e736a64c4c538086fe4aaca9127619505889c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jan 2021 12:18:32 +0800
Subject: [PATCH 1062/3374] Create
 1727-largest-submatrix-with-rearrangements.js

---
 1727-largest-submatrix-with-rearrangements.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1727-largest-submatrix-with-rearrangements.js

diff --git a/1727-largest-submatrix-with-rearrangements.js b/1727-largest-submatrix-with-rearrangements.js
new file mode 100644
index 00000000..435fc7ce
--- /dev/null
+++ b/1727-largest-submatrix-with-rearrangements.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number}
+ */
+const largestSubmatrix = function(a) {
+ 		let n = a.length;
+		let m = a[0].length;
+		let count = Array(m).fill(0);
+		let result = 0;
+		for (let i = 0; i < n; ++i) {
+			for (let j = 0; j < m; ++j) {
+				count[j] = (a[i][j] ? count[j] + 1 : 0);
+			}
+			let b = count.slice();
+            b.sort((a, b) => a - b)
+			b = b.reverse()
+			for (let j = 0; j < m; ++j) {
+				result = Math.max(result, (j + 1) * b[j]);
+			}
+		}
+		return result;   
+};
+

From 5a55adefa3a3f570fed60091b2258058f1a8b5a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jan 2021 19:25:16 +0800
Subject: [PATCH 1063/3374] Create
 1725-number-of-rectangles-that-can-form-the-largest-square.js

---
 ...tangles-that-can-form-the-largest-square.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1725-number-of-rectangles-that-can-form-the-largest-square.js

diff --git a/1725-number-of-rectangles-that-can-form-the-largest-square.js b/1725-number-of-rectangles-that-can-form-the-largest-square.js
new file mode 100644
index 00000000..dcd7f73c
--- /dev/null
+++ b/1725-number-of-rectangles-that-can-form-the-largest-square.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[][]} rectangles
+ * @return {number}
+ */
+const countGoodRectangles = function(A) {
+  const arr = []
+  let max = 0
+  A.forEach(e => {
+    const tmp = Math.min(...e)
+    if(tmp > max) max=tmp
+    arr.push(tmp)
+  })
+  let res = 0
+  for(let e of arr) {
+    if(e >= max) res++
+  }
+  return res
+};

From d8b93eb57745372d6ceb84d50ae7b7f4e34679c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jan 2021 19:26:02 +0800
Subject: [PATCH 1064/3374] Create 1726-tuple-with-same-product.js

---
 1726-tuple-with-same-product.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1726-tuple-with-same-product.js

diff --git a/1726-tuple-with-same-product.js b/1726-tuple-with-same-product.js
new file mode 100644
index 00000000..b948f581
--- /dev/null
+++ b/1726-tuple-with-same-product.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const tupleSameProduct = function(nums) {
+  const m = {}
+  const len = nums.length
+  for(let i = 0; i < len - 1; i++) {
+    for(let j = i + 1; j < len; j++) {
+      const tmp = nums[i] * nums[j]
+      if(m[tmp] == null) m[tmp] = 0
+      m[tmp]++
+    } 
+  }
+  let res = 0
+  Object.keys(m).forEach(e => {
+    if(m[e] > 1) res += m[e] * (m[e] - 1)  * 4
+  })
+  
+  return res
+};

From 2708dce1f77fbabd34672abb14c19d171435b256 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jan 2021 20:43:48 +0800
Subject: [PATCH 1065/3374] Update
 1727-largest-submatrix-with-rearrangements.js

---
 1727-largest-submatrix-with-rearrangements.js | 36 +++++++++----------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/1727-largest-submatrix-with-rearrangements.js b/1727-largest-submatrix-with-rearrangements.js
index 435fc7ce..5025dd3a 100644
--- a/1727-largest-submatrix-with-rearrangements.js
+++ b/1727-largest-submatrix-with-rearrangements.js
@@ -2,22 +2,20 @@
  * @param {number[][]} matrix
  * @return {number}
  */
-const largestSubmatrix = function(a) {
- 		let n = a.length;
-		let m = a[0].length;
-		let count = Array(m).fill(0);
-		let result = 0;
-		for (let i = 0; i < n; ++i) {
-			for (let j = 0; j < m; ++j) {
-				count[j] = (a[i][j] ? count[j] + 1 : 0);
-			}
-			let b = count.slice();
-            b.sort((a, b) => a - b)
-			b = b.reverse()
-			for (let j = 0; j < m; ++j) {
-				result = Math.max(result, (j + 1) * b[j]);
-			}
-		}
-		return result;   
-};
-
+const largestSubmatrix = function (a) {
+  const n = a.length
+  const m = a[0].length
+  const count = Array(m).fill(0)
+  let result = 0
+  for (let i = 0; i < n; ++i) {
+    for (let j = 0; j < m; ++j) {
+      count[j] = a[i][j] ? count[j] + 1 : 0
+    }
+    const b = count.slice()
+    b.sort((a, b) => b - a)
+    for (let j = 0; j < m; ++j) {
+      result = Math.max(result, (j + 1) * b[j])
+    }
+  }
+  return result
+}

From 5ef87d6c4acebccb5fc5d08c09a5735cb6548c7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Jan 2021 21:07:20 +0800
Subject: [PATCH 1066/3374] Create
 1724-checking-existence-of-edge-length-limited-paths-ii.js

---
 ...istence-of-edge-length-limited-paths-ii.js | 119 ++++++++++++++++++
 1 file changed, 119 insertions(+)
 create mode 100644 1724-checking-existence-of-edge-length-limited-paths-ii.js

diff --git a/1724-checking-existence-of-edge-length-limited-paths-ii.js b/1724-checking-existence-of-edge-length-limited-paths-ii.js
new file mode 100644
index 00000000..84e0cff5
--- /dev/null
+++ b/1724-checking-existence-of-edge-length-limited-paths-ii.js
@@ -0,0 +1,119 @@
+const DistanceLimitedPathsExist = function (n, edgeList) {
+  edgeList.sort((a, b) => a[2] - b[2])
+  this.dis = []
+  this.uf = new SnapshotUF(n)
+  let cur_dis = 0
+  for (let e of edgeList) {
+    if (e[2] > cur_dis) {
+      this.dis.push(cur_dis)
+      cur_dis = e[2]
+      this.uf.snap()
+    }
+    this.uf.union(e[0], e[1])
+  }
+  this.dis.push(cur_dis)
+  this.uf.snap()
+}
+
+DistanceLimitedPathsExist.prototype.query = function (p, q, limit) {
+  let snap_id = lower_bound(this.dis, limit) - this.dis[0] - 1
+  return this.uf.check(p, q, snap_id)
+}
+
+class SnapshotArray {
+  constructor(length) {
+    this.tim = 0
+    this.vec = Array.from({ length: length }, () => [0])
+    this.ti = Array.from({ length: length }, () => [0])
+  }
+  set(index, val) {
+    if (this.ti[index][this.ti.length - 1] === this.tim) {
+      this.vec[index][this.vec[index].length - 1] = val
+    } else {
+      this.ti[index].push(this.tim)
+      this.vec[index].push(val)
+    }
+  }
+  get(idx, snapId) {
+    const p = lower_bound(this.ti[idx], snapId + 1) - this.ti[idx][0] - 1
+    return this.vec[idx][p]
+  }
+  snap() {
+    return this.tim++
+  }
+}
+
+class SnapshotUF extends SnapshotArray {
+  constructor(n) {
+    super(n)
+    for (let i = 0; i < n; i++) this.set(i, -1)
+  }
+  find(x, snap_id) {
+    let rep = this.get(x, snap_id)
+    if (rep < 0) return x
+    return this.find(rep, snap_id)
+  }
+  union(x, y) {
+    let px = this.find(x, this.tim)
+    let py = this.find(y, this.tim)
+    if (px == py) return
+    let sizepx = -1 * this.get(px, this.tim)
+    let sizepy = -1 * this.get(py, this.tim)
+    if (sizepx >= sizepy) {
+      this.set(px, -1 * sizepx + -1 * sizepy)
+      this.set(py, px)
+    } else {
+      this.set(py, -1 * sizepx + -1 * sizepy)
+      this.set(px, py)
+    }
+  }
+  check(x, y, snap_id) {
+    return this.find(x, snap_id) === this.find(y, snap_id)
+  }
+}
+
+function lower_bound(array, arg1, arg2, arg3, arg4) {
+  let first
+  let last
+  let value
+  let less
+  if (arg3 === undefined) {
+    first = 0
+    last = array.length
+    value = arg1
+    less = arg2
+  } else {
+    first = arg1
+    last = arg2
+    value = arg3
+    less = arg4
+  }
+
+  if (less === undefined) {
+    less = function (a, b) {
+      return a < b
+    }
+  }
+
+  let len = last - first
+  let middle
+  let step
+  while (len > 0) {
+    step = Math.floor(len / 2)
+    middle = first + step
+    if (less(array[middle], value, middle)) {
+      first = middle
+      first += 1
+      len = len - step - 1
+    } else {
+      len = step
+    }
+  }
+  return first
+}
+
+/**
+ * Your DistanceLimitedPathsExist object will be instantiated and called as such:
+ * DistanceLimitedPathsExist* obj = new DistanceLimitedPathsExist(n, edgeList);
+ * bool param_1 = obj->query(p,q,limit);
+ */

From 44325c83f9e1eccbafef259ba10dd4b2a9ff804a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 19:35:13 +0800
Subject: [PATCH 1067/3374] Update
 1727-largest-submatrix-with-rearrangements.js

---
 1727-largest-submatrix-with-rearrangements.js | 33 ++++++++++---------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/1727-largest-submatrix-with-rearrangements.js b/1727-largest-submatrix-with-rearrangements.js
index 5025dd3a..6323aed1 100644
--- a/1727-largest-submatrix-with-rearrangements.js
+++ b/1727-largest-submatrix-with-rearrangements.js
@@ -2,20 +2,21 @@
  * @param {number[][]} matrix
  * @return {number}
  */
-const largestSubmatrix = function (a) {
-  const n = a.length
-  const m = a[0].length
-  const count = Array(m).fill(0)
-  let result = 0
-  for (let i = 0; i < n; ++i) {
-    for (let j = 0; j < m; ++j) {
-      count[j] = a[i][j] ? count[j] + 1 : 0
+const largestSubmatrix = function(matrix) {
+    const n = matrix.length;
+    const m = matrix[0].length;
+    const cols = Array(m).fill(0)
+    let res = 0
+    for(let i = 0; i < n; i++) {
+      for(let j = 0; j < m; j++) {
+        cols[j] = matrix[i][j] === 1 ? cols[j] + 1 : 0
+      }
+      const tmp = cols.slice()
+      tmp.sort((a, b) => b - a)
+      for(let j = 0; j < m; j++) {
+        res = Math.max(res, (j + 1) * tmp[j])
+      }
     }
-    const b = count.slice()
-    b.sort((a, b) => b - a)
-    for (let j = 0; j < m; ++j) {
-      result = Math.max(result, (j + 1) * b[j])
-    }
-  }
-  return result
-}
+    return res
+};
+

From a4379b220fe01b624c093936c764eaae543ab320 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:07:24 +0800
Subject: [PATCH 1068/3374] Create 1350-students-with-invalid-departments.sql

---
 1350-students-with-invalid-departments.sql | 3 +++
 1 file changed, 3 insertions(+)
 create mode 100644 1350-students-with-invalid-departments.sql

diff --git a/1350-students-with-invalid-departments.sql b/1350-students-with-invalid-departments.sql
new file mode 100644
index 00000000..f89383dd
--- /dev/null
+++ b/1350-students-with-invalid-departments.sql
@@ -0,0 +1,3 @@
+# Write your MySQL query statement below
+SELECT id, name FROM Students
+WHERE department_id not in (SELECT id from Departments);

From e29373083fb4fda392a424c659b4746efe0f3228 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:15:44 +0800
Subject: [PATCH 1069/3374] Create 1119-remove-vowels-from-a-string.js

---
 1119-remove-vowels-from-a-string.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1119-remove-vowels-from-a-string.js

diff --git a/1119-remove-vowels-from-a-string.js b/1119-remove-vowels-from-a-string.js
new file mode 100644
index 00000000..b0ccfd23
--- /dev/null
+++ b/1119-remove-vowels-from-a-string.js
@@ -0,0 +1,7 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const removeVowels = function(s) {
+  return s.replace(/[aeiou]/g, '')
+};

From 6f3c9c803129baf885d21a8b3d6e8563e8df62ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:19:58 +0800
Subject: [PATCH 1070/3374] Create 1587-bank-account-summary-ii.js

---
 1587-bank-account-summary-ii.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1587-bank-account-summary-ii.js

diff --git a/1587-bank-account-summary-ii.js b/1587-bank-account-summary-ii.js
new file mode 100644
index 00000000..68ae3626
--- /dev/null
+++ b/1587-bank-account-summary-ii.js
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT u.name, SUM(amount) as balance
+FROM Transactions
+JOIN Users u
+USING (account)
+GROUP BY account
+HAVING balance>10000;

From d4d82a6661423d43ad97a42d77e6b92e1120cd61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:21:02 +0800
Subject: [PATCH 1071/3374] Rename 1587-bank-account-summary-ii.js to
 1587-bank-account-summary-ii.sql

---
 ...bank-account-summary-ii.js => 1587-bank-account-summary-ii.sql | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 1587-bank-account-summary-ii.js => 1587-bank-account-summary-ii.sql (100%)

diff --git a/1587-bank-account-summary-ii.js b/1587-bank-account-summary-ii.sql
similarity index 100%
rename from 1587-bank-account-summary-ii.js
rename to 1587-bank-account-summary-ii.sql

From b76c1e7ea2b9d246b1e8bcd27702b268a066d2e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:22:31 +0800
Subject: [PATCH 1072/3374] Create
 1378-replace-employee-id-with-the-unique-identifier.sql

---
 1378-replace-employee-id-with-the-unique-identifier.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1378-replace-employee-id-with-the-unique-identifier.sql

diff --git a/1378-replace-employee-id-with-the-unique-identifier.sql b/1378-replace-employee-id-with-the-unique-identifier.sql
new file mode 100644
index 00000000..dc3d9715
--- /dev/null
+++ b/1378-replace-employee-id-with-the-unique-identifier.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT unique_id, name
+FROM Employees
+LEFT JOIN  EmployeeUNI
+USING (id);

From 83d383546b99e11d29a705a4f2d2141ca3136cc0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:29:01 +0800
Subject: [PATCH 1073/3374] Create 1480-running-sum-of-1d-array.js

---
 1480-running-sum-of-1d-array.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1480-running-sum-of-1d-array.js

diff --git a/1480-running-sum-of-1d-array.js b/1480-running-sum-of-1d-array.js
new file mode 100644
index 00000000..7a842ad3
--- /dev/null
+++ b/1480-running-sum-of-1d-array.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const runningSum = function(nums) {
+  for(let i = 1, len = nums.length; i < len; i++) {
+    nums[i] += nums[i - 1]
+  }
+  return nums
+};

From eb4a524662ec9bf631f9c96edcd7e57cde6a423a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:30:38 +0800
Subject: [PATCH 1074/3374] Create 1303-find-the-team-size.sql

---
 1303-find-the-team-size.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1303-find-the-team-size.sql

diff --git a/1303-find-the-team-size.sql b/1303-find-the-team-size.sql
new file mode 100644
index 00000000..0446f739
--- /dev/null
+++ b/1303-find-the-team-size.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT employee_id, 
+    COUNT(team_id) OVER(PARTITION BY team_id) AS team_size
+FROM Employee;

From 7b9639b4aa8977b90316aac0756bc230a9e388ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:32:52 +0800
Subject: [PATCH 1075/3374] Create
 1623-all-valid-triplets-that-can-represent-a-country.sql

---
 ...l-valid-triplets-that-can-represent-a-country.sql | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1623-all-valid-triplets-that-can-represent-a-country.sql

diff --git a/1623-all-valid-triplets-that-can-represent-a-country.sql b/1623-all-valid-triplets-that-can-represent-a-country.sql
new file mode 100644
index 00000000..67b4af69
--- /dev/null
+++ b/1623-all-valid-triplets-that-can-represent-a-country.sql
@@ -0,0 +1,12 @@
+# Write your MySQL query statement below
+SELECT sa.student_name AS member_a
+    , sb.student_name AS member_b
+    , sc.student_name AS member_c
+FROM schoola sa CROSS JOIN schoolb sb 
+    CROSS JOIN schoolc sc
+        WHERE sa.student_name != sb.student_name 
+            AND sa.student_name != sc.student_name
+            AND sb.student_name != sc.student_name
+            AND sa.student_id != sc.student_id
+            AND sb.student_id != sc.student_id
+            AND sa.student_id != sb.student_id;

From 9d26c50e6185556afd978f49e21465a7eb56fd32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:44:19 +0800
Subject: [PATCH 1076/3374] Create
 1431-kids-with-the-greatest-number-of-candies.js

---
 1431-kids-with-the-greatest-number-of-candies.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1431-kids-with-the-greatest-number-of-candies.js

diff --git a/1431-kids-with-the-greatest-number-of-candies.js b/1431-kids-with-the-greatest-number-of-candies.js
new file mode 100644
index 00000000..4f9776fb
--- /dev/null
+++ b/1431-kids-with-the-greatest-number-of-candies.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} candies
+ * @param {number} extraCandies
+ * @return {boolean[]}
+ */
+const kidsWithCandies = function(candies, extraCandies) {
+  const res = []
+  let max = 0
+  for(let e of candies) max = Math.max(e, max)
+  max -= extraCandies
+  for(let i = 0, len = candies.length; i < len; i++) {
+    res.push(candies[i] >= max)
+  }
+  return res
+};

From 8e7d7c37984901216a2b4d84e9a381061ffef50a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jan 2021 21:47:37 +0800
Subject: [PATCH 1077/3374] Create 1470-shuffle-the-array.js

---
 1470-shuffle-the-array.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1470-shuffle-the-array.js

diff --git a/1470-shuffle-the-array.js b/1470-shuffle-the-array.js
new file mode 100644
index 00000000..516c7e00
--- /dev/null
+++ b/1470-shuffle-the-array.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @param {number} n
+ * @return {number[]}
+ */
+const shuffle = function(nums, n) {
+  const res = []
+  for(let i = 0; i < n; i++) {
+    res.push(nums[i], nums[i + n])
+  }
+  return res
+};

From d179b02e4f550c175a62df13357334ac17f17c00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Jan 2021 20:03:16 +0800
Subject: [PATCH 1078/3374] Create 1512-number-of-good-pairs.js

---
 1512-number-of-good-pairs.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1512-number-of-good-pairs.js

diff --git a/1512-number-of-good-pairs.js b/1512-number-of-good-pairs.js
new file mode 100644
index 00000000..fa3094aa
--- /dev/null
+++ b/1512-number-of-good-pairs.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numIdenticalPairs = function(nums) {
+  let res = 0, count = Array(101).fill(0)
+  for(let e of nums) {
+    res += count[e]++
+  }
+  return res
+};

From e8cf1ff8d5f3a73169ae473e39ed6fdfb7af025d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Jan 2021 13:27:31 +0800
Subject: [PATCH 1079/3374] Create 1728-cat-and-mouse-ii.js

---
 1728-cat-and-mouse-ii.js | 88 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 1728-cat-and-mouse-ii.js

diff --git a/1728-cat-and-mouse-ii.js b/1728-cat-and-mouse-ii.js
new file mode 100644
index 00000000..0ced25b8
--- /dev/null
+++ b/1728-cat-and-mouse-ii.js
@@ -0,0 +1,88 @@
+/**
+ * @param {string[]} grid
+ * @param {number} catJump
+ * @param {number} mouseJump
+ * @return {boolean}
+ */
+const canMouseWin = function(grid, catJump, mouseJump) {
+  let n,m,k,lim,cache,mpos = -1, cpos = -1, fpos = -1
+  n = grid.length
+  m = grid[0].length
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < m; j++) {
+      if(grid[i][j] === 'M') mpos = i * m + j
+      else if(grid[i][j] === 'C') cpos = i * m + j
+      else if(grid[i][j] === 'F') fpos = i * m + j
+    }
+  }
+  mnei = Array(n * m), cnei = Array(n * m)
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < m; j++) {
+      mnei[i * m + j] = traj(i, j, mouseJump)
+    }
+  }
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < m; j++) {
+      cnei[i * m + j] = traj(i, j, catJump)
+    }
+  }
+  k = m * n
+  lim = 100
+  cache = Array.from({ length: lim }, () => Array(k * k).fill(0))
+
+  for(let i = 0; i < lim; i++) {
+    for(let j = 0; j < k * k; j++) {
+      cache[i][j] = -1
+    }
+  }
+
+  return mouseWin(mpos, cpos, 0)
+
+  function traj(i, j, d) {
+    if(grid[i][j] === '#') return []
+    let pos = i * m + j
+    let change = []
+    change.push(pos)
+    for(let k = 1; k < d + 1; k++) {
+      if(i + k >= n || grid[i + k][j] === '#') break
+      change.push(pos + k * m)
+    }
+    for(let k = 1; k < d + 1; k++) {
+      if(i - k < 0 || grid[i - k][j] === '#') break
+      change.push(pos - k * m) 
+    }
+    for(let k = 1; k < d + 1; k++) {
+      if(j + k >= m || grid[i][j + k] === '#') break
+      change.push(pos + k)
+    }
+    for(let k = 1; k < d + 1; k++) {
+      if(j - k < 0 || grid[i][j - k] === '#') break
+      change.push(pos - k)
+    }
+    return change
+  }
+  
+  function mouseWin(mpos, cpos, turn) {
+    if(turn === lim) return false
+    let e = mpos * k + cpos
+    if(cache[turn][e] >= 0) return cache[turn][e] === 1
+    if(cpos === fpos || cpos === mpos) return false
+    if(mpos === fpos) return true
+    if((turn & 1) !== 0) {
+      let b = 0
+      for(let newCpos of cnei[cpos]) {
+        if(!mouseWin(mpos, newCpos, turn + 1)) b = 1
+      }
+      if(b===0) cache[turn][e] = 1
+      else cache[turn][e] = 0
+    } else {
+      let b = 0
+      for(let newMpos of mnei[mpos]) {
+        if(mouseWin(newMpos, cpos, turn + 1)) b = 1
+      }
+      if(b === 1) cache[turn][e] = 1
+      else cache[turn][e] = 0
+    }
+    return cache[turn][e] === 1
+  }
+};

From efc88e4028d9a7cc293ca2e1192dca6d10990615 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Jan 2021 17:02:00 +0800
Subject: [PATCH 1080/3374] Create 1729-find-followers-count.sql

---
 1729-find-followers-count.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1729-find-followers-count.sql

diff --git a/1729-find-followers-count.sql b/1729-find-followers-count.sql
new file mode 100644
index 00000000..cfe38287
--- /dev/null
+++ b/1729-find-followers-count.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT user_id, COUNT(follower_id) AS followers_count
+FROM Followers
+GROUP BY user_id
+ORDER BY user_id;

From 5142c72bd41aed79d1d3beb15000206250c0de36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Jan 2021 20:08:44 +0800
Subject: [PATCH 1081/3374] Update 41-first-missing-positive.js

---
 41-first-missing-positive.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/41-first-missing-positive.js b/41-first-missing-positive.js
index 5343bb2d..8b42d3cd 100644
--- a/41-first-missing-positive.js
+++ b/41-first-missing-positive.js
@@ -23,20 +23,20 @@ const firstMissingPositive = function(nums) {
  * @return {number}
  */
 function firstMissingPositive(nums) {
-  const A = nums
   const n = nums.length
   for (let i = 0; i < n; i++) {
-    while (A[i] > 0 && A[i] <= n && A[A[i] - 1] !== A[i]) swap(A, i, A[i] - 1)
+    while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i])
+      swap(nums, i, nums[i] - 1)
   }
 
   for (let i = 0; i < n; i++) {
-    if (A[i] !== i + 1) return i + 1
+    if (nums[i] !== i + 1) return i + 1
   }
   return n + 1
 }
 
 function swap(arr, i, j) {
-  let tmp = arr[i]
+  const tmp = arr[i]
   arr[i] = arr[j]
   arr[j] = tmp
 }

From 1f748aabaac64f087186eb690e8e82115380cb2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Jan 2021 19:29:26 +0800
Subject: [PATCH 1082/3374] Create 1603-design-parking-system.js

---
 1603-design-parking-system.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1603-design-parking-system.js

diff --git a/1603-design-parking-system.js b/1603-design-parking-system.js
new file mode 100644
index 00000000..8f980fec
--- /dev/null
+++ b/1603-design-parking-system.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} big
+ * @param {number} medium
+ * @param {number} small
+ */
+const ParkingSystem = function(big, medium, small) {
+  this['3'] = small
+  this['2'] = medium
+  this['1'] = big
+};
+
+/** 
+ * @param {number} carType
+ * @return {boolean}
+ */
+ParkingSystem.prototype.addCar = function(carType) {
+  this[carType]--
+  if(this[carType] < 0) {
+    this[carType] = 0
+    return false
+  }
+  return true
+};
+
+/** 
+ * Your ParkingSystem object will be instantiated and called as such:
+ * var obj = new ParkingSystem(big, medium, small)
+ * var param_1 = obj.addCar(carType)
+ */

From 9b0df17204d3b777a4f9acc9f09b4ab4ce52c110 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 00:44:37 +0800
Subject: [PATCH 1083/3374] Create 1732-find-the-highest-altitude.js

---
 1732-find-the-highest-altitude.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1732-find-the-highest-altitude.js

diff --git a/1732-find-the-highest-altitude.js b/1732-find-the-highest-altitude.js
new file mode 100644
index 00000000..b3ed3097
--- /dev/null
+++ b/1732-find-the-highest-altitude.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} gain
+ * @return {number}
+ */
+const largestAltitude = function(gain) {
+  const h = [0]
+  for(let e of gain) {
+    h.push(h[h.length - 1] + e)
+  }
+  let max = 0
+  for(let e of h) {
+    max = Math.max(max, e)
+  }
+  return max
+};

From 050684c6f52139a45828a25dfc01412f9e4e5034 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 00:45:06 +0800
Subject: [PATCH 1084/3374] Create 1733-minimum-number-of-people-to-teach.js

---
 1733-minimum-number-of-people-to-teach.js | 45 +++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1733-minimum-number-of-people-to-teach.js

diff --git a/1733-minimum-number-of-people-to-teach.js b/1733-minimum-number-of-people-to-teach.js
new file mode 100644
index 00000000..f17fb30f
--- /dev/null
+++ b/1733-minimum-number-of-people-to-teach.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number} n
+ * @param {number[][]} languages
+ * @param {number[][]} friendships
+ * @return {number}
+ */
+var minimumTeachings = function(n, languages, friendships) {
+        let cnt_people = languages.length;
+
+  const knows = Array.from({length: cnt_people}, () => Array(n).fill(0))
+        for(let who = 0; who < cnt_people; ++who) {
+            for(let x of languages[who]) {
+                knows[who][x-1] = true;
+            }
+        }
+        let req = Array(n).fill(0);
+        let s = new Set();
+        for(let edge of friendships) {
+            let a = edge[0] - 1;
+            let b = edge[1] - 1;
+            let yes = false;
+            for(let x of languages[a]) {
+                if(knows[b][x-1]) {
+                    yes = true;
+                }
+            }
+            if(yes) {
+                continue;
+            }
+            s.add(a);
+            s.add(b);
+        }
+        let best = Infinity;
+        for(let i = 0; i < n; ++i) {
+            let needed = 0;
+            for(let person of s) {
+                if(!knows[person][i]) {
+                    needed++;
+                }
+            }
+            best = Math.min(best, needed);
+        }
+        return best;    
+};
+

From 0898ad7dc52d9ef19a2da29913bff8f85be96eeb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 00:45:35 +0800
Subject: [PATCH 1085/3374] Create 1734-decode-xored-permutation.js

---
 1734-decode-xored-permutation.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1734-decode-xored-permutation.js

diff --git a/1734-decode-xored-permutation.js b/1734-decode-xored-permutation.js
new file mode 100644
index 00000000..341db848
--- /dev/null
+++ b/1734-decode-xored-permutation.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} encoded
+ * @return {number[]}
+ */
+const decode = function(A) {
+    let i;
+    let n = A.length + 1;
+    let f = 0;
+    const res = [];
+    for(i=1;i<n+1;i++){
+      f ^= i;
+    }
+    for(i=1;i<n-1;i+=2){
+      f ^= A[i];
+    }
+    res.push(f);
+    for(i=1;i<n;i++){
+      f ^= A[i-1];
+      res.push(f);
+    }
+    return res;    
+};

From 5d59996a3bff208466d07e14d94bd307770c5d7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 00:46:06 +0800
Subject: [PATCH 1086/3374] Create
 1735-count-ways-to-make-array-with-product.js

---
 1735-count-ways-to-make-array-with-product.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 1735-count-ways-to-make-array-with-product.js

diff --git a/1735-count-ways-to-make-array-with-product.js b/1735-count-ways-to-make-array-with-product.js
new file mode 100644
index 00000000..f98c6785
--- /dev/null
+++ b/1735-count-ways-to-make-array-with-product.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var waysToFillArray = function(queries) {
+  const nax = 10123;
+  const C = Array.from({length: nax}, () => Array(15).fill(0n));
+        const mod = BigInt(10 ** 9 + 7);
+        if(C[1][1] == 0n) {
+            for(let i = 0; i < nax; ++i) {
+                C[i][0] = 1n;
+                if(i < 15) {
+                    C[i][i] = 1n;
+                }
+                for(let j = 1; j < i && j < 15; ++j) {
+                    C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
+                }
+            }
+        }
+        const answer = [];
+        for(let query of queries) {
+            let n = query[0];
+            let k = query[1];
+            let total = 1n;
+            const consider =( cnt) => {
+                total = total * C[n+cnt-1][cnt] % mod; ;
+            };
+            for(let i = 2; i * i <= k; ++i) {
+                if(k % i == 0) {
+                    let cnt = 0;
+                    while(k % i == 0) {
+                        k = (k/i) >> 0;
+                        cnt++;
+                    }
+                    consider(cnt);
+                }
+            }
+            if(k != 1) {
+                consider(1);
+            }
+            answer.push(total);
+        }
+        return answer; 
+};

From 5fcb18197eae25e91ca6599f156366efddd371cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 12:23:31 +0800
Subject: [PATCH 1087/3374] Create
 1736-latest-time-by-replacing-hidden-digits.js

---
 ...-latest-time-by-replacing-hidden-digits.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1736-latest-time-by-replacing-hidden-digits.js

diff --git a/1736-latest-time-by-replacing-hidden-digits.js b/1736-latest-time-by-replacing-hidden-digits.js
new file mode 100644
index 00000000..033ec30c
--- /dev/null
+++ b/1736-latest-time-by-replacing-hidden-digits.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} time
+ * @return {string}
+ */
+var maximumTime = function(time) {
+  const arr = time.split('')
+  let idx = time.indexOf('?')
+  if(idx < 0) return time
+  while(arr.indexOf('?') >= 0) {
+      idx = arr.indexOf('?')
+      let e
+      if(idx === 0) {
+        if(time[1] === '?') e = 2
+        else if(+time[1] < 4) e =2
+        else e = 1
+        arr[0] = '' + e
+
+      } else if(idx === 1) {
+        if(+arr[0] > 1) e = 3
+        else e = 9
+        arr[1] = '' + e
+      } else if(idx === 3) {
+        e = 5
+        arr[3] = '' + e
+      } else if(idx === 4) {
+        e = 9
+        arr[4] = '' + e
+      }      
+  }
+
+  return arr.join('')
+};

From 4490385ca2627c65cde3672de682ea9b6e6bf857 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 12:24:04 +0800
Subject: [PATCH 1088/3374] Create
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...ters-to-satisfy-one-of-three-conditions.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
new file mode 100644
index 00000000..4036284b
--- /dev/null
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+const minCharacters = function(a, b) {
+    let n1 = a.length, n2 = b.length;
+    const cnt1 = Array(26).fill(0);
+    const cnt2 = Array(26).fill(0);
+    const aCode = ('a').charCodeAt(0);   
+    for (let c of a) ++cnt1[c.charCodeAt(0) - aCode];
+    for (let c of b) ++cnt2[c.charCodeAt(0) - aCode];
+    let res = n1 - Math.max(...cnt1) + n2 - Math.max(...cnt2);
+    for (let i = 0; i < 25; ++i) {
+      let cur1 = 0, cur2 = 0;
+      for (let j = 0; j < 26; ++j) {
+        if (j <= i) {
+          cur1 += cnt2[j];
+          cur2 += cnt1[j];
+        } else {
+          cur1 += cnt1[j];
+          cur2 += cnt2[j];
+        }
+      }
+      res = Math.min(Math.min(cur1, cur2), res);
+    }
+    return res;
+};

From dc1fac4f825e7c4e93cd7f6ff93f3195bd56c55a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 12:24:39 +0800
Subject: [PATCH 1089/3374] Create
 1738-find-kth-largest-xor-coordinate-value.js

---
 1738-find-kth-largest-xor-coordinate-value.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1738-find-kth-largest-xor-coordinate-value.js

diff --git a/1738-find-kth-largest-xor-coordinate-value.js b/1738-find-kth-largest-xor-coordinate-value.js
new file mode 100644
index 00000000..887bb1a0
--- /dev/null
+++ b/1738-find-kth-largest-xor-coordinate-value.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} matrix
+ * @param {number} k
+ * @return {number}
+ */
+var kthLargestValue = function(matrix, k) {
+    let m = matrix.length;
+    let n = matrix[0].length;
+    const v = [], d = Array(n).fill(0);
+    d[0] = matrix[0][0];
+    v.push(d[0]);
+    for (let i = 1; i < n; ++i) {
+      d[i] = matrix[0][i] ^ d[i - 1];
+      v.push(d[i]);
+    }
+    for (let i = 1; i < m; ++i) {
+      let cur = matrix[i][0];
+      d[0] ^= cur;
+      v.push(d[0]);
+      for (let j = 1; j < n; ++j) {
+        cur ^= matrix[i][j];
+        d[j] ^= cur;
+        v.push(d[j]);
+      }
+    }
+    v.sort((a, b) => b - a)
+    return v[k - 1];
+};
+
+

From 975b0981a099bf565657a1fce537bdea583d5cb2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 12:25:18 +0800
Subject: [PATCH 1090/3374] Create 1739-building-boxes.js

---
 1739-building-boxes.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1739-building-boxes.js

diff --git a/1739-building-boxes.js b/1739-building-boxes.js
new file mode 100644
index 00000000..b11d34cf
--- /dev/null
+++ b/1739-building-boxes.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minimumBoxes = function(n) {
+  let sum = 1n, base = 1n, row = 1n;
+  n = BigInt(n)
+  while (sum < n) {
+    base += (++row);
+    sum += base;
+  }
+  while (sum > n) {
+    --base;
+    sum -= (row--);
+    if (sum < n) return base + 1n;
+  }
+  return base;
+};
+

From dcf0a5ae482e23d8dc66bf54102c0828cee6875b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jan 2021 17:36:43 +0800
Subject: [PATCH 1091/3374] Update
 1738-find-kth-largest-xor-coordinate-value.js

---
 1738-find-kth-largest-xor-coordinate-value.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1738-find-kth-largest-xor-coordinate-value.js b/1738-find-kth-largest-xor-coordinate-value.js
index 887bb1a0..18455b2b 100644
--- a/1738-find-kth-largest-xor-coordinate-value.js
+++ b/1738-find-kth-largest-xor-coordinate-value.js
@@ -27,4 +27,34 @@ var kthLargestValue = function(matrix, k) {
     return v[k - 1];
 };
 
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @param {number} k
+ * @return {number}
+ */
+const kthLargestValue = function(matrix, k) {
+    const tmp = []
+    const n = matrix.length, m = matrix[0].length
+    const dp = Array.from({ length: n }, () => Array(m).fill(0))
+    dp[0][0] = matrix[0][0]
+    tmp.push(dp[0][0])
+    for(let j = 1; j < m; j++) {
+      dp[0][j] = dp[0][j - 1] ^ matrix[0][j]
+      tmp.push(dp[0][j])
+    }
+    for(let i = 1; i < n; i++) {
+      dp[i][0] = dp[i - 1][0] ^ matrix[i][0]
+      tmp.push(dp[i][0])
+    }
+    for(let i = 1; i < n; i++) {
+        for(let j = 1; j < m; j++) {
+            dp[i][j] = dp[i][j - 1] ^ dp[i - 1][j] ^ matrix[i][j] ^ dp[i - 1][j - 1]
+            tmp.push(dp[i][j])
+        }
+    }
+    tmp.sort((a, b) => b - a)
+    return tmp[k - 1]
+};
 

From 4230e53e4ff40a2ff2df7be942460cb9f146dd3a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jan 2021 22:38:06 +0800
Subject: [PATCH 1092/3374] Update
 1735-count-ways-to-make-array-with-product.js

---
 1735-count-ways-to-make-array-with-product.js | 78 +++++++++----------
 1 file changed, 39 insertions(+), 39 deletions(-)

diff --git a/1735-count-ways-to-make-array-with-product.js b/1735-count-ways-to-make-array-with-product.js
index f98c6785..b2d7829d 100644
--- a/1735-count-ways-to-make-array-with-product.js
+++ b/1735-count-ways-to-make-array-with-product.js
@@ -2,43 +2,43 @@
  * @param {number[][]} queries
  * @return {number[]}
  */
-var waysToFillArray = function(queries) {
-  const nax = 10123;
-  const C = Array.from({length: nax}, () => Array(15).fill(0n));
-        const mod = BigInt(10 ** 9 + 7);
-        if(C[1][1] == 0n) {
-            for(let i = 0; i < nax; ++i) {
-                C[i][0] = 1n;
-                if(i < 15) {
-                    C[i][i] = 1n;
-                }
-                for(let j = 1; j < i && j < 15; ++j) {
-                    C[i][j] = (C[i-1][j-1] + C[i-1][j]) % mod;
-                }
-            }
+var waysToFillArray = function (queries) {
+  const nax = 10123
+  const C = Array.from({ length: nax }, () => Array(15).fill(0n))
+  const mod = BigInt(10 ** 9 + 7)
+  if (C[1][1] == 0n) {
+    for (let i = 0; i < nax; ++i) {
+      C[i][0] = 1n
+      if (i < 15) {
+        C[i][i] = 1n
+      }
+      for (let j = 1; j < i && j < 15; ++j) {
+        C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod
+      }
+    }
+  }
+  const answer = []
+  for (let query of queries) {
+    let n = query[0]
+    let k = query[1]
+    let total = 1n
+    const consider = (cnt) => {
+      total = (total * C[n + cnt - 1][cnt]) % mod
+    }
+    for (let i = 2; i * i <= k; ++i) {
+      if (k % i == 0) {
+        let cnt = 0
+        while (k % i == 0) {
+          k = (k / i) >> 0
+          cnt++
         }
-        const answer = [];
-        for(let query of queries) {
-            let n = query[0];
-            let k = query[1];
-            let total = 1n;
-            const consider =( cnt) => {
-                total = total * C[n+cnt-1][cnt] % mod; ;
-            };
-            for(let i = 2; i * i <= k; ++i) {
-                if(k % i == 0) {
-                    let cnt = 0;
-                    while(k % i == 0) {
-                        k = (k/i) >> 0;
-                        cnt++;
-                    }
-                    consider(cnt);
-                }
-            }
-            if(k != 1) {
-                consider(1);
-            }
-            answer.push(total);
-        }
-        return answer; 
-};
+        consider(cnt)
+      }
+    }
+    if (k != 1) {
+      consider(1)
+    }
+    answer.push(total)
+  }
+  return answer
+}

From be31536d9802bf7535a62235ec2ea1dc30c546f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Jan 2021 13:53:16 +0800
Subject: [PATCH 1093/3374] Create
 1210-minimum-moves-to-reach-target-with-rotations.js

---
 ...um-moves-to-reach-target-with-rotations.js | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 1210-minimum-moves-to-reach-target-with-rotations.js

diff --git a/1210-minimum-moves-to-reach-target-with-rotations.js b/1210-minimum-moves-to-reach-target-with-rotations.js
new file mode 100644
index 00000000..6d23ef5a
--- /dev/null
+++ b/1210-minimum-moves-to-reach-target-with-rotations.js
@@ -0,0 +1,69 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minimumMoves = function (grid) {
+  const n = grid.length;
+  const start = [0, 0, 0, 1].join(',');
+  const end = [n - 1, n - 2, n - 1, n - 1].join(",");
+  let curr_level = new Set([start]);
+  let moves = 0;
+  const visited = new Set();
+  while (curr_level.size) {
+    const next_level = new Set();
+    for (let pos of curr_level) {
+      visited.add(pos);
+      let [r1, c1, r2, c2] = pos.split(",").map((e) => +e);
+      if (
+        c1 + 1 < n &&
+        grid[r1][c1 + 1] == 0 &&
+        c2 + 1 < n &&
+        grid[r2][c2 + 1] == 0
+      ) {
+        const coord = [r1, c1 + 1, r2, c2 + 1].join(",");
+        if (!visited.has(coord)) {
+          next_level.add(coord);
+        }
+      }
+      if (
+        r1 + 1 < n &&
+        grid[r1 + 1][c1] == 0 &&
+        r2 + 1 < n &&
+        grid[r2 + 1][c2] == 0
+      ) {
+        const coord = [r1 + 1, c1, r2 + 1, c2].join(",");
+        if (!visited.has(coord)) {
+          next_level.add(coord);
+        }
+      }
+      if (
+        r1 == r2 &&
+        c2 == c1 + 1 &&
+        r1 + 1 < n &&
+        grid[r1 + 1][c1] + grid[r1 + 1][c1 + 1] == 0
+      ) {
+        const coord = [r1, c1, r1 + 1, c1].join(",");
+        if (!visited.has(coord)) {
+          next_level.add(coord);
+        }
+      }
+      if (
+        c1 == c2 &&
+        r2 == r1 + 1 &&
+        c1 + 1 < n &&
+        grid[r1][c1 + 1] + grid[r1 + 1][c1 + 1] == 0
+      ) {
+        const coord = [r1, c1, r1, c1 + 1].join(",");
+        if (!visited.has(coord)) {
+          next_level.add(coord);
+        }
+      }
+    }
+    if (next_level.has(end)) {
+      return moves + 1;
+    }
+    curr_level = next_level;
+    moves += 1;
+  }
+  return -1;
+};

From 2878106b0a9a5ddff0083778f59d4e2d3962cefb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Jan 2021 20:18:29 +0800
Subject: [PATCH 1094/3374] Update
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...ters-to-satisfy-one-of-three-conditions.js | 44 ++++++++++---------
 1 file changed, 23 insertions(+), 21 deletions(-)

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index 4036284b..3b29d69d 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -3,26 +3,28 @@
  * @param {string} b
  * @return {number}
  */
-const minCharacters = function(a, b) {
-    let n1 = a.length, n2 = b.length;
-    const cnt1 = Array(26).fill(0);
-    const cnt2 = Array(26).fill(0);
-    const aCode = ('a').charCodeAt(0);   
-    for (let c of a) ++cnt1[c.charCodeAt(0) - aCode];
-    for (let c of b) ++cnt2[c.charCodeAt(0) - aCode];
-    let res = n1 - Math.max(...cnt1) + n2 - Math.max(...cnt2);
-    for (let i = 0; i < 25; ++i) {
-      let cur1 = 0, cur2 = 0;
-      for (let j = 0; j < 26; ++j) {
-        if (j <= i) {
-          cur1 += cnt2[j];
-          cur2 += cnt1[j];
-        } else {
-          cur1 += cnt1[j];
-          cur2 += cnt2[j];
-        }
+const minCharacters = function (a, b) {
+  const n1 = a.length,
+    n2 = b.length
+  const cnt1 = Array(26).fill(0)
+  const cnt2 = Array(26).fill(0)
+  const aCode = 'a'.charCodeAt(0)
+  for (let c of a) ++cnt1[c.charCodeAt(0) - aCode]
+  for (let c of b) ++cnt2[c.charCodeAt(0) - aCode]
+  let res = n1 - Math.max(...cnt1) + n2 - Math.max(...cnt2)
+  for (let i = 0; i < 25; ++i) {
+    let cur1 = 0,
+      cur2 = 0
+    for (let j = 0; j < 26; ++j) {
+      if (j <= i) {
+        cur1 += cnt2[j]
+        cur2 += cnt1[j]
+      } else {
+        cur1 += cnt1[j]
+        cur2 += cnt2[j]
       }
-      res = Math.min(Math.min(cur1, cur2), res);
     }
-    return res;
-};
+    res = Math.min(Math.min(cur1, cur2), res)
+  }
+  return res
+}

From 51c68ea1f4ed6676128748837c7e4cdb0648132b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jan 2021 11:57:46 +0800
Subject: [PATCH 1095/3374] Create 1223-dice-roll-simulation.js

---
 1223-dice-roll-simulation.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1223-dice-roll-simulation.js

diff --git a/1223-dice-roll-simulation.js b/1223-dice-roll-simulation.js
new file mode 100644
index 00000000..2a760b53
--- /dev/null
+++ b/1223-dice-roll-simulation.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} n
+ * @param {number[]} rollMax
+ * @return {number}
+ */
+const dieSimulator = function(n, rollMax) {
+  const mod = 10 ** 9 + 7
+  const faces = rollMax.length
+  const dp = Array.from({ length: n + 1 }, () => new Array(faces + 1).fill(0))
+  dp[0][faces] = 1
+  for(let j = 0; j < faces; j++) {
+    dp[1][j] = 1
+  }
+  dp[1][faces] = faces
+  for(let i = 2; i < n + 1; i++) {
+    for(let j = 0; j < faces; j++) {
+      for(let k = 1; k < rollMax[j] + 1; k++) {
+        if(i - k < 0) break
+        dp[i][j] += dp[i - k][faces] - dp[i - k][j]
+        dp[i][j] %= mod
+      }
+    }
+    dp[i][faces] = dp[i].reduce((ac, e) => ac + e, 0)
+  }
+  return dp[n][faces] % mod
+};

From 84724a506e685a495fe4d62cef10ae6570dc289b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jan 2021 17:32:29 +0800
Subject: [PATCH 1096/3374] Create 1316-distinct-echo-substrings.js

---
 1316-distinct-echo-substrings.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1316-distinct-echo-substrings.js

diff --git a/1316-distinct-echo-substrings.js b/1316-distinct-echo-substrings.js
new file mode 100644
index 00000000..26c3b1d7
--- /dev/null
+++ b/1316-distinct-echo-substrings.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} text
+ * @return {number}
+ */
+const distinctEchoSubstrings = function (text) {
+  const set = new Set()
+  for(let len = 1; len <= text.length / 2; len++) {
+    for(let l = 0, r = len, count = 0; l < text.length - len; l++, r++) {
+      if(text.charAt(l) === text.charAt(r)) count++
+      else count = 0
+
+      if(count === len) {
+        set.add(text.slice(l - len + 1, l + 1))
+        count--
+      }
+    }
+  }
+  return set.size
+}

From 86a93f86dd6c1929e55934cedc318ac65d956a6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jan 2021 21:29:10 +0800
Subject: [PATCH 1097/3374] Update 1739-building-boxes.js

---
 1739-building-boxes.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1739-building-boxes.js b/1739-building-boxes.js
index b11d34cf..420f84d6 100644
--- a/1739-building-boxes.js
+++ b/1739-building-boxes.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minimumBoxes = function(n) {
+  let i = 1, c = 1, s = 1
+  while(s < n) {
+    i += 1, c += i, s += c
+  }
+  while(s - i >= n) {
+    s -= i, c -= 1, i -= 1
+  }
+  return c
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From 4eff252dde4d0b9fd13a3a328109068f24f99364 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Jan 2021 09:46:13 +0800
Subject: [PATCH 1098/3374] Update 287-find-the-duplicate-number.js

---
 287-find-the-duplicate-number.js | 192 +++++++++++++++++++++++++++++++
 1 file changed, 192 insertions(+)

diff --git a/287-find-the-duplicate-number.js b/287-find-the-duplicate-number.js
index 10bf088e..e4a2fa62 100755
--- a/287-find-the-duplicate-number.js
+++ b/287-find-the-duplicate-number.js
@@ -59,3 +59,195 @@ const findDuplicate = function(nums) {
     }
   }
 };
+
+
+/**
+
+# File: FindDuplicate.py
+# Author: Keith Schwarz (htiek@cs.stanford.edu)
+#
+# An algorithm for solving the following (classic) hard interview problem:
+#
+# "You are given an array of integers of length n, where each element ranges
+#  from 0 to n - 2, inclusive.  Prove that at least one  duplicate element must
+#  exist, and give an O(n)-time, O(1)-space algorithm for finding some
+#  duplicated element.  You must not modify the array elements during this 
+#  process."
+#
+# This problem (reportedly) took CS legend Don Knuth twenty-four hours to solve
+# and I have only met one person (Keith Amling) who could solve it in less time
+# than this.
+#
+# The first part of this problem - proving that at least one duplicate element
+# must exist - is a straightforward application of the pigeonhole principle.
+# If the values range from 0 to n - 2, inclusive, then there are only n - 1
+# different values.  If we have an array of n elements, one must necessarily be
+# duplicated.
+#
+# The second part of this problem - finding the duplicated element subject to
+# the given constraints - is much harder.  To solve this, we're going to need a
+# series of nonobvious insights that transform the problem into an instance of
+# something entirely different.
+#
+# The main trick we need to use to solve this problem is to notice that because
+# we have an array of n elements ranging from 0 to n - 2, we can think of the
+# array as defining a function f from the set {0, 1, ..., n - 1} onto itself.
+# This function is defined by f(i) = A[i].  Given this setup, a duplicated
+# value corresponds to a pair of indices i != j such that f(i) = f(j).  Our
+# challenge, therefore, is to find this pair (i, j).  Once we have it, we can
+# easily find the duplicated value by just picking f(i) = A[i].
+#
+# But how are we to find this repeated value?  It turns out that this is a
+# well-studied problem in computer science called cycle detection.  The general
+# form of the problem is as follows.  We are given a function f.  Define the
+# sequence x_i as
+#
+#    x_0     = k       (for some k)
+#    x_1     = f(x_0)
+#    x_2     = f(f(x_0))
+#    ...
+#    x_{n+1} = f(x_n)
+#
+# Assuming that f maps from a domain into itself, this function will have one
+# of three forms.  First, if the domain is infinite, then the sequence could be
+# infinitely long and nonrepeating.  For example, the function f(n) = n + 1 on
+# the integers has this property - no number is ever duplicated.  Second, the
+# sequence could be a closed loop, which means that there is some i so that
+# x_0 = x_i.  In this case, the sequence cycles through some fixed set of
+# values indefinitely.  Finally, the sequence could be "rho-shaped."  In this
+# case, the sequence looks something like this:
+#
+#     x_0 -> x_1 -> ... x_k -> x_{k+1} ... -> x_{k+j}
+#                        ^                       |
+#                        |                       |
+#                        +-----------------------+
+#
+# That is, the sequence begins with a chain of elements that enters a cycle,
+# then cycles around indefinitely.  We'll denote the first element of the cycle
+# that is reached in the sequence the "entry" of the cycle.
+#
+# For our particular problem of finding a duplicated element in the array,
+# consider the sequence formed by starting at position n - 1 and then
+# repeatedly applying f.  That is, we start at the last position in the array,
+# then go to the indicated index, repeating this process.  My claim is that
+# this sequence is rho-shaped.  To see this, note that it must contains a cycle
+# because the array is finite and after visiting n elements, we necessarily
+# must visit some element twice.  This is true no matter where we start off in
+# the array.  Moreover, note that since the array elements range from 0 to
+# n - 2 inclusive, there is no array index that contains n - 1 as a value.
+# Consequently, when we leave index n - 1 after applying the function f one
+# time, we can never get back there.  This means that n - 1 can't be part of a
+# cycle, but if we follow indices starting there we must eventually hit some
+# other node twice.  The concatenation of the chain starting at n - 1 with the
+# cycle it hits must be rho-shaped.
+#
+# Moreover, think about the node we encounter that starts at the entry of the
+# cycle.  Since this node is at the entry of the cycle, there must be two
+# inputs to the function f that both result in that index being generated.  For
+# this to be possible, it must be that there are indices i != j with
+# f(i) = f(j), meaning that A[i] = A[j].  Thus the index of the entry of the
+# cycle must be one of the values that is duplicated in the array.
+#
+# There is a famous algorithm due to Robert Floyd that, given a rho-shaped
+# sequence, finds the entry point of the cycle in linear time and using only
+# constant space.  This algorithm is often referred to as the "tortoise and
+# hare" algorithm, for reasons that will become clearer shortly.
+#
+# The idea behind the algorithm is to define two quantities.  First, let c be
+# the length of the chain that enters the cycle, and let l be the length of the
+# cycle.  Next, let l' be the smallest multiple of l that's larger than c.
+# I claim that for any rho-shaped sequence l' defined above, that
+#
+#    x_{l'} = x_{2l'}
+#
+# The proof is actually straightforward and very illustrative - it's one of my
+# favorite proofs in computer science.  The idea is that since l' is at least
+# c, it must be contained in the cycle.  Moreover, since l' is a multiple of
+# the length of the loop, we can write it as ml for some constant m.  If we
+# start at position x_{l'}, which is inside the loop, then take l' more steps
+# forward to get to x_{2l'}, then we will just walk around the loop m times,
+# ending up right back where we started.
+#
+# One key trick of Floyd's algorithm is that even if we don't explicitly know l
+# or c, we can still find the value l' in O(l') time.  The idea is as follows.
+# We begin by keeping track of two values "slow" and "fast," both starting at
+# x_0.  We then iteratively compute
+#
+#    slow = f(slow)
+#    fast = f(f(fast))
+#
+# We repeat this process until we find that slow and fast are equal to one
+# another.  When this happens, we know that slow = x_j for some j, and
+# fast = x_{2j} for that same j.  Since x_j = x_{2j}, we know that j must be at
+# least c, since it has to be contained in the cycle.  Moreover, we know that j
+# must be a multiple of l, since the fact that x_j = x_{2j} means that taking j
+# steps while in the cycle ends up producing the same result.  Finally, j must
+# be the smallest multiple of l greater than c, since if there were a smaller
+# multiple of l greater than c then we would have reached that multiple before
+# we reached j.  Consequently, we must have that j = l', meaning that we can
+# find l' without knowing anything about the length or shape of the cycle!
+#
+# To complete the construction, we need to show how to use our information
+# about l' to find the entry to the cycle (which is at position x_c).  To do
+# this, we start off one final variable, which we call "finder," at x_0.  We
+# then iteratively repeat the following:
+#
+#   finder = f(finder)
+#   slow   = f(slow)
+#
+# until finder = slow.  We claim that (1) the two will eventually hit each
+# other, and (2) they will hit each other at the entry to the cycle.  To see
+# this, we remark that since slow is at position x_{l'}, if we take c steps
+# forward, then we have that slow will be at position x_{l' + c}.  Since l' is
+# a multiple of the loop length, this is equivalent to taking c steps forward,
+# then walking around the loop some number of times back to where you started.
+# In other words, x_{l' + c} = x_c.  Moreover, consider the position of the
+# finder variable after c steps.  It starts at x_0, so after c steps it will be
+# at position x_c.  This proves both (1) and (2), since we've shown that the
+# two must eventually hit each other, and when they do they hit at position x_c
+# at the entry to the cycle.
+#
+# The beauty of this algorithm is that it uses only O(1) external memory to
+# keep track of two different pointers - the slow pointer, and then the fast
+# pointer (for the first half) and the finder pointer (for the second half).
+# But on top of that, it runs in O(n) time.  To see this, note that the time
+# required for the slow pointer to hit the fast pointer is O(l').  Since l' is
+# the smallest multiple of l greater than c, we have two cases to consider.
+# First, if l > c, then this is l.  Otherwise, if l < c, then we have that
+# there must be some multiple of l between c and 2c.  To see this, note that
+# in the range c and 2c there are c different values, and since l < c at least
+# one of them must be equal to 0 mod l.  Finally, the time required to find the
+# start of the cycle from this point is O(c).  This gives a total runtime of at
+# most O(c + max{l, 2c}).  All of these values are at most n, so this algorithm
+# runs in time O(n).
+
+def findArrayDuplicate(array):
+    assert len(array) > 0
+
+    # The "tortoise and hare" step.  We start at the end of the array and try
+    # to find an intersection point in the cycle.
+    slow = len(array) - 1
+    fast = len(array) - 1
+
+    # Keep advancing 'slow' by one step and 'fast' by two steps until they
+    # meet inside the loop.
+    while True:
+        slow = array[slow]
+        fast = array[array[fast]]
+
+        if slow == fast:
+            break
+
+    # Start up another pointer from the end of the array and march it forward
+    # until it hits the pointer inside the array.
+    finder = len(array) - 1
+    while True:
+        slow   = array[slow]
+        finder = array[finder]
+
+        # If the two hit, the intersection index is the duplicate element.
+        if slow == finder:
+            return slow
+
+
+*/

From 7f086bbc5b2fd6cace649886945aabc9d050fac2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Jan 2021 16:36:55 +0800
Subject: [PATCH 1099/3374] Update 660-remove-9.js

---
 660-remove-9.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/660-remove-9.js b/660-remove-9.js
index 70ef5763..c9fc656b 100644
--- a/660-remove-9.js
+++ b/660-remove-9.js
@@ -10,3 +10,13 @@ const newInteger = function (n) {
   }
   return parseInt(res, 10)
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const newInteger = function (n) {
+  return +(n).toString(9)
+}

From c8fb6bf901115d53d808b49d5da497f7b40cf6b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Jan 2021 22:38:52 +0800
Subject: [PATCH 1100/3374] Update
 448-find-all-numbers-disappeared-in-an-array.js

---
 ...find-all-numbers-disappeared-in-an-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/448-find-all-numbers-disappeared-in-an-array.js b/448-find-all-numbers-disappeared-in-an-array.js
index 40828515..bf3dd2da 100755
--- a/448-find-all-numbers-disappeared-in-an-array.js
+++ b/448-find-all-numbers-disappeared-in-an-array.js
@@ -15,3 +15,21 @@ const findDisappearedNumbers = function(nums) {
   }
   return arr;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findDisappearedNumbers = function(nums) {
+  for(let i = 0, len = nums.length; i < len; i++) {
+    const idx = Math.abs(nums[i]) - 1
+    nums[idx] = - Math.abs(nums[idx])
+  }
+  const res = []
+  nums.forEach((e, i) => {
+    if(e > 0) res.push(i + 1)
+  })
+  return res
+};

From 1f7aba87179412d4b60c3482c131a7d0981fb7f5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Jan 2021 23:54:11 +0800
Subject: [PATCH 1101/3374] Create
 1741-find-total-time-spent-by-each-employee.sql

---
 1741-find-total-time-spent-by-each-employee.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1741-find-total-time-spent-by-each-employee.sql

diff --git a/1741-find-total-time-spent-by-each-employee.sql b/1741-find-total-time-spent-by-each-employee.sql
new file mode 100644
index 00000000..02260b71
--- /dev/null
+++ b/1741-find-total-time-spent-by-each-employee.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT event_day AS day, emp_id, SUM(out_time - in_time) AS total_time
+FROM Employees
+GROUP BY event_day, emp_id;

From f99442823e7421906449bdc10762354e03db00dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 00:13:29 +0800
Subject: [PATCH 1102/3374] Create 1740-find-distance-in-a-binary-tree.js

---
 1740-find-distance-in-a-binary-tree.js | 63 ++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 1740-find-distance-in-a-binary-tree.js

diff --git a/1740-find-distance-in-a-binary-tree.js b/1740-find-distance-in-a-binary-tree.js
new file mode 100644
index 00000000..874b5878
--- /dev/null
+++ b/1740-find-distance-in-a-binary-tree.js
@@ -0,0 +1,63 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} p
+ * @param {number} q
+ * @return {number}
+ */
+const findDistance = function (root, p, q) {
+  if (p == q) return 0
+  let result = -1
+  dfs(root, p, q)
+  return result
+
+  /**
+		The return value means the distance from root node to EITHER p OR q. If
+		neither p nor q are reachable from the root, return -1.
+		
+		It is either p or q but not both, because if the root node can reach both 
+		p and q, it is a common ancestor of p and q and the answer should already 
+		be available.
+	**/
+  function dfs(root, p, q) {
+    if (root == null) return -1
+
+    let left = dfs(root.left, p, q)
+    let right = dfs(root.right, p, q)
+
+    if (root.val == p || root.val == q) {
+      // root is p or q, but none of p or q is a descendent of root.
+      // The distance from root to one of p and q is 0 in this case.
+      if (left < 0 && right < 0) {
+        return 0
+      }
+
+      // root is p or q, and root is also the LCA of p and q.
+      result = 1 + (left >= 0 ? left : right)
+      return -1
+    }
+
+    // root is neither p nor q, but it is the LCA of p and q.
+    if (left >= 0 && right >= 0) {
+      result = left + right + 2
+      return -1
+    }
+
+    if (left >= 0) {
+      return left + 1
+    }
+
+    if (right >= 0) {
+      return right + 1
+    }
+
+    return -1
+  }
+}

From 1c698d50cb3f14fcd5c9109dc6d778ef3b185ba4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 00:32:54 +0800
Subject: [PATCH 1103/3374] Update 1740-find-distance-in-a-binary-tree.js

---
 1740-find-distance-in-a-binary-tree.js | 60 ++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/1740-find-distance-in-a-binary-tree.js b/1740-find-distance-in-a-binary-tree.js
index 874b5878..9d982dec 100644
--- a/1740-find-distance-in-a-binary-tree.js
+++ b/1740-find-distance-in-a-binary-tree.js
@@ -61,3 +61,63 @@ const findDistance = function (root, p, q) {
     return -1
   }
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} p
+ * @param {number} q
+ * @return {number}
+ */
+const findDistance = function (root, p, q) {
+  let lca = lowestCommonAncestor(root, p, q)
+
+  const queue = []
+  queue.push(lca)
+  let dp = -1,
+    dq = -1
+  let d = 0
+  while (queue.length && (dp == -1 || dq == -1)) {
+    for (let k = queue.length; k > 0; k--) {
+      let node = queue.shift()
+      if (node.val == p) {
+        dp = d
+      }
+
+      if (node.val == q) {
+        dq = d
+      }
+
+      if (node.left != null) {
+        queue.push(node.left)
+      }
+
+      if (node.right != null) {
+        queue.push(node.right)
+      }
+    }
+    d++
+  }
+
+  return dp + dq
+
+  function lowestCommonAncestor(root, p, q) {
+    if (root == null || root.val == p || root.val == q) {
+      return root
+    }
+    let left = lowestCommonAncestor(root.left, p, q)
+    let right = lowestCommonAncestor(root.right, p, q)
+
+    return left == null ? right : right == null ? left : root
+  }
+}
+

From a7205ff9f3a55dba32ea3412a77d48d46bbd006f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 16:30:34 +0800
Subject: [PATCH 1104/3374] Create 1742-maximum-number-of-balls-in-a-box.js

---
 1742-maximum-number-of-balls-in-a-box.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1742-maximum-number-of-balls-in-a-box.js

diff --git a/1742-maximum-number-of-balls-in-a-box.js b/1742-maximum-number-of-balls-in-a-box.js
new file mode 100644
index 00000000..acb7c9f8
--- /dev/null
+++ b/1742-maximum-number-of-balls-in-a-box.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} lowLimit
+ * @param {number} highLimit
+ * @return {number}
+ */
+const countBalls = function(lowLimit, highLimit) {
+  const m = {}
+  for(let i = lowLimit; i <= highLimit; i++) {
+    const tmp = (i + '').split('').map(e => +e).reduce((ac, e) => ac + e, 0)
+    if(m[tmp] == null) m[tmp] = 0
+    m[tmp]++
+  }
+  const arr = Object.values(m)
+  arr.sort((a, b) => b - a)
+  return arr[0]
+};

From 91cf223e3b11fdd9bcd71aba0d1d0cb5f62a6f64 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 16:31:21 +0800
Subject: [PATCH 1105/3374] Create
 1743-restore-the-array-from-adjacent-pairs.js

---
 1743-restore-the-array-from-adjacent-pairs.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1743-restore-the-array-from-adjacent-pairs.js

diff --git a/1743-restore-the-array-from-adjacent-pairs.js b/1743-restore-the-array-from-adjacent-pairs.js
new file mode 100644
index 00000000..d4255c5e
--- /dev/null
+++ b/1743-restore-the-array-from-adjacent-pairs.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} adjacentPairs
+ * @return {number[]}
+ */
+const restoreArray = function(pairs) {
+  const m = {}
+  for(let e of pairs) {
+    const [k, v] = e
+    if(m[k] == null) m[k] = new Set()
+    if(m[v] == null) m[v] = new Set()
+    m[k].add(v)
+    m[v].add(k)
+  }
+  const q = [pairs[0]]
+  let res = pairs[0]
+  m[res[0]].delete(res[1])
+  m[res[1]].delete(res[0])
+  let n = pairs.length
+  while(n) {
+    const front = res[0], rear = res[res.length - 1]
+    
+    if(m[front]) {
+        const newf = [...m[front].values()][0]
+        if(m[front].size) res.unshift(newf)
+        if(m[front]) m[front].delete(newf)
+        if(m[newf]) m[newf].delete(front)
+        if(m[front].size === 0) delete m[front]
+    }
+     
+    if(m[rear]) {
+       const newr = [...m[rear].values()][0]
+       if(m[rear].size) res.push(newr)
+       if(m[rear]) m[rear].delete(newr)
+       if(m[newr]) m[newr].delete(rear)
+       if(m[rear].size === 0) delete m[rear]
+    }
+    n--
+  }
+    
+  return res
+};

From 574716ad411d4fb14ea46f0142aff7488feec51b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 16:32:12 +0800
Subject: [PATCH 1106/3374] Create
 1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js

---
 ...at-your-favorite-candy-on-your-favorite-day.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js

diff --git a/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js b/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js
new file mode 100644
index 00000000..1ca8866a
--- /dev/null
+++ b/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js
@@ -0,0 +1,15 @@
+function canEat(candiesCount: number[], queries: number[][]): boolean[] {
+    const acc = Array(candiesCount.length);
+    acc[0] = candiesCount[0];
+    for (let i = 1; i < candiesCount.length; i++) {
+      acc[i] = acc[i - 1] + candiesCount[i]
+    }
+
+    return queries.map(([typ, day, cap]) => {
+        let candyMin = typ === 0 ? 1 : acc[typ - 1] + 1;
+        let candyMax = acc[typ];
+        let eatMin = day + 1;
+        let eatMax = (day + 1) * cap;
+        return (candyMax < eatMin || eatMax < candyMin) ? false : true;
+    })
+};

From d32dda553301ec0b9ac3ab0d6b230a4da642296d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 16:32:52 +0800
Subject: [PATCH 1107/3374] Create 1745-palindrome-partitioning-iv.js

---
 1745-palindrome-partitioning-iv.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1745-palindrome-partitioning-iv.js

diff --git a/1745-palindrome-partitioning-iv.js b/1745-palindrome-partitioning-iv.js
new file mode 100644
index 00000000..c8eb2960
--- /dev/null
+++ b/1745-palindrome-partitioning-iv.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkPartitioning = function(s) {
+  for(let i = 1, len = s.length; i < len - 1; i++) {
+    for(let j = i + 1; j < len; j++) {
+      const s1 = s.slice(0, i), s2 = s.slice(i, j), s3 = s.slice(j)
+      if(chk(s1) && chk(s2) && chk(s3)) return true
+    }
+  }
+  return false
+};
+
+function chk(s) {
+  let l = 0, r = s.length - 1
+  for(;l <= r;) {
+    if(s[l] === s[r]) {
+      l++
+      r--
+    } else return false
+  }
+  return true
+}

From c02bc66528735a1489fa463ef7f398126bf161d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jan 2021 20:51:37 +0800
Subject: [PATCH 1108/3374] Update
 1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js

---
 ...our-favorite-candy-on-your-favorite-day.js | 34 ++++++++++++-------
 1 file changed, 21 insertions(+), 13 deletions(-)

diff --git a/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js b/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js
index 1ca8866a..ee0251c3 100644
--- a/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js
+++ b/1744-can-you-eat-your-favorite-candy-on-your-favorite-day.js
@@ -1,15 +1,23 @@
-function canEat(candiesCount: number[], queries: number[][]): boolean[] {
-    const acc = Array(candiesCount.length);
-    acc[0] = candiesCount[0];
-    for (let i = 1; i < candiesCount.length; i++) {
-      acc[i] = acc[i - 1] + candiesCount[i]
-    }
+/**
+ * @param {number[]} candiesCount
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const canEat = function(candiesCount, queries) {
+  const n = candiesCount.length
+  const pre = Array(n).fill(0)
+  for(let i = 1; i < n; i++) {
+    pre[i] = pre[i - 1] + candiesCount[i - 1]
+  }
+  return queries.map((e, i) => {
+    const [t, d, c] = e
+    const num = candiesCount[t]
+    const min = d, max = (d + 1) * c
 
-    return queries.map(([typ, day, cap]) => {
-        let candyMin = typ === 0 ? 1 : acc[typ - 1] + 1;
-        let candyMax = acc[typ];
-        let eatMin = day + 1;
-        let eatMax = (day + 1) * cap;
-        return (candyMax < eatMin || eatMax < candyMin) ? false : true;
-    })
+    if(pre[t] + num > min && pre[t] < max) {
+       return true
+    } else {
+       return false
+    }
+  })
 };

From e41f6a8eb6967a2e851b67e89fbf0bb32d765c00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Feb 2021 17:39:19 +0800
Subject: [PATCH 1109/3374] Update 1745-palindrome-partitioning-iv.js

---
 1745-palindrome-partitioning-iv.js | 51 ++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/1745-palindrome-partitioning-iv.js b/1745-palindrome-partitioning-iv.js
index c8eb2960..d342cf83 100644
--- a/1745-palindrome-partitioning-iv.js
+++ b/1745-palindrome-partitioning-iv.js
@@ -1,3 +1,54 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkPartitioning = function(s) {
+  const map = manacher(s);
+  return checkPartitioningDfs(map, s, 0);
+};
+
+function checkPartitioningDfs(map, word, i, path = []) {
+  if (path.length > 3) return false;
+  if (path.length == 3 && path.join('') == word) return true;
+  let found = false;
+  const length = map.get(i);
+  path.push(word.substr(i, length));
+  found = found || checkPartitioningDfs(map, word, i + length, path);
+  path.pop();
+
+  path.push(word.substr(i, 1));
+  found = found || checkPartitioningDfs(map, word, i + 1, path);
+  path.pop();
+  
+  return found;
+}
+
+function manacher(s) {
+  const t = '^#' + s.split('').join('#') + '#$';
+  let r = 0;
+  let c = 0;
+  let maxC = 0;
+  const rad = new Array(t.length).fill(0);
+  for (let i = 1; i < t.length - 1; ++i) {
+    if (r > i) rad[i] = Math.min(rad[2 * c - i], r - i);
+    while (t[i - rad[i] - 1] == t[i + rad[i] + 1]) rad[i]++;
+    if (i + rad[i] > r) {
+      c = i;
+      r = i + rad[i];
+    }
+    if (rad[c] > rad[maxC]) maxC = c;
+  }
+  const ans = new Map();
+  for (let i = 0; i < rad.length; ++i) {
+    if (rad[i] > 0) {
+      ans.set((i - rad[i] - 1) >>> 1, rad[i]);
+    }
+  }
+  return ans;
+}
+
+// another
+
 /**
  * @param {string} s
  * @return {boolean}

From 2249138e661ef1636dee5ee0528745d5305a9f75 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Feb 2021 20:14:51 +0800
Subject: [PATCH 1110/3374] Update 1745-palindrome-partitioning-iv.js

---
 1745-palindrome-partitioning-iv.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1745-palindrome-partitioning-iv.js b/1745-palindrome-partitioning-iv.js
index d342cf83..8576c981 100644
--- a/1745-palindrome-partitioning-iv.js
+++ b/1745-palindrome-partitioning-iv.js
@@ -47,6 +47,31 @@ function manacher(s) {
   return ans;
 }
 
+// another
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkPartitioning = function (s) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(false))
+  for(let i = n - 1; i >= 0; i--) {
+    for(let j = i; j < n; j++) {
+      if(s[i] === s[j]) {
+        dp[i][j] = i + 1 <= j - 1 ? dp[i + 1][j - 1] : true
+      } else dp[i][j] = false
+    }
+  }
+  for(let i = 1; i < n - 1; i++) {
+    for(let j = i; j < n - 1; j++) {
+      if(dp[0][i - 1] && dp[i][j] && dp[j + 1][n - 1]) return true
+    }
+  }
+  return false
+}
+
+
 // another
 
 /**

From 1c09df7713ebfa33fb16cfb3260cb566b776a487 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Feb 2021 10:27:09 +0800
Subject: [PATCH 1111/3374] Create
 1299-replace-elements-with-greatest-element-on-right-side.js

---
 ...e-elements-with-greatest-element-on-right-side.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1299-replace-elements-with-greatest-element-on-right-side.js

diff --git a/1299-replace-elements-with-greatest-element-on-right-side.js b/1299-replace-elements-with-greatest-element-on-right-side.js
new file mode 100644
index 00000000..c37e674a
--- /dev/null
+++ b/1299-replace-elements-with-greatest-element-on-right-side.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+const replaceElements = function(arr) {
+  const suffix = [-1], n = arr.length
+  for(let i = n - 2; i >= 0; i--) {
+    suffix.unshift(Math.max(suffix[0], arr[i + 1]))
+  }
+  
+  return suffix
+};

From 84673bb53468562f1a901dc49105ad97eb2fb636 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Feb 2021 11:19:09 +0800
Subject: [PATCH 1112/3374] Create 1252-cells-with-odd-values-in-a-matrix.js

---
 1252-cells-with-odd-values-in-a-matrix.js | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1252-cells-with-odd-values-in-a-matrix.js

diff --git a/1252-cells-with-odd-values-in-a-matrix.js b/1252-cells-with-odd-values-in-a-matrix.js
new file mode 100644
index 00000000..aa00e19c
--- /dev/null
+++ b/1252-cells-with-odd-values-in-a-matrix.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number[][]} indices
+ * @return {number}
+ */
+const oddCells = function (n, m, indices) {
+  const oddRows = new BitSet(n),
+    oddCols = new BitSet(m)
+  let cntRow = 0,
+    cntCol = 0
+  for (let idx of indices) {
+    oddRows.flip(idx[0])
+    oddCols.flip(idx[1])
+    cntRow += oddRows.get(idx[0]) ? 1 : -1
+    cntCol += oddCols.get(idx[1]) ? 1 : -1
+  }
+  return (m - cntCol) * cntRow + (n - cntRow) * cntCol
+}
+
+class BitSet {
+  constructor(n) {
+    this.arr = Array(n).fill(0)
+  }
+  flip(idx) {
+    this.arr[idx] = this.arr[idx] === 0 ? 1 : 0
+  }
+  get(idx) {
+    return this.arr[idx]
+  }
+}

From 7e0fea972335f2d81cf3e7b20797c1b6d4d3f5c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Feb 2021 15:15:54 +0800
Subject: [PATCH 1113/3374] Create
 1365-how-many-numbers-are-smaller-than-the-current-number.js

---
 ...umbers-are-smaller-than-the-current-number.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1365-how-many-numbers-are-smaller-than-the-current-number.js

diff --git a/1365-how-many-numbers-are-smaller-than-the-current-number.js b/1365-how-many-numbers-are-smaller-than-the-current-number.js
new file mode 100644
index 00000000..82b033a9
--- /dev/null
+++ b/1365-how-many-numbers-are-smaller-than-the-current-number.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const smallerNumbersThanCurrent = function(nums) {
+    const count = new Array(101).fill(0);
+    const res = new Array(nums.length).fill(0);
+    for (let i = 0; i < nums.length; i++) count[nums[i]]++
+    for (let i = 1 ; i <= 100; i++) count[i] += count[i-1]
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] == 0) res[i] = 0
+        else res[i] = count[nums[i] - 1]
+    }
+    return res;
+};
+

From 105a8dcf269f1d303414372eb9b69d63d676a65a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Feb 2021 21:03:50 +0800
Subject: [PATCH 1114/3374] Update 28-implement-strStr().js

---
 28-implement-strStr().js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/28-implement-strStr().js b/28-implement-strStr().js
index 6475ee3b..98513914 100755
--- a/28-implement-strStr().js
+++ b/28-implement-strStr().js
@@ -1,3 +1,35 @@
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+const strStr = function(a, b) {
+  if(b === '') return 0
+  if(a.length < b.length) return -1
+  if(a.length === b.length) return a === b ? 0 : -1
+  const m = a.length, n = b.length
+  const fail = Array(n).fill(-1)
+  // DFA
+  for(let i = 1; i < n; i++) {
+    let j = fail[i - 1]
+    while(j !== -1 && b[j + 1] !== b[i]) {
+      j = fail[j]      
+    }
+    if(b[j + 1] === b[i]) fail[i] = j + 1
+  }
+  let pos = -1
+  for(let i = 0; i < m; i++) {
+    while(pos !== -1 && a[i] !== b[pos + 1]) pos = fail[pos]
+    if(a[i] === b[pos + 1]) {
+      pos++
+      if(pos === n - 1) return i - n + 1
+    }
+  }
+  return -1
+};
+
+// another
+
 /**
  * @param {string} haystack
  * @param {string} needle

From 323504b6c22c3441cfaf89903c0cb296d12f1c58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Feb 2021 19:35:55 +0800
Subject: [PATCH 1115/3374] Update 214-shortest-palindrome.js

---
 214-shortest-palindrome.js | 39 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/214-shortest-palindrome.js b/214-shortest-palindrome.js
index a0b99e14..fce3267e 100644
--- a/214-shortest-palindrome.js
+++ b/214-shortest-palindrome.js
@@ -11,3 +11,42 @@ const shortestPalindrome = function(s) {
   let suffix = s.substring(j);
   return suffix.split('').reverse().join('') + shortestPalindrome(s.substring(0, j)) + suffix;
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const shortestPalindrome = function (s) {
+  const tmp = s + '#' + s.split('').reverse().join('')
+  const fail = getFail(tmp)
+  return (
+    s
+      .split('')
+      .slice(fail[fail.length - 1])
+      .reverse()
+      .join('') + s
+  )
+}
+
+function getFail(s) {
+  const n = s.length
+  const table = new Array(n).fill(0)
+  let index = 0
+  for (let i = 1; i < n; ) {
+    if (s.charAt(index) === s.charAt(i)) {
+      table[i] = ++index
+      i++
+    } else {
+      if (index > 0) {
+        index = table[index - 1]
+      } else {
+        index = 0
+        i++
+      }
+    }
+  }
+  return table
+}
+

From fb682b338be69dfbbe8bb861fe8de0ae36b523ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Feb 2021 13:17:00 +0800
Subject: [PATCH 1116/3374] Create
 1746-maximum-subarray-sum-after-one-operation.js

---
 1746-maximum-subarray-sum-after-one-operation.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1746-maximum-subarray-sum-after-one-operation.js

diff --git a/1746-maximum-subarray-sum-after-one-operation.js b/1746-maximum-subarray-sum-after-one-operation.js
new file mode 100644
index 00000000..e2ae70ed
--- /dev/null
+++ b/1746-maximum-subarray-sum-after-one-operation.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumAfterOperation = function(nums) {
+  const n = nums.length
+  const dp = Array.from({ length: n }, () => Array(2).fill(0))
+  dp[0][0] = nums[0], dp[0][1] = nums[0] * nums[0]
+  let res = dp[0][1]
+  for(let i = 1; i < n; i++) {
+    dp[i][0] = Math.max(nums[i], dp[i - 1][0] + nums[i])
+    dp[i][1] = Math.max(nums[i] * nums[i], dp[i - 1][0] + nums[i] * nums[i], dp[i - 1][1] + nums[i])
+    res = Math.max(res, dp[i][1])
+  }
+  return res
+};

From 358d3397f6bea67009c8b1ab3c25fbb826859f4e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Feb 2021 13:26:41 +0800
Subject: [PATCH 1117/3374] Create 1747-leetflex-banned-accounts.sql

---
 1747-leetflex-banned-accounts.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1747-leetflex-banned-accounts.sql

diff --git a/1747-leetflex-banned-accounts.sql b/1747-leetflex-banned-accounts.sql
new file mode 100644
index 00000000..6dd14d01
--- /dev/null
+++ b/1747-leetflex-banned-accounts.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT DISTINCT L1.account_id FROM LogInfo L1 INNER JOIN LogInfo L2 
+ON L1.account_id = L2.account_id 
+AND L1.ip_address <> L2.ip_address 
+AND (L1.login BETWEEN L2.login AND L2.logout OR L1.logout BETWEEN L2.login AND L2.logout);

From 7a79ac8ea6736d567a77216319fa28101be5a13b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Feb 2021 23:33:51 +0800
Subject: [PATCH 1118/3374] Update 459-repeated-substring-pattern.js

---
 459-repeated-substring-pattern.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/459-repeated-substring-pattern.js b/459-repeated-substring-pattern.js
index 38c2c927..2ed1fcce 100644
--- a/459-repeated-substring-pattern.js
+++ b/459-repeated-substring-pattern.js
@@ -54,3 +54,20 @@ const repeatedSubstringPattern = function (s) {
     return prefix
   }
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const repeatedSubstringPattern = function(s) {
+    let i = 1, j = 0, n = s.length;
+    const dp = Array(n + 1).fill(0);
+    while( i < s.length ){
+        if( s[i] === s[j] ) dp[++i] = ++j;
+        else if( j === 0 ) i++;
+        else j = dp[j];
+    }
+    return dp[n] && (dp[n] % (n - dp[n]) === 0);   
+};

From e31727c2a3bbd91ba95de603ad34e0623888c55a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:47:58 +0800
Subject: [PATCH 1119/3374] Create 1748-sum-of-unique-elements.js

---
 1748-sum-of-unique-elements.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1748-sum-of-unique-elements.js

diff --git a/1748-sum-of-unique-elements.js b/1748-sum-of-unique-elements.js
new file mode 100644
index 00000000..bb9ef416
--- /dev/null
+++ b/1748-sum-of-unique-elements.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfUnique = function(nums) {
+  const m = {}
+  for(let e of nums) {
+      if(m[e] == null) m[e] = 0
+      m[e]++
+  }
+  let res = 0
+  // console.log(m)
+  Object.entries(m).forEach(e => {
+      const [k, v] = e
+      if(v === 1) res += +k
+  })
+  return res
+};

From 4c2cf5820f67a56243fffc0a07be9c5a7623def3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:48:26 +0800
Subject: [PATCH 1120/3374] Create 1749-maximum-absolute-sum-of-any-subarray.js

---
 1749-maximum-absolute-sum-of-any-subarray.js | 32 ++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1749-maximum-absolute-sum-of-any-subarray.js

diff --git a/1749-maximum-absolute-sum-of-any-subarray.js b/1749-maximum-absolute-sum-of-any-subarray.js
new file mode 100644
index 00000000..9469466e
--- /dev/null
+++ b/1749-maximum-absolute-sum-of-any-subarray.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxAbsoluteSum = function(nums) {
+            let min = 0, max = 0;
+            let positiveSum = 0, negativeSum = 0;
+            for (let num of nums)
+            {
+                positiveSum += num;
+                if (positiveSum > max)
+                {
+                    max = positiveSum;
+                }
+
+                if (positiveSum < 0)
+                {
+                    positiveSum = 0;
+                }
+                negativeSum += num;
+                if (negativeSum < min)
+                {
+                    min = negativeSum;
+                }
+                if (negativeSum > 0)
+                {
+                    negativeSum = 0;
+                }
+            }
+
+            return Math.max(Math.abs(min), max);
+};

From ac4d7f2d3bcedc7647bdf339428e080473bc8d10 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:48:58 +0800
Subject: [PATCH 1121/3374] Create
 1750-minimum-length-of-string-after-deleting-similar-ends.js

---
 ...ength-of-string-after-deleting-similar-ends.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1750-minimum-length-of-string-after-deleting-similar-ends.js

diff --git a/1750-minimum-length-of-string-after-deleting-similar-ends.js b/1750-minimum-length-of-string-after-deleting-similar-ends.js
new file mode 100644
index 00000000..14f152cc
--- /dev/null
+++ b/1750-minimum-length-of-string-after-deleting-similar-ends.js
@@ -0,0 +1,15 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumLength = function(s) {
+  const n = s.length
+  let l = 0, r = n - 1
+  while(l < r && s[l] === s[r]) {
+    while(l < r - 1 && s[r] === s[r - 1]) r--
+    while(l + 1 < r && s[l] === s[l + 1]) l++
+    l++
+    r--
+  }
+  return r - l + 1
+};

From 5c189bc50c65644efb814d01d6eab90a0eec258c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:49:33 +0800
Subject: [PATCH 1122/3374] Create
 1751-maximum-number-of-events-that-can-be-attended-ii.js

---
 ...umber-of-events-that-can-be-attended-ii.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1751-maximum-number-of-events-that-can-be-attended-ii.js

diff --git a/1751-maximum-number-of-events-that-can-be-attended-ii.js b/1751-maximum-number-of-events-that-can-be-attended-ii.js
new file mode 100644
index 00000000..ddf33c47
--- /dev/null
+++ b/1751-maximum-number-of-events-that-can-be-attended-ii.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} events
+ * @param {number} k
+ * @return {number}
+ */
+const maxValue = function(events, k) {
+
+        cache = new Map();
+        events.sort((a,b) => a[0] - b[0]);
+        return dfs(events, 0, -1, k);
+    
+    function dfs(events, idx, end, k){
+        let key = idx + "," + end + "," + k;
+        if(cache.has(key)){
+            return cache.get(key);
+        }
+        if(idx >= events.length){
+            return 0;
+        }
+        if(k == 0) {
+            return 0;
+        }
+        let max = 0;
+        if(events[idx][0] > end){
+            max = Math.max(max, dfs(events, idx+1, events[idx][1], k-1) + events[idx][2]);
+        }
+        
+        max = Math.max(max, dfs(events, idx+1, end, k));
+        cache.set(key, max);
+        return max;
+    }
+};

From fb122d513054dca8266798af386fc0d899d27fa5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:50:02 +0800
Subject: [PATCH 1123/3374] Create 1752-check-if-array-is-sorted-and-rotated.js

---
 1752-check-if-array-is-sorted-and-rotated.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1752-check-if-array-is-sorted-and-rotated.js

diff --git a/1752-check-if-array-is-sorted-and-rotated.js b/1752-check-if-array-is-sorted-and-rotated.js
new file mode 100644
index 00000000..e634b954
--- /dev/null
+++ b/1752-check-if-array-is-sorted-and-rotated.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const check = function(nums) {
+  let prev = -1, mark = 0
+  for(let e of nums) {
+    
+    if(e >= prev) prev = e
+    else {
+      mark++
+      prev = e
+    }
+    if(mark > 1) return false
+  }
+  if(mark === 1 && nums[0] < nums[nums.length - 1]) {
+      return false
+  }
+  return true
+};

From b0cff89d4a95f5627763036991bbc1ce5906b947 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:50:33 +0800
Subject: [PATCH 1124/3374] Create 1753-maximum-score-from-removing-stones.js

---
 1753-maximum-score-from-removing-stones.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1753-maximum-score-from-removing-stones.js

diff --git a/1753-maximum-score-from-removing-stones.js b/1753-maximum-score-from-removing-stones.js
new file mode 100644
index 00000000..fe93eed7
--- /dev/null
+++ b/1753-maximum-score-from-removing-stones.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number}
+ */
+const maximumScore = function(a, b, c) {
+  const arr = [a, b, c]
+  arr.sort((a, b) => a - b)
+  
+
+    if (arr[0] + arr[1] <= arr[2]) {
+        return arr[0] + arr[1];
+    } else {
+        const min = Math.min(arr[0], Math.floor((arr[1] + arr[0] - arr[2]) / 2));
+        return arr[2] + min;
+    }
+};

From 8fc20030f2643953f6d9092db15437bdf2d18312 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:51:02 +0800
Subject: [PATCH 1125/3374] Create 1754-largest-merge-of-two-strings.js

---
 1754-largest-merge-of-two-strings.js | 36 ++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1754-largest-merge-of-two-strings.js

diff --git a/1754-largest-merge-of-two-strings.js b/1754-largest-merge-of-two-strings.js
new file mode 100644
index 00000000..dadc74d8
--- /dev/null
+++ b/1754-largest-merge-of-two-strings.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {string}
+ */
+const largestMerge = function(word1, word2) {
+  const stack1 = word1.split(''), stack2 = word2.split('')
+  const arr = []
+  
+  while(stack1.length && stack2.length) {
+    const c1 = stack1[0], c2 = stack2[0]
+    if(c1 > c2) {
+      stack1.shift()
+      arr.push(c1)
+    } else if(c1 < c2) {
+      stack2.shift()
+      arr.push(c2)
+    } else {
+      if(stack1.join('') > stack2.join('')) {
+        stack1.shift()
+        arr.push(c1)
+      } else {
+        stack2.shift()
+          arr.push(c2)
+      }
+    }
+  }
+  if(stack1.length) {
+    arr.push(...stack1)
+  }
+  if(stack2.length) {
+    arr.push(...stack2)
+  } 
+  
+  return arr.join('')
+};

From 4b55359051fc2126cbe46c48c1efc7144b3ce494 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Feb 2021 15:51:43 +0800
Subject: [PATCH 1126/3374] Create 1755-closest-subsequence-sum.js

---
 1755-closest-subsequence-sum.js | 75 +++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 1755-closest-subsequence-sum.js

diff --git a/1755-closest-subsequence-sum.js b/1755-closest-subsequence-sum.js
new file mode 100644
index 00000000..0f8fd60d
--- /dev/null
+++ b/1755-closest-subsequence-sum.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number[]} nums
+ * @param {number} goal
+ * @return {number}
+ */
+var minAbsDifference = function(a, b) {
+        let n = a.length, m = (n / 2) >> 0, r = n - m;
+        let ans = 2e9;
+        const {max, min, abs} = Math
+        const va = [], vb = [];
+        for(let i=0;i<1<<m;++i) {
+            let tmp=0;
+            for(let j=0;j<m;++j) {
+                if(i>>j&1) tmp+=a[j];
+            }
+            ans=min(ans,abs(tmp-b));
+            va.push(tmp);
+        }
+        // sort(va.begin(), va.end());
+        va.sort((a, b) => a - b)
+        for(let i=0;i<1<<r;++i) {
+            let tmp=0;
+            for(let j=0;j<r;++j) {
+                if(i>>j&1) tmp+=a[j+m];
+            }
+            ans=min(ans,abs(tmp-b));
+            let k=b-tmp;
+            let pos=lower_bound(va, k);
+            for(let j=pos-1;j<=pos+1;++j) {
+                if(j>=0 && j<va.length) {
+                    ans=min(ans, abs(va[j]+tmp-b));
+                }
+            }
+        }
+        return ans;
+};
+
+function lower_bound(array, arg1, arg2, arg3, arg4) {
+    let first;
+    let last;
+    let value;
+    let less;
+    if (arg3 === undefined) {
+        first = 0;
+        last = array.length;
+        value = arg1;
+        less = arg2;
+    } else {
+        first = arg1;
+        last = arg2;
+        value = arg3;
+        less = arg4;
+    }
+
+    if (less === undefined) {
+        less = function (a, b) { return a < b; };
+    }
+
+    let len = last - first;
+    let middle;
+    let step;
+    while (len > 0) {
+        step = Math.floor(len / 2);
+        middle = first + step;
+        if (less(array[middle], value, middle)) {
+            first = middle;
+            first += 1;
+            len = len - step - 1;
+        } else {
+            len = step;
+        }
+    }
+    return first;
+};
+

From 2fa516122223d491a0b0f57294931b4c28f78762 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Feb 2021 20:04:12 +0800
Subject: [PATCH 1127/3374] Create 1367-linked-list-in-binary-tree.js

---
 1367-linked-list-in-binary-tree.js | 43 ++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 1367-linked-list-in-binary-tree.js

diff --git a/1367-linked-list-in-binary-tree.js b/1367-linked-list-in-binary-tree.js
new file mode 100644
index 00000000..41e48b07
--- /dev/null
+++ b/1367-linked-list-in-binary-tree.js
@@ -0,0 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const isSubPath = function(head, root) {
+  const res = { found: false }
+  traverse(root, head, res)
+  return res.found
+};
+
+function traverse(node, list, res) {
+  if(res.found) return
+  if(node == null) return
+  if(node.val === list.val && helper(node, list)) {
+    res.found = true
+    return
+  } 
+  traverse(node.left, list, res)
+  traverse(node.right, list, res)
+}
+
+function helper(node, list) {
+  if(list == null) return true
+  if(node == null) return false
+  if(list.val !== node.val) return false
+  return helper(node.left, list.next) || helper(node.right, list.next)
+}

From 59fea935f1c8ffa84629ea90684bd3ee6033062b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Feb 2021 18:25:37 +0800
Subject: [PATCH 1128/3374] Update 1749-maximum-absolute-sum-of-any-subarray.js

---
 1749-maximum-absolute-sum-of-any-subarray.js | 49 +++++++++-----------
 1 file changed, 23 insertions(+), 26 deletions(-)

diff --git a/1749-maximum-absolute-sum-of-any-subarray.js b/1749-maximum-absolute-sum-of-any-subarray.js
index 9469466e..9e8b4440 100644
--- a/1749-maximum-absolute-sum-of-any-subarray.js
+++ b/1749-maximum-absolute-sum-of-any-subarray.js
@@ -2,31 +2,28 @@
  * @param {number[]} nums
  * @return {number}
  */
-const maxAbsoluteSum = function(nums) {
-            let min = 0, max = 0;
-            let positiveSum = 0, negativeSum = 0;
-            for (let num of nums)
-            {
-                positiveSum += num;
-                if (positiveSum > max)
-                {
-                    max = positiveSum;
-                }
+const maxAbsoluteSum = function (nums) {
+  let min = Infinity,
+    max = -Infinity
+  let positiveSum = 0,
+    negativeSum = 0
+  for (let num of nums) {
+    positiveSum += num
+    if (positiveSum > max) {
+      max = positiveSum
+    }
 
-                if (positiveSum < 0)
-                {
-                    positiveSum = 0;
-                }
-                negativeSum += num;
-                if (negativeSum < min)
-                {
-                    min = negativeSum;
-                }
-                if (negativeSum > 0)
-                {
-                    negativeSum = 0;
-                }
-            }
+    if (positiveSum < 0) {
+      positiveSum = 0
+    }
+    negativeSum += num
+    if (negativeSum < min) {
+      min = negativeSum
+    }
+    if (negativeSum > 0) {
+      negativeSum = 0
+    }
+  }
 
-            return Math.max(Math.abs(min), max);
-};
+  return Math.max(Math.abs(min), max)
+}

From fe93afaeaddeb70ade77e2db17aa7f2d25c3006f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Feb 2021 18:51:06 +0800
Subject: [PATCH 1129/3374] Update 1749-maximum-absolute-sum-of-any-subarray.js

---
 1749-maximum-absolute-sum-of-any-subarray.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1749-maximum-absolute-sum-of-any-subarray.js b/1749-maximum-absolute-sum-of-any-subarray.js
index 9e8b4440..503164e2 100644
--- a/1749-maximum-absolute-sum-of-any-subarray.js
+++ b/1749-maximum-absolute-sum-of-any-subarray.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxAbsoluteSum = function (nums) {
+  let min = 0,
+    max = 0,
+    sum = 0
+  for(let e of nums) {
+    sum += e
+    min = Math.min(sum, min)
+    max = Math.max(sum, max)
+  }
+  return max - min
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 5d0eaeea9902a454c2c37181e4047d536cab50bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Feb 2021 22:25:09 +0800
Subject: [PATCH 1130/3374] Update
 1751-maximum-number-of-events-that-can-be-attended-ii.js

---
 ...umber-of-events-that-can-be-attended-ii.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1751-maximum-number-of-events-that-can-be-attended-ii.js b/1751-maximum-number-of-events-that-can-be-attended-ii.js
index ddf33c47..0de7c6d0 100644
--- a/1751-maximum-number-of-events-that-can-be-attended-ii.js
+++ b/1751-maximum-number-of-events-that-can-be-attended-ii.js
@@ -1,3 +1,47 @@
+/**
+ * @param {number[][]} events
+ * @param {number} k
+ * @return {number}
+ */
+const maxValue = function (events, k) {
+  // d[i][j] 表示以 events[i]结尾的取最多j个最大值
+  // d[i][j-1],  Math.max( d[m][j-1] + v[i]) for m ending < start[i]
+  events.sort((a, b) => a[1] - b[1])
+  const n = events.length
+  let d = []
+  for (let j = 0; j <= k; j++) {
+    const newD = []
+    for (let i = 0; i < n; i++) {
+      if (j === 0) {
+        newD[i] = 0
+      } else if (j === 1) {
+        newD[i] = events[i][2]
+      } else if (i === 0) {
+        newD[i] = events[i][2]
+      } else {
+        newD[i] = d[i] // 以i结尾最多取j-1次的最大值
+        const v = events[i][2]
+        const start = events[i][0]
+        for (let m = 0; m < i; m++) {
+          if (events[m][1] < start) {
+            if (d[m] + v > newD[i]) {
+              newD[i] = d[m] + v
+            }
+          } else {
+            break
+          }
+        }
+      }
+    }
+    d = [...newD]
+  }
+  return Math.max(...d)
+}
+
+
+// another
+
+
 /**
  * @param {number[][]} events
  * @param {number} k

From 726f53c13f8df9dc2f6137b41ba1d361e9ed9230 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Feb 2021 21:46:14 +0800
Subject: [PATCH 1131/3374] Update 1754-largest-merge-of-two-strings.js

---
 1754-largest-merge-of-two-strings.js | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/1754-largest-merge-of-two-strings.js b/1754-largest-merge-of-two-strings.js
index dadc74d8..f910ba72 100644
--- a/1754-largest-merge-of-two-strings.js
+++ b/1754-largest-merge-of-two-strings.js
@@ -1,3 +1,40 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {string}
+ */
+var largestMerge = function(word1, word2) {
+    let merge = "";
+    
+    while(word1.length && word2.length) {
+        if (word1[0] > word2[0]) {
+            merge += word1[0];
+            word1 = word1.slice(1);
+        } else if (word1[0] < word2[0]) {
+            merge += word2[0];
+            word2 = word2.slice(1);
+        } else {
+            if (word1 > word2) {
+                merge += word1[0];
+                word1 = word1.slice(1);
+            } else {
+                merge += word2[0];
+                word2 = word2.slice(1);
+            }
+        }
+    }
+    
+    if (word1.length) {
+        merge += word1;
+    } else if (word2.length) {
+        merge += word2;
+    }
+    
+    return merge;  
+};
+
+// another
+
 /**
  * @param {string} word1
  * @param {string} word2

From 1013531489a903470f604d1e689c7bcf84eaf2c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Feb 2021 00:19:12 +0800
Subject: [PATCH 1132/3374] Update 1755-closest-subsequence-sum.js

---
 1755-closest-subsequence-sum.js | 55 +++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/1755-closest-subsequence-sum.js b/1755-closest-subsequence-sum.js
index 0f8fd60d..f7fee8e8 100644
--- a/1755-closest-subsequence-sum.js
+++ b/1755-closest-subsequence-sum.js
@@ -1,3 +1,58 @@
+/**
+ * @param {number[]} nums
+ * @param {number} goal
+ * @return {number}
+ */
+const minAbsDifference = function (nums, goal) {
+  let min = Math.abs(goal)
+  if (!nums.length) return min
+  const generateSums = (a) => {
+    let sums = []
+    for (let i = 0; i < a.length; i++) {
+      const l = sums.length
+      for (let j = 0; j < l; j++) {
+        sums.push(sums[j] + a[i])
+        min = Math.min(min, Math.abs(sums[j] + a[i] - goal))
+        if (min === 0) return
+      }
+      sums.push(a[i])
+      min = Math.min(min, Math.abs(a[i] - goal))
+      if (min === 0) return
+    }
+    return sums
+  }
+
+  const n1 = nums.slice(0, Math.ceil(nums.length / 2))
+  const n2 = nums.slice(Math.ceil(nums.length / 2), nums.length)
+  const sums1 = generateSums(n1)
+  if (min === 0) return min
+  const sums2 = generateSums(n2)
+  if (min === 0) return min
+
+  sums2.sort((a, b) => a - b)
+  for (let i = 0; i < sums1.length; i++) {
+    if (min === 0) return min
+    let l = 0
+    let r = sums2.length
+    let sum
+    while (l < r) {
+      const h = Math.floor((l + r) / 2)
+      sum = sums1[i] + sums2[h]
+      min = Math.min(min, Math.abs(sum - goal))
+      if (min === 0) return min
+      if (sum - goal < 0) {
+        l = h + 1
+      } else {
+        r = h
+      }
+    }
+  }
+  return min
+}
+
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} goal

From ede258dddddaadf4918ba29a04b5223202d191aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Feb 2021 23:48:16 +0800
Subject: [PATCH 1133/3374] Update 743-network-delay-time.js

---
 743-network-delay-time.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/743-network-delay-time.js b/743-network-delay-time.js
index e66a70c4..153e225e 100644
--- a/743-network-delay-time.js
+++ b/743-network-delay-time.js
@@ -17,3 +17,33 @@ const networkDelayTime = function (times, N, K) {
   }
   return mins.includes(Infinity) ? -1 : Math.max(...mins)
 }
+
+// another
+
+/**
+ * @param {number[][]} times
+ * @param {number} N
+ * @param {number} K
+ * @return {number}
+ */
+const networkDelayTime = function(times, N, K) {
+    const distances = new Array(N).fill(Infinity);
+    distances[K - 1] = 0;
+    
+    for(let i = 0 ; i < N -1 ; i++){
+        let counter = 0;
+        for(let j = 0 ; j < times.length ; j++){
+            const source = times[j][0];
+            const target = times[j][1];
+            const weight = times[j][2];
+            if(distances[source - 1] + weight < distances[target - 1]){
+                distances[target - 1] = distances[source - 1] + weight;
+                counter++
+            }
+        }
+        if(counter === 0) break
+    }
+    
+    const res = Math.max(...distances);
+    return res === Infinity ? -1 : res;
+};

From 467eb78aa0bbef3867a1a781036e0a583d118ff6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Feb 2021 12:20:57 +0800
Subject: [PATCH 1134/3374] Create
 1761-minimum-degree-of-a-connected-trio-in-a-graph.js

---
 ...m-degree-of-a-connected-trio-in-a-graph.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1761-minimum-degree-of-a-connected-trio-in-a-graph.js

diff --git a/1761-minimum-degree-of-a-connected-trio-in-a-graph.js b/1761-minimum-degree-of-a-connected-trio-in-a-graph.js
new file mode 100644
index 00000000..0b29335a
--- /dev/null
+++ b/1761-minimum-degree-of-a-connected-trio-in-a-graph.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const minTrioDegree = function(n, edges) {
+        let ans = 10 ** 8
+        const adj = []
+        const deg = {}
+               
+        function incDeg(u) {
+            if(deg[u] == null) deg[u] = 0
+            deg[u]++
+        }
+        for(let i = 0; i < n; i++) {
+            adj.push(Array(n).fill(false))
+        }
+            
+        for (let [u, v] of edges) {
+            adj[u - 1][v - 1] = true
+            adj[v - 1][u - 1] = true
+            incDeg(u - 1)
+            incDeg(v - 1)
+        }
+        for(let u1 = 0; u1 < n; u1++) {
+            for(let u2 = u1 + 1; u2 < n; u2++) {
+                for(let u3 = u2 + 1; u3 < n; u3++) {
+                    if(adj[u1][u2] && adj[u2][u3] && adj[u3][u1]) {
+                       let tmp = deg[u1] + deg[u2] + deg[u3] - 6
+                       ans = Math.min(ans, tmp)
+                    }
+                }
+            }
+        }
+
+        if (ans > 10000000) ans = -1
+        return ans
+};

From e83c9ab1baf573062e5df091b676b64a6e73f0f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Feb 2021 12:22:00 +0800
Subject: [PATCH 1135/3374] Create 1760-minimum-limit-of-balls-in-a-bag.js

---
 1760-minimum-limit-of-balls-in-a-bag.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1760-minimum-limit-of-balls-in-a-bag.js

diff --git a/1760-minimum-limit-of-balls-in-a-bag.js b/1760-minimum-limit-of-balls-in-a-bag.js
new file mode 100644
index 00000000..fd3e868f
--- /dev/null
+++ b/1760-minimum-limit-of-balls-in-a-bag.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @param {number} maxOperations
+ * @return {number}
+ */
+const minimumSize = function(nums, maxOperations) {
+        let L = 1, R = 10 ** 9;
+        while(L < R){
+            let M = (L + (R - L) / 2) >> 0, cnt = 0;
+            for(let x of nums) cnt += ((x + M - 1) / M - 1) >> 0;
+            if(cnt > maxOperations) L = M + 1;
+            else R = M;
+        }
+        return L;
+};
+

From 519dede455a35eee2fa8a36b60dfad6500e138a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Feb 2021 12:22:37 +0800
Subject: [PATCH 1136/3374] Create
 1759-count-number-of-homogenous-substrings.js

---
 1759-count-number-of-homogenous-substrings.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1759-count-number-of-homogenous-substrings.js

diff --git a/1759-count-number-of-homogenous-substrings.js b/1759-count-number-of-homogenous-substrings.js
new file mode 100644
index 00000000..a60e7c32
--- /dev/null
+++ b/1759-count-number-of-homogenous-substrings.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countHomogenous = function(s) {
+  const mod = 10 ** 9 + 7
+  let pre = s[0], res = 0, curL = 1
+  for(let i = 1, len = s.length; i < len; i++) {
+    if(s[i] === pre) {
+      curL++
+    } else {
+      res = (res + helper(curL)) % mod
+      pre = s[i]
+      curL = 1
+    }
+  }
+  if(curL === 1) res = (res + 1) % mod
+  else res = (res + helper(curL)) % mod
+  return res
+
+  function helper(num) {
+     return (num * (num + 1)) / 2
+  }
+};
+

From 1044587d179ad219c0298a9cfc59f14d0eea7e18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Feb 2021 12:23:05 +0800
Subject: [PATCH 1137/3374] Create
 1758-minimum-changes-to-make-alternating-binary-string.js

---
 ...um-changes-to-make-alternating-binary-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1758-minimum-changes-to-make-alternating-binary-string.js

diff --git a/1758-minimum-changes-to-make-alternating-binary-string.js b/1758-minimum-changes-to-make-alternating-binary-string.js
new file mode 100644
index 00000000..de91c4bb
--- /dev/null
+++ b/1758-minimum-changes-to-make-alternating-binary-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minOperations = function(s) {
+  const arr = s.split('')
+  return Math.min(helper(arr, 0, '0'), helper(arr, 0, '1'))
+    
+  function helper(arr, idx, ch) {
+    if(idx === arr.length) return 0
+    if(arr[idx] !== ch) return 1 + helper(arr, idx + 1, ch === '0' ? '1' : '0')
+    else return helper(arr, idx + 1, ch === '0' ? '1' : '0')
+  }
+};

From e79d9d3fd73acc946d86ee199b84f2d4907fa49e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Feb 2021 20:01:50 +0800
Subject: [PATCH 1138/3374] Update
 1761-minimum-degree-of-a-connected-trio-in-a-graph.js

---
 ...m-degree-of-a-connected-trio-in-a-graph.js | 62 +++++++++----------
 1 file changed, 31 insertions(+), 31 deletions(-)

diff --git a/1761-minimum-degree-of-a-connected-trio-in-a-graph.js b/1761-minimum-degree-of-a-connected-trio-in-a-graph.js
index 0b29335a..e752c0e5 100644
--- a/1761-minimum-degree-of-a-connected-trio-in-a-graph.js
+++ b/1761-minimum-degree-of-a-connected-trio-in-a-graph.js
@@ -3,36 +3,36 @@
  * @param {number[][]} edges
  * @return {number}
  */
-const minTrioDegree = function(n, edges) {
-        let ans = 10 ** 8
-        const adj = []
-        const deg = {}
-               
-        function incDeg(u) {
-            if(deg[u] == null) deg[u] = 0
-            deg[u]++
-        }
-        for(let i = 0; i < n; i++) {
-            adj.push(Array(n).fill(false))
-        }
-            
-        for (let [u, v] of edges) {
-            adj[u - 1][v - 1] = true
-            adj[v - 1][u - 1] = true
-            incDeg(u - 1)
-            incDeg(v - 1)
-        }
-        for(let u1 = 0; u1 < n; u1++) {
-            for(let u2 = u1 + 1; u2 < n; u2++) {
-                for(let u3 = u2 + 1; u3 < n; u3++) {
-                    if(adj[u1][u2] && adj[u2][u3] && adj[u3][u1]) {
-                       let tmp = deg[u1] + deg[u2] + deg[u3] - 6
-                       ans = Math.min(ans, tmp)
-                    }
-                }
-            }
+const minTrioDegree = function (n, edges) {
+  let ans = 10 ** 8
+  const adj = []
+  const deg = {}
+
+  function incDeg(u) {
+    if (deg[u] == null) deg[u] = 0
+    deg[u]++
+  }
+  for (let i = 0; i < n; i++) {
+    adj.push(Array(n).fill(false))
+  }
+
+  for (let [u, v] of edges) {
+    adj[u - 1][v - 1] = true
+    adj[v - 1][u - 1] = true
+    incDeg(u - 1)
+    incDeg(v - 1)
+  }
+  for (let u1 = 0; u1 < n; u1++) {
+    for (let u2 = u1 + 1; u2 < n; u2++) {
+      for (let u3 = u2 + 1; u3 < n; u3++) {
+        if (adj[u1][u2] && adj[u2][u3] && adj[u3][u1]) {
+          let tmp = deg[u1] + deg[u2] + deg[u3] - 6
+          ans = Math.min(ans, tmp)
         }
+      }
+    }
+  }
 
-        if (ans > 10000000) ans = -1
-        return ans
-};
+  if (ans > 10000000) ans = -1
+  return ans
+}

From acc590e844ee232ff65ef880baa6876911a54575 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Feb 2021 14:31:45 +0800
Subject: [PATCH 1139/3374] Update 407-trapping-rain-water-ii.js

---
 407-trapping-rain-water-ii.js | 132 ++++++++++++++++++++++++++++++++++
 1 file changed, 132 insertions(+)

diff --git a/407-trapping-rain-water-ii.js b/407-trapping-rain-water-ii.js
index 92bdf871..4fa7fe6c 100644
--- a/407-trapping-rain-water-ii.js
+++ b/407-trapping-rain-water-ii.js
@@ -1,3 +1,135 @@
+/**
+ * @param {number[][]} heightMap
+ * @return {number}
+ */
+
+const trapRainWater = function (heightMap) {
+  const pq = new PriorityQueue((a, b) => a[2] < b[2])
+  const visited = []
+  for (let i = 0; i < heightMap.length; i++) {
+    visited[i] = []
+    for (let j = 0; j < heightMap[0].length; j++) {
+      if (
+        i > 0 &&
+        i < heightMap.length - 1 &&
+        j > 0 &&
+        j < heightMap[0].length - 1
+      )
+        continue
+      pq.push([i, j, heightMap[i][j]])
+      visited[i][j] = true
+    }
+  }
+
+  let max = -Infinity,
+    count = 0
+  while (!pq.isEmpty()) {
+    const cur = pq.pop()
+    if (cur[2] > max) max = cur[2]
+    check(cur[0], cur[1])
+  }
+  function check(row, col) {
+    const step = [
+      [-1, 0],
+      [1, 0],
+      [0, -1],
+      [0, 1],
+    ]
+    for (let i = 0; i < step.length; i++) {
+      let newR = row + step[i][0],
+        newC = col + step[i][1]
+      if (
+        newR < 0 ||
+        newR >= heightMap.length ||
+        newC < 0 ||
+        newC >= heightMap[0].length
+      )
+        continue
+      if (visited[newR][newC]) continue
+      visited[newR][newC] = true
+      const newVal = heightMap[newR][newC]
+      if (newVal < max) {
+        count += max - newVal
+        check(newR, newC)
+      } else {
+        pq.push([newR, newC, newVal])
+      }
+    }
+  }
+
+  return count
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+
+// another
+
 /**
  * @param {number[][]} heightMap
  * @return {number}

From 4888acced8d589d361b556a69fff44707e2a0744 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Feb 2021 15:37:37 +0800
Subject: [PATCH 1140/3374] Update 407-trapping-rain-water-ii.js

---
 407-trapping-rain-water-ii.js | 110 ++++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)

diff --git a/407-trapping-rain-water-ii.js b/407-trapping-rain-water-ii.js
index 4fa7fe6c..21892090 100644
--- a/407-trapping-rain-water-ii.js
+++ b/407-trapping-rain-water-ii.js
@@ -1,3 +1,113 @@
+/**
+ * @param {number[][]} heightMap
+ * @return {number}
+ */
+
+const trapRainWater = function (heightMap) {
+  const pq = new PriorityQueue((a, b) => a[2] < b[2])
+  const m = heightMap.length, n = heightMap[0].length
+  
+  const visited = Array.from({ length: m }, () => Array(n).fill(false))
+  
+  for(let i = 0; i < m; i++) {
+    visited[i][0] = visited[i][n - 1] = true
+    pq.push([i, 0, heightMap[i][0]])
+    pq.push([i, n - 1, heightMap[i][n - 1]])
+  }
+  for(let j = 1; j < n - 1; j++) {
+    visited[0][j] = visited[m - 1][j] = true
+    pq.push([0, j, heightMap[0][j]], [m - 1, j, heightMap[m - 1][j]])
+  }
+  
+  let res = 0
+  const dirs = [[-1, 0], [1, 0], [0, 1], [0, -1]]
+  while(!pq.isEmpty()) {
+    const cur = pq.pop()
+    const [r, c, h] = cur
+    for(let dir of dirs) {
+      const newR = r + dir[0], newC = c + dir[1]
+      if(newR < 0 || newR >= m || newC < 0 || newC >= n || visited[newR][newC]) continue
+      visited[newR][newC] = true
+      res += Math.max(0, h - heightMap[newR][newC])
+      pq.push([newR, newC, Math.max(h, heightMap[newR][newC])])
+    }
+  }
+  
+  return res
+
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+
+
+// another
+
 /**
  * @param {number[][]} heightMap
  * @return {number}

From 71f31959f7ecf4683e9eb168fe293f1dbb97777c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Feb 2021 14:38:49 +0800
Subject: [PATCH 1141/3374] Create 1514-path-with-maximum-probability.js

---
 1514-path-with-maximum-probability.js | 105 ++++++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 1514-path-with-maximum-probability.js

diff --git a/1514-path-with-maximum-probability.js b/1514-path-with-maximum-probability.js
new file mode 100644
index 00000000..8212718b
--- /dev/null
+++ b/1514-path-with-maximum-probability.js
@@ -0,0 +1,105 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} succProb
+ * @param {number} start
+ * @param {number} end
+ * @return {number}
+ */
+var maxProbability = function (n, edges, succProb, start, end) {
+  const g = {}
+  for (let i = 0; i < edges.length; ++i) {
+    const a = edges[i][0],
+      b = edges[i][1]
+    if (g[a] == null) g[a] = []
+    if (g[b] == null) g[b] = []
+    g[a].push([b, i])
+    g[b].push([a, i])
+  }
+  const p = new Array(n).fill(0)
+  p[start] = 1
+  const pq = new PriorityQueue((a, b) => -p[a] < -p[b])
+  pq.push(start)
+  while (!pq.isEmpty()) {
+    const cur = pq.pop()
+    if (cur === end) {
+      return p[end]
+    }
+    for (let a of g[cur] || []) {
+      const neighbor = a[0],
+        index = a[1]
+      if (p[cur] * succProb[index] > p[neighbor]) {
+        p[neighbor] = p[cur] * succProb[index]
+        pq.push(neighbor)
+      }
+    }
+  }
+  return 0
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 0d912929d6f036a9bf658fb8a37a103d3a2c9345 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Feb 2021 14:58:39 +0800
Subject: [PATCH 1142/3374] Update 1514-path-with-maximum-probability.js

---
 1514-path-with-maximum-probability.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1514-path-with-maximum-probability.js b/1514-path-with-maximum-probability.js
index 8212718b..bd47209e 100644
--- a/1514-path-with-maximum-probability.js
+++ b/1514-path-with-maximum-probability.js
@@ -6,7 +6,7 @@
  * @param {number} end
  * @return {number}
  */
-var maxProbability = function (n, edges, succProb, start, end) {
+const maxProbability = function (n, edges, succProb, start, end) {
   const g = {}
   for (let i = 0; i < edges.length; ++i) {
     const a = edges[i][0],
@@ -18,7 +18,7 @@ var maxProbability = function (n, edges, succProb, start, end) {
   }
   const p = new Array(n).fill(0)
   p[start] = 1
-  const pq = new PriorityQueue((a, b) => -p[a] < -p[b])
+  const pq = new PriorityQueue((a, b) => p[a] > p[b])
   pq.push(start)
   while (!pq.isEmpty()) {
     const cur = pq.pop()

From 8d5dc32e869432c34abf346c60ecb9bf4e72a02a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Feb 2021 20:35:27 +0800
Subject: [PATCH 1143/3374] Create 1066-campus-bikes-ii.js

---
 1066-campus-bikes-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1066-campus-bikes-ii.js

diff --git a/1066-campus-bikes-ii.js b/1066-campus-bikes-ii.js
new file mode 100644
index 00000000..e7b365ce
--- /dev/null
+++ b/1066-campus-bikes-ii.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} workers
+ * @param {number[][]} bikes
+ * @return {number}
+ */
+const assignBikes = function (workers, bikes) {
+  const n = workers.length
+  const m = bikes.length
+  const dp = Array.from({ length: n + 1 }, () =>
+    Array(1 << m).fill(Number.MAX_VALUE / 2)
+  )
+
+  dp[0][0] = 0
+  let min = Number.MAX_VALUE
+  for (let i = 1; i <= n; i++) {
+    for (let s = 1; s < 1 << m; s++) {
+      for (let j = 0; j < m; j++) {
+        if ((s & (1 << j)) === 0) continue
+        let prev = s ^ (1 << j)
+        dp[i][s] = Math.min(
+          dp[i - 1][prev] + dis(workers[i - 1], bikes[j]),
+          dp[i][s]
+        )
+        if (i === n) min = Math.min(min, dp[i][s])
+      }
+    }
+  }
+  return min
+}
+
+function dis(p1, p2) {
+  return Math.abs(p1[0] - p2[0]) + Math.abs(p1[1] - p2[1])
+}

From d225d2bb0ab1fc1c3127adf9063db7bc19f58a9c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 19:46:15 +0800
Subject: [PATCH 1144/3374] Create 1678-merge-strings-alternately.js

---
 1678-merge-strings-alternately.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1678-merge-strings-alternately.js

diff --git a/1678-merge-strings-alternately.js b/1678-merge-strings-alternately.js
new file mode 100644
index 00000000..d93be80c
--- /dev/null
+++ b/1678-merge-strings-alternately.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {string}
+ */
+var mergeAlternately = function(word1, word2) {
+  let res = '', mark = 0, i = 0, j = 0
+  while(i < word1.length && j < word2.length) {
+    if(mark === 0) {
+      res += word1[i++]
+      mark = 1
+    } else {
+      res += word2[j++]
+      mark = 0
+    }
+  }
+  while(i < word1.length) res += word1[i++]
+  while(j < word2.length) res += word2[j++]
+  
+  return res
+};

From c584af691aebde3996114783a3c1b886fac76e32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 19:46:55 +0800
Subject: [PATCH 1145/3374] Rename 1678-merge-strings-alternately.js to
 1768-merge-strings-alternately.js

---
 ...ge-strings-alternately.js => 1768-merge-strings-alternately.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 1678-merge-strings-alternately.js => 1768-merge-strings-alternately.js (100%)

diff --git a/1678-merge-strings-alternately.js b/1768-merge-strings-alternately.js
similarity index 100%
rename from 1678-merge-strings-alternately.js
rename to 1768-merge-strings-alternately.js

From c823a0f6135d7de0c9de41605724932b2f51de04 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 19:47:29 +0800
Subject: [PATCH 1146/3374] Create
 1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js

---
 ...perations-to-move-all-balls-to-each-box.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js

diff --git a/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
new file mode 100644
index 00000000..0e66e10b
--- /dev/null
+++ b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} boxes
+ * @return {number[]}
+ */
+const minOperations = function(boxes) {
+  const res = []
+  for(let i = 0, len = boxes.length; i < len; i++) {
+    res[i] = helper(boxes, i)
+  }
+
+  return res
+};
+
+function helper(str, idx) {
+  let res = 0
+  for(let i = 0, len = str.length; i < len; i++) {
+    if(i === idx || str[i] === '0') continue
+    res += Math.abs(i - idx)
+  }
+  return res
+}

From d2297623ae3a6bdd5571c50131f42d4218ea25b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 19:48:01 +0800
Subject: [PATCH 1147/3374] Create
 1770-maximum-score-from-performing-multiplication-operations.js

---
 ...om-performing-multiplication-operations.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1770-maximum-score-from-performing-multiplication-operations.js

diff --git a/1770-maximum-score-from-performing-multiplication-operations.js b/1770-maximum-score-from-performing-multiplication-operations.js
new file mode 100644
index 00000000..fb4efcc0
--- /dev/null
+++ b/1770-maximum-score-from-performing-multiplication-operations.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} multipliers
+ * @return {number}
+ */
+const maximumScore = function(nums, multipliers) {
+  const n = nums.length, m = multipliers.length
+  const { max } = Math
+  const dp = Array.from({ length: m + 1 }, () => Array(m + 1).fill(-Infinity))
+  return helper(0, 0)
+  function helper(l, i) {
+    if(i === m) return 0
+    if(dp[l][i] !== -Infinity) return dp[l][i]
+    const pickLeft = helper(l + 1, i + 1) + nums[l] * multipliers[i]
+    const pickRight = helper(l, i + 1) + nums[n - (i - l) - 1] * multipliers[i]
+    return dp[l][i] = max(pickLeft, pickRight)
+  }
+
+};

From 8f942dda3f631f0111b0baa74a63b9b8981d3c34 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 19:48:35 +0800
Subject: [PATCH 1148/3374] Create
 1771-maximize-palindrome-length-from-subsequences.js

---
 ...ize-palindrome-length-from-subsequences.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1771-maximize-palindrome-length-from-subsequences.js

diff --git a/1771-maximize-palindrome-length-from-subsequences.js b/1771-maximize-palindrome-length-from-subsequences.js
new file mode 100644
index 00000000..e7b9ae42
--- /dev/null
+++ b/1771-maximize-palindrome-length-from-subsequences.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const longestPalindrome = function(word1, word2) {
+    const sz = word1.length + word2.length
+    let res = 0;
+    const dp = Array.from({ length: sz + 1 }, () => Array(sz + 1).fill(0))
+    longestPalindromeSubseq(word1 + word2, dp);
+    for (let i = 0; i < word1.length; ++i)
+        for (let j = word2.length - 1; j >= 0; --j)
+            if (word1[i] == word2[j]) {
+                res = Math.max(res, dp[i][word1.length + j + 1]);
+                break;
+            }
+    return res;
+
+}
+function longestPalindromeSubseq( s, dp) {
+    for (let len = 1; len <= s.length; ++len) 
+        for (let i = 0; i + len <= s.length; ++i) 
+            dp[i][i + len] = s[i] == s[i + len - 1] ? 
+                dp[i + 1][i + len - 1] + (len == 1 ? 1 : 2) : 
+                    Math.max(dp[i][i + len - 1],  dp[i + 1][i + len]);
+    return dp[0][s.length];
+}    
+
+

From 7429df753d254abeec29c8f924a8b2556958803f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 21:40:27 +0800
Subject: [PATCH 1149/3374] Create 1763-longest-nice-substring.js

---
 1763-longest-nice-substring.js | 37 ++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1763-longest-nice-substring.js

diff --git a/1763-longest-nice-substring.js b/1763-longest-nice-substring.js
new file mode 100644
index 00000000..acdb1970
--- /dev/null
+++ b/1763-longest-nice-substring.js
@@ -0,0 +1,37 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const longestNiceSubstring = function(s) {
+  let res = ''
+  const n = s.length
+  
+  const arr = Array(26).fill(null)
+  for(let i = 0; i < n - 1; i++) {
+    for(let j = i + 1; j < n; j++) {
+      const tmp = s.slice(i, j + 1)
+      if(helper(tmp)) {
+        if(tmp.length > res.length) res = tmp
+      }
+    }
+  }
+  
+  
+  return res
+};
+
+function helper(s) {
+  const arr = Array(26).fill(null)
+  const a = 'a'.charCodeAt(0), A = 'A'.charCodeAt(0)
+  for(let e of s) {
+    const ecode = e.charCodeAt(0)
+    if(arr[ecode - a] === 0 || arr[ecode - A] === 0) continue
+    if(ecode - a < 26 && ecode - a >= 0) arr[ecode - a] = arr[ecode - a] === 1 ? 0 : -1
+    if(ecode - A < 26 && ecode - A >= 0) arr[ecode - A] = arr[ecode - A] === -1 ? 0 : 1
+  }
+  for(let e of arr) {
+    if(e === -1 || e === 1) return false
+  }
+  
+  return true
+}

From 9625abc891e383837cd429dc7fec945bb325739f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Feb 2021 22:31:12 +0800
Subject: [PATCH 1150/3374] Create
 1764-form-array-by-concatenating-subarrays-of-another-array.js

---
 ...oncatenating-subarrays-of-another-array.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1764-form-array-by-concatenating-subarrays-of-another-array.js

diff --git a/1764-form-array-by-concatenating-subarrays-of-another-array.js b/1764-form-array-by-concatenating-subarrays-of-another-array.js
new file mode 100644
index 00000000..df30e677
--- /dev/null
+++ b/1764-form-array-by-concatenating-subarrays-of-another-array.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} groups
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canChoose = function(groups, nums) {
+    const m = groups.length;
+    let gi = 0;
+    let ni = 0;
+    while (ni < nums.length && gi < m)
+    {
+        let check = true;
+        for (let i = 0; i < groups[gi].length; i++)
+        {
+            if (ni + i >= nums.length || groups[gi][i] != nums[ni + i])
+            {
+                check = false;
+                break;
+            }
+        }
+
+        if (check)
+        {
+            ni += groups[gi].length;
+            gi++;
+        }
+        else
+        {
+            ni++;
+        }
+    }
+
+    return gi >= m;
+};
+

From 6a2692cc1beec72f13debc858e1286ecbb9dc9c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Feb 2021 20:28:26 +0800
Subject: [PATCH 1151/3374] Update 882-reachable-nodes-in-subdivided-graph.js

---
 882-reachable-nodes-in-subdivided-graph.js | 93 ++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/882-reachable-nodes-in-subdivided-graph.js b/882-reachable-nodes-in-subdivided-graph.js
index 9d7fc3cf..89c1afbe 100644
--- a/882-reachable-nodes-in-subdivided-graph.js
+++ b/882-reachable-nodes-in-subdivided-graph.js
@@ -1,3 +1,96 @@
+/**
+ * @param {number[][]} edges
+ * @param {number} maxMoves
+ * @param {number} n
+ * @return {number}
+ */
+const reachableNodes = function(edges, maxMoves, n) {
+    let res = 0,
+    heap = new Heap(),
+    state = new Array(n).fill(0),
+    graph = Array.from(new Array(n), () => []),
+    distance = new Array(n).fill(Number.MAX_SAFE_INTEGER);
+  for (let [u, v, d] of edges) {
+    graph[u].push([v, d]);
+    graph[v].push([u, d]);
+  }
+  distance[0] = 0;
+  heap.insert([0, distance[0]]);
+  while (heap.length != 0) {
+    let t = heap.remove();
+    if (state[t[0]] === 1) continue;
+    if (distance[t[0]] <= maxMoves) res++;
+    state[t[0]] = 1;
+    for (let i of graph[t[0]]) {
+      if (distance[i[0]] > distance[t[0]] + i[1] + 1) {
+        distance[i[0]] = distance[t[0]] + i[1] + 1;
+        heap.insert([i[0], distance[i[0]]]);
+      }
+    }
+  }
+  for (let [u, v, d] of edges) {
+    let a = maxMoves - distance[u] >= 0 ? maxMoves - distance[u] : 0,
+      b = maxMoves - distance[v] >= 0 ? maxMoves - distance[v] : 0;
+    res += Math.min(d, a + b);
+  }
+  return res;
+};
+
+class Heap {
+  constructor() {
+    this.heap = [];
+  }
+
+  get length() {
+    return this.heap.length;
+  }
+
+  compare(i, j) {
+    if (!this.heap[j]) return false;
+    return this.heap[i][1] > this.heap[j][1];
+  }
+
+  swap(i, j) {
+    const temp = this.heap[i];
+    this.heap[i] = this.heap[j];
+    this.heap[j] = temp;
+  }
+
+  insert(num) {
+    this.heap.push(num);
+    let idx = this.length - 1;
+    let parent = (idx - 1) >> 1;
+    while (idx !== 0 && this.compare(parent, idx)) {
+      this.swap(parent, idx);
+      idx = parent;
+      parent = (idx - 1) >> 1;
+    }
+  }
+
+  remove() {
+    if (this.length === 1) return this.heap.pop();
+    let res = this.heap[0],
+      idx = 0,
+      left = 1 | (idx << 1),
+      right = (1 + idx) << 1;
+    this.heap[0] = this.heap.pop();
+    while (this.compare(idx, left) || this.compare(idx, right)) {
+      if (this.compare(left, right)) {
+        this.swap(idx, right);
+        idx = right;
+      } else {
+        this.swap(idx, left);
+        idx = left;
+      }
+      left = 1 | (idx << 1);
+      right = (1 + idx) << 1;
+    }
+    return res;
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} edges
  * @param {number} M

From f8f56d7c9035a5c3b0200642a1086cd3338ef272 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Feb 2021 09:47:43 +0800
Subject: [PATCH 1152/3374] Update
 1764-form-array-by-concatenating-subarrays-of-another-array.js

---
 ...oncatenating-subarrays-of-another-array.js | 50 +++++++++----------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/1764-form-array-by-concatenating-subarrays-of-another-array.js b/1764-form-array-by-concatenating-subarrays-of-another-array.js
index df30e677..88e73e5d 100644
--- a/1764-form-array-by-concatenating-subarrays-of-another-array.js
+++ b/1764-form-array-by-concatenating-subarrays-of-another-array.js
@@ -4,32 +4,30 @@
  * @return {boolean}
  */
 const canChoose = function(groups, nums) {
-    const m = groups.length;
-    let gi = 0;
-    let ni = 0;
-    while (ni < nums.length && gi < m)
-    {
-        let check = true;
-        for (let i = 0; i < groups[gi].length; i++)
-        {
-            if (ni + i >= nums.length || groups[gi][i] != nums[ni + i])
-            {
-                check = false;
-                break;
-            }
-        }
-
-        if (check)
-        {
-            ni += groups[gi].length;
-            gi++;
-        }
-        else
-        {
-            ni++;
-        }
+  let gi = 0, ni = 0
+  const n = groups.length, m = nums.length
+  while(gi < n && ni < m) {
+    const len = groups[gi].length
+    let pass = true
+    if(nums[ni] !== groups[gi][0]) {
+      ni++
+      continue
+    }
+    for(let i = 1; i < len; i++) {
+      if(nums[ni + i] !== groups[gi][i]) {
+        pass = false
+        break
+      }
+    }
+    if(pass) {
+      gi++
+      ni += len
+    } else {
+      ni++
     }
+  }
+  if(gi >= n) return true
 
-    return gi >= m;
-};
+  return false
 
+};

From 76edffe67cce96cddf3a2ff236b62603c0db5465 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Feb 2021 21:08:35 +0800
Subject: [PATCH 1153/3374] Update
 1764-form-array-by-concatenating-subarrays-of-another-array.js

---
 ...oncatenating-subarrays-of-another-array.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1764-form-array-by-concatenating-subarrays-of-another-array.js b/1764-form-array-by-concatenating-subarrays-of-another-array.js
index 88e73e5d..1fd9fc52 100644
--- a/1764-form-array-by-concatenating-subarrays-of-another-array.js
+++ b/1764-form-array-by-concatenating-subarrays-of-another-array.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number[][]} groups
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canChoose = function (groups, nums) {
+  const m = nums.length
+  let index = 0
+  for (let group of groups) {
+    const n = group.length
+    // Step-1 Generate LPS
+    const lps = Array(n).fill(0)
+    for (let i = 1; i < n; i++) {
+      let j = lps[i - 1]
+      while (j > 0 && group[i] !== group[j]) {
+        j = lps[j - 1]
+      }
+      if (group[i] === group[j]) {
+        j++
+      }
+      lps[i] = j
+    }
+
+    // Step-2 - Matching
+    let j = 0
+    while (index < m) {
+      if (nums[index] === group[j]) {
+        j++
+        index++
+      }
+      if (j === n) break
+      else if (index < m && nums[index] != group[j]) {
+        if (j > 0) {
+          j = lps[j - 1]
+        } else {
+          index++
+        }
+      }
+    }
+    if (j !== n) return false
+  }
+  return true
+}
+
+
+// another
+
+
 /**
  * @param {number[][]} groups
  * @param {number[]} nums

From fa5d77004c6bb2969994dd1af194a18a4cf70573 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Feb 2021 22:28:43 +0800
Subject: [PATCH 1154/3374] Create 1765-map-of-highest-peak.js

---
 1765-map-of-highest-peak.js | 40 +++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1765-map-of-highest-peak.js

diff --git a/1765-map-of-highest-peak.js b/1765-map-of-highest-peak.js
new file mode 100644
index 00000000..d74a3e7c
--- /dev/null
+++ b/1765-map-of-highest-peak.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} isWater
+ * @return {number[][]}
+ */
+const highestPeak = function(isWater) {
+  let q = []
+  const visited = new Set()
+  const m = isWater.length, n = isWater[0].length
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(isWater[i][j] === 1) {
+          q.push([i, j, 0])
+          visited.add(`${i},${j}`)
+      }
+    }
+  }
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  const dirs = [[-1, 0], [1, 0], [0, 1], [0, -1]]
+  
+  while(q.length) {
+    const size = q.length
+    const next = []
+    // Array.shift time complexity: O(n)
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      const [row, col, val] = cur
+      for(let dir of dirs) {
+        const newRow = row + dir[0], newCol = col + dir[1]
+        const key = `${newRow},${newCol}`
+        if(newRow < 0 || newRow >= m || newCol < 0 || newCol >= n || visited.has(key) || res[newRow][newCol] !== 0) continue
+        next.push([newRow, newCol, val + 1])
+        res[newRow][newCol] = val + 1
+        visited.add(key)
+      }
+    }
+    q = next
+
+  }
+  return res
+};

From bb7a61391cfe67dc391c7732767db80f26af6663 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Feb 2021 17:51:17 +0800
Subject: [PATCH 1155/3374] Create 1766-tree-of-coprimes.js

---
 1766-tree-of-coprimes.js | 44 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 1766-tree-of-coprimes.js

diff --git a/1766-tree-of-coprimes.js b/1766-tree-of-coprimes.js
new file mode 100644
index 00000000..32324162
--- /dev/null
+++ b/1766-tree-of-coprimes.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const getCoprimes = function (nums, edges) {
+  const output = Array(nums.length).fill(null)
+  const graph = new Map()
+  for (let [u, v] of edges) {
+    if (!graph.has(u)) graph.set(u, [])
+    if (!graph.has(v)) graph.set(v, [])
+    graph.get(u).push(v)
+    graph.get(v).push(u)
+  }
+
+  function getGCD(a, b) {
+    if (!b) return a
+    return getGCD(b, a % b)
+  }
+
+  // ancestors is an array of unique ancestors from the recent to the farthest
+  // indices maps the index of each ancestor
+  function dfs(i, ancestors, indices) {
+    for (let num of ancestors) {
+      const gcd = getGCD(nums[i], num)
+      if (gcd === 1) {
+        output[i] = indices[num]
+        break
+      }
+    }
+
+    if (output[i] === null) output[i] = -1
+    ancestors = [nums[i], ...ancestors.filter((x) => x !== nums[i])]
+    indices[nums[i]] = i
+    for (let next of graph.get(i)) {
+      if (output[next] === null) {
+        dfs(next, ancestors, [...indices])
+      }
+    }
+  }
+
+  dfs(0, [], Array(51))
+  return output
+}

From 0eb01bd81df8e61b1f68efec42f3da206af63110 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Feb 2021 22:18:38 +0800
Subject: [PATCH 1156/3374] Update 1734-decode-xored-permutation.js

---
 1734-decode-xored-permutation.js | 30 +++++++++++++-----------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/1734-decode-xored-permutation.js b/1734-decode-xored-permutation.js
index 341db848..dca2ef79 100644
--- a/1734-decode-xored-permutation.js
+++ b/1734-decode-xored-permutation.js
@@ -2,21 +2,17 @@
  * @param {number[]} encoded
  * @return {number[]}
  */
-const decode = function(A) {
-    let i;
-    let n = A.length + 1;
-    let f = 0;
-    const res = [];
-    for(i=1;i<n+1;i++){
-      f ^= i;
-    }
-    for(i=1;i<n-1;i+=2){
-      f ^= A[i];
-    }
-    res.push(f);
-    for(i=1;i<n;i++){
-      f ^= A[i-1];
-      res.push(f);
-    }
-    return res;    
+const decode = function(encoded) {
+  let a = 0
+  const n = encoded.length + 1
+  for(let i = 0; i <= n; i++) {
+    a ^= i
+    if(i < n && i % 2 === 1) a ^= encoded[i]
+  }
+  const res = [a]
+  for(let i = 0; i < n - 1; i++) {
+    res[i + 1] = res[i] ^ encoded[i]
+  }
+  
+  return res
 };

From 3980cf723d112f328d1a6a73a9cc202f69bf82d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Feb 2021 17:39:28 +0800
Subject: [PATCH 1157/3374] Update
 1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js

---
 ...perations-to-move-all-balls-to-each-box.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
index 0e66e10b..6364c519 100644
--- a/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
+++ b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
@@ -1,3 +1,29 @@
+/**
+ * @param {string} boxes
+ * @return {number[]}
+ */
+const minOperations = function(boxes) {
+  const n = boxes.length
+  const res = Array(n).fill(0)
+  let cum = 0, sum = 0
+  for(let i = 0; i < n; i++) {
+    res[i] += sum
+    cum += +boxes[i]
+    sum += cum
+  }
+  cum = 0, sum = 0
+  for(let i = n - 1; i >= 0; i--) {
+    res[i] += sum
+    cum += +boxes[i]
+    sum += cum
+  }
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {string} boxes
  * @return {number[]}

From 94d847ca5c0927f26c42e48f45784be6f70ba11c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Feb 2021 16:54:15 +0800
Subject: [PATCH 1158/3374] Update 148-sort-list.js

---
 148-sort-list.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/148-sort-list.js b/148-sort-list.js
index 7d7e008a..a63c5dda 100644
--- a/148-sort-list.js
+++ b/148-sort-list.js
@@ -49,6 +49,38 @@ function merge(left, right) {
     return dummy.next;
 }
 
+
+// another
+
+    function sortList(head) {
+        quickSort(head, null);
+        return head;
+    }
+    
+    function quickSort( head,  tail){
+        if (head == tail) {
+            return;
+        }
+        let slow = head, fast = head.next;
+        let p = head.val;
+        while (fast != tail){
+            if (fast.val <= p){
+                slow = slow.next;
+                swap(slow, fast);
+            }
+            fast = fast.next;
+        }
+        swap(head, slow);
+        quickSort(head, slow);
+        quickSort(slow.next, tail);
+    }
+    
+    function swap( node1,  node2){
+         let tmp = node1.val;
+         node1.val = node2.val;
+         node2.val = tmp;
+    }
+
 // another
 
 /**

From 3425d0e1467649bd41a6d80760ed638a3596a2ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Feb 2021 19:41:04 +0800
Subject: [PATCH 1159/3374] Update
 3-longest-substring-without-repeating-characters.js

---
 ...-substring-without-repeating-characters.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/3-longest-substring-without-repeating-characters.js b/3-longest-substring-without-repeating-characters.js
index 1bd9a89c..78f0636b 100755
--- a/3-longest-substring-without-repeating-characters.js
+++ b/3-longest-substring-without-repeating-characters.js
@@ -1,3 +1,24 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstring = function(s) {
+  if(s.length < 2) return s.length
+  const hash = {}
+  let max = 0
+  for(let i = 0, j = -1, len = s.length; i < len; i++) {
+    const cur = s[i]
+    if(hash[cur] != null) j = Math.max(j, hash[cur])
+    
+    hash[cur] = i
+    max = Math.max(max, i - j)
+  }
+  
+  return max
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From b86865483264c7314fe011563ee43eaee522a166 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Feb 2021 21:29:03 +0800
Subject: [PATCH 1160/3374] Update 4-median-of-two-sorted-arrays.js

---
 4-median-of-two-sorted-arrays.js | 46 ++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/4-median-of-two-sorted-arrays.js b/4-median-of-two-sorted-arrays.js
index 5cde4582..feef923e 100755
--- a/4-median-of-two-sorted-arrays.js
+++ b/4-median-of-two-sorted-arrays.js
@@ -47,3 +47,49 @@ const findMedianSortedArrays = function(A, B) {
     }
   }
 };
+
+// another
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const findMedianSortedArrays = function (nums1, nums2) {
+  if (nums1.length > nums2.length) {
+    return findMedianSortedArrays(nums2, nums1)
+  }
+  const x = nums1.length
+  const y = nums2.length
+
+  let low = 0
+  let high = x
+
+  while (low <= high) {
+    const partX = Math.floor((low + high) / 2)
+    const partY = Math.floor((x + y + 1) / 2) - partX
+
+    const maxX = partX === 0 ? Number.NEGATIVE_INFINITY : nums1[partX - 1]
+    const maxY = partY === 0 ? Number.NEGATIVE_INFINITY : nums2[partY - 1]
+
+    const minX =
+      partX === nums1.length ? Number.POSITIVE_INFINITY : nums1[partX]
+    const minY =
+      partY === nums2.length ? Number.POSITIVE_INFINITY : nums2[partY]
+
+    if (maxX <= minY && maxY <= minX) {
+      const lowMax = Math.max(maxX, maxY)
+
+      if ((x + y) % 2 == 1) {
+        return Math.max(maxX, maxY)
+      } else {
+        return (Math.max(maxX, maxY) + Math.min(minX, minY)) / 2
+      }
+    } else if (maxX < minY) {
+      low = partX + 1
+    } else {
+      high = partX - 1
+    }
+  }
+}
+

From d45b4fcb5d1dcf729e890e7e1c3334a2dc917515 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Feb 2021 12:17:08 +0800
Subject: [PATCH 1161/3374] Update 148-sort-list.js

---
 148-sort-list.js | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/148-sort-list.js b/148-sort-list.js
index a63c5dda..19404403 100644
--- a/148-sort-list.js
+++ b/148-sort-list.js
@@ -1,3 +1,51 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+function sortList(head) {
+  quickSort(head, null);
+  return head;
+}
+
+function quickSort(head, tail) {
+  if (head == tail) {
+    return;
+  }
+  const slow = partition(head, tail);
+  quickSort(head, slow);
+  quickSort(slow.next, tail);
+}
+
+function swap(node1, node2) {
+  let tmp = node1.val;
+  node1.val = node2.val;
+  node2.val = tmp;
+}
+
+function partition(head, tail) {
+  let slow = head,
+    fast = head.next;
+  let p = head.val;
+  while (fast != tail) {
+    if (fast.val <= p) {
+      slow = slow.next;
+      swap(slow, fast);
+    }
+    fast = fast.next;
+  }
+  swap(head, slow);
+  return slow;
+}
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From dd6f7cec84b60680bb29b6396259d71b5b2cc4ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Feb 2021 12:43:42 +0800
Subject: [PATCH 1162/3374] Update 516-longest-palindromic-subsequence.js

---
 516-longest-palindromic-subsequence.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/516-longest-palindromic-subsequence.js b/516-longest-palindromic-subsequence.js
index cdb115ef..c7290c3f 100644
--- a/516-longest-palindromic-subsequence.js
+++ b/516-longest-palindromic-subsequence.js
@@ -1,3 +1,26 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestPalindromeSubseq = function(s) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(0))
+  for(let i = 0; i < n; i++) {
+    dp[i][i] = 1
+    for(let j = i - 1; j >= 0; j--) {
+      if(s[i] === s[j]) {
+        dp[i][j] = dp[i - 1][j + 1] + 2
+      } else {
+        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j + 1])
+      }
+    }
+  }
+  
+  return dp[n - 1][0]
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 8712d4aeda6c462543eeac6fde1d9fa01df180af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Feb 2021 19:45:29 +0800
Subject: [PATCH 1163/3374] Update
 1771-maximize-palindrome-length-from-subsequences.js

---
 ...ize-palindrome-length-from-subsequences.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1771-maximize-palindrome-length-from-subsequences.js b/1771-maximize-palindrome-length-from-subsequences.js
index e7b9ae42..fd093aa0 100644
--- a/1771-maximize-palindrome-length-from-subsequences.js
+++ b/1771-maximize-palindrome-length-from-subsequences.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const longestPalindrome = function(word1, word2) {
+  const str = word1 + word2
+  const len = str.length, m = word1.length, n = word2.length
+  const dp = LPS(str)
+  let res = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(word1[i] !== word2[j]) continue
+      res = Math.max(res, 2 + dp[i + 1][j + m - 1])
+    }
+  }
+  return res
+}
+
+function LPS(str) {
+  const n = str.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(0))
+  for(let i = n - 1; i >= 0; i--) {
+    dp[i][i] = 1
+    for(let j = i + 1; j < n; j++) {
+      if(str[i] === str[j]) dp[i][j] = 2 + dp[i + 1][j - 1]
+      else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1])
+    }
+  }
+  return dp
+}
+
+
+// another
+
 /**
  * @param {string} word1
  * @param {string} word2

From 0d894d2bba240deb15c6ed1208b3449f9996da17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Feb 2021 20:24:40 +0800
Subject: [PATCH 1164/3374] Update 516-longest-palindromic-subsequence.js

---
 516-longest-palindromic-subsequence.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/516-longest-palindromic-subsequence.js b/516-longest-palindromic-subsequence.js
index c7290c3f..7eaeefe0 100644
--- a/516-longest-palindromic-subsequence.js
+++ b/516-longest-palindromic-subsequence.js
@@ -1,3 +1,25 @@
+// 区间DP
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestPalindromeSubseq = function(s) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(0))
+  for(let i = 0; i < n; i++) dp[i][i] = 1
+  for(let len = 2; len <= n; len++) {
+    for(let i = 0; i + len - 1 < n; i++) {
+      const j = i + len - 1
+      if(s[i] === s[j]) dp[i][j] = 2 + dp[i + 1][j - 1]
+      else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1])
+    }
+  }
+  return dp[0][n - 1]
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From d7f78a69297aaf47461340fc1246ed552674690e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 00:04:55 +0800
Subject: [PATCH 1165/3374] Update 4-median-of-two-sorted-arrays.js

---
 4-median-of-two-sorted-arrays.js | 38 ++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/4-median-of-two-sorted-arrays.js b/4-median-of-two-sorted-arrays.js
index feef923e..095350b7 100755
--- a/4-median-of-two-sorted-arrays.js
+++ b/4-median-of-two-sorted-arrays.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const findMedianSortedArrays = function(nums1, nums2) {
+  if(nums1.length > nums2.length) return findMedianSortedArrays(nums2, nums1)
+  const m = nums1.length, n = nums2.length
+  let low = 0, high = m
+  while(low <= high) {
+    
+    const px = Math.floor((low + high) / 2)
+    const py = Math.floor(( m + n + 1 ) / 2) - px
+    
+    const maxLeft1 = px === 0 ? -Infinity : nums1[px - 1]
+    const minRight1 = px === m ? Infinity : nums1[px]
+    
+    const maxLeft2 = py === 0 ? -Infinity : nums2[py - 1]
+    const minRight2 = py === n ? Infinity : nums2[py]
+    
+    if(maxLeft1 <= minRight2 && maxLeft2 <= minRight1) {
+      if((m + n) % 2 === 0) {
+        return (Math.max(maxLeft1, maxLeft2) + Math.min(minRight1, minRight2)) / 2
+      } else {
+        return Math.max(maxLeft1, maxLeft2)
+      }
+    } else if(maxLeft1 > minRight2) {
+      high = px - 1        
+    } else {
+      low = px + 1
+    }
+    
+  }
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number[]} B
@@ -93,3 +130,4 @@ const findMedianSortedArrays = function (nums1, nums2) {
   }
 }
 
+

From 8b90fd89cbea5eb4e896d54a98291ada94641802 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 12:50:15 +0800
Subject: [PATCH 1166/3374] Create 1773-count-items-matching-a-rule.js

---
 1773-count-items-matching-a-rule.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1773-count-items-matching-a-rule.js

diff --git a/1773-count-items-matching-a-rule.js b/1773-count-items-matching-a-rule.js
new file mode 100644
index 00000000..b761bf79
--- /dev/null
+++ b/1773-count-items-matching-a-rule.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[][]} items
+ * @param {string} ruleKey
+ * @param {string} ruleValue
+ * @return {number}
+ */
+const countMatches = function(items, ruleKey, ruleValue) {
+  let res = 0
+  for(let e of items) {
+    if(helper(e, ruleKey, ruleValue)) res++
+  }
+  return res
+};
+
+function helper(e, k, v) {
+  const [t, c, n] = e
+  if(k === 'type' && v === t) {
+    return true
+  } else if(k === 'color' && v === c) {
+    return true
+  } else if(k === 'name' && v === n) {
+    return true
+  }
+  
+  return false
+  
+}

From d709d6d5ce1acea88d5a0e4e8dc6ab124026b4a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 12:50:43 +0800
Subject: [PATCH 1167/3374] Create 1774-closest-dessert-cost.js

---
 1774-closest-dessert-cost.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1774-closest-dessert-cost.js

diff --git a/1774-closest-dessert-cost.js b/1774-closest-dessert-cost.js
new file mode 100644
index 00000000..a274115a
--- /dev/null
+++ b/1774-closest-dessert-cost.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} baseCosts
+ * @param {number[]} toppingCosts
+ * @param {number} target
+ * @return {number}
+ */
+const closestCost = function(baseCosts, toppingCosts, target) {
+    let n = baseCosts.length, m = toppingCosts.length;
+    const { abs } = Math
+    const costs = new Set();
+    for (let i = 0; i < n; i++) {
+      dfs(toppingCosts, 0, m, baseCosts[i], costs);
+    }
+    const nums = [];
+    for (let x of costs) nums.push(x);
+    nums.sort((a, b) => abs(a - target) == abs(b - target) ? a - b : abs(a - target) - abs(b - target))
+    return nums[0];
+  
+};
+
+function dfs(toppingCosts, ind, m, cost, costs) {
+    costs.add(cost);
+    if (ind >= m) return;
+    dfs(toppingCosts, ind + 1, m, cost, costs);
+    dfs(toppingCosts, ind + 1, m, cost + toppingCosts[ind], costs);
+    dfs(toppingCosts, ind + 1, m, cost + toppingCosts[ind] * 2, costs);
+}

From ce78e980f48666b7ae4deb8c28902e743a698400 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 12:51:10 +0800
Subject: [PATCH 1168/3374] Create
 1775-equal-sum-arrays-with-minimum-number-of-operations.js

---
 ...rrays-with-minimum-number-of-operations.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1775-equal-sum-arrays-with-minimum-number-of-operations.js

diff --git a/1775-equal-sum-arrays-with-minimum-number-of-operations.js b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
new file mode 100644
index 00000000..cdbc354c
--- /dev/null
+++ b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minOperations = function(nums1, nums2) {
+    const len1 = nums1.length, len2 = nums2.length;
+    if (len1 > 6 * len2 || len2 > 6 * len1) return -1;
+    let sum1 = 0, sum2 = 0;
+    for (let x of nums1) sum1 += x;
+    for (let x of nums2) sum2 += x;
+    if (sum1 === sum2) return 0;
+    nums1.sort((a, b) => a - b)
+    nums2.sort((a, b) => a - b)
+    let cnt = 0;
+    if (sum1 > sum2) {
+        let ind1 = len1 - 1, ind2 = 0;
+        while (sum1 > sum2) { 
+            if (ind2 === len2 || nums1[ind1] - 1 > 6 - nums2[ind2]) sum1 -= nums1[ind1--] - 1;
+            else sum2 += 6 - nums2[ind2++];
+            cnt++;
+        }
+        return cnt;
+    }
+    let ind1 = 0, ind2 = len2 - 1;
+    while (sum1 < sum2) {
+        if (ind1 === len1 || nums2[ind2] - 1 > 6 - nums1[ind1]) sum2 -= nums2[ind2--] - 1;
+        else sum1 += 6 - nums1[ind1++];
+        cnt++;
+    }
+    return cnt;
+};

From 9a882f5a8a830f49f53d9040291b9eeff0ffd989 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 12:51:37 +0800
Subject: [PATCH 1169/3374] Create 1776-car-fleet-ii.js

---
 1776-car-fleet-ii.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1776-car-fleet-ii.js

diff --git a/1776-car-fleet-ii.js b/1776-car-fleet-ii.js
new file mode 100644
index 00000000..a40a8602
--- /dev/null
+++ b/1776-car-fleet-ii.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} cars
+ * @return {number[]}
+ */
+var getCollisionTimes = function (cars) {
+  let n = cars.length,
+    t = 0,
+    i
+  const ans = Array(n)
+  for (let i = 0; i < n; i++) ans[i] = -1
+  const s = []
+  s[++t] = n - 1
+  for (let i = n - 2; ~i; i--) {
+    while (t && cars[s[t]][1] >= cars[i][1]) t--
+    while (
+      t > 1 &&
+      (cars[s[t]][0] - cars[i][0]) * (cars[i][1] - cars[s[t - 1]][1]) >
+        (cars[s[t - 1]][0] - cars[i][0]) * (cars[i][1] - cars[s[t]][1])
+    )
+      t--
+    if (t) ans[i] = (cars[s[t]][0] - cars[i][0]) / (cars[i][1] - cars[s[t]][1])
+    s[++t] = i
+  }
+  return ans
+}

From 47569e5feac799e5c597c4ff90cabf6cea9459d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 13:12:30 +0800
Subject: [PATCH 1170/3374] Update 1776-car-fleet-ii.js

---
 1776-car-fleet-ii.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1776-car-fleet-ii.js b/1776-car-fleet-ii.js
index a40a8602..86a1c6c5 100644
--- a/1776-car-fleet-ii.js
+++ b/1776-car-fleet-ii.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[][]} cars
+ * @return {number[]}
+ */
+var getCollisionTimes = function(cars) {
+  const n = cars.length
+  const ans = Array(n).fill(0)
+  const stack = []
+  for(let i = n - 1; i >= 0; i--) {
+    while(stack.length) {
+      if(cars[stack[stack.length - 1]][1] >= cars[i][1]) stack.pop()
+      else {
+        if(ans[stack[stack.length - 1]] < 0) break
+        const d = ans[stack[stack.length - 1]] * (cars[i][1] - cars[stack[stack.length - 1]][1])
+        if(d > cars[stack[stack.length - 1]][0] - cars[i][0]) break
+        else stack.pop()
+      }
+    }
+    if(stack.length === 0) ans[i] = -1
+    else {
+      const t = (cars[stack[stack.length - 1]][0]-cars[i][0])/(cars[i][1]-cars[stack[stack.length - 1]][1])
+      ans[i] = t
+    }
+    stack.push(i)
+  }
+  return ans
+};
+
+// another
+
 /**
  * @param {number[][]} cars
  * @return {number[]}

From 209ea5c048c1a6b4915c214054708521fe594893 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 13:35:28 +0800
Subject: [PATCH 1171/3374] Update 1776-car-fleet-ii.js

---
 1776-car-fleet-ii.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/1776-car-fleet-ii.js b/1776-car-fleet-ii.js
index 86a1c6c5..01eab963 100644
--- a/1776-car-fleet-ii.js
+++ b/1776-car-fleet-ii.js
@@ -3,21 +3,32 @@
  * @return {number[]}
  */
 var getCollisionTimes = function(cars) {
+  //这道题必须想清楚一点，那就是如果ans[i]有正值，那么一定是cars[i]和某个cars[j]（j>i且speed[j]<speed[i]）
+  //相撞之后，所谓的融合，其实可以理解为cars[i]消失了，cars[j]状态不变
+  //所以我们只关注一辆车后面，不关注其前面，它的前面对它没有任何影响。可以考虑从后往前遍历
   const n = cars.length
   const ans = Array(n).fill(0)
+  //设立一个类似单调栈的栈，栈底最慢，栈顶最快
   const stack = []
   for(let i = n - 1; i >= 0; i--) {
     while(stack.length) {
+      //如果栈顶比我快，我追不上它，可以考虑等它消失之后我去撞它前面的，所以将它pop
       if(cars[stack[stack.length - 1]][1] >= cars[i][1]) stack.pop()
+      //如果栈顶比我慢，我就决定去碰它了
       else {
+        //如果它不会消失，那我肯定能碰它，break
         if(ans[stack[stack.length - 1]] < 0) break
+        //如果它会消失，我需要计算一下在它消失之前能否追上它
         const d = ans[stack[stack.length - 1]] * (cars[i][1] - cars[stack[stack.length - 1]][1])
+        //能追上，那我肯定碰它，break
         if(d > cars[stack[stack.length - 1]][0] - cars[i][0]) break
+        //追不上，那算了，追它前面的车
         else stack.pop()
       }
     }
     if(stack.length === 0) ans[i] = -1
     else {
+      //相对距离除以相对速度
       const t = (cars[stack[stack.length - 1]][0]-cars[i][0])/(cars[i][1]-cars[stack[stack.length - 1]][1])
       ans[i] = t
     }
@@ -26,6 +37,7 @@ var getCollisionTimes = function(cars) {
   return ans
 };
 
+
 // another
 
 /**

From b4ed2009931f3cc1fcdf3443c3a29426474da765 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Feb 2021 22:21:38 +0800
Subject: [PATCH 1172/3374] Update
 1653-minimum-deletions-to-make-string-balanced.js

---
 ...nimum-deletions-to-make-string-balanced.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1653-minimum-deletions-to-make-string-balanced.js b/1653-minimum-deletions-to-make-string-balanced.js
index edae94cb..ac09dbf2 100644
--- a/1653-minimum-deletions-to-make-string-balanced.js
+++ b/1653-minimum-deletions-to-make-string-balanced.js
@@ -1,3 +1,24 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumDeletions = function(s) {
+  let res = 0
+  let cnt = 0
+  for(let c of s) {
+    if(c === 'a' && cnt > 0) {
+      res++
+      cnt--
+    } else if(c === 'b') {
+      cnt++
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 1da96fab5df2f3ba2c8f00875292ebabf298e043 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Mar 2021 11:03:57 +0800
Subject: [PATCH 1173/3374] Update
 1671-minimum-number-of-removals-to-make-mountain-array.js

---
 ...mber-of-removals-to-make-mountain-array.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1671-minimum-number-of-removals-to-make-mountain-array.js b/1671-minimum-number-of-removals-to-make-mountain-array.js
index 350df2e6..933532f3 100644
--- a/1671-minimum-number-of-removals-to-make-mountain-array.js
+++ b/1671-minimum-number-of-removals-to-make-mountain-array.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumMountainRemovals = function(nums) {
+  const inc = LIS(nums)
+  const dec = LIS(nums.slice().reverse()).reverse()
+  let res = 0
+  for(let i = 0, len = nums.length; i < len; i++) {
+    if(inc[i] > 1 && dec[i] > 1) res = Math.max(res, inc[i] + dec[i] - 1)
+  }
+  return nums.length - res
+};
+
+function LIS(arr) {
+  const stack = []
+  const res = []
+  for(let e of arr) {
+    if((stack.length && e > stack[stack.length - 1]) || stack.length === 0) {
+      stack.push(e)
+      res.push(stack.length)
+      continue
+    }
+    let l = 0, r = stack.length - 1
+    while(l < r) {
+      const mid = l + ((r - l) >> 1)
+      if(stack[mid] < e) l = mid + 1
+      else r = mid
+    }
+    stack[l] = e
+    res.push(stack.length)
+  }
+  
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From f229d6b02a95894e074d881cb1bd3681641384ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Mar 2021 11:29:37 +0800
Subject: [PATCH 1174/3374] Update
 1775-equal-sum-arrays-with-minimum-number-of-operations.js

---
 ...rrays-with-minimum-number-of-operations.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/1775-equal-sum-arrays-with-minimum-number-of-operations.js b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
index cdbc354c..9137f466 100644
--- a/1775-equal-sum-arrays-with-minimum-number-of-operations.js
+++ b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minOperations = function(nums1, nums2) {
+  const m = nums1.length, n = nums2.length
+  if(m > n * 6 || n > m * 6) return -1
+  const sum1 = nums1.reduce((ac, e) => ac + e, 0)
+  const sum2 = nums2.reduce((ac, e) => ac + e, 0)
+  let largerArr, smallerArr
+  if(sum1 === sum2) return 0
+  if(sum1 > sum2) {
+    largerArr = nums1
+    smallerArr = nums2
+  } else {
+    largerArr = nums2
+    smallerArr = nums1
+  }
+  
+  const gain = []
+  for(let e of largerArr) gain.push(e - 1)
+  for(let e of smallerArr) gain.push(6 - e)
+  gain.sort((a, b) => b - a)
+  let diff = Math.abs(sum2 - sum1)
+  let cnt = 0
+  for(let e of gain) {
+    diff -= e
+    cnt++
+    if(diff <= 0) return cnt
+  }
+  return -1
+};
+
+
+
+
+// another
+
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2

From d2c79787144d707a4584e4fffc36656d49a42467 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Mar 2021 11:44:06 +0800
Subject: [PATCH 1175/3374] Update
 1775-equal-sum-arrays-with-minimum-number-of-operations.js

---
 ...rrays-with-minimum-number-of-operations.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1775-equal-sum-arrays-with-minimum-number-of-operations.js b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
index 9137f466..4f723a5a 100644
--- a/1775-equal-sum-arrays-with-minimum-number-of-operations.js
+++ b/1775-equal-sum-arrays-with-minimum-number-of-operations.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minOperations = function(nums1, nums2) {
+  const m = nums1.length, n = nums2.length
+  if(m > n * 6 || n > m * 6) return -1
+  let sum1 = sum(nums1), sum2 = sum(nums2)
+  if(sum1 > sum2) return minOperations(nums2, nums1)
+
+  const arr = Array(6).fill(0)
+  nums1.forEach(e => arr[6 - e]++)
+  nums2.forEach(e => arr[e - 1]++)
+
+  let res = 0, i = 5
+  while(sum1 < sum2) {
+    while(arr[i] === 0) i--
+    sum1 += i
+    res++
+    arr[i]--
+  }
+
+  return res
+};
+
+function sum(arr) {
+  return arr.reduce((ac, e) => ac + e, 0)
+}
+
+// another
+
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2

From c401e5c47a75a138ef4fd3cc36e4284923e0333b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Mar 2021 12:22:08 +0800
Subject: [PATCH 1176/3374] Update 1776-car-fleet-ii.js

---
 1776-car-fleet-ii.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1776-car-fleet-ii.js b/1776-car-fleet-ii.js
index 01eab963..34d81e53 100644
--- a/1776-car-fleet-ii.js
+++ b/1776-car-fleet-ii.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} cars
+ * @return {number[]}
+ */
+const getCollisionTimes = function(cars) {
+  const n = cars.length;
+  const stack = [];
+  const res = Array(n)
+  for(let i = n - 1; i >= 0; i--) {
+    const [p, s] = cars[i]
+    res[i] = -1
+    while(stack.length) {
+      const j = stack[stack.length - 1]
+      const [p2, s2] = cars[j]
+      if(s2 >= s || res[j] > 0 && (p2 - p) / (s - s2) >= res[j]) stack.pop()
+      else break
+    }
+    if(stack.length) {
+      const j = stack[stack.length - 1]
+      const [p2, s2] = cars[j]
+      res[i] = (p2 - p) / (s - s2)
+    }
+    stack.push(i)
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[][]} cars
  * @return {number[]}

From 72f19990721c195c79f376c36b4e50e8a94d6460 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Mar 2021 13:49:57 +0800
Subject: [PATCH 1177/3374] Update 1664-ways-to-make-a-fair-array.js

---
 1664-ways-to-make-a-fair-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1664-ways-to-make-a-fair-array.js b/1664-ways-to-make-a-fair-array.js
index 2651c597..11e38596 100644
--- a/1664-ways-to-make-a-fair-array.js
+++ b/1664-ways-to-make-a-fair-array.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const waysToMakeFair = function(nums) {
+  const n = nums.length, right = Array(2).fill(0), left = Array(2).fill(0)
+  let res = 0
+  for(let i = 0; i < n; i++) right[i % 2] += nums[i]
+  for(let i = 0; i < n; i++) {
+    right[i % 2] -= nums[i]
+    if(left[0] + right[1] === left[1] + right[0]) res++
+    left[i % 2] += nums[i]
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From ed2a7410cae43d6aa63f8ebeacc59d5fbba3f24c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Mar 2021 20:27:59 +0800
Subject: [PATCH 1178/3374] Create
 1784-check-if-binary-string-has-at-most-one-segment-of-ones.js

---
 ...-binary-string-has-at-most-one-segment-of-ones.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1784-check-if-binary-string-has-at-most-one-segment-of-ones.js

diff --git a/1784-check-if-binary-string-has-at-most-one-segment-of-ones.js b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.js
new file mode 100644
index 00000000..25300c32
--- /dev/null
+++ b/1784-check-if-binary-string-has-at-most-one-segment-of-ones.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkOnesSegment = function(s) {
+  let res = 1
+  for(let i = 1, len = s.length; i < len; i++) {
+    if(s[i] === '1' && s[i - 1] === '0') res++
+    if(s[i] === '1' && s[i - 1] === '1') continue
+  }
+  return res <= 1
+};

From 789d29e48fd9faf260b927418f0edda214dcc681 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Mar 2021 20:29:03 +0800
Subject: [PATCH 1179/3374] Create
 1785-minimum-elements-to-add-to-form-a-given-sum.js

---
 ...minimum-elements-to-add-to-form-a-given-sum.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1785-minimum-elements-to-add-to-form-a-given-sum.js

diff --git a/1785-minimum-elements-to-add-to-form-a-given-sum.js b/1785-minimum-elements-to-add-to-form-a-given-sum.js
new file mode 100644
index 00000000..ea8518bd
--- /dev/null
+++ b/1785-minimum-elements-to-add-to-form-a-given-sum.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @param {number} goal
+ * @return {number}
+ */
+const minElements = function(nums, limit, goal) {
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  let delta = goal - sum
+  if(delta === 0) return 0
+  const op = delta > 0 ? '+' : '-'
+  let res = 0
+  delta = Math.abs(delta)
+  return  Math.floor(delta / limit) + (delta % limit > 0 ? 1 : 0)
+};

From 8ec9439fea5d3ce3ad597a95c04d0887b1d737e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Mar 2021 21:21:01 +0800
Subject: [PATCH 1180/3374] Create
 1786-number-of-restricted-paths-from-first-to-last-node.js

---
 ...estricted-paths-from-first-to-last-node.js | 118 ++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 1786-number-of-restricted-paths-from-first-to-last-node.js

diff --git a/1786-number-of-restricted-paths-from-first-to-last-node.js b/1786-number-of-restricted-paths-from-first-to-last-node.js
new file mode 100644
index 00000000..0552741f
--- /dev/null
+++ b/1786-number-of-restricted-paths-from-first-to-last-node.js
@@ -0,0 +1,118 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countRestrictedPaths = function(n, edges) {
+  const adj = {}
+  const MOD = 10 ** 9 + 7
+  for(let edge of edges) {
+    const [u,v,d] = edge
+    if(adj[u] == null) adj[u] = []
+    if(adj[v] == null) adj[v] = []
+    adj[u].push([v, d])
+    adj[v].push([u, d])
+  }
+  const dist = Array(n + 1).fill(Infinity)
+  dist[n] = 0
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  pq.push([0, n])
+  while(!pq.isEmpty()) {
+    const [d, u] = pq.peek()
+    pq.pop()
+    if(d > dist[u]) continue
+    for(let [v, c] of adj[u]) {
+      if(d + c < dist[v]) {
+        dist[v] = d + c
+        pq.push([dist[v], v])
+      }
+    }
+  }
+    
+  const order = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    order[i] = i + 1
+  }
+    
+  order.sort((u, v) => dist[u] - dist[v])
+  const ans = Array(n + 1).fill(0)
+  ans[n] = 1
+  for(let u of order) {
+    for(let [v, c] of adj[u]) {
+      if(dist[v] > dist[u]) {
+        ans[v] = (ans[v] + ans[u]) % MOD
+      }
+    }
+  }
+    
+  return ans[1]
+};
+
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From cbde64d1174bb8356c7b52218e4674616776ad6b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Mar 2021 22:00:33 +0800
Subject: [PATCH 1181/3374] Create
 1787-make-the-xor-of-all-segments-equal-to-zero.js

---
 ...e-the-xor-of-all-segments-equal-to-zero.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1787-make-the-xor-of-all-segments-equal-to-zero.js

diff --git a/1787-make-the-xor-of-all-segments-equal-to-zero.js b/1787-make-the-xor-of-all-segments-equal-to-zero.js
new file mode 100644
index 00000000..db715bc4
--- /dev/null
+++ b/1787-make-the-xor-of-all-segments-equal-to-zero.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const L = 2 ** 10;
+const MAX = Number.MAX_SAFE_INTEGER;
+const mi = Math.min;
+const minChanges = (a, k) => {
+    let n = a.length;
+    let dp = Array(L).fill(MAX);
+    dp[0] = 0;
+    for (let i = 0; i < k; i++) {
+        let tmp = Array(L).fill(0);
+        let tot = 0;
+        for (let j = i; j < n; j += k) {
+            tmp[a[j]]++; // frequency count of starting points from each kth continuous subarray
+            tot++; // total count of starting points from each kth continuous subarray
+        }
+        let ndp = Array(L).fill(0);
+        let min = MAX;
+        for (let j = 0; j < L; j++) {
+            min = mi(min, dp[j]);
+        }
+        min += tot;
+        ndp = ndp.map(x => x = min); // updated nested dp array with min value
+        for (let j = 0; j < L; j++) {
+            if (tmp[j] != 0) {
+                for (let m = 0; m < L; m++) {
+                    ndp[m ^ j] = mi(ndp[m ^ j], dp[m] + tot - tmp[j]);
+                }
+            }
+        }
+        dp = ndp;  // reset dp
+    }
+    return dp[0];
+};

From a3382d9c42b06a95ce40cfa0a911e2b8fc1c3eed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 09:09:26 +0800
Subject: [PATCH 1182/3374] Update 42-trapping-rain-water.js

---
 42-trapping-rain-water.js | 34 ++++++++++++----------------------
 1 file changed, 12 insertions(+), 22 deletions(-)

diff --git a/42-trapping-rain-water.js b/42-trapping-rain-water.js
index 4f6245b4..ef63143f 100644
--- a/42-trapping-rain-water.js
+++ b/42-trapping-rain-water.js
@@ -52,29 +52,19 @@ const trap = function(height) {
  * @return {number}
  */
 const trap = function(height) {
-  const len = height.length
-  if(len === 0) return 0
-  let left = 0
-  let right = len - 1
-  let leftMax = 0
-  let rightMax = 0
-  let res = 0
-  while(left < right) {
-    if(height[left] < height[right]) {
-      if(height[left] <= leftMax) {
-        res += leftMax - height[left]
-      } else {
-        leftMax = height[left]
-      }
-      left++
+  const n = height.length
+  let l = 0, r = n - 1, res = 0, leftMax = 0, rightMax = 0
+  while(l <= r) {
+    if(height[l] <= height[r]) {
+      if(height[l] >= leftMax) leftMax = height[l]
+      else res += leftMax - height[l]
+      l++
     } else {
-      if(height[right] <= rightMax) {
-         res += rightMax - height[right]
-      } else {
-        rightMax = height[right]
-      }
-      right--
+      if(height[r] >= rightMax) rightMax = height[r]
+      else res += rightMax - height[r]
+      r--
     }
   }
   return res
-};  
+};
+

From db08b2428b245350007aa7a8c1e4b6cebfa7dd48 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 11:27:28 +0800
Subject: [PATCH 1183/3374] Update 7-reverse-integer.js

---
 7-reverse-integer.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/7-reverse-integer.js b/7-reverse-integer.js
index f6f83c2a..4a2fef60 100755
--- a/7-reverse-integer.js
+++ b/7-reverse-integer.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+const reverse = function (x) {
+  let res = 0, tail, newResult
+  const low = -Math.pow(2, 31), high = Math.pow(2, 31)
+  while(x !== 0) {
+    tail = x % 10
+    newResult = res * 10 + tail
+    // if((newResult - tail) / 10 !== res) return 0
+    if(newResult < low || newResult >= high) return 0
+    res = newResult
+    x = ~~(x / 10)
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number} x
  * @return {number}

From 47d626c6d5a93d0f81e4fb969ae41c8df00fd889 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 14:07:12 +0800
Subject: [PATCH 1184/3374] Update 8-string-to-integer-(atoi).js

---
 8-string-to-integer-(atoi).js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/8-string-to-integer-(atoi).js b/8-string-to-integer-(atoi).js
index 26bb1c86..aa0ff301 100755
--- a/8-string-to-integer-(atoi).js
+++ b/8-string-to-integer-(atoi).js
@@ -5,3 +5,33 @@
 const myAtoi = function(str) {
   return Math.max(Math.min(parseInt(str) || 0, 2147483647), -2147483648);
 };
+
+// anotther
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const myAtoi = function(s) {
+    let n = s.length, i = 0, j = 0, sign = 1;
+    if(n === 0) {
+        return 0;
+    } 
+    while(i < n && s[i] === ' ') {
+        i++;
+    }
+    if(i < n && (s[i] === '-' || s[i] === '+')) {
+        sign = (s[i] === '-') ? -1 : 1;
+        i++;
+    }
+    j = i
+    while(i < n) {
+        if(Number.isInteger(parseInt(s[i]))) i++;
+        else break;
+    }
+    let result = parseInt(s.slice(j, i))
+    if(isNaN(result)) return 0
+    if(sign * result < -(2**31)) return -(2**31);
+    else if(sign * result > (2**31-1)) return 2**31-1;
+    else return sign * result;  
+};

From 4fd8ec129438662e8d9b243c3e54f45b4c1f4a61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 15:25:39 +0800
Subject: [PATCH 1185/3374] Update 11-container-with-most-water.js

---
 11-container-with-most-water.js | 18 +++++++-----------
 1 file changed, 7 insertions(+), 11 deletions(-)

diff --git a/11-container-with-most-water.js b/11-container-with-most-water.js
index 623b971b..2b3aa808 100755
--- a/11-container-with-most-water.js
+++ b/11-container-with-most-water.js
@@ -3,16 +3,12 @@
  * @return {number}
  */
 const maxArea = function(height) {
-  const arr = [];
-  const arr_len = height.length;
-  for (let i = 0, j = arr_len - 1; i < j; ) {
-    arr.push(Math.abs(j - i) * Math.min(height[i], height[j]));
-    if (height[i] < height[j]) {
-      i++;
-    } else {
-      j--;
-    }
+  let res = 0, l = 0, r = height.length - 1
+  while(l < r) {
+    const tmp = (r - l) * Math.min(height[l], height[r])
+    if(tmp > res) res = tmp
+    if(height[l] < height[r]) l++
+    else r--
   }
-
-  return Math.max.apply(Math, arr);
+  return res
 };

From a7fa5c0ec6c74aa4b392238fcb7bc0685da458cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 16:12:37 +0800
Subject: [PATCH 1186/3374] Update 23-merge-k-sorted-lists.js

---
 23-merge-k-sorted-lists.js | 100 +++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)

diff --git a/23-merge-k-sorted-lists.js b/23-merge-k-sorted-lists.js
index 982922fa..73b598ea 100644
--- a/23-merge-k-sorted-lists.js
+++ b/23-merge-k-sorted-lists.js
@@ -33,3 +33,103 @@ function merge(lists, l, r) {
   head.next = left ? left : right
   return dummy.next
 }
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+const mergeKLists = function(lists) {
+  if(lists == null || lists.length === 0) return null
+  const dummy = new ListNode()
+  let head = dummy
+  const pq = new PriorityQueue((a, b) => a.val < b.val)
+  for(let list of lists) {
+    while(list) {
+      pq.push(list)
+      list = list.next
+    }
+  }
+  while(!pq.isEmpty()) {
+    const pop = pq.pop()
+    head.next = new ListNode(pop.val)
+    head = head.next
+  }
+  return dummy.next
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 5e3c039c0b1626aec0d32a7a941aec04253ed939 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Mar 2021 21:17:52 +0800
Subject: [PATCH 1187/3374] Update 227-basic-calculator-ii.js

---
 227-basic-calculator-ii.js | 34 +++++++++++++++-------------------
 1 file changed, 15 insertions(+), 19 deletions(-)

diff --git a/227-basic-calculator-ii.js b/227-basic-calculator-ii.js
index 575bb6be..1aecde43 100644
--- a/227-basic-calculator-ii.js
+++ b/227-basic-calculator-ii.js
@@ -3,24 +3,20 @@
  * @return {number}
  */
 const calculate = function(s) {
-  if (!s || !s.length) return 0
-  let n = 0
-  let op = '+'
-  const stack = []
-  for (let i = 0; i < s.length; i++) {
-    let c = s.charAt(i)
-    let isNumber = '0' <= c && c <= '9'
-    if (isNumber) {
-      n = n * 10 + +c
-    }
-    if ((!isNumber && c !== ' ') || i == s.length - 1) {
-      if (op === '+') stack.push(n)
-      else if (op === '-') stack.push(-n)
-      else if (op === '*') stack.push(stack.pop() * n)
-      else if (op === '/') stack.push(~~(stack.pop() / n))
-      op = c
-      n = 0
+  const stack = [], n = s.length
+  let op = '+', num = 0
+  for(let i = 0; i < n; i++) {
+    const isNumber = s[i] >= '0' && s[i] <= '9'
+    if(isNumber) num = num * 10 + (+s[i])
+    if((!isNumber && s[i] !== ' ') || i === n - 1) {
+      if(op === '+') stack.push(num)
+      else if(op === '-') stack.push(-num)
+      else if(op === '*') stack.push(stack.pop() * num)
+      else if(op === '/') stack.push(~~(stack.pop() / num))
+      op = s[i]
+      num = 0
     }
   }
-  return stack.reduce((a, b) => a + b, 0)
-}
+  
+  return stack.reduce((ac, e) => ac + e, 0)
+};

From 77742be4aa46d79067d39523d9a7a7ae558f46c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Mar 2021 21:44:54 +0800
Subject: [PATCH 1188/3374] Create
 1525-number-of-good-ways-to-split-a-string.js

---
 1525-number-of-good-ways-to-split-a-string.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1525-number-of-good-ways-to-split-a-string.js

diff --git a/1525-number-of-good-ways-to-split-a-string.js b/1525-number-of-good-ways-to-split-a-string.js
new file mode 100644
index 00000000..5d1b4093
--- /dev/null
+++ b/1525-number-of-good-ways-to-split-a-string.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numSplits = function(s) {
+  const arr = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for(let i = 0, len = s.length; i < len; i++) {
+    arr[s.charCodeAt(i) - a]++
+  }
+  const cur = Array(26).fill(0)
+  let res = 0
+  for(let i = 0, len = s.length; i < len - 1; i++) {
+    cur[s.charCodeAt(i) - a]++
+    let tmp = false, clone = arr.slice()
+    for(let j = 0; j < 26; j++) {
+      clone[j] -= cur[j]
+    }
+    const curNum = cur.reduce((ac, e) => ac + (e > 0 ? 1 : 0), 0)
+    const cloneNum = clone.reduce((ac, e) => ac + (e > 0 ? 1 : 0), 0)
+    if(curNum === cloneNum) res++
+  }
+  
+  return res
+};
+

From 35b9564e97f705bf2ebedb77980f2a7b77f146c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Mar 2021 22:09:13 +0800
Subject: [PATCH 1189/3374] Update
 1525-number-of-good-ways-to-split-a-string.js

---
 1525-number-of-good-ways-to-split-a-string.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1525-number-of-good-ways-to-split-a-string.js b/1525-number-of-good-ways-to-split-a-string.js
index 5d1b4093..4c443bc6 100644
--- a/1525-number-of-good-ways-to-split-a-string.js
+++ b/1525-number-of-good-ways-to-split-a-string.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numSplits = function(s) {
+  const n = s.length
+  const freq = new Map()
+  const prefix = Array(26).fill(0)
+  for(let i = 0; i < n; i++) {
+    if(freq.get(s[i]) == null) freq.set(s[i], 0)
+    freq.set(s[i], freq.get(s[i]) + 1)
+    prefix[i] = freq.size
+  }
+  freq.clear()
+  const suffix = Array(26).fill(0)
+  for(let i = n - 1; i >= 0 ;i--) {
+    if(freq.get(s[i]) == null) freq.set(s[i], 0)
+    freq.set(s[i], freq.get(s[i]) + 1)
+    suffix[i] = freq.size
+  }
+  // console.log(prefix, suffix)
+  let res = 0
+  for(let i = 1; i < n; i++) {
+    if(prefix[i - 1] === suffix[i]) res++
+  }
+  
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 600e1d9a7625c703b45cacb4fd8a534db881ec50 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Mar 2021 14:29:54 +0800
Subject: [PATCH 1190/3374] Update 450-delete-node-in-a-bst.js

---
 450-delete-node-in-a-bst.js | 33 +++++++++++++++++----------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/450-delete-node-in-a-bst.js b/450-delete-node-in-a-bst.js
index 8e6b80ef..a66de96d 100644
--- a/450-delete-node-in-a-bst.js
+++ b/450-delete-node-in-a-bst.js
@@ -11,22 +11,23 @@
  * @return {TreeNode}
  */
 const deleteNode = function(root, key) {
-    if(root == null) return null
-    if (root.val > key) {
-        root.left = deleteNode(root.left, key)
-    } else if(root.val < key) {
-        root.right = deleteNode(root.right, key)
+  if(root == null) return null
+  if(key < root.val) {
+    root.left = deleteNode(root.left, key)
+  } else if(key > root.val) {
+    root.right = deleteNode(root.right, key)
+  } else {
+    if(root.left == null) {
+      return root.right
+    } else if(root.right == null) {
+      return root.left
     } else {
-        if (root.left == null) {
-            return root.right
-        }
-        if (root.right == null) {
-            return root.left
-        }
-        let rightSmallest = root.right
-        while(rightSmallest.left != null) rightSmallest = rightSmallest.left
-        rightSmallest.left = root.left
-        return root.right
+      let smallestRight = root.right
+      while(smallestRight.left !== null) smallestRight = smallestRight.left
+      smallestRight.left = root.left
+      return root.right
     }
-    return root
+  }
+  
+  return root
 };

From 6d1982117c21f99244fe3f1b09bbdd988f22a202 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Mar 2021 09:15:19 +0800
Subject: [PATCH 1191/3374] Update 83-remove-duplicates-from-sorted-list.js

---
 83-remove-duplicates-from-sorted-list.js | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/83-remove-duplicates-from-sorted-list.js b/83-remove-duplicates-from-sorted-list.js
index b78e214c..6339d4e7 100755
--- a/83-remove-duplicates-from-sorted-list.js
+++ b/83-remove-duplicates-from-sorted-list.js
@@ -20,3 +20,31 @@ const deleteDuplicates = function(head) {
   }
   return head;
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const deleteDuplicates = function(head) {
+  let prev = null, cur = head
+  while(cur) {
+    if(prev && prev.val === cur.val) {
+      prev.next = cur.next
+      cur = cur.next
+    } else {
+      prev = cur
+      cur = cur.next      
+    }
+  }
+  return head
+};
+

From 79c19348c334cb4c8b37c4bcf410c9fc75bd3bba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Mar 2021 09:41:37 +0800
Subject: [PATCH 1192/3374] Create 1781-sum-of-beauty-of-all-substrings.js

---
 1781-sum-of-beauty-of-all-substrings.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1781-sum-of-beauty-of-all-substrings.js

diff --git a/1781-sum-of-beauty-of-all-substrings.js b/1781-sum-of-beauty-of-all-substrings.js
new file mode 100644
index 00000000..6926fff3
--- /dev/null
+++ b/1781-sum-of-beauty-of-all-substrings.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const beautySum = function(s) {
+  let ans = 0
+  const a = 'a'.charCodeAt(0)
+  const min = arr => {
+    let res = Infinity
+    for(let e of arr) {
+      if(e !== 0) res = Math.min(e, res)
+    }
+    return res
+  }
+  for(let i = 0, n = s.length; i < n; i++) {
+    let freq = Array(26).fill(0)
+    for(let j = i; j < n; j++) {
+      freq[s.charCodeAt(j) - a]++
+      ans += Math.max(...freq) - min(freq)
+    }
+  }
+  return ans 
+};

From 8d3e6b8c9c3b509a1013eab4275f96fcc24c8ca6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Mar 2021 10:33:27 +0800
Subject: [PATCH 1193/3374] Update 92-reverse-linked-list-ii.js

---
 92-reverse-linked-list-ii.js | 42 ++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/92-reverse-linked-list-ii.js b/92-reverse-linked-list-ii.js
index c9995ac3..b9d5efef 100644
--- a/92-reverse-linked-list-ii.js
+++ b/92-reverse-linked-list-ii.js
@@ -83,3 +83,45 @@ const reverseBetween = function(head, m, n) {
     }
     return dummy.next;
 };
+
+
+// another
+
+/**
+ * @param {ListNode} head
+ * @param {number} left
+ * @param {number} right
+ * @return {ListNode}
+ */
+const reverseBetween = function(head, left, right) {
+  if(head == null) return head
+  if(left === right) return head
+  let cur = head, prev = null
+  let step = 1
+  while(step !== left) {
+    prev = cur
+    cur = cur.next
+    step++
+  }
+  let l = cur
+  while(step !== right) {
+    cur = cur.next
+    step++
+  }
+  let r = cur, next = cur.next
+  // reverse
+  
+  let start = l, p = null
+  while(start !== r) {
+    let n = start.next
+    start.next = p
+    p = start
+    start = n
+  }
+
+  r.next = p
+  l.next = next
+  if(prev) prev.next = r
+
+  return prev ? head : r
+};

From 4c538f4ad6626be3fb6de6742b331d558cbe3a54 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Mar 2021 16:17:34 +0800
Subject: [PATCH 1194/3374] Update 162-find-peak-element.js

---
 162-find-peak-element.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/162-find-peak-element.js b/162-find-peak-element.js
index 526b153d..c3c9bd07 100644
--- a/162-find-peak-element.js
+++ b/162-find-peak-element.js
@@ -1,3 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findPeakElement = function(nums) {
+  let low = 0;
+  let high = nums.length-1;
+
+  while(low < high) {
+    let mid1 = low + ((high - low) >> 1);
+    let mid2 = mid1 + 1;
+    if(nums[mid1] < nums[mid2]) low = mid2;
+    else high = mid1;
+  }
+  return low;
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 3a1fab0a953130082df7248de0eafb5466d5d092 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Mar 2021 20:05:27 +0800
Subject: [PATCH 1195/3374] Update 136-single-number.js

---
 136-single-number.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/136-single-number.js b/136-single-number.js
index 4010bf48..662dfc28 100644
--- a/136-single-number.js
+++ b/136-single-number.js
@@ -7,3 +7,14 @@ const singleNumber = function(nums) {
   for(let i = 1; i< nums.length; i++) xor ^= nums[i]
   return xor
 };
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNumber = function(nums) {
+  return nums.reduce((ac, e) => ac ^ e, 0)
+};

From 7bb3bc92f86bda4f4c62bb8be791f8c740a9724b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:41:13 +0800
Subject: [PATCH 1196/3374] Create maximum-score-of-a-good-subarray.js

---
 maximum-score-of-a-good-subarray.js | 31 +++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 maximum-score-of-a-good-subarray.js

diff --git a/maximum-score-of-a-good-subarray.js b/maximum-score-of-a-good-subarray.js
new file mode 100644
index 00000000..bd2aa809
--- /dev/null
+++ b/maximum-score-of-a-good-subarray.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumScore = function(nums, k) {
+  const n = nums.length
+  let minVal = nums[k]
+  let len = 1, ans = minVal * len, l = k - 1, r = k + 1
+  while(l >= 0 || r < n) {
+    len++
+    let i = 0
+    if(l < 0) {
+      i = r
+      r++
+    } else if(r === n) {
+      i = l
+      l--
+    } else if(nums[l] < nums[r]) {
+      i = r
+      r++
+    } else {
+      i = l
+      l--
+    }
+    minVal = Math.min(minVal, nums[i])
+    const tmp = minVal * len
+    if(tmp > ans) ans = tmp
+  }
+  return ans
+};

From 40c706d17b031e2a87bff6d50fce098142b4fc8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:41:56 +0800
Subject: [PATCH 1197/3374] Create maximum-average-pass-ratio.js

---
 maximum-average-pass-ratio.js | 103 ++++++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 maximum-average-pass-ratio.js

diff --git a/maximum-average-pass-ratio.js b/maximum-average-pass-ratio.js
new file mode 100644
index 00000000..c321b6b4
--- /dev/null
+++ b/maximum-average-pass-ratio.js
@@ -0,0 +1,103 @@
+/**
+ * @param {number[][]} classes
+ * @param {number} extraStudents
+ * @return {number}
+ */
+const maxAverageRatio = function(classes, extraStudents) {
+  const pq = new PriorityQueue((a, b) => a.up > b.up);
+  for (let x of classes) pq.push(new Node(x[0], x[1]));
+  while (extraStudents--) {
+    let temp = pq.peek();
+    pq.pop();
+    temp.pass++, temp.total++;
+    temp.calUp();
+    pq.push(temp);
+  }
+    let total = 0.0;
+    let n = classes.length;
+    while (!pq.isEmpty()) {
+        let temp = pq.peek();
+        pq.pop();
+        total += temp.pass / temp.total;
+    }
+    return total / n;
+};
+
+class Node {
+  constructor(pass, total) {
+    this.pass = pass
+    this.total = total
+    this.calUp()
+  }
+  calUp() {
+    this.up = (this.pass + 1) / (this.total + 1) - this.pass / this.total
+  }
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 1893f4977fb39d34936101763d8e7a270fa2f2fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:42:27 +0800
Subject: [PATCH 1198/3374] Create find-center-of-star-graph.js

---
 find-center-of-star-graph.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 find-center-of-star-graph.js

diff --git a/find-center-of-star-graph.js b/find-center-of-star-graph.js
new file mode 100644
index 00000000..9cc88b93
--- /dev/null
+++ b/find-center-of-star-graph.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const findCenter = function(edges) {
+  const map = {}
+  for(let e of edges) {
+    const [u, v] = e
+    if(map[u] == null) map[u] = []
+    if(map[v] == null) map[v] = []
+    map[u].push(v)
+    map[v].push(u)
+  }
+  
+  const keys = Object.keys(map)
+  let res, max = -Infinity
+  keys.forEach(e => {
+    if(map[e].length > max) {
+      res = e
+      max = map[e].length
+    }
+  })
+  
+  return res
+  
+};

From 2d4f56225a366946e4047cc37287fd25929466c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:43:05 +0800
Subject: [PATCH 1199/3374] Create
 check-if-one-string-swap-can-make-strings-equal.js

---
 ...-one-string-swap-can-make-strings-equal.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 check-if-one-string-swap-can-make-strings-equal.js

diff --git a/check-if-one-string-swap-can-make-strings-equal.js b/check-if-one-string-swap-can-make-strings-equal.js
new file mode 100644
index 00000000..86960808
--- /dev/null
+++ b/check-if-one-string-swap-can-make-strings-equal.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+const areAlmostEqual = function(s1, s2) {
+  if (s1 === s2) return true
+  let arr = []
+  for(let i = 0, len = s1.length; i < len; i++) {
+    if(s1[i] !== s2[i]) arr.push(i)
+    
+    if(arr.length > 2) return false
+  }
+  
+  if(arr.length === 1) return false
+  const [i1, i2] = arr
+  if(s1[i2] === s2[i1]) return true
+  return false
+};

From 6976acd0a9c35049c75842b5a80e1d062342c7d6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:50:43 +0800
Subject: [PATCH 1200/3374] Update maximum-score-of-a-good-subarray.js

---
 maximum-score-of-a-good-subarray.js | 37 +++++++++++++----------------
 1 file changed, 16 insertions(+), 21 deletions(-)

diff --git a/maximum-score-of-a-good-subarray.js b/maximum-score-of-a-good-subarray.js
index bd2aa809..78afaaad 100644
--- a/maximum-score-of-a-good-subarray.js
+++ b/maximum-score-of-a-good-subarray.js
@@ -4,28 +4,23 @@
  * @return {number}
  */
 const maximumScore = function(nums, k) {
-  const n = nums.length
-  let minVal = nums[k]
-  let len = 1, ans = minVal * len, l = k - 1, r = k + 1
-  while(l >= 0 || r < n) {
-    len++
-    let i = 0
-    if(l < 0) {
-      i = r
-      r++
-    } else if(r === n) {
-      i = l
-      l--
-    } else if(nums[l] < nums[r]) {
-      i = r
-      r++
+  const n = nums.length, {min, max} = Math
+  let mini = nums[k];
+  let ans = mini;
+  let i = k;
+  let j = k;
+
+  while (i > 0 || j < n - 1) {
+    if (i == 0 || (j+1 < n && nums[i-1] <= nums[j+1])) {
+      j++;
+      mini = min(mini, nums[j]);
+      ans = max(ans, mini * (j - i + 1));
     } else {
-      i = l
-      l--
+      i--;
+      mini = min(mini, nums[i]);
+      ans = max(ans, mini * (j - i + 1));
     }
-    minVal = Math.min(minVal, nums[i])
-    const tmp = minVal * len
-    if(tmp > ans) ans = tmp
   }
-  return ans
+
+  return ans;
 };

From a9e8c1e63cb9f8ae0611d7dcde49527a5f837d92 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 11:54:07 +0800
Subject: [PATCH 1201/3374] Update maximum-score-of-a-good-subarray.js

---
 maximum-score-of-a-good-subarray.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/maximum-score-of-a-good-subarray.js b/maximum-score-of-a-good-subarray.js
index 78afaaad..233f0301 100644
--- a/maximum-score-of-a-good-subarray.js
+++ b/maximum-score-of-a-good-subarray.js
@@ -11,15 +11,14 @@ const maximumScore = function(nums, k) {
   let j = k;
 
   while (i > 0 || j < n - 1) {
-    if (i == 0 || (j+1 < n && nums[i-1] <= nums[j+1])) {
+    if (i === 0 || (j + 1 < n && nums[i - 1] <= nums[j + 1])) {
       j++;
       mini = min(mini, nums[j]);
-      ans = max(ans, mini * (j - i + 1));
     } else {
       i--;
       mini = min(mini, nums[i]);
-      ans = max(ans, mini * (j - i + 1));
     }
+    ans = max(ans, mini * (j - i + 1));
   }
 
   return ans;

From f4e16d828815aafba83833647c5ded0831441b63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 12:04:59 +0800
Subject: [PATCH 1202/3374] Rename maximum-score-of-a-good-subarray.js to
 1793-maximum-score-of-a-good-subarray.js

---
 ...a-good-subarray.js => 1793-maximum-score-of-a-good-subarray.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename maximum-score-of-a-good-subarray.js => 1793-maximum-score-of-a-good-subarray.js (100%)

diff --git a/maximum-score-of-a-good-subarray.js b/1793-maximum-score-of-a-good-subarray.js
similarity index 100%
rename from maximum-score-of-a-good-subarray.js
rename to 1793-maximum-score-of-a-good-subarray.js

From c73829e905fd803e169fd268d6289073e09f0484 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 12:05:20 +0800
Subject: [PATCH 1203/3374] Rename maximum-average-pass-ratio.js to
 1792-maximum-average-pass-ratio.js

---
 ...um-average-pass-ratio.js => 1792-maximum-average-pass-ratio.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename maximum-average-pass-ratio.js => 1792-maximum-average-pass-ratio.js (100%)

diff --git a/maximum-average-pass-ratio.js b/1792-maximum-average-pass-ratio.js
similarity index 100%
rename from maximum-average-pass-ratio.js
rename to 1792-maximum-average-pass-ratio.js

From 4ea889fc96765fbd6e293c43c70543700336386b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 12:05:48 +0800
Subject: [PATCH 1204/3374] Rename find-center-of-star-graph.js to
 1791-find-center-of-star-graph.js

---
 find-center-of-star-graph.js => 1791-find-center-of-star-graph.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename find-center-of-star-graph.js => 1791-find-center-of-star-graph.js (100%)

diff --git a/find-center-of-star-graph.js b/1791-find-center-of-star-graph.js
similarity index 100%
rename from find-center-of-star-graph.js
rename to 1791-find-center-of-star-graph.js

From e8142af6dbabdbc71b4072e02f4f76e09d8ed2c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 12:06:18 +0800
Subject: [PATCH 1205/3374] Rename
 check-if-one-string-swap-can-make-strings-equal.js to
 1790-check-if-one-string-swap-can-make-strings-equal.js

---
 ....js => 1790-check-if-one-string-swap-can-make-strings-equal.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename check-if-one-string-swap-can-make-strings-equal.js => 1790-check-if-one-string-swap-can-make-strings-equal.js (100%)

diff --git a/check-if-one-string-swap-can-make-strings-equal.js b/1790-check-if-one-string-swap-can-make-strings-equal.js
similarity index 100%
rename from check-if-one-string-swap-can-make-strings-equal.js
rename to 1790-check-if-one-string-swap-can-make-strings-equal.js

From 876211ce8459e935a7773ee31dfc33433af3d48d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Mar 2021 13:53:23 +0800
Subject: [PATCH 1206/3374] Update 1791-find-center-of-star-graph.js

---
 1791-find-center-of-star-graph.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/1791-find-center-of-star-graph.js b/1791-find-center-of-star-graph.js
index 9cc88b93..b57647b9 100644
--- a/1791-find-center-of-star-graph.js
+++ b/1791-find-center-of-star-graph.js
@@ -1,3 +1,13 @@
+/**
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const findCenter = function(edges) {
+  return edges[0][0] === edges[1][0] || edges[0][0] === edges[1][1] ? edges[0][0] : edges[0][1]
+};
+
+// another
+
 /**
  * @param {number[][]} edges
  * @return {number}

From 3cd991bed26bf51f24f24ea14d03b2656cf94d8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Mar 2021 10:01:25 +0800
Subject: [PATCH 1207/3374] Create 1310-xor-queries-of-a-subarray.js

---
 1310-xor-queries-of-a-subarray.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1310-xor-queries-of-a-subarray.js

diff --git a/1310-xor-queries-of-a-subarray.js b/1310-xor-queries-of-a-subarray.js
new file mode 100644
index 00000000..efad256d
--- /dev/null
+++ b/1310-xor-queries-of-a-subarray.js
@@ -0,0 +1,19 @@
+ /**
+ * @param {number[]} arr
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const xorQueries = function(arr, queries) {
+  const pre = [], n = arr.length
+  let xor = arr[0]
+  pre.push(xor)
+  for(let i = 1; i < n; i++) {
+    pre[i] = pre[i - 1] ^ arr[i]
+  }
+
+  const res = queries.map((e, i) => {
+    const [l, r] = e
+    return pre[r] ^ (l > 0 ? pre[l - 1] : 0)
+  })
+  return res
+};

From 56917f8e41c1c9a0d35d79a642ecc2a161b3081c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Mar 2021 10:43:48 +0800
Subject: [PATCH 1208/3374] Create
 1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js

---
 ...s-that-can-form-two-arrays-of-equal-xor.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js

diff --git a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
new file mode 100644
index 00000000..f9243e7e
--- /dev/null
+++ b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const countTriplets = function(arr) {
+  arr.unshift(0)
+  const n = arr.length
+  let res = 0
+  for(let i = 1; i < n; i++) {
+    arr[i] ^= arr[i - 1]
+  }
+  const count = {}, total = {}
+  for(let i = 0; i < n; i++) {
+    if(count[arr[i]] == null) count[arr[i]] = 0
+    if(total[arr[i]] == null) total[arr[i]] = 0
+    res += count[arr[i]]++ * (i - 1) - total[arr[i]]
+    total[arr[i]] += i
+  }
+  return res
+};

From fd8f629ef83b9780dc4c56fe89feda2f9adfbd78 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Mar 2021 20:01:34 +0800
Subject: [PATCH 1209/3374] Update
 1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js

---
 ...s-that-can-form-two-arrays-of-equal-xor.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
index f9243e7e..02a65836 100644
--- a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
+++ b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
@@ -1,3 +1,24 @@
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const countTriplets = function(arr) {
+  let res = 0
+  const n = arr.length
+  for(let i = 0; i < n; i++) {
+    let xor = arr[i]
+    for(let j = i + 1; j < n; j++) {
+      xor ^= arr[j]
+      if(xor === 0) res += j - i
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} arr
  * @return {number}

From e93c652fe21b04c07abfc6579857f7efe4ce7461 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Mar 2021 11:20:40 +0800
Subject: [PATCH 1210/3374] Update 1792-maximum-average-pass-ratio.js

---
 1792-maximum-average-pass-ratio.js | 108 +++++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/1792-maximum-average-pass-ratio.js b/1792-maximum-average-pass-ratio.js
index c321b6b4..58573af6 100644
--- a/1792-maximum-average-pass-ratio.js
+++ b/1792-maximum-average-pass-ratio.js
@@ -1,3 +1,111 @@
+/**
+ * @param {number[][]} classes
+ * @param {number} extraStudents
+ * @return {number}
+ */
+const maxAverageRatio = function (classes, extraStudents) {
+  const pq = new PriorityQueue((a, b) => a.delta > b.delta)
+  const n = classes.length
+  for (let e of classes) {
+    pq.push({
+      pass: e[0],
+      total: e[1],
+      ratio: e[0] / e[1],
+      delta: (e[0] + 1) / (e[1] + 1) - e[0] / e[1],
+    })
+  }
+
+  while (extraStudents) {
+    const tmp = pq.pop()
+    tmp.pass++
+    tmp.total++
+    tmp.ratio = tmp.pass / tmp.total
+    tmp.delta = (tmp.pass + 1) / (tmp.total + 1) - tmp.ratio
+    pq.push(tmp)
+    extraStudents--
+  }
+
+  let res = 0
+  while (!pq.isEmpty()) {
+    const tmp = pq.pop()
+    res += tmp.ratio
+  }
+
+  return res / n
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+
+
+// another
+
 /**
  * @param {number[][]} classes
  * @param {number} extraStudents

From 0416c0a981c000e1bb7e2b4e2c31188d0b4ea206 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Mar 2021 22:56:56 +0800
Subject: [PATCH 1211/3374] Create
 1780-check-if-number-is-a-sum-of-powers-of-three.js

---
 1780-check-if-number-is-a-sum-of-powers-of-three.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1780-check-if-number-is-a-sum-of-powers-of-three.js

diff --git a/1780-check-if-number-is-a-sum-of-powers-of-three.js b/1780-check-if-number-is-a-sum-of-powers-of-three.js
new file mode 100644
index 00000000..72083886
--- /dev/null
+++ b/1780-check-if-number-is-a-sum-of-powers-of-three.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const checkPowersOfThree = function(n) {
+  const num = ~~(n / 3)
+  const rem = n % 3
+  if(num === 0 && rem === 1) return true
+  if(rem === 2) return false
+  return checkPowersOfThree(num)
+};

From ae6553a72ea7f483226ce4b40927603a71c8c969 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Mar 2021 19:31:58 +0800
Subject: [PATCH 1212/3374] Update 1793-maximum-score-of-a-good-subarray.js

---
 1793-maximum-score-of-a-good-subarray.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1793-maximum-score-of-a-good-subarray.js b/1793-maximum-score-of-a-good-subarray.js
index 233f0301..980891cc 100644
--- a/1793-maximum-score-of-a-good-subarray.js
+++ b/1793-maximum-score-of-a-good-subarray.js
@@ -23,3 +23,26 @@ const maximumScore = function(nums, k) {
 
   return ans;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumScore = function(nums, k) {
+  const n = nums.length, { max, min } = Math
+  let l = k, r = k, mi = nums[k]
+  let res = nums[k]
+  while(l > 0 || r < n - 1) {
+    if(l === 0) r++
+    else if(r === n - 1) l--
+    else if(nums[l - 1] < nums[r + 1]) r++
+    else l--
+    mi = min(mi, nums[l], nums[r])
+    res = max(res, mi * (r - l + 1))
+  }
+  
+  return res
+};

From f1a8a88c35e7f69301887dbaa51dc9b2f2782919 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Mar 2021 20:14:49 +0800
Subject: [PATCH 1213/3374] Update
 1685-sum-of-absolute-differences-in-a-sorted-array.js

---
 ...-absolute-differences-in-a-sorted-array.js | 28 ++++++++-----------
 1 file changed, 12 insertions(+), 16 deletions(-)

diff --git a/1685-sum-of-absolute-differences-in-a-sorted-array.js b/1685-sum-of-absolute-differences-in-a-sorted-array.js
index 13fba8d0..0092062e 100644
--- a/1685-sum-of-absolute-differences-in-a-sorted-array.js
+++ b/1685-sum-of-absolute-differences-in-a-sorted-array.js
@@ -2,20 +2,16 @@
  * @param {number[]} nums
  * @return {number[]}
  */
-var getSumAbsoluteDifferences = function(nums) {
-        let left = 0
-        let right = nums.length - 2
-        let begin = 0
-        for(let i = 1, len = nums.length; i < len; i++) {
-          begin += (nums[i] - nums[0])
-        }
-
-        const res = [begin]
-        for(let i = 1, len = nums.length; i < len; i++) {
-            res.push(res[i - 1] - (nums[i] - nums[i - 1]) * (right - left))
-            left += 1
-            right -= 1
-        }
-
-        return res    
+const getSumAbsoluteDifferences = function(nums) {
+  const res = [], n = nums.length
+  let first = 0
+  for(let i = 1; i < n; i++) {
+    first += nums[i] - nums[0]
+  }
+  res[0] = first
+  for(let i = 1; i < n; i++) {
+    res[i] = res[i - 1] + (nums[i] - nums[i - 1]) * i - (nums[i] - nums[i - 1]) * (n - i)
+  }
+  
+  return res
 };

From aeb0595b67407b7e3785f0430bdb3ebd5f330b22 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Mar 2021 21:40:55 +0800
Subject: [PATCH 1214/3374] Update 41-first-missing-positive.js

---
 41-first-missing-positive.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/41-first-missing-positive.js b/41-first-missing-positive.js
index 8b42d3cd..3bd7ef24 100644
--- a/41-first-missing-positive.js
+++ b/41-first-missing-positive.js
@@ -40,3 +40,31 @@ function swap(arr, i, j) {
   arr[i] = arr[j]
   arr[j] = tmp
 }
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const firstMissingPositive = function(nums) {
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    while(nums[i] < n && nums[nums[i] - 1] !== nums[i]) {
+      swap(nums, i, nums[i] - 1)
+    }
+  }
+  
+  for(let i = 0; i < n; i++) {
+    if(nums[i] !== i + 1) return i + 1
+  }
+  
+  return n + 1
+};
+
+function swap(arr, i, j) {
+  const tmp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = tmp
+}

From a5b2cee814fb7121fd335f30d67eeb67dcdab616 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Mar 2021 19:49:25 +0800
Subject: [PATCH 1215/3374] Create 1506-find-root-of-n-ary-tree.js

---
 1506-find-root-of-n-ary-tree.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1506-find-root-of-n-ary-tree.js

diff --git a/1506-find-root-of-n-ary-tree.js b/1506-find-root-of-n-ary-tree.js
new file mode 100644
index 00000000..36e8727c
--- /dev/null
+++ b/1506-find-root-of-n-ary-tree.js
@@ -0,0 +1,25 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node[]} tree
+ * @return {Node}
+ */
+const findRoot = function(tree) {
+  let sum = 0
+  for(let n of tree) {
+    sum += n.val
+    for(let c of n.children) {
+      sum -= c.val
+    }
+  }
+  for(let n of tree) {
+    if(n.val === sum) return n
+  }
+  return null
+};

From 5b157f4bcf38a90176c1174dbb2409976cc5b767 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Mar 2021 20:10:01 +0800
Subject: [PATCH 1216/3374] Update 1506-find-root-of-n-ary-tree.js

---
 1506-find-root-of-n-ary-tree.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1506-find-root-of-n-ary-tree.js b/1506-find-root-of-n-ary-tree.js
index 36e8727c..7f1316af 100644
--- a/1506-find-root-of-n-ary-tree.js
+++ b/1506-find-root-of-n-ary-tree.js
@@ -23,3 +23,31 @@ const findRoot = function(tree) {
   }
   return null
 };
+
+// another
+
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node[]} tree
+ * @return {Node}
+ */
+const findRoot = function(tree) {
+  let sum = 0
+  for(let n of tree) {
+    sum ^= n.val
+    for(let c of n.children) {
+      sum ^= c.val
+    }
+  }
+  for(let n of tree) {
+    if(n.val === sum) return n
+  }
+  return null
+};

From d9a1b598745e761449221fc64af3f681935180e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Mar 2021 20:30:35 +0800
Subject: [PATCH 1217/3374] Update
 1790-check-if-one-string-swap-can-make-strings-equal.js

---
 1790-check-if-one-string-swap-can-make-strings-equal.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1790-check-if-one-string-swap-can-make-strings-equal.js b/1790-check-if-one-string-swap-can-make-strings-equal.js
index 86960808..1612d9b9 100644
--- a/1790-check-if-one-string-swap-can-make-strings-equal.js
+++ b/1790-check-if-one-string-swap-can-make-strings-equal.js
@@ -14,6 +14,6 @@ const areAlmostEqual = function(s1, s2) {
   
   if(arr.length === 1) return false
   const [i1, i2] = arr
-  if(s1[i2] === s2[i1]) return true
+  if(s1[i2] === s2[i1] && s1[i1] === s2[i2]) return true
   return false
 };

From 855bbd42ea1932631a9481913db053c3ac11d24f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Mar 2021 11:07:32 +0800
Subject: [PATCH 1218/3374] Update 15-3sum.js

---
 15-3sum.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/15-3sum.js b/15-3sum.js
index 806f3272..c6f4a983 100755
--- a/15-3sum.js
+++ b/15-3sum.js
@@ -27,3 +27,32 @@ const threeSum = function (nums) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const threeSum = function(nums) {
+  const res = [], n = nums.length
+  nums.sort((a, b) => a - b)
+  for(let i = 0; i < n - 2; i++) {
+    let l = i + 1, r = n - 1, target = -nums[i]
+    if(i === 0 || (i > 0 && nums[i] !== nums[i - 1])) {
+      while(l < r) {
+        if(nums[l] + nums[r] === target) {
+          res.push([nums[i], nums[l], nums[r]])
+          while(l < n - 1 && nums[l] === nums[l + 1]) l++
+          while(r > 0 && nums[r] === nums[r - 1]) r--
+          r--
+          l++
+        } else if(nums[l] + nums[r] > target) {
+          r--
+        } else l++
+      }
+    }
+  }  
+
+  return res
+};

From 8786a46a106e5de6063a4f2a7a6edef78fedc915 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Mar 2021 19:55:27 +0800
Subject: [PATCH 1219/3374] Update
 1738-find-kth-largest-xor-coordinate-value.js

---
 1738-find-kth-largest-xor-coordinate-value.js | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)

diff --git a/1738-find-kth-largest-xor-coordinate-value.js b/1738-find-kth-largest-xor-coordinate-value.js
index 18455b2b..b593d9f7 100644
--- a/1738-find-kth-largest-xor-coordinate-value.js
+++ b/1738-find-kth-largest-xor-coordinate-value.js
@@ -58,3 +58,108 @@ const kthLargestValue = function(matrix, k) {
     return tmp[k - 1]
 };
 
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @param {number} k
+ * @return {number}
+ */
+const kthLargestValue = function(matrix, k) {
+  if(matrix == null || matrix[0] == null) return 0
+  const m = matrix.length, n = matrix[0].length
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  res[0][0] = matrix[0][0]
+  for(let i = 1; i < m; i++) {
+    res[i][0] = res[i - 1][0] ^ matrix[i][0]
+  }
+  for(let j = 1; j < n; j++) {
+    res[0][j] = res[0][j - 1] ^ matrix[0][j]
+  }
+  
+  for(let i = 1; i < m; i++) {
+    for(let j = 1; j < n; j++) {
+      res[i][j] = res[i][j - 1] ^ res[i - 1][j] ^ res[i - 1][j - 1] ^ matrix[i][j]
+    }
+  }
+  
+  const pq = new PriorityQueue((a, b) => a < b)
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      pq.push(res[i][j])
+      if(pq.size() > k) pq.pop()
+    }
+  }
+  
+  return pq.pop()
+  
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 4f5674d238589605985f1aa588f3598507d5f1cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Mar 2021 19:18:06 +0800
Subject: [PATCH 1220/3374] Create
 1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.js

---
 ...int-that-has-the-same-x-or-y-coordinate.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.js

diff --git a/1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.js b/1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.js
new file mode 100644
index 00000000..9a8c5230
--- /dev/null
+++ b/1779-find-nearest-point-that-has-the-same-x-or-y-coordinate.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number[][]} points
+ * @return {number}
+ */
+const nearestValidPoint = function(x, y, points) {
+  let idx = -1, dis = Infinity
+  const {min, max, abs} = Math
+  for(let i = 0; i < points.length; i++) {
+    const e = points[i]
+    const [tx, ty] = e
+    if(tx === x || ty === y) {
+      const tmp = abs(tx - x) + abs(ty - y)
+      if(tmp < dis) {
+        idx = i
+        dis = tmp
+      }
+    }
+  }
+  
+  return idx === -1 ? -1 : idx
+};

From cbec2f0e212224db6e2e715d87a84e44f29926a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Mar 2021 10:13:47 +0800
Subject: [PATCH 1221/3374] Update 1734-decode-xored-permutation.js

---
 1734-decode-xored-permutation.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1734-decode-xored-permutation.js b/1734-decode-xored-permutation.js
index dca2ef79..4b0ecdf9 100644
--- a/1734-decode-xored-permutation.js
+++ b/1734-decode-xored-permutation.js
@@ -16,3 +16,28 @@ const decode = function(encoded) {
   
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} encoded
+ * @return {number[]}
+ */
+const decode = function(A) {
+  let xor = 0
+  const len = A.length
+  const permLen = len + 1
+  for(let i = 1; i <= permLen; i++) {
+    xor ^= i
+  }
+  // except first
+  for(let i = 1; i < len; i += 2) xor ^= A[i]
+  const first = xor
+  const res = [xor]
+  let pre = xor
+  for(let i = 1; i < permLen; i++) {
+    res[i] = A[i - 1] ^ pre
+    pre = res[i]
+  }
+  return res;    
+};

From 1da2b886af572ae678f87fd8d0fc945a2d84a252 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Mar 2021 15:19:13 +0800
Subject: [PATCH 1222/3374] Create 1801-number-of-orders-in-the-backlog.js

---
 1801-number-of-orders-in-the-backlog.js | 130 ++++++++++++++++++++++++
 1 file changed, 130 insertions(+)
 create mode 100644 1801-number-of-orders-in-the-backlog.js

diff --git a/1801-number-of-orders-in-the-backlog.js b/1801-number-of-orders-in-the-backlog.js
new file mode 100644
index 00000000..c5bcd0af
--- /dev/null
+++ b/1801-number-of-orders-in-the-backlog.js
@@ -0,0 +1,130 @@
+/**
+ * @param {number[][]} orders
+ * @return {number}
+ */
+const getNumberOfBacklogOrders = function (orders) {
+  const h0 = new PriorityQueue((a, b) => a[0] > b[0])
+  const h1 = new PriorityQueue((a, b) => a[0] > b[0])
+  const P = 10 ** 9 + 7
+  const { min } = Math
+
+  while (!h0.isEmpty()) h0.pop()
+  while (!h1.isEmpty()) h1.pop()
+  let i,
+    j,
+    i1,
+    j1,
+    ans = 0
+  for (let c of orders) {
+    i = c[0]
+    j = c[1]
+    if (c[2]) {
+      while (!h0.isEmpty() && h0.peek()[0] >= i) {
+        i1 = h0.peek()[0]
+        j1 = h0.peek()[1]
+        h0.pop()
+        if (j > j1) j -= j1
+        else {
+          j1 -= j
+          j = 0
+          if (j1) h0.push([i1, j1])
+          break
+        }
+      }
+      if (j) h1.push([-i, j])
+    } else {
+      while (!h1.isEmpty() && -h1.peek()[0] <= i) {
+        i1 = h1.peek()[0]
+        j1 = h1.peek()[1]
+        h1.pop()
+        if (j > j1) j -= j1
+        else {
+          j1 -= j
+          j = 0
+          if (j1) h1.push([i1, j1])
+          break
+        }
+      }
+      if (j) h0.push([i, j])
+    }
+  }
+  while (!h0.isEmpty()) {
+    ans += h0.peek()[1]
+    h0.pop()
+    if (ans >= P) ans -= P
+  }
+  while (!h1.isEmpty()) {
+    ans += h1.peek()[1]
+    h1.pop()
+    if (ans >= P) ans -= P
+  }
+  return ans
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 482b08807dc3f4725caeeaf31aafd4d58e9017f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Mar 2021 15:20:12 +0800
Subject: [PATCH 1223/3374] Create 1800-maximum-ascending-subarray-sum.js

---
 1800-maximum-ascending-subarray-sum.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1800-maximum-ascending-subarray-sum.js

diff --git a/1800-maximum-ascending-subarray-sum.js b/1800-maximum-ascending-subarray-sum.js
new file mode 100644
index 00000000..b7a91bd4
--- /dev/null
+++ b/1800-maximum-ascending-subarray-sum.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxAscendingSum = function(nums) {
+  let res = -Infinity
+  
+  const n = nums.length
+  let cur = 0
+  for(let i = 0; i < n; i++) {
+    if(i === 0) cur = nums[i]
+    if(i > 0) {
+      if(nums[i] > nums[i - 1]) {
+        cur += nums[i]
+        res = Math.max(res, cur)
+      } else {
+        res = Math.max(res, cur)
+        cur = nums[i]
+      } 
+    }
+  }
+  res = Math.max(res, cur)  
+  return res
+};

From 79c3d6b764e6c85d1ffe4047a2bd5e3ea7e6da15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Mar 2021 15:22:43 +0800
Subject: [PATCH 1224/3374] Create
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
new file mode 100644
index 00000000..1dffb51a
--- /dev/null
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @param {number} index
+ * @param {number} maxSum
+ * @return {number}
+ */
+const maxValue = function(n, index, maxSum) {
+		let ret=0;
+		let i;
+  const {max} = Math
+		for(i=30;i>=0;i--) {
+			let tmp=ret+(1<<i);
+			let L=max(0,tmp-index);
+			let sum=(L+tmp)*(tmp-L+1)/2;
+			let R=max(0,tmp-(n-1-index));
+			sum+=(R+tmp)*(tmp-R+1)/2-tmp;
+
+			if(sum<=maxSum-n) ret+=1<<i;
+		}
+		return ret+1;
+};

From 96525ecedf809adb93432b5369a245183c5670a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Mar 2021 17:45:58 +0800
Subject: [PATCH 1225/3374] Create 1803-count-pairs-with-xor-in-a-range.js

---
 1803-count-pairs-with-xor-in-a-range.js | 46 +++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1803-count-pairs-with-xor-in-a-range.js

diff --git a/1803-count-pairs-with-xor-in-a-range.js b/1803-count-pairs-with-xor-in-a-range.js
new file mode 100644
index 00000000..c9529f86
--- /dev/null
+++ b/1803-count-pairs-with-xor-in-a-range.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const countPairs = function (nums, low, high) {
+  const trie = new Trie()
+
+  let ans = 0
+  for (let x of nums) {
+    ans += trie.count(x, high + 1) - trie.count(x, low)
+    trie.insert(x)
+  }
+  return ans
+}
+
+class Trie {
+  constructor() {
+    this.root = {}
+  }
+  insert(val) {
+    let node = this.root
+    for (let i = 14; i >= 0; i--) {
+      let bit = (val >> i) & 1
+      if (!(bit in node)) node[bit] = { cnt: 1 }
+      else node[bit]['cnt'] += 1
+      node = node[bit]
+    }
+  }
+  count(val, high) {
+    let ans = 0
+    let node = this.root
+    for (let i = 14; i >= 0; i--) {
+      if (!node) break
+      let bit = (val >> i) & 1
+      let cmp = (high >> i) & 1
+      if (cmp) {
+        if (node[bit]) ans += node[bit]['cnt']
+        node = node[1 ^ bit]
+      } else node = node[bit]
+    }
+
+    return ans
+  }
+}

From a5397cd249f4d54164ad982ee4fcced8757f22e5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Mar 2021 21:06:27 +0800
Subject: [PATCH 1226/3374] Update
 421-maximum-xor-of-two-numbers-in-an-array.js

---
 421-maximum-xor-of-two-numbers-in-an-array.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/421-maximum-xor-of-two-numbers-in-an-array.js b/421-maximum-xor-of-two-numbers-in-an-array.js
index 4ec73846..ed3ff2a3 100644
--- a/421-maximum-xor-of-two-numbers-in-an-array.js
+++ b/421-maximum-xor-of-two-numbers-in-an-array.js
@@ -74,3 +74,48 @@ const findMaximumXOR = function(nums) {
   }
   return maxResult
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaximumXOR = function (nums) {
+  if (nums == null || nums.length == 0) {
+    return 0
+  }
+  const root = new Trie()
+  for (let num of nums) {
+    let curNode = root
+    for (let i = 31; i >= 0; i--) {
+      let curBit = (num >>> i) & 1
+      if (curNode.children[curBit] == null) {
+        curNode.children[curBit] = new Trie()
+      }
+      curNode = curNode.children[curBit]
+    }
+  }
+  let max = Number.MIN_VALUE
+  for (let num of nums) {
+    let curNode = root
+    let curSum = 0
+    for (let i = 31; i >= 0; i--) {
+      let curBit = (num >>> i) & 1
+      if (curNode.children[curBit ^ 1] != null) {
+        curSum += 1 << i
+        curNode = curNode.children[curBit ^ 1]
+      } else {
+        curNode = curNode.children[curBit]
+      }
+    }
+    max = Math.max(curSum, max)
+  }
+  return max
+}
+
+class Trie {
+  constructor() {
+    this.children = {}
+  }
+}

From 207d6e0077c7483e7cc8a4afd1f59d29c54bdf52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Mar 2021 22:23:12 +0800
Subject: [PATCH 1227/3374] Update 1803-count-pairs-with-xor-in-a-range.js

---
 1803-count-pairs-with-xor-in-a-range.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/1803-count-pairs-with-xor-in-a-range.js b/1803-count-pairs-with-xor-in-a-range.js
index c9529f86..1cd9f17c 100644
--- a/1803-count-pairs-with-xor-in-a-range.js
+++ b/1803-count-pairs-with-xor-in-a-range.js
@@ -33,8 +33,8 @@ class Trie {
     let node = this.root
     for (let i = 14; i >= 0; i--) {
       if (!node) break
-      let bit = (val >> i) & 1
-      let cmp = (high >> i) & 1
+      const bit = (val >> i) & 1
+      const cmp = (high >> i) & 1
       if (cmp) {
         if (node[bit]) ans += node[bit]['cnt']
         node = node[1 ^ bit]

From 4072a2da09e0ef53a04e25680dd801131be9df77 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Mar 2021 13:27:37 +0800
Subject: [PATCH 1228/3374] Update 42-trapping-rain-water.js

---
 42-trapping-rain-water.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/42-trapping-rain-water.js b/42-trapping-rain-water.js
index ef63143f..4b2a964a 100644
--- a/42-trapping-rain-water.js
+++ b/42-trapping-rain-water.js
@@ -68,3 +68,28 @@ const trap = function(height) {
   return res
 };
 
+// another
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+const trap = function(height) {
+    const n = height.length
+    if(n === 0) return 0
+    let res = 0
+    let l = 0, r = n - 1, leftMax = height[l], rightMax = height[r]
+    while(l < r) {
+      if(height[l] <= height[r]) {
+        l++
+        leftMax = Math.max(leftMax, height[l])
+        res += (leftMax - height[l]) 
+      } else {
+        r--
+        rightMax = Math.max(rightMax, height[r])
+        res += rightMax - height[r]
+      }
+    }
+
+    return res
+};

From 81c8ca53161c1d1e1ead8c06cc78ce48c6e2db32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Mar 2021 16:19:12 +0800
Subject: [PATCH 1229/3374] Update 152-maximum-product-subarray.js

---
 152-maximum-product-subarray.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/152-maximum-product-subarray.js b/152-maximum-product-subarray.js
index 75b21c55..fe71634f 100644
--- a/152-maximum-product-subarray.js
+++ b/152-maximum-product-subarray.js
@@ -64,3 +64,29 @@ const maxProduct = function(nums) {
   }
   return res
 };
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxProduct = function (nums) {
+  if(nums == null || nums.length === 0) return 0
+  const n = nums.length
+  let res = nums[0]
+  for(let i = 1, min = res, max = res; i < n; i++) {
+    if(nums[i] < 0) {
+      let tmax = max, tmin = min
+      min = Math.min(nums[i], tmax * nums[i])
+      max = Math.max(nums[i], tmin * nums[i])
+    } else {
+      min = Math.min(nums[i], min * nums[i])
+      max = Math.max(nums[i], max * nums[i])
+    }
+    res = Math.max(res, max)
+  }
+  
+  return res
+}

From 75a52f97b1af5ac78d822a5b2009e5ea86788eae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Mar 2021 14:56:28 +0800
Subject: [PATCH 1230/3374] Update 55-jump-game.js

---
 55-jump-game.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/55-jump-game.js b/55-jump-game.js
index baaae368..4bf6ebf6 100644
--- a/55-jump-game.js
+++ b/55-jump-game.js
@@ -26,5 +26,4 @@ const canJump = function(nums) {
     max = Math.max(max, i + nums[i])
     if(max >= n - 1) return true
   }
-  return max >= n - 1
 };

From 3a7408f40ac7582180541833b606b2bb09a95138 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Mar 2021 14:21:57 +0800
Subject: [PATCH 1231/3374] Create
 1798-maximum-number-of-consecutive-values-you-can-make.js

---
 ...mum-number-of-consecutive-values-you-can-make.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1798-maximum-number-of-consecutive-values-you-can-make.js

diff --git a/1798-maximum-number-of-consecutive-values-you-can-make.js b/1798-maximum-number-of-consecutive-values-you-can-make.js
new file mode 100644
index 00000000..3f896373
--- /dev/null
+++ b/1798-maximum-number-of-consecutive-values-you-can-make.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} coins
+ * @return {number}
+ */
+const getMaximumConsecutive = function(coins) {
+  coins.sort((a, b) => a - b);
+  let res = 1;
+  for (let a of coins) {
+    if (a > res) break;
+    res += a;
+  }
+  return res; 
+};

From daf48642c5c9729929e8cdd1e9bcbc92b7a5f1f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Mar 2021 21:59:20 +0800
Subject: [PATCH 1232/3374] Create 1799-maximize-score-after-n-operations.js

---
 1799-maximize-score-after-n-operations.js | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1799-maximize-score-after-n-operations.js

diff --git a/1799-maximize-score-after-n-operations.js b/1799-maximize-score-after-n-operations.js
new file mode 100644
index 00000000..28e97a5c
--- /dev/null
+++ b/1799-maximize-score-after-n-operations.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxScore = function (nums) {
+  const gcd = (a, b) => (b === 0 ? a : gcd(b, a % b))
+  const n = nums.length / 2
+  const memo = {}
+  const traverse = (op, mask) => {
+    if (op > n) {
+      return 0
+    }
+    const idx = op * 100000 + mask
+    if (memo[idx] === undefined) {
+      let res = 0
+      for (let i = 0; i < 2 * n - 1; i++) {
+        if (mask & (1 << i)) continue
+        for (let j = i + 1; j < 2 * n; j++) {
+          if (mask & (1 << j)) continue
+          const newMask = mask | (1 << i) | (1 << j)
+          res = Math.max(
+            res,
+            traverse(op + 1, newMask) + op * gcd(nums[i], nums[j])
+          )
+        }
+      }
+      memo[idx] = res
+    }
+    return memo[idx]
+  }
+  const res = traverse(1, 0)
+  return res
+}

From bfd3422e52c86ae4b162577b812ce493a7b56ae7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 10:27:59 +0800
Subject: [PATCH 1233/3374] Update 54-spiral-matrix.js

---
 54-spiral-matrix.js | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/54-spiral-matrix.js b/54-spiral-matrix.js
index 2c9eebcf..fbbb5aff 100644
--- a/54-spiral-matrix.js
+++ b/54-spiral-matrix.js
@@ -39,3 +39,48 @@ const spiralOrder = function(matrix) {
     }
     return res
 };
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+const spiralOrder = function(matrix) {
+  const res = [], m = matrix.length, n = matrix[0].length
+  const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]]
+  let di = 0, i = 0, j = 0, nx = 0, ny = 1
+  while(true) {
+    res.push(matrix[i][j])
+    matrix[i][j] = Infinity
+    if(chk(i, j)) {
+      if(di === 0 && (j + 1 >= n || matrix[i][j + 1] === Infinity)) {
+        i++
+        di = 1
+      } else if(di === 1 && (i + 1 >= m || matrix[i + 1][j] === Infinity)) {
+        j--
+        di = 2
+      } else if(di === 2 && (j - 1 < 0 || matrix[i][j - 1] === Infinity)) {
+        i--
+        di = 3
+      } else if(di === 3 && (i - 1 < 0 || matrix[i - 1][j] === Infinity)) {
+        j++
+        di = 0
+      } else {
+        i += dirs[di][0]
+        j += dirs[di][1]
+      }
+    } else break
+  }
+  return res
+
+  function chk(i, j) {
+    for(let dir of dirs) {
+      const nx = i + dir[0], ny = j + dir[1]
+      if(nx >= 0 && nx < matrix.length && ny >= 0 && ny < matrix[0].length && matrix[nx][ny] !== Infinity) return true
+    }
+    return false
+  } 
+};
+  
+

From 6fc04d5562c415c577c7278a3753e03a429b46eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 20:27:46 +0800
Subject: [PATCH 1234/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 27 +++++++++----------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index 1dffb51a..54bbb8c4 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -4,18 +4,17 @@
  * @param {number} maxSum
  * @return {number}
  */
-const maxValue = function(n, index, maxSum) {
-		let ret=0;
-		let i;
-  const {max} = Math
-		for(i=30;i>=0;i--) {
-			let tmp=ret+(1<<i);
-			let L=max(0,tmp-index);
-			let sum=(L+tmp)*(tmp-L+1)/2;
-			let R=max(0,tmp-(n-1-index));
-			sum+=(R+tmp)*(tmp-R+1)/2-tmp;
+const maxValue = function (n, index, maxSum) {
+  let ret = 0
+  const { max } = Math
+  for (let i = 30; i >= 0; i--) {
+    const tmp = ret + (1 << i)
+    const L = max(0, tmp - index)
+    let sum = ((L + tmp) * (tmp - L + 1)) / 2
+    const R = max(0, tmp - (n - 1 - index))
+    sum += ((R + tmp) * (tmp - R + 1)) / 2 - tmp
 
-			if(sum<=maxSum-n) ret+=1<<i;
-		}
-		return ret+1;
-};
+    if (sum <= maxSum - n) ret += 1 << i
+  }
+  return ret + 1
+}

From 48bb59c39fef21d0a60537d73227b224fe280d76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 20:28:33 +0800
Subject: [PATCH 1235/3374] Create
 1805-number-of-different-integers-in-a-string.js

---
 ...umber-of-different-integers-in-a-string.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1805-number-of-different-integers-in-a-string.js

diff --git a/1805-number-of-different-integers-in-a-string.js b/1805-number-of-different-integers-in-a-string.js
new file mode 100644
index 00000000..ef4477eb
--- /dev/null
+++ b/1805-number-of-different-integers-in-a-string.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const numDifferentIntegers = function(word) {
+  let cur = ''
+  const n = word.length
+  const set = new Set()
+  for(let i = 0; i < n; i++ ) {
+    if(word[i] >= '0' && word[i] <= '9') cur += word[i]
+    else {
+      if(cur) set.add(+cur)
+      cur = ''
+    }
+    if(i === n - 1 && cur) set.add(+cur)
+  }
+
+  return set.size
+};

From a67d808c8eb9afb0b62bd6cf5a09dc22f1f7311c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 20:29:04 +0800
Subject: [PATCH 1236/3374] Create
 1806-minimum-number-of-operations-to-reinitialize-a-permutation.js

---
 ...perations-to-reinitialize-a-permutation.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1806-minimum-number-of-operations-to-reinitialize-a-permutation.js

diff --git a/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
new file mode 100644
index 00000000..72103d55
--- /dev/null
+++ b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const reinitializePermutation = function(n) {
+  let perm = []
+  for(let i = 0; i < n; i++) {
+    perm[i] = i
+  }
+  let clone = perm.slice()
+  let res = 0
+  
+  while(true) {
+    res++
+    let arr = clone.slice()
+    for(let i = 0; i < clone.length; i++) {
+      if(i % 2 === 0) arr[i] = clone[i / 2]
+      else arr[i] = clone[n / 2 + (i - 1) / 2]
+    }
+    
+    if(chk(perm, arr)) break
+    clone = arr
+  }
+  
+  
+  return res
+  
+  function chk(a1, a2) {
+    for(let i = 0, len = a1.length; i < len; i++) {
+      if(a1[i] !== a2[i]) return false
+    }
+    return true
+  }
+};

From 995239787eef5bfc560bed4f286239ba4e2a7220 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 20:29:35 +0800
Subject: [PATCH 1237/3374] Create
 1807-evaluate-the-bracket-pairs-of-a-string.js

---
 ...-evaluate-the-bracket-pairs-of-a-string.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1807-evaluate-the-bracket-pairs-of-a-string.js

diff --git a/1807-evaluate-the-bracket-pairs-of-a-string.js b/1807-evaluate-the-bracket-pairs-of-a-string.js
new file mode 100644
index 00000000..8d14fdfc
--- /dev/null
+++ b/1807-evaluate-the-bracket-pairs-of-a-string.js
@@ -0,0 +1,41 @@
+/**
+ * @param {string} s
+ * @param {string[][]} knowledge
+ * @return {string}
+ */
+const evaluate = function(s, knowledge) {
+  const map = {}
+  for(let e of knowledge) {
+    const [k, v] = e
+    map[k] = v
+  }
+  const n = s.length
+  let start = -1, end = 0
+  let cur = ''
+  const arr = []
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '(') {
+      start = i
+      if(cur) {
+        arr.push(cur)
+        cur = ''
+      }
+      continue
+    }
+    else if(start !== -1 && s[i] !== ')') {
+      cur += s[i]
+    }
+    else if(s[i] === ')') {
+      if(cur in map) arr.push(map[cur])
+      else arr.push('?')
+      start = -1
+      cur = ''
+    } else {
+      cur += s[i]
+    }
+    if(i === n - 1 && cur) arr.push(cur)
+  }
+  
+  return arr.join('')
+  
+};

From 221190247eea0eceb447bb59a9585b9ea43527b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Mar 2021 20:31:43 +0800
Subject: [PATCH 1238/3374] Create 1808-maximize-number-of-nice-divisors.js

---
 1808-maximize-number-of-nice-divisors.js | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1808-maximize-number-of-nice-divisors.js

diff --git a/1808-maximize-number-of-nice-divisors.js b/1808-maximize-number-of-nice-divisors.js
new file mode 100644
index 00000000..a5674ff3
--- /dev/null
+++ b/1808-maximize-number-of-nice-divisors.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number} primeFactors
+ * @return {number}
+ */
+const MOD = BigInt(1e9 + 7)
+const maxNiceDivisors = (pf) => {
+  if (pf == 1) return 1
+  let bpf = BigInt(pf)
+  let res
+  if (pf % 3 == 0) {
+    res = powmod(3n, bpf / 3n, MOD)
+  } else if (pf % 3 == 1) {
+    res = (powmod(3n, bpf / 3n - 1n, MOD) * 4n) % MOD
+  } else {
+    res = (powmod(3n, bpf / 3n, MOD) * 2n) % MOD
+  }
+  return Number(res)
+}
+
+const powmod = (a, b, mod) => {
+  let r = 1n
+  while (b > 0n) {
+    if (b % 2n == 1) r = (r * a) % mod
+    b >>= 1n
+    a = (a * a) % mod
+  }
+  return r
+}

From c66d9e0302ffb02a8d607956b5d3771230dc8c41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Mar 2021 14:18:36 +0800
Subject: [PATCH 1239/3374] Update
 1806-minimum-number-of-operations-to-reinitialize-a-permutation.js

---
 ...of-operations-to-reinitialize-a-permutation.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
index 72103d55..cfc56ae4 100644
--- a/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
+++ b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
@@ -32,3 +32,18 @@ const reinitializePermutation = function(n) {
     return true
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const reinitializePermutation = function(n) {
+  let res = 0, i = 1;
+  while (res === 0 || i > 1) {
+    i = i * 2 % (n - 1);
+    res++;
+  }
+  return res;
+};

From f8dc14c0eec741af32196dae248598031a58825e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Mar 2021 15:06:46 +0800
Subject: [PATCH 1240/3374] Update
 1806-minimum-number-of-operations-to-reinitialize-a-permutation.js

---
 ...perations-to-reinitialize-a-permutation.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
index cfc56ae4..3176daf4 100644
--- a/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
+++ b/1806-minimum-number-of-operations-to-reinitialize-a-permutation.js
@@ -47,3 +47,22 @@ const reinitializePermutation = function(n) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const reinitializePermutation = function(n) {
+	if (n === 2) return 1
+	const mod = n - 1
+	let curr_power = 2
+	let cnt = 1
+	// Find multiplicative order modulo n-1
+	while (curr_power !== 1) {
+		curr_power = (2 * curr_power) % mod
+		cnt++
+  }
+	return cnt
+};

From 05a559ad65396138719e9795cf063b8fb92193f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 10:10:34 +0800
Subject: [PATCH 1241/3374] Update 343-integer-break.js

---
 343-integer-break.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/343-integer-break.js b/343-integer-break.js
index 65a728dc..6ea757d8 100755
--- a/343-integer-break.js
+++ b/343-integer-break.js
@@ -32,3 +32,21 @@ const integerBreak = function(n) {
   }
   return maxArr[n];
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const integerBreak = function(n) {
+  if(n === 2) return 1
+  if(n === 3) return 2
+  let num = ~~(n / 3)
+  let rem = n % 3
+  if(rem === 1) {
+    rem += 3
+    num--
+  }
+  return rem === 0 ? Math.pow(3, num) : Math.pow(3, num) * rem
+};

From c037c113f9b965d69069291f15388154db01f374 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 10:24:33 +0800
Subject: [PATCH 1242/3374] Update 343-integer-break.js

---
 343-integer-break.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/343-integer-break.js b/343-integer-break.js
index 6ea757d8..66489f14 100755
--- a/343-integer-break.js
+++ b/343-integer-break.js
@@ -50,3 +50,14 @@ const integerBreak = function(n) {
   }
   return rem === 0 ? Math.pow(3, num) : Math.pow(3, num) * rem
 };
+
+/**
+
+If an optimal product contains a factor f >= 4, 
+then you can replace it with factors 2 and f-2 without losing optimality,
+as 2*(f-2) = 2f-4 >= f. So you never need a factor greater than or equal to 4,
+meaning you only need factors 1, 2 and 3 (and 1 is of course wasteful and you'd only use it for n=2 and n=3, where it's needed).
+
+For the rest I agree, 3*3 is simply better than 2*2*2, so you'd never use 2 more than twice.
+
+*/

From be44778d1bab37d6ec1429fc1099c77b20c97053 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 12:05:31 +0800
Subject: [PATCH 1243/3374] Update 343-integer-break.js

---
 343-integer-break.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/343-integer-break.js b/343-integer-break.js
index 66489f14..22446b08 100755
--- a/343-integer-break.js
+++ b/343-integer-break.js
@@ -1,3 +1,20 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const integerBreak = function(n) {
+  const dp = Array(n + 1).fill(0)
+  dp[2] = 1
+  for(let i = 3; i <= n; i++) {
+    for(let j = 1; j < i; j++) {
+      dp[i] = Math.max(dp[i], j * Math.max(i - j, dp[i - j]))
+    }
+  }
+  return dp[n]
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 1755a3c80f22965f4ae839e52e2961aa75821ec7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 13:39:51 +0800
Subject: [PATCH 1244/3374] Update 191-number-of-1-bits.js

---
 191-number-of-1-bits.js | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/191-number-of-1-bits.js b/191-number-of-1-bits.js
index a20625e2..617f8173 100644
--- a/191-number-of-1-bits.js
+++ b/191-number-of-1-bits.js
@@ -3,12 +3,10 @@
  * @return {number}
  */
 const hammingWeight = function(n) {
-    let str = (n >>> 0).toString(2)
-    let count = 0
-    for(let i = 0; i < str.length; i++) {
-        if(str.charAt(i) === '1') {
-            count += 1
-        }
-    }
-    return count
+  const str = (n >>> 0).toString(2)
+  let res = 0
+  for(let c of str) {
+    if(c === '1') res++
+  }
+  return res
 };

From cae80b993fbf3e83aa39f9fa67839cf3182b1685 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 13:44:44 +0800
Subject: [PATCH 1245/3374] Update 191-number-of-1-bits.js

---
 191-number-of-1-bits.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/191-number-of-1-bits.js b/191-number-of-1-bits.js
index 617f8173..8395aae6 100644
--- a/191-number-of-1-bits.js
+++ b/191-number-of-1-bits.js
@@ -1,3 +1,18 @@
+/**
+ * @param {number} n - a positive integer
+ * @return {number}
+ */
+const hammingWeight = function(n) {
+  let res = 0
+  while(n > 0) {
+    if(n & 1) res++
+    n = n >>> 1
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number} n - a positive integer
  * @return {number}

From d4cae51f1f0ed6f9a62c992b4567d3840c4b021b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 14:20:41 +0800
Subject: [PATCH 1246/3374] Update 148-sort-list.js

---
 148-sort-list.js | 72 +++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 37 deletions(-)

diff --git a/148-sort-list.js b/148-sort-list.js
index 19404403..dbfacf1e 100644
--- a/148-sort-list.js
+++ b/148-sort-list.js
@@ -48,53 +48,51 @@ function partition(head, tail) {
 
 /**
  * Definition for singly-linked list.
- * function ListNode(val) {
- *     this.val = val;
- *     this.next = null;
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
  * }
  */
 /**
  * @param {ListNode} head
  * @return {ListNode}
  */
-
-const sortList = function(head) {
-    if (!head || !head.next) return head;
-    let fast = head;
-    let slow = head;
-    let pre = null;
-    while (fast && fast.next) {
-        pre = slow;
-        fast = fast.next.next;
-        slow = slow.next;
-    }
-    pre.next = null;
-    const left = sortList(head);
-    const right = sortList(slow);
-    return merge(left, right);
+function sortList(head) {
+  if(head == null || head.next == null) return head
+  let slow = head, fast = head, pre = null
+  while(fast && fast.next) {
+    pre = slow
+    slow = slow.next
+    fast = fast.next.next
+  }
+  pre.next = null
+  const left = sortList(head)
+  const right = sortList(slow)
+  return merge(left, right)
 }
 
-
 function merge(left, right) {
-    const dummy = new ListNode(0);
-    let list = dummy
-    while (left && right) {
-        if (left.val < right.val) {
-            list.next = left;
-            left = left.next;
-        } else {
-            list.next = right;
-            right = right.next;
-        }
-        list = list.next;
+  const dummy = new ListNode()
+  let cur = dummy
+  while(left && right) {
+    if (left.val <= right.val) {
+      cur.next = left
+      left = left.next
+    } else {
+      cur.next = right
+      right = right.next
     }
-    if (left) {
-        list.next = left;
-    }
-    if (right) {
-        list.next = right;
-    }
-    return dummy.next;
+    cur = cur.next
+  }
+  if(left) {
+    cur.next = left
+  }
+
+  if(right) {
+    cur.next = right
+  }
+
+  return dummy.next
 }
 
 

From 795e674c86e6994e06c3a0ddd5eccc9555aeb2fa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 14:43:13 +0800
Subject: [PATCH 1247/3374] Update 146-lru-cache.js

---
 146-lru-cache.js | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/146-lru-cache.js b/146-lru-cache.js
index 90bb19f1..d9ef0dc7 100755
--- a/146-lru-cache.js
+++ b/146-lru-cache.js
@@ -88,7 +88,7 @@ LRUCache.prototype.put = function(key, value) {
  */
 const LRUCache = function(capacity) {
   this.m = new Map()
-  this.l = capacity
+  this.limit = capacity
 };
 
 /** 
@@ -111,16 +111,14 @@ LRUCache.prototype.get = function(key) {
 LRUCache.prototype.put = function(key, value) {
   if(this.m.has(key)) {
     this.m.delete(key)
-    this.m.set(key, value)
   } else {
-    if(this.m.size >= this.l) {
-      const k = this.m.keys().next().value
-      this.m.delete(k)
+    if(this.m.size >= this.limit) {
+      const first = this.m.keys().next().value
+      this.m.delete(first)
     }
-    this.m.set(key, value)
   }
+  this.m.set(key, value)
 };
-
 /** 
  * Your LRUCache object will be instantiated and called as such:
  * var obj = new LRUCache(capacity)

From 653920c3a2a1033580f4ff9be56724b49fd93290 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 14:57:46 +0800
Subject: [PATCH 1248/3374] Update 18-4sum.js

---
 18-4sum.js | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/18-4sum.js b/18-4sum.js
index a006b9e1..069b349b 100644
--- a/18-4sum.js
+++ b/18-4sum.js
@@ -1,3 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[][]}
+ */
+const fourSum = function (nums, target) {
+  nums.sort((a, b) => a - b)
+  const results = []
+  kSum(nums, target, 4, 0, [], results)
+  return results
+}
+
+function kSum(nums, target, k, i, acc, results) {
+  if (nums[i] * k > target || nums[nums.length - 1] * k < target) return
+  if (k > 2) {
+    for (let j = i; j <= nums.length - k; j++) {
+      if (j == i || nums[j] > nums[j - 1])
+        kSum(nums, target - nums[j], k - 1, j + 1, [...acc, nums[j]], results)
+    }
+  } else {
+    twoSum(nums, target, i, acc, results)
+  }
+}
+
+function twoSum(nums, target, i, acc, results) {
+  let lo = i
+  let hi = nums.length - 1
+  while (lo < hi) {
+    const sum = nums[lo] + nums[hi]
+    if (sum == target) {
+      results.push([...acc, nums[lo], nums[hi]])
+      while (nums[lo] == nums[lo + 1]) lo++
+      while (nums[hi] == nums[hi - 1]) hi--
+      lo++
+      hi--
+    } else if (sum < target) {
+      lo++
+    } else {
+      hi--
+    }
+  }
+}
+
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} target

From 4e78b3dfe2c9a77323edd567768da884ebe109e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 17:02:46 +0800
Subject: [PATCH 1249/3374] Update 56-merge-intervals.js

---
 56-merge-intervals.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/56-merge-intervals.js b/56-merge-intervals.js
index 3be10e04..89a5fb3e 100644
--- a/56-merge-intervals.js
+++ b/56-merge-intervals.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+const merge = function(intervals) {
+  if(intervals == null || intervals.length === 0) return []
+  intervals.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  const res = [intervals[0]]
+  for(let i = 1, n = intervals.length; i < n; i++) {
+    const last = res[res.length - 1]
+    const lastEnd = last[1]
+    const [s, e] = intervals[i]
+    if(s > lastEnd) {
+      res.push(intervals[i])
+    } else {
+      last[1] = Math.max(last[1], e)
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * Definition for an interval.
  * function Interval(start, end) {

From 2ee578c45fb6e2efa8c3770381988839c8d1e1bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 17:49:32 +0800
Subject: [PATCH 1250/3374] Update 1041-robot-bounded-in-circle.js

---
 1041-robot-bounded-in-circle.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1041-robot-bounded-in-circle.js b/1041-robot-bounded-in-circle.js
index e268c8c4..59b27fb2 100644
--- a/1041-robot-bounded-in-circle.js
+++ b/1041-robot-bounded-in-circle.js
@@ -12,3 +12,25 @@ const isRobotBounded = function(instructions) {
     }
   return x == 0 && y == 0 || i > 0;
 };
+
+// another
+
+/**
+ * @param {string} instructions
+ * @return {boolean}
+ */
+const isRobotBounded = function(instructions) {
+  let x = 0, y = 0, i = 0
+  const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]] // U, R, D, L
+  for(let e of instructions) {
+    if(e === 'R') {
+      i = (i + 1) % 4
+    } else if(e === 'L') {
+      i = (i + 3) % 4
+    } else {
+      x += dirs[i][0]
+      y += dirs[i][1]
+    }
+  }
+  return x === 0 && y === 0 || i > 0
+};

From ffcf7c2ec408454d2dfd4c8bff33f4f185818462 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Mar 2021 20:59:32 +0800
Subject: [PATCH 1251/3374] Update 50-powx-n.js

---
 50-powx-n.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/50-powx-n.js b/50-powx-n.js
index b985b443..36c6619e 100644
--- a/50-powx-n.js
+++ b/50-powx-n.js
@@ -17,6 +17,23 @@ const myPow = function(x, n) {
 
 // another
 
+/**
+ * @param {number} x
+ * @param {number} n
+ * @return {number}
+ */
+const myPow = function(x, n) {
+  if(n === 0) return 1
+  if(n === 1) return x
+  if(n < 0) {
+    x = 1 / x
+    n = -n
+  }
+  return n % 2 === 1 ? myPow(x, ~~(n / 2)) ** 2 * x : myPow(x, ~~(n / 2)) ** 2
+};
+
+// another
+
 /**
  * @param {number} x
  * @param {number} n

From e2a8908702156fc913aa32da22221daa01c00f47 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Mar 2021 10:53:21 +0800
Subject: [PATCH 1252/3374] Update 68-text-justification.js

---
 68-text-justification.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/68-text-justification.js b/68-text-justification.js
index a629c398..3f26e4a1 100755
--- a/68-text-justification.js
+++ b/68-text-justification.js
@@ -1,3 +1,40 @@
+/**
+ * @param {string[]} words
+ * @param {number} maxWidth
+ * @return {string[]}
+ */
+const fullJustify = function(words, maxWidth) {
+  const res = []
+  let curRow = []
+  let numOfChars = 0
+  
+  for (let w of words) {
+    if (numOfChars + w.length + curRow.length > maxWidth) {
+      for(let i = 0; i < maxWidth - numOfChars; i++) {
+        if(curRow.length === 1) {
+          curRow[0] += ' '
+        } else {
+          curRow[i % (curRow.length - 1)] += ' '
+        }
+      }
+      res.push(curRow.join(''))
+      curRow = []
+      numOfChars = 0
+    }
+    curRow.push(w)
+    numOfChars += w.length
+  }
+
+  const numOfSpace = maxWidth - numOfChars - (curRow.length - 1)
+  let tail = ''
+  for(let i = 0; i < numOfSpace; i++) tail += ' '
+  res.push(curRow.join(' ') + tail)
+
+  return res
+};
+
+// another
+
 /**
  * @param {string[]} words
  * @param {number} L

From 4a5426426d1d4112c53dafd150f04b8c006c28be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Mar 2021 11:27:27 +0800
Subject: [PATCH 1253/3374] Update 121-best-time-to-buy-and-sell-stock.js

---
 121-best-time-to-buy-and-sell-stock.js | 15 +++++++--------
 1 file changed, 7 insertions(+), 8 deletions(-)

diff --git a/121-best-time-to-buy-and-sell-stock.js b/121-best-time-to-buy-and-sell-stock.js
index fd613dcd..7a5d1899 100755
--- a/121-best-time-to-buy-and-sell-stock.js
+++ b/121-best-time-to-buy-and-sell-stock.js
@@ -21,12 +21,11 @@ const maxProfit = function(prices) {
  * @param {number[]} prices
  * @return {number}
  */
-const maxProfit = function (prices) {
-  let maxCur = 0,
-    maxSoFar = 0
-  for (let i = 1; i < prices.length; i++) {
-    maxCur = Math.max(0, (maxCur += prices[i] - prices[i - 1]))
-    maxSoFar = Math.max(maxCur, maxSoFar)
+const maxProfit = function(prices) {
+  let res = 0, maxCur = 0
+  for(let i = 1; i < prices.length; i++) {
+    maxCur = Math.max(0, maxCur + (prices[i] - prices[i - 1]))
+    res = Math.max(res, maxCur)
   }
-  return maxSoFar
-}
+  return res
+};

From 5fc8bd8e71fe05e1ae7dce0d6ab917204afce7b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Mar 2021 14:41:47 +0800
Subject: [PATCH 1254/3374] Update 91-decode-ways.js

---
 91-decode-ways.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/91-decode-ways.js b/91-decode-ways.js
index eb664299..300145d2 100644
--- a/91-decode-ways.js
+++ b/91-decode-ways.js
@@ -1,3 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numDecodings = function(s) {
+  if(s == null || s.length === 0) return 1
+  if(s[0] === '0') return 0
+  const set = new Set()
+  const n = s.length
+  for(let i = 1; i <= 26; i++) {
+    set.add(`${i}`)
+  }
+  const dp = Array(n + 1).fill(0)
+  dp[0] = dp[1] = 1
+  for(let i = 2; i <= n; i++) {
+    if(set.has(s[i - 2] + s[i - 1])) dp[i] += dp[i - 2]
+    if(set.has(s[i - 1])) dp[i] += dp[i - 1]
+  }
+  return dp[n]
+};
+
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From de9d4d2dd51761de36991a6e3220bd574b483ef4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Mar 2021 15:46:48 +0800
Subject: [PATCH 1255/3374] Update 450-delete-node-in-a-bst.js

---
 450-delete-node-in-a-bst.js | 42 +++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/450-delete-node-in-a-bst.js b/450-delete-node-in-a-bst.js
index a66de96d..51eee135 100644
--- a/450-delete-node-in-a-bst.js
+++ b/450-delete-node-in-a-bst.js
@@ -31,3 +31,45 @@ const deleteNode = function(root, key) {
   
   return root
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} key
+ * @return {TreeNode}
+ */
+const deleteNode = function(root, key) {
+  if(root == null) return root
+
+  if(root.val < key) root.right = deleteNode(root.right, key)
+  else if(root.val > key) root.left = deleteNode(root.left, key)
+  else {
+    if(root.left == null && root.right === null) root = null
+    else if(root.left == null) root = root.right
+    else if(root.right == null) root = root.left
+    else {
+      const min = findMin(root.right)
+      root.val = min.val
+      root.right = deleteNode(root.right, root.val)
+    }
+  }
+
+  return root
+};
+
+function findMin(node) {
+  let cur = node
+  while(cur.left) {
+    cur = cur.left
+  }
+  return cur
+}

From 40b5c6e0ca09cb0672bbd04384b3745abd24f97b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 09:20:03 +0800
Subject: [PATCH 1256/3374] Update 92-reverse-linked-list-ii.js

---
 92-reverse-linked-list-ii.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/92-reverse-linked-list-ii.js b/92-reverse-linked-list-ii.js
index b9d5efef..e2bdad76 100644
--- a/92-reverse-linked-list-ii.js
+++ b/92-reverse-linked-list-ii.js
@@ -84,6 +84,40 @@ const reverseBetween = function(head, m, n) {
     return dummy.next;
 };
 
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} left
+ * @param {number} right
+ * @return {ListNode}
+ */
+const reverseBetween = function(head, left, right) {
+  if(head == null || left === right) return head
+  const dummy = new ListNode()
+  dummy.next = head
+  let tail = null, p = dummy
+  for(let i = 1; i < left; i++) {
+    p = p.next
+  } 
+  tail = p.next
+  let tmp
+  for(let i = 0; i < right - left; i++) {
+    tmp = p.next
+    p.next = tail.next
+    tail.next = tail.next.next
+    p.next.next = tmp
+  }
+
+  return dummy.next
+};
 
 // another
 

From 901263dba473a8ac4c8199a9b55669d55ae6734c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 09:37:45 +0800
Subject: [PATCH 1257/3374] Update 2-add-two-numbers.js

---
 2-add-two-numbers.js | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2-add-two-numbers.js b/2-add-two-numbers.js
index 26c7b3c8..eeaa3925 100755
--- a/2-add-two-numbers.js
+++ b/2-add-two-numbers.js
@@ -76,3 +76,45 @@ function single(l1, l2, res) {
     }
   }
 }
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  let extra = false
+  const dummy = new ListNode()
+  let cur = dummy
+  while(l1 || l2) {
+    let val = 0
+    if(l1) val += l1.val
+    if(l2) val += l2.val
+    if(extra) val += 1
+      
+    if(val > 9) {
+      extra = true
+      val = val % 10
+    } else {
+      extra = false
+    }
+    cur.next = new ListNode(val)
+    cur = cur.next
+    if(l1) l1 = l1.next
+    if(l2) l2 = l2.next
+  }
+
+  if(extra) cur.next = new ListNode(1)
+  return dummy.next
+};
+
+

From b6a3ad61f14f418dc0d3279271ac49bfb87447d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 13:56:26 +0800
Subject: [PATCH 1258/3374] Update 829-consecutive-numbers-sum.js

---
 829-consecutive-numbers-sum.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/829-consecutive-numbers-sum.js b/829-consecutive-numbers-sum.js
index 133c9681..e2d5e98f 100644
--- a/829-consecutive-numbers-sum.js
+++ b/829-consecutive-numbers-sum.js
@@ -9,3 +9,21 @@ const consecutiveNumbersSum = function (N) {
   }
   return count
 }
+
+// another
+
+/**
+ * @param {number} N
+ * @return {number}
+ */
+const consecutiveNumbersSum = function(N) {
+  let res = 0
+  for(let i = 1; i <= N; i++) {
+    const diff = i * (i - 1) / 2
+    const nd = N - diff
+    if(nd <= 0) break
+    if(nd % i === 0) res++
+  }
+  
+  return res
+};

From c21332b031130bffc2a45694f32ff368d63e9dcc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 15:20:43 +0800
Subject: [PATCH 1259/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index 8215f354..ea7bcd27 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -20,20 +20,20 @@ Output: 1
  * @return {number}
  */
 const minMeetingRooms = function(intervals) {
-  const len = intervals.length
-  const starts = new Array(len)
-  const ends = new Array(len)
-  for (let i = 0; i < len; i++) {
-    starts[i] = intervals[i][0]
-    ends[i] = intervals[i][1]
+  const n = intervals.length
+  const start = Array(n), end = Array(n)
+  for(let i = 0; i < n; i++) {
+    start[i] = intervals[i][0]
+    end[i] = intervals[i][1]
   }
-  starts.sort((a, b) => a - b)
-  ends.sort((a, b) => a - b)
-  let rooms = 0
-  let endsItr = 0
-  for (let i = 0; i < len; i++) {
-    if (starts[i] < ends[endsItr]) rooms++
-    else endsItr++
+  start.sort((a, b) => a - b)
+  end.sort((a, b) => a - b)
+
+  let res = 0, endIdx = 0
+  for(let i = 0; i < n; i++) {
+    if(start[i] < end[endIdx]) res++
+    else endIdx++
   }
-  return rooms
+
+  return res
 }

From 3f52b76622965d696232679bfc8aba32e0ad4f8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 15:45:14 +0800
Subject: [PATCH 1260/3374] Update 20-valid-parentheses.js

---
 20-valid-parentheses.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/20-valid-parentheses.js b/20-valid-parentheses.js
index f05cb320..00fc5c02 100755
--- a/20-valid-parentheses.js
+++ b/20-valid-parentheses.js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+ const isValid = function(s) {
+  const stack = []
+  const n = s.length
+  for(let c of s) {
+    if(c === '(' || c === '{' || c === '[') stack.push(c)
+    else if(c === ')') {
+      if(stack[stack.length - 1] === '(') stack.pop()
+      else return false
+    }
+    else if(c === '}') {
+      if(stack[stack.length - 1] === '{') stack.pop()
+      else return false
+    }
+    else if(c === ']') {
+      if(stack[stack.length - 1] === '[') stack.pop()
+      else return false
+    }
+  }
+  return stack.length === 0
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {boolean}

From c568523f94cd9c86323bc7270662876c6e2ac33c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 15:49:00 +0800
Subject: [PATCH 1261/3374] Update 20-valid-parentheses.js

---
 20-valid-parentheses.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/20-valid-parentheses.js b/20-valid-parentheses.js
index 00fc5c02..c9065a42 100755
--- a/20-valid-parentheses.js
+++ b/20-valid-parentheses.js
@@ -1,3 +1,21 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+ const isValid = function(s) {
+  const stack = []
+  for(let c of s) {
+    if(c === '(') stack.push(')')
+    else if(c === '{') stack.push('}')
+    else if(c === '[') stack.push(']')
+    else if(stack.length === 0 || c !== stack.pop()) return false
+  }
+  return stack.length === 0
+};
+
+
+// another
+
 /**
  * @param {string} s
  * @return {boolean}

From 86170c3de06e5d90a3e125776e8b37b6afa6ede9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Apr 2021 17:35:34 +0800
Subject: [PATCH 1262/3374] Update 380-insert-delete-getrandom-o1.js

---
 380-insert-delete-getrandom-o1.js | 27 +++++++++++++--------------
 1 file changed, 13 insertions(+), 14 deletions(-)

diff --git a/380-insert-delete-getrandom-o1.js b/380-insert-delete-getrandom-o1.js
index 7358dbea..e4591798 100644
--- a/380-insert-delete-getrandom-o1.js
+++ b/380-insert-delete-getrandom-o1.js
@@ -2,8 +2,8 @@
  * Initialize your data structure here.
  */
 const RandomizedSet = function () {
+  this.arr = []
   this.map = new Map()
-  this.array = []
 }
 
 /**
@@ -12,10 +12,11 @@ const RandomizedSet = function () {
  * @return {boolean}
  */
 RandomizedSet.prototype.insert = function (val) {
-  const { array, map } = this
-  if (map.has(val)) return false
-  array.push(val)
-  map.set(val, array.length - 1)
+  const {arr, map} = this
+  if(map.has(val)) return false
+  const size = arr.length
+  arr.push(val)
+  map.set(val, size)
   return true
 }
 
@@ -25,12 +26,12 @@ RandomizedSet.prototype.insert = function (val) {
  * @return {boolean}
  */
 RandomizedSet.prototype.remove = function (val) {
-  const { array, map } = this
-  if (!map.has(val)) return false
-  const [last, index] = [array[array.length - 1], map.get(val)]
-  array[index] = last
-  map.set(last, index)
-  array.pop()
+  const {arr, map} = this
+  if(!map.has(val)) return false
+  const idx = map.get(val), last = arr[arr.length - 1]
+  arr[idx] = last
+  map.set(last, idx)
+  arr.pop()
   map.delete(val)
   return true
 }
@@ -40,9 +41,7 @@ RandomizedSet.prototype.remove = function (val) {
  * @return {number}
  */
 RandomizedSet.prototype.getRandom = function () {
-  const { array } = this
-  const r = Math.floor(array.length * Math.random())
-  return array[r]
+  return this.arr[~~(this.arr.length * Math.random())]
 }
 
 /**

From 867a44591dca62979844eca8e7410e6c635b998b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Apr 2021 23:01:46 +0800
Subject: [PATCH 1263/3374] Update 518-coin-change-2.js

---
 518-coin-change-2.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/518-coin-change-2.js b/518-coin-change-2.js
index ec1c2d5b..54db7941 100644
--- a/518-coin-change-2.js
+++ b/518-coin-change-2.js
@@ -34,3 +34,31 @@ const change = function (amount, coins) {
   }
   return dp[amount]
 }
+
+// another
+
+// another
+
+const change = function(amount,coins) {
+  const n = coins.length
+  const dp = Array.from({ length: n + 1 }, () => Array(amount + 1))
+  dp[0][0] = 1
+  for(let i = 0; i < n; i++) dp[i][0] = 1
+  helper(0, amount)
+  return dp[0][amount] === undefined ? 0 : dp[0][amount]
+  
+  function helper(i, rem) {
+    if(dp[i][rem] != null) return dp[i][rem]
+    if(rem < 0) return 0
+    if(rem === 0) return 1
+    if(i >= coins.length) return 0
+    let res = 0
+    
+    res += helper(i, rem - coins[i])
+    res += helper(i + 1, rem)
+    
+    dp[i][rem] = res
+      
+    return res
+  } 
+}

From 3c9a8caefff5ec3eceef2dc62865cc846fee08e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Apr 2021 23:10:47 +0800
Subject: [PATCH 1264/3374] Update 21-merge-two-sorted-lists.js

---
 21-merge-two-sorted-lists.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/21-merge-two-sorted-lists.js b/21-merge-two-sorted-lists.js
index 83091e5c..3d094664 100755
--- a/21-merge-two-sorted-lists.js
+++ b/21-merge-two-sorted-lists.js
@@ -22,3 +22,37 @@ const mergeTwoLists = function(l1, l2) {
     return l2;
   }
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const mergeTwoLists = function(l1, l2) {
+  const dummy = new ListNode()
+  let cur = dummy
+  while(l1 && l2) {
+    if(l1.val < l2.val) {
+      cur.next = new ListNode(l1.val)
+      l1 = l1.next
+    } else {
+      cur.next = new ListNode(l2.val)
+      l2 = l2.next
+    }
+    
+    cur = cur.next
+  }
+  if(l1) cur.next = l1
+  if(l2) cur.next = l2
+  
+  return dummy.next
+};

From 31c6b69f9d0b8bbc23ee025f5b4be0e06e35ba78 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Apr 2021 23:47:04 +0800
Subject: [PATCH 1265/3374] Update 347-top-k-frequent-elements.js

---
 347-top-k-frequent-elements.js | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/347-top-k-frequent-elements.js b/347-top-k-frequent-elements.js
index c5f2c1f5..2acf9413 100755
--- a/347-top-k-frequent-elements.js
+++ b/347-top-k-frequent-elements.js
@@ -31,3 +31,38 @@ const topKFrequent = function(nums, k) {
   return res
 };
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const topKFrequent = function(nums, k) {
+  const hash = {}
+  for(let n of nums) {
+    if(hash[n] == null) hash[n] = 0
+    hash[n]++
+  }
+  const entries = Object.entries(hash)
+  let min = Infinity, max = -Infinity
+  const reverse = {}
+  for(let [k, freq] of entries) {
+    if(freq < min) min = freq
+    if(freq > max) max = freq
+    if(reverse[freq] == null) reverse[freq] = []
+    reverse[freq].push(k)
+  }
+  const n = max - min + 1
+  const arr = Array(n)
+  let res = []
+  let limit = max
+  while(limit) {
+    if(reverse[limit]) res.push(...reverse[limit])
+    limit--
+    if(res.length >= k) break
+  }
+  res.splice(k)
+  return res
+};
+

From db6de7a32330e060ba853d4b654dce8ee63a5836 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Apr 2021 11:26:52 +0800
Subject: [PATCH 1266/3374] Update 23-merge-k-sorted-lists.js

---
 23-merge-k-sorted-lists.js | 44 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/23-merge-k-sorted-lists.js b/23-merge-k-sorted-lists.js
index 73b598ea..1804d044 100644
--- a/23-merge-k-sorted-lists.js
+++ b/23-merge-k-sorted-lists.js
@@ -34,6 +34,50 @@ function merge(lists, l, r) {
   return dummy.next
 }
 
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode[]} lists
+ * @return {ListNode}
+ */
+const mergeKLists = function(lists) {
+  if(lists == null || lists.length === 0) return null
+  if(lists.length === 1) return lists[0]
+  if(lists.length === 2) return mergeTwo(lists[0], lists[1])
+  const left = mergeKLists(lists.slice(0, ~~(lists.length / 2)))
+  const right = mergeKLists(lists.slice(~~(lists.length / 2)))
+  
+  return mergeTwo(left, right)
+};
+
+function mergeTwo(l1, l2) {
+  const dummy = new ListNode()
+  let cur = dummy
+  while(l1 && l2) {
+    if(l1.val < l2.val) {
+      cur.next = l1
+      l1 = l1.next
+    } else {
+      cur.next = l2
+      l2 = l2.next
+    }
+    cur = cur.next
+  }
+  if(l1) cur.next = l1
+  if(l2) cur.next = l2
+  
+  
+  return dummy.next
+}
+
+
 // another
 
 /**

From 6643f099766a877973701137b418d5a08a6c9641 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Apr 2021 12:24:05 +0800
Subject: [PATCH 1267/3374] Create 981-time-based-key-value-store.js

---
 981-time-based-key-value-store.js | 47 +++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 981-time-based-key-value-store.js

diff --git a/981-time-based-key-value-store.js b/981-time-based-key-value-store.js
new file mode 100644
index 00000000..24ca2531
--- /dev/null
+++ b/981-time-based-key-value-store.js
@@ -0,0 +1,47 @@
+/**
+ * Initialize your data structure here.
+ */
+const TimeMap = function() {
+   this.hash = {}
+};
+
+/** 
+ * @param {string} key 
+ * @param {string} value 
+ * @param {number} timestamp
+ * @return {void}
+ */
+TimeMap.prototype.set = function(key, value, timestamp) {
+  if(this.hash[key] == null) this.hash[key] = []
+  this.hash[key].push([value, timestamp])
+};
+
+/** 
+ * @param {string} key 
+ * @param {number} timestamp
+ * @return {string}
+ */
+TimeMap.prototype.get = function(key, timestamp) {
+  if(this.hash[key] == null) return ''
+  const arr = this.hash[key]
+
+  let l = 0, r = arr.length
+  while(l < r) {
+    const mid = l + ((r - l) >> 1)
+    if(arr[mid][1] <= timestamp) {
+      l = mid + 1
+    } else {
+      r = mid
+    }
+  }
+
+  if(r === 0) return ''
+  return arr[r - 1][0]
+};
+
+/** 
+ * Your TimeMap object will be instantiated and called as such:
+ * var obj = new TimeMap()
+ * obj.set(key,value,timestamp)
+ * var param_2 = obj.get(key,timestamp)
+ */

From c3c43bed4792296ecca44dfd09e63724c8a26c30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Apr 2021 13:59:38 +0800
Subject: [PATCH 1268/3374] Update 981-time-based-key-value-store.js

---
 981-time-based-key-value-store.js | 50 +++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/981-time-based-key-value-store.js b/981-time-based-key-value-store.js
index 24ca2531..67101e69 100644
--- a/981-time-based-key-value-store.js
+++ b/981-time-based-key-value-store.js
@@ -16,6 +16,56 @@ TimeMap.prototype.set = function(key, value, timestamp) {
   this.hash[key].push([value, timestamp])
 };
 
+/** 
+ * @param {string} key 
+ * @param {number} timestamp
+ * @return {string}
+ */
+TimeMap.prototype.get = function(key, timestamp) {
+  if(this.hash[key] == null) return ''
+  const arr = this.hash[key]
+
+  let l = 0, r = arr.length - 1;
+  while(l <= r) {
+    const pick = Math.floor((l + r) / 2);
+    if (arr[pick][1] < timestamp) {
+        l = pick + 1;
+    } else if (arr[pick][1] > timestamp) {
+        r = pick - 1
+    } else {
+        return arr[pick][0];
+    }
+  }
+  return arr[r]?.[0] || ''
+};
+
+/** 
+ * Your TimeMap object will be instantiated and called as such:
+ * var obj = new TimeMap()
+ * obj.set(key,value,timestamp)
+ * var param_2 = obj.get(key,timestamp)
+ */
+
+// another
+
+/**
+ * Initialize your data structure here.
+ */
+const TimeMap = function() {
+   this.hash = {}
+};
+
+/** 
+ * @param {string} key 
+ * @param {string} value 
+ * @param {number} timestamp
+ * @return {void}
+ */
+TimeMap.prototype.set = function(key, value, timestamp) {
+  if(this.hash[key] == null) this.hash[key] = []
+  this.hash[key].push([value, timestamp])
+};
+
 /** 
  * @param {string} key 
  * @param {number} timestamp

From e66b77775cc85f88e4f50f3ffa6fa54a0e80170b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Apr 2021 12:23:56 +0800
Subject: [PATCH 1269/3374] Create
 1819-number-of-different-subsequences-gcds.js

---
 1819-number-of-different-subsequences-gcds.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1819-number-of-different-subsequences-gcds.js

diff --git a/1819-number-of-different-subsequences-gcds.js b/1819-number-of-different-subsequences-gcds.js
new file mode 100644
index 00000000..cc6aa6c6
--- /dev/null
+++ b/1819-number-of-different-subsequences-gcds.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countDifferentSubsequenceGCDs = function(nums) {
+    const MAX = 2e5 + 1;
+     const cnt = Array(MAX).fill(0)
+    for (let x of nums) cnt[x] = true;
+    let ret = 0;
+    for (let x=1; x<MAX; x++) {
+        let g = 0;
+        for (let y=x; y<MAX; y+=x) {
+            if (cnt[y]) g = gcd(g, y);
+        }
+        if (g == x) ret++;
+    }
+    return ret;
+};
+
+function gcd(x,y){
+    if(y === 0) return x
+    return gcd(y, x % y)
+}
+
+

From 1e5585ac9ed831dfaa01340cca67bf0cddfec328 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Apr 2021 17:02:24 +0800
Subject: [PATCH 1270/3374] Create 1816-truncate-sentence.js

---
 1816-truncate-sentence.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1816-truncate-sentence.js

diff --git a/1816-truncate-sentence.js b/1816-truncate-sentence.js
new file mode 100644
index 00000000..0a73bce1
--- /dev/null
+++ b/1816-truncate-sentence.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const truncateSentence = function(s, k) {
+  const arr = s.split(' ')
+  const sli = arr.slice(0, k)
+  return sli.join(' ')
+};

From 90ee18e82ae487aa40081948c4b4c4e4724ffb58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Apr 2021 17:02:52 +0800
Subject: [PATCH 1271/3374] Create 1817-finding-the-users-active-minutes.js

---
 1817-finding-the-users-active-minutes.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1817-finding-the-users-active-minutes.js

diff --git a/1817-finding-the-users-active-minutes.js b/1817-finding-the-users-active-minutes.js
new file mode 100644
index 00000000..df7e2e20
--- /dev/null
+++ b/1817-finding-the-users-active-minutes.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} logs
+ * @param {number} k
+ * @return {number[]}
+ */
+const findingUsersActiveMinutes = function(logs, k) {
+  const hash = {}, map = {}
+  logs.forEach(l => {
+    const [id, mi] = l
+    if(hash[mi] == null) hash[mi] = new Set()
+    if(map[id] == null) map[id] = new Set()
+    hash[mi].add(id)
+    map[id].add(mi)
+  })
+
+  const res = Array(k).fill(0)
+  Object.keys(map).forEach(k => {
+     const num = map[k].size
+     res[num - 1]++
+  })
+  
+  return res
+  
+};

From c7bdfd976472fa82b35986c257a8dcee75832a3e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Apr 2021 17:03:22 +0800
Subject: [PATCH 1272/3374] Create 1818-minimum-absolute-sum-difference.js

---
 1818-minimum-absolute-sum-difference.js | 28 +++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1818-minimum-absolute-sum-difference.js

diff --git a/1818-minimum-absolute-sum-difference.js b/1818-minimum-absolute-sum-difference.js
new file mode 100644
index 00000000..89c8e653
--- /dev/null
+++ b/1818-minimum-absolute-sum-difference.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minAbsoluteSumDiff = function(nums1, nums2) {
+  let sum = 0, lgDiff = -Infinity, idx = -1
+  const mod = 10 ** 9 + 7
+  const n = nums1.length, { min, max, abs } = Math 
+  for(let i = 0; i < n; i++) {
+    let tmp = abs(nums1[i] - nums2[i])
+    if(tmp > lgDiff) lgDiff = tmp, idx = i
+    sum = (sum + tmp) % mod
+  }
+    
+  let res = sum, delta = lgDiff, t = Infinity
+  for(let i = 0; i < n; i++) {
+    if(i !== idx) {
+      const t1 = abs(nums1[i] - nums2[idx])
+      // const t2 = abs(nums2[i] - nums1[idx])
+      const tmp = min(t1, lgDiff)
+      if(tmp < t) t = tmp
+    }
+  }
+  // console.log(sum, lgDiff, idx, t)
+  return (sum - lgDiff + t) % mod
+  
+};

From e4edc5c5a07491a39632b4ab07f3975aca952717 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Apr 2021 20:13:09 +0800
Subject: [PATCH 1273/3374] Update 370-range-addition.js

---
 370-range-addition.js | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/370-range-addition.js b/370-range-addition.js
index 828b72e2..979178db 100644
--- a/370-range-addition.js
+++ b/370-range-addition.js
@@ -26,7 +26,6 @@ After applying operation [0,2,-2]:
 [-2,0,3,5,3]
 
 */
-
 /**
  * @param {number} length
  * @param {number[][]} updates
@@ -35,9 +34,7 @@ After applying operation [0,2,-2]:
 const getModifiedArray = function(length, updates) {
   const res = new Array(length).fill(0)
   for (let update of updates) {
-    let value = update[2]
-    let start = update[0]
-    let end = update[1]
+    const [start, end, value] = update
     res[start] += value
     if (end < length - 1) res[end + 1] -= value
   }

From 660e9e16945ec4abeb4474a5333e4dfd6a96ce23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Apr 2021 12:58:25 +0800
Subject: [PATCH 1274/3374] Update 92-reverse-linked-list-ii.js

---
 92-reverse-linked-list-ii.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/92-reverse-linked-list-ii.js b/92-reverse-linked-list-ii.js
index e2bdad76..e9c73874 100644
--- a/92-reverse-linked-list-ii.js
+++ b/92-reverse-linked-list-ii.js
@@ -159,3 +159,38 @@ const reverseBetween = function(head, left, right) {
 
   return prev ? head : r
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} left
+ * @param {number} right
+ * @return {ListNode}
+ */
+const reverseBetween = function(head, left, right) {
+  if(head == null) return head
+  const dummy = new ListNode()
+  dummy.next = head
+
+  let p = dummy
+  for(let i = 0; i < left - 1; i++) {
+    p = p.next
+  }
+  let tail = p.next, tmp = null
+  for(let i = 0; i < right - left; i++) {
+    tmp = p.next
+    p.next = tail.next
+    tail.next = tail.next.next
+    p.next.next = tmp
+  }
+  
+  return dummy.next
+};

From aba904e3346c6d4102feb8a43b89996399459179 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Apr 2021 21:10:20 +0800
Subject: [PATCH 1275/3374] Update 699-falling-squares.js

---
 699-falling-squares.js | 55 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/699-falling-squares.js b/699-falling-squares.js
index 5438e80a..a21ff74b 100644
--- a/699-falling-squares.js
+++ b/699-falling-squares.js
@@ -31,3 +31,58 @@ function getHeight(intervals, cur) {
   intervals.push(cur)
   return cur.height
 }
+
+// another
+
+/**
+ * @param {number[][]} positions
+ * @return {number[]}
+ */
+var fallingSquares = function (positions) {
+  let ranges = [{ left: 0, height: 0, right: 1e8 + 1e6 }], rtn = [], max = 0
+
+  outer:
+  for (let [left, length] of positions) {
+    let curHeight = 0, startI = -1, right = left + length, newRanges = []
+    for (let i = 0; i < ranges.length; i++) {
+      let range = ranges[i]
+      if (left < range.right && startI == -1) {
+        startI = i
+        // left part
+        if (left != range.left) {
+          newRanges.push({
+            left: range.left,
+            height: range.height,
+            right: left
+          })
+        }
+      }
+      if (startI != -1) {
+        curHeight = Math.max(curHeight, range.height)
+      }
+      if (right <= range.right) {
+        // added part
+        let newHeight = length + curHeight
+        newRanges.push({
+          left,
+          height: newHeight,
+          right,
+        })
+        // right part
+        if (right != range.right) {
+          newRanges.push({
+            left: right,
+            height: range.height,
+            right: range.right,
+          })
+        }
+        max = Math.max(newHeight, max)
+        rtn.push(max)
+        // replace
+        ranges.splice(startI, i - startI + 1, ...newRanges)
+        continue outer
+      }
+    }
+  }
+  return rtn
+};

From 6d9fb49a983182b42e479fa811fcb09c172eb86d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Apr 2021 21:28:13 +0800
Subject: [PATCH 1276/3374] Update 699-falling-squares.js

---
 699-falling-squares.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/699-falling-squares.js b/699-falling-squares.js
index a21ff74b..aeebee63 100644
--- a/699-falling-squares.js
+++ b/699-falling-squares.js
@@ -14,17 +14,18 @@ function fallingSquares(positions) {
   const res = []
   let h = 0
   for (let pos of positions) {
-    let cur = new Interval(pos[0], pos[0] + pos[1] - 1, pos[1])
+    let cur = new Interval(pos[0], pos[0] + pos[1], pos[1])
     h = Math.max(h, getHeight(intervals, cur))
     res.push(h)
   }
+  console.log(intervals)
   return res
 }
 function getHeight(intervals, cur) {
   let preMaxHeight = 0
   for (let i of intervals) {
-    if (i.end < cur.start) continue
-    if (i.start > cur.end) continue
+    if (i.end <= cur.start) continue
+    if (i.start >= cur.end) continue
     preMaxHeight = Math.max(preMaxHeight, i.height)
   }
   cur.height += preMaxHeight

From 8790e3ac826c9f1abcad61788f434d127e5c8b2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Apr 2021 19:05:55 +0800
Subject: [PATCH 1277/3374] Create
 1815-maximum-number-of-groups-getting-fresh-donuts.js

---
 ...m-number-of-groups-getting-fresh-donuts.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 1815-maximum-number-of-groups-getting-fresh-donuts.js

diff --git a/1815-maximum-number-of-groups-getting-fresh-donuts.js b/1815-maximum-number-of-groups-getting-fresh-donuts.js
new file mode 100644
index 00000000..84b25e27
--- /dev/null
+++ b/1815-maximum-number-of-groups-getting-fresh-donuts.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number} batchSize
+ * @param {number[]} groups
+ * @return {number}
+ */
+const maxHappyGroups = function (batchSize, groups) {
+  const arr = new Array(batchSize + 1).fill(0)
+  let result = 0
+  // reduce group to groups of size  group%n
+  for (let gSize of groups) {
+    arr[gSize % batchSize]++
+  }
+
+  // Only need 1 step
+  result += arr[0]
+  arr[0] = 0
+
+  // Only need 2 step
+  for (let i = 1; i < batchSize / 2; i++) {
+    let min = Math.min(arr[i], arr[batchSize - i])
+    arr[i] -= min
+    arr[batchSize - i] -= min
+    result += min
+  }
+  result += dfs(arr, 0, new Map())
+  return result
+}
+
+function dfs(arr, remain, cache) {
+  let n = arr.length - 1
+  const key = arr.join(',')
+  if (cache.has(key)) return cache.get(key)
+  let result = 0
+  // greedy and short cut when we can finish the current round
+  if (remain > 0 && arr[n - remain] > 0) {
+    arr[n - remain]--
+    result = dfs(arr, 0, cache)
+    arr[n - remain]++
+  } else {
+    for (let i = 1; i < arr.length; i++) {
+      if (arr[i] > 0) {
+        arr[i]--
+        result = Math.max(
+          result,
+          dfs(arr, (remain + i) % n, cache) + (remain == 0 ? 1 : 0)
+        )
+        arr[i]++
+      }
+    }
+  }
+  cache.set(key, result)
+  return result
+}

From 94f9d112bd49d22eb3daa6fb16e266bb638c31c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Apr 2021 20:27:49 +0800
Subject: [PATCH 1278/3374] Update 1818-minimum-absolute-sum-difference.js

---
 1818-minimum-absolute-sum-difference.js | 51 +++++++++++++++----------
 1 file changed, 31 insertions(+), 20 deletions(-)

diff --git a/1818-minimum-absolute-sum-difference.js b/1818-minimum-absolute-sum-difference.js
index 89c8e653..c46574c0 100644
--- a/1818-minimum-absolute-sum-difference.js
+++ b/1818-minimum-absolute-sum-difference.js
@@ -3,26 +3,37 @@
  * @param {number[]} nums2
  * @return {number}
  */
-const minAbsoluteSumDiff = function(nums1, nums2) {
-  let sum = 0, lgDiff = -Infinity, idx = -1
+const minAbsoluteSumDiff = function (A, B) {
   const mod = 10 ** 9 + 7
-  const n = nums1.length, { min, max, abs } = Math 
-  for(let i = 0; i < n; i++) {
-    let tmp = abs(nums1[i] - nums2[i])
-    if(tmp > lgDiff) lgDiff = tmp, idx = i
-    sum = (sum + tmp) % mod
+  const sA = [...A].sort((a, b) => a - b)
+  let res = 0
+  let gain = 0
+
+  for (let i = 0; i < A.length; i++) {
+    const delta = Math.abs(A[i] - B[i])
+    res += delta
+    // if delta <= gain, delta - newDelta is not possbile to be better than gain
+    if (delta <= gain) continue
+    // Find closest to B[i] in A
+    const idx = binaryS(sA, B[i])
+    // Double check l, l + 1, l - 1
+    const newDelta = Math.min(
+      Math.abs(sA[idx] - B[i]),
+      idx >= 1 ? Math.abs(sA[idx - 1] - B[i]) : Infinity,
+      idx + 1 < A.length ? Math.abs(sA[idx + 1] - B[i]) : Infinity
+    )
+    gain = Math.max(gain, delta - newDelta)
   }
-    
-  let res = sum, delta = lgDiff, t = Infinity
-  for(let i = 0; i < n; i++) {
-    if(i !== idx) {
-      const t1 = abs(nums1[i] - nums2[idx])
-      // const t2 = abs(nums2[i] - nums1[idx])
-      const tmp = min(t1, lgDiff)
-      if(tmp < t) t = tmp
-    }
+  return (res - gain) % mod
+}
+function binaryS(A, b) {
+  let [l, r] = [0, A.length - 1]
+  while (l < r) {
+    const mid = l + ((r - l) >> 1)
+    const midV = A[mid]
+    if (midV === b) return mid
+    if (midV < b) l = mid + 1
+    else r = mid - 1
   }
-  // console.log(sum, lgDiff, idx, t)
-  return (sum - lgDiff + t) % mod
-  
-};
+  return l
+}

From ccb9524d3736c0af446c8ef53515ae1e0b3d760d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Apr 2021 16:25:20 +0800
Subject: [PATCH 1279/3374] Update 1091-shortest-path-in-binary-matrix.js

---
 1091-shortest-path-in-binary-matrix.js | 36 +++++++++++++-------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/1091-shortest-path-in-binary-matrix.js b/1091-shortest-path-in-binary-matrix.js
index 85741715..3e906d2a 100644
--- a/1091-shortest-path-in-binary-matrix.js
+++ b/1091-shortest-path-in-binary-matrix.js
@@ -3,32 +3,32 @@
  * @return {number}
  */
 const shortestPathBinaryMatrix = function(grid) {
-  let N = grid.length,
-    qu = [[0, 0]],
-    path = 1
+  if(grid == null || grid.length === 0 || grid[0][0] === 1) return -1 
+  let res = 1
+  const n = grid.length
   const dirs = [
-    [-1, 0],
     [1, 0],
-    [0, -1],
+    [-1, 0],
     [0, 1],
+    [0, -1],
     [-1, -1],
     [-1, 1],
+    [1, 1],
     [1, -1],
-    [1, 1]
   ]
-  while (qu.length !== 0) {
-    let cop = qu
-    qu = []
-    for (let [r, c] of cop) {
-      if (r < 0 || r >= grid.length || c < 0 || c >= grid[0].length) continue
-      if (grid[r][c] === 1) continue
-      grid[r][c] = 1
-      if (r === N - 1 && c === N - 1) return path
-      for (let dir of dirs) {
-        qu.push([r + dir[0], c + dir[1]])
+  let q = [[0, 0]]
+  while(q.length) {
+    const tmp = q
+    q = []
+    for(let [x, y] of tmp) {
+      if (x < 0 || x >= n || y < 0 || y >= n || grid[x][y] !== 0) continue
+      if(x === n - 1 && y === n - 1) return res
+      grid[x][y] = 1
+      for(let [dx, dy] of dirs) {    
+        q.push([x + dx, y + dy])
       }
     }
-    path++
+    res++
   }
   return -1
-}
+};

From 11f1b4e050dd3069e2017f68f507f804a0984ce2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Apr 2021 16:37:04 +0800
Subject: [PATCH 1280/3374] Update 1091-shortest-path-in-binary-matrix.js

---
 1091-shortest-path-in-binary-matrix.js | 46 ++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/1091-shortest-path-in-binary-matrix.js b/1091-shortest-path-in-binary-matrix.js
index 3e906d2a..110137e1 100644
--- a/1091-shortest-path-in-binary-matrix.js
+++ b/1091-shortest-path-in-binary-matrix.js
@@ -32,3 +32,49 @@ const shortestPathBinaryMatrix = function(grid) {
   }
   return -1
 };
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const shortestPathBinaryMatrix = function(grid) {
+  if(grid == null || grid.length === 0 || grid[0][0] === 1) return -1 
+  let res = 1
+  const n = grid.length
+  const dirs = [
+    [1, 0],
+    [-1, 0],
+    [0, 1],
+    [0, -1],
+    [-1, -1],
+    [-1, 1],
+    [1, 1],
+    [1, -1],
+  ]
+  let q = [[0, 0]]
+  while(q.length) {
+    let ref = q
+    q = []
+    for(let [x, y] of ref) {
+      if(x === n - 1 && y === n - 1) return res
+      grid[x][y] = 1
+      for(let [dx, dy] of dirs) {
+        const nx = x + dx, ny = y + dy
+        if(helper(grid, nx, ny)) {
+          q.push([nx, ny])
+          grid[nx][ny] = 1 // very important
+        }
+      }
+    }
+    res++
+  }
+  return -1
+};
+
+function helper(grid, i, j) {
+  const n = grid.length
+  if(i < 0 || i >= n || j < 0 || j >= n || grid[i][j] !== 0) return false
+  return true
+}

From 59059ea5589b07b8966d05f43e0cde0ff262c4c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Apr 2021 21:58:54 +0800
Subject: [PATCH 1281/3374] Create 953-verifying-an-alien-dictionary.js

---
 953-verifying-an-alien-dictionary.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 953-verifying-an-alien-dictionary.js

diff --git a/953-verifying-an-alien-dictionary.js b/953-verifying-an-alien-dictionary.js
new file mode 100644
index 00000000..d2717a39
--- /dev/null
+++ b/953-verifying-an-alien-dictionary.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[]} words
+ * @param {string} order
+ * @return {boolean}
+ */
+const isAlienSorted = function(words, order) {
+  const mapping = Array(26).fill(0), a = 'a'.charCodeAt(0)
+  for(let i = 0, len = order.length; i < len; i++) {
+    mapping[order.charCodeAt(i) - a] = i
+  }
+
+  for(let i = 1, n = words.length; i < n; i++) {
+    if(bigger(words[i - 1], words[i])) return false
+  }
+  
+  return true
+  
+  function bigger(s1, s2) {
+    const n = s1.length, m = s2.length;
+    for (let i = 0; i < n && i < m; ++i) {
+      if (s1.charAt(i) != s2.charAt(i)) return mapping[s1.charCodeAt(i) - a] > mapping[s2.charCodeAt(i) - a];          
+    }
+
+    return n > m;
+  }
+
+};

From 585b834332d677e0002a64d0f8e3da58c71237c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Apr 2021 12:46:29 +0800
Subject: [PATCH 1282/3374] Create 1824-minimum-sideway-jumps.js

---
 1824-minimum-sideway-jumps.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1824-minimum-sideway-jumps.js

diff --git a/1824-minimum-sideway-jumps.js b/1824-minimum-sideway-jumps.js
new file mode 100644
index 00000000..b96a62e7
--- /dev/null
+++ b/1824-minimum-sideway-jumps.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} obstacles
+ * @return {number}
+ */
+const minSideJumps = function(obstacles) {
+  const n = obstacles.length
+  const { max, min } = Math
+    const dp = [10000000, 1, 0, 1];
+    for (let i of obstacles) {
+        dp[i] = dp[0];
+        for (let j = 1; j <= 3; ++j)
+            if (i !== j)
+                dp[j] = min(dp[1] + (j != 1 ? 1 : 0), dp[2] + (j != 2 ? 1 : 0), dp[3] + (j != 3 ? 1 : 0));
+    }
+    return min(dp[1], dp[2], dp[3]);
+};
+

From 860df66a0843eece1a44573a91df66bb3a8c45c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 14:15:53 +0800
Subject: [PATCH 1283/3374] Create 1822-sign-of-the-product-of-an-array.js

---
 1822-sign-of-the-product-of-an-array.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1822-sign-of-the-product-of-an-array.js

diff --git a/1822-sign-of-the-product-of-an-array.js b/1822-sign-of-the-product-of-an-array.js
new file mode 100644
index 00000000..d2650ca6
--- /dev/null
+++ b/1822-sign-of-the-product-of-an-array.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const arraySign = function(nums) {
+  let pos = 0, neg = 0, zero = 0
+  for(let e of nums) {
+    if(e > 0) pos++
+    else if(e < 0) neg++
+    else zero++
+  }
+  if(zero > 0) return 0
+  if(neg % 2 === 1) return -1
+  else return 1
+};

From 989c1bfe0e08746b81bb7eed8cb868d76d4e5c8d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 14:16:39 +0800
Subject: [PATCH 1284/3374] Create 1823-find-the-winner-of-the-circular-game.js

---
 1823-find-the-winner-of-the-circular-game.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1823-find-the-winner-of-the-circular-game.js

diff --git a/1823-find-the-winner-of-the-circular-game.js b/1823-find-the-winner-of-the-circular-game.js
new file mode 100644
index 00000000..706a3fd1
--- /dev/null
+++ b/1823-find-the-winner-of-the-circular-game.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const findTheWinner = function(n, k) {
+  const arr = Array(n).fill(0)
+  for(let i = 0; i < n; i++) arr[i] = i + 1
+  let idx = 0
+  while(arr.length > 1) {
+    idx = (idx + k - 1) % arr.length
+    arr.splice(idx, 1)
+  }
+  return arr.length ? arr[0] : -1
+};
+

From 0e3ccb1fcee8a44933ff8a5e0096f734ee77cb61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 14:39:30 +0800
Subject: [PATCH 1285/3374] Create
 1249-minimum-remove-to-make-valid-parentheses.js

---
 ...inimum-remove-to-make-valid-parentheses.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1249-minimum-remove-to-make-valid-parentheses.js

diff --git a/1249-minimum-remove-to-make-valid-parentheses.js b/1249-minimum-remove-to-make-valid-parentheses.js
new file mode 100644
index 00000000..eb294a6e
--- /dev/null
+++ b/1249-minimum-remove-to-make-valid-parentheses.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+ const minRemoveToMakeValid = function(s) {
+  const stack = [], n = s.length
+  const arr = s.split('')
+  let res = ''
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '(') stack.push(i + 1)
+    if(s[i] === ')') {
+      if(stack.length && stack[stack.length - 1] >= 0) stack.pop()
+      else stack.push(-(i + 1))
+    }
+  }
+  while(stack.length) {
+    arr[Math.abs(stack.pop()) - 1] = ''
+  }
+  return arr.join('')
+};

From 5b9b2747b12ef064661b671d8e383c1b23120739 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 15:11:12 +0800
Subject: [PATCH 1286/3374] Create
 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js

---
 ...cake-after-horizontal-and-vertical-cuts.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js

diff --git a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js
new file mode 100644
index 00000000..204580c6
--- /dev/null
+++ b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} h
+ * @param {number} w
+ * @param {number[]} horizontalCuts
+ * @param {number[]} verticalCuts
+ * @return {number}
+ */
+const maxArea = function(h, w, horizontalCuts, verticalCuts) {
+  return getMax(h, horizontalCuts) * getMax(w, verticalCuts) % (10 ** 9 + 7)
+};
+
+function getMax(limit, cuts) {
+  cuts.sort((a, b) => a - b)
+  const n = cuts.length
+  let max = Math.max(cuts[0], limit - cuts[n - 1])
+  for(let i = 1; i < n; i++) {
+    max = Math.max(max, cuts[i] - cuts[i - 1])
+  }
+  return max
+}

From 3429848cac07dfd7d021097fa2b2d2fa2698f7c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 15:36:45 +0800
Subject: [PATCH 1287/3374] Create 1348-tweet-counts-per-frequency.js

---
 1348-tweet-counts-per-frequency.js | 54 ++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 1348-tweet-counts-per-frequency.js

diff --git a/1348-tweet-counts-per-frequency.js b/1348-tweet-counts-per-frequency.js
new file mode 100644
index 00000000..2ceb9584
--- /dev/null
+++ b/1348-tweet-counts-per-frequency.js
@@ -0,0 +1,54 @@
+const createNode = val => ({ val, left: null, right: null });
+class BinarySearchTree {
+  constructor() {
+    this.root = null;
+  }
+  insert(val, cur = this.root) {
+    const node = createNode(val);
+    if (!this.root) { this.root = node; return; }
+    if (val >= cur.val) {
+      !cur.right ? (cur.right = node) : this.insert(val, cur.right);
+    } else {
+      !cur.left ? (cur.left = node) : this.insert(val, cur.left);
+    }
+  }
+  traversal(low, high, interval, intervals, cur = this.root) {
+    if (!cur) return;
+    if (cur.val <= high && cur.val >= low) {
+      ++intervals[Math.floor((cur.val - low + 1) / interval)];
+    }
+    cur.val > low && this.traversal(low, high, interval, intervals, cur.left);
+    cur.val < high && this.traversal(low, high, interval, intervals, cur.right);
+  }
+};
+class TweetCounts {
+  constructor() {
+    this.freqInterval = {
+      minute: 60,
+      hour: 3600,
+      day: 86400,
+    };
+    this.data = new Map();
+  }
+
+  recordTweet(name, time) {
+    if (this.data.has(name) === false) {
+      this.data.set(name, new BinarySearchTree());
+    }
+    this.data.get(name).insert(time);
+  }
+
+  getTweetCountsPerFrequency(freq, name, start, end) {
+    const interval = this.freqInterval[freq];
+    const ret = new Array(Math.ceil((end - start + 1) / interval)).fill(0);
+    this.data.has(name) && this.data.get(name).traversal(start, end, interval, ret);
+    return ret;
+  }
+};
+
+/** 
+ * Your TweetCounts object will be instantiated and called as such:
+ * var obj = new TweetCounts()
+ * obj.recordTweet(tweetName,time)
+ * var param_2 = obj.getTweetCountsPerFrequency(freq,tweetName,startTime,endTime)
+ */

From cc72c926629ed0f01a4b43d9e859ee17c55df003 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 16:29:20 +0800
Subject: [PATCH 1288/3374] Create
 1209-remove-all-adjacent-duplicates-in-string-ii.js

---
 ...ve-all-adjacent-duplicates-in-string-ii.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1209-remove-all-adjacent-duplicates-in-string-ii.js

diff --git a/1209-remove-all-adjacent-duplicates-in-string-ii.js b/1209-remove-all-adjacent-duplicates-in-string-ii.js
new file mode 100644
index 00000000..69db7ffe
--- /dev/null
+++ b/1209-remove-all-adjacent-duplicates-in-string-ii.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const removeDuplicates = function (s, k) {
+  const stack = [];
+  const arr = s.split('')
+  for(let i = 0; i < arr.length; i++) {
+    if(i === 0 || arr[i] !== arr[i - 1]) {
+      stack.push(1)
+    } else {
+      stack[stack.length - 1]++
+      if(stack[stack.length - 1] === k) {
+        stack.pop()
+        arr.splice(i - k + 1, k)
+        i -= k
+      }
+    }
+    
+  }
+  return arr.join('')
+};

From 5784b2b5e5cfc06efdf4f8bc4ccf32694dd81b7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 16:47:54 +0800
Subject: [PATCH 1289/3374] Update
 1209-remove-all-adjacent-duplicates-in-string-ii.js

---
 ...ve-all-adjacent-duplicates-in-string-ii.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1209-remove-all-adjacent-duplicates-in-string-ii.js b/1209-remove-all-adjacent-duplicates-in-string-ii.js
index 69db7ffe..e03e4c40 100644
--- a/1209-remove-all-adjacent-duplicates-in-string-ii.js
+++ b/1209-remove-all-adjacent-duplicates-in-string-ii.js
@@ -21,3 +21,31 @@ const removeDuplicates = function (s, k) {
   }
   return arr.join('')
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const removeDuplicates = function (s, k) {
+  const stack = [];
+  s = s.split('');
+  for (let i = 0; i < s.length;) {
+    if (i === 0 || s[i] !== s[i - 1]) {
+      stack.push(1);
+      i++
+    } else {
+      stack[stack.length - 1]++;
+      if (stack[stack.length - 1] === k) {
+        stack.pop();
+        s.splice(i - k + 1, k);
+        i = i - k + 1;
+      } else {
+        i++
+      }
+    }
+  }
+  return s.join('');
+};

From e3875672b84ad6f41c9fd94300ee240c5b755829 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 17:06:54 +0800
Subject: [PATCH 1290/3374] Create 1472-design-browser-history.js

---
 1472-design-browser-history.js | 57 ++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 1472-design-browser-history.js

diff --git a/1472-design-browser-history.js b/1472-design-browser-history.js
new file mode 100644
index 00000000..808bc6c6
--- /dev/null
+++ b/1472-design-browser-history.js
@@ -0,0 +1,57 @@
+/**
+ * @param {string} homepage
+ */
+const BrowserHistory = function(homepage) {
+  this.idx = 0
+  this.arr = [homepage]
+};
+
+/** 
+ * @param {string} url
+ * @return {void}
+ */
+BrowserHistory.prototype.visit = function(url) {
+  const n = this.arr.length
+  this.arr.splice(this.idx + 1, n - this.idx - 1, url)
+  this.idx++
+};
+
+/** 
+ * @param {number} steps
+ * @return {string}
+ */
+BrowserHistory.prototype.back = function(steps) {
+  const idx = this.idx
+  let tmp = idx - steps
+  if(tmp < 0) {
+    this.idx = 0
+    return this.arr[0]
+  } else {
+    this.idx = tmp
+    return this.arr[tmp]
+  }
+};
+
+/** 
+ * @param {number} steps
+ * @return {string}
+ */
+BrowserHistory.prototype.forward = function(steps) {
+  const n = this.arr.length
+  let tmp = this.idx + steps
+  if(tmp >= n) {
+    this.idx  = n - 1
+    return this.arr[n - 1]
+  } else {
+    this.idx = tmp
+    return this.arr[tmp]
+  }
+};
+
+/** 
+ * Your BrowserHistory object will be instantiated and called as such:
+ * var obj = new BrowserHistory(homepage)
+ * obj.visit(url)
+ * var param_2 = obj.back(steps)
+ * var param_3 = obj.forward(steps)
+ */

From bc1cbeda85c63d4a7b9348c7edd9dd5d1a8d52ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 17:42:43 +0800
Subject: [PATCH 1291/3374] Update 1472-design-browser-history.js

---
 1472-design-browser-history.js | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/1472-design-browser-history.js b/1472-design-browser-history.js
index 808bc6c6..c1f6fd16 100644
--- a/1472-design-browser-history.js
+++ b/1472-design-browser-history.js
@@ -3,6 +3,7 @@
  */
 const BrowserHistory = function(homepage) {
   this.idx = 0
+  this.last = 0
   this.arr = [homepage]
 };
 
@@ -11,9 +12,9 @@ const BrowserHistory = function(homepage) {
  * @return {void}
  */
 BrowserHistory.prototype.visit = function(url) {
-  const n = this.arr.length
-  this.arr.splice(this.idx + 1, n - this.idx - 1, url)
   this.idx++
+  this.arr[this.idx] = url
+  this.last = this.idx
 };
 
 /** 
@@ -37,7 +38,7 @@ BrowserHistory.prototype.back = function(steps) {
  * @return {string}
  */
 BrowserHistory.prototype.forward = function(steps) {
-  const n = this.arr.length
+  const n = this.last + 1
   let tmp = this.idx + steps
   if(tmp >= n) {
     this.idx  = n - 1
@@ -47,11 +48,3 @@ BrowserHistory.prototype.forward = function(steps) {
     return this.arr[tmp]
   }
 };
-
-/** 
- * Your BrowserHistory object will be instantiated and called as such:
- * var obj = new BrowserHistory(homepage)
- * obj.visit(url)
- * var param_2 = obj.back(steps)
- * var param_3 = obj.forward(steps)
- */

From 762c1885f94b85fb81153a9fe951db5bb3a2f5ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Apr 2021 20:39:09 +0800
Subject: [PATCH 1292/3374] Update 329-longest-increasing-path-in-a-matrix.js

---
 329-longest-increasing-path-in-a-matrix.js | 57 +++++++++++++---------
 1 file changed, 34 insertions(+), 23 deletions(-)

diff --git a/329-longest-increasing-path-in-a-matrix.js b/329-longest-increasing-path-in-a-matrix.js
index 68f65262..c71b8477 100644
--- a/329-longest-increasing-path-in-a-matrix.js
+++ b/329-longest-increasing-path-in-a-matrix.js
@@ -2,32 +2,43 @@
  * @param {number[][]} matrix
  * @return {number}
  */
-const longestIncreasingPath = function(matrix) {
-  if (matrix.length === 0) return 0
-  let max = 1
-  const rows = matrix.length
-  const cols = matrix[0].length
-  const cache = Array.from({ length: rows }, () => new Array(cols).fill(0))
-  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < cols; j++) {
-      let len = dfs(matrix, i, j, rows, cols, cache, dirs)
-      max = Math.max(max, len)
+const longestIncreasingPath = function (matrix) {
+  const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+  const m = matrix.length,
+    n = matrix[0].length
+  let res = 1
+  const memo = Array.from({ length: m }, () => Array(n).fill(0))
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const tmp = dfs(matrix, i, j, m, n, memo, dirs)
+      res = Math.max(tmp, res)
     }
   }
-  return max
+  return res
 }
 
-function dfs(matrix, i, j, rows, cols, cache, dirs) {
-  if (cache[i][j] !== 0) return cache[i][j]
-  let max = 1
-  for (let dir of dirs) {
-    let ii = i + dir[0]
-    let jj = j + dir[1]
-    if (ii < 0 || ii >= rows || jj < 0 || jj >= cols || matrix[ii][jj] <= matrix[i][j]) continue
-    let len = 1 + dfs(matrix, ii, jj, rows, cols, cache, dirs)
-    max = Math.max(len, max)
+function dfs(matrix, i, j, m, n, memo, dirs) {
+  if (memo[i][j] !== 0) return memo[i][j]
+  let res = 1
+  for (let [dx, dy] of dirs) {
+    const nx = i + dx,
+      ny = j + dy
+    if (
+      nx < 0 ||
+      nx >= m ||
+      ny < 0 ||
+      ny >= n ||
+      matrix[nx][ny] <= matrix[i][j]
+    )
+      continue
+    const tmp = 1 + dfs(matrix, nx, ny, m, n, memo, dirs)
+    res = Math.max(res, tmp)
   }
-  cache[i][j] = max
-  return max
+  memo[i][j] = res
+  return res
 }

From 82273c5056660af1897bf7951a809ef97eb78400 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 10:55:49 +0800
Subject: [PATCH 1293/3374] Create
 987-vertical-order-traversal-of-a-binary-tree.js

---
 ...rtical-order-traversal-of-a-binary-tree.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 987-vertical-order-traversal-of-a-binary-tree.js

diff --git a/987-vertical-order-traversal-of-a-binary-tree.js b/987-vertical-order-traversal-of-a-binary-tree.js
new file mode 100644
index 00000000..5dbc84f0
--- /dev/null
+++ b/987-vertical-order-traversal-of-a-binary-tree.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number[][]}
+ */
+const verticalTraversal = function(root) {
+  const arr = []
+  helper(root, 0, 0, arr)
+  arr.sort((a, b) => a[0] - b[0] || b[1] - a[1] || a[2] - b[2])
+  const res = new Map()
+
+  for(let [x, y, val] of arr) {
+    if(!res.has(x)) res.set(x, [])
+    res.get(x).push(val)
+  }
+  return [...res.values()]
+};
+
+function helper(node, x, y, arr) {
+  if(node) {
+    helper(node.left, x - 1, y - 1, arr)
+    arr.push([x, y, node.val])
+    helper(node.right, x  + 1, y - 1, arr)
+  }
+}

From b80c50c72d0c534c6c04750e4331063aa52a38ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 12:32:03 +0800
Subject: [PATCH 1294/3374] Update 84-largest-rectangle-in-histogram.js

---
 84-largest-rectangle-in-histogram.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/84-largest-rectangle-in-histogram.js b/84-largest-rectangle-in-histogram.js
index d1f094f9..a05263fe 100644
--- a/84-largest-rectangle-in-histogram.js
+++ b/84-largest-rectangle-in-histogram.js
@@ -58,3 +58,24 @@ const largestRectangleArea = function(heights) {
   }
   return max;
 };
+
+// another
+
+/**
+ * @param {number[]} heights
+ * @return {number}
+ */
+const largestRectangleArea = function(heights) {
+  heights.push(0)
+  const st = [], n = heights.length
+  let res = 0
+  for(let i = 0; i <= n; i++) {
+    while(st.length && heights[st[st.length - 1]] >= heights[i]) {
+      const top = st.pop()
+      const pre = st.length ? st[st.length - 1] : -1
+      res = Math.max(res, heights[top] * (i - pre - 1))
+    }
+    st.push(i)
+  }
+  return res
+};

From 86fb8c6df995daae548e06f347a7be0fa4c908d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 13:49:11 +0800
Subject: [PATCH 1295/3374] Create
 1353-maximum-number-of-events-that-can-be-attended.js

---
 ...m-number-of-events-that-can-be-attended.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1353-maximum-number-of-events-that-can-be-attended.js

diff --git a/1353-maximum-number-of-events-that-can-be-attended.js b/1353-maximum-number-of-events-that-can-be-attended.js
new file mode 100644
index 00000000..c5bedaad
--- /dev/null
+++ b/1353-maximum-number-of-events-that-can-be-attended.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+function maxEvents(events) {
+  events.sort(([, aEnd], [, bEnd]) => aEnd - bEnd);
+  const lastDay = events[events.length - 1][1];
+  const segmentTree = new SegmentTree(Array.from({ length: lastDay }, (_, i) => i), Infinity, (a, b) => Math.min(a, b));
+  let daysAttended = 0;
+
+  for (const [start, end] of events) {
+    // earliest attendable day
+    const ead = segmentTree.queryIn(start - 1, end);
+    if (ead <= end) {
+      daysAttended += 1;
+      segmentTree.setAt(ead, Infinity);
+    }
+  }
+
+  return daysAttended;
+}
+
+// https://github.com/axross/complex-data-structures
+// new SegmentTree(values, identity, associate)
+//     segmentTree.getAt(i)
+//     segmentTree.queryIn(from, to)
+//     segmentTree.setAt(i, value)
+//     segmentTree.length
+class SegmentTree{constructor(t,e,s){if(this.valueLength=t.length,this.identity=e,this.associate=s,0===t.length)this.tree=[];else{const h=2**Math.ceil(Math.log2(t.length))*2-1,i=[];for(let s=0;s<=h>>1;++s)i[(h>>1)+s]=s<t.length?t[s]:e;for(let t=(h>>1)-1;t>=0;--t)i[t]=s(i[2*t+1],i[2*t+2]);this.tree=i}}get length(){return this.valueLength}getAt(t){return this.tree[t+(this.tree.length>>1)]}queryIn(t,e){let s=this.identity;const h=[[0,0,1+(this.tree.length>>1)]];for(;h.length>0;){const[i,r,n]=h.pop();r>=t&&n<=e?s=this.associate(s,this.tree[i]):r>=e||n<t||i>this.tree.length>>1||h.push([2*i+1,r,r+n>>1],[2*i+2,r+n>>1,n])}return s}setAt(t,e){const s=t+(this.tree.length>>1);this.tree[s]=e;let h=s-1>>1;for(;h>=0;)this.tree[h]=this.associate(this.tree[2*h+1],this.tree[2*h+2]),h=h-1>>1}}

From 6016beec42726321f64448a2f1c878e846bc9ecd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 14:02:20 +0800
Subject: [PATCH 1296/3374] Update
 1353-maximum-number-of-events-that-can-be-attended.js

---
 ...m-number-of-events-that-can-be-attended.js | 100 ++++++++++++++++++
 1 file changed, 100 insertions(+)

diff --git a/1353-maximum-number-of-events-that-can-be-attended.js b/1353-maximum-number-of-events-that-can-be-attended.js
index c5bedaad..205a96c5 100644
--- a/1353-maximum-number-of-events-that-can-be-attended.js
+++ b/1353-maximum-number-of-events-that-can-be-attended.js
@@ -1,3 +1,103 @@
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+function maxEvents(events) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  
+  events.sort((a, b) => a[0] - b[0])
+  let i = 0, res = 0, d = 0, n = events.length
+
+  while(!pq.isEmpty() || i < n) {
+    if(pq.isEmpty()) {
+      d = events[i][0]
+    }
+    while(i < n && events[i][0] <= d) {
+      pq.push(events[i++][1])
+    }
+    pq.pop()
+    res++
+    d++
+    while(!pq.isEmpty() && pq.peek() < d) {
+      pq.pop()
+    }
+  }
+
+  return res
+}
+
+
+// another
+
+
+
 /**
  * @param {number[][]} events
  * @return {number}

From 14fdbd2a3228b90c1083c7ed848bd0dbd320f013 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 14:47:54 +0800
Subject: [PATCH 1297/3374] Update
 1353-maximum-number-of-events-that-can-be-attended.js

---
 ...m-number-of-events-that-can-be-attended.js | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/1353-maximum-number-of-events-that-can-be-attended.js b/1353-maximum-number-of-events-that-can-be-attended.js
index 205a96c5..58ec8b08 100644
--- a/1353-maximum-number-of-events-that-can-be-attended.js
+++ b/1353-maximum-number-of-events-that-can-be-attended.js
@@ -94,6 +94,99 @@ function maxEvents(events) {
 }
 
 
+// another
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+function maxEvents(events) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  events.sort((a, b) => a[0] - b[0])
+  let res = 0, i = 0, n = events.length
+  for(let d = 1; d <= 100000; d++) {
+    while(i < n && events[i][0] === d) {
+      pq.push(events[i++][1])
+    }
+    while(!pq.isEmpty() && pq.peek() < d) {
+      pq.pop()
+    }
+    if(!pq.isEmpty()) {
+      res++
+      pq.pop()
+    }
+  }
+  return res
+}
+
+
 // another
 
 

From 78b0f1ac7912de4d51b13061b285a80136a37cc4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 14:59:54 +0800
Subject: [PATCH 1298/3374] Create 1448-count-good-nodes-in-binary-tree.js

---
 1448-count-good-nodes-in-binary-tree.js | 31 +++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1448-count-good-nodes-in-binary-tree.js

diff --git a/1448-count-good-nodes-in-binary-tree.js b/1448-count-good-nodes-in-binary-tree.js
new file mode 100644
index 00000000..120036d0
--- /dev/null
+++ b/1448-count-good-nodes-in-binary-tree.js
@@ -0,0 +1,31 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const goodNodes = function(root) {
+  if(root == null) return 0
+  let res = 0
+
+  helper(root, root.val)
+
+  return res
+  
+  function helper(node, max) {
+    if(node == null) return
+    if(node.val >= max) {
+      res++
+      max = node.val
+    }
+    helper(node.left, max)
+    helper(node.right, max)
+  }
+};

From f0fe6e50a8976ccbf11658392bbe68dc35ac0fa6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 15:39:08 +0800
Subject: [PATCH 1299/3374] Create 983-minimum-cost-for-tickets.js

---
 983-minimum-cost-for-tickets.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 983-minimum-cost-for-tickets.js

diff --git a/983-minimum-cost-for-tickets.js b/983-minimum-cost-for-tickets.js
new file mode 100644
index 00000000..92f6ce27
--- /dev/null
+++ b/983-minimum-cost-for-tickets.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} days
+ * @param {number[]} costs
+ * @return {number}
+ */
+const mincostTickets = function(days, costs) {
+  const last7 = [], last30 = []
+  let res = 0
+  for(let d of days) {
+    while(last7.length && last7[0][0] + 7 <= d) last7.pop()
+    while(last30.length && last30[0][0] + 30 <= d) last30.pop()
+    last7.push([d, res  + costs[1]])
+    last30.push([d, res + costs[2]])
+    res = Math.min(res + costs[0], last7[0][1], last30[0][1])
+  }
+  return res
+};

From 97871edde99df845c16e625002aaec351b4017d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 17:11:38 +0800
Subject: [PATCH 1300/3374] Create 1314-matrix-block-sum.js

---
 1314-matrix-block-sum.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1314-matrix-block-sum.js

diff --git a/1314-matrix-block-sum.js b/1314-matrix-block-sum.js
new file mode 100644
index 00000000..bf8a69f1
--- /dev/null
+++ b/1314-matrix-block-sum.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} k
+ * @return {number[][]}
+ */
+const matrixBlockSum = function(mat, k) {
+  const m = mat.length, n = mat[0].length
+  const rangeSum = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      rangeSum[i + 1][j + 1] = rangeSum[i + 1][j] + rangeSum[i][j + 1] - rangeSum[i][j] + mat[i][j]
+    }
+  }
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      let r1 = Math.max(0, i - k), c1 = Math.max(0, j - k)
+      let r2 = Math.min(m, i + k + 1), c2 = Math.min(n, j + k + 1)
+      res[i][j] = rangeSum[r2][c2] - rangeSum[r2][c1] - rangeSum[r1][c2] + rangeSum[r1][c1]
+    }
+  }
+
+  return res
+};

From b9ea32806fba264a22b969066e650ca57289af83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 20:01:49 +0800
Subject: [PATCH 1301/3374] Create 950-reveal-cards-in-increasing-order.js

---
 950-reveal-cards-in-increasing-order.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 950-reveal-cards-in-increasing-order.js

diff --git a/950-reveal-cards-in-increasing-order.js b/950-reveal-cards-in-increasing-order.js
new file mode 100644
index 00000000..d25244e7
--- /dev/null
+++ b/950-reveal-cards-in-increasing-order.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} deck
+ * @return {number[]}
+ */
+const deckRevealedIncreasing = function(deck) {
+  const n= deck.length;
+
+  deck.sort((a, b) => a - b)
+  const q = [];
+  for (let i=0; i<n; i++) q.push(i);
+  const res = new Array(n).fill(0);
+  for (let i=0; i<n; i++){
+    res[q.shift()]=deck[i];
+    q.push(q.shift());
+  }
+  return res;
+};

From 8128f9f05757d19df590180c84d9d2d72e1f706c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Apr 2021 21:05:28 +0800
Subject: [PATCH 1302/3374] Update 489-robot-room-cleaner.js

---
 489-robot-room-cleaner.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/489-robot-room-cleaner.js b/489-robot-room-cleaner.js
index 38c82566..b1c55cef 100644
--- a/489-robot-room-cleaner.js
+++ b/489-robot-room-cleaner.js
@@ -63,3 +63,39 @@ const cleanRoom = function(robot) {
     }
   }
 }
+
+// another
+
+/**
+ * @param {Robot} robot
+ * @return {void}
+ */
+const cleanRoom = function(robot) {
+  const dirs = [
+    [-1, 0],
+    [0, 1],
+    [1, 0],
+    [0, -1]
+  ]
+  const visited = new Set()
+  clean(0, 0, 0)
+  function clean( x, y, curDirection) {
+    robot.clean()
+    visited.add(`${x},${y}`)
+    for(let i = curDirection; i < curDirection + 4; i++) {
+      const nx = dirs[i % 4][0] + x
+      const ny = dirs[i % 4][1] + y
+      if(!visited.has(`${nx},${ny}`) && robot.move()) {
+        clean(nx, ny, i % 4)
+      }
+      robot.turnRight()
+    }
+    robot.turnRight()
+    robot.turnRight()
+    robot.move()
+    robot.turnRight()
+    robot.turnRight()
+    
+  }
+};
+

From 1c1a5eb2a6679e0b80ab8de31248caa390247992 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 09:36:20 +0800
Subject: [PATCH 1303/3374] Update 701-insert-into-a-binary-search-tree.js

---
 701-insert-into-a-binary-search-tree.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/701-insert-into-a-binary-search-tree.js b/701-insert-into-a-binary-search-tree.js
index 7cb0ac51..f6b8a655 100644
--- a/701-insert-into-a-binary-search-tree.js
+++ b/701-insert-into-a-binary-search-tree.js
@@ -44,3 +44,25 @@ const insertIntoBST = function(root, val) {
     }
     return root;
 }; 
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} val
+ * @return {TreeNode}
+ */
+const insertIntoBST = function(root, val) {
+  if(root == null) return new TreeNode(val)
+  if(val < root.val) root.left = insertIntoBST(root.left, val)
+  else if(val > root.val) root.right = insertIntoBST(root.right, val)
+  return root
+};

From f761ca068e1cb2980ff6a560542ece1bf0a357e8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 11:13:02 +0800
Subject: [PATCH 1304/3374] Create 1396-count-number-of-teams.js

---
 1396-count-number-of-teams.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1396-count-number-of-teams.js

diff --git a/1396-count-number-of-teams.js b/1396-count-number-of-teams.js
new file mode 100644
index 00000000..0eda5130
--- /dev/null
+++ b/1396-count-number-of-teams.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} rating
+ * @return {number}
+ */
+const numTeams = function(rating) {
+  let res = 0
+  for(let i = 1, n = rating.length; i < n - 1; i++) {
+    const less = Array(2).fill(0), greater = Array(2).fill(0)
+    for(let j = 0; j < n; j++) {
+      if(rating[i] > rating[j]) {
+        less[j < i ? 0 : 1]++
+      }
+      if(rating[i] < rating[j]) {
+        greater[j > i ? 0 : 1]++
+      }
+    }
+    res += less[0] * greater[0] + less[1] * greater[1]
+  }
+  return res
+};

From b87194f9e7d37193252104c01c9e6075be2f3f83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 13:57:21 +0800
Subject: [PATCH 1305/3374] Create 1395-count-number-of-teams.js

---
 1395-count-number-of-teams.js | 64 +++++++++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 1395-count-number-of-teams.js

diff --git a/1395-count-number-of-teams.js b/1395-count-number-of-teams.js
new file mode 100644
index 00000000..076cd0ff
--- /dev/null
+++ b/1395-count-number-of-teams.js
@@ -0,0 +1,64 @@
+/**
+ * @param {number[]} rating
+ * @return {number}
+ */
+const numTeams = function(rating) {
+  let res = 0
+  for(let i = 1, n = rating.length; i < n - 1; i++) {
+    const less = Array(2).fill(0), greater = Array(2).fill(0)
+    for(let j = 0; j < n; j++) {
+      if(rating[i] > rating[j]) {
+        less[j < i ? 0 : 1]++
+      }
+      if(rating[i] < rating[j]) {
+        greater[j > i ? 0 : 1]++
+      }
+    }
+    res += less[0] * greater[0] + less[1] * greater[1]
+  }
+  return res
+};
+
+
+// another
+
+/**
+ * @param {number[]} rating
+ * @return {number}
+ */
+const numTeams = function(rating) {
+  if(rating.length < 3) return 0
+  const n = rating.length
+  const leftTree = Array(1e5 + 1).fill(0)
+  const rightTree = Array(1e5 + 1).fill(0)
+  for(let r of rating) update(rightTree, r, 1)
+  let res = 0
+  for(let r of rating) {
+    update(rightTree, r,  -1)
+    res += getPrefixSum(leftTree, r - 1) * getSuffixSum(rightTree, r + 1)
+    res += getSuffixSum(leftTree, r + 1) * getPrefixSum(rightTree, r - 1)
+    update(leftTree, r, 1)
+  }
+
+  return res
+};
+
+function update(bit, index, val) {
+  while(index < bit.length) {
+    bit[index] += val
+    index += index & (-index)
+  }
+}
+
+function getPrefixSum(bit, index) {
+  let res = 0
+  while(index > 0) {
+    res += bit[index]
+    index -= index & (-index)
+  }
+  return res
+}
+
+function  getSuffixSum(bit, index) {
+  return getPrefixSum(bit, 1e5) - getPrefixSum(bit, index - 1)
+}

From 6a3f0c26a98d8b5ee4d86dfc7b1a270d876c5612 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 14:30:28 +0800
Subject: [PATCH 1306/3374] Update 347-top-k-frequent-elements.js

---
 347-top-k-frequent-elements.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/347-top-k-frequent-elements.js b/347-top-k-frequent-elements.js
index 2acf9413..d7f8a6c5 100755
--- a/347-top-k-frequent-elements.js
+++ b/347-top-k-frequent-elements.js
@@ -66,3 +66,34 @@ const topKFrequent = function(nums, k) {
   return res
 };
 
+// another
+
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+ const topKFrequent = function(nums, k) {
+  const n = nums.length
+  const freq = Array(n + 1).fill(null)
+  const hash = {}
+  for(let e of nums) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  for(let k in hash) {
+    if(hash.hasOwnProperty(k)) {
+      const v = hash[k]
+      if(freq[v] == null) freq[v] = []
+      freq[v].push(k)
+    }
+  }
+  const res = []
+  for(let i = n; i >= 0; i--) {
+    if(freq[i] != null) res.push(...freq[i])
+    if(res.length >= k) break
+  }
+  if(res.length > k) res.slice(k)
+  return res
+};

From d0de465a79f7fc4f4a0b85aecf42338f05e97227 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 14:31:40 +0800
Subject: [PATCH 1307/3374] Update 347-top-k-frequent-elements.js

---
 347-top-k-frequent-elements.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/347-top-k-frequent-elements.js b/347-top-k-frequent-elements.js
index d7f8a6c5..5a59bc3f 100755
--- a/347-top-k-frequent-elements.js
+++ b/347-top-k-frequent-elements.js
@@ -94,6 +94,6 @@ const topKFrequent = function(nums, k) {
     if(freq[i] != null) res.push(...freq[i])
     if(res.length >= k) break
   }
-  if(res.length > k) res.slice(k)
+  if(res.length > k) res.splice(k)
   return res
 };

From 8bd1a0a0eb0d2a775fd313bcd8a6d8387e13e3cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Apr 2021 15:40:05 +0800
Subject: [PATCH 1308/3374] Update 72-edit-distance.js

---
 72-edit-distance.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/72-edit-distance.js b/72-edit-distance.js
index a9a30af8..f9e41c89 100644
--- a/72-edit-distance.js
+++ b/72-edit-distance.js
@@ -23,3 +23,32 @@ const minDistance = function(word1, word2) {
     }
     return dp[m][n];
 };
+
+// another
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const minDistance = function(word1, word2) {
+  const m = word1.length, n = word2.length
+  const dp = Array(n + 1).fill(0)
+  for(let i = 1; i <= n; i++) dp[i] = i 
+  let pre = 0
+  for(let i = 1; i <= m; i++) {
+    pre = dp[0]
+    dp[0] = i
+    for(let j = 1; j <= n; j++) {
+      let tmp = dp[j]
+      if(word1[i - 1] === word2[j - 1]) {
+        dp[j] = pre
+      } else {
+        dp[j] = Math.min(pre, dp[j],  dp[j - 1]) + 1
+      }
+      pre = tmp
+    }
+  }
+
+  return dp[n]
+};

From cead5ef65e9b014a47e4d5235782b273a6a56c18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Apr 2021 00:30:33 +0800
Subject: [PATCH 1309/3374] Update 47-permutations-ii.js

---
 47-permutations-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/47-permutations-ii.js b/47-permutations-ii.js
index 47d28267..02337a11 100644
--- a/47-permutations-ii.js
+++ b/47-permutations-ii.js
@@ -29,3 +29,36 @@ function permuteUniqueHelper(m, l, p, i, r) {
     }
   }
 }
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const permuteUnique = function(nums) {
+  const set = new Set()
+  const used = new Set()
+  bt(nums, 0, [], used, set)
+  const res = []
+  for(let item of set) {
+    res.push(item.split(','))
+  }
+  return res
+};
+
+function bt(nums, i, cur, used, set) {
+  if(i === nums.length) {
+    set.add(cur.slice().join(','))
+    return
+  }
+  for(let idx = 0; idx < nums.length; idx++) {
+    if(used.has(idx)) continue
+    cur.push(nums[idx])
+    used.add(idx)
+    bt(nums, i + 1, cur, used, set)
+    used.delete(idx)
+    cur.pop()
+  }
+}

From 1e05a216101ba334001bd6ce19ef9d36be7f31d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Apr 2021 16:21:26 +0800
Subject: [PATCH 1310/3374] Create 932-beautiful-array.js

---
 932-beautiful-array.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 932-beautiful-array.js

diff --git a/932-beautiful-array.js b/932-beautiful-array.js
new file mode 100644
index 00000000..a0e5d999
--- /dev/null
+++ b/932-beautiful-array.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} N
+ * @return {number[]}
+ */
+const beautifulArray = function(N) {
+  let res = [];
+  res.push(1);
+  while (res.length < N) {
+    const tmp = [];
+    for (let i of res) if (i * 2 - 1 <= N) tmp.push(i * 2 - 1);
+    for (let i of res) if (i * 2 <= N) tmp.push(i * 2);
+    res = tmp;
+  }
+  return res;
+};

From ada3d370614381100b90d1ee13a6d96050a72751 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Apr 2021 11:17:23 +0800
Subject: [PATCH 1311/3374] Update 1564-put-boxes-into-the-warehouse-i.js

---
 1564-put-boxes-into-the-warehouse-i.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1564-put-boxes-into-the-warehouse-i.js b/1564-put-boxes-into-the-warehouse-i.js
index 5638d57a..d3d07cf3 100644
--- a/1564-put-boxes-into-the-warehouse-i.js
+++ b/1564-put-boxes-into-the-warehouse-i.js
@@ -15,3 +15,24 @@ const maxBoxesInWarehouse = function(boxes, warehouse) {
   }
   return j
 };
+
+// another
+
+/**
+ * @param {number[]} boxes
+ * @param {number[]} warehouse
+ * @return {number}
+ */
+const maxBoxesInWarehouse = function(boxes, warehouse) {
+  if(warehouse == null || warehouse.length === 0) return 0
+  const m = boxes.length, n = warehouse.length
+  for(let i = 1; i < n; i++) {
+    warehouse[i] = Math.min(warehouse[i], warehouse[i - 1])
+  }
+  boxes.sort((a, b) => a - b)
+  let res = 0
+  for(let i = n - 1; i >= 0; i--) {
+    if(res < m && boxes[res] <= warehouse[i]) res++
+  }
+  return res
+};

From b7ed6efd004d02267a24c28885d86bb0c9326e53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Apr 2021 11:33:34 +0800
Subject: [PATCH 1312/3374] Update 1564-put-boxes-into-the-warehouse-i.js

---
 1564-put-boxes-into-the-warehouse-i.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1564-put-boxes-into-the-warehouse-i.js b/1564-put-boxes-into-the-warehouse-i.js
index d3d07cf3..cf4ca8e3 100644
--- a/1564-put-boxes-into-the-warehouse-i.js
+++ b/1564-put-boxes-into-the-warehouse-i.js
@@ -36,3 +36,24 @@ const maxBoxesInWarehouse = function(boxes, warehouse) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} boxes
+ * @param {number[]} warehouse
+ * @return {number}
+ */
+const maxBoxesInWarehouse = function(boxes, warehouse) {
+  if(warehouse == null || warehouse.length === 0) return 0
+  const m = boxes.length, n = warehouse.length
+  boxes.sort((a, b) => a - b)
+  let i = m - 1, res = 0
+  for(let house of warehouse) {
+    while(i >= 0 && boxes[i] > house) i--
+    if(i === -1) return res
+    res++
+    i--
+  }
+  return res
+};

From ac87e3543e9a83cf2ffb39cdfac21813b22228b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Apr 2021 20:58:10 +0800
Subject: [PATCH 1313/3374] Update 233-number-of-digit-one.js

---
 233-number-of-digit-one.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/233-number-of-digit-one.js b/233-number-of-digit-one.js
index b2c568e7..938403e6 100644
--- a/233-number-of-digit-one.js
+++ b/233-number-of-digit-one.js
@@ -37,3 +37,31 @@ const countDigitOne = function (n) {
   return ones
 }
 
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countDigitOne = function(n) {
+  let res = 0, factor = 1, lower = 0, cur = 0, higher = 0
+  while(~~(n / factor) !== 0) {
+    lower = n - (~~(n / factor)) * factor
+    cur = (~~(n / factor)) % 10
+    higher = ~~(n / (factor * 10))
+    switch(cur) {
+      case 0:
+        res += higher * factor
+        break
+      case 1:
+        res += higher * factor + lower + 1
+        break
+      default:
+        res += (higher + 1) * factor
+        break
+    }
+    factor *= 10
+  }
+  
+  return res
+};

From 3a07eb40b6804003c586173c5887b9be605b6331 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 10:02:27 +0800
Subject: [PATCH 1314/3374] Create 1476-subrectangle-queries.js

---
 1476-subrectangle-queries.js | 39 ++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1476-subrectangle-queries.js

diff --git a/1476-subrectangle-queries.js b/1476-subrectangle-queries.js
new file mode 100644
index 00000000..fa046b59
--- /dev/null
+++ b/1476-subrectangle-queries.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} rectangle
+ */
+const SubrectangleQueries = function(rectangle) {
+  this.rect = rectangle
+  this.ops = []
+};
+
+/** 
+ * @param {number} row1 
+ * @param {number} col1 
+ * @param {number} row2 
+ * @param {number} col2 
+ * @param {number} newValue
+ * @return {void}
+ */
+SubrectangleQueries.prototype.updateSubrectangle = function(row1, col1, row2, col2, newValue) {
+  this.ops.push([row1, col1, row2, col2, newValue])
+};
+
+/** 
+ * @param {number} row 
+ * @param {number} col
+ * @return {number}
+ */
+SubrectangleQueries.prototype.getValue = function(row, col) {
+  for(let i = this.ops.length - 1; i >= 0; i--) {
+    const op = this.ops[i]
+    if(op[0] <= row && op[1] <= col && row <= op[2] && col <= op[3]) return op[4]
+  }
+  return this.rect[row][col]
+};
+
+/** 
+ * Your SubrectangleQueries object will be instantiated and called as such:
+ * var obj = new SubrectangleQueries(rectangle)
+ * obj.updateSubrectangle(row1,col1,row2,col2,newValue)
+ * var param_2 = obj.getValue(row,col)
+ */

From 3cfe48ce70fbd7f4b0b13aa903d46a2f6364b05b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 12:46:08 +0800
Subject: [PATCH 1315/3374] Create 1834-single-threaded-cpu.js

---
 1834-single-threaded-cpu.js | 102 ++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 1834-single-threaded-cpu.js

diff --git a/1834-single-threaded-cpu.js b/1834-single-threaded-cpu.js
new file mode 100644
index 00000000..5e86d910
--- /dev/null
+++ b/1834-single-threaded-cpu.js
@@ -0,0 +1,102 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number[]}
+ */
+const getOrder = function(tasks) {
+  const pq = new PriorityQueue(compare), n = tasks.length
+  const res = []
+  let time = 0, i = 0
+  for(let i = 0; i < n; i++) tasks[i].push(i)
+  tasks.sort((a, b) => a[0] - b[0])
+  
+  while(i < n || !pq.isEmpty()) {
+    if(pq.isEmpty()) {
+      time = Math.max(time, tasks[i][0])
+    }
+    while(i < n && time >= tasks[i][0]) {
+      pq.push([tasks[i][1], tasks[i][2]])
+      i++
+    }
+    const [dur, idx] = pq.pop()
+    time += dur
+    res.push(idx)
+  }
+
+  return res
+};
+
+function compare(a, b) {
+  if(a[0] < b[0]) return true
+  else if (a[0] > b[0]) return false
+  else {
+    return a[1] < b[1]
+  }
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From a39deffb3d0251ccfa8c1d72069f1eccc00df752 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 12:50:23 +0800
Subject: [PATCH 1316/3374] Create
 1835-find-xor-sum-of-all-pairs-bitwise-and.js

---
 1835-find-xor-sum-of-all-pairs-bitwise-and.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1835-find-xor-sum-of-all-pairs-bitwise-and.js

diff --git a/1835-find-xor-sum-of-all-pairs-bitwise-and.js b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
new file mode 100644
index 00000000..78158a24
--- /dev/null
+++ b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @return {number}
+ */
+const getXORSum = function(arr1, arr2) {
+  const bits = Array(32).fill(0)
+  for (let v of arr2) {
+      let pos = 0;
+      while (v > 0) {
+        if (v & 1) {
+          bits[pos]++;
+        }
+        v = v >> 1;
+        pos++;
+      }
+    }
+
+    let res = 0;
+
+    for (let v of arr1) {
+      let pos = 0;
+      let tmp = 0;
+      while (v > 0) {
+        if (v & 1) {
+          if (bits[pos] % 2 == 1) {
+            tmp |= (1 << pos);
+          }
+        }
+        v = v >> 1;
+        pos++;
+      }
+
+      res ^= tmp;
+    }
+
+    return res;
+};
+

From d0f755b0a3e9658c0da21f26d76f0f5800c93ee7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 13:28:17 +0800
Subject: [PATCH 1317/3374] Update 1834-single-threaded-cpu.js

---
 1834-single-threaded-cpu.js | 109 ++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/1834-single-threaded-cpu.js b/1834-single-threaded-cpu.js
index 5e86d910..ddf36092 100644
--- a/1834-single-threaded-cpu.js
+++ b/1834-single-threaded-cpu.js
@@ -1,3 +1,112 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number[]}
+ */
+const getOrder = function(tasks) {
+  const pq = new PriorityQueue(compare), n = tasks.length
+  const res = []
+  let time = 0, i = 0
+  for(let i = 0; i < n; i++) tasks[i].push(i)
+  tasks.sort((a, b) => a[0] - b[0])
+  
+  time = tasks[0][0]
+  while(i < n || !pq.isEmpty()) {
+    while ((i < n) && (tasks[i][0] <= time)) {
+      pq.push([tasks[i][1], tasks[i][2]])
+      i++
+    }
+    if(!pq.isEmpty()) {
+      const [dur, idx] = pq.pop()
+      time += dur
+      res.push(idx)
+    } else if(i < n) {
+      time = tasks[i][0]
+    }
+
+  }
+
+  return res
+};
+
+function compare(a, b) {
+  if(a[0] < b[0]) return true
+  else if (a[0] > b[0]) return false
+  else {
+    return a[1] < b[1]
+  }
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+
+// another
+
 /**
  * @param {number[][]} tasks
  * @return {number[]}

From bb50c689cde987a9936eb295a34cffbaf9456118 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 14:18:35 +0800
Subject: [PATCH 1318/3374] Create 1832-check-if-the-sentence-is-pangram.js

---
 1832-check-if-the-sentence-is-pangram.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1832-check-if-the-sentence-is-pangram.js

diff --git a/1832-check-if-the-sentence-is-pangram.js b/1832-check-if-the-sentence-is-pangram.js
new file mode 100644
index 00000000..d52d6e67
--- /dev/null
+++ b/1832-check-if-the-sentence-is-pangram.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} sentence
+ * @return {boolean}
+ */
+const checkIfPangram = function(sentence) {
+  const hash = new Map()
+  for(let ch of sentence) {
+    if(!hash.has(ch)) hash.set(ch, 0)
+    hash.set(ch, hash.get(ch) + 1)
+  }
+  return hash.size >= 26
+};

From 1aba0072e420fa5cae8e709571f1c9aa6fcc904c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 14:19:48 +0800
Subject: [PATCH 1319/3374] Create 1833-maximum-ice-cream-bars.js

---
 1833-maximum-ice-cream-bars.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1833-maximum-ice-cream-bars.js

diff --git a/1833-maximum-ice-cream-bars.js b/1833-maximum-ice-cream-bars.js
new file mode 100644
index 00000000..1b6d789b
--- /dev/null
+++ b/1833-maximum-ice-cream-bars.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} costs
+ * @param {number} coins
+ * @return {number}
+ */
+const maxIceCream = function(costs, coins) {
+  costs.sort((a, b) => a - b)
+  let res = 0, idx = 0
+  while(coins >= costs[idx]) {
+    res++
+    coins -= costs[idx++]
+  }
+  
+  return res
+};

From 827515e1343cc3461103865e2e6f31b857abc166 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Apr 2021 14:53:50 +0800
Subject: [PATCH 1320/3374] Update
 1835-find-xor-sum-of-all-pairs-bitwise-and.js

---
 1835-find-xor-sum-of-all-pairs-bitwise-and.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/1835-find-xor-sum-of-all-pairs-bitwise-and.js b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
index 78158a24..bab1cf9a 100644
--- a/1835-find-xor-sum-of-all-pairs-bitwise-and.js
+++ b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
@@ -1,3 +1,6 @@
+// On every bit XOR acts as modulo 2 addition and AND acts as modulo 2 multiplication.
+// The set {0,1} with modulo 2 addition and multiplication is the field GF(2) and the distributive property holds in every field.
+
 /**
  * @param {number[]} arr1
  * @param {number[]} arr2

From ad69750f106d591ae255c87abe7f5b1a87993def Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Apr 2021 12:19:45 +0800
Subject: [PATCH 1321/3374] Update 37-sudoku-solver.js

---
 37-sudoku-solver.js | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/37-sudoku-solver.js b/37-sudoku-solver.js
index 5e20d0a4..dc27ac15 100644
--- a/37-sudoku-solver.js
+++ b/37-sudoku-solver.js
@@ -34,3 +34,46 @@ const solveSudoku = function(board) {
     return true
   }
 }
+
+
+// another
+
+/**
+ * @param {character[][]} board
+ * @return {void} Do not return anything, modify board in-place instead.
+ */
+const solveSudoku = function(board) {
+  helper(board, 0 , 0)
+};
+
+function helper(board, row, col) {
+  for(let i = row, m = board.length; i < m; i++, col = 0) {
+    for(let j = col, n = board[0].length; j < n; j++) {
+      if(board[i][j] !== '.') continue
+      for(let k = 1; k <= 9; k++) {
+        const ch = `${k}`
+        const res = valid(board, i, j, ch)
+        if(res) {
+          board[i][j] = ch
+          if(helper(board, i, j + 1)) return true
+          else {
+            board[i][j] = '.'
+          }
+        }
+      }
+      return false
+    }
+  }
+  return true
+}
+
+
+function valid(board, row, col, ch) {
+  const blkRow = ~~(row / 3), blkCol = ~~(col / 3)
+  for(let i = 0; i < 9; i++) {
+    if(board[row][i] === ch) return false
+    if(board[i][col] === ch) return false
+    if(board[blkRow * 3 + Math.floor(i / 3)][blkCol * 3 + (i % 3)] === ch) return false
+  }
+  return true
+}

From 1dd9b3dbf6098351ea5205071acb66342b707daf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Apr 2021 13:49:55 +0800
Subject: [PATCH 1322/3374] Update 37-sudoku-solver.js

---
 37-sudoku-solver.js | 27 ++++++++++-----------------
 1 file changed, 10 insertions(+), 17 deletions(-)

diff --git a/37-sudoku-solver.js b/37-sudoku-solver.js
index dc27ac15..b057ce6e 100644
--- a/37-sudoku-solver.js
+++ b/37-sudoku-solver.js
@@ -47,27 +47,20 @@ const solveSudoku = function(board) {
 };
 
 function helper(board, row, col) {
-  for(let i = row, m = board.length; i < m; i++, col = 0) {
-    for(let j = col, n = board[0].length; j < n; j++) {
-      if(board[i][j] !== '.') continue
-      for(let k = 1; k <= 9; k++) {
-        const ch = `${k}`
-        const res = valid(board, i, j, ch)
-        if(res) {
-          board[i][j] = ch
-          if(helper(board, i, j + 1)) return true
-          else {
-            board[i][j] = '.'
-          }
-        }
-      }
-      return false
+  if(row >= 9) return true
+  if(col >= 9) return helper(board, row + 1, 0)
+  if(board[row][col] !== '.') return helper(board, row, col + 1)
+  for(let i = 1; i <= 9; i++) {
+    const ch = `${i}`
+    if(valid(board, row, col, ch)) {
+      board[row][col] = ch
+      if(helper(board, row, col + 1)) return true
+      board[row][col] = '.'
     }
   }
-  return true
+  return false
 }
 
-
 function valid(board, row, col, ch) {
   const blkRow = ~~(row / 3), blkCol = ~~(col / 3)
   for(let i = 0; i < 9; i++) {

From 574bc893920e297135c9af1d57bafe6cade4be45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Apr 2021 14:26:05 +0800
Subject: [PATCH 1323/3374] Update 803-bricks-falling-when-hit.js

---
 803-bricks-falling-when-hit.js | 39 ++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/803-bricks-falling-when-hit.js b/803-bricks-falling-when-hit.js
index 40b104c6..d2cda611 100644
--- a/803-bricks-falling-when-hit.js
+++ b/803-bricks-falling-when-hit.js
@@ -157,3 +157,42 @@ class DisjointSet {
   }
 }
 
+// another
+
+/**
+ * @param {number[][]} grid
+ * @param {number[][]} hits
+ * @return {number[]}
+ */
+const hitBricks = function(grid, hits) {
+  const res = Array(hits.length).fill(0), dirs = [-1, 0, 1, 0, -1]
+  for(let [r, c] of hits) {
+    grid[r][c] -= 1
+  }
+  for(let i = 0; i < grid[0].length; i++) {
+    dfs(0, i, grid)
+  }
+  for(let i = hits.length - 1; i >= 0; i--) {
+    const [r, c] = hits[i]
+    grid[r][c] += 1
+    if(grid[r][c] === 1 && isConnected(r, c, grid, dirs)) {
+      res[i] = dfs(r, c, grid) - 1
+    }
+  }
+  return res
+}
+function dfs(i, j, grid) {
+  if(i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] !== 1) return 0
+  grid[i][j] = 2
+  return 1 + dfs(i + 1, j, grid) + dfs(i - 1, j, grid) + dfs(i, j + 1, grid) + dfs(i, j - 1, grid)
+}
+function isConnected(i, j, grid, dirs) {
+  if(i === 0) return true
+  for(let k = 1; k < dirs.length; k++) {
+    const r = i + dirs[k - 1], c = j + dirs[k]
+    if(r >= 0 && r < grid.length && c >= 0 && c < grid[0].length && grid[r][c] === 2) {
+      return true
+    }
+  }
+  return false
+}

From 5aeb5ef8a0caf49bfa8adbf5918467cc71eec881 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Apr 2021 10:22:01 +0800
Subject: [PATCH 1324/3374] Update 31-next-permutation.js

---
 31-next-permutation.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/31-next-permutation.js b/31-next-permutation.js
index 3df5d135..baf10d95 100644
--- a/31-next-permutation.js
+++ b/31-next-permutation.js
@@ -32,3 +32,42 @@ function swap(arr, i, j) {
   arr[j] ^= arr[i];
   arr[i] ^= arr[j];
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+const nextPermutation = function(nums) {
+  const n = nums.length
+  let start, end
+  for(let i = n - 2; i >= 0; i--) {
+    if(nums[i] < nums[i + 1]) {
+      start = i
+      break
+    }
+  }
+  if(start == null) {
+    reverse(nums, 0, n - 1)
+  } else {
+    for(let i = n - 1; i >= 0; i--) {
+      if(nums[i] > nums[start]) {
+        end = i
+        break
+      }
+    }
+    swap(nums, start, end)
+    reverse(nums, start + 1, n - 1)
+  }
+};
+function reverse(arr, start, end) {
+  while(start < end) {
+    swap(arr, start++, end--)
+  }
+}
+function swap(arr, i, j) {
+  const tmp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = tmp
+}

From 888fc68b3d934b7bc2857cc40c51448c2f0a2b85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Apr 2021 11:05:59 +0800
Subject: [PATCH 1325/3374] Update 983-minimum-cost-for-tickets.js

---
 983-minimum-cost-for-tickets.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/983-minimum-cost-for-tickets.js b/983-minimum-cost-for-tickets.js
index 92f6ce27..60c0181e 100644
--- a/983-minimum-cost-for-tickets.js
+++ b/983-minimum-cost-for-tickets.js
@@ -7,9 +7,9 @@ const mincostTickets = function(days, costs) {
   const last7 = [], last30 = []
   let res = 0
   for(let d of days) {
-    while(last7.length && last7[0][0] + 7 <= d) last7.pop()
-    while(last30.length && last30[0][0] + 30 <= d) last30.pop()
-    last7.push([d, res  + costs[1]])
+    while(last7.length && last7[0][0] + 7 <= d) last7.shift()
+    while(last30.length && last30[0][0] + 30 <= d) last30.shift()
+    last7.push([d, res + costs[1]])
     last30.push([d, res + costs[2]])
     res = Math.min(res + costs[0], last7[0][1], last30[0][1])
   }

From 28b2ead3ddbf76125467bc9e969e21844e7528a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Apr 2021 09:21:27 +0800
Subject: [PATCH 1326/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index 5cd3a8fe..a39e485e 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -19,3 +19,37 @@ const getPermutation = function (n, k) {
   }
   return sb
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getPermutation = function(n, k) {
+  let pos = 0
+  const numbers = []
+  const factorial = Array(n + 1).fill(0)
+  let str = ''
+
+  let sum = 1
+  factorial[0] = 1
+
+  for(let i = 1; i <= n; i++) {
+    sum *= i
+    factorial[i] = sum
+  }
+  for(let i = 1; i <= n; i++) {
+    numbers.push(i)
+  }
+  k--
+  for(let i = 1; i <= n; i++) {
+    const idx = ~~(k / factorial[n - i])
+    str += numbers[idx]
+    numbers.splice(idx, 1)
+    k -= idx * factorial[n - i]
+  }
+
+  return str
+};

From b16c8f51add89e77bdb8ad4b867861c82bb7d3d6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Apr 2021 09:53:47 +0800
Subject: [PATCH 1327/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index a39e485e..9711d3d2 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -28,28 +28,24 @@ const getPermutation = function (n, k) {
  * @return {string}
  */
 const getPermutation = function(n, k) {
-  let pos = 0
-  const numbers = []
-  const factorial = Array(n + 1).fill(0)
-  let str = ''
-
-  let sum = 1
+  const factorial = []
+  const nums = []
+  let res = ''
   factorial[0] = 1
-
-  for(let i = 1; i <= n; i++) {
+  for(let i = 1, sum = 1; i <= n; i++) {
     sum *= i
     factorial[i] = sum
   }
   for(let i = 1; i <= n; i++) {
-    numbers.push(i)
+    nums.push(i)
   }
   k--
-  for(let i = 1; i <= n; i++) {
+  for(let i = 0; i <= n; i++) {
     const idx = ~~(k / factorial[n - i])
-    str += numbers[idx]
-    numbers.splice(idx, 1)
+    res += nums[idx]
+    nums.splice(idx, 1)
     k -= idx * factorial[n - i]
   }
 
-  return str
+  return res
 };

From 7e5b79b857e3bd0bd653dca65e738fb93df02e68 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Apr 2021 14:04:03 +0800
Subject: [PATCH 1328/3374] Update 226-invert-binary-tree.js

---
 226-invert-binary-tree.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/226-invert-binary-tree.js b/226-invert-binary-tree.js
index 311f4a05..60a57563 100644
--- a/226-invert-binary-tree.js
+++ b/226-invert-binary-tree.js
@@ -48,3 +48,25 @@ const invertTree = function (root) {
   }
   return root
 }
+
+// anoother
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const invertTree = function(root) {
+  if(root == null) return root
+  let tmp = root.left
+  root.left = invertTree(root.right)
+  root.right = invertTree(tmp)
+  return root
+};

From 5b3180c62090753da8b6a1a29c3350fec38bdda7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Apr 2021 11:33:34 +0800
Subject: [PATCH 1329/3374] Create
 1830-minimum-number-of-operations-to-make-string-sorted.js

---
 ...ber-of-operations-to-make-string-sorted.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1830-minimum-number-of-operations-to-make-string-sorted.js

diff --git a/1830-minimum-number-of-operations-to-make-string-sorted.js b/1830-minimum-number-of-operations-to-make-string-sorted.js
new file mode 100644
index 00000000..e7808cbd
--- /dev/null
+++ b/1830-minimum-number-of-operations-to-make-string-sorted.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const makeStringSorted = function (s) {
+  const mod = BigInt(10 ** 9 + 7),
+    n = s.length
+  const a = 'a'.charCodeAt(0)
+  let ans = 0n
+  const freq = Array(26).fill(0n)
+  for (let c of s) {
+    freq[c.charCodeAt(0) - a]++
+  }
+  const fact = Array(n + 1).fill(1n)
+  for (let i = 1n; i <= n; i++) {
+    fact[i] = (fact[i - 1n] * i) % mod
+  }
+  let l = n
+  for (let c of s) {
+    l--
+    let t = 0n,
+      rev = 1n
+    for (let i = 0; i < 26; i++) {
+      if (i < c.charCodeAt(0) - a) t += freq[i]
+      rev = (rev * fact[freq[i]]) % mod
+    }
+    ans += ((t * fact[l]) % mod) * modpow(rev, mod - 2n)
+    ans %= mod
+    freq[c.charCodeAt(0) - a]--
+  }
+  return Number(ans)
+  function modpow(b, p) {
+    let ans = 1n
+    for (; p; p >>= 1n) {
+      if (p & 1n) ans = (ans * b) % mod
+      b = (b * b) % mod
+    }
+    return ans
+  }
+}

From 5b5c64ac452ad325ba6c1d3dd47b816c42c752ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Apr 2021 12:19:49 +0800
Subject: [PATCH 1330/3374] Update 139-word-break.js

---
 139-word-break.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/139-word-break.js b/139-word-break.js
index c87a8af9..98a84d48 100644
--- a/139-word-break.js
+++ b/139-word-break.js
@@ -51,3 +51,28 @@ const wordBreak = function(s, wordDict) {
 
     return f[len];
 };
+
+
+// another
+
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+const wordBreak = function(s, wordDict) {
+  const set = new Set(wordDict)
+  const dp = Array(s.length + 1).fill(false)
+  dp[0] = true
+  for(let i = 1; i <= s.length; i++) {
+    for(let j = 0; j < i; j++) {
+      if(dp[j] && set.has(s.slice(j, i))) {
+        dp[i] = true
+        break
+      }
+    }
+  }
+  
+  return dp[s.length]
+};
+

From 03ccae90835ca70185bc38be48bba0c686b695dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Apr 2021 15:23:41 +0800
Subject: [PATCH 1331/3374] Update 140-word-break-ii.js

---
 140-word-break-ii.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/140-word-break-ii.js b/140-word-break-ii.js
index e1c6adc3..06f39ff2 100644
--- a/140-word-break-ii.js
+++ b/140-word-break-ii.js
@@ -57,3 +57,35 @@ const wordBreak = function (s, wordDict) {
   const res = dfs(0)
   return res.filter((a) => a.join('') === s).map((a) => a.join(' '))
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {string[]}
+ */
+
+const wordBreak = (s, wordDict) => {
+  const set = new Set(wordDict)
+  return helper(s, 0, set)
+}
+
+function helper(s, idx, dict) {
+  if(idx === s.length) return []
+  const res = []
+  for(let i = idx; i < s.length; i++) {
+    const tmp = s.slice(idx, i + 1)
+    if(dict.has(tmp)) {
+      const arr = helper(s, i + 1, dict)
+      if(i + 1 >= s.length) {
+        res.push(tmp)
+      } else if(arr.length) {
+        for(let e of arr) {
+          res.push(tmp + ' ' + e)
+        }
+      }
+    }
+  }
+  return res
+}

From b11a4f90c77d548c5b884749d33742695269195b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Apr 2021 17:13:31 +0800
Subject: [PATCH 1332/3374] Update 410-split-array-largest-sum.js

---
 410-split-array-largest-sum.js | 41 ++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/410-split-array-largest-sum.js b/410-split-array-largest-sum.js
index 668279b9..a48f3f1e 100644
--- a/410-split-array-largest-sum.js
+++ b/410-split-array-largest-sum.js
@@ -98,3 +98,44 @@ When Largest sum of sub-arrays is in range [6, 15], we can always find a way to
 However, when Largest sum of sub-arrays is in range [5, 5], there is no way to do this.
 This mapped this problem into the second sub-problem. Bool array B here is [5:false, 6:true, 7:true, 8:true, ..., 15:true]. We want to find the index i of the first true in B, which is the answer of this entire question, and by solving the first sub-problem, we have an API that can tell us given an i (Largest sum of sub-arrays), whether B[i] is true (whether we can find a way to cut A to satisfy the constraint). 
  */
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} m
+ * @return {number}
+ */
+const splitArray = (nums, m) => {
+  let max = -Infinity, sum = 0
+  for(let num of nums) {
+    sum += num
+    max = Math.max(max, num)
+  }
+  if (m === 1) return sum
+  let l = max, r = sum
+  while(l < r) {
+    let mid = l + ((r - l) >> 1)
+    if(valid(mid, nums, m)) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  return l
+}
+
+function valid(target, nums, m) {
+  let cnt = 1, sum = 0
+  for(let num of nums) {
+    sum += num
+    if(sum > target) {
+      cnt++
+      sum = num
+      if(cnt > m) return false
+    }
+  }
+
+  return true
+}

From faec736f775dedded92ea8df1ea4762cbfc6e228 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Apr 2021 21:57:27 +0800
Subject: [PATCH 1333/3374] Update 1041-robot-bounded-in-circle.js

---
 1041-robot-bounded-in-circle.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1041-robot-bounded-in-circle.js b/1041-robot-bounded-in-circle.js
index 59b27fb2..65146881 100644
--- a/1041-robot-bounded-in-circle.js
+++ b/1041-robot-bounded-in-circle.js
@@ -34,3 +34,26 @@ const isRobotBounded = function(instructions) {
   }
   return x === 0 && y === 0 || i > 0
 };
+
+// another
+
+/**
+ * @param {string} instructions
+ * @return {boolean}
+ */
+const isRobotBounded = function(instructions) {
+  const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]]
+  let x = 0, y = 0, i = 0
+  for(let ins of instructions) {
+    if(ins === 'G') {
+      const dir = dirs[i]
+      x += dir[0]
+      y += dir[1]
+    } else if(ins === 'L') {
+      i = i - 1 < 0 ? 3 : i - 1 
+    } else if(ins === 'R') {
+      i = i + 1 > 3 ? 0 : i + 1
+    }
+  }
+  return x === 0 && y === 0 || i !== 0
+};

From c3e4c76de14b64ba7175ac0b3e8a1593b2be0cb5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Apr 2021 10:03:38 +0800
Subject: [PATCH 1334/3374] Update 1834-single-threaded-cpu.js

---
 1834-single-threaded-cpu.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1834-single-threaded-cpu.js b/1834-single-threaded-cpu.js
index ddf36092..4a394db0 100644
--- a/1834-single-threaded-cpu.js
+++ b/1834-single-threaded-cpu.js
@@ -209,3 +209,33 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+/**
+ * @param {number[][]} tasks
+ * @return {number[]}
+ */
+const getOrder = function(tasks) {
+  const n = tasks.length
+  const pq = new PriorityQueue((a, b) => a[0] === b[0] ? a[1] < b[1] : a[0] < b[0])
+  tasks.forEach((e, i) => e.push(i))
+  tasks.sort((a, b) => a[0] - b[0])
+  let idx = 0, time = 0
+  const res = []
+
+  while(idx < n || !pq.isEmpty()) {
+    while(idx < n && tasks[idx][0] <= time) {
+      pq.push([tasks[idx][1], task[idx][2]])
+      idx++
+    }
+    if(!pq.isEmpty()) {
+      const tmp = pq.pop()
+      time += tmp[0]
+      res.push(tmp[1])
+    } else if(idx < n) {
+      time = tasks[idx][0]
+    }
+  }
+  return res
+
+};

From 9db2621bba8d5faf64980288d033be42b8f928f2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Apr 2021 22:10:44 +0800
Subject: [PATCH 1335/3374] Update 445-add-two-numbers-II.js

---
 445-add-two-numbers-II.js | 52 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/445-add-two-numbers-II.js b/445-add-two-numbers-II.js
index 65a246ed..ef5c15e6 100755
--- a/445-add-two-numbers-II.js
+++ b/445-add-two-numbers-II.js
@@ -40,3 +40,55 @@ const addTwoNumbers = function(l1, l2) {
 
   return list.val === 0 ? list.next : list;
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  const s1 = [], s2 = []
+  let h1 = l1, h2 = l2
+  while(h1) {
+    s1.push(h1.val)
+    h1 = h1.next
+  }
+  while(h2) {
+    s2.push(h2.val)
+    h2 = h2.next
+  }
+  let inc = false
+  let tail = null
+  while(s1.length || s2.length) {
+    let tmp = 0
+    if(s1.length) tmp += s1.pop()
+    if(s2.length) tmp += s2.pop()
+    if(inc) tmp++
+    if(tmp > 9) {
+      inc = true
+    } else {
+      inc = false
+    }
+    tmp = tmp % 10
+    const cur = new ListNode(tmp)
+    if(tail) cur.next = tail
+    tail = cur
+  }
+  
+  if(inc) {
+    const head = new ListNode(1)
+    head.next = tail
+    return head
+  }
+  return tail
+  
+};

From ff75ccd843c01bedfe5376fd505f4d7627209cd3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Apr 2021 12:11:57 +0800
Subject: [PATCH 1336/3374] Update
 1835-find-xor-sum-of-all-pairs-bitwise-and.js

---
 1835-find-xor-sum-of-all-pairs-bitwise-and.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/1835-find-xor-sum-of-all-pairs-bitwise-and.js b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
index bab1cf9a..8ada2371 100644
--- a/1835-find-xor-sum-of-all-pairs-bitwise-and.js
+++ b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
@@ -40,3 +40,16 @@ const getXORSum = function(arr1, arr2) {
     return res;
 };
 
+// another
+
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @return {number}
+ */
+const getXORSum = function(arr1, arr2) {
+  let x1 = arr1[0], x2 = arr2[0]
+  for(let i = 1; i < arr1.length; i++) x1 ^= arr1[i]
+  for(let i = 1; i < arr2.length; i++) x2 ^= arr2[i]
+  return x1 & x2
+};

From 54e8c900a27d09164b0c40053e43afe79963f404 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Apr 2021 17:35:30 +0800
Subject: [PATCH 1337/3374] Update 295-find-median-from-data-stream.js

---
 295-find-median-from-data-stream.js | 104 ++++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/295-find-median-from-data-stream.js b/295-find-median-from-data-stream.js
index 86c11b55..99487161 100644
--- a/295-find-median-from-data-stream.js
+++ b/295-find-median-from-data-stream.js
@@ -38,3 +38,107 @@ MedianFinder.prototype.findMedian = function() {
  * obj.addNum(num)
  * var param_2 = obj.findMedian()
  */
+
+// another
+
+/**
+ * initialize your data structure here.
+ */
+const MedianFinder = function() {
+  this.minPQ = new PriorityQueue()
+  this.maxPQ = new PriorityQueue((a, b) => a < b)
+};
+
+/** 
+ * @param {number} num
+ * @return {void}
+ */
+MedianFinder.prototype.addNum = function(num) {
+  this.minPQ.push(num)
+  this.maxPQ.push(this.minPQ.pop())
+  if(this.minPQ.size() < this.maxPQ.size()) {
+    this.minPQ.push(this.maxPQ.pop())
+  }
+};
+
+/**
+ * @return {number}
+ */
+MedianFinder.prototype.findMedian = function() {
+  if(this.minPQ.size() > this.maxPQ.size()) return this.minPQ.peek()
+  else return (this.minPQ.peek() + this.maxPQ.peek()) / 2
+};
+
+/** 
+ * Your MedianFinder object will be instantiated and called as such:
+ * var obj = new MedianFinder()
+ * obj.addNum(num)
+ * var param_2 = obj.findMedian()
+ */
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From f29a417bdb04fbf2117f249cb6e7c957a95b9531 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 10:28:48 +0800
Subject: [PATCH 1338/3374] Update 227-basic-calculator-ii.js

---
 227-basic-calculator-ii.js | 40 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/227-basic-calculator-ii.js b/227-basic-calculator-ii.js
index 1aecde43..57be3ffd 100644
--- a/227-basic-calculator-ii.js
+++ b/227-basic-calculator-ii.js
@@ -20,3 +20,43 @@ const calculate = function(s) {
   
   return stack.reduce((ac, e) => ac + e, 0)
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  if(s == null || s.length === 0) return 0
+  let sum = 0, num = 0, op = '+', tmp = 0
+  const stack = []
+  for(let i = 0; i < s.length; i++) {
+    const ch = s[i]
+    const isInt = ch => ch >= '0' && ch <= '9'
+    if(isInt(ch)) {
+      num = num * 10 + (+ch)
+    }
+    if((!isInt(ch) && ch !== ' ') || i === s.length - 1) {
+      if(op === '+') {
+        sum += tmp
+        tmp = num
+      }
+      else if(op === '-') {
+        sum += tmp
+        tmp = - num
+      }
+      else if(op === '*') {
+        tmp *= num
+      }
+      else if(op === '/') {
+        tmp = ~~(tmp / num)
+      }
+      op = ch
+      num = 0
+    }
+
+  }
+
+  return sum + tmp
+}

From 6334a70e42e080767bf55ab224d58058f8623905 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 12:37:36 +0800
Subject: [PATCH 1339/3374] Create
 1838-frequency-of-the-most-frequent-element.js

---
 ...-frequency-of-the-most-frequent-element.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1838-frequency-of-the-most-frequent-element.js

diff --git a/1838-frequency-of-the-most-frequent-element.js b/1838-frequency-of-the-most-frequent-element.js
new file mode 100644
index 00000000..d61b472a
--- /dev/null
+++ b/1838-frequency-of-the-most-frequent-element.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxFrequency = function(nums, k) {
+    let res = 1, i = 0, j;
+    let sum = 0;
+    nums.sort((a,  b) => a - b)
+    for (j = 0; j < nums.length; ++j) {
+        sum += nums[j];
+        while (sum + k < nums[j] * (j - i + 1)) {
+            sum -= nums[i];
+            i += 1;
+        }
+        res = Math.max(res, j - i + 1);
+    }
+    return res;
+};

From 9f49240b64802ad67a612fb668df7b3c1e13b545 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 13:01:07 +0800
Subject: [PATCH 1340/3374] Create 1837-sum-of-digits-in-base-k.js

---
 1837-sum-of-digits-in-base-k.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1837-sum-of-digits-in-base-k.js

diff --git a/1837-sum-of-digits-in-base-k.js b/1837-sum-of-digits-in-base-k.js
new file mode 100644
index 00000000..403174c6
--- /dev/null
+++ b/1837-sum-of-digits-in-base-k.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const sumBase = function(n, k) {
+  let str = n.toString(k)
+  let res = 0
+  for(let ch of str) res += +ch
+  
+  return res
+};

From 2f41916a59c01142a496962c541845e735e3d8c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 13:05:00 +0800
Subject: [PATCH 1341/3374] Create
 1839-longest-substring-of-all-vowels-in-order.js

---
 ...ongest-substring-of-all-vowels-in-order.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1839-longest-substring-of-all-vowels-in-order.js

diff --git a/1839-longest-substring-of-all-vowels-in-order.js b/1839-longest-substring-of-all-vowels-in-order.js
new file mode 100644
index 00000000..d33253ff
--- /dev/null
+++ b/1839-longest-substring-of-all-vowels-in-order.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+function longestBeautifulSubstring(word) {
+  let result = 0,
+    current = 0
+  let currentVowel = "a"
+  const set = new Set()
+  for (let i = 0; i < word.length; i++)
+    if (word.charAt(i) < currentVowel) {
+      set.clear()
+      if (word.charAt(i) == "a") {
+        set.add("a")
+        current = 1
+      } else current = 0
+      currentVowel = "a"
+    } else {
+      current++
+      currentVowel = word.charAt(i)
+      set.add(currentVowel)
+      if (set.size == 5) result = Math.max(result, current)
+    }
+  return result
+}

From 0b35db47d344523e9f82b54ed099c5beac826d1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 13:21:42 +0800
Subject: [PATCH 1342/3374] Create 1840-maximum-building-height.js

---
 1840-maximum-building-height.js | 46 +++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1840-maximum-building-height.js

diff --git a/1840-maximum-building-height.js b/1840-maximum-building-height.js
new file mode 100644
index 00000000..f88b1e2f
--- /dev/null
+++ b/1840-maximum-building-height.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number[][]} restrictions
+ * @return {number}
+ */
+var maxBuilding = function (n, restrictions) {
+  restrictions.sort((a, b) => a[0] - b[0]);
+  let prevInd = 1,
+    prevH = 0;
+  for (let i = 0; i < restrictions.length; i++) {
+    restrictions[i][1] = Math.min(
+      restrictions[i][1],
+      prevH + (restrictions[i][0] - prevInd)
+    );
+    prevInd = restrictions[i][0];
+    prevH = restrictions[i][1];
+  }
+
+  for (let i = restrictions.length - 2; i >= 0; i--) {
+    restrictions[i][1] = Math.min(
+      restrictions[i][1],
+      restrictions[i + 1][1] + (restrictions[i + 1][0] - restrictions[i][0])
+    );
+  }
+
+  let ph = 0,
+    pInd = 1,
+    highest = 0;
+  for (let i = 0; i < restrictions.length; i++) {
+    let ind = restrictions[i][0];
+    let h = restrictions[i][1];
+    if (ph < h) {
+      h = Math.min(h, ph + (ind - pInd));
+
+      let remains = Math.max(0, ind - pInd - (h - ph));
+      highest = Math.max(highest, h + ~~(remains / 2));
+    } else {
+      let remains = ind - pInd - (ph - h);
+      highest = Math.max(highest, ph + ~~(remains / 2));
+    }
+    ph = h;
+    pInd = ind;
+  }
+  highest = Math.max(highest, ph + (n - pInd));
+  return highest;
+};

From 0631ed7785981f5c685221cb3c3b641c0e2af08a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 14:01:54 +0800
Subject: [PATCH 1343/3374] Update
 1838-frequency-of-the-most-frequent-element.js

---
 ...-frequency-of-the-most-frequent-element.js | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/1838-frequency-of-the-most-frequent-element.js b/1838-frequency-of-the-most-frequent-element.js
index d61b472a..de7a8a6c 100644
--- a/1838-frequency-of-the-most-frequent-element.js
+++ b/1838-frequency-of-the-most-frequent-element.js
@@ -3,17 +3,17 @@
  * @param {number} k
  * @return {number}
  */
-var maxFrequency = function(nums, k) {
-    let res = 1, i = 0, j;
-    let sum = 0;
-    nums.sort((a,  b) => a - b)
-    for (j = 0; j < nums.length; ++j) {
-        sum += nums[j];
-        while (sum + k < nums[j] * (j - i + 1)) {
-            sum -= nums[i];
-            i += 1;
-        }
-        res = Math.max(res, j - i + 1);
+const maxFrequency = function(nums, k) {
+  let res = 1, i = 0, j = 0, sum = 0
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+  for(j = 0; j < n; j++) {
+    sum += nums[j]
+    while(sum + k < (j - i + 1)  * nums[j]) {
+      sum -= nums[i]
+      i++
     }
-    return res;
+    res = Math.max(res, j - i + 1)
+  } 
+  return res
 };

From 6fd5ea7daed988999762984ec17e943a9a540f45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Apr 2021 14:44:58 +0800
Subject: [PATCH 1344/3374] Update
 1839-longest-substring-of-all-vowels-in-order.js

---
 ...ongest-substring-of-all-vowels-in-order.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1839-longest-substring-of-all-vowels-in-order.js b/1839-longest-substring-of-all-vowels-in-order.js
index d33253ff..38cc6578 100644
--- a/1839-longest-substring-of-all-vowels-in-order.js
+++ b/1839-longest-substring-of-all-vowels-in-order.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+function longestBeautifulSubstring(word) {
+  let res = 0, cur = 'a', cnt = 0
+  const set = new Set()
+  for(let ch of word) {
+    if(ch < cur) {
+      set.clear()
+      cnt = 0
+      cur = 'a'
+      if(ch === cur) {
+        cnt++
+        set.add(cur)
+      }
+    } else {
+      cnt++
+      set.add(ch)
+      cur = ch
+      if(set.size === 5) res = Math.max(res, cnt)
+    }
+  }
+  return res
+}
+
+
+// another
+
 /**
  * @param {string} word
  * @return {number}

From 95965ef936aeedad28893cc700d08dab6b9da773 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Apr 2021 19:55:03 +0800
Subject: [PATCH 1345/3374] Update 140-word-break-ii.js

---
 140-word-break-ii.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/140-word-break-ii.js b/140-word-break-ii.js
index 06f39ff2..168e398f 100644
--- a/140-word-break-ii.js
+++ b/140-word-break-ii.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {string[]}
+ */
+const wordBreak = function(s, wordDict) {
+  const set = new Set(wordDict)
+  return helper(s, 0, set)
+};
+
+function helper(str, idx, set) {
+  if(idx === str.length) return []
+  const res = []
+  for(let i = idx; i < str.length; i++) {
+    const tmp = str.slice(idx, i + 1)
+    if(set.has(tmp)) {
+      const arr = helper(str, i + 1, set)
+      if(i === str.length - 1) res.push(tmp)
+      for(let item of arr) {
+        res.push(`${tmp} ${item}`)
+      }
+    }
+  }
+  return res
+}
+
+// another
+
+
 /**
  * @param {string} s
  * @param {string[]} wordDict

From 951ccc148575879c22255fb26578eaa28905ac36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Apr 2021 21:22:35 +0800
Subject: [PATCH 1346/3374] Update 140-word-break-ii.js

---
 140-word-break-ii.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/140-word-break-ii.js b/140-word-break-ii.js
index 168e398f..36070c6a 100644
--- a/140-word-break-ii.js
+++ b/140-word-break-ii.js
@@ -5,25 +5,27 @@
  */
 const wordBreak = function(s, wordDict) {
   const set = new Set(wordDict)
-  return helper(s, 0, set)
+  const map = new Map()
+  return helper(s, 0, set, map)
 };
 
-function helper(str, idx, set) {
+function helper(str, idx, set, map) {
   if(idx === str.length) return []
+  if(map.has(idx)) return map.get(idx)
   const res = []
   for(let i = idx; i < str.length; i++) {
     const tmp = str.slice(idx, i + 1)
     if(set.has(tmp)) {
-      const arr = helper(str, i + 1, set)
+      const arr = helper(str, i + 1, set, map)
       if(i === str.length - 1) res.push(tmp)
       for(let item of arr) {
         res.push(`${tmp} ${item}`)
       }
     }
   }
+  map.set(idx, res)
   return res
 }
-
 // another
 
 

From f1d5e7ddd776c0aa89cb8f9940cc58e88cfc0afe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Apr 2021 22:08:51 +0800
Subject: [PATCH 1347/3374] Update 139-word-break.js

---
 139-word-break.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/139-word-break.js b/139-word-break.js
index 98a84d48..ad37fdf0 100644
--- a/139-word-break.js
+++ b/139-word-break.js
@@ -1,3 +1,34 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+const wordBreak = function(s, wordDict) {
+  const map = new Map()
+  return helper(s, 0, new Set(wordDict), map)
+};
+
+function helper(str, idx, set, map) {
+  if(idx === str.length) return true
+  if(map.has(idx)) return map.get(idx)
+  let res = false
+  for(let i = idx; i < str.length; i++) {
+    const tmp = str.slice(idx, i + 1)
+    if(set.has(tmp)) {
+      const bool = helper(str, i + 1, set, map)
+      if(bool) {
+        res = true
+        break
+      }
+    }
+  }
+  map.set(idx, res)
+  return res
+}
+
+// another
+
+
 /**
  * @param {string} s
  * @param {string[]} wordDict

From 3daa3fcec4d7c9d305f749c0387fdbe093fe3485 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Apr 2021 10:36:12 +0800
Subject: [PATCH 1348/3374] Update
 1838-frequency-of-the-most-frequent-element.js

---
 ...-frequency-of-the-most-frequent-element.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1838-frequency-of-the-most-frequent-element.js b/1838-frequency-of-the-most-frequent-element.js
index de7a8a6c..b57a76f9 100644
--- a/1838-frequency-of-the-most-frequent-element.js
+++ b/1838-frequency-of-the-most-frequent-element.js
@@ -17,3 +17,24 @@ const maxFrequency = function(nums, k) {
   } 
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxFrequency = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let i = 0, sum = 0, res = 1
+  for(let j = 0; j < nums.length; j++) {
+    sum += nums[j]
+    while(sum + k < (j - i + 1) * nums[j]) {
+      sum -= nums[i]
+      i++
+    }
+    res = Math.max(res, j - i + 1)
+  }
+  return res
+};

From 723884085ab6126ef0ffbea55dc364f07ceca298 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Apr 2021 17:17:28 +0800
Subject: [PATCH 1349/3374] Create 1382-balance-a-binary-search-tree.js

---
 1382-balance-a-binary-search-tree.js | 33 ++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1382-balance-a-binary-search-tree.js

diff --git a/1382-balance-a-binary-search-tree.js b/1382-balance-a-binary-search-tree.js
new file mode 100644
index 00000000..5aab1b35
--- /dev/null
+++ b/1382-balance-a-binary-search-tree.js
@@ -0,0 +1,33 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const balanceBST = function(root) {
+  const arr = []
+  inOrder(root, arr)
+  return constructBST(arr, 0, arr.length - 1)
+};
+
+function inOrder(node, arr) {
+  if(node == null) return
+  inOrder(node.left, arr)
+  arr.push(node.val)
+  inOrder(node.right, arr)
+}
+
+function constructBST(arr, start, end) {
+  if(start > end) return null
+  const mid = start + ((end - start) >> 1)
+  const node = new TreeNode(arr[mid])
+  node.left = constructBST(arr, start, mid - 1)
+  node.right = constructBST(arr, mid + 1, end)
+  return node
+}

From d2abe01c0529179d81485ceb0fd1227360250821 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Apr 2021 17:42:57 +0800
Subject: [PATCH 1350/3374] Create
 1290-convert-binary-number-in-a-linked-list-to-integer.js

---
 ...nary-number-in-a-linked-list-to-integer.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1290-convert-binary-number-in-a-linked-list-to-integer.js

diff --git a/1290-convert-binary-number-in-a-linked-list-to-integer.js b/1290-convert-binary-number-in-a-linked-list-to-integer.js
new file mode 100644
index 00000000..f057f346
--- /dev/null
+++ b/1290-convert-binary-number-in-a-linked-list-to-integer.js
@@ -0,0 +1,20 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {number}
+ */
+const getDecimalValue = function(head) {
+  let res = 0
+
+  while(head) {
+    res = res * 2 + head.val
+    head = head.next
+  }
+  return res
+};

From ba609f6cd03100fac70e1ddf53ea0744a1a43db9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Apr 2021 10:07:30 +0800
Subject: [PATCH 1351/3374] Create 1366-rank-teams-by-votes.js

---
 1366-rank-teams-by-votes.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1366-rank-teams-by-votes.js

diff --git a/1366-rank-teams-by-votes.js b/1366-rank-teams-by-votes.js
new file mode 100644
index 00000000..0181a888
--- /dev/null
+++ b/1366-rank-teams-by-votes.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string[]} votes
+ * @return {string}
+ */
+const rankTeams = function(votes) {
+   if (votes.length === 1) return votes[0];
+    const score = new Map(votes[0].split('').map(c => [c, new Array(votes[0].length).fill(0)]));
+    for (s of votes) {
+        for (let i = 0; i < s.length; i++) {
+            score.get(s[i])[i]++;
+        }
+    }
+    return votes[0].split('').sort((a,b) => {
+        for (let i = 0; i < votes[0].length; i++) {
+            if (score.get(a)[i] > score.get(b)[i]) return -1;
+            if (score.get(a)[i] < score.get(b)[i]) return 1;
+        }
+        return a < b ? -1 : 1;
+    }).join('');
+};

From c7798efa92e41299cf256ae1d16d24092ac27fa3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Apr 2021 11:09:58 +0800
Subject: [PATCH 1352/3374] Update 1366-rank-teams-by-votes.js

---
 1366-rank-teams-by-votes.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1366-rank-teams-by-votes.js b/1366-rank-teams-by-votes.js
index 0181a888..ef253262 100644
--- a/1366-rank-teams-by-votes.js
+++ b/1366-rank-teams-by-votes.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string[]} votes
+ * @return {string}
+ */
+const rankTeams = function(votes) {
+  const hash = {}
+  const l = votes[0].length
+  for(let vote of votes) {
+    for(let i = 0; i < l; i++) {
+      const ch = vote[i]
+      if(hash[ch] == null) hash[ch] = Array(l).fill(0)
+      hash[ch][i]++
+    }
+  }
+  const keys = Object.keys(hash)
+  keys.sort((a, b) => {
+    for(let i = 0; i < l; i++) {
+      if(hash[a][i] !== hash[b][i]) {
+        return hash[b][i] - hash[a][i]
+      }
+    }
+    return a === b ? 0 : (a < b ? -1 : 1)
+  })
+
+  return keys.join('')
+};
+
+// another
+
 /**
  * @param {string[]} votes
  * @return {string}

From 87d3fdee4807b2f0e3c51f7b40f179d09ff75b37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Apr 2021 21:09:54 +0800
Subject: [PATCH 1353/3374] Update 472-concatenated-words.js

---
 472-concatenated-words.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/472-concatenated-words.js b/472-concatenated-words.js
index 31cf5996..049b4a97 100644
--- a/472-concatenated-words.js
+++ b/472-concatenated-words.js
@@ -1,3 +1,40 @@
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+
+const findAllConcatenatedWordsInADict = function (words) {
+  const set = new Set(words)
+  const res = []
+  const map = new Map()
+  for (let w of words) {
+    if (w.length < 2) continue
+    if (dfs(w, set, map, 0)) res.push(w)
+  }
+  return res
+
+  function dfs(word, set, map, pos) {
+    if (pos > 0 && map.get(word)) return map.get(word)
+    if (pos > 0 && set.has(word)) {
+      map.set(word, true)
+      return map.get(word)
+    }
+    for (let i = 1; i < word.length; i++) {
+      const left = word.slice(0, i)
+      const right = word.slice(i)
+      if (set.has(right) && dfs(left, set, map, pos + 1)) {
+        map.set(word, true)
+        return map.get(word)
+      }
+    }
+
+    map.set(word, false)
+    return false
+  }
+}
+
+// another
+
 /**
  * @param {string[]} words
  * @return {string[]}

From a2524c2db74a35f50b1b015e8661d82652ff2ecd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Apr 2021 21:23:02 +0800
Subject: [PATCH 1354/3374] Update 472-concatenated-words.js

---
 472-concatenated-words.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/472-concatenated-words.js b/472-concatenated-words.js
index 049b4a97..eda86b85 100644
--- a/472-concatenated-words.js
+++ b/472-concatenated-words.js
@@ -33,6 +33,44 @@ const findAllConcatenatedWordsInADict = function (words) {
   }
 }
 
+// another
+
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+
+const findAllConcatenatedWordsInADict = function (words) {
+  const set = new Set(words)
+  const res = []
+  const map = new Map()
+
+  for(let word of words) {
+    if(dfs(word, 0)) res.push(word)
+  }
+  return res
+  function dfs(word, idx) {
+    if(map.has(word)) return map.get(word)
+    if(idx > 0 && set.has(word)) return true
+    let tmp = false
+    for(let i = 1; i < word.length; i++) {
+      const prefix = word.slice(0, i), suffix = word.slice(i)
+      if(set.has(prefix) && set.has(suffix)) {
+        tmp = true
+        break
+      }
+      if(set.has(prefix) && dfs(suffix, idx + 1)) {
+        tmp = true
+        break
+      }
+    }
+    
+    map.set(word, tmp)
+    return tmp
+  }
+}
+
+
 // another
 
 /**

From 07718d5f8d065712fb87b8af78f9633d6df91e11 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Apr 2021 22:24:46 +0800
Subject: [PATCH 1355/3374] Update 472-concatenated-words.js

---
 472-concatenated-words.js | 41 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/472-concatenated-words.js b/472-concatenated-words.js
index eda86b85..096a4693 100644
--- a/472-concatenated-words.js
+++ b/472-concatenated-words.js
@@ -1,3 +1,44 @@
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+
+const findAllConcatenatedWordsInADict = function (words) {
+  const pre = new Set()
+  words.sort((a, b) => a.length - b.length)
+  const res = []
+  for(let i = 0; i < words.length; i++) {
+    if(valid(words[i], pre)) {
+      res.push(words[i])
+    }
+    pre.add(words[i])
+  }
+
+  return res
+
+  function valid(str, set) {
+    if(set.size === 0) return false
+    const dp = Array(str.length + 1).fill(false)
+    dp[0] = true
+    for(let i = 1; i <= str.length; i++) {
+      for(let j = 0; j < i; j++) {
+        if(!dp[j]) continue
+        if(set.has(str.slice(j, i))) {
+          dp[i] = true
+          break
+        }
+      }
+    }
+    
+    return dp[str.length]
+  }
+}
+
+
+
+
+// another
+
 /**
  * @param {string[]} words
  * @return {string[]}

From 5c00e0c366a678fc623bb86d93c488ccfa47364c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Apr 2021 15:10:56 +0800
Subject: [PATCH 1356/3374] Update
 1839-longest-substring-of-all-vowels-in-order.js

---
 ...ongest-substring-of-all-vowels-in-order.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1839-longest-substring-of-all-vowels-in-order.js b/1839-longest-substring-of-all-vowels-in-order.js
index 38cc6578..d5d78f94 100644
--- a/1839-longest-substring-of-all-vowels-in-order.js
+++ b/1839-longest-substring-of-all-vowels-in-order.js
@@ -24,6 +24,36 @@ function longestBeautifulSubstring(word) {
   return res
 }
 
+// another
+
+/**
+ * @param {string} word
+ * @return {number}
+ */
+function longestBeautifulSubstring(word) {
+  let res = 0, cur = 'a', cnt = 0
+  const set = new Set()
+  for (let ch of word) {
+    if (ch >= cur) {
+      cnt++
+      cur = ch
+      set.add(ch)
+    } else {
+      set.clear()
+      cnt = 0
+      cur = 'a'
+      if(ch === cur) {
+        set.add(ch)
+        cnt++
+      }
+    }
+    if (set.size === 5) {
+      res = Math.max(res, cnt)
+    }
+  }
+
+  return res
+}
 
 // another
 

From 2cd6af7438378a31933c30e878514a844abfafeb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 May 2021 20:15:02 +0800
Subject: [PATCH 1357/3374] Create 1539-kth-missing-positive-number.js

---
 1539-kth-missing-positive-number.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1539-kth-missing-positive-number.js

diff --git a/1539-kth-missing-positive-number.js b/1539-kth-missing-positive-number.js
new file mode 100644
index 00000000..6a0c0184
--- /dev/null
+++ b/1539-kth-missing-positive-number.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @return {number}
+ */
+const findKthPositive = function(arr, k) {
+  let l = 0, r = arr.length, m;
+  while (l < r) {
+    m = (l + r) >> 1;
+    if (arr[m] - 1 - m < k) l = m + 1;
+    else r = m;
+  }
+  return l + k;
+};

From 865b5655a87f8fe03fcf1b5e355a7d8ae784ac3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 May 2021 13:52:18 +0800
Subject: [PATCH 1358/3374] Create
 1848-minimum-distance-to-the-target-element.js

---
 ...-minimum-distance-to-the-target-element.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1848-minimum-distance-to-the-target-element.js

diff --git a/1848-minimum-distance-to-the-target-element.js b/1848-minimum-distance-to-the-target-element.js
new file mode 100644
index 00000000..440d4340
--- /dev/null
+++ b/1848-minimum-distance-to-the-target-element.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @param {number} start
+ * @return {number}
+ */
+const getMinDistance = function(nums, target, start) {
+  let min = Infinity, res = -1
+  for(let i = 0; i < nums.length; i++) {
+    if(nums[i] === target) {
+      if(min > Math.abs(i - start)) {
+        res = i
+        min = Math.abs(i - start)
+      }
+    }
+  }
+  
+  return min
+  
+};

From 048d239e62200ac5808b2f2fb7ccead1af5631a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 May 2021 13:52:47 +0800
Subject: [PATCH 1359/3374] Create
 1849-splitting-a-string-into-descending-consecutive-values.js

---
 ...ring-into-descending-consecutive-values.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1849-splitting-a-string-into-descending-consecutive-values.js

diff --git a/1849-splitting-a-string-into-descending-consecutive-values.js b/1849-splitting-a-string-into-descending-consecutive-values.js
new file mode 100644
index 00000000..ef29c79f
--- /dev/null
+++ b/1849-splitting-a-string-into-descending-consecutive-values.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const splitString = function(s) {
+  return dfs(s, 0, [Infinity])
+};
+
+function dfs(str, idx, arr) {
+  if(idx >= str.length && arr.length > 2) return true
+  for(let i = idx; i < str.length; i++) {
+    const tmp = str.slice(idx, i + 1)
+    const num = parseInt(tmp, 10)
+    const pre = arr[arr.length - 1]
+    if(num < pre && (pre === Infinity || pre - num === 1)) {
+      arr.push(num)
+      if(dfs(str, i + 1, arr)) return true      
+      arr.pop()
+    }
+  }
+  return false
+}

From b6c7eb35c1927113f00850f52fb5fc2c041232a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 May 2021 14:29:38 +0800
Subject: [PATCH 1360/3374] Create
 1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js

---
 ...-swaps-to-reach-the-kth-smallest-number.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js

diff --git a/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js b/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js
new file mode 100644
index 00000000..e12293b6
--- /dev/null
+++ b/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js
@@ -0,0 +1,60 @@
+/**
+ * @param {string} num
+ * @param {number} k
+ * @return {number}
+ */
+const getMinSwaps = function (num, k) {
+  const temp = num.split('')
+  for (let i = 0; i < k; i++) nextPermutation(temp)
+  return count(num.split(''), temp, temp.length)
+}
+
+function nextPermutation(a) {
+  let i = a.length - 2
+  //Find the first element which isn't in increasing order fom behind
+  while (i >= 0 && a[i] >= a[i + 1]) i--
+  //If we found an element
+  if (i >= 0) {
+    // Find the rightmost element such that a[j] > a[i]
+    let j = bSearch(a, i + 1, a.length - 1, a[i])
+    // swap a[i] and a[j]
+    a[i] = a[i] ^ a[j] ^ (a[j] = a[i])
+  }
+  //reverse array from i + 1 till end
+  reverse(a, i + 1, a.length - 1)
+}
+
+function bSearch(a, i, j, key) {
+  while (i <= j) {
+    let mid = (i + j) >>> 1
+
+    if (key < a[mid]) i = mid + 1
+    else j = mid - 1
+  }
+  return i - 1
+}
+
+function reverse(a, i, j) {
+  while (i < j) a[i] = a[i] ^ a[j] ^ (a[j--] = a[i++])
+}
+
+function count(s1, s2, n) {
+  let i = 0,
+    j = 0,
+    res = 0
+
+  while (i < n) {
+    j = i
+
+    while (s1[j] != s2[i]) j++
+
+    while (i < j) {
+      let temp = s1[j]
+      s1[j] = s1[j - 1]
+      s1[j-- - 1] = temp
+      ++res
+    }
+    ++i
+  }
+  return res
+}

From 3642b0a27efb9e98b10fed3831be4136d4ea7bc1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 May 2021 16:03:09 +0800
Subject: [PATCH 1361/3374] Create
 1851-minimum-interval-to-include-each-query.js

---
 ...-minimum-interval-to-include-each-query.js | 302 ++++++++++++++++++
 1 file changed, 302 insertions(+)
 create mode 100644 1851-minimum-interval-to-include-each-query.js

diff --git a/1851-minimum-interval-to-include-each-query.js b/1851-minimum-interval-to-include-each-query.js
new file mode 100644
index 00000000..3bcf0adf
--- /dev/null
+++ b/1851-minimum-interval-to-include-each-query.js
@@ -0,0 +1,302 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const minInterval = function (A, Q) {
+  const QQ = []
+  for (let idx = 0; idx < Q.length; idx++) QQ.push([Q[idx], idx])
+  QQ.sort((a, b) => a[0] - b[0])
+  A.sort((a, b) => a[0] - b[0])
+  let i = 0,
+    N = A.length
+  const ans = Array(Q.length).fill(-1)
+  const m = new TreeMap()
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  for (let [q, index] of QQ) {
+    for (; i < N && A[i][0] <= q; i++) {
+      let len = A[i][1] - A[i][0] + 1
+      if (m.get(len) == null) m.set(len, 0)
+      m.set(len, m.get(len) + 1)
+      pq.push([A[i][1], len])
+    }
+    while (pq.size() > 0 && pq.peek()[0] < q) {
+      let [right, len] = pq.peek()
+      m.set(len, m.get(len) - 1)
+      if (m.get(len) === 0) m.remove(len)
+      pq.pop()
+    }
+    const first = m.getMinKey()
+    if (m.getLength()) ans[index] = first
+  }
+  return ans
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+function TreeMap() {
+  var root = null
+  var keyType = void 0
+  var length = 0
+
+  return {
+    each: each,
+    set: set,
+    get: get,
+    getTree: getTree,
+    getLength: getLength,
+    getMaxKey: getMaxKey,
+    getMinKey: getMinKey,
+    remove: remove,
+  }
+
+  function checkKey(key, checkKeyType) {
+    var localKeyType = typeof key
+
+    if (
+      localKeyType !== 'number' &&
+      localKeyType !== 'string' &&
+      localKeyType !== 'boolean'
+    ) {
+      throw new Error("'key' must be a number, a string or a boolean")
+    }
+
+    if (checkKeyType === true && localKeyType !== keyType) {
+      throw new Error('All keys must be of the same type')
+    }
+
+    return localKeyType
+  }
+
+  function call(callback) {
+    var args = Array.prototype.slice.call(arguments, 1)
+
+    if (typeof callback === 'function') {
+      callback.apply(void 0, args)
+    }
+  }
+
+  function getTree() {
+    return root
+  }
+
+  function getLength() {
+    return length
+  }
+
+  function each(callback) {
+    internalEach(root, callback)
+  }
+
+  function internalEach(node, callback, internalCallback) {
+    if (node === null) {
+      return call(internalCallback)
+    }
+
+    internalEach(node.left, callback, function () {
+      call(callback, node.value, node.key)
+
+      internalEach(node.right, callback, function () {
+        call(internalCallback)
+      })
+    })
+  }
+
+  function get(key) {
+    checkKey(key)
+
+    return internalGet(key, root)
+  }
+
+  function internalGet(key, node) {
+    if (node === null) {
+      return void 0
+    }
+
+    if (key < node.key) {
+      return internalGet(key, node.left)
+    } else if (key > node.key) {
+      return internalGet(key, node.right)
+    } else {
+      return node.value
+    }
+  }
+
+  function set(key, value) {
+    if (root === null) {
+      keyType = checkKey(key)
+    } else {
+      checkKey(key, true)
+    }
+
+    root = internalSet(key, value, root)
+  }
+
+  function internalSet(key, value, node) {
+    if (node === null) {
+      length++
+
+      return {
+        key: key,
+        value: value,
+        left: null,
+        right: null,
+      }
+    }
+
+    if (key < node.key) {
+      node.left = internalSet(key, value, node.left)
+    } else if (key > node.key) {
+      node.right = internalSet(key, value, node.right)
+    } else {
+      node.value = value
+    }
+
+    return node
+  }
+
+  function getMaxKey() {
+    var maxNode = getMaxNode(root)
+
+    if (maxNode !== null) {
+      return maxNode.key
+    }
+
+    return maxNode
+  }
+
+  function getMinKey() {
+    var minNode = getMinNode(root)
+
+    if (minNode !== null) {
+      return minNode.key
+    }
+
+    return minNode
+  }
+
+  function getMaxNode(node) {
+    while (node !== null && node.right !== null) {
+      node = node.right
+    }
+
+    return node
+  }
+
+  function getMinNode(node) {
+    while (node !== null && node.left !== null) {
+      node = node.left
+    }
+
+    return node
+  }
+
+  function remove(key) {
+    checkKey(key)
+
+    root = internalRemove(key, root)
+  }
+
+  function internalRemove(key, node) {
+    if (node === null) {
+      return null
+    }
+
+    if (key < node.key) {
+      node.left = internalRemove(key, node.left)
+    } else if (key > node.key) {
+      node.right = internalRemove(key, node.right)
+    } else {
+      if (node.left !== null && node.right !== null) {
+        var maxNode = getMaxNode(node.left)
+
+        var maxNodeKey = maxNode.key
+        var maxNodeValue = maxNode.value
+
+        maxNode.key = node.key
+        maxNode.value = node.value
+        node.key = maxNodeKey
+        node.value = maxNodeValue
+
+        node.left = internalRemove(key, node.left)
+      } else if (node.left !== null) {
+        length--
+        return node.left
+      } else if (node.right !== null) {
+        length--
+        return node.right
+      } else {
+        length--
+        return null
+      }
+    }
+
+    return node
+  }
+}

From a5432df97a2d4e602e9058c821b234f581a22198 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 May 2021 23:08:50 +0800
Subject: [PATCH 1362/3374] Create
 1846-maximum-element-after-decreasing-and-rearranging.js

---
 ...imum-element-after-decreasing-and-rearranging.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1846-maximum-element-after-decreasing-and-rearranging.js

diff --git a/1846-maximum-element-after-decreasing-and-rearranging.js b/1846-maximum-element-after-decreasing-and-rearranging.js
new file mode 100644
index 00000000..70d6be66
--- /dev/null
+++ b/1846-maximum-element-after-decreasing-and-rearranging.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const maximumElementAfterDecrementingAndRearranging = function(arr) {
+    arr.sort((a, b) => a - b);
+    arr[0] = 1;
+    for(let i = 1; i < arr.length; i++) {
+        if(arr[i] <= arr[i - 1] + 1) continue;
+        arr[i] = arr[i - 1] + 1;
+    }
+    return arr[arr.length - 1];
+};

From f8893a0a7db6528efc342ceaca9274601bde7fef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 May 2021 20:04:11 +0800
Subject: [PATCH 1363/3374] Update
 1697-checking-existence-of-edge-length-limited-paths.js

---
 1697-checking-existence-of-edge-length-limited-paths.js | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/1697-checking-existence-of-edge-length-limited-paths.js b/1697-checking-existence-of-edge-length-limited-paths.js
index 12928026..cf678002 100644
--- a/1697-checking-existence-of-edge-length-limited-paths.js
+++ b/1697-checking-existence-of-edge-length-limited-paths.js
@@ -16,13 +16,11 @@ const distanceLimitedPathsExist = function (n, edgeList, queries) {
   for (let i of order) {
     const limit = queries[i][2]
     while (idx < edgeList.length && edgeList[idx][2] < limit) {
-      const u = edgeList[idx][0],
-        v = edgeList[idx][1]
+      const [u, v] = edgeList[idx]
       uf.union(u, v)
       idx++
     }
-    const u0 = queries[i][0],
-      v0 = queries[i][1]
+    const [u0, v0] = queries[i]
     if (uf.find(u0) === uf.find(v0)) ans[i] = true
   }
   return ans

From e7e7931b31edeace24a8ffab105f08b5024b6db6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 May 2021 21:56:25 +0800
Subject: [PATCH 1364/3374] Update
 1707-maximum-xor-with-an-element-from-array.js

---
 1707-maximum-xor-with-an-element-from-array.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
index e63749e0..7aa24804 100644
--- a/1707-maximum-xor-with-an-element-from-array.js
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -17,10 +17,10 @@ const maximizeXor = function (nums, queries) {
       if (m < nums[mid])r = mid
       else l = mid + 1
     }
-    r -= 1
+    r--
     l = 0
     let ans = x & ~maxMask
-    for (let bit = numOfBits - 1; bit >= 0; bit -= 1) {
+    for (let bit = numOfBits - 1; bit >= 0; bit--) {
       const mask = 1 << bit
       if (x & mask) {
         if ((nums[l] & mask) === 0) {
@@ -46,6 +46,7 @@ const maximizeXor = function (nums, queries) {
   }
 }
 
+
 // another
 
 /**

From fc9b1efa68cf2e4eb0e65c3a96733ec577d68769 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 May 2021 15:44:52 +0800
Subject: [PATCH 1365/3374] Create 1847-closest-room.js

---
 1847-closest-room.js | 71 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 1847-closest-room.js

diff --git a/1847-closest-room.js b/1847-closest-room.js
new file mode 100644
index 00000000..f2c7aa85
--- /dev/null
+++ b/1847-closest-room.js
@@ -0,0 +1,71 @@
+
+/**
+ * @param {number[][]} rooms
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+ const closestRoom = function (rooms, queries) {
+  rooms.sort((a, b) => b[1] - a[1])
+  const n = queries.length
+  const minSize = Array(n).fill(0).map((_, i) => i)
+    .sort((a, b) => queries[b][1] - queries[a][1])
+
+  const res = new Array(queries.length).fill(-1)
+  const bst = new BinarySearchTree()
+  let currentRoom = 0
+
+  minSize.forEach((query) => {
+    const [preferredRoom, minimumSize] = queries[query]
+    if (rooms[0][1] < minimumSize) return
+
+    while (currentRoom < rooms.length && rooms[currentRoom][1] >= minimumSize) {
+      bst.add(rooms[currentRoom][0])
+      currentRoom++
+    }
+
+    res[query] = bst.search(preferredRoom)
+  })
+
+  return res
+}
+
+class BinarySearchTree {
+  constructor() {
+    this.root = null
+  }
+
+  add(val) {
+    this.root = this.insert(this.root, val)
+  }
+
+  insert(node, val) {
+    if (!node) return new TreeNode(val)
+    if (node.val < val) {
+      node.right = this.insert(node.right, val)
+    } else {
+      node.left = this.insert(node.left, val)
+    }
+    return node
+  }
+
+  search(val, node = this.root) {
+    if (node.val === val) return val
+    const currentDistance = Math.abs(node.val - val)
+    const nextChild = node.val < val ? node.right : node.left
+    if (!nextChild) return node.val
+    const closestChild = this.search(val, nextChild)
+    const childDistance = Math.abs(closestChild - val)
+    if (childDistance < currentDistance) return closestChild
+    if (childDistance === currentDistance)
+      return Math.min(closestChild, node.val)
+    return node.val
+  }
+}
+
+class TreeNode {
+  constructor(val) {
+    this.val = val
+    this.left = null
+    this.right = null
+  }
+}

From 290f7511185399b232171850b008548092933f23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 May 2021 13:30:04 +0800
Subject: [PATCH 1366/3374] Update
 1851-minimum-interval-to-include-each-query.js

---
 ...-minimum-interval-to-include-each-query.js | 145 ++++++++++++++++++
 1 file changed, 145 insertions(+)

diff --git a/1851-minimum-interval-to-include-each-query.js b/1851-minimum-interval-to-include-each-query.js
index 3bcf0adf..b2a0f7f3 100644
--- a/1851-minimum-interval-to-include-each-query.js
+++ b/1851-minimum-interval-to-include-each-query.js
@@ -1,3 +1,148 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const minInterval = function (intervals, queries) {
+  const n = intervals.length
+  const m = queries.length
+  const sortedQueryIdx = [...Array(m).keys()].sort(
+    (a, b) => queries[a] - queries[b]
+  )
+  intervals.sort((a, b) => a[0] - b[0]) // sort by start & ascending
+  const minHeap = new BinaryHeap((c, p) => c.size >= p.size)
+  const res = Array(m).fill(0)
+  let i = 0
+  for (const idx of sortedQueryIdx) {
+    const query = queries[idx]
+    while (i < n && intervals[i][0] <= query) {
+      minHeap.push({
+        size: intervals[i][1] - intervals[i][0] + 1,
+        start: intervals[i][0],
+        end: intervals[i][1],
+      })
+      i++
+    }
+    while (!minHeap.isEmpty() && minHeap.peek().end < query) {
+      minHeap.pop()
+    }
+    res[idx] = minHeap.isEmpty() ? -1 : minHeap.peek().size
+  }
+  return res
+}
+
+class BinaryHeap {
+  /**
+   * @param {compareFunction} compareFn
+   */
+  constructor(compareFn) {
+    this.content = []
+    this.compareFn = compareFn // Min-Heap: (c, p) => c > p
+  }
+
+  /**
+   * @return {number} - Current heap size.
+   */
+  size() {
+    return this.content.length
+  }
+
+  /**
+   * @return {boolean} - True if heap size is empty.
+   */
+  isEmpty() {
+    return this.size() === 0
+  }
+
+  /**
+   * @return {*} - Root node of the heap.
+   */
+  peek() {
+    return this.size() > 0 ? this.content[0] : null
+  }
+
+  /**
+   * @param {*} node - New node to add.
+   */
+  push(node) {
+    this.content.push(node)
+    this._bubbleUp(this.content.length - 1)
+  }
+
+  /**
+   * @return {*} - Root node of the heap.
+   */
+  pop() {
+    if (this.content.length === 0) return null
+    const root = this.content[0]
+    const last = this.content.pop()
+    if (this.content.length > 0) {
+      this.content[0] = last
+      this._sinkDown(0)
+    }
+    return root
+  }
+
+  /**
+   * @param {*} node - Node to delete.
+   */
+  remove(node) {
+    const length = this.content.length
+    for (let i = 0; i < length; i++) {
+      if (this.content[i] !== node) continue
+      const last = this.content.pop()
+      if (i === length - 1) break
+      this.content[i] = last
+      this._bubbleUp(i)
+      this._sinkDown(i)
+      break
+    }
+  }
+
+  /**
+   * @param {number} idx - Index of the node to bubble up
+   */
+  _bubbleUp(idx) {
+    const node = this.content[idx]
+    while (idx > 0) {
+      const parentIdx = Math.floor((idx + 1) / 2) - 1
+      const parent = this.content[parentIdx]
+      if (this.compareFn(node, parent)) break
+      this.content[parentIdx] = node
+      this.content[idx] = parent
+      idx = parentIdx
+    }
+  }
+
+  /**
+   * @param {number} idx - Index of the node to sink down
+   */
+  _sinkDown(idx) {
+    const node = this.content[idx]
+    while (true) {
+      const child2Idx = (idx + 1) * 2
+      const child1Idx = child2Idx - 1
+      let swapIdx = -1
+      if (child1Idx < this.content.length) {
+        const child1 = this.content[child1Idx]
+        if (!this.compareFn(child1, node)) swapIdx = child1Idx
+      }
+      if (child2Idx < this.content.length) {
+        const child2 = this.content[child2Idx]
+        const compareNode = swapIdx === -1 ? node : this.content[child1Idx]
+        if (!this.compareFn(child2, compareNode)) swapIdx = child2Idx
+      }
+      if (swapIdx === -1) break
+      this.content[idx] = this.content[swapIdx]
+      this.content[swapIdx] = node
+      idx = swapIdx
+    }
+  }
+}
+
+
+// another
+
 /**
  * @param {number[][]} intervals
  * @param {number[]} queries

From b06e016adbcd2208c203614a9d9b3580396510a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 May 2021 12:05:15 +0800
Subject: [PATCH 1367/3374] Update
 1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js

---
 ...adjacent-swaps-to-reach-the-kth-smallest-number.js | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js b/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js
index e12293b6..4fa860fe 100644
--- a/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js
+++ b/1850-minimum-adjacent-swaps-to-reach-the-kth-smallest-number.js
@@ -3,7 +3,7 @@
  * @param {number} k
  * @return {number}
  */
-const getMinSwaps = function (num, k) {
+ const getMinSwaps = function (num, k) {
   const temp = num.split('')
   for (let i = 0; i < k; i++) nextPermutation(temp)
   return count(num.split(''), temp, temp.length)
@@ -16,7 +16,7 @@ function nextPermutation(a) {
   //If we found an element
   if (i >= 0) {
     // Find the rightmost element such that a[j] > a[i]
-    let j = bSearch(a, i + 1, a.length - 1, a[i])
+    const j = bSearch(a, i + 1, a.length - 1, a[i])
     // swap a[i] and a[j]
     a[i] = a[i] ^ a[j] ^ (a[j] = a[i])
   }
@@ -26,8 +26,7 @@ function nextPermutation(a) {
 
 function bSearch(a, i, j, key) {
   while (i <= j) {
-    let mid = (i + j) >>> 1
-
+    const mid = (i + j) >>> 1
     if (key < a[mid]) i = mid + 1
     else j = mid - 1
   }
@@ -45,11 +44,9 @@ function count(s1, s2, n) {
 
   while (i < n) {
     j = i
-
     while (s1[j] != s2[i]) j++
-
     while (i < j) {
-      let temp = s1[j]
+      const temp = s1[j]
       s1[j] = s1[j - 1]
       s1[j-- - 1] = temp
       ++res

From 83179dee578c83768a86f88feea94c987bf0c51f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 May 2021 17:45:28 +0800
Subject: [PATCH 1368/3374] Create 1325-delete-leaves-with-a-given-value.js

---
 1325-delete-leaves-with-a-given-value.js | 29 ++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1325-delete-leaves-with-a-given-value.js

diff --git a/1325-delete-leaves-with-a-given-value.js b/1325-delete-leaves-with-a-given-value.js
new file mode 100644
index 00000000..7d41bbff
--- /dev/null
+++ b/1325-delete-leaves-with-a-given-value.js
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {TreeNode}
+ */
+const removeLeafNodes = function(root, target) {
+  return dfs(root, target)
+  
+};
+
+function dfs(node, target) {
+  if(node == null) return node
+  if(node.left == null && node.right == null) {
+    if(node.val === target)  return null
+    else return node
+  }
+  node.right = dfs(node.right, target)
+  node.left = dfs(node.left, target)
+  if(node.right == null && node.left == null) return dfs(node, target)
+  return node
+}

From a8118d1bb71501e64f88fe3ba57b0417b00b7a02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 May 2021 20:18:11 +0800
Subject: [PATCH 1369/3374] Update 1325-delete-leaves-with-a-given-value.js

---
 1325-delete-leaves-with-a-given-value.js | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/1325-delete-leaves-with-a-given-value.js b/1325-delete-leaves-with-a-given-value.js
index 7d41bbff..33e8a0d9 100644
--- a/1325-delete-leaves-with-a-given-value.js
+++ b/1325-delete-leaves-with-a-given-value.js
@@ -13,7 +13,6 @@
  */
 const removeLeafNodes = function(root, target) {
   return dfs(root, target)
-  
 };
 
 function dfs(node, target) {
@@ -27,3 +26,24 @@ function dfs(node, target) {
   if(node.right == null && node.left == null) return dfs(node, target)
   return node
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} target
+ * @return {TreeNode}
+ */
+const removeLeafNodes = function(root, target) {
+  if(root.left)  root.left = removeLeafNodes(root.left, target)
+  if(root.right) root.right = removeLeafNodes(root.right, target)
+  return root.left == root.right && root.val === target ? null : root
+};

From e4b213e47ff9be89af97ecefc0d21f901585ca20 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 14:14:53 +0800
Subject: [PATCH 1370/3374] Create 1856-maximum-subarray-min-product.js

---
 1856-maximum-subarray-min-product.js | 46 ++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 1856-maximum-subarray-min-product.js

diff --git a/1856-maximum-subarray-min-product.js b/1856-maximum-subarray-min-product.js
new file mode 100644
index 00000000..439b0d94
--- /dev/null
+++ b/1856-maximum-subarray-min-product.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumMinProduct = function (nums) {
+  const n = nums.length
+  const mod = BigInt(10 ** 9 + 7)
+  const preSum = Array(n + 1).fill(0n)
+  for (let i = 0; i < n; i++) {
+    preSum[i + 1] = preSum[i] + BigInt(nums[i])
+  }
+  const l = Array(n).fill(0) // l[i] stores index of farthest element greater or equal to nums[i]
+  const r = Array(n).fill(0) // r[i] stores index of farthest element greater or equal to nums[i]
+  let st = []
+
+  for (let i = 0; i < n; i++) {
+    while (st.length && nums[st[st.length - 1]] >= nums[i]) st.pop()
+    if (st.length) l[i] = st[st.length - 1] + 1
+    else l[i] = 0
+    st.push(i)
+  }
+  
+  st = []
+  for (let i = n - 1; i >= 0; i--) {
+    while (st.length && nums[st[st.length - 1]] >= nums[i]) st.pop()
+    if (st.length) r[i] = st[st.length - 1] - 1
+    else r[i] = n - 1
+    st.push(i)
+  }
+  function getSum(left, right) {
+    // inclusive
+    return preSum[right + 1] - preSum[left]
+  }
+
+  let maxProduct = 0n
+  for (let i = 0; i < n; i++) {
+    maxProduct = bigint_max(maxProduct, BigInt(nums[i]) * getSum(l[i], r[i]))
+  }
+  return maxProduct % mod
+}
+function bigint_max(...args){
+    if (args.length < 1){ throw 'Max of empty list'; }
+    m = args[0];
+    args.forEach(a=>{if (a > m) {m = a}});
+    return m;
+}

From 6875c091b083847b32b90e74e777bd89de2622e8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 18:05:22 +0800
Subject: [PATCH 1371/3374] Create 1854-maximum-population-year.js

---
 1854-maximum-population-year.js | 59 +++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 1854-maximum-population-year.js

diff --git a/1854-maximum-population-year.js b/1854-maximum-population-year.js
new file mode 100644
index 00000000..628db32a
--- /dev/null
+++ b/1854-maximum-population-year.js
@@ -0,0 +1,59 @@
+/**
+ * @param {number[][]} logs
+ * @return {number}
+ */
+const maximumPopulation = function(logs) {
+  logs.sort((a, b) => {
+    if(a[0] === b[0]) return a[1] - b[1]
+    return a[0] - b[0]
+  })
+  const arr = Array(101).fill(0)
+  const bit = new FenwickTree(101)
+  for(let i = 0, len = logs.length; i < len; i++) {
+    const [start, end] = logs[i]
+    const idx = start - 1950
+    bit.update(idx + 1, 1)
+  }
+  for(let i = 0, len = logs.length; i < len; i++) {
+    const [start, end] = logs[i]
+    const idx = end - 1950
+    bit.update(idx + 1, -1)
+  }
+  let max = 0
+  for(let i = 1; i <= 101; i++) {
+    max = Math.max(max, bit.query(i))
+  }
+  let tmp
+  for(let i = 1; i <= 101; i++) {
+    if(bit.query(i) === max) {
+      tmp = i
+      break
+    }
+  }
+  
+  return 1950 + tmp - 1
+};
+
+const lowBit = (x) => x & -x
+class FenwickTree {
+  constructor(n) {
+    if (n < 1) return
+    this.sum = Array(n + 1).fill(0)
+  }
+  update(i, delta) {
+    if (i < 1) return
+    while (i < this.sum.length) {
+      this.sum[i] += delta
+      i += lowBit(i)
+    }
+  }
+  query(i) {
+    if (i < 1) return
+    let sum = 0
+    while (i > 0) {
+      sum += this.sum[i]
+      i -= lowBit(i)
+    }
+    return sum
+  }
+}

From ea5025be569fda76a7d9b0d38f8cee96d050770b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 18:12:33 +0800
Subject: [PATCH 1372/3374] Update 1854-maximum-population-year.js

---
 1854-maximum-population-year.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1854-maximum-population-year.js b/1854-maximum-population-year.js
index 628db32a..c8a1f739 100644
--- a/1854-maximum-population-year.js
+++ b/1854-maximum-population-year.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[][]} logs
+ * @return {number}
+ */
+const maximumPopulation = function(logs) {
+  const n = logs.length
+  const arr = Array(101).fill(0)
+  const base = 1950
+  for(let log of logs) {
+    const [start, end] = log
+    arr[start - base]++
+    arr[end - base]--
+  }
+  
+  let res = 0, tmp = -Infinity
+  for(let i = 1; i < 101; i++) {
+    arr[i] += arr[i - 1]
+  }
+  for(let i = 0; i < 101; i++) {
+    if(arr[i] > tmp) {
+      res = i
+      tmp = arr[i]
+    }
+  }
+  return res + base
+};
+
+
+// another
+
 /**
  * @param {number[][]} logs
  * @return {number}

From fb5a72f8f3a65f3685456fadb61df6655583cf1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 18:14:07 +0800
Subject: [PATCH 1373/3374] Create
 1855-maximum-distance-between-a-pair-of-values.js

---
 ...ximum-distance-between-a-pair-of-values.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1855-maximum-distance-between-a-pair-of-values.js

diff --git a/1855-maximum-distance-between-a-pair-of-values.js b/1855-maximum-distance-between-a-pair-of-values.js
new file mode 100644
index 00000000..ff799df6
--- /dev/null
+++ b/1855-maximum-distance-between-a-pair-of-values.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maxDistance = function(nums1, nums2) {
+  let res = 0
+  const m = nums1.length, n = nums2.length
+  for(let i = 0; i < m; i++) {
+    const idx = bSearch(nums2, i, n - 1, nums1[i])
+    res = Math.max(res, idx - i)
+  }
+  return res
+};
+
+function bSearch(a, i, j, key) {
+  while (i <= j) {
+    let mid = (i + j) >>> 1
+    if (key <= a[mid]) i = mid + 1
+    else if(key > a[mid]) j = mid - 1
+  }
+  return i - 1
+}

From 23d7c3b237beeeb04fdff930d37a30bbad488dac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 21:03:45 +0800
Subject: [PATCH 1374/3374] Update
 1849-splitting-a-string-into-descending-consecutive-values.js

---
 ...ring-into-descending-consecutive-values.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1849-splitting-a-string-into-descending-consecutive-values.js b/1849-splitting-a-string-into-descending-consecutive-values.js
index ef29c79f..48e25d46 100644
--- a/1849-splitting-a-string-into-descending-consecutive-values.js
+++ b/1849-splitting-a-string-into-descending-consecutive-values.js
@@ -1,3 +1,26 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const splitString = function(s) {
+  return helper(s, null)
+};
+
+function helper(str, previous) {
+  for(let i = 0, n = str.length; i < n; i++) {
+    const tmp = +(str.slice(0, i + 1))
+    if(previous == null) {
+      if(helper(str.slice(i + 1), tmp)) return true
+    } else if(previous - tmp === 1 && (i === n - 1 || helper(str.slice(i + 1), tmp))) return true
+  }
+  
+  return false
+}
+
+
+// another
+
+
 /**
  * @param {string} s
  * @return {boolean}

From d26f7e6f72b30a5ef8602bf96fb5a73f404157b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 21:44:04 +0800
Subject: [PATCH 1375/3374] Create
 1857-largest-color-value-in-a-directed-graph.js

---
 ...largest-color-value-in-a-directed-graph.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1857-largest-color-value-in-a-directed-graph.js

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
new file mode 100644
index 00000000..4914fbfd
--- /dev/null
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -0,0 +1,41 @@
+/**
+ * @param {string} colors
+ * @param {number[][]} edges
+ * @return {number}
+ */
+ const largestPathValue = function(colors, edges) {
+    const graph = {}
+    const n = colors.length, a = 'a'.charCodeAt(0)
+    const indegree = Array(colors.length).fill(0)
+    for(let e of edges) {
+      if(graph[e[0]] == null) graph[e[0]] = []
+      graph[e[0]].push(e[1])
+      indegree[e[1]]++
+    }
+    const cnt = Array.from({ length: n }, () => Array(26).fill(0))
+    const q = []
+    for(let i = 0; i < n; i++) {
+      if(indegree[i] === 0) {
+        q.push(i)
+        cnt[i][colors.charCodeAt(i) - a] = 1
+      }
+    }
+    let res = 0, seen = 0
+    while(q.length) {
+      const u = q[0]
+      q.shift()
+      let val = Math.max(...cnt[u])
+      res = Math.max(res, val)
+      seen++
+      if(graph[u] == null) continue
+      for(let v of graph[u]) {
+        for(let i = 0; i < 26; i++) {
+          cnt[v][i] = Math.max(cnt[v][i], cnt[u][i] + (i === colors.charCodeAt(v) - a))
+        }
+        if(--indegree[v] === 0) q.push(v)
+      }
+    }
+    return seen < colors.length ? -1 : res
+  };
+  
+  

From f8094d91b21e97dedb62b441c75fa8eacb912cba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 May 2021 21:44:39 +0800
Subject: [PATCH 1376/3374] Update
 1857-largest-color-value-in-a-directed-graph.js

---
 ...largest-color-value-in-a-directed-graph.js | 69 ++++++++++---------
 1 file changed, 36 insertions(+), 33 deletions(-)

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index 4914fbfd..47bd3060 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -3,39 +3,42 @@
  * @param {number[][]} edges
  * @return {number}
  */
- const largestPathValue = function(colors, edges) {
-    const graph = {}
-    const n = colors.length, a = 'a'.charCodeAt(0)
-    const indegree = Array(colors.length).fill(0)
-    for(let e of edges) {
-      if(graph[e[0]] == null) graph[e[0]] = []
-      graph[e[0]].push(e[1])
-      indegree[e[1]]++
+const largestPathValue = function (colors, edges) {
+  const graph = {}
+  const n = colors.length,
+    a = 'a'.charCodeAt(0)
+  const indegree = Array(colors.length).fill(0)
+  for (let e of edges) {
+    if (graph[e[0]] == null) graph[e[0]] = []
+    graph[e[0]].push(e[1])
+    indegree[e[1]]++
+  }
+  const cnt = Array.from({ length: n }, () => Array(26).fill(0))
+  const q = []
+  for (let i = 0; i < n; i++) {
+    if (indegree[i] === 0) {
+      q.push(i)
+      cnt[i][colors.charCodeAt(i) - a] = 1
     }
-    const cnt = Array.from({ length: n }, () => Array(26).fill(0))
-    const q = []
-    for(let i = 0; i < n; i++) {
-      if(indegree[i] === 0) {
-        q.push(i)
-        cnt[i][colors.charCodeAt(i) - a] = 1
+  }
+  let res = 0,
+    seen = 0
+  while (q.length) {
+    const u = q[0]
+    q.shift()
+    let val = Math.max(...cnt[u])
+    res = Math.max(res, val)
+    seen++
+    if (graph[u] == null) continue
+    for (let v of graph[u]) {
+      for (let i = 0; i < 26; i++) {
+        cnt[v][i] = Math.max(
+          cnt[v][i],
+          cnt[u][i] + (i === colors.charCodeAt(v) - a)
+        )
       }
+      if (--indegree[v] === 0) q.push(v)
     }
-    let res = 0, seen = 0
-    while(q.length) {
-      const u = q[0]
-      q.shift()
-      let val = Math.max(...cnt[u])
-      res = Math.max(res, val)
-      seen++
-      if(graph[u] == null) continue
-      for(let v of graph[u]) {
-        for(let i = 0; i < 26; i++) {
-          cnt[v][i] = Math.max(cnt[v][i], cnt[u][i] + (i === colors.charCodeAt(v) - a))
-        }
-        if(--indegree[v] === 0) q.push(v)
-      }
-    }
-    return seen < colors.length ? -1 : res
-  };
-  
-  
+  }
+  return seen < colors.length ? -1 : res
+}

From 13614982df99caf5d0c6e1c1d3085f72fc0e6e7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 May 2021 12:06:46 +0800
Subject: [PATCH 1377/3374] Update 131-palindrome-partitioning.js

---
 131-palindrome-partitioning.js | 37 ++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/131-palindrome-partitioning.js b/131-palindrome-partitioning.js
index c528343b..56ebb6cb 100644
--- a/131-palindrome-partitioning.js
+++ b/131-palindrome-partitioning.js
@@ -31,3 +31,40 @@ function isPalindrome(str, start, i) {
   }
   return true
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string[][]}
+ */
+const partition = function(s) {
+  const res = []
+  helper(s, 0, [], res)
+  return res
+};
+
+function helper(str, idx, cur, res) {
+  if(idx >= str.length) {
+    res.push(cur.slice())
+    return
+  }
+  for(let i = idx, len = str.length; i < len; i++) {
+    const tmp = str.slice(idx, i + 1)
+    if(chk(tmp)) {
+      cur.push(tmp)
+      helper(str, i + 1, cur, res)
+      cur.pop()
+    }
+  }
+}
+function chk(str) {
+  const n = str.length
+  let l = 0, r = n - 1
+  while(l < r) {
+    if(str[l] !== str[r]) return false
+    l++
+    r--
+  }
+  return true
+}

From 521b1b67f92a15c726d05a7a2ab5bfa7d5d40bd5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 May 2021 17:10:02 +0800
Subject: [PATCH 1378/3374] Update 291-word-pattern-ii.js

---
 291-word-pattern-ii.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/291-word-pattern-ii.js b/291-word-pattern-ii.js
index c0243b91..91f77ac2 100644
--- a/291-word-pattern-ii.js
+++ b/291-word-pattern-ii.js
@@ -28,3 +28,41 @@ function isMatch(str, i, pat, j, map, set) {
   }
   return false
 }
+
+// another
+
+/**
+ * @param {string} pattern
+ * @param {string} s
+ * @return {boolean}
+ */
+const wordPatternMatch = function(pattern, s) {
+  const obj = { res: false }
+  const hash = {}
+  helper(pattern, s, 0, 0, hash, obj)
+  return obj.res
+};
+
+function helper(p, s, i, j, hash, obj) {
+  if(obj.res) return
+  if(i === p.length && j === s.length) {
+    obj.res = true
+    return
+  }
+  if(i >= p.length || j >= s.length) return
+  for(let m = j; m < s.length && obj.res === false; m++) {
+    const tmp = s.slice(j, m + 1)
+    if(hash[p[i]]) {
+      if(tmp === hash[p[i]]) {
+        helper(p, s, i + 1, m + 1, hash, obj)
+      }
+    } else {
+      const set = new Set(Object.values(hash))
+      if (!set.has(tmp)) {
+        hash[p[i]] = tmp
+        helper(p, s, i + 1, m + 1, hash, obj)
+        delete hash[p[i]]
+      }
+    }
+  }
+}

From 216822059bd2537b8d962c5630b96bd99a1d7e12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 May 2021 20:37:24 +0800
Subject: [PATCH 1379/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 39 +++++++++++++++++----------------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index 9268882a..e41a04d9 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -2,35 +2,36 @@
  * @param {number[]} A
  * @return {number}
  */
-const sumSubarrayMins = function(A) {
-  let n = A.length;
-  let s1 = [];
-  let s2 = [];
-  let left = new Array(n);
-  let right = new Array(n);
+const sumSubarrayMins = function (A) {
+  const n = A.length
+  const s1 = []
+  const s2 = []
+  const left = new Array(n)
+  const right = new Array(n)
 
   for (let i = 0; i < n; i++) {
-    let count = 1;
+    let count = 1
     while (s1.length && s1[s1.length - 1][0] > A[i]) {
-      count += s1.pop()[1];
+      count += s1.pop()[1]
     }
-    left[i] = count;
-    s1.push([A[i], count]);
+    left[i] = count
+    s1.push([A[i], count])
   }
 
   for (let i = n - 1; i >= 0; i--) {
-    let count = 1;
+    let count = 1
+    // use ">=" to deal with duplicate elements
     while (s2.length && s2[s2.length - 1][0] >= A[i]) {
-      count += s2.pop()[1];
+      count += s2.pop()[1]
     }
-    right[i] = count;
-    s2.push([A[i], count]);
+    right[i] = count
+    s2.push([A[i], count])
   }
 
-  let res = 0;
-  let mod = 1e9 + 7;
+  let res = 0
+  const mod = 1e9 + 7
   for (let i = 0; i < n; i++) {
-    res = (res + left[i] * A[i] * right[i]) % mod;
+    res = (res + left[i] * A[i] * right[i]) % mod
   }
-  return res;
-};
+  return res
+}

From 6550b7e2dccd2c5905fc77ff33885b16119a506a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 May 2021 22:17:18 +0800
Subject: [PATCH 1380/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 48 +++++++++++++++------------------
 1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index e41a04d9..5a503f9f 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -1,37 +1,33 @@
 /**
- * @param {number[]} A
+ * @param {number[]} arr
  * @return {number}
  */
-const sumSubarrayMins = function (A) {
-  const n = A.length
-  const s1 = []
-  const s2 = []
-  const left = new Array(n)
-  const right = new Array(n)
-
-  for (let i = 0; i < n; i++) {
-    let count = 1
-    while (s1.length && s1[s1.length - 1][0] > A[i]) {
-      count += s1.pop()[1]
+const sumSubarrayMins = function(arr) {
+  const n = arr.length, s1 = [], s2 = [], left = Array(n), right = Array(n)
+  for(let i = 0; i < n; i++) {
+    let cnt = 1
+    while(s1.length && s1[s1.length - 1][0] > arr[i]) {
+      cnt += s1.pop()[1]
     }
-    left[i] = count
-    s1.push([A[i], count])
+    left[i] = cnt
+    s1.push([arr[i], cnt])
   }
-
-  for (let i = n - 1; i >= 0; i--) {
-    let count = 1
-    // use ">=" to deal with duplicate elements
-    while (s2.length && s2[s2.length - 1][0] >= A[i]) {
-      count += s2.pop()[1]
+  
+  for(let i = n - 1; i >= 0; i--) {
+    let cnt = 1
+    while(s2.length && s2[s2.length - 1][0] >= arr[i]) {
+      cnt += s2.pop()[1]
     }
-    right[i] = count
-    s2.push([A[i], count])
+    right[i] = cnt
+    s2.push([arr[i], cnt])
   }
-
   let res = 0
   const mod = 1e9 + 7
-  for (let i = 0; i < n; i++) {
-    res = (res + left[i] * A[i] * right[i]) % mod
+  for(let i = 0; i < n; i++) {
+    // left[i] number of starting positions
+    // right[i] number of ending positions
+    res = (res + arr[i] * left[i] * right[i]) % mod
   }
+  
   return res
-}
+};

From a010bd29583c025d040ca64b525e272f1343ee83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 May 2021 22:18:02 +0800
Subject: [PATCH 1381/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index 5a503f9f..b9cf6459 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -15,6 +15,7 @@ const sumSubarrayMins = function(arr) {
   
   for(let i = n - 1; i >= 0; i--) {
     let cnt = 1
+    // use ">=" to deal with duplicate elements
     while(s2.length && s2[s2.length - 1][0] >= arr[i]) {
       cnt += s2.pop()[1]
     }

From 33ffa9af2a2bb1af0b6cd9eb43bd4d7b2e63c225 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 May 2021 20:50:17 +0800
Subject: [PATCH 1382/3374] Update 1856-maximum-subarray-min-product.js

---
 1856-maximum-subarray-min-product.js | 47 ++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1856-maximum-subarray-min-product.js b/1856-maximum-subarray-min-product.js
index 439b0d94..163784e3 100644
--- a/1856-maximum-subarray-min-product.js
+++ b/1856-maximum-subarray-min-product.js
@@ -44,3 +44,50 @@ function bigint_max(...args){
     args.forEach(a=>{if (a > m) {m = a}});
     return m;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumMinProduct = function(nums) {
+  const n = nums.length, s1 = [], s2 = [],
+    left = Array(n), right = Array(n), mod = BigInt(1e9 + 7)
+  for(let i = 0; i < n; i++) {
+    while(s1.length && nums[s1[s1.length - 1]] >= nums[i]) s1.pop()
+    if(s1.length) left[i] = s1[s1.length - 1] + 1
+    else left[i] = 0
+    s1.push(i)
+  }
+  
+  for(let i = n - 1; i >= 0; i--) {
+    while(s2.length && nums[s2[s2.length - 1]] >= nums[i]) s2.pop()
+    if(s2.length) right[i] = s2[s2.length - 1] - 1
+    else right[i] = n - 1
+    s2.push(i)
+  }
+  
+  const preSum = Array(n)
+  for(let i = 0; i < n; i++) {
+    preSum[i] = (i === 0 ? 0n : preSum[i - 1]) + BigInt(nums[i])
+  }
+  let res = 0n
+  for(let i = 0; i < n; i++) {
+    res = max(res, getSum(preSum, left[i], right[i]) * BigInt(nums[i]))
+  }
+  return res % mod
+  
+};
+
+function getSum(arr, l, r) {
+  return arr[r] - (l === 0 ? 0n : arr[l - 1])
+}
+
+function max(...args) {
+  let res = -Infinity
+  for(let e of args) {
+    if(e > res) res = e
+  }
+  return res
+}

From 0b6acaeb389ee0cfb9f38f6af19d52d61a423f53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 May 2021 22:49:28 +0800
Subject: [PATCH 1383/3374] Update
 1857-largest-color-value-in-a-directed-graph.js

---
 1857-largest-color-value-in-a-directed-graph.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index 47bd3060..be5c8ba3 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -26,7 +26,7 @@ const largestPathValue = function (colors, edges) {
   while (q.length) {
     const u = q[0]
     q.shift()
-    let val = Math.max(...cnt[u])
+    const val = Math.max(...cnt[u])
     res = Math.max(res, val)
     seen++
     if (graph[u] == null) continue

From d5a7ab056894b39a944d5e36d790655bf57ea90d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 May 2021 21:39:32 +0800
Subject: [PATCH 1384/3374] Update 1591-strange-printer-ii.js

---
 1591-strange-printer-ii.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/1591-strange-printer-ii.js b/1591-strange-printer-ii.js
index c5a48fd6..5e9be1d4 100644
--- a/1591-strange-printer-ii.js
+++ b/1591-strange-printer-ii.js
@@ -13,13 +13,13 @@ const isPrintable = function (targetGrid) {
     for (let j = 0; j < n; j++) {
       let c = targetGrid[i][j]
       colorSet.add(c)
-      posMin[c][0] = Math.min(posMin[c][0], i) // Up
-      posMin[c][1] = Math.min(posMin[c][1], j) // Left
-      posMax[c][0] = Math.max(posMax[c][0], i) // Down
-      posMax[c][1] = Math.max(posMax[c][1], j) // Right
+      posMin[c][0] = Math.min(posMin[c][0], i) //Up
+      posMin[c][1] = Math.min(posMin[c][1], j) //Left
+      posMax[c][0] = Math.max(posMax[c][0], i) //Down
+      posMax[c][1] = Math.max(posMax[c][1], j) //Right
     }
   }
-  while (colorSet.size > 0) {
+  while (colorSet.size) {
     const tmp = new Set()
     for (let color of colorSet) {
       if (!isRect(targetGrid, color)) {
@@ -45,6 +45,7 @@ const isPrintable = function (targetGrid) {
         A[i][j] = 0
       }
     }
+
     return true
   }
 }

From b8cc0d1c51b2b3bc2b60d2acb4ab04dead3a7702 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 16:52:13 +0800
Subject: [PATCH 1385/3374] Create 1863-sum-of-all-subset-xor-totals.js

---
 1863-sum-of-all-subset-xor-totals.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1863-sum-of-all-subset-xor-totals.js

diff --git a/1863-sum-of-all-subset-xor-totals.js b/1863-sum-of-all-subset-xor-totals.js
new file mode 100644
index 00000000..1597b8b1
--- /dev/null
+++ b/1863-sum-of-all-subset-xor-totals.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const subsetXORSum = function(nums) {
+  let res = {sum: 0}
+  
+  helper(nums, 0, [], res)
+  return res.sum
+};
+
+function helper(arr, idx, cur, res) {
+  if(idx === arr.length) {
+    res.sum += calc(cur)
+    return
+  }
+  const clone = cur.slice()
+  helper(arr, idx + 1, clone, res)
+  const c2 = cur.slice()
+  c2.push(arr[idx])
+  helper(arr, idx + 1, c2, res)
+}
+
+function calc(arr) {
+  let res = 0
+  for(let e of arr) res ^= e
+  return res
+}

From 7489b958c0d92da37823a446d4431d90a120a2b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 16:54:02 +0800
Subject: [PATCH 1386/3374] Create
 1864-minimum-number-of-swaps-to-make-the-binary-string-alternating.js

---
 ...s-to-make-the-binary-string-alternating.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 1864-minimum-number-of-swaps-to-make-the-binary-string-alternating.js

diff --git a/1864-minimum-number-of-swaps-to-make-the-binary-string-alternating.js b/1864-minimum-number-of-swaps-to-make-the-binary-string-alternating.js
new file mode 100644
index 00000000..86d29d67
--- /dev/null
+++ b/1864-minimum-number-of-swaps-to-make-the-binary-string-alternating.js
@@ -0,0 +1,53 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minSwaps = function(s) {
+  const valid = chk(s)
+  if(valid === -1) return -1
+  const [zeroNum, oneNum] = valid
+  let res = Infinity
+  if(zeroNum === oneNum) {
+    // zero start
+    let tmpZero = 0
+    let cur = '0'
+    for(let i = 0; i < s.length; i++) {
+      if(i % 2 === 0 && s[i] !== '0') tmpZero++
+    }
+    
+    res = Math.min(tmpZero, res)
+    // one start
+    let tmpOne = 0
+    cur = '1'
+    for(let i = 0; i < s.length; i++) {
+      if(i % 2 === 0 && s[i] !== '1') tmpOne++
+    }
+    res = Math.min(tmpOne, res)
+  } else if(zeroNum > oneNum) {
+    let tmpZero = 0
+    let cur = '0'
+    for(let i = 0; i < s.length; i++) {
+      if(i % 2 === 0 && s[i] !== '0') tmpZero++
+    }
+    
+    res = Math.min(tmpZero, res)     
+  } else {
+    let tmpOne = 0
+    cur = '1'
+    for(let i = 0; i < s.length; i++) {
+      if(i % 2 === 0 && s[i] !== '1') tmpOne++
+    }
+    res = Math.min(tmpOne, res)
+  }
+  return res
+};
+
+function chk(str) {
+  let oneNum = 0, zeroNum = 0
+  for(let ch of str) {
+    if(ch === '0') zeroNum++
+    else oneNum++
+  } 
+  return Math.abs(zeroNum - oneNum) <= 1 ? [zeroNum, oneNum] : -1
+}
+

From 9cb36a08c19d0548e81fe7b6723e5da05740f09a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 16:54:34 +0800
Subject: [PATCH 1387/3374] Create 1865-finding-pairs-with-a-certain-sum.js

---
 1865-finding-pairs-with-a-certain-sum.js | 50 ++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1865-finding-pairs-with-a-certain-sum.js

diff --git a/1865-finding-pairs-with-a-certain-sum.js b/1865-finding-pairs-with-a-certain-sum.js
new file mode 100644
index 00000000..984fd296
--- /dev/null
+++ b/1865-finding-pairs-with-a-certain-sum.js
@@ -0,0 +1,50 @@
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ */
+const FindSumPairs = function(nums1, nums2) {
+  this.nums1 = nums1
+  this.nums2 = nums2
+  const m = nums1.length, n = nums2.length
+  this.mp = {}
+  for(let x of nums2) {
+    if(this.mp[x] == null) this.mp[x] = 0
+    this.mp[x]++
+  }
+};
+
+/** 
+ * @param {number} index 
+ * @param {number} val
+ * @return {void}
+ */
+FindSumPairs.prototype.add = function(index, val) {
+  if(val !== 0) {
+    if(!(--this.mp[this.nums2[index]])) delete this.mp[this.nums2[index]]    
+  }
+  this.nums2[index] += val
+  if(this.mp[this.nums2[index]] == null) this.mp[this.nums2[index]] = 0
+  if(val !== 0)this.mp[this.nums2[index]]++
+};
+
+/** 
+ * @param {number} tot
+ * @return {number}
+ */
+FindSumPairs.prototype.count = function(tot) {
+  let ans = 0;
+  for (let x of this.nums1) {
+    let res = tot - x;
+    if (!this.mp[res]) continue;
+    ans += this.mp[res];
+  }
+  return ans;
+};
+
+/** 
+ * Your FindSumPairs object will be instantiated and called as such:
+ * var obj = new FindSumPairs(nums1, nums2)
+ * obj.add(index,val)
+ * var param_2 = obj.count(tot)
+ */

From 1ad83f5781f525280907899aa8fe31c67e9998e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 16:55:07 +0800
Subject: [PATCH 1388/3374] Create
 1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js

---
 ...-to-rearrange-sticks-with-k-sticks-visible.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js

diff --git a/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js b/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js
new file mode 100644
index 00000000..4ff4a255
--- /dev/null
+++ b/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const rearrangeSticks = function(n, k) {
+  const mod = BigInt(1e9 + 7)
+  const g = Array.from({ length: 1001 }, () => Array(1001).fill(0n))
+  g[1][1] = 1n
+  for(let i = 2; i <= 1000; i++) {
+    for(let j = 1; j <= i; j++ ) {
+      g[i][j] = (g[i - 1][j - 1] + BigInt(i - 1) * g[i - 1][j] % mod) % mod
+    }
+  }
+  return g[n][k]
+};

From 2f842ea60ca320ebfab3e614684381652d358a57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 19:55:12 +0800
Subject: [PATCH 1389/3374] Create 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1462-course-schedule-iv.js

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
new file mode 100644
index 00000000..7faaa98d
--- /dev/null
+++ b/1462-course-schedule-iv.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const checkIfPrerequisite = function(numCourses, prerequisites, queries) {
+  const n = numCourses
+  const connected = Array.from({ length: n }, () => Array(n).fill(false))
+  for(let p of prerequisites) connected[p[0]][p[1]] = true
+  for(let k = 0; k < n; k++) {
+    for(let i = 0; i < n; i++) {
+      for(let j = 0; j < n; j++) {
+        connected[i][j] = connected[i][j] || (connected[i][k] && connected[k][j]);
+      }
+    }
+  }
+  const res = []
+  for(let q of queries) res.push(connected[q[0]][q[1]])
+  return res
+};

From 4b7fd933c957a66645ca6da9e8334d3375082d1f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 May 2021 20:08:43 +0800
Subject: [PATCH 1390/3374] Update 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index 7faaa98d..33ec5f9c 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -5,6 +5,7 @@
  * @return {boolean[]}
  */
 const checkIfPrerequisite = function(numCourses, prerequisites, queries) {
+  // https://en.wikipedia.org/wiki/Floyd%E2%80%93Warshall_algorithm
   const n = numCourses
   const connected = Array.from({ length: n }, () => Array(n).fill(false))
   for(let p of prerequisites) connected[p[0]][p[1]] = true

From b16714220e995264b85f7a2d0fbec60082377604 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 May 2021 19:50:40 +0800
Subject: [PATCH 1391/3374] Create 802-find-eventual-safe-states.js

---
 802-find-eventual-safe-states.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 802-find-eventual-safe-states.js

diff --git a/802-find-eventual-safe-states.js b/802-find-eventual-safe-states.js
new file mode 100644
index 00000000..44a5d8b4
--- /dev/null
+++ b/802-find-eventual-safe-states.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+const eventualSafeNodes = function(graph) {
+  const n = graph.length, memo = {}, visited = new Set(), res = []
+  for(let i = 0; i < n; i++) {
+    if(!dfs(graph, i, memo, visited)) res.push(i)
+  }
+  return res
+};
+
+function dfs(graph, node, memo, visited) {
+  if(memo[node] != null) return memo[node]
+  let hasCycle = false
+  visited.add(node)
+  for(let e of graph[node]) {
+    if(visited.has(e) || dfs(graph, e, memo, visited)) {
+      hasCycle = true
+      break
+    }
+  }
+  visited.delete(node)
+  memo[node] = hasCycle
+  return hasCycle
+}

From 55dbfa6b8e120b1bcfa5b34f43f4db35eb85b43f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 May 2021 20:32:24 +0800
Subject: [PATCH 1392/3374] Create
 1867-orders-with-maximum-quantity-above-average.sql

---
 1867-orders-with-maximum-quantity-above-average.sql | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1867-orders-with-maximum-quantity-above-average.sql

diff --git a/1867-orders-with-maximum-quantity-above-average.sql b/1867-orders-with-maximum-quantity-above-average.sql
new file mode 100644
index 00000000..744035ce
--- /dev/null
+++ b/1867-orders-with-maximum-quantity-above-average.sql
@@ -0,0 +1,10 @@
+# Write your MySQL query statement below
+select order_id from OrdersDetails
+group by order_id
+having max(quantity) > (
+  select max(avg_quantity) from
+  (select order_id, sum(quantity) / count(product_id) as avg_quantity 
+    from OrdersDetails
+    group by order_id
+  ) t
+);

From c8493e0646e9941922023dbfe658427d66c8eda4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 May 2021 20:55:04 +0800
Subject: [PATCH 1393/3374] Create 1859-sorting-the-sentence.js

---
 1859-sorting-the-sentence.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1859-sorting-the-sentence.js

diff --git a/1859-sorting-the-sentence.js b/1859-sorting-the-sentence.js
new file mode 100644
index 00000000..8da3d884
--- /dev/null
+++ b/1859-sorting-the-sentence.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const sortSentence = function(s) {
+  const arr = s.split(' ')
+  const n = arr.length, res = Array(n)
+  for(let e of arr) {
+    const idx = +e[e.length - 1]
+    res[idx - 1] = e.slice(0, e.length - 1)
+  }
+  return res.join(' ')
+};

From 79d92cafc820512ef4717023ecb74ade52d87fd9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 May 2021 21:42:00 +0800
Subject: [PATCH 1394/3374] Create 1860-incremental-memory-leak.js

---
 1860-incremental-memory-leak.js | 34 +++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1860-incremental-memory-leak.js

diff --git a/1860-incremental-memory-leak.js b/1860-incremental-memory-leak.js
new file mode 100644
index 00000000..2eaf5bbd
--- /dev/null
+++ b/1860-incremental-memory-leak.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} memory1
+ * @param {number} memory2
+ * @return {number[]}
+ */
+const memLeak = function(memory1, memory2) {
+  let i = 1
+  const res = Array(3).fill(0)
+  res[0] = 1
+  res[1] = memory1
+  res[2] = memory2
+  while(true) {
+    if(res[1] >= i || res[2] >= i) {
+      if(res[1] >= i && res[2] >= i) {
+        if(res[1] === res[2]) {
+           res[1] -= i
+        } else if(res[1] > res[2]) {
+          res[1] -= i
+        } else {
+          res[2] -= i
+        }
+      } else if(res[1] >= i) {
+        res[1] -= i
+      } else if(res[2] >= i){
+        res[2] -= i
+      }
+    } else {
+      res[0] = i
+      return res
+    }
+    
+    i++
+  }
+};

From 9f2a4d917c07e457a9599c6286577dc5369cfbd8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 May 2021 21:31:21 +0800
Subject: [PATCH 1395/3374] Update 48-rotate-image.js

---
 48-rotate-image.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/48-rotate-image.js b/48-rotate-image.js
index 7274fa2d..ba36f95b 100644
--- a/48-rotate-image.js
+++ b/48-rotate-image.js
@@ -21,3 +21,22 @@ const rotate = function(matrix) {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+const rotate = function (matrix) {
+  matrix.reverse()
+  for (let i = 0; i < matrix.length; ++i) {
+    for (let j = i + 1; j < matrix[i].length; ++j) swap(matrix, i, j)
+  }
+}
+
+function swap(matrix, i, j) {
+  const tmp = matrix[j][i]
+  matrix[j][i] = matrix[i][j]
+  matrix[i][j] = tmp
+}

From 23285ac43dd10faba985d5fdd90713282aa0aa4f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 May 2021 19:33:22 +0800
Subject: [PATCH 1396/3374] Create 1861-rotating-the-box.js

---
 1861-rotating-the-box.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1861-rotating-the-box.js

diff --git a/1861-rotating-the-box.js b/1861-rotating-the-box.js
new file mode 100644
index 00000000..dd5c683e
--- /dev/null
+++ b/1861-rotating-the-box.js
@@ -0,0 +1,26 @@
+/**
+ * @param {character[][]} box
+ * @return {character[][]}
+ */
+const rotateTheBox = function(box) {
+  const m = box.length, n = box[0].length
+  const res = Array.from({ length: n }, () => Array(m).fill('.'))
+  for(let i = 0; i < m; i++) {
+    let j = n - 1
+    let pos = j
+    while(j >= 0) {
+      if(box[i][j] === '*') {
+        pos = j - 1
+      } else if(box[i][j] === '#') {
+        box[i][j] = '.'
+        box[i][pos] = '#'
+        res[pos][m - 1 - i] = '#'
+        pos--
+      }
+      res[j][m - 1 - i] = box[i][j]
+      j--
+    }
+    
+  }
+  return res
+};

From c855c194bfa88f42bdded4a7e3839dcb51076eee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 May 2021 22:09:46 +0800
Subject: [PATCH 1397/3374] Update 1861-rotating-the-box.js

---
 1861-rotating-the-box.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1861-rotating-the-box.js b/1861-rotating-the-box.js
index dd5c683e..dcd137ee 100644
--- a/1861-rotating-the-box.js
+++ b/1861-rotating-the-box.js
@@ -1,3 +1,27 @@
+/**
+ * @param {character[][]} box
+ * @return {character[][]}
+ */
+const rotateTheBox = function(box) {
+  const m = box.length, n = box[0].length
+  const res = Array.from({ length: n }, () => Array(m).fill('.'))
+  for(let i = 0; i < m; i++) {
+    for(let j = n - 1, pos = n - 1; j >= 0; j--) {
+      if(box[i][j] === '.') continue
+      if(box[i][j] === '#') {
+        res[pos][m - 1 - i] = '#'
+        pos--
+      } else {
+        res[j][m - 1 - i] = '*'
+        pos = j - 1
+      }
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {character[][]} box
  * @return {character[][]}

From 519e72e1a6ce5b585910e0daee1ae3db3471d234 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 May 2021 19:28:25 +0800
Subject: [PATCH 1398/3374] Create 1862-sum-of-floored-pairs.js

---
 1862-sum-of-floored-pairs.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1862-sum-of-floored-pairs.js

diff --git a/1862-sum-of-floored-pairs.js b/1862-sum-of-floored-pairs.js
new file mode 100644
index 00000000..bd6ac4f7
--- /dev/null
+++ b/1862-sum-of-floored-pairs.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfFlooredPairs = function (nums) {
+  const MAX = Math.max(...nums)
+  const countsGreaterOrEqualTo = new Array(MAX + 1).fill(0)
+  const numCounts = new Map()
+  const MOD = 1e9 + 7
+  nums.forEach((num) => {
+    countsGreaterOrEqualTo[num]++
+    numCounts.set(num, (numCounts.get(num) || 0) + 1)
+  })
+
+  for (let num = MAX - 1; num >= 0; num--) {
+    countsGreaterOrEqualTo[num] += countsGreaterOrEqualTo[num + 1]
+  }
+  
+  let totalCount = 0
+  numCounts.forEach((count, num) => {
+    let current = num
+    while (current <= MAX) {
+      totalCount = (totalCount + countsGreaterOrEqualTo[current] * count) % MOD
+      current += num
+    }
+  })
+
+  return totalCount
+}

From db3653cb9d9d6c7e1e2f672bf4535df1389454c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 May 2021 14:00:11 +0800
Subject: [PATCH 1399/3374] Update 470-implement-rand10-using-rand7.js

---
 470-implement-rand10-using-rand7.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/470-implement-rand10-using-rand7.js b/470-implement-rand10-using-rand7.js
index 9ea03193..eef7543c 100644
--- a/470-implement-rand10-using-rand7.js
+++ b/470-implement-rand10-using-rand7.js
@@ -10,3 +10,17 @@ const rand10 = function() {
   }
   return (result % 10) + 1
 }
+
+// another
+
+/**
+ * The rand7() API is already defined for you.
+ * var rand7 = function() {}
+ * @return {number} a random integer in the range 1 to 7
+ */
+const rand10 = function() {
+  let tmp = 40
+  while(tmp >= 40) tmp = 7 * (rand7() - 1) + (rand7() - 1)
+  
+  return tmp % 10 + 1
+};

From e882167372ee999aa0f5d56342d8d5be963876f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 May 2021 22:41:32 +0800
Subject: [PATCH 1400/3374] Update
 1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js

---
 ...-rearrange-sticks-with-k-sticks-visible.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js b/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js
index 4ff4a255..e652838e 100644
--- a/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js
+++ b/1866-number-of-ways-to-rearrange-sticks-with-k-sticks-visible.js
@@ -14,3 +14,28 @@ const rearrangeSticks = function(n, k) {
   }
   return g[n][k]
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const rearrangeSticks = function(n, k) {
+    const MOD = 1e9 + 7;
+    // first # can be smallest # in which case we recurse for (n - 1, k - 1) 
+    // or it can not be and smallest can be in any of n - 1 otehr positions for recursed(n - 1, k)
+    const dp = new Array(n + 1).fill().map( _ => new Array(k + 1).fill(0) );
+    for (let i = 1; i <= n; ++i) {
+        for (let j = 1; j <= k; ++j) {
+            if (j === i) {
+                dp[i][j] = 1;
+            } else if (j < i) {
+                dp[i][j] = (dp[i - 1][j - 1] + (i - 1) * dp[i - 1][j]) % MOD;
+            }
+        }
+    }
+    return dp[n][k] % MOD;
+    
+};

From e939e0ad082171877d5b3e5afb9f4bd1d4efe923 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 May 2021 13:56:11 +0800
Subject: [PATCH 1401/3374] Update 903-valid-permutations-for-di-sequence.js

---
 903-valid-permutations-for-di-sequence.js | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/903-valid-permutations-for-di-sequence.js b/903-valid-permutations-for-di-sequence.js
index a46b3fbd..8e5aaa60 100644
--- a/903-valid-permutations-for-di-sequence.js
+++ b/903-valid-permutations-for-di-sequence.js
@@ -1,3 +1,34 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numPermsDISequence = function(s) {
+  const n = s.length, mod = 1e9 + 7
+  const dp = Array.from({ length: n + 1}, () => Array(n + 1).fill(0))
+  dp[0][0] = 1
+  for(let i = 1; i <= n; i++) {
+    for(let j = 0; j <= i; j++) {
+      if(s[i - 1] === 'D') {
+        for(let k = j; k <= i - 1; k++) {
+          dp[i][j] = (dp[i][j] + dp[i - 1][k]) % mod
+        }
+      } else {
+        for(let k = 0; k < j; k++) {
+          dp[i][j] = (dp[i][j] + dp[i - 1][k]) % mod
+        }
+      }
+    }
+  }
+  let res = 0
+  for(let i = 0; i <= n; i++) {
+    res = (res + dp[n][i]) % mod
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} S
  * @return {number}

From 57f65ceac86b1bcd96be4d8f14ba0a8cbfa9b770 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 12:41:21 +0800
Subject: [PATCH 1402/3374] Create 1870-minimum-speed-to-arrive-on-time.js

---
 1870-minimum-speed-to-arrive-on-time.js | 27 +++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1870-minimum-speed-to-arrive-on-time.js

diff --git a/1870-minimum-speed-to-arrive-on-time.js b/1870-minimum-speed-to-arrive-on-time.js
new file mode 100644
index 00000000..975e6fa5
--- /dev/null
+++ b/1870-minimum-speed-to-arrive-on-time.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} dist
+ * @param {number} hour
+ * @return {number}
+ */
+const minSpeedOnTime = function(dist, hour) {
+  const sum = dist.reduce((ac, e) => ac + e, 0)
+  let l = 1, r = 10 ** 7
+  while(l < r) {
+    let mid = l + ((r - l) >> 1)
+    if(chk(mid)) r = mid
+    else l = mid + 1
+  }
+
+  return chk(l) ? l : -1
+  
+  function chk(speed) {
+    let res = 0
+    for(let i = 0, len = dist.length; i < len - 1; i++) {
+      res += Math.ceil(dist[i] / speed)
+    }
+    if (dist.length) res += dist[dist.length - 1] / speed 
+    return res <= hour
+  }
+  
+};
+

From 55f98275f156e388e96e5c7cfd81051901b4aa3d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 12:42:24 +0800
Subject: [PATCH 1403/3374] Create
 1869-longer-contiguous-segments-of-ones-than-zeros.js

---
 ...-contiguous-segments-of-ones-than-zeros.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1869-longer-contiguous-segments-of-ones-than-zeros.js

diff --git a/1869-longer-contiguous-segments-of-ones-than-zeros.js b/1869-longer-contiguous-segments-of-ones-than-zeros.js
new file mode 100644
index 00000000..8fbceb89
--- /dev/null
+++ b/1869-longer-contiguous-segments-of-ones-than-zeros.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkZeroOnes = function(s) {
+  const stack = []
+  let zl = 0, ol = 0
+  for(let e of s) {
+    let tmp = 0, zo = ''
+    while(stack.length && stack[stack.length - 1] !== e) {
+      if(zo === '') zo = stack[stack.length - 1]
+      tmp++
+      stack.pop()
+    }
+    if(zo === '1') ol = Math.max(tmp, ol)
+    if(zo === '0') zl = Math.max(tmp, zl)
+    stack.push(e)
+  } 
+  if(stack.length) {
+    let zo = stack[stack.length - 1]
+    if(zo === '1') ol = Math.max(stack.length, ol)
+    if(zo === '0') zl = Math.max(stack.length, zl)
+  }
+  return ol > zl
+};

From ead91d2398453b72d7f3a524afbecbee79ade778 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 12:43:44 +0800
Subject: [PATCH 1404/3374] Create 1872-stone-game-viii.js

---
 1872-stone-game-viii.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1872-stone-game-viii.js

diff --git a/1872-stone-game-viii.js b/1872-stone-game-viii.js
new file mode 100644
index 00000000..e6067265
--- /dev/null
+++ b/1872-stone-game-viii.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+const stoneGameVIII = function (A) {
+  let N = A.length,
+    ans = -Infinity
+  for (let i = 1; i < N; ++i) A[i] += A[i - 1] // now A[i] becomes prefix[i]
+  let mx = A[N - 1] // dp[N - 1] = prefix[N - 1]
+  for (let i = N - 2; i >= 0; --i) {
+    ans = Math.max(ans, mx) // since dp[i] = mx, we try to use dp[i] to update ans.
+    mx = Math.max(mx, A[i] - mx) // try to update mx using prefix[i] - dp[i]
+  }
+  return ans
+}

From 3ad1e30a03cd6bee881713369f9bf23121063b1f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 12:44:20 +0800
Subject: [PATCH 1405/3374] Create 1871-jump-game-vii.js

---
 1871-jump-game-vii.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1871-jump-game-vii.js

diff --git a/1871-jump-game-vii.js b/1871-jump-game-vii.js
new file mode 100644
index 00000000..7913a351
--- /dev/null
+++ b/1871-jump-game-vii.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {number} minJump
+ * @param {number} maxJump
+ * @return {boolean}
+ */
+const canReach = function(s, minJump, maxJump) {
+  let n = s.length;
+  const {max, min} = Math
+  if (s[n - 1] != '0') return false;
+  const pre_sum = Array(n + 1).fill(0);
+  const check = Array(n + 1).fill(0);
+  check[1] = 1;
+  pre_sum[1] = 1;
+  for (let i = 1; i < n; i++) {
+      pre_sum[i + 1] = pre_sum[i];
+      if (s[i] == '1') continue;
+      if (i < minJump) continue;
+      let r = i - minJump;
+      let l = max(0, i - maxJump);
+      if (pre_sum[r + 1] - pre_sum[l] == 0) continue;
+      check[i + 1] = true;
+      pre_sum[i + 1]++;
+  }
+  return check[n];
+};

From 31fcfc8a250c66890064cb86bc97aaf82b02ed52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 14:31:31 +0800
Subject: [PATCH 1406/3374] Update 1871-jump-game-vii.js

---
 1871-jump-game-vii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1871-jump-game-vii.js b/1871-jump-game-vii.js
index 7913a351..c3950653 100644
--- a/1871-jump-game-vii.js
+++ b/1871-jump-game-vii.js
@@ -1,3 +1,31 @@
+/**
+ * @param {string} s
+ * @param {number} minJump
+ * @param {number} maxJump
+ * @return {boolean}
+ */
+const canReach = function(s, minJump, maxJump) {
+  const n = s.length
+  const queue = [0]
+  let mx = 0
+  const { max, min } = Math
+  while(queue.length) {
+    const i = queue.shift()
+    for(let j = max(i + minJump, mx + 1); j < min(s.length, i + maxJump + 1); j++) {
+      if(s[j] === '0') {
+        if(j === n - 1) return true
+        queue.push(j)
+      }
+    }
+    mx = i + maxJump
+  }
+  
+  return false
+};
+
+
+// another
+
 /**
  * @param {string} s
  * @param {number} minJump

From 29169117546797e43150f170b35fd3e387a9ac00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 May 2021 21:05:50 +0800
Subject: [PATCH 1407/3374] Update 1094-car-pooling.js

---
 1094-car-pooling.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1094-car-pooling.js b/1094-car-pooling.js
index 9b82dc84..3d987e2d 100644
--- a/1094-car-pooling.js
+++ b/1094-car-pooling.js
@@ -12,3 +12,27 @@ const carPooling = function(trips, capacity) {
   for (let i = 0; capacity >= 0 && i < 1001; ++i) capacity -= stops[i]
   return capacity >= 0
 }
+
+// another
+
+/**
+ * @param {number[][]} trips
+ * @param {number} capacity
+ * @return {boolean}
+ */
+const carPooling = function(trips, capacity) {
+  const arr = Array(1001).fill(0)
+  for(let el of trips) {
+    const [num, s, e] = el
+    arr[s] += num
+    arr[e] -= num
+  }
+  for(let i = 1; i < 1001; i++) {
+    if(arr[i] !== 0) arr[i] += arr[i - 1]
+    else arr[i] = arr[i - 1]
+  }
+  for(let e of arr) {
+    if(e > capacity) return false
+  }
+  return true
+};

From 88accd7f6bd06737437d42f0b54c8c3fac708777 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 May 2021 13:22:27 +0800
Subject: [PATCH 1408/3374] Update 1109-corporate-flight-bookings.js

---
 1109-corporate-flight-bookings.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1109-corporate-flight-bookings.js b/1109-corporate-flight-bookings.js
index d326526c..bb980cc8 100644
--- a/1109-corporate-flight-bookings.js
+++ b/1109-corporate-flight-bookings.js
@@ -12,3 +12,23 @@ const corpFlightBookings = function(bookings, n) {
   for (let i = 1; i < n; ++i) res[i] += res[i - 1]
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} bookings
+ * @param {number} n
+ * @return {number[]}
+ */
+const corpFlightBookings = function(bookings, n) {
+  const arr = Array(n + 2).fill(0)
+  for(let [s, e, num] of bookings) {
+    arr[s] += num
+    arr[e + 1] -= num
+  }
+  for(let i = 1; i <= n; i++) {
+    if(arr[i] !== 0) arr[i] += arr[i - 1]
+    else arr[i] = arr[i - 1]
+  }
+  return arr.slice(1, n + 1)
+};

From b3de8abe3462511d6ba099b03df3ee418b3e4401 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 May 2021 21:04:46 +0800
Subject: [PATCH 1409/3374] Update 759-employee-free-time.js

---
 759-employee-free-time.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/759-employee-free-time.js b/759-employee-free-time.js
index 401a5d9f..ff19b672 100644
--- a/759-employee-free-time.js
+++ b/759-employee-free-time.js
@@ -113,3 +113,35 @@ const employeeFreeTime = function(schedule) {
   }
   return res
 }
+
+// another
+
+/**
+ * // Definition for an Interval.
+ * function Interval(start, end) {
+ *    this.start = start;
+ *    this.end = end;
+ * };
+ */
+
+/**
+ * @param {Interval[][]} schedule
+ * @return {Interval[]}
+ */
+const employeeFreeTime = function (schedule) {
+  const res = [], timeLine = []
+  schedule.forEach(e => timeLine.push(...e))
+  timeLine.sort((a, b) => a.start - b.start)
+  let tmp = timeLine[0]
+  for(let i = 1, n = timeLine.length; i < n; i++) {
+    const el = timeLine[i]
+    if(el.start > tmp.end) {
+      res.push(new Interval(tmp.end, el.start))
+      tmp = el
+    } else {
+      tmp = el.end > tmp.end ? el : tmp
+    }
+  }
+  return res
+}
+

From 0e77faebddc32b773407f547bc1452736d9ded57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 May 2021 21:59:12 +0800
Subject: [PATCH 1410/3374] Update 5-longest-palindromic-substring.js

---
 5-longest-palindromic-substring.js | 37 ++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/5-longest-palindromic-substring.js b/5-longest-palindromic-substring.js
index 1c460a1f..76afe7f4 100755
--- a/5-longest-palindromic-substring.js
+++ b/5-longest-palindromic-substring.js
@@ -70,3 +70,40 @@ function preProcess(s) {
   ret += "#$";
   return ret;
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const longestPalindrome = function(s) {
+  const n = s.length
+  let res = ''
+  for(let i = 0; i < n; i++) {
+    const first = chk(s, i, i, n)
+    if(first.length > res.length) res = first
+    const second = chk(s, i, i + 1, n)
+    if(second.length > res.length) res = second
+  }
+  return res
+};
+
+function chk(str, i, j, n) {
+  if(j >= n) return str[i]
+  let l = i, r = j
+  while(l >= 0 && r < n) {
+    if(str[l] === str[r]) {
+      l--
+      r++
+    } else {
+      return str.slice(l + 1, r)
+    }
+  }
+  if(l < 0) {
+    return str.slice(0, r)
+  } else {
+    return str.slice(l + 1, n)
+  }
+}
+

From 23a0f022c98a057fd0e42ec7b52b3b742c47abd7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 May 2021 22:09:06 +0800
Subject: [PATCH 1411/3374] Update 1871-jump-game-vii.js

---
 1871-jump-game-vii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1871-jump-game-vii.js b/1871-jump-game-vii.js
index c3950653..ace67d12 100644
--- a/1871-jump-game-vii.js
+++ b/1871-jump-game-vii.js
@@ -52,3 +52,25 @@ const canReach = function(s, minJump, maxJump) {
   }
   return check[n];
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} minJump
+ * @param {number} maxJump
+ * @return {boolean}
+ */
+const canReach = function(s, minJump, maxJump) {
+  const n = s.length, dp = Array(n).fill(0)
+  dp[0] = 1
+  let pre = 0
+  for(let i = 1; i < n; i++) {
+    if(i >= minJump) {
+      pre += dp[i - minJump]
+    }
+    if(i > maxJump) pre -= dp[i - maxJump - 1]
+    dp[i] = pre > 0 && s[i] === '0' ? 1 : 0
+  }
+  return dp[n - 1]
+};

From c5577654b39813bd9d72d2f6c5ab474d0ad96f1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 May 2021 21:37:49 +0800
Subject: [PATCH 1412/3374] Update
 995-minimum-number-of-k-consecutive-bit-flips.js

---
 ...nimum-number-of-k-consecutive-bit-flips.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/995-minimum-number-of-k-consecutive-bit-flips.js b/995-minimum-number-of-k-consecutive-bit-flips.js
index ae3a47d1..4b26d18b 100644
--- a/995-minimum-number-of-k-consecutive-bit-flips.js
+++ b/995-minimum-number-of-k-consecutive-bit-flips.js
@@ -16,3 +16,31 @@ const minKBitFlips = function(A, K) {
     }
     return res;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minKBitFlips = function(nums, k) {
+  const n = nums.length, q = []
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    if(nums[i] === 0) {
+      if(q.length === 0 || q.length % 2 === 0) {
+        res++
+        q.push(i + k - 1)
+      }
+    } else {
+      if(q.length % 2 === 1) {
+        res++
+        q.push(i + k - 1)
+      }
+    }
+    if(q.length && i >= q[0]) q.shift()
+  }
+  return q.length ? -1 : res
+};
+

From bc23f401748f7e9777a1ebf7c257490275500ab6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 May 2021 20:53:40 +0800
Subject: [PATCH 1413/3374] Update 48-rotate-image.js

---
 48-rotate-image.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/48-rotate-image.js b/48-rotate-image.js
index ba36f95b..83583d57 100644
--- a/48-rotate-image.js
+++ b/48-rotate-image.js
@@ -40,3 +40,27 @@ function swap(matrix, i, j) {
   matrix[j][i] = matrix[i][j]
   matrix[i][j] = tmp
 }
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ * @return {void} Do not return anything, modify matrix in-place instead.
+ */
+const rotate = function (matrix) {
+  matrix.reverse()
+  for (let i = 0; i < matrix.length; ++i) {
+    for (let j = matrix[i].length - 1; j > i; j--) swap(matrix, i, j)
+  }
+}
+
+function swap(matrix, i, j) {
+  const tmp = matrix[j][i]
+  matrix[j][i] = matrix[i][j]
+  matrix[i][j] = tmp
+}
+/*
+1 2 3      7 8 9     7 4 1
+4 5 6 ---> 4 5 6 --->8 5 2
+7 8 9      1 2 3     9 6 3
+*/

From e6342d176b745893c33ab320926cc96238f103cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 May 2021 22:12:28 +0800
Subject: [PATCH 1414/3374] Update 1870-minimum-speed-to-arrive-on-time.js

---
 1870-minimum-speed-to-arrive-on-time.js | 28 +++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1870-minimum-speed-to-arrive-on-time.js b/1870-minimum-speed-to-arrive-on-time.js
index 975e6fa5..0a59cb8b 100644
--- a/1870-minimum-speed-to-arrive-on-time.js
+++ b/1870-minimum-speed-to-arrive-on-time.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} dist
+ * @param {number} hour
+ * @return {number}
+ */
+const minSpeedOnTime = function(dist, hour) {
+  let l = 1, r = 1e7
+  while(l <= r) {
+    let mid = (l + r) >> 1
+    if(valid(mid)) r = mid -1
+    else l = mid + 1
+  }
+  return l > 1e7 ? -1 : l
+  
+  function valid(speed) {
+    let sum = 0
+    for(let e of dist) {
+      sum = Math.ceil(sum)
+      sum += e / speed
+      if(sum > hour) return 
+    }
+    
+    return true
+  }
+};
+
+// another
+
 /**
  * @param {number[]} dist
  * @param {number} hour

From 2c061119b8222bb34fc6180d2f41d4886333e4b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 May 2021 10:23:30 +0800
Subject: [PATCH 1415/3374] Update 664-strange-printer.js

---
 664-strange-printer.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/664-strange-printer.js b/664-strange-printer.js
index 2cfa9a33..deb5a1fe 100644
--- a/664-strange-printer.js
+++ b/664-strange-printer.js
@@ -29,3 +29,26 @@ const strangePrinter = function(s) {
 
   return help(s, 0, n - 1)
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const strangePrinter = function(s) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(n))
+  for(let i = 0; i < n; i++) dp[i][i] = 1
+  for(let len = 2; len <= n; len++) {
+    for(let i = 0; i < n - len + 1; i++) {
+      let j = i + len - 1
+      dp[i][j] = 1 + dp[i + 1][j]
+      for(let k = i + 1; k < j; k++) {
+        if(s[i] === s[k]) dp[i][j] = Math.min(dp[i][j], dp[i][k - 1] + dp[k + 1][j])
+      }
+      if(s[i] === s[j]) dp[i][j] = Math.min(dp[i][j - 1], dp[i][j])
+    }
+  }
+  return dp[0][n - 1]
+};

From 09d636bbe3548d5ec3cffec27cfac159e7329030 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 May 2021 12:19:41 +0800
Subject: [PATCH 1416/3374] Create 1882-process-tasks-using-servers.js

---
 1882-process-tasks-using-servers.js | 118 ++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 1882-process-tasks-using-servers.js

diff --git a/1882-process-tasks-using-servers.js b/1882-process-tasks-using-servers.js
new file mode 100644
index 00000000..0ea0dc15
--- /dev/null
+++ b/1882-process-tasks-using-servers.js
@@ -0,0 +1,118 @@
+/**
+ * @param {number[]} servers
+ * @param {number[]} tasks
+ * @return {number[]}
+ */
+const assignTasks = function(servers, tasks) {
+  let i = 0
+  const freePQ = new PriorityQueue((a, b) => {
+    if(a.w < b.w) return true
+    else if(a.w > b.w) return false
+    else {
+      if(a.idx < b.idx) return true
+      return false
+    }
+  })
+  const runningPQ = new PriorityQueue((a, b) => {
+    return a.end < b.end
+  })
+  const res = []
+  for(let i = 0; i < servers.length; i++) {
+    freePQ.push({
+      w: servers[i],
+      idx: i
+    })
+  }
+  let taskIdx = 0
+  while(taskIdx < tasks.length) {
+    while(!runningPQ.isEmpty() && runningPQ.peek().end <= i) {
+      let server = runningPQ.pop()
+      freePQ.push({
+        w: server.w,
+        idx: server.idx
+      })
+    }
+    
+    while(taskIdx <= i && !freePQ.isEmpty() && taskIdx < tasks.length) {
+      const server = freePQ.pop()
+      res[taskIdx] = server.idx
+      runningPQ.push({
+        end: i + tasks[taskIdx],
+        w: server.w,
+        idx: server.idx
+      })
+      taskIdx++
+    }
+    if(i < tasks.length || !freePQ.isEmpty()) i++
+    else i = Math.max(i + 1, runningPQ.peek().end)
+  }
+  return res
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 1abb8c58aa4a64622b5217773af811e8d002328a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 May 2021 20:40:42 +0800
Subject: [PATCH 1417/3374] Create
 1880-check-if-word-equals-summation-of-two-words.js

---
 ...k-if-word-equals-summation-of-two-words.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 1880-check-if-word-equals-summation-of-two-words.js

diff --git a/1880-check-if-word-equals-summation-of-two-words.js b/1880-check-if-word-equals-summation-of-two-words.js
new file mode 100644
index 00000000..54703af5
--- /dev/null
+++ b/1880-check-if-word-equals-summation-of-two-words.js
@@ -0,0 +1,44 @@
+/**
+ * @param {string} firstWord
+ * @param {string} secondWord
+ * @param {string} targetWord
+ * @return {boolean}
+ */
+const isSumEqual = function(firstWord, secondWord, targetWord) {
+  let str = 'abcdefghij'
+  const hash = {}, reverse = {}
+  for(let i = 0; i < str.length; i++) {
+    hash[str[i]] = i
+    reverse[i] = str[i]
+  }
+  let len1 = firstWord.length, len2 = secondWord.length
+  if (len1 < len2) return isSumEqual(secondWord, firstWord, targetWord)
+  // len1 >= len2
+  if (len1 > len2) {
+    for(let i = len1 - len2; i > 0; i--) {
+      secondWord = 'a' + secondWord
+    }
+  }
+  let res = '', inc = 0
+  for(let i = len1 - 1; i >= 0; i--) {
+    const tmp = hash[firstWord[i]] + hash[secondWord[i]] + inc
+    if (tmp > 9) {
+      inc = 1
+    } else {
+      inc = 0
+    }
+    const cur = tmp % 10
+    res = reverse[cur] + res
+  }
+  
+  if(inc) res = 'b' + res
+  // console.log(res)
+  let r1 = '', r2 = ''
+  for(let i = 0; i < targetWord.length; i++) {
+    r1 = r1 + hash[targetWord[i]]
+  }
+  for(let i = 0; i < res.length; i++) {
+    r2 = r2 + hash[res[i]]
+  }
+  return (+r1) === (+r2)
+};

From c3d0f93af71f299fce1b2da3c1e9121df7eb9878 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 May 2021 20:41:16 +0800
Subject: [PATCH 1418/3374] Create 1881-maximum-value-after-insertion.js

---
 1881-maximum-value-after-insertion.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1881-maximum-value-after-insertion.js

diff --git a/1881-maximum-value-after-insertion.js b/1881-maximum-value-after-insertion.js
new file mode 100644
index 00000000..fe1983f1
--- /dev/null
+++ b/1881-maximum-value-after-insertion.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} n
+ * @param {number} x
+ * @return {string}
+ */
+const maxValue = function(n, x) {
+  const neg = n[0] === '-'
+  if (neg) {
+    for(let i = 1; i < n.length; i++) {
+      if(+n[i] > x) {
+        return n.slice(0, i) + x + n.slice(i)
+      }
+    }
+    return n + x
+  } else {
+    for(let i = 0; i < n.length; i++) {
+      if(+n[i] < x) {
+        
+        return n.slice(0, i) + x + n.slice(i)
+      }
+    }
+    return n + x
+  }
+};

From 857ab8a0c20e003f397c54ec59a90188995c7aaf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 May 2021 20:48:25 +0800
Subject: [PATCH 1419/3374] Create
 1883-minimum-skips-to-arrive-at-meeting-on-time.js

---
 ...imum-skips-to-arrive-at-meeting-on-time.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1883-minimum-skips-to-arrive-at-meeting-on-time.js

diff --git a/1883-minimum-skips-to-arrive-at-meeting-on-time.js b/1883-minimum-skips-to-arrive-at-meeting-on-time.js
new file mode 100644
index 00000000..5349fc76
--- /dev/null
+++ b/1883-minimum-skips-to-arrive-at-meeting-on-time.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[]} dist
+ * @param {number} speed
+ * @param {number} hoursBefore
+ * @return {number}
+ */
+const minSkips = function (dist, speed, hoursBefore) {
+  let left = 0
+  let right = dist.length
+
+  while (left < right) {
+    let mid = ~~(left + (right - left) / 2)
+    if (dfs(dist, speed, mid) > 1.0 * hoursBefore) {
+      left = mid + 1
+    } else {
+      right = mid
+    }
+  }
+  return dfs(dist, speed, left) <= 1.0 * hoursBefore ? left : -1
+  function dfs(dist, speed, skips) {
+    const dp = Array.from({ length: dist.length }, () =>
+      Array(skips + 1).fill(0)
+    )
+    let eps = 1e-9
+    for (let i = 0; i <= skips; i++) {
+      dp[0][i] = (dist[0] * 1.0) / speed - eps
+    }
+
+    for (let i = 1; i < dist.length; i++) {
+      dp[i][0] = Math.ceil(dp[i - 1][0]) + (dist[i] * 1.0) / speed - eps
+      for (let j = 1; j <= skips; j++) {
+        let time = dp[i - 1][j - 1] + (dist[i] * 1.0) / speed - eps
+        dp[i][j] = Math.min(
+          time,
+          Math.ceil(dp[i - 1][j]) + (dist[i] * 1.0) / speed - eps
+        )
+      }
+    }
+    return dp[dist.length - 1][skips]
+  }
+}

From 90ab4700ddab4b3d2f64d9e4302a595e20a3dd60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 May 2021 10:37:59 +0800
Subject: [PATCH 1420/3374] Update
 1589-maximum-sum-obtained-of-any-permutation.js

---
 ...maximum-sum-obtained-of-any-permutation.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1589-maximum-sum-obtained-of-any-permutation.js b/1589-maximum-sum-obtained-of-any-permutation.js
index f101a480..0baa6812 100644
--- a/1589-maximum-sum-obtained-of-any-permutation.js
+++ b/1589-maximum-sum-obtained-of-any-permutation.js
@@ -18,3 +18,31 @@ const maxSumRangeQuery = function (nums, requests) {
   for (let i = 0; i < n; ++i) res = (res + nums[i] * count[i]) % mod
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maxSumRangeQuery = function (nums, requests) {
+  const n = nums.length, arr = Array(n + 1).fill(0)
+  for(let [s, e] of requests) {
+    arr[s] += 1
+    arr[e + 1] -= 1
+  }
+  for(let i = 0, cur = 0; i < n; i++) {
+    cur += arr[i]
+    arr[i] = cur
+  }
+  nums.sort((a, b) => b - a)
+  arr.sort((a, b) => b - a)
+  const mod = 1e9 + 7
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    if (arr[i] <= 0) break
+    res = (res + nums[i] * arr[i]) % mod
+  }
+  return res
+}

From 476801b7e1cf9ea4295ad2bbbebae2880de4f1cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Jun 2021 21:54:58 +0800
Subject: [PATCH 1421/3374] Update
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 45 +++++++++----------
 1 file changed, 21 insertions(+), 24 deletions(-)

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
index 99f147c9..7e72432f 100644
--- a/1674-minimum-moves-to-make-array-complementary.js
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -3,27 +3,24 @@
  * @param {number} limit
  * @return {number}
  */
-const minMoves = function(nums, limit) {
-    const min = Math.min, max = Math.max
-    const n = nums.length;
-    const delta = Array(limit * 2 + 2).fill(0);
-    for (let i = 0; i < n / 2; ++i) {
-        let lo = 1 + min(nums[i], nums[n - i - 1]);
-        let hi = limit + max(nums[i], nums[n - i - 1]);
-        let sum = nums[i] + nums[n - i - 1];
-        delta[lo]--;
-        delta[sum]--;
-        delta[sum + 1]++;
-        delta[hi + 1]++;
-    }
-    let now = n;
-    let ans = n;
-    for (let i = 2; i <= limit * 2; ++i) {
-        now += delta[i];
-        ans = min(ans, now);
-    }
-    return ans;  
-};
-
-
-
+const minMoves = function (nums, limit) {
+  const { min, max } = Math
+  const n = nums.length
+  const delta = Array(limit * 2 + 2).fill(0)
+  for (let i = 0; i < n / 2; i++) {
+    const lo = 1 + min(nums[i], nums[n - i - 1])
+    const hi = limit + max(nums[i], nums[n - i - 1])
+    const sum = nums[i] + nums[n - i - 1]
+    delta[lo]--
+    delta[sum]--
+    delta[sum + 1]++
+    delta[hi + 1]++
+  }
+  let now = n
+  let ans = n
+  for (let i = 2; i <= limit * 2; i++) {
+    now += delta[i]
+    ans = min(ans, now)
+  }
+  return ans
+}

From fda25f0e7ea9fe337add55934697b5259235f69b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Jun 2021 23:13:58 +0800
Subject: [PATCH 1422/3374] Update
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
index 7e72432f..2fbf8c14 100644
--- a/1674-minimum-moves-to-make-array-complementary.js
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -24,3 +24,35 @@ const minMoves = function (nums, limit) {
   }
   return ans
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const minMoves = function (nums, limit) {
+  const n = nums.length, { max, min } = Math
+  const delta = Array(2 * limit + 2).fill(0)
+  for(let i = 0; i < n / 2; i++) {
+    const a = nums[i], b = nums[n - 1 - i]
+    // [2, min(a, b) + 1)
+    delta[2] += 2
+    // [min(a, b) + 1, a + b)
+    delta[min(a, b) + 1] -= 1
+    delta[a + b]--
+    // [a + b + 1, max(a, b) + limit]
+    delta[a + b + 1] += 1
+    // (max(a, b) + limit, 2 * limit]
+    delta[max(a, b) + limit + 1] +=1
+  }
+  
+  let res = n, cur = 0
+  for(let i = 2; i <= limit * 2; i++) {
+    cur += delta[i]
+    res = min(cur, res)
+  }
+  
+  return res
+}

From 3de38f15d54afe307b737555e5ffe0ea1f763215 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Jun 2021 19:48:01 +0800
Subject: [PATCH 1423/3374] Create
 1878-get-biggest-three-rhombus-sums-in-a-grid.js

---
 ...et-biggest-three-rhombus-sums-in-a-grid.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 1878-get-biggest-three-rhombus-sums-in-a-grid.js

diff --git a/1878-get-biggest-three-rhombus-sums-in-a-grid.js b/1878-get-biggest-three-rhombus-sums-in-a-grid.js
new file mode 100644
index 00000000..07449480
--- /dev/null
+++ b/1878-get-biggest-three-rhombus-sums-in-a-grid.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[]}
+ */
+const getBiggestThree = function (grid) {
+  const rows = grid.length
+  const cols = grid[0].length
+  const maxSide = Math.ceil(Math.min(rows, cols) / 2)
+  let max1 = 0
+  let max2 = 0
+  let max3 = 0
+  let sum, lastColIndex
+
+  const calcSums = function (row, col) {
+    for (let i = 0; i < maxSide; ++i) {
+      if (row + i < rows && row - i >= 0 && col + i * 2 < cols) {
+        sum = grid[row][col]
+        if (i > 0) {
+          for (let j = 1; j <= i; ++j) {
+            sum += grid[row + j][col + j] + grid[row - j][col + j]
+          }
+          lastColIndex = col + i * 2
+          for (let j = 1; j < i; ++j) {
+            sum +=
+              grid[row + j][lastColIndex - j] + grid[row - j][lastColIndex - j]
+          }
+          sum += grid[row][lastColIndex]
+        }
+
+        if (sum > max1) {
+          max3 = max2
+          max2 = max1
+          max1 = sum
+        } else if (sum > max2 && sum !== max1) {
+          max3 = max2
+          max2 = sum
+        } else if (sum > max3 && sum !== max1 && sum !== max2) {
+          max3 = sum
+        }
+      } else {
+        break
+      }
+    }
+  }
+
+  for (let i = 0; i < rows; ++i) {
+    for (let j = 0; j < cols; ++j) {
+      calcSums(i, j)
+    }
+  }
+
+  return [max1, max2, max3].filter((x) => x)
+}

From 96b9e3fe35942bc1293e5a4540043643ed105d14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Jun 2021 12:51:58 +0800
Subject: [PATCH 1424/3374] Update
 1878-get-biggest-three-rhombus-sums-in-a-grid.js

---
 ...et-biggest-three-rhombus-sums-in-a-grid.js | 56 ++++++-------------
 1 file changed, 16 insertions(+), 40 deletions(-)

diff --git a/1878-get-biggest-three-rhombus-sums-in-a-grid.js b/1878-get-biggest-three-rhombus-sums-in-a-grid.js
index 07449480..357876ca 100644
--- a/1878-get-biggest-three-rhombus-sums-in-a-grid.js
+++ b/1878-get-biggest-three-rhombus-sums-in-a-grid.js
@@ -5,49 +5,25 @@
 const getBiggestThree = function (grid) {
   const rows = grid.length
   const cols = grid[0].length
-  const maxSide = Math.ceil(Math.min(rows, cols) / 2)
-  let max1 = 0
-  let max2 = 0
-  let max3 = 0
-  let sum, lastColIndex
-
-  const calcSums = function (row, col) {
-    for (let i = 0; i < maxSide; ++i) {
-      if (row + i < rows && row - i >= 0 && col + i * 2 < cols) {
-        sum = grid[row][col]
-        if (i > 0) {
-          for (let j = 1; j <= i; ++j) {
-            sum += grid[row + j][col + j] + grid[row - j][col + j]
-          }
-          lastColIndex = col + i * 2
-          for (let j = 1; j < i; ++j) {
-            sum +=
-              grid[row + j][lastColIndex - j] + grid[row - j][lastColIndex - j]
-          }
-          sum += grid[row][lastColIndex]
+  const res = []
+  for(let i = 0; i < rows; i++) {
+    for(let j = 0; j < cols; j++) {
+      for(let size = 0; i - size >= 0 && i + size < rows && j + size * 2 < cols; size++) {
+        let tmp = 0, r = i, c = j
+        do {tmp += grid[r++][c++]} while(r < rows && c < cols && r < i + size)
+        if(size > 0) {
+          do {tmp += grid[r--][c++]} while(c < cols && c < j + 2 * size)
+          do {tmp += grid[r--][c--]} while(r > 0 && r > i - size)
+          do {tmp += grid[r++][c--]} while(c > 0 && r < i)
         }
-
-        if (sum > max1) {
-          max3 = max2
-          max2 = max1
-          max1 = sum
-        } else if (sum > max2 && sum !== max1) {
-          max3 = max2
-          max2 = sum
-        } else if (sum > max3 && sum !== max1 && sum !== max2) {
-          max3 = sum
+        if(res.indexOf(tmp) === -1) res.push(tmp)
+        if(res.length > 3) {
+          res.sort((a, b) => b - a)
+          res.splice(3)
         }
-      } else {
-        break
       }
     }
   }
-
-  for (let i = 0; i < rows; ++i) {
-    for (let j = 0; j < cols; ++j) {
-      calcSums(i, j)
-    }
-  }
-
-  return [max1, max2, max3].filter((x) => x)
+  res.sort((a, b) => b - a)
+  return res
 }

From 3728d6d697b3fd76a1497c0f3f5e57f81b92dbd2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Jun 2021 19:01:26 +0800
Subject: [PATCH 1425/3374] Create 1879-minimum-xor-sum-of-two-arrays.js

---
 1879-minimum-xor-sum-of-two-arrays.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1879-minimum-xor-sum-of-two-arrays.js

diff --git a/1879-minimum-xor-sum-of-two-arrays.js b/1879-minimum-xor-sum-of-two-arrays.js
new file mode 100644
index 00000000..31790237
--- /dev/null
+++ b/1879-minimum-xor-sum-of-two-arrays.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minimumXORSum = function(nums1, nums2) {
+  const dp = Array(1 << nums2.length).fill(Infinity)
+  return dfs(dp, nums1, nums2, 0, 0)
+};
+
+function dfs(dp, a, b, i, mask) {
+  if(i >= a.length) return 0
+  if(dp[mask] === Infinity) {
+    for(let j = 0; j < b.length; j++) {
+      if((mask & (1 << j)) === 0) {
+        dp[mask] = Math.min(dp[mask], (a[i] ^ b[j]) + dfs(dp, a, b, i + 1, mask + (1 << j)))
+      }
+    }
+  }
+  return dp[mask]
+}

From 65e65b3faee663915fd7ead195f37f1832bc1194 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Jun 2021 21:45:50 +0800
Subject: [PATCH 1426/3374] Update 1879-minimum-xor-sum-of-two-arrays.js

---
 1879-minimum-xor-sum-of-two-arrays.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1879-minimum-xor-sum-of-two-arrays.js b/1879-minimum-xor-sum-of-two-arrays.js
index 31790237..7c6232f3 100644
--- a/1879-minimum-xor-sum-of-two-arrays.js
+++ b/1879-minimum-xor-sum-of-two-arrays.js
@@ -19,3 +19,27 @@ function dfs(dp, a, b, i, mask) {
   }
   return dp[mask]
 }
+
+// another
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minimumXORSum = function (nums1, nums2) {
+  const dp = Array(1 << nums2.length).fill(Infinity)
+  return dfs(0, 0)
+  
+  function dfs(i, mask) {
+    if(i >= nums2.length) return 0
+    if(dp[mask] != Infinity) return dp[mask]
+    for(let j = 0; j < nums2.length; j++) {
+      if((mask & (1 << j)) === 0) {
+        dp[mask] = Math.min(dp[mask], (nums1[i] ^ nums2[j]) + dfs(i + 1, mask + (1 << j)) )   
+      }
+    } 
+    return dp[mask]
+  }
+}
+

From da05f4f9f55f832994fc6aea9343887be2ac6513 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Jun 2021 12:00:28 +0800
Subject: [PATCH 1427/3374] Update 1066-campus-bikes-ii.js

---
 1066-campus-bikes-ii.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1066-campus-bikes-ii.js b/1066-campus-bikes-ii.js
index e7b365ce..d3d96ed1 100644
--- a/1066-campus-bikes-ii.js
+++ b/1066-campus-bikes-ii.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[][]} workers
+ * @param {number[][]} bikes
+ * @return {number}
+ */
+const assignBikes = function(workers, bikes) {
+  const n = workers.length, m = bikes.length
+  const dp = Array(1 << m).fill(Infinity)
+  return dfs(0, 0)
+ 
+  function dfs(i, mask) {
+    if(i >= workers.length) return 0
+    if(dp[mask] !== Infinity) return dp[mask]
+    for(let j = 0; j < bikes.length; j++) {
+      if((mask & (1 << j)) === 0) {
+         dp[mask] = Math.min(dp[mask], dist(i, j) + dfs(i + 1, mask + (1 << j)))
+      }
+    }
+    
+    return dp[mask]
+  }
+  
+  function dist(j, i) {
+    return Math.abs(bikes[i][0] - workers[j][0]) + Math.abs(bikes[i][1] - workers[j][1])
+  }
+};
+
+// another
+
 /**
  * @param {number[][]} workers
  * @param {number[][]} bikes

From 64960726671ce845744af2c8fee8706522a27e9e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Jun 2021 13:32:24 +0800
Subject: [PATCH 1428/3374] Create
 1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js

---
 ...s-to-make-the-binary-string-alternating.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js

diff --git a/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
new file mode 100644
index 00000000..fabf8ae1
--- /dev/null
+++ b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
@@ -0,0 +1,48 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minFlips = function (s) {
+  let n = s.length
+  let t = s + s
+  let a0 = 0
+  let a1 = 0
+  let b0 = 0
+  let b1 = 0
+  let ans = Infinity
+  for (let i = 0; i < t.length; i++) {
+      if (t[i] == '0') {
+          if (i % 2 == 0) {
+              a0++
+          } else {
+              b0++
+          }
+      } else {
+          if (i % 2 == 0) {
+              a1++
+          } else {
+              b1++
+          }
+      }
+
+      if (i >= n) {
+          if (t[i - n] == '0') {
+              if ((i - n) % 2 == 0) {
+                  a0--
+              } else {
+                  b0--
+              }
+          } else {
+              if ((i - n) % 2 == 0) {
+                  a1--
+              } else {
+                  b1--
+              }
+          }
+      }
+      ans = Math.min(ans, Math.min(n - a0 - b1, n - a1 - b0))
+  }
+
+  return ans
+}
+

From e8f664c3db5b3be1bcf508544a94c613874d92d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Jun 2021 19:52:42 +0800
Subject: [PATCH 1429/3374] Update
 1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js

---
 ...s-to-make-the-binary-string-alternating.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
index fabf8ae1..da32124d 100644
--- a/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
+++ b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
@@ -46,3 +46,35 @@ const minFlips = function (s) {
   return ans
 }
 
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minFlips = function (s) {
+  const n = s.length
+  s += s
+  let s1 = '', s2 = ''
+  for(let i = 0;i < s.length; i++) {
+    s1 += i % 2 === 0 ? '0' : '1'
+    s2 += i % 2 === 0 ? '1' : '0'
+  }
+  let res1 = 0, res2 = 0, res = Infinity
+  for(let i = 0; i < s.length; i++) {
+    if(s1[i] !== s[i]) res1++
+    if(s2[i] !== s[i]) res2++
+    if(i >= n) {
+      if(s1[i - n] !== s[i - n]) res1--
+      if(s2[i - n] !== s[i - n]) res2--
+    }
+    if(i >= n - 1) {
+      res = Math.min(res, res1, res2)
+    }
+  }
+  
+  return res
+}
+
+
+

From 5acdbbf7ec3559ea5b25c036fe073cee04dba4b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Jun 2021 20:58:56 +0800
Subject: [PATCH 1430/3374] Create
 1886-determine-whether-matrix-can-be-obtained-by-rotation.js

---
 ...ther-matrix-can-be-obtained-by-rotation.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1886-determine-whether-matrix-can-be-obtained-by-rotation.js

diff --git a/1886-determine-whether-matrix-can-be-obtained-by-rotation.js b/1886-determine-whether-matrix-can-be-obtained-by-rotation.js
new file mode 100644
index 00000000..785367a5
--- /dev/null
+++ b/1886-determine-whether-matrix-can-be-obtained-by-rotation.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} mat
+ * @param {number[][]} target
+ * @return {boolean}
+ */
+const findRotation = function(mat, target) {
+  if(chk(mat, target)) return true
+  for(let i = 0; i < 3; i++) {
+    rotate(mat)
+    if(chk(mat, target)) return true
+  }
+  return false
+};
+
+function chk(m1, m2) {
+  for(let i = 0; i < m1.length; i++) {
+    for(let j = 0; j < m1.length; j++) {
+      if(m1[i][j] !== m2[i][j]) return false
+    }
+  }
+  return true
+}
+
+function rotate(matrix) {
+  matrix.reverse()
+  for (let i = 0; i < matrix.length; ++i) {
+    for (let j = matrix[i].length - 1; j > i; j--) swap(matrix, i, j)
+  }
+}
+
+function swap(matrix, i, j) {
+  const tmp = matrix[j][i]
+  matrix[j][i] = matrix[i][j]
+  matrix[i][j] = tmp
+}

From 8fa0755692e62416e29cf4e6cb8d2c49e73841ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Jun 2021 21:23:30 +0800
Subject: [PATCH 1431/3374] Create
 1887-reduction-operations-to-make-the-array-elements-equal.js

---
 ...ations-to-make-the-array-elements-equal.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1887-reduction-operations-to-make-the-array-elements-equal.js

diff --git a/1887-reduction-operations-to-make-the-array-elements-equal.js b/1887-reduction-operations-to-make-the-array-elements-equal.js
new file mode 100644
index 00000000..63db3c46
--- /dev/null
+++ b/1887-reduction-operations-to-make-the-array-elements-equal.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const reductionOperations = function(nums) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  const arr = Array(n).fill(0)
+  for(let i = 1; i < n; i++) {
+    if(nums[i] > nums[i - 1]) arr[i] = 1
+  }
+  let res = 0, pre = 0
+  
+  for(let i = 1; i < n; i++) {
+    if(arr[i] === 0) arr[i] = arr[i - 1]
+    else arr[i] += arr[i - 1]
+  }
+
+  for(let e of arr) {
+    res += e
+  }
+  return res
+};

From b4aa0b3edbdc66e261e91156efdeb15bf2f553d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Jun 2021 21:24:21 +0800
Subject: [PATCH 1432/3374] Create 1889-minimum-space-wasted-from-packaging.js

---
 1889-minimum-space-wasted-from-packaging.js | 49 +++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 1889-minimum-space-wasted-from-packaging.js

diff --git a/1889-minimum-space-wasted-from-packaging.js b/1889-minimum-space-wasted-from-packaging.js
new file mode 100644
index 00000000..14caabbb
--- /dev/null
+++ b/1889-minimum-space-wasted-from-packaging.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} packages
+ * @param {number[][]} boxes
+ * @return {number}
+ */
+var minWastedSpace = function (packages, boxes) {
+  packages.sort(function (a, b) {
+    return a - b
+  })
+  let count = 0,
+    b,
+    wastage,
+    minWastage = Number.MAX_SAFE_INTEGER,
+    flag = false
+  for (let i = 0; i < boxes.length; i++) {
+    boxes[i].sort(function (a, b) {
+      return a - b
+    })
+    b = 0
+    wastage = 0
+    count = 0
+    if (boxes[i][boxes[i].length - 1] < packages[packages.length - 1]) {
+      //This supplier's largest box is smaller than our larget package, this supplier can't be used
+      continue
+    }
+    while (count < packages.length && b < boxes[i].length) {
+      if (packages[count] <= boxes[i][b]) {
+        wastage += boxes[i][b] - packages[count]
+        if (wastage > minWastage) {
+          //Need not to porcess this supplier if wastage has already been more than minWastage
+          break
+        }
+        count++
+      } else {
+        b++
+      }
+    }
+    if (count === packages.length) {
+      flag = true //We have found atleas 1 answer
+      if (wastage < minWastage) {
+        minWastage = wastage
+      }
+    }
+  }
+  if (flag === false) {
+    return -1
+  }
+  return minWastage % 1000000007
+}

From 92cf1f67ad9d1618bf1d5702c48fdcd3768af10d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Jun 2021 10:06:50 +0800
Subject: [PATCH 1433/3374] Create
 1876-substrings-of-size-three-with-distinct-characters.js

---
 ...s-of-size-three-with-distinct-characters.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1876-substrings-of-size-three-with-distinct-characters.js

diff --git a/1876-substrings-of-size-three-with-distinct-characters.js b/1876-substrings-of-size-three-with-distinct-characters.js
new file mode 100644
index 00000000..fb8d6fb0
--- /dev/null
+++ b/1876-substrings-of-size-three-with-distinct-characters.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+ const countGoodSubstrings = function(s) {
+  let res = 0
+  for(let i = 2; i < s.length; i++) {
+    if(chk(s, i)) res++
+  }
+  
+  return res
+};
+
+function chk(s, i) {
+  return s[i - 2] !== s[i - 1] &&
+    s[i - 2] !== s[i] &&
+    s[i - 1] !== s[i]
+}

From e7e446dcda4a45ed58b691378f1e69477da471bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Jun 2021 20:39:40 +0800
Subject: [PATCH 1434/3374] Update 1882-process-tasks-using-servers.js

---
 1882-process-tasks-using-servers.js | 53 +++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/1882-process-tasks-using-servers.js b/1882-process-tasks-using-servers.js
index 0ea0dc15..2f3a3dfd 100644
--- a/1882-process-tasks-using-servers.js
+++ b/1882-process-tasks-using-servers.js
@@ -116,3 +116,56 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[]} servers
+ * @param {number[]} tasks
+ * @return {number[]}
+ */
+const assignTasks = function(servers, tasks) {
+  const freePQ = new PriorityQueue((a, b) => {
+    if(a.w < b.w) return true
+    else if(a.w > b.w) return false
+    else {
+      if(a.idx < b.idx) return true
+      return false
+    }
+  })
+  const runningPQ = new PriorityQueue((a, b) => {
+    return a.end === b.end ? (a.w === b.w ? a.idx < b.idx : a.w < b.w) : a.end < b.end
+  })
+  const res = []
+  for(let i = 0; i < servers.length; i++) {
+    freePQ.push({
+      w: servers[i],
+      idx: i
+    })
+  }
+  for(let i = 0, n = tasks.length; i < n; i++) {
+    const cur = tasks[i]
+    while(runningPQ.size() && runningPQ.peek().end <= i) {
+      const el = runningPQ.pop()
+      freePQ.push({
+        w: el.w,
+        idx: el.idx,
+      })
+    }
+    
+    if(freePQ.isEmpty()) {
+      const el = runningPQ.pop()
+      res[i] = el.idx
+      el.end += cur
+      runningPQ.push(el)
+    } else {
+      const el = freePQ.pop()
+      res[i] = el.idx
+      el.end = i + cur
+      runningPQ.push(el)
+    }
+  }
+
+  return res
+};
+

From 78b951ee408b3727cbf015d595133ae4b6c60c3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Jun 2021 21:20:04 +0800
Subject: [PATCH 1435/3374] Update 53-maximum-subarray.js

---
 53-maximum-subarray.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/53-maximum-subarray.js b/53-maximum-subarray.js
index 15725003..60de46f4 100755
--- a/53-maximum-subarray.js
+++ b/53-maximum-subarray.js
@@ -11,3 +11,33 @@ const maxSubArray = function(nums) {
   }
   return maxSum;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSubArray = function(nums) {
+  return helper(nums, 0, nums.length - 1)
+};
+
+function helper(arr, l, r) {
+  if(l > r) return -Infinity
+  const mid = l + ((r - l) >> 1)
+  let cur = 0, leftMax = 0, rightMax = 0
+  for(let i = mid - 1; i >= l; i--) {
+    cur += arr[i]
+    leftMax = Math.max(leftMax, cur)
+  }
+  cur = 0
+  for(let i = mid + 1; i <= r; i++) {
+    cur += arr[i]
+    rightMax = Math.max(rightMax, cur)
+  }
+  const res = arr[mid] + leftMax + rightMax
+  const leftRes = helper(arr, l, mid - 1)
+  const rightRes = helper(arr, mid + 1, r)
+  
+  return Math.max(res, leftRes, rightRes)
+}

From 21df4eee3b3379e3f1bb83e182521a719275cadb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Jun 2021 20:18:33 +0800
Subject: [PATCH 1436/3374] Update 1167-minimum-cost-to-connect-sticks.js

---
 1167-minimum-cost-to-connect-sticks.js | 86 ++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/1167-minimum-cost-to-connect-sticks.js b/1167-minimum-cost-to-connect-sticks.js
index ff6d7fa1..6eeb60c6 100644
--- a/1167-minimum-cost-to-connect-sticks.js
+++ b/1167-minimum-cost-to-connect-sticks.js
@@ -124,4 +124,90 @@ const connectSticks = function(sticks) {
   return result
 }
 
+// another
+
+/**
+ * @param {number[]} sticks
+ * @return {number}
+ */
+const connectSticks = function(sticks) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  for(let e of sticks) pq.push(e)
+  let res = 0
+  while(pq.size() > 1) {
+    const e1 = pq.pop()
+    const e2 = pq.pop()
+    pq.push(e1 + e2)
+    res += e1 + e2
+  }
+  
+  return res
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
 
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 056e513ee3a0d2f26bd19581a9e3778e87a699eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Jun 2021 21:21:56 +0800
Subject: [PATCH 1437/3374] Update 25-reverse-nodes-in-k-group.js

---
 25-reverse-nodes-in-k-group.js | 85 ++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/25-reverse-nodes-in-k-group.js b/25-reverse-nodes-in-k-group.js
index 40e0d8a1..d7f9a36c 100644
--- a/25-reverse-nodes-in-k-group.js
+++ b/25-reverse-nodes-in-k-group.js
@@ -28,3 +28,88 @@ const reverseKGroup = function(head, k) {
   }
   return dmy.next
 }
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+const reverseKGroup = function (head, k) {
+  let ptr = head
+  let ktail = null
+
+  // Head of the final, moified linked list
+  let new_head = null
+
+  // Keep going until there are nodes in the list
+  while (ptr != null) {
+    let count = 0
+
+    // Start counting nodes from the head
+    ptr = head
+
+    // Find the head of the next k nodes
+    while (count < k && ptr != null) {
+      ptr = ptr.next
+      count += 1
+    }
+
+    // If we counted k nodes, reverse them
+    if (count == k) {
+      // Reverse k nodes and get the new head
+      let revHead = reverseLinkedList(head, k)
+
+      // new_head is the head of the final linked list
+      if (new_head == null) new_head = revHead
+
+      // ktail is the tail of the previous block of
+      // reversed k nodes
+      if (ktail != null) ktail.next = revHead
+
+      ktail = head
+      head = ptr
+    }
+  }
+
+  // attach the final, possibly un-reversed portion
+  if (ktail != null) ktail.next = head
+
+  return new_head == null ? head : new_head
+}
+
+function reverseLinkedList(head, k) {
+  // Reverse k nodes of the given linked list.
+  // This function assumes that the list contains
+  // atleast k nodes.
+  let new_head = null
+  let ptr = head
+
+  while (k > 0) {
+    // Keep track of the next node to process in the
+    // original list
+    let next_node = ptr.next
+
+    // Insert the node pointed to by "ptr"
+    // at the beginning of the reversed list
+    ptr.next = new_head
+    new_head = ptr
+
+    // Move on to the next node
+    ptr = next_node
+
+    // Decrement the count of nodes to be reversed by 1
+    k--
+  }
+
+  // Return the head of the reversed list
+  return new_head
+}

From 6f7b7a0c8b3f72361e4512fa375ff342aa1b7314 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Jun 2021 20:15:11 +0800
Subject: [PATCH 1438/3374] Update 25-reverse-nodes-in-k-group.js

---
 25-reverse-nodes-in-k-group.js | 42 ++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/25-reverse-nodes-in-k-group.js b/25-reverse-nodes-in-k-group.js
index d7f9a36c..bf6a75e2 100644
--- a/25-reverse-nodes-in-k-group.js
+++ b/25-reverse-nodes-in-k-group.js
@@ -29,6 +29,48 @@ const reverseKGroup = function(head, k) {
   return dmy.next
 }
 
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+const reverseKGroup = function (head, k) {
+  if(head == null) return head
+  const dummy = new ListNode()
+  dummy.next = head
+  let n = 0, cur = head
+  while(cur) {
+    n++
+    cur = cur.next
+  }
+  if(n < k) return head
+  let pre = dummy, tail = head
+
+  for(let i = 0; i + k <= n; i += k) {
+    for(let j = 1; j < k; j++) {
+      const tmp = pre.next
+      pre.next = tail.next
+      tail.next = tail.next.next
+      pre.next.next = tmp
+    }
+    pre = tail
+    tail = tail.next
+  } 
+  
+  return dummy.next
+}
+
+
+
 // another
 
 /**

From 25d9987bd72abc085534ca02afdf14ae5bc555ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Jun 2021 19:47:59 +0800
Subject: [PATCH 1439/3374] Update 1889-minimum-space-wasted-from-packaging.js

---
 1889-minimum-space-wasted-from-packaging.js | 54 +++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1889-minimum-space-wasted-from-packaging.js b/1889-minimum-space-wasted-from-packaging.js
index 14caabbb..1e733c58 100644
--- a/1889-minimum-space-wasted-from-packaging.js
+++ b/1889-minimum-space-wasted-from-packaging.js
@@ -1,3 +1,57 @@
+/**
+ * @param {number[]} packages
+ * @param {number[][]} boxes
+ * @return {number}
+ */
+const minWastedSpace = function (packages, boxes) {
+  const mod = 1e9 + 7
+  const n = packages.length
+  packages.sort((a, b) => a - b)
+  const preSum = packages.reduce(
+    (acc, cur) => {
+      acc.push(acc[acc.length - 1] + cur)
+      return acc
+    },
+    [0]
+  )
+
+  const upperBound = (target) => {
+    let lo = 0,
+      hi = n
+    while (lo < hi) {
+      const mi = (lo + hi) >> 1
+      const val = packages[mi]
+      if (val <= target) {
+        lo = mi + 1
+      } else {
+        hi = mi
+      }
+    }
+    return lo
+  }
+
+  let res = Infinity
+  for (const bs of boxes) {
+    bs.sort((a, b) => b - a)
+    if (bs[0] < packages[n - 1]) continue
+    let wastes = bs[0] * n - preSum[n]
+    let last = bs[0]
+    for (let i = 1; i < bs.length; i++) {
+      const b = bs[i]
+      const j = upperBound(b)
+      if (j <= 0) {
+        break
+      }
+      wastes -= (last - b) * j
+      last = b
+    }
+    res = Math.min(res, wastes)
+  }
+  return res === Infinity ? -1 : res % mod
+}
+
+// another
+
 /**
  * @param {number[]} packages
  * @param {number[][]} boxes

From 4aeb04acc18965e299c1a7d25ce447b5f0dd3926 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Jun 2021 20:11:49 +0800
Subject: [PATCH 1440/3374] Update 502-ipo.js

---
 502-ipo.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/502-ipo.js b/502-ipo.js
index 95219ee7..b00add48 100644
--- a/502-ipo.js
+++ b/502-ipo.js
@@ -6,9 +6,9 @@
  * @return {number}
  */
 const findMaximizedCapital = function(k, W, Profits, Capital) {
-  let idxArr = Profits.map((_, i) => i).sort((ia, ib) => Profits[ib] - Profits[ia]);
+  const idxArr = Profits.map((_, i) => i).sort((ia, ib) => Profits[ib] - Profits[ia]);
   while (k) {
-    let choose = idxArr.findIndex(i => Capital[i] <= W);
+    const choose = idxArr.findIndex(i => Capital[i] <= W);
     if (choose == -1) return W;
     W += Profits[idxArr[choose]];
     idxArr.splice(choose, 1);

From 0d1d9e4d5d9971872290c079bc300cd8b89ebb7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Jun 2021 20:59:44 +0800
Subject: [PATCH 1441/3374] Update 502-ipo.js

---
 502-ipo.js | 95 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 95 insertions(+)

diff --git a/502-ipo.js b/502-ipo.js
index b00add48..e095989d 100644
--- a/502-ipo.js
+++ b/502-ipo.js
@@ -1,3 +1,98 @@
+/**
+ * @param {number} k
+ * @param {number} W
+ * @param {number[]} Profits
+ * @param {number[]} Capital
+ * @return {number}
+ */
+const findMaximizedCapital = function(k, W, Profits, Capital) {
+  const capPQ = new PriorityQueue((a, b) => a.cap < b.cap)
+  const proPQ = new PriorityQueue((a, b) => a.pro > b.pro)
+  for(let i = 0, len = Profits.length; i < len; i++) {
+    capPQ.push({ cap: Capital[i], pro: Profits[i] })
+  }
+  while(k) {
+    while(!capPQ.isEmpty() && capPQ.peek().cap <= W) {
+      proPQ.push(capPQ.pop())
+    }
+    if(proPQ.isEmpty()) break
+    
+    W += proPQ.pop().pro
+    k--
+  }
+  return W
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number} k
  * @param {number} W

From 2a93e195b62c5760313e0b4670a69f4b779db6da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Jun 2021 14:06:30 +0800
Subject: [PATCH 1442/3374] Create
 1900-the-earliest-and-latest-rounds-where-players-compete.js

---
 ...and-latest-rounds-where-players-compete.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1900-the-earliest-and-latest-rounds-where-players-compete.js

diff --git a/1900-the-earliest-and-latest-rounds-where-players-compete.js b/1900-the-earliest-and-latest-rounds-where-players-compete.js
new file mode 100644
index 00000000..2836f4ee
--- /dev/null
+++ b/1900-the-earliest-and-latest-rounds-where-players-compete.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ * @param {number} firstPlayer
+ * @param {number} secondPlayer
+ * @return {number[]}
+ */
+const earliestAndLatest = function (n, firstPlayer, secondPlayer) {
+  const { max, min } = Math
+  const hash = {}
+  function dp(l, r, m) {
+    const key = `${l}${r}${m}`
+    if (hash[key] != null) return hash[key]
+    if (l > r) return dp(r, l, m)
+    if (l === r) return [1, 1]
+    let nxt_m = (m + 1) >> 1
+    let ans = [n, 0]
+    for (let i = 1; i < l + 1; i++) {
+      let l_win = i - 1,
+        l_lose = l - i
+      for (
+        let j = max(r - ~~(m / 2) - 1, 0) + l_lose + 1;
+        j < min(r - 1 - l_win, nxt_m - i) + 1;
+        j++
+      ) {
+        let tmp = dp(i, j, nxt_m)
+        ans = [min(ans[0], tmp[0]), max(ans[1], tmp[1])]
+      }
+    }
+    hash[key] = [ans[0] + 1, ans[1] + 1]
+    return hash[key]
+  }
+
+  return dp(firstPlayer, n - secondPlayer + 1, n)
+}

From 3c924e154339247a40f1a91a94a89078eef3a906 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Jun 2021 14:07:08 +0800
Subject: [PATCH 1443/3374] Create
 1899-merge-triplets-to-form-target-triplet.js

---
 1899-merge-triplets-to-form-target-triplet.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1899-merge-triplets-to-form-target-triplet.js

diff --git a/1899-merge-triplets-to-form-target-triplet.js b/1899-merge-triplets-to-form-target-triplet.js
new file mode 100644
index 00000000..3b147614
--- /dev/null
+++ b/1899-merge-triplets-to-form-target-triplet.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[][]} triplets
+ * @param {number[]} target
+ * @return {boolean}
+ */
+const mergeTriplets = function (triplets, target) {
+  let n = triplets.length
+  const ans = Array(3).fill(0)
+  const { max } = Math
+  for (let i = 0; i < n; i++) {
+    if (
+      triplets[i][0] <= target[0] &&
+      triplets[i][1] <= target[1] &&
+      triplets[i][2] <= target[2]
+    ) {
+      ans[0] = max(ans[0], triplets[i][0])
+      ans[1] = max(ans[1], triplets[i][1])
+      ans[2] = max(ans[2], triplets[i][2])
+    }
+  }
+  return ans[0] == target[0] && ans[1] == target[1] && ans[2] == target[2]
+}

From 4b871cfc9b1c537afa278353218df598ed2d3e10 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Jun 2021 14:07:37 +0800
Subject: [PATCH 1444/3374] Create
 1898-maximum-number-of-removable-characters.js

---
 ...-maximum-number-of-removable-characters.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1898-maximum-number-of-removable-characters.js

diff --git a/1898-maximum-number-of-removable-characters.js b/1898-maximum-number-of-removable-characters.js
new file mode 100644
index 00000000..77c297ac
--- /dev/null
+++ b/1898-maximum-number-of-removable-characters.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string} s
+ * @param {string} p
+ * @param {number[]} removable
+ * @return {number}
+ */
+const maximumRemovals = function (s, p, removable) {
+  const n = removable.length
+  let l = 0,
+    r = n
+  while (l < r) {
+    let mid = (l + r + 1) >> 1
+    if (is_valid(s, p, removable, mid)) l = mid
+    else r = mid - 1
+  }
+  return l
+}
+
+function is_valid(s, p, removable, cnt) {
+  let len1 = s.length,
+    len2 = p.length
+  const check = Array(len1).fill(0)
+  for (let i = 0; i < cnt; i++) check[removable[i]] = 1
+  let ind1 = 0,
+    ind2 = 0
+  while (ind1 < len1 && ind2 < len2) {
+    if (s[ind1] != p[ind2] || check[ind1]) {
+      ind1++
+      continue
+    }
+    ind1++, ind2++
+  }
+  return ind2 == len2
+}

From 10314910518f0b9405e964cff00fafcc14195ffe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Jun 2021 14:08:07 +0800
Subject: [PATCH 1445/3374] Create
 1897-redistribute-characters-to-make-all-strings-equal.js

---
 ...ute-characters-to-make-all-strings-equal.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1897-redistribute-characters-to-make-all-strings-equal.js

diff --git a/1897-redistribute-characters-to-make-all-strings-equal.js b/1897-redistribute-characters-to-make-all-strings-equal.js
new file mode 100644
index 00000000..9ca9a384
--- /dev/null
+++ b/1897-redistribute-characters-to-make-all-strings-equal.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string[]} words
+ * @return {boolean}
+ */
+const makeEqual = function(words) {
+  const arr = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for(let w  of words) {
+    for(let ch of w) {
+      arr[ch.charCodeAt(0) - a]++
+    }
+  }
+  const n = words.length
+  for(let i = 0; i < 26; i++) {
+    if(arr[i] % n !== 0) return false
+  }
+  return true
+};

From b0404f6a4f75e912ca6df87d971be68c205cc542 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Jun 2021 20:58:46 +0800
Subject: [PATCH 1446/3374] Update 857-minimum-cost-to-hire-k-workers.js

---
 857-minimum-cost-to-hire-k-workers.js | 33 +++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/857-minimum-cost-to-hire-k-workers.js b/857-minimum-cost-to-hire-k-workers.js
index 46394d91..028bcf65 100644
--- a/857-minimum-cost-to-hire-k-workers.js
+++ b/857-minimum-cost-to-hire-k-workers.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} quality
+ * @param {number[]} wage
+ * @param {number} K
+ * @return {number}
+ */
+const mincostToHireWorkers = function(quality, wage, K) {
+    const workers = [], n = quality.length;
+    for (let i = 0; i < n; i++) {
+        workers[i] = { ratio: wage[i] / quality[i], quality: quality[i] }
+    }
+    workers.sort((a, b) => a.ratio - b.ratio);
+    const heap = new MaxPriorityQueue({ priority: x => x.quality });
+    let totalQuality = 0, res = Infinity;
+    while (workers.length) {
+        const curWorker = workers.shift();
+        totalQuality += curWorker.quality;
+        heap.enqueue(curWorker);
+        
+        if (heap.size() > K) {
+            totalQuality -= heap.dequeue().element.quality;
+        }
+        if (heap.size() === K) {
+            res = Math.min(res, curWorker.ratio * totalQuality)
+        }
+    }
+    return res;
+};
+
+
+
+// another
+
 /**
  * @param {number[]} quality
  * @param {number[]} wage

From b4b6ff9c412bed815b443c62fbf1dfd0fa92c277 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Jun 2021 22:19:55 +0800
Subject: [PATCH 1447/3374] Create
 1893-check-if-all-the-integers-in-a-range-are-covered.js

---
 ...if-all-the-integers-in-a-range-are-covered.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1893-check-if-all-the-integers-in-a-range-are-covered.js

diff --git a/1893-check-if-all-the-integers-in-a-range-are-covered.js b/1893-check-if-all-the-integers-in-a-range-are-covered.js
new file mode 100644
index 00000000..bcd916b9
--- /dev/null
+++ b/1893-check-if-all-the-integers-in-a-range-are-covered.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} ranges
+ * @param {number} left
+ * @param {number} right
+ * @return {boolean}
+ */
+const isCovered = function(ranges, left, right) {
+	for(let i = left; i <= right; i++) {
+		let seen = false;
+		for(let j = 0; j < ranges.length && !seen; j++) 
+			if(i >= ranges[j][0] && i <= ranges[j][1]) 
+				seen = true;
+		if(!seen) return false;
+	}
+	return true;
+};

From 963053468fd30e41bb517a14bb5d35e305180f81 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Jun 2021 22:26:58 +0800
Subject: [PATCH 1448/3374] Update
 1893-check-if-all-the-integers-in-a-range-are-covered.js

---
 ...all-the-integers-in-a-range-are-covered.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1893-check-if-all-the-integers-in-a-range-are-covered.js b/1893-check-if-all-the-integers-in-a-range-are-covered.js
index bcd916b9..1aff5dee 100644
--- a/1893-check-if-all-the-integers-in-a-range-are-covered.js
+++ b/1893-check-if-all-the-integers-in-a-range-are-covered.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[][]} ranges
+ * @param {number} left
+ * @param {number} right
+ * @return {boolean}
+ */
+const isCovered = function(ranges, left, right) {
+  const arr = Array(52).fill(0)
+  for(let [s, e] of ranges) {
+    arr[s]++
+    arr[e + 1]--
+  }
+  for(let i = 1; i < 52; i++) {
+    arr[i] += arr[i - 1]
+  }
+  for(let i = left; i <= right; i++) {
+    if(arr[i] === 0) return false
+  }
+  
+  return true
+};
+
+// another
+
 /**
  * @param {number[][]} ranges
  * @param {number} left

From 57c75b381f9a1e6310c78ef70cfbf6b8f14cadf9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Jun 2021 14:44:33 +0800
Subject: [PATCH 1449/3374] Update 215-kth-largest-element-in-an-array.js

---
 215-kth-largest-element-in-an-array.js | 48 ++++++++++++--------------
 1 file changed, 22 insertions(+), 26 deletions(-)

diff --git a/215-kth-largest-element-in-an-array.js b/215-kth-largest-element-in-an-array.js
index c0514eb2..f8544874 100755
--- a/215-kth-largest-element-in-an-array.js
+++ b/215-kth-largest-element-in-an-array.js
@@ -66,42 +66,38 @@ function quickselect(arr, lo, hi, k) {
  * @param {number} k
  * @return {number}
  */
-const findKthLargest = function(list, k) {
-  const len = list.length
-  let lo = 0
-  let hi = len - 1
-  let pivot = 0
-  let t = len - k
-  while(lo < hi) {
-    pivot = partition(list, lo, hi)
-    if(pivot === t) {
-      break
-    } else if(pivot < t) {
-      lo = pivot + 1
-    } else if(pivot > t) {
-      hi = pivot - 1
+const findKthLargest = function(nums, k) {
+  const n = nums.length
+  let l = 0, r = n - 1, t = n - k
+  while(l < r) {
+    const mid = partition(nums, l, r)
+    if(mid < t) {
+      l = mid + 1
+    } else {
+      if(mid === t) break
+      else r = mid - 1
     }
   }
-  
-  return list[t]
-}
+  return nums[t]
+};
 
-function partition(arr, s, e) {
-  let t = arr[e]
-  let i = s
-  for(let j = s; j <= e - 1; j++) {
-    if(arr[j] <= t) {
+function partition(arr, left, right) {
+  let pivot = arr[right]
+  let l = left, r = right - 1, j = left
+  for(let i = left; i < right; i++) {
+    if(arr[i] <= pivot) {
       swap(arr, i, j)
-      i++
+      j++
     }
   }
-  swap(arr, i, e) 
-  return i
+  swap(arr, j, right)
+  return j
 }
 
 function swap(arr, i, j) {
-  let tmp = arr[i]
+  const tmp = arr[i]
   arr[i] = arr[j]
   arr[j] = tmp
 }
 
+

From 3cff0f2adeb14a6936b18fb930289f48551eb59b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Jun 2021 21:11:46 +0800
Subject: [PATCH 1450/3374] Create
 1896-minimum-cost-to-change-the-final-value-of-expression.js

---
 ...to-change-the-final-value-of-expression.js | 89 +++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 1896-minimum-cost-to-change-the-final-value-of-expression.js

diff --git a/1896-minimum-cost-to-change-the-final-value-of-expression.js b/1896-minimum-cost-to-change-the-final-value-of-expression.js
new file mode 100644
index 00000000..a5600719
--- /dev/null
+++ b/1896-minimum-cost-to-change-the-final-value-of-expression.js
@@ -0,0 +1,89 @@
+/**
+ * @param {string} expression
+ * @return {number}
+ */
+function minOperationsToFlip (s) {
+  const nums = []
+  const ops = []
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '0') nums.push([0, 0, 1])
+    else if (s[i] === '1') nums.push([1, 1, 0])
+    else if (s[i] === '(') ops.push('(')
+    else if (s[i] === ')') {
+      while (ops.length && ops[ops.length - 1] !== '(') {
+        const op = ops.pop()
+        calc(op)
+      }
+      if (ops.length) ops.pop()
+    } else {
+      while (ops.length && grade(ops[ops.length - 1]) >= grade(s[i])) {
+        const op = ops.pop()
+        calc(op)
+      }
+      ops.push(s[i])
+    }
+  }
+
+  while (ops.length && nums.length >= 2) {
+    const op = ops.pop()
+    calc(op)
+  }
+  const val = nums[0][0]
+  return nums[0][2 - val]
+
+  function calc (op) {
+    const [x, y] = [nums.pop(), nums.pop()]
+    let [z, a0, a1] = [0, 0, 0]
+    switch (op) {
+      case '&':
+        z = x[0] & y[0]
+        if (x[0] === 0 && y[0] === 0) {
+          a0 = 0
+          a1 = Math.min(x[2] + 1, y[2] + 1)
+        }
+        if (x[0] === 0 && y[0] === 1) {
+          a0 = 0
+          a1 = 1
+        }
+        if (x[0] === 1 && y[0] === 0) {
+          a0 = 0
+          a1 = 1
+        }
+        if (x[0] === 1 && y[0] === 1) {
+          a0 = Math.min(x[1], y[1])
+          a1 = 0
+        }
+        break
+      case '|':
+        z = x[0] | y[0]
+        if (x[0] === 0 && y[0] === 0) {
+          a0 = 0
+          a1 = Math.min(x[2], y[2])
+        }
+        if (x[0] === 0 && y[0] === 1) {
+          a0 = 1
+          a1 = 0
+        }
+        if (x[0] === 1 && y[0] === 0) {
+          a0 = 1
+          a1 = 0
+        }
+        if (x[0] === 1 && y[0] === 1) {
+          a0 = Math.min(x[1] + 1, y[1] + 1)
+          a1 = 0
+        }
+        break
+    }
+    nums.push([z, a0, a1])
+  }
+  function grade (op) {
+    switch (op) {
+      case '(':
+        return 1
+      case '&':
+      case '|':
+        return 2
+    }
+    return 0
+  }
+};

From 64c9108ca5301cd43ed8d58ce734c317cda264cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 10:27:58 +0800
Subject: [PATCH 1451/3374] Create 1901-find-a-peak-element-ii.js

---
 1901-find-a-peak-element-ii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1901-find-a-peak-element-ii.js

diff --git a/1901-find-a-peak-element-ii.js b/1901-find-a-peak-element-ii.js
new file mode 100644
index 00000000..882df7c7
--- /dev/null
+++ b/1901-find-a-peak-element-ii.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[][]} mat
+ * @return {number[]}
+ */
+const findPeakGrid = function(mat) {
+    let lowCol = 0;
+    let highCol = mat[0].length - 1;
+
+    while(lowCol <= highCol) {
+        let midCol = lowCol + ~~((highCol - lowCol) / 2);
+        let maxRow = 0;
+        for(let i = 0; i < mat.length; i++) {
+            maxRow = mat[i][midCol] > mat[maxRow][midCol] ? i : maxRow;
+        }
+
+        let isLeftElementBig = midCol - 1 >= lowCol && mat[maxRow][midCol - 1] > mat[maxRow][midCol];
+        let isRightElementBig = midCol + 1 <= highCol && mat[maxRow][midCol + 1] > mat[maxRow][midCol];
+
+        if(!isLeftElementBig && !isRightElementBig) {
+            return [maxRow, midCol];
+        } else if(isRightElementBig) {
+            lowCol = midCol + 1;
+        } else {
+            highCol = midCol - 1;
+        }
+    }
+    return null;
+};

From 444ada36b53dc843598eb18aaf0ac68d11e3200b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 12:06:33 +0800
Subject: [PATCH 1452/3374] Create 1903-largest-odd-number-in-string.js

---
 1903-largest-odd-number-in-string.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1903-largest-odd-number-in-string.js

diff --git a/1903-largest-odd-number-in-string.js b/1903-largest-odd-number-in-string.js
new file mode 100644
index 00000000..097f1cb7
--- /dev/null
+++ b/1903-largest-odd-number-in-string.js
@@ -0,0 +1,11 @@
+/**
+ * @param {string} num
+ * @return {string}
+ */
+const largestOddNumber = function(num) {
+  let idx= -1
+  for(let i = 0, n = num.length; i < n; i++) {
+    if((+num[i]) % 2 === 1) idx = i
+  }
+  return num.slice(0, idx+1)
+};

From f0f1ed351241134a057f2bb7f571ac9f4ed59ee5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 12:12:19 +0800
Subject: [PATCH 1453/3374] Create
 1904-the-number-of-full-rounds-you-have-played.js

---
 1904-the-number-of-full-rounds-you-have-played.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1904-the-number-of-full-rounds-you-have-played.js

diff --git a/1904-the-number-of-full-rounds-you-have-played.js b/1904-the-number-of-full-rounds-you-have-played.js
new file mode 100644
index 00000000..6951e755
--- /dev/null
+++ b/1904-the-number-of-full-rounds-you-have-played.js
@@ -0,0 +1,11 @@
+/**
+ * @param {string} startTime
+ * @param {string} finishTime
+ * @return {number}
+ */
+const numberOfRounds = function(startTime, finishTime) {
+  let start = 60 * parseInt(startTime.slice(0, 2)) + parseInt(startTime.slice(3))
+  let finish = 60 * parseInt(finishTime.slice(0, 2)) + parseInt(finishTime.slice(3));
+  if (start > finish) finish += 60 * 24; // If `finishTime` is earlier than `startTime`, add 24 hours to `finishTime`.
+  return Math.floor(finish / 15) - Math.ceil(start / 15); // floor(finish / 15) - ceil(start / 15)
+};

From 8e64eb474b5d06740e6ade748564d134a1a12dc3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 13:02:52 +0800
Subject: [PATCH 1454/3374] Create 1905-count-sub-islands.js

---
 1905-count-sub-islands.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1905-count-sub-islands.js

diff --git a/1905-count-sub-islands.js b/1905-count-sub-islands.js
new file mode 100644
index 00000000..b89e0a5e
--- /dev/null
+++ b/1905-count-sub-islands.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} grid1
+ * @param {number[][]} grid2
+ * @return {number}
+ */
+const countSubIslands = function(grid1, grid2) {
+    let m = grid2.length, n = grid2[0].length, res = 0;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid2[i][j] === 1) res += dfs(grid1, grid2, i, j);                 
+        }
+    }
+    return res;  
+};
+
+function dfs(B, A, i, j) {
+    let m = A.length, n = A[0].length, res = 1;
+    if (i < 0 || i == m || j < 0 || j == n || A[i][j] == 0) return 1;
+    A[i][j] = 0;
+    res &= dfs(B, A, i - 1, j);
+    res &= dfs(B, A, i + 1, j);
+    res &= dfs(B, A, i, j - 1);
+    res &= dfs(B, A, i, j + 1);
+    return res & B[i][j];
+}

From d3e5f08b0263548394404140c5211bff2869b9d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 13:38:06 +0800
Subject: [PATCH 1455/3374] Create 1906-minimum-absolute-difference-queries.js

---
 1906-minimum-absolute-difference-queries.js | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1906-minimum-absolute-difference-queries.js

diff --git a/1906-minimum-absolute-difference-queries.js b/1906-minimum-absolute-difference-queries.js
new file mode 100644
index 00000000..837228ec
--- /dev/null
+++ b/1906-minimum-absolute-difference-queries.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const minDifference = function(nums, queries) {
+    const res = [], cnt = Array.from({ length: nums.length + 1 }, () =>  Array(101).fill(0))
+    
+    for (let i = 0; i < nums.length; ++i) {
+        for (let j = 1; j <= 100; ++j) {
+            cnt[i + 1][j] = cnt[i][j] + (nums[i] == j);          
+        }      
+    }
+
+
+    for (let i = 0; i < queries.length; ++i) {
+        let prev = 0, delta = Infinity;
+        for (let j = 1; j <= 100; ++j)
+            if (cnt[queries[i][1] + 1][j] - cnt[queries[i][0]][j]) {
+                delta = Math.min(delta, prev == 0 ? Infinity : j - prev);
+                prev = j;
+            }
+        res.push(delta == Infinity ? -1 : delta);
+    }
+    return res;
+};

From 218ba2828f3cf52b00db8569ed20e1cc43b88137 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Jun 2021 21:18:44 +0800
Subject: [PATCH 1456/3374] Update 1834-single-threaded-cpu.js

---
 1834-single-threaded-cpu.js | 43 +++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1834-single-threaded-cpu.js b/1834-single-threaded-cpu.js
index 4a394db0..192aedec 100644
--- a/1834-single-threaded-cpu.js
+++ b/1834-single-threaded-cpu.js
@@ -239,3 +239,46 @@ const getOrder = function(tasks) {
   return res
 
 };
+
+// another
+
+/**
+ * @param {number[][]} tasks
+ * @return {number[]}
+ */
+const getOrder = function (tasks) {
+  tasks = tasks.map((e, idx) => [e[0], e[1], idx])
+  tasks.sort((a, b) => a[0] - b[0])
+  const pq = new PriorityQueue(compare)
+  const res = []
+  let i = 0,
+    t = 0
+  while (i < tasks.length) {
+    while (i < tasks.length && tasks[i][0] <= t) {
+      let [ent, pt, ind] = tasks[i]
+      i += 1
+      pq.push([pt, ind])
+    }
+    if (pq.size() == 0) {
+      if (i < tasks.length) t = tasks[i][0]
+      continue
+    }
+    let [pt, ind] = pq.pop()
+    res.push(ind)
+    t += pt
+  }
+  while (pq.size()) {
+    let [pt, index] = pq.pop()
+    res.push(index)
+  }
+  return res
+}
+
+function compare(a, b) {
+  if (a[0] < b[0]) return true
+  else if (a[0] > b[0]) return false
+  else {
+    return a[1] < b[1]
+  }
+}
+

From e62044c4b6e1093333b0fd72f3c131691454761c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Jun 2021 19:57:43 +0800
Subject: [PATCH 1457/3374] Update 540-single-element-in-a-sorted-array.js

---
 540-single-element-in-a-sorted-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/540-single-element-in-a-sorted-array.js b/540-single-element-in-a-sorted-array.js
index 7c8518d9..461c52a2 100755
--- a/540-single-element-in-a-sorted-array.js
+++ b/540-single-element-in-a-sorted-array.js
@@ -15,6 +15,24 @@ const singleNonDuplicate = function(nums) {
 
 // another
 
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNonDuplicate = function(nums) {
+  const n = nums.length
+  let left = 0, right = n - 1
+  while(left < right) {
+    const mid = ~~((left + right) / 2)
+    if((mid % 2 === 0 && nums[mid] === nums[mid + 1]) || (mid % 2 === 1 && nums[mid] === nums[mid - 1])) left = mid + 1
+    else right = mid
+  }
+  
+  return nums[left]
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 20c82efbf7efc5118b4ec6b22fea60068f22bb62 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Jun 2021 20:00:43 +0800
Subject: [PATCH 1458/3374] Update 540-single-element-in-a-sorted-array.js

---
 540-single-element-in-a-sorted-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/540-single-element-in-a-sorted-array.js b/540-single-element-in-a-sorted-array.js
index 461c52a2..a840caa3 100755
--- a/540-single-element-in-a-sorted-array.js
+++ b/540-single-element-in-a-sorted-array.js
@@ -15,6 +15,24 @@ const singleNonDuplicate = function(nums) {
 
 // another
 
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const singleNonDuplicate = function(nums) {
+  const n = nums.length
+  let left = 0, right = n - 1
+  while(left < right) {
+    const mid = left + ((right - left) >> 1)
+    if(nums[mid] === nums[mid ^ 1]) left = mid + 1
+    else right = mid
+  }
+  
+  return nums[left]
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 2b0631a1cac4ab33924a26e4177b0ca467e471ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Jun 2021 16:12:31 +0800
Subject: [PATCH 1459/3374] Update 445-add-two-numbers-II.js

---
 445-add-two-numbers-II.js | 60 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/445-add-two-numbers-II.js b/445-add-two-numbers-II.js
index ef5c15e6..4800985a 100755
--- a/445-add-two-numbers-II.js
+++ b/445-add-two-numbers-II.js
@@ -1,3 +1,63 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(head1, head2) {
+  const r1 = reverse(head1), r2 = reverse(head2)
+  let l1 = r1, l2 = r2, inc = 0
+  let dummy = new ListNode()
+  let pre = dummy
+  while(l1 || l2) {
+    let val = inc
+    if(l1) {
+      val += l1.val
+      l1 = l1.next
+    }
+    if(l2) {
+      val += l2.val
+      l2 = l2.next
+    }
+    if(val > 9) inc = 1
+    else inc = 0
+    const cur = new ListNode(val % 10)
+    pre.next = cur
+    pre = cur
+  }
+  if (inc) {
+    pre.next = new ListNode(1)
+  }
+  return reverse(dummy.next) 
+};
+
+function reverse(head) {
+  const dummy = new ListNode()
+  dummy.next = head
+  let len = 0, cur = head
+  while(cur) {
+    len++
+    cur = cur.next
+  }
+  let p = dummy, tail = head, tmp = null
+  for(let i = 0; i < len - 1; i++) {
+    tmp = p.next
+    p.next = tail.next
+    tail.next = tail.next.next
+    p.next.next = tmp
+  }
+  return dummy.next
+}
+
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From 75df5ade870512ddaf71750a2535fbc6988dac73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Jun 2021 20:10:29 +0800
Subject: [PATCH 1460/3374] Update
 1904-the-number-of-full-rounds-you-have-played.js

---
 ...e-number-of-full-rounds-you-have-played.js | 28 ++++++++++++++++---
 1 file changed, 24 insertions(+), 4 deletions(-)

diff --git a/1904-the-number-of-full-rounds-you-have-played.js b/1904-the-number-of-full-rounds-you-have-played.js
index 6951e755..3aaafdf4 100644
--- a/1904-the-number-of-full-rounds-you-have-played.js
+++ b/1904-the-number-of-full-rounds-you-have-played.js
@@ -4,8 +4,28 @@
  * @return {number}
  */
 const numberOfRounds = function(startTime, finishTime) {
-  let start = 60 * parseInt(startTime.slice(0, 2)) + parseInt(startTime.slice(3))
-  let finish = 60 * parseInt(finishTime.slice(0, 2)) + parseInt(finishTime.slice(3));
-  if (start > finish) finish += 60 * 24; // If `finishTime` is earlier than `startTime`, add 24 hours to `finishTime`.
-  return Math.floor(finish / 15) - Math.ceil(start / 15); // floor(finish / 15) - ceil(start / 15)
+  const { ceil, floor } = Math
+  const start = new Node(startTime), finish = new Node(finishTime)
+  if(finish.compare(start)) finish.hour += 24
+  let cnt = 0
+  if(start.hour === finish.hour) {
+    const r = floor(finish.minute / 15)
+    const l = ceil(start.minute / 15)
+    if(l >= r) return 0
+    return r - l
+  }
+  cnt += 4 - ceil(start.minute / 15) + floor(finish.minute / 15)
+  start.hour++
+  cnt += (finish.hour - start.hour) * 4
+  return cnt
 };
+
+class Node {
+  constructor(str) {
+    this.hour = +str.slice(0, 2)
+    this.minute = +str.slice(3)
+  }
+  compare(node) {
+    return this.hour === node.hour ? this.minute < node.minute : this.hour < node.hour
+  }
+}

From dcb01b6638f355a9c3a2f5f4a912b78eb13f9343 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Jun 2021 20:13:38 +0800
Subject: [PATCH 1461/3374] Update
 1904-the-number-of-full-rounds-you-have-played.js

---
 1904-the-number-of-full-rounds-you-have-played.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/1904-the-number-of-full-rounds-you-have-played.js b/1904-the-number-of-full-rounds-you-have-played.js
index 3aaafdf4..d53993e3 100644
--- a/1904-the-number-of-full-rounds-you-have-played.js
+++ b/1904-the-number-of-full-rounds-you-have-played.js
@@ -1,3 +1,17 @@
+/**
+ * @param {string} startTime
+ * @param {string} finishTime
+ * @return {number}
+ */
+const numberOfRounds = function(startTime, finishTime) {
+  let start = 60 * parseInt(startTime.slice(0, 2)) + parseInt(startTime.slice(3))
+  let finish = 60 * parseInt(finishTime.slice(0, 2)) + parseInt(finishTime.slice(3));
+  if (start > finish) finish += 60 * 24; // If `finishTime` is earlier than `startTime`, add 24 hours to `finishTime`.
+  return Math.max(0, Math.floor(finish / 15) - Math.ceil(start / 15)); // floor(finish / 15) - ceil(start / 15)
+};
+
+// another
+
 /**
  * @param {string} startTime
  * @param {string} finishTime

From fd3a613879c19b9fad7a500a8fccc9b35f17ec29 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Jun 2021 19:23:15 +0800
Subject: [PATCH 1462/3374] Update 1906-minimum-absolute-difference-queries.js

---
 1906-minimum-absolute-difference-queries.js | 39 +++++++++++----------
 1 file changed, 20 insertions(+), 19 deletions(-)

diff --git a/1906-minimum-absolute-difference-queries.js b/1906-minimum-absolute-difference-queries.js
index 837228ec..0b153a62 100644
--- a/1906-minimum-absolute-difference-queries.js
+++ b/1906-minimum-absolute-difference-queries.js
@@ -3,24 +3,25 @@
  * @param {number[][]} queries
  * @return {number[]}
  */
-const minDifference = function(nums, queries) {
-    const res = [], cnt = Array.from({ length: nums.length + 1 }, () =>  Array(101).fill(0))
-    
-    for (let i = 0; i < nums.length; ++i) {
-        for (let j = 1; j <= 100; ++j) {
-            cnt[i + 1][j] = cnt[i][j] + (nums[i] == j);          
-        }      
-    }
-
+const minDifference = function (nums, queries) {
+  const res = [],
+    cnt = Array.from({ length: nums.length + 1 }, () => Array(101).fill(0))
 
-    for (let i = 0; i < queries.length; ++i) {
-        let prev = 0, delta = Infinity;
-        for (let j = 1; j <= 100; ++j)
-            if (cnt[queries[i][1] + 1][j] - cnt[queries[i][0]][j]) {
-                delta = Math.min(delta, prev == 0 ? Infinity : j - prev);
-                prev = j;
-            }
-        res.push(delta == Infinity ? -1 : delta);
+  for (let i = 0; i < nums.length; ++i) {
+    for (let j = 1; j <= 100; ++j) {
+      cnt[i + 1][j] = cnt[i][j] + (nums[i] == j)
     }
-    return res;
-};
+  }
+
+  for (let i = 0; i < queries.length; ++i) {
+    let prev = 0,
+      delta = Infinity
+    for (let j = 1; j <= 100; ++j)
+      if (cnt[queries[i][1] + 1][j] - cnt[queries[i][0]][j]) {
+        delta = Math.min(delta, prev == 0 ? Infinity : j - prev)
+        prev = j
+      }
+    res.push(delta == Infinity ? -1 : delta)
+  }
+  return res
+}

From a48579eba6a5a3c13cf51429e39f9a281ca7f40e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Jun 2021 22:14:37 +0800
Subject: [PATCH 1463/3374] Update 264-ugly-number-ii.js

---
 264-ugly-number-ii.js | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/264-ugly-number-ii.js b/264-ugly-number-ii.js
index b062b445..af94e904 100644
--- a/264-ugly-number-ii.js
+++ b/264-ugly-number-ii.js
@@ -2,15 +2,19 @@
  * @param {number} n
  * @return {number}
  */
-const nthUglyNumber = function(n) {
-  const dp = [1]
-  let [a, b, c] = [0, 0, 0]
+const nthUglyNumber = function (n) {
+  if (n <= 0) return false
+  if (n === 1) return true
+  let t2 = 0,
+    t3 = 0,
+    t5 = 0
+  const k = Array(n).fill(1)
+  k[0] = 1
   for (let i = 1; i < n; i++) {
-    let [ua, ub, uc] = [dp[a] * 2, dp[b] * 3, dp[c] * 5]
-    dp[i] = Math.min(ua, ub, uc)
-    if (dp[i] === ua) a++
-    if (dp[i] === ub) b++
-    if (dp[i] === uc) c++
+    k[i] = Math.min(k[t2] * 2, k[t3] * 3, k[t5] * 5)
+    if (k[i] == k[t2] * 2) t2++
+    if (k[i] == k[t3] * 3) t3++
+    if (k[i] == k[t5] * 5) t5++
   }
-  return dp[n - 1]
+  return k[n - 1]
 }

From 8c54083ca57052c9bb0f31b28b369ab7d4f5ff74 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 26 Jun 2021 21:01:34 +0800
Subject: [PATCH 1464/3374] Update 313-super-ugly-number.js

---
 313-super-ugly-number.js | 92 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 92 insertions(+)

diff --git a/313-super-ugly-number.js b/313-super-ugly-number.js
index 4de633c8..598944b8 100644
--- a/313-super-ugly-number.js
+++ b/313-super-ugly-number.js
@@ -20,3 +20,95 @@ const nthSuperUglyNumber = function(n, primes) {
   }
   return arr[n - 1]
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} primes
+ * @return {number}
+ */
+const nthSuperUglyNumber = function(n, primes) {
+  const ugly = Array(n).fill(0)
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  
+  for(let i = 0; i < primes.length; i++) pq.push([primes[i], 1, primes[i]])
+  ugly[0] = 1
+  for(let i = 1; i < n; i++) {
+    ugly[i] = pq.peek()[0]
+    while(pq.peek()[0] === ugly[i]) {
+      const next = pq.pop()
+      pq.push([next[2] * ugly[next[1]], next[1] + 1, next[2]])
+    }
+  }
+  
+  return ugly[n - 1]
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 067586bede3a03241fe2f7830fe55c97600056e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Jun 2021 21:16:18 +0800
Subject: [PATCH 1465/3374] Create 1915-number-of-wonderful-substrings.js

---
 1915-number-of-wonderful-substrings.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1915-number-of-wonderful-substrings.js

diff --git a/1915-number-of-wonderful-substrings.js b/1915-number-of-wonderful-substrings.js
new file mode 100644
index 00000000..91de957c
--- /dev/null
+++ b/1915-number-of-wonderful-substrings.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const asi = (c) => c.charCodeAt();
+const wonderfulSubstrings = (s) => {
+    let res = 0;
+    let f = Array(2 ** 10).fill(0);
+    f[0] = 1; // count array
+    let cur = res = 0;
+    for (const c of s) {
+        cur ^= 1 << asi(c) - 97; // get Hash (the set bit for a character.), update prefix parity
+        res += f[cur];
+        for (let i = 0; i < 10; i++) { // a ~ j
+            res += f[cur ^ 1 << i]; // 1 << i get Hash
+        }
+        f[cur]++;
+    }
+    return res;
+};

From b01cade35f60636ea9e07b6363c07888382d8af1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Jun 2021 21:19:52 +0800
Subject: [PATCH 1466/3374] Create
 1913-maximum-product-difference-between-two-pairs.js

---
 1913-maximum-product-difference-between-two-pairs.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1913-maximum-product-difference-between-two-pairs.js

diff --git a/1913-maximum-product-difference-between-two-pairs.js b/1913-maximum-product-difference-between-two-pairs.js
new file mode 100644
index 00000000..1786d953
--- /dev/null
+++ b/1913-maximum-product-difference-between-two-pairs.js
@@ -0,0 +1,9 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxProductDifference = function(nums) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  return nums[n - 1] * nums[n - 2] - nums[0] * nums[1]
+};

From 38124f40b946df05e9aed71e8c13c15928100097 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Jun 2021 21:22:02 +0800
Subject: [PATCH 1467/3374] Create
 1914-cyclically-rotating-a-gridsubmissions.js

---
 1914-cyclically-rotating-a-gridsubmissions.js | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 1914-cyclically-rotating-a-gridsubmissions.js

diff --git a/1914-cyclically-rotating-a-gridsubmissions.js b/1914-cyclically-rotating-a-gridsubmissions.js
new file mode 100644
index 00000000..8d950c18
--- /dev/null
+++ b/1914-cyclically-rotating-a-gridsubmissions.js
@@ -0,0 +1,65 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number[][]}
+ */
+var rotateGrid = function(grid, k) {
+    var m = grid.length;
+    var n = grid[0].length;
+	
+	  // step1: loop each layer
+    var layer = Math.min(n/2, m/2);
+    for(l = 0; l<layer; l++) {
+	     // step2: flat layer "l" into one-dimension array
+        var cur = [];
+        // top
+        for(var j = l; j<n-l; j++)
+        {
+            cur.push(grid[l][j]);
+        }
+        // right
+        for(var i = l+1; i<m-l; i++)
+        {
+            cur.push(grid[i][n-l-1]);
+        }
+        // bottom
+        for(var j = n-l-2; j>=l; j--)
+        {
+            cur.push(grid[m-l-1][j]);
+        }
+        // left
+        for(var i = m-l-2; i>l; i--)
+        {
+            cur.push(grid[i][l]);
+        }
+		
+        // step3: rotation (k%len) on one-dimension array
+        var d = cur.length;
+        var offset = k % d;
+        cur = [...cur.slice(offset, d), ...cur.slice(0, offset)];
+		
+        // step4: refill rotated array back to 2D array at current layer
+        var index = 0;
+        // top
+        for(var j = l; j<n-l; j++)
+        {
+            grid[l][j] = cur[index++];
+        }
+        // right
+        for(var i = l+1; i<m-l; i++)
+        {
+            grid[i][n-l-1] = cur[index++];
+        }
+        // bottom
+        for(var j = n-l-2; j>=l; j--)
+        {
+            grid[m-l-1][j] = cur[index++];
+        }
+        // left
+        for(var i = m-l-2; i>l; i--)
+        { 
+            grid[i][l] = cur[index++];
+        }
+    }
+    return grid;
+};

From 6380a7ab401f3b1075cabd293d5201e71fcf2951 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Jun 2021 14:53:16 +0800
Subject: [PATCH 1468/3374] Update
 1914-cyclically-rotating-a-gridsubmissions.js

---
 1914-cyclically-rotating-a-gridsubmissions.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/1914-cyclically-rotating-a-gridsubmissions.js b/1914-cyclically-rotating-a-gridsubmissions.js
index 8d950c18..056a22c3 100644
--- a/1914-cyclically-rotating-a-gridsubmissions.js
+++ b/1914-cyclically-rotating-a-gridsubmissions.js
@@ -1,3 +1,45 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number[][]}
+ */
+const rotateGrid = function(grid, k) {
+  const m = grid.length, n = grid[0].length
+  let top = 0, left = 0, right = n - 1, bottom = m - 1
+  while(top < bottom && left < right) {
+    const num = (right - left + 1) * 2 + (bottom - top + 1) * 2 - 4
+    let rem = k % num
+    while(rem) {
+      const tmp = grid[top][left]
+      // top
+      for(let i = left; i < right; i++) {
+        grid[top][i] = grid[top][i + 1]
+      }
+      // right
+      for(let i = top; i < bottom; i++) {
+        grid[i][right] = grid[i + 1][right]
+      }
+      // bottom
+      for(let i = right; i > left; i--) {
+        grid[bottom][i] = grid[bottom][i - 1]
+      }
+      // left
+      for(let i = bottom; i > top; i--) {
+        grid[i][left] = grid[i - 1][left]
+      }
+      grid[top + 1][left] = tmp
+      rem--
+    }
+    left++
+    top++
+    right--
+    bottom--
+  }
+  return grid
+};
+
+// another
+
 /**
  * @param {number[][]} grid
  * @param {number} k

From 41cd8bab244fb21d5185cd8ecabb5495f3c97347 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Jun 2021 16:14:58 +0800
Subject: [PATCH 1469/3374] Update 328-odd-even-linked-list.js

---
 328-odd-even-linked-list.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/328-odd-even-linked-list.js b/328-odd-even-linked-list.js
index f3615535..068e799b 100755
--- a/328-odd-even-linked-list.js
+++ b/328-odd-even-linked-list.js
@@ -23,3 +23,40 @@ const oddEvenList = function(head) {
   odd.next = evenHead;
   return head;
 };
+
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+function oddEvenList(head) {
+  if(head == null) return head
+  const dummyOdd = new ListNode()
+  const dummyEven = new ListNode()
+  
+  dummyOdd.next = head
+  let odd = head, even = dummyEven
+  let idx = 2, cur = head.next
+  while(cur) {
+    if (idx % 2 === 1) {
+      odd.next = cur
+      odd = odd.next
+    } else {
+      even.next = cur
+      even = even.next
+    }
+    cur = cur.next
+    idx++
+  }
+  odd.next = dummyEven.next
+  even.next = null
+  return dummyOdd.next
+}

From be83f821b2b1e5f3203e922821e9e58159d71b9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Jun 2021 22:04:29 +0800
Subject: [PATCH 1470/3374] Create 1911-maximum-alternating-subsequence-sum.js

---
 1911-maximum-alternating-subsequence-sum.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1911-maximum-alternating-subsequence-sum.js

diff --git a/1911-maximum-alternating-subsequence-sum.js b/1911-maximum-alternating-subsequence-sum.js
new file mode 100644
index 00000000..fbcfcabb
--- /dev/null
+++ b/1911-maximum-alternating-subsequence-sum.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxAlternatingSum = function(nums) {
+  let odd = 0, even = 0;
+  for (let a of nums) {
+    even = Math.max(even, odd + a);
+    odd = even - a;
+  }
+  return even;
+};

From e18ae1d53d26652d8d68b0f760cce2965d15248f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Jun 2021 23:04:12 +0800
Subject: [PATCH 1471/3374] Update 1911-maximum-alternating-subsequence-sum.js

---
 1911-maximum-alternating-subsequence-sum.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/1911-maximum-alternating-subsequence-sum.js b/1911-maximum-alternating-subsequence-sum.js
index fbcfcabb..555eefb8 100644
--- a/1911-maximum-alternating-subsequence-sum.js
+++ b/1911-maximum-alternating-subsequence-sum.js
@@ -10,3 +10,17 @@ const maxAlternatingSum = function(nums) {
   }
   return even;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxAlternatingSum = function(nums) {
+  let res = nums[0]
+  for(let i = 1; i < nums.length; i++) {
+    res += Math.max(nums[i] - nums[i - 1], 0)
+  }
+  return res
+};

From 581a790832e92872d6d75a9abb6321cc5f0e6fff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Jul 2021 19:44:40 +0800
Subject: [PATCH 1472/3374] Create
 1916-count-ways-to-build-rooms-in-an-ant-colony.js

---
 ...nt-ways-to-build-rooms-in-an-ant-colony.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 1916-count-ways-to-build-rooms-in-an-ant-colony.js

diff --git a/1916-count-ways-to-build-rooms-in-an-ant-colony.js b/1916-count-ways-to-build-rooms-in-an-ant-colony.js
new file mode 100644
index 00000000..4c4a6d4f
--- /dev/null
+++ b/1916-count-ways-to-build-rooms-in-an-ant-colony.js
@@ -0,0 +1,60 @@
+/**
+ * @param {number[]} prevRoom
+ * @return {number}
+ */
+const waysToBuildRooms = function (prevRoom) {
+  return brute(prevRoom);
+};
+function brute(prevRoom) {
+  const power = function (a, b, n) {
+    a = a % n;
+    let result = 1n;
+    let x = a;
+    while (b > 0) {
+      let leastSignificantBit = b % 2n;
+      b = b / 2n;
+      if (leastSignificantBit == 1n) {
+        result = result * x;
+        result = result % n;
+      }
+      x = x * x;
+      x = x % n;
+    }
+    return result;
+  };
+  const modInverse = function (aa, mm) {
+    return power(BigInt(aa), BigInt(mm - 2), BigInt(mm));
+  };
+  const mod = Math.pow(10, 9) + 7;
+  let nodes = {};
+  for (let i = 0; i < prevRoom.length; i++) {
+    nodes[i] = { val: i, edges: {} };
+  }
+  for (let i = 1; i < prevRoom.length; i++) {
+    nodes[prevRoom[i]].edges[i] = true;
+  }
+  let memo = {};
+  const numNodes = function (root) {
+    var key = root.val;
+    if (memo[key] !== undefined) {
+      return memo[key];
+    }
+    var res = 1;
+    for (var x in root.edges) {
+      res += numNodes(nodes[x]);
+    }
+    memo[key] = res;
+    return res;
+  };
+  let den = 1;
+  for (let x in nodes) {
+    let size = numNodes(nodes[x]);
+    den = (den * size) % mod;
+  }
+  let numerator = 1;
+  for (let i = 1; i < prevRoom.length; i++) {
+    numerator = (numerator * (i + 1)) % mod;
+  }
+  let denInverse = modInverse(den, mod);
+  return (BigInt(numerator) * denInverse) % BigInt(mod);
+}

From df2704dc754a5d636bcaacd977332e14097a09ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Jul 2021 10:43:59 +0800
Subject: [PATCH 1473/3374] Create tmp.js

---
 tmp.js | 86 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 tmp.js

diff --git a/tmp.js b/tmp.js
new file mode 100644
index 00000000..0479fb6d
--- /dev/null
+++ b/tmp.js
@@ -0,0 +1,86 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isDecomposable = function(s) {
+  let hasTwo = false
+  let i = 0
+  let j = 0
+  
+  while(j < s.length) {
+    while(j + 1 < s.length && s[j + 1] === s[i]) {
+      j += 1
+    }
+    
+    if (((j - i + 1) % 3) === 2) {
+      if (!hasTwo) {
+        hasTwo = true
+      } else {
+        return false
+      }
+    } else if (((j - i + 1) % 3) === 1) {
+      return false
+    }
+    j++
+    i = j
+  }
+    
+  return hasTwo
+};
+
+
+class Solution {
+public:
+    vector<int> longestCommomSubsequence(vector<vector<int>>& arrays) {
+        int n = arrays.size();
+        vector<int> nums = vector<int>(100); // 100 possible numbers as stated in the question
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < arrays[i].size(); j++) {
+                nums[arrays[i][j] - 1]++; // count occurrences
+            }
+        }
+        vector<int> ans;
+        for (int i = 0; i < 100; i++) {
+            if (nums[i] == n) ans.push_back(i + 1); // save it if it appears in every array
+        }
+        return ans;
+    }
+};
+
+class Solution {
+    public int[] findMaximums(int[] nums) {
+        if(nums == null || nums.length == 0) return nums;
+        // calc the [l, r] for each ele where in [l, r]: ele is the min value
+        int len = nums.length;
+        TreeSet<Integer> idx = new TreeSet<>();
+        Integer[] indices = new Integer[len];
+        for(int i = 0; i < len; i++) indices[i] = i;
+        Arrays.sort(indices, (l, r) -> nums[l] - nums[r]);
+        int prev = -1;
+        int[] ranges = new int[len];
+        Queue<Integer> sameLevel = new LinkedList<>();
+        int[] ans = new int[len];
+        for(int i = 0; i < len; i++) {
+            if(nums[indices[i]] > prev) {
+                while(!sameLevel.isEmpty()) {
+                    idx.add(sameLevel.poll());
+                }
+            }
+            Integer l = idx.lower(indices[i]);
+            Integer r = idx.higher(indices[i]);
+            ranges[indices[i]] = (r == null?len - 1:r - 1) - (l == null?0:l + 1) + 1;
+            prev = nums[indices[i]];
+            sameLevel.add(indices[i]);
+        }
+		// we iterate ranges from maximum to minimum to construct the ans array
+        int j = len - 1;
+        for(int i = len - 1; i >= 0; i--) {
+            while(j >= 0 && ranges[indices[j]] < len - i) {
+                j--;
+            }
+            ans[len - 1 - i] = nums[indices[j]];
+        }
+        return ans;
+    }
+}
+

From 20b14d2e6eac58734564dcebcac17dc592f8c116 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Jul 2021 10:45:09 +0800
Subject: [PATCH 1474/3374] Update tmp.js

---
 tmp.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tmp.js b/tmp.js
index 0479fb6d..23f8f619 100644
--- a/tmp.js
+++ b/tmp.js
@@ -84,3 +84,11 @@ class Solution {
     }
 }
 
+/**
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+var minDayskVariants = function(points, k) {
+    
+};

From a149b67e1ab0dc53275964091c6f5d1745695ba7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Jul 2021 11:34:05 +0800
Subject: [PATCH 1475/3374] Update tmp.js

---
 tmp.js | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 55 insertions(+), 8 deletions(-)

diff --git a/tmp.js b/tmp.js
index 23f8f619..4e53563a 100644
--- a/tmp.js
+++ b/tmp.js
@@ -84,11 +84,58 @@ class Solution {
     }
 }
 
-/**
- * @param {number[][]} points
- * @param {number} k
- * @return {number}
- */
-var minDayskVariants = function(points, k) {
-    
-};
+class Solution:
+    def minDayskVariants(self, points: List[List[int]], k: int) -> int:
+        lo = 0
+        hi = int(1e9)
+        
+		# binary search check helper function
+        def check(day):
+            lines = collections.defaultdict(collections.Counter)
+            
+            # 2d sweep line
+            for x, y in points:
+                lbx, lby = (x, y - day) # left point
+                ubx, uby = (x - day, y) # bottom point
+                
+				# lbx + lby == ubx + uby == new x axis's open line
+                lines[lbx+lby][lby-lbx] += 1
+                lines[ubx+uby][uby-ubx+1] -= 1 # 
+                
+				# lbx + lby == ubx + uby == new x axis's close line
+                lbx, lby = (x + day, y) # right point
+                ubx, uby = (x, y + day) # upper point
+                lines[lbx+lby+1][lby-lbx] -= 1 
+                lines[ubx+uby+1][uby-ubx+1] += 1
+            
+            # hold a new ranges to sweep all lines from left to right on new x axis
+            ranges = collections.Counter()
+			
+			# for every critical points on new x axis (it's a diag on the original axis),
+			# add the sweep lines on new y axis
+            for diag in sorted(lines):
+                for num in sorted(lines[diag]):
+                    cnt = lines[diag][num]
+                    ranges[num] += cnt
+                
+				# for every critical points, check whether there is an area having 
+				# overlapping points >= k
+                cur = 0
+                for num in sorted(ranges):
+                    cnt = ranges[num] 
+                    cur += cnt
+
+                    if cur >= k:
+                        return True
+            
+            return False
+                
+		# binary search
+        while lo < hi:
+            mid = (lo + hi) // 2
+            if check(mid):
+                hi = mid
+            else:
+                lo = mid + 1
+        
+        return lo

From 71f6c586f514180b8d40bb4a5f8b7ade1913cb3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Jul 2021 19:10:20 +0800
Subject: [PATCH 1476/3374] Update 1915-number-of-wonderful-substrings.js

---
 1915-number-of-wonderful-substrings.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1915-number-of-wonderful-substrings.js b/1915-number-of-wonderful-substrings.js
index 91de957c..8402c87d 100644
--- a/1915-number-of-wonderful-substrings.js
+++ b/1915-number-of-wonderful-substrings.js
@@ -1,3 +1,27 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const wonderfulSubstrings = (word) => {
+  let res = 0, count = Array(1024).fill(0);
+  let cur = 0;
+  count[0] = 1;
+  for (let i = 0; i < word.length; ++i) {
+    const num = word[i].charCodeAt() - 97;
+    cur ^= 1 << (num);
+    res += count[cur];
+    ++count[cur];
+    
+    for (let j = 0; j < 10; ++j) {
+      res += count[cur ^ (1 << j)];
+    }
+  }
+  
+  return res;
+};
+
+// another
+
 /**
  * @param {string} word
  * @return {number}

From 24b3960faa4823425bfecf769b4ba7fb29cf2115 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Jul 2021 22:24:46 +0800
Subject: [PATCH 1477/3374] Create
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
new file mode 100644
index 00000000..2617178c
--- /dev/null
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var findTheLongestSubstring = function (s, V = 'aeiou', max = 0) {
+  let encode = (c) => {
+    let i = V.indexOf(c)
+    return i == -1 ? 0 : 1 << i
+  }
+  let N = s.length
+  let A = Array(N + 1).fill(0)
+  let seen = new Map([[0, 0]])
+  for (let i = 1; i <= N; ++i) {
+    A[i] = A[i - 1] ^ encode(s[i - 1])
+    let first = seen.has(A[i]) ? seen.get(A[i]) : i
+    if (first == i) seen.set(A[i], i) // first seen A[i] index
+    max = Math.max(max, i - first) // max of i-th index minus first seen A[i] index
+  }
+  return max
+}

From de6b2cb187eee04d1053cab947c1e6f423909d0c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Jul 2021 22:25:19 +0800
Subject: [PATCH 1478/3374] Create 1920-build-array-from-permutation.js

---
 1920-build-array-from-permutation.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1920-build-array-from-permutation.js

diff --git a/1920-build-array-from-permutation.js b/1920-build-array-from-permutation.js
new file mode 100644
index 00000000..50dda790
--- /dev/null
+++ b/1920-build-array-from-permutation.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const buildArray = function(nums) {
+  const res = []
+  for(let i = 0, n = nums.length; i < n; i++) {
+    res[i] = nums[nums[i]]
+  }
+  return res
+};

From d33202213a761a267ba2dfee16a5f379cd8f0211 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Jul 2021 22:25:53 +0800
Subject: [PATCH 1479/3374] Create 1921-eliminate-maximum-number-of-monsters.js

---
 1921-eliminate-maximum-number-of-monsters.js | 90 ++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 1921-eliminate-maximum-number-of-monsters.js

diff --git a/1921-eliminate-maximum-number-of-monsters.js b/1921-eliminate-maximum-number-of-monsters.js
new file mode 100644
index 00000000..e21fbe7b
--- /dev/null
+++ b/1921-eliminate-maximum-number-of-monsters.js
@@ -0,0 +1,90 @@
+/**
+ * @param {number[]} dist
+ * @param {number[]} speed
+ * @return {number}
+ */
+const eliminateMaximum = function(dist, speed) {
+  const pq = new PriorityQueue((a, b) => a[0] / a[1] < b[0] / b[1])
+  const n = dist.length
+  for(let i = 0; i < n; i++) {
+    pq.push([dist[i], speed[i]])
+  }
+  let res = 0
+  while(true) {
+    if(pq.isEmpty()) break
+    if(pq.peek()[0] < 0) break
+    const tmp = pq.pop()
+    if(tmp[0] <= res * tmp[1]) break
+    res++
+  }
+  
+  return res
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From f8a08d45202da8603df63c5cf4e9145f73b88dc7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Jul 2021 22:26:21 +0800
Subject: [PATCH 1480/3374] Create 1922-count-good-numbers.js

---
 1922-count-good-numbers.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1922-count-good-numbers.js

diff --git a/1922-count-good-numbers.js b/1922-count-good-numbers.js
new file mode 100644
index 00000000..28813aaa
--- /dev/null
+++ b/1922-count-good-numbers.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countGoodNumbers = function (n) {
+  n = BigInt(n)
+  const MOD = BigInt(10 ** 9 + 7)
+  let res =
+    quick_pow(5n, (n + 1n) / 2n ) * quick_pow(4n, n / 2n)
+  res %= MOD
+  return res
+
+  function quick_pow(b, m) {
+    let ans = 1n
+    while (m) {
+      if (m % 2n === 1n) ans = (ans * b) % MOD
+      m = m / 2n
+      b = (b * b) % MOD
+    }
+    return ans
+  }
+}
+

From f103c1d369def980b94c77663ea44c34906890d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Jul 2021 20:16:09 +0800
Subject: [PATCH 1481/3374] Create
 1909-remove-one-element-to-make-the-array-strictly-increasing.js

---
 ...ment-to-make-the-array-strictly-increasing.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1909-remove-one-element-to-make-the-array-strictly-increasing.js

diff --git a/1909-remove-one-element-to-make-the-array-strictly-increasing.js b/1909-remove-one-element-to-make-the-array-strictly-increasing.js
new file mode 100644
index 00000000..9446fc73
--- /dev/null
+++ b/1909-remove-one-element-to-make-the-array-strictly-increasing.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canBeIncreasing = function(nums) {
+	let previous = nums[0];
+	let used = false;
+	for (let i = 1; i < nums.length; i++){
+		if (nums[i] <= previous) {
+      if (used) return false;
+      used = true;
+      if (i === 1 || nums[i] > nums[i - 2]) previous = nums[i];
+		} else previous = nums[i];
+	}
+	return true;
+};

From 162c1fc470efdd93b2103396b659597adbd20910 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Jul 2021 19:45:41 +0800
Subject: [PATCH 1482/3374] Create 1062-longest-repeating-substring.js

---
 1062-longest-repeating-substring.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1062-longest-repeating-substring.js

diff --git a/1062-longest-repeating-substring.js b/1062-longest-repeating-substring.js
new file mode 100644
index 00000000..605af3ed
--- /dev/null
+++ b/1062-longest-repeating-substring.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestRepeatingSubstring = function(s) {
+    const n = s.length;
+    // dp[i][j] means # of repeated chars for substrings ending at i and j
+    const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0));
+    let res = 0;
+    for (let i = 1; i <= n; i++) {
+        for (let j = i + 1; j <= n; j++) {
+            if (s.charAt(i - 1) === s.charAt(j - 1)) {
+                dp[i][j] = dp[i - 1][j - 1] + 1;
+                res = Math.max(res, dp[i][j]);
+            }
+        }
+    }
+    return res;
+};

From 62ef8fb36232f64f370f57d168d03b51b075c44c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Jul 2021 19:59:00 +0800
Subject: [PATCH 1483/3374] Update 1062-longest-repeating-substring.js

---
 1062-longest-repeating-substring.js | 32 +++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1062-longest-repeating-substring.js b/1062-longest-repeating-substring.js
index 605af3ed..9238e218 100644
--- a/1062-longest-repeating-substring.js
+++ b/1062-longest-repeating-substring.js
@@ -1,3 +1,35 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestRepeatingSubstring = function(s) {
+  let left = 0;
+  let right = s.length - 1;
+  while(left < right) {
+    let pivot = Math.floor((left + right + 1) / 2);
+    if (hasRepeat(s, pivot)) {
+      left = pivot;
+    } else {
+      right = pivot - 1;
+    }
+  }
+  return left;
+};
+
+const hasRepeat = (s, l) => {
+  const strings = new Set();
+  for (let i = 0; i < s.length - l + 1; i++) {
+    const sub = s.substr(i, l);
+    if (strings.has(sub)) {
+      return true;
+    }
+    strings.add(sub);
+  }
+  return false;
+}
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 83c62cb4a71bc6613363e889b2da06dad704f67a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Jul 2021 21:44:57 +0800
Subject: [PATCH 1484/3374] Update 1062-longest-repeating-substring.js

---
 1062-longest-repeating-substring.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/1062-longest-repeating-substring.js b/1062-longest-repeating-substring.js
index 9238e218..9016c72c 100644
--- a/1062-longest-repeating-substring.js
+++ b/1062-longest-repeating-substring.js
@@ -49,3 +49,6 @@ const longestRepeatingSubstring = function(s) {
     }
     return res;
 };
+
+// non-overlap version
+// http://nriverwang.blogspot.com/2013/04/longest-repeated-substring.html

From a4286175ebb89aa015c1f25043acd741d62c79a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Jul 2021 21:52:35 +0800
Subject: [PATCH 1485/3374] Update 1062-longest-repeating-substring.js

---
 1062-longest-repeating-substring.js | 62 +++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/1062-longest-repeating-substring.js b/1062-longest-repeating-substring.js
index 9016c72c..ee57fe13 100644
--- a/1062-longest-repeating-substring.js
+++ b/1062-longest-repeating-substring.js
@@ -52,3 +52,65 @@ const longestRepeatingSubstring = function(s) {
 
 // non-overlap version
 // http://nriverwang.blogspot.com/2013/04/longest-repeated-substring.html
+
+/*
+You are to find the longest repeated substring in a given text. 
+Repeated substrings may not overlap. If more than one substring is 
+repeated with the same length, print the first one you find.(starting 
+from the beginning of the text). NOTE: The substrings can't be all spaces.
+
+Input Sample:
+Your program should accept as its first argument a path to a filename. 
+The input file contains several lines. Each line is one test case.
+Each line contains a test string. eg.
+
+banana
+abc
+
+Output Sample:
+For each set of input produce a single line of output which is the 
+longest repeated substring. If there is none, print out the string NONE. eg.
+an
+NONE
+
+std::string repeated_substring(std::string &str) {
+    int len = str.length();
+
+    int **c = new int*[len + 1];
+    for (int i = 0; i <= len; ++i)
+        c[i] = new int[len + 1];
+    for (int i = 0; i <= len; ++i) {
+        c[i][0] = 0;
+        c[0][i] = 0;
+    }
+
+    int max_len = 0, index = len + 1;
+    for (int i = 1; i <= len; ++i) {
+        for (int j = 1; j <= len; ++j) {
+            if (str[i-1] == str[j-1] && abs(i-j) > c[i-1][j-1]) {
+                c[i][j] = c[i-1][j-1] + 1;
+                if (c[i][j] > max_len) {
+                    max_len = c[i][j];
+                    index = std::min(i, j);
+                }
+            } else {
+                c[i][j] = 0;
+            }
+        }
+    }
+    
+    for (int i = 0; i <= len; ++i)
+        delete[] c[i];
+    delete[] c;
+ 
+    if (max_len > 0) {
+        std::string ret = str.substr(index - max_len, max_len);
+        for (int i = 0; i < max_len; ++i)
+            if(ret[i] != ' ')
+                return ret;
+    }
+
+    return "NONE";
+}
+
+*/

From b1155a8772f666932f0d0adf0cbe1320f80f8c7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Jul 2021 20:58:53 +0800
Subject: [PATCH 1486/3374] Update 1044-longest-duplicate-substring.js

---
 1044-longest-duplicate-substring.js | 33 +++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1044-longest-duplicate-substring.js b/1044-longest-duplicate-substring.js
index 48291448..9403a04b 100644
--- a/1044-longest-duplicate-substring.js
+++ b/1044-longest-duplicate-substring.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const longestDupSubstring = function(s) {
+  const n = s.length
+  let l = 0, r = n, res = ''
+  while(l < r) {
+    const mid = (l + r + 1) >> 1
+    const [chk, str] = valid(s, mid)
+    if(chk) {
+      l = mid
+      res = str
+    } else {
+      r = mid - 1
+    }
+  }
+  return res
+};
+
+function valid(s, len) {
+  const set = new Set()
+  for(let i = 0, n = s.length; i <= n - len; i++) {
+    const tmp = s.substr(i, len)
+    if(set.has(tmp)) return [true, tmp]
+    set.add(tmp)
+  }
+  
+  return [false, '']
+}
+
+// another
+
 /**
  * @param {string} S
  * @return {string}

From c58ad69fda63cdb49068515e698478ec1c7d3428 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Jul 2021 11:58:55 +0800
Subject: [PATCH 1487/3374] Create 1554-strings-differ-by-one-character.js

---
 1554-strings-differ-by-one-character.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1554-strings-differ-by-one-character.js

diff --git a/1554-strings-differ-by-one-character.js b/1554-strings-differ-by-one-character.js
new file mode 100644
index 00000000..2ad361e8
--- /dev/null
+++ b/1554-strings-differ-by-one-character.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string[]} dict
+ * @return {boolean}
+ */
+ const differByOne = function(dict) {
+  const n = dict.length, m = dict[0].length
+  for (let j = 0; j < m; j++) {
+    const seen = new Set()
+    for(let i = 0; i < n; i++) {
+      const newStr = dict[i].slice(0, j) + '*' + dict[i].slice(j + 1)
+      if(seen.has(newStr)) return true
+      seen.add(newStr)
+    }
+  }
+
+  return false  
+};

From 434170a76041492af110b885a579b4c05ea1e399 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Jul 2021 13:21:22 +0800
Subject: [PATCH 1488/3374] Update 1554-strings-differ-by-one-character.js

---
 1554-strings-differ-by-one-character.js | 34 +++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/1554-strings-differ-by-one-character.js b/1554-strings-differ-by-one-character.js
index 2ad361e8..23044537 100644
--- a/1554-strings-differ-by-one-character.js
+++ b/1554-strings-differ-by-one-character.js
@@ -15,3 +15,37 @@
 
   return false  
 };
+
+// another
+
+/**
+ * @param {string[]} dict
+ * @return {boolean}
+ */
+const differByOne = function (dict) {
+  const M = dict.length,
+    N = dict[0].length
+  const hash = Array(M).fill(0),
+    ord = (c) => c.charCodeAt(0),
+    MOD = 1e13, seen = new Set()
+  // 1. generate each i-th rolling hash
+  for (let i = 0; i < M; ++i) {
+    let base = 1
+    for (let j = 0; j < N; ++j) {
+      hash[i] = (hash[i] + base * ord(dict[i][j])) % MOD
+      base = (123 * base) % MOD
+    }
+  }
+  // 2. remove each j-th char from each i-th rolling hash to 🔍 find a diff collision 💥
+  for (let i = 0; i < M; ++i) {
+    let base = 1
+    for (let j = 0; j < N; ++j) {
+      const diff = (hash[i] - base * ord(dict[i][j])) % MOD
+      if (seen.has(diff)) return true // 🎯 found a diff collision 💥
+      seen.add(diff)
+      base = (123 * base) % MOD
+    }
+  }
+  return false
+}
+

From 4c2916c4392d37262c1e0ccbfa6ce5e5905a42d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Jul 2021 21:37:35 +0800
Subject: [PATCH 1489/3374] Update 1554-strings-differ-by-one-character.js

---
 1554-strings-differ-by-one-character.js | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/1554-strings-differ-by-one-character.js b/1554-strings-differ-by-one-character.js
index 23044537..642d2ad0 100644
--- a/1554-strings-differ-by-one-character.js
+++ b/1554-strings-differ-by-one-character.js
@@ -24,26 +24,27 @@
  */
 const differByOne = function (dict) {
   const M = dict.length,
-    N = dict[0].length
-  const hash = Array(M).fill(0),
+    N = dict[0].length,
+    hash = Array(M).fill(0),
     ord = (c) => c.charCodeAt(0),
-    MOD = 1e13, seen = new Set()
+    MOD = 1e13, seen = new Set(),
+    zPlusOne = 'z'.charCodeAt(0)
   // 1. generate each i-th rolling hash
   for (let i = 0; i < M; ++i) {
     let base = 1
     for (let j = 0; j < N; ++j) {
       hash[i] = (hash[i] + base * ord(dict[i][j])) % MOD
-      base = (123 * base) % MOD
+      base = (zPlusOne * base) % MOD
     }
   }
-  // 2. remove each j-th char from each i-th rolling hash to 🔍 find a diff collision 💥
+  // 2. remove each j-th char from each i-th rolling hash to find a diff collision
   for (let i = 0; i < M; ++i) {
     let base = 1
     for (let j = 0; j < N; ++j) {
       const diff = (hash[i] - base * ord(dict[i][j])) % MOD
-      if (seen.has(diff)) return true // 🎯 found a diff collision 💥
+      if (seen.has(diff)) return true
       seen.add(diff)
-      base = (123 * base) % MOD
+      base = (zPlusOne * base) % MOD
     }
   }
   return false

From c1aaa80ce97ec60c757c4d1d574788a96c7716af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Jul 2021 20:30:21 +0800
Subject: [PATCH 1490/3374] Create 1923-longest-common-subpath.js

---
 1923-longest-common-subpath.js | 98 ++++++++++++++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 1923-longest-common-subpath.js

diff --git a/1923-longest-common-subpath.js b/1923-longest-common-subpath.js
new file mode 100644
index 00000000..b87890ea
--- /dev/null
+++ b/1923-longest-common-subpath.js
@@ -0,0 +1,98 @@
+/**
+ * @param {number} n
+ * @param {number[][]} paths
+ * @return {number}
+ */
+const longestCommonSubpath = function(n, paths) {
+  if (!paths.length) return 0
+  let arr = paths[0]
+  for (const path of paths) if (path.length < arr.length) arr = path
+  return new Sam(arr).longestCommonSubpath(paths)  
+};
+
+class State {
+  constructor(len, link, next) {
+    this.len = len
+    this.link = link
+    this.next = new Map(next)
+    this.ans = len
+    this.revLink = []
+    this.max = 0
+  }
+}
+
+/**
+ * @param p {State}
+ * @return boolean
+ */
+function dfs(p) {
+  let hasNext = false
+  for (const q of p.revLink) {
+    hasNext = dfs(q) || hasNext
+  }
+  if (hasNext) p.max = p.len
+  return p.max > 0
+}
+
+class Sam {
+  newState(len, link, next) {
+    const state = new State(len, link, next)
+    this.container.push(state)
+    return state
+  }
+
+  constructor(path) {
+    this.container = []
+    const root = this.newState(0, null)
+    let last = root
+    for (const x of path) {
+      const cur = this.newState(last.len + 1, root)
+      for (let p = last; p; p = p.link) {
+        const q = p.next.get(x)
+        if (!q) {
+          p.next.set(x, cur)
+          continue
+        }
+        if (q.len === p.len + 1) {
+          cur.link = q
+        } else {
+          const clone = this.newState(p.len + 1, q.link, q.next)
+          for (; p && p.next.get(x) === q; p = p.link) p.next.set(x, clone)
+          cur.link = q.link = clone
+        }
+        break
+      }
+      last = cur
+    }
+    for (const state of this.container)
+      if (state.link) state.link.revLink.push(state)
+  }
+
+  visit(path) {
+    for (const state of this.container) state.max = 0
+    const root = this.container[0]
+    let p = root
+    let len = 0
+    for (const x of path) {
+      for (; ; p = p.link, len = p.len) {
+        const q = p.next.get(x)
+        if (q) {
+          p = q
+          p.max = Math.max(p.max, ++len)
+          break
+        }
+        if (!p.link) break
+      }
+    }
+    dfs(root)
+    for (const state of this.container)
+      state.ans = Math.min(state.ans, state.max)
+  }
+
+  longestCommonSubpath(paths) {
+    for (const path of paths) this.visit(path)
+    let ans = 0
+    for (const state of this.container) ans = Math.max(ans, state.ans)
+    return ans
+  }
+}

From 4713a5e68fdd41ea2b44b8ab7da8d578da2fa667 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Jul 2021 22:49:28 +0800
Subject: [PATCH 1491/3374] Update
 1698-number-of-distinct-substrings-in-a-string.js

---
 ...mber-of-distinct-substrings-in-a-string.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1698-number-of-distinct-substrings-in-a-string.js b/1698-number-of-distinct-substrings-in-a-string.js
index 595ec3f7..f67060eb 100644
--- a/1698-number-of-distinct-substrings-in-a-string.js
+++ b/1698-number-of-distinct-substrings-in-a-string.js
@@ -12,3 +12,31 @@ const countDistinct = function(s) {
   
   return set.size
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countDistinct = function (s, count = 0) {
+  const root = new Trie()
+  const N = s.length
+  for (let i = 0; i < N; i++) {
+    let node = root
+    for (let j = i; j < N; j++) {
+      const c = s[j]
+      if (!node.children.has(c)) {
+        node.children.set(c, new Trie())
+        count++
+      }
+      node = node.children.get(c)
+    }
+  }
+  return count
+}
+class Trie {
+  constructor() {
+    this.children = new Map()
+  }
+}

From 97937489616b84f398e36b13e2da70180f7d2925 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Jul 2021 13:39:41 +0800
Subject: [PATCH 1492/3374] Create 1929-concatenation-of-array.js

---
 1929-concatenation-of-array.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1929-concatenation-of-array.js

diff --git a/1929-concatenation-of-array.js b/1929-concatenation-of-array.js
new file mode 100644
index 00000000..58d03269
--- /dev/null
+++ b/1929-concatenation-of-array.js
@@ -0,0 +1,7 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const getConcatenation = function(nums) {
+  return nums.concat(nums)
+};

From ea0451f4bf4d9dca10332bfcf540b036c05f26e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Jul 2021 13:47:18 +0800
Subject: [PATCH 1493/3374] Create
 1930-unique-length-3-palindromic-subsequences.js

---
 ...nique-length-3-palindromic-subsequences.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1930-unique-length-3-palindromic-subsequences.js

diff --git a/1930-unique-length-3-palindromic-subsequences.js b/1930-unique-length-3-palindromic-subsequences.js
new file mode 100644
index 00000000..e7365aa5
--- /dev/null
+++ b/1930-unique-length-3-palindromic-subsequences.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countPalindromicSubsequence = (s) => {
+    let res = 0;
+    for (let i = 0; i < 26; i++) {
+        for (let j = 0; j < 26; j++) {
+            let len = 0;
+            for (const c of s) {
+                if(len === 3) break
+                if (len == 0) {
+                    if (c.charCodeAt() - 97 == i) len++; // first char
+                } else if (len == 1) {
+                    if (c.charCodeAt() - 97 == j) len++; // second char
+                } else if (len == 2) {
+                    if (c.charCodeAt() - 97 == i) len++; // third char
+                }
+            }
+            if (len == 3) res++;
+        }
+    }
+    return res;
+};

From feae7bb96ef1925662cac6fa66abc02c6bb65733 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Jul 2021 14:16:25 +0800
Subject: [PATCH 1494/3374] Create
 1931-painting-a-grid-with-three-different-colors.js

---
 ...ting-a-grid-with-three-different-colors.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1931-painting-a-grid-with-three-different-colors.js

diff --git a/1931-painting-a-grid-with-three-different-colors.js b/1931-painting-a-grid-with-three-different-colors.js
new file mode 100644
index 00000000..f5d4e0bb
--- /dev/null
+++ b/1931-painting-a-grid-with-three-different-colors.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const colorTheGrid = function(m, n) {
+  // Get color of the `mask` at `pos`, 2 bit store 1 color
+  function getColor(mask, pos) {
+    return (mask >> (2 * pos)) & 3
+  }
+  // Set `color` to the `mask` at `pos`, 2 bit store 1 color
+  function setColor(mask, pos, color) {
+    return mask | (color << (2 * pos))
+  }
+  function dfs(r, curColMask, prevColMask, out) {
+    // Filled full color for a row
+    if(r === m) {
+      out.push(curColMask)
+      return
+    }
+    // Try colors i in [1=RED, 2=GREEN, 3=BLUE]
+    for(let i = 1; i <= 3; i++) {
+      if(getColor(prevColMask, r) !== i && (r === 0 || getColor(curColMask, r - 1) !== i)) {
+        dfs(r + 1, setColor(curColMask, r, i), prevColMask, out)
+      }
+    }
+  }
+  // Generate all possible columns we can draw, if the previous col is `prevColMask`
+  function neighbor(prevColMask) {
+    let out = []
+    dfs(0, 0, prevColMask, out)
+    return out
+  }
+  const mod = 10 ** 9 + 7
+  const memo = {}
+  function dp(c, prevColMask) {
+    // Found a valid way
+    if(c === n) return 1
+    if(memo[`${c},${prevColMask}`] != null) return memo[`${c},${prevColMask}`]
+    let res = 0
+    const arr = neighbor(prevColMask)
+    for(let e of arr) {
+      res = (res + dp(c + 1, e)) % mod
+    }
+    memo[`${c},${prevColMask}`] = res
+    return res
+  }
+  
+  return dp(0, 0)
+  
+};

From bc34f30424794e40a7e1596c94aee37a6f5c1201 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Jul 2021 09:37:30 +0800
Subject: [PATCH 1495/3374] Update 792-number-of-matching-subsequences.js

---
 792-number-of-matching-subsequences.js | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/792-number-of-matching-subsequences.js b/792-number-of-matching-subsequences.js
index d1ac1e88..bf440135 100644
--- a/792-number-of-matching-subsequences.js
+++ b/792-number-of-matching-subsequences.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number}
+ */
+const numMatchingSubseq = function(s, words) {
+  const hash = {}
+  for(let w of words) {
+    if(hash[w[0]] == null) hash[w[0]] = []
+    const it = w[Symbol.iterator]()
+    hash[w[0]].push( it )
+    it.next()
+  }
+  let res = 0
+  for(let ch of s) {
+    const advance = hash[ch] || []
+    hash[ch] = []
+    for(let it of advance) {
+      const obj = it.next()
+      if(obj.done === false) {
+        if(hash[obj.value] == null) hash[obj.value] = []
+        hash[obj.value].push(it)
+      } else {
+        res++
+      }
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} S
  * @param {string[]} words
@@ -20,3 +53,4 @@ const numMatchingSubseq = function(S, words) {
     }
     return res
   };
+

From 0076ffaddd7bdf657bebb06be929c086a64e66c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Jul 2021 10:29:18 +0800
Subject: [PATCH 1496/3374] Update
 1930-unique-length-3-palindromic-subsequences.js

---
 ...nique-length-3-palindromic-subsequences.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1930-unique-length-3-palindromic-subsequences.js b/1930-unique-length-3-palindromic-subsequences.js
index e7365aa5..d615b832 100644
--- a/1930-unique-length-3-palindromic-subsequences.js
+++ b/1930-unique-length-3-palindromic-subsequences.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countPalindromicSubsequence = function(s) {
+  const first = Array(26).fill(Infinity), last = Array(26).fill(0)
+  let res = 0
+  const n = s.length, a = 'a'.charCodeAt(0)
+  for(let i = 0; i < n; i++) {
+    const code = s[i].charCodeAt(0)
+    first[code - a] = Math.min(i, first[code - a])
+    last[code - a] = i
+  }
+
+  for(let i = 0; i < 26; i++) {
+    if(last[i] - 1 > first[i]) {
+      const tmp = s.slice(first[i] + 1, last[i])
+      const set = new Set()
+      for(let ch of tmp) set.add(ch)
+      res += set.size
+    }
+  }
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 58a7fab23cfac781d161f47de7230089d3bcb1c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Jul 2021 20:17:45 +0800
Subject: [PATCH 1497/3374] Create 1055-shortest-way-to-form-string,js

---
 1055-shortest-way-to-form-string,js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1055-shortest-way-to-form-string,js

diff --git a/1055-shortest-way-to-form-string,js b/1055-shortest-way-to-form-string,js
new file mode 100644
index 00000000..1628fb07
--- /dev/null
+++ b/1055-shortest-way-to-form-string,js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} source
+ * @param {string} target
+ * @return {number}
+ */
+const shortestWay = function(source, target) {
+  const a = 'a'.charCodeAt(0), map = Array(26).fill(0)
+  for(let ch of source) {
+    map[ch.charCodeAt(0) - a] = 1
+  }
+  let j = 0, res = 1
+  for(let i = 0, n = target.length; i < n; i++, j++) {
+    const cur = target[i]
+    if(map[cur.charCodeAt(0) - a] === 0) return -1
+    while(j < source.length && source[j] !== cur) {
+      j++
+    }
+    if(j === source.length) {
+      res++
+      j = -1
+      i--
+    }
+  }
+  
+  return res
+};

From e4c370f67b5167732252a665d58b650d48731b25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Jul 2021 11:35:36 +0800
Subject: [PATCH 1498/3374] Update
 524-longest-word-in-dictionary-through-deleting.js

---
 ...est-word-in-dictionary-through-deleting.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/524-longest-word-in-dictionary-through-deleting.js b/524-longest-word-in-dictionary-through-deleting.js
index 4e52aeaf..ee2326be 100644
--- a/524-longest-word-in-dictionary-through-deleting.js
+++ b/524-longest-word-in-dictionary-through-deleting.js
@@ -1,3 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string[]} dictionary
+ * @return {string}
+ */
+const findLongestWord = function(s, dictionary) {
+  dictionary.sort((a, b) => a.length === b.length ? cmp(a, b) : b.length - a.length)
+  let res = ''
+  for(let d of dictionary) {
+    let j = 0
+    for(let i = 0, n = s.length; i < n; i++) {
+      if(d[j] === s[i]) j++
+      if(j === d.length) return d
+    }
+  }
+  return ''
+  function cmp(s1, s2) {
+    for(let i = 0, n = s1.length; i < n; i++) {
+      if(s1[i] < s2[i]) return -1
+      else if(s1[i] > s2[i]) return 1
+    }
+    return 0
+  }
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @param {string[]} d

From 36979ae9c4e18592a8288da38451bca73fa86db9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Jul 2021 14:16:18 +0800
Subject: [PATCH 1499/3374] Update
 524-longest-word-in-dictionary-through-deleting.js

---
 ...est-word-in-dictionary-through-deleting.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/524-longest-word-in-dictionary-through-deleting.js b/524-longest-word-in-dictionary-through-deleting.js
index ee2326be..ffd815ae 100644
--- a/524-longest-word-in-dictionary-through-deleting.js
+++ b/524-longest-word-in-dictionary-through-deleting.js
@@ -1,3 +1,27 @@
+/**
+ * @param {string} s
+ * @param {string[]} dictionary
+ * @return {string}
+ */
+const findLongestWord = function(s, dictionary) {
+  let res = ''
+  for(let d of dictionary) {
+    let j = 0
+    for(let i = 0, n = s.length; i < n; i++) {
+      if(d[j] === s[i]) j++
+      if(j === d.length && j >= res.length) {
+        if(j > res.length || d < res) {
+          res = d
+        }
+        break
+      }
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string[]} dictionary

From 2b3f204c2a6d43089f5d06d4cc602d96d9ebbe41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Jul 2021 21:29:22 +0800
Subject: [PATCH 1500/3374] Create 788-rotated-digits.js

---
 788-rotated-digits.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 788-rotated-digits.js

diff --git a/788-rotated-digits.js b/788-rotated-digits.js
new file mode 100644
index 00000000..6954f420
--- /dev/null
+++ b/788-rotated-digits.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const rotatedDigits = function(n) {
+   const dp = new Array(n + 1).fill(0);
+    let count = 0;
+    for(let i = 0; i <= n; i++){
+      if(i < 10){
+        if(i == 0 || i == 1 || i == 8) dp[i] = 1;
+        else if(i == 2 || i == 5 || i == 6 || i == 9){
+          dp[i] = 2;
+          count++;
+        }
+      } else {
+        let a = dp[~~(i / 10)], b = dp[i % 10];
+        if(a == 1 && b == 1) dp[i] = 1;
+        else if(a >= 1 && b >= 1){
+          dp[i] = 2;
+          count++;
+        }
+      }
+    }
+    return count; 
+};

From 8925502135874a65c872804a90acf9cc3c0c1c2c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Jul 2021 22:07:09 +0800
Subject: [PATCH 1501/3374] Create
 1827-minimum-operations-to-make-the-array-increasing.js

---
 ...-operations-to-make-the-array-increasing.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1827-minimum-operations-to-make-the-array-increasing.js

diff --git a/1827-minimum-operations-to-make-the-array-increasing.js b/1827-minimum-operations-to-make-the-array-increasing.js
new file mode 100644
index 00000000..d5c31859
--- /dev/null
+++ b/1827-minimum-operations-to-make-the-array-increasing.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minOperations = function(nums) {
+  let res = 0
+  let pre = nums[0]
+  for(let i = 1, n = nums.length; i < n; i++) {
+    const e = nums[i]
+    if(e <= pre) {
+      res += pre - e + 1
+      pre++
+    } else {
+      pre = e
+    }
+  }
+  return res
+};

From 85c9132cc783be5f55a9f6ef46ef8f7bee91c08d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Jul 2021 22:13:41 +0800
Subject: [PATCH 1502/3374] Create 884-uncommon-words-from-two-sentences.js

---
 884-uncommon-words-from-two-sentences.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 884-uncommon-words-from-two-sentences.js

diff --git a/884-uncommon-words-from-two-sentences.js b/884-uncommon-words-from-two-sentences.js
new file mode 100644
index 00000000..73b4f0f2
--- /dev/null
+++ b/884-uncommon-words-from-two-sentences.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string[]}
+ */
+const uncommonFromSentences = function(s1, s2) {
+  const hash = {}
+  const a1 = s1.split(' '), a2 = s2.split(' ')
+  for(let e of a1) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const res = []
+  for(let e of a2) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  Object.keys(hash).forEach(k => {
+    if(hash[k] === 1) res.push(k)
+  })
+  
+  return res
+};

From 3fbb72cc90ff097156d899e71598665d2ecfc545 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Jul 2021 21:53:41 +0800
Subject: [PATCH 1503/3374] Update 727-minimum-window-subsequence.js

---
 727-minimum-window-subsequence.js | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/727-minimum-window-subsequence.js b/727-minimum-window-subsequence.js
index 54599fdb..c75b04cc 100644
--- a/727-minimum-window-subsequence.js
+++ b/727-minimum-window-subsequence.js
@@ -1,3 +1,43 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string}
+ */
+const minWindow = function(s1, s2) {
+  let res = '', n = s1.length, m = s2.length
+  if(s1 === '' || s2 === '') return res
+  let minLen = Infinity
+  let right = 0
+  while(right < n) {
+    let tIndex = 0
+    while(right < n) {
+      if(s1[right] === s2[tIndex]) tIndex++
+      if(tIndex === m) break
+      right++
+    }
+    if(right === n) break
+    let left = right
+    tIndex = m - 1
+    while(left >= 0) {
+      if(s1[left] === s2[tIndex]) {
+        tIndex--
+      }
+      if(tIndex < 0) break
+      left--
+    }
+    
+    if(right - left + 1 < minLen) {
+      minLen = right - left + 1
+      res = s1.slice(left, right + 1)
+    }
+    right = left + 1
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} S
  * @param {string} T

From 482ce325773fb19cdc8a9fb6ed30854ddbdb9b69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Jul 2021 21:03:49 +0800
Subject: [PATCH 1504/3374] Create
 1928-minimum-cost-to-reach-destination-in-time.js

---
 ...nimum-cost-to-reach-destination-in-time.js | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 1928-minimum-cost-to-reach-destination-in-time.js

diff --git a/1928-minimum-cost-to-reach-destination-in-time.js b/1928-minimum-cost-to-reach-destination-in-time.js
new file mode 100644
index 00000000..db1a7339
--- /dev/null
+++ b/1928-minimum-cost-to-reach-destination-in-time.js
@@ -0,0 +1,105 @@
+/**
+ * @param {number} maxTime
+ * @param {number[][]} edges
+ * @param {number[]} passingFees
+ * @return {number}
+ */
+const minCost = function(maxTime, edges, passingFees) {
+  const n = passingFees.length
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  const graph = {}
+  for(let [s, e, t] of edges) {
+    if(graph[s] == null) graph[s] = []
+    if(graph[e] == null) graph[e] = []
+    graph[s].push([e, t])
+    graph[e].push([s, t])
+  }
+  
+  const times = {}
+  
+  pq.push([passingFees[0], 0, 0])
+  while(!pq.isEmpty()) {
+    const [cost, node, time] = pq.pop()
+    
+    if(time > maxTime) continue
+    if(node === n - 1) return cost
+    
+    if(times[node] == null || times[node] > time) {
+      times[node] = time
+      for(let [nxt, ext] of graph[node]) {
+        pq.push([cost + passingFees[nxt], nxt, time + ext])
+      }
+    }
+    
+  }
+  
+  return -1
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 020e1611e5fc883086e80af8e2611ea656179eb3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Jul 2021 17:05:13 +0800
Subject: [PATCH 1505/3374] Update
 1931-painting-a-grid-with-three-different-colors.js

---
 ...ting-a-grid-with-three-different-colors.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/1931-painting-a-grid-with-three-different-colors.js b/1931-painting-a-grid-with-three-different-colors.js
index f5d4e0bb..1433b0e4 100644
--- a/1931-painting-a-grid-with-three-different-colors.js
+++ b/1931-painting-a-grid-with-three-different-colors.js
@@ -49,3 +49,54 @@ const colorTheGrid = function(m, n) {
   return dp(0, 0)
   
 };
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const colorTheGrid = function(m, n) {
+  const mod = 10 ** 9 + 7
+  const colors = [1, 2, 3]
+  const memoDp = {}, memoOpts = {}
+  function getColor(pos, preMask) {
+    return (preMask >> (pos * 2)) & 3
+  }
+  function setColor(pos, color, curMask) {
+    return curMask | (color << (pos * 2))
+  }
+  function dfs(pos, curMask, preMask, res) {
+    if(pos === m) {
+      res.push(curMask)
+      return
+    }
+    for(let c of colors) {
+      if(getColor(pos, preMask) !== c && (pos === 0 || getColor(pos - 1, curMask) !== c)) {
+        dfs(pos + 1, setColor(pos, c, curMask), preMask, res)
+      }
+    }
+  }
+  function curOpts(preMask) {
+    if (memoOpts[preMask]) return memoOpts[preMask]
+    const res = []
+    dfs(0, 0, preMask, res)
+    memoOpts[preMask] = res
+    return res
+  }
+  function dp(col, preMask) {
+    const k = `${col},${preMask}`
+    if(col === n) return 1
+    if(memoDp[k]) return memoDp[k]
+    let res = 0
+    const cur = curOpts(preMask)
+    for(let mask of cur) {
+      res = (res + dp(col + 1, mask)) % mod
+    }
+    memoDp[k] = res
+    return res
+  }
+
+  return dp(0, 0)
+};

From 71d7f23f3abbd2c1c8c2fc4da70ff6a1d8fbd8d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Jul 2021 20:32:52 +0800
Subject: [PATCH 1506/3374] Create 1207-unique-number-of-occurrences.js

---
 1207-unique-number-of-occurrences.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1207-unique-number-of-occurrences.js

diff --git a/1207-unique-number-of-occurrences.js b/1207-unique-number-of-occurrences.js
new file mode 100644
index 00000000..d1621449
--- /dev/null
+++ b/1207-unique-number-of-occurrences.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} arr
+ * @return {boolean}
+ */
+const uniqueOccurrences = function(arr) {
+  const hash = {}
+  for(let e of arr) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const ks = new Set(Object.keys(hash)), vs = new Set(Object.values(hash))
+  return ks.size === vs.size
+};

From b57dda7b727cb4945a79942e71fa2517134c7adf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Jul 2021 21:52:12 +0800
Subject: [PATCH 1507/3374] Create 800-similar-rgb-color.js

---
 800-similar-rgb-color.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 800-similar-rgb-color.js

diff --git a/800-similar-rgb-color.js b/800-similar-rgb-color.js
new file mode 100644
index 00000000..1b7974a8
--- /dev/null
+++ b/800-similar-rgb-color.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} color
+ * @return {string}
+ */
+const similarRGB = function(color) {
+  const candidates = ['00', '11', '22', '33', '44', '55', '66', '77', '88', '99', 'aa', 'bb', 'cc', 'dd', 'ee', 'ff']
+  const r = color.slice(1, 3), g = color.slice(3, 5), b = color.slice(5, 7)
+  
+  return `#${min(r)}${min(g)}${min(b)}`
+  
+  function min(str) {
+    let res = '', max = Infinity
+    for(let s of candidates) {
+      const tmp = Math.abs(parseInt(s, 16) - parseInt(str, 16))
+      if(tmp < max) {
+        max = tmp
+        res = s
+      }
+    }
+    return res
+  }
+};

From 94a31a36422426ee40219a1b86047cb6170f35da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Jul 2021 22:59:03 +0800
Subject: [PATCH 1508/3374] Create 824-goat-latin.js

---
 824-goat-latin.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 824-goat-latin.js

diff --git a/824-goat-latin.js b/824-goat-latin.js
new file mode 100644
index 00000000..da271e6c
--- /dev/null
+++ b/824-goat-latin.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} sentence
+ * @return {string}
+ */
+const toGoatLatin = function(sentence) {
+  const arr = sentence.split(' ')
+  const vowel = new Set(['a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'])
+  for(let i = 0, n = arr.length; i < n; i++) {
+    const first = arr[i][0]
+    const ma = vowel.has(first) ? 'ma' : ''
+    const tmp = !vowel.has(first) ? `${arr[i].slice(1)}${first}ma` : arr[i]
+    const suffix = 'a'.repeat(i + 1)
+    arr[i] = `${tmp}${ma}${suffix}`
+  }
+  return arr.join(' ')
+};

From 20127efbbcb75874b336e47861f4dff06348a27c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Jul 2021 23:15:48 +0800
Subject: [PATCH 1509/3374] Create 1214-two-sum-bsts.js

---
 1214-two-sum-bsts.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1214-two-sum-bsts.js

diff --git a/1214-two-sum-bsts.js b/1214-two-sum-bsts.js
new file mode 100644
index 00000000..7b83717c
--- /dev/null
+++ b/1214-two-sum-bsts.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root1
+ * @param {TreeNode} root2
+ * @param {number} target
+ * @return {boolean}
+ */
+const twoSumBSTs = function(root1, root2, target) {
+  if(root1 == null && root2 == null) return false
+  if(root2 == null) return root1.val === target
+  if(root1 == null) return root2.val === target
+  if(root1.val + root2.val === target) return true
+  if(root1.val + root2.val < target) {
+    return twoSumBSTs(root1.right, root2, target) || twoSumBSTs(root1, root2.right, target)
+  } else {
+    return twoSumBSTs(root1.left, root2, target) || twoSumBSTs(root1, root2.left, target)
+  }
+};

From 2255c916c2a089d0d37e1a22a757a7e017ab88b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Jul 2021 11:33:00 +0800
Subject: [PATCH 1510/3374] Update 1214-two-sum-bsts.js

---
 1214-two-sum-bsts.js | 43 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1214-two-sum-bsts.js b/1214-two-sum-bsts.js
index 7b83717c..fb363a05 100644
--- a/1214-two-sum-bsts.js
+++ b/1214-two-sum-bsts.js
@@ -23,3 +23,46 @@ const twoSumBSTs = function(root1, root2, target) {
     return twoSumBSTs(root1.left, root2, target) || twoSumBSTs(root1, root2.left, target)
   }
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root1
+ * @param {TreeNode} root2
+ * @param {number} target
+ * @return {boolean}
+ */
+const twoSumBSTs = function(root1, root2, target) {
+  if(root1 == null || root2 == null) return false
+  const s1 = [], s2 = []
+  while(true) {
+    while(root1) {
+      s1.push(root1)
+      root1 = root1.left
+    }
+    while(root2) {
+      s2.push(root2)
+      root2 = root2.right
+    }
+    if(s1.length === 0 || s2.length === 0) return false
+    const t1 = s1[s1.length - 1], t2 = s2[s2.length - 1]
+    if(t1.val + t2.val === target) return true
+    if(t1.val + t2.val < target) {
+      root1 = t1.right
+      s1.pop()
+    } else {
+      root2 = t2.left
+      s2.pop()
+    }
+    
+  }
+  return false
+};

From e69d6160ae9f7e0a8c4d2866c7608bf66e036793 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Jul 2021 21:13:40 +0800
Subject: [PATCH 1511/3374] Create 1932-merge-bsts-to-create-single-bst.js

---
 1932-merge-bsts-to-create-single-bst.js | 86 +++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 1932-merge-bsts-to-create-single-bst.js

diff --git a/1932-merge-bsts-to-create-single-bst.js b/1932-merge-bsts-to-create-single-bst.js
new file mode 100644
index 00000000..9a3040db
--- /dev/null
+++ b/1932-merge-bsts-to-create-single-bst.js
@@ -0,0 +1,86 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode[]} trees
+ * @return {TreeNode}
+ */
+const canMerge = function (trees) {
+  const mapRoots = {}
+  const mapLeaves = {}
+  let prev
+
+  //check all trees and hashMap all available roots and leaves
+  for (let node of trees) {
+    mapRoots[node.val] = node
+    if (node.left != null) {
+      if (mapLeaves[node.left.val] != null)
+        //different nodes can't refer to the same node -> abnormal BST
+        return null
+      mapLeaves[node.left.val] = node.left
+    }
+    if (node.right != null) {
+      if (mapLeaves[node.right.val] != null)
+        //different nodes can't refer to the same node -> abnormal BST
+        return null
+      mapLeaves[node.right.val] = node.right
+    }
+  }
+
+  let rootRes = null
+  let count = trees.length
+
+  //find potential root-result of the merged entire tree
+  //that is node without any references from the parent leaf nodes
+  for (let node of trees) {
+    if (mapLeaves[node.val] == null) {
+      rootRes = node
+      break
+    }
+  }
+
+  //if there are no nodes like that -> abnormal BST
+  if (rootRes == null) return rootRes
+
+  const q = []
+
+  //put root-result leaves into queue
+  if (rootRes.left != null) q.push(rootRes.left)
+  if (rootRes.right != null) q.push(rootRes.right)
+  count--
+
+  while (q.length) {
+    //get leaf from the queue and check if there is correponding available root
+    let leaf = q.pop()
+    let root = mapRoots[leaf.val]
+    if (root != null) {
+      //there is root matched to leaf, so let's merge it
+      count--
+      leaf.left = root.left
+      leaf.right = root.right
+      //add new leaves into the queue
+      if (root.left != null) q.push(root.left)
+      if (root.right != null) q.push(root.right)
+    }
+  }
+
+  prev = 0
+  //if we have merged all inputed trees and that is valid BST by values, then return rootRes
+  return count == 0 && recSanity(rootRes) ? rootRes : null
+
+  function recSanity(node) {
+    if (node == null) return true
+
+    if (!recSanity(node.left)) return false
+
+    if (prev >= node.val) return false
+    prev = node.val
+
+    return recSanity(node.right)
+  }
+}

From 963a280c6ad8d1d532be8ef67d205a7780ffda55 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Jul 2021 20:38:50 +0800
Subject: [PATCH 1512/3374] Create 1935-maximum-number-of-words-you-can-type.js

---
 1935-maximum-number-of-words-you-can-type.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1935-maximum-number-of-words-you-can-type.js

diff --git a/1935-maximum-number-of-words-you-can-type.js b/1935-maximum-number-of-words-you-can-type.js
new file mode 100644
index 00000000..ccbd27c8
--- /dev/null
+++ b/1935-maximum-number-of-words-you-can-type.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} text
+ * @param {string} brokenLetters
+ * @return {number}
+ */
+const canBeTypedWords = function(text, brokenLetters) {
+  const set = new Set(brokenLetters.split(''))
+  const arr = text.split(' ')
+  let res = 0
+  for(let e of arr) {
+    let ok = true
+    for(let c of e) {
+      if(set.has(c)) {
+        ok = false
+        break
+      }
+    }
+    if(ok) res++
+  }
+  
+  return res
+};

From e9f2b6f7596a3899bc2139f2024843fae5369304 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Jul 2021 20:39:26 +0800
Subject: [PATCH 1513/3374] Create 1936-add-minimum-number-of-rungs.js

---
 1936-add-minimum-number-of-rungs.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1936-add-minimum-number-of-rungs.js

diff --git a/1936-add-minimum-number-of-rungs.js b/1936-add-minimum-number-of-rungs.js
new file mode 100644
index 00000000..07eb14bc
--- /dev/null
+++ b/1936-add-minimum-number-of-rungs.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} rungs
+ * @param {number} dist
+ * @return {number}
+ */
+const addRungs = function(rungs, dist) {
+  let res = 0
+  let pre = 0
+  const { floor, ceil } = Math
+  for(let r of rungs) {
+    if(r - pre > dist) {
+      // console.log(r, pre)
+      res += ceil((r - pre) / dist) - 1
+    }
+    pre = r
+  }
+  return res
+};

From 6fab7f50b2d044e2b3091e6cf571934089926e71 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Jul 2021 20:40:09 +0800
Subject: [PATCH 1514/3374] Create 1937-maximum-number-of-points-with-cost.js

---
 1937-maximum-number-of-points-with-cost.js | 38 ++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1937-maximum-number-of-points-with-cost.js

diff --git a/1937-maximum-number-of-points-with-cost.js b/1937-maximum-number-of-points-with-cost.js
new file mode 100644
index 00000000..90cd8ab2
--- /dev/null
+++ b/1937-maximum-number-of-points-with-cost.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const maxPoints = function(points) {
+    let m = points.length, n = points[0].length;
+    let result = 0;
+    // dp
+    const dp = Array.from({ length: m }, () => Array(n).fill(0));
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (i == 0) {
+                dp[i][j] = points[i][j];
+            } else {
+                dp[i][j] = Math.max(points[i][j] + dp[i - 1][j], dp[i][j]);
+            }
+        }
+        for (let j = 0; j < n; j++) {
+            // right
+            for (let k = 1; k < n - j; k++) {
+                if (dp[i][j + k] >= dp[i][j] - k) {
+                    break;
+                }
+                dp[i][j + k] = dp[i][j] - k;
+            }
+            for (let k = 1; k <= j; k++) {
+                if (dp[i][j - k] >= dp[i][j] - k) {
+                    break;
+                }
+                dp[i][j - k] = dp[i][j] - k;
+            }
+        }
+    }
+    for (let j = 0; j < n; j++) {
+        result = Math.max(result, dp[m - 1][j]);
+    }
+    return result;
+};

From a81ac651d12303773009f36997d7a8fa625541f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Jul 2021 13:50:47 +0800
Subject: [PATCH 1515/3374] Update 1937-maximum-number-of-points-with-cost.js

---
 1937-maximum-number-of-points-with-cost.js | 33 ++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1937-maximum-number-of-points-with-cost.js b/1937-maximum-number-of-points-with-cost.js
index 90cd8ab2..83e5caf7 100644
--- a/1937-maximum-number-of-points-with-cost.js
+++ b/1937-maximum-number-of-points-with-cost.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const maxPoints = function(points) {
+  const m = points.length, n = points[0].length
+  let prev = points[0].slice()
+  for(let i = 1; i < m; i++) {
+    const left = []
+    left[0] = prev[0]
+    // left to right
+    for(let j = 1; j < n; j++) {
+      left[j] = Math.max(prev[j], left[j - 1] - 1)
+    }
+    const right = []
+    right[n - 1] = prev[n - 1]
+    // right to left
+    for(let j = n - 2; j >= 0; j--) {
+      right[j] = Math.max(prev[j], right[j + 1] - 1)
+    }
+
+    const cur = []
+    for(let j = 0; j < n; j++) {
+      cur[j] = Math.max(left[j], right[j]) + points[i][j]
+    }
+    prev = cur
+  }
+
+  return Math.max(...prev)
+};
+
+// another
+
 /**
  * @param {number[][]} points
  * @return {number}

From f4bb182f4069a55e214b8802f71b6276250ce0ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Jul 2021 16:29:21 +0800
Subject: [PATCH 1516/3374] Update 994-rotting-oranges.js

---
 994-rotting-oranges.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/994-rotting-oranges.js b/994-rotting-oranges.js
index e78c1ca8..2fa9a406 100644
--- a/994-rotting-oranges.js
+++ b/994-rotting-oranges.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const orangesRotting = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]]
+  const visited = new Set()
+  let q = []
+  let num = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 2) q.push([i, j]), visited.add(`${i},${j}`)
+      if(grid[i][j] !== 0) num++
+    }
+  }
+  let res = 0
+  while(q.length) {
+    const size = q.length
+    const tmp = []
+    for(let i = 0; i < size; i++) {
+      const [x, y] = q[i]
+      for(let [dx, dy] of dirs) {
+        const nx = x + dx, ny = y + dy
+        if(nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] === 1 && !visited.has(`${nx},${ny}`)) {
+          tmp.push([nx, ny])
+          visited.add(`${nx},${ny}`)
+        }
+      }
+    }
+    q = tmp
+    if(q.length) res++
+  }
+  return visited.size === num ? res : -1
+};
+
+// another
+
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 907efbb7dc4c088415ac3f2e64363c1488abbb3a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Jul 2021 19:57:59 +0800
Subject: [PATCH 1517/3374] Update
 795-number-of-subarrays-with-bounded-maximum.js

---
 ...umber-of-subarrays-with-bounded-maximum.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/795-number-of-subarrays-with-bounded-maximum.js b/795-number-of-subarrays-with-bounded-maximum.js
index 3ade7405..beb84f9d 100644
--- a/795-number-of-subarrays-with-bounded-maximum.js
+++ b/795-number-of-subarrays-with-bounded-maximum.js
@@ -21,3 +21,27 @@ const numSubarrayBoundedMax = function(A, L, R) {
     }
     return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} left
+ * @param {number} right
+ * @return {number}
+ */
+const numSubarrayBoundedMax = function(nums, left, right) {
+  let prev = -1, dp = 0, res = 0
+  for(let i = 0, n = nums.length; i < n; i++) {
+    const cur = nums[i]
+    if(cur < left) res += dp
+    else if(cur > right) {
+      dp = 0
+      prev = i
+    } else {
+      dp = i - prev
+      res += dp
+    }
+  }
+  return res
+};

From a55f0fa13d51d4c02f10898b5cf979f79091ffb5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Jul 2021 08:31:27 +0800
Subject: [PATCH 1518/3374] Update 46-permutations.js

---
 46-permutations.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/46-permutations.js b/46-permutations.js
index 2a3486a0..82faf2f7 100755
--- a/46-permutations.js
+++ b/46-permutations.js
@@ -21,3 +21,28 @@ function backtrack(list, tempList, nums) {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const permute = function(nums) {
+  const res = []
+  bt(nums, 0, [], res)
+  return res
+};
+
+function bt(nums, idx, cur, res) {
+  if(idx === nums.length) {
+    res.push(cur.slice())
+    return
+  }
+  for(let i = 0; i < nums.length; i++) {
+    if(cur.indexOf(nums[i]) !== -1) continue
+    cur.push(nums[i])
+    bt(nums, idx + 1, cur, res)
+    cur.pop()
+  }
+}

From aef824c507eb985d6bc1e9cd504b5fbba266214e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Jul 2021 19:26:02 +0800
Subject: [PATCH 1519/3374] Create
 1714-sum-of-special-evenly-spaced-elements-in-array.js

---
 ...special-evenly-spaced-elements-in-array.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 1714-sum-of-special-evenly-spaced-elements-in-array.js

diff --git a/1714-sum-of-special-evenly-spaced-elements-in-array.js b/1714-sum-of-special-evenly-spaced-elements-in-array.js
new file mode 100644
index 00000000..0d60e731
--- /dev/null
+++ b/1714-sum-of-special-evenly-spaced-elements-in-array.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const solve = function (nums, queries) {
+  const n = nums.length
+  const dividingPoint = Math.floor(Math.sqrt(n))
+  const mod = 1e9 + 7
+  const prefix = new Map()
+
+  const res = new Array(queries.length)
+  for (let i = 0; i < queries.length; i++) {
+    let x = queries[i][0],
+      y = queries[i][1]
+    if (y > dividingPoint) {
+      let sm = 0
+      while (x < n) {
+        sm += nums[x]
+        sm %= mod
+        x += y
+      }
+      res[i] = sm
+    } else {
+      let startingPoint = x % y
+      if (!prefix.has(y)) {
+        prefix.set(y, new Map())
+      }
+      if (!prefix.get(y).has(startingPoint)) {
+        const curPrefix = []
+        curPrefix.push(0)
+        let cur = startingPoint,
+          sm = 0
+        while (cur < n) {
+          sm += nums[cur]
+          sm %= mod
+          curPrefix.push(sm)
+          cur += y
+        }
+        prefix.get(y).set(startingPoint, curPrefix)
+      }
+      const curPrefix = prefix.get(y).get(startingPoint)
+      res[i] =
+        (curPrefix[curPrefix.length - 1] - curPrefix[~~(x / y)] + mod) % mod
+    }
+  }
+  return res
+}

From ee9db09e3737d81849fb66db363722701f2edbc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Jul 2021 22:17:52 +0800
Subject: [PATCH 1520/3374] Create 883-projection-area-of-3d-shapes.js

---
 883-projection-area-of-3d-shapes.js | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 883-projection-area-of-3d-shapes.js

diff --git a/883-projection-area-of-3d-shapes.js b/883-projection-area-of-3d-shapes.js
new file mode 100644
index 00000000..f4a914fc
--- /dev/null
+++ b/883-projection-area-of-3d-shapes.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const projectionArea = function(grid) {
+  let xy = 0, xz = 0, yz = 0
+  const m = grid.length, n = grid[0].length
+  for (let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j]) xy++
+    }
+  }
+  
+  for (let i = 0; i < m; i++) {
+    let tmp = 0
+    for(let j = 0; j < n; j++) {
+      tmp = Math.max(tmp, grid[i][j])
+    }
+    xz += tmp
+  }
+  for (let j = 0; j < n; j++) {
+    let tmp = 0
+    for(let i = 0; i < m; i++) {
+      tmp = Math.max(tmp, grid[i][j])  
+    }
+    yz += tmp
+  }
+  
+  return xy + yz + xz
+};

From 4f5ebfe03c18f1606661e33913777a093dfab61e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Jul 2021 10:40:03 +0800
Subject: [PATCH 1521/3374] Update
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...ters-to-satisfy-one-of-three-conditions.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index 3b29d69d..33672db3 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -28,3 +28,39 @@ const minCharacters = function (a, b) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+const minCharacters = function(a, b) {
+  return Math.min(method1(a, b), method1(b, a), method3(a, b))
+};
+
+function method1(str1, str2) {
+  let res = Infinity, a = 'a'.charCodeAt(0)
+  for(let i = 1; i < 26; i++) {
+    let cnt1 = 0, cnt2 = 0, mid = String.fromCharCode(a + i)
+    for(let ch of str1) {
+      if(ch >= mid) cnt1++ 
+    }
+    for(let ch of str2) {
+      if(ch < mid) cnt2++
+    }
+    res = Math.min(res, cnt1 + cnt2)
+  }
+  return res
+}
+
+function method3(str1, str2) {
+  const a = 'a'.charCodeAt(0)
+  const cnt1 = Array(26).fill(0), cnt2 = Array(26).fill(0)
+  for(let ch of str1) cnt1[ch.charCodeAt(0) - a]++
+  for(let ch of str2) cnt2[ch.charCodeAt(0) - a]++
+  let res = 0
+  for(let i = 0; i < 26; i++) res = Math.max(res, cnt1[i] + cnt2[i])
+  return str1.length + str2.length - res
+}

From 810ab27bde81dbe302bfa374031b437461b17e0b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Jul 2021 10:43:41 +0800
Subject: [PATCH 1522/3374] Update
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...-minimum-characters-to-satisfy-one-of-three-conditions.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index 33672db3..8a9118f7 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -60,7 +60,6 @@ function method3(str1, str2) {
   const cnt1 = Array(26).fill(0), cnt2 = Array(26).fill(0)
   for(let ch of str1) cnt1[ch.charCodeAt(0) - a]++
   for(let ch of str2) cnt2[ch.charCodeAt(0) - a]++
-  let res = 0
-  for(let i = 0; i < 26; i++) res = Math.max(res, cnt1[i] + cnt2[i])
-  return str1.length + str2.length - res
+  return str1.length + str2.length - Math.max(...cnt1) - Math.max(...cnt2)
 }
+

From ae8f26b97b2d78ce8a492ce2e820f08abfe0617e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Jul 2021 19:25:44 +0800
Subject: [PATCH 1523/3374] Update
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...ters-to-satisfy-one-of-three-conditions.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index 8a9118f7..aa948052 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -63,3 +63,34 @@ function method3(str1, str2) {
   return str1.length + str2.length - Math.max(...cnt1) - Math.max(...cnt2)
 }
 
+// another
+
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+const minCharacters = function (a, b) {
+  const m = a.length, n = b.length
+  let res = m + n
+  const cnt1 = Array(26).fill(0), cnt2 = Array(26).fill(0)
+  const ac = 'a'.charCodeAt(0)
+  for(let ch of a) cnt1[ch.charCodeAt(0) - ac]++
+  for(let ch of b) cnt2[ch.charCodeAt(0) - ac]++
+  const c3 = res - Math.max(...cnt1) - Math.max(...cnt2)
+  for(let i = 0; i < 26; i++) {
+    if(i > 0) {
+      cnt1[i] += cnt1[i - 1]
+      cnt2[i] += cnt2[i - 1]      
+    }
+
+    if(i < 25) {
+      res = Math.min(res, m - cnt1[i] + cnt2[i])
+      res = Math.min(res, n - cnt2[i] + cnt1[i])
+    }
+  }
+  
+  return Math.min(res, c3)
+}
+
+

From 02f63a785f89ba5c485bebc2262d8df3b286470f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Jul 2021 20:47:53 +0800
Subject: [PATCH 1524/3374] Create 892-surface-area-of-3d-shapes.js

---
 892-surface-area-of-3d-shapes.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 892-surface-area-of-3d-shapes.js

diff --git a/892-surface-area-of-3d-shapes.js b/892-surface-area-of-3d-shapes.js
new file mode 100644
index 00000000..fca60f28
--- /dev/null
+++ b/892-surface-area-of-3d-shapes.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const surfaceArea = function(grid) {
+  if(grid == null || grid.length === 0) return 0
+  const m = grid.length, n = grid[0].length
+  let res = 0, adj = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      const h = grid[i][j]
+      if(h) res += h * 4 + 2
+      if(j > 0) {
+        if(grid[i][j - 1]) adj += Math.min(h, grid[i][j - 1])
+      }
+      if(i > 0) {
+        if(grid[i - 1][j]) adj += Math.min(h, grid[i - 1][j])
+      }
+      // console.log(adj)
+    }
+  }
+  
+  return res - adj * 2
+};
+
+// 2 * 4 + 2
+// 6 + 10 + 14 + 18 - (1 + 2 + 3 + 1) * 2

From eb274fe276fba0aa42b19631b3c3a6467be095bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 14:14:26 +0800
Subject: [PATCH 1525/3374] Create 897-increasing-order-search-tree.js

---
 897-increasing-order-search-tree.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 897-increasing-order-search-tree.js

diff --git a/897-increasing-order-search-tree.js b/897-increasing-order-search-tree.js
new file mode 100644
index 00000000..afa41b35
--- /dev/null
+++ b/897-increasing-order-search-tree.js
@@ -0,0 +1,23 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const increasingBST = function(root) {
+  return helper(root, null)
+};
+
+function helper(node, tail) {
+  if(node == null) return tail
+  const res = helper(node.left, node)
+  node.left = null
+  node.right = helper(node.right, tail)
+  return res
+}

From 2e67ffa6dfc49b4647328e621afc480fc0909859 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 15:55:00 +0800
Subject: [PATCH 1526/3374] Create 888-fair-candy-swap.js

---
 888-fair-candy-swap.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 888-fair-candy-swap.js

diff --git a/888-fair-candy-swap.js b/888-fair-candy-swap.js
new file mode 100644
index 00000000..8764adaa
--- /dev/null
+++ b/888-fair-candy-swap.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} aliceSizes
+ * @param {number[]} bobSizes
+ * @return {number[]}
+ */
+const fairCandySwap = function(aliceSizes, bobSizes) {
+  let sum = 0
+  for(let e of aliceSizes) sum += e
+  for(let e of bobSizes) sum -= e
+  // sum > 0, alice > bob
+  // sum < 0, alice < bob
+  sum /= 2
+  const set = new Set()
+  for(let e of aliceSizes) set.add(e)
+  for(let e of bobSizes) {
+    if(set.has(e + sum)) return [e + sum, e]
+  }
+  return [0]
+};

From 3c32c5726bd48cf4292ed22350f8b9d5e6768876 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 16:03:09 +0800
Subject: [PATCH 1527/3374] Create 896-monotonic-array.js

---
 896-monotonic-array.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 896-monotonic-array.js

diff --git a/896-monotonic-array.js b/896-monotonic-array.js
new file mode 100644
index 00000000..8850288d
--- /dev/null
+++ b/896-monotonic-array.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const isMonotonic = function(nums) {
+  return inc(nums) || dec(nums)
+};
+
+function inc(nums) {
+  if(nums == null || nums.length <= 1) return true
+  for(let i = 1, n = nums.length; i < n; i++) {
+    if(nums[i] < nums[i - 1]) return false
+  }
+  return true 
+}
+function dec(nums) {
+  if(nums == null || nums.length <= 1) return true
+  for(let i = 1, n = nums.length; i < n; i++) {
+    if(nums[i] > nums[i - 1]) return false
+  }
+  return true 
+}

From d2766b511d1344f5d298f7469fe72dc63e62ed4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 16:08:45 +0800
Subject: [PATCH 1528/3374] Update 896-monotonic-array.js

---
 896-monotonic-array.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/896-monotonic-array.js b/896-monotonic-array.js
index 8850288d..03a547f6 100644
--- a/896-monotonic-array.js
+++ b/896-monotonic-array.js
@@ -20,3 +20,18 @@ function dec(nums) {
   }
   return true 
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const isMonotonic = function(nums) {
+  let inc = true, dec =  true
+  for(let i = 1, n = nums.length; i < n; i++) {
+    inc &= nums[i] >= nums[i - 1]
+    dec &= nums[i] <= nums[i - 1]
+  }
+  return inc ||  dec
+};

From 242261da9b804b6e53c4c38d69974d15a50bdba0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 17:42:21 +0800
Subject: [PATCH 1529/3374] Create 908-smallest-range-i.js

---
 908-smallest-range-i.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 908-smallest-range-i.js

diff --git a/908-smallest-range-i.js b/908-smallest-range-i.js
new file mode 100644
index 00000000..8139e659
--- /dev/null
+++ b/908-smallest-range-i.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const smallestRangeI = function(nums, k) {
+  let min = Infinity, max = -Infinity
+  for(let e of nums) {
+    min = Math.min(min, e)
+    max = Math.max(max, e)
+  }
+  return max - k >= min + k ? max - k - (min + k) : 0
+};

From 2b854316abf745d4e44510ea62b0a4b3f79a470f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 20:05:46 +0800
Subject: [PATCH 1530/3374] Create 914-x-of-a-kind-in-a-deck-of-cards.js

---
 914-x-of-a-kind-in-a-deck-of-cards.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 914-x-of-a-kind-in-a-deck-of-cards.js

diff --git a/914-x-of-a-kind-in-a-deck-of-cards.js b/914-x-of-a-kind-in-a-deck-of-cards.js
new file mode 100644
index 00000000..04754e03
--- /dev/null
+++ b/914-x-of-a-kind-in-a-deck-of-cards.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} deck
+ * @return {boolean}
+ */
+const hasGroupsSizeX = function(deck) {
+  if(deck == null || deck.length <= 1) return false
+  const hash = {}
+  for(let e of deck) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  let res = 0
+  for(let k in hash) res = gcd(hash[k], res)
+  return res > 1
+};
+
+function gcd(a, b) {
+  return b ? gcd(b, a % b) : a
+}

From 6d65568f03bf9e51932c3d8141d2c376aabf59b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 21:38:46 +0800
Subject: [PATCH 1531/3374] Create
 1142-user-activity-for-the-past-30-days-ii.sql

---
 1142-user-activity-for-the-past-30-days-ii.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1142-user-activity-for-the-past-30-days-ii.sql

diff --git a/1142-user-activity-for-the-past-30-days-ii.sql b/1142-user-activity-for-the-past-30-days-ii.sql
new file mode 100644
index 00000000..d2b3aad1
--- /dev/null
+++ b/1142-user-activity-for-the-past-30-days-ii.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT ifnull(ROUND(COUNT(DISTINCT session_id)/COUNT(DISTINCT user_id), 2),0.00) 
+AS average_sessions_per_user
+FROM Activity 
+WHERE activity_date >= '2019-06-28' and activity_date <= '2019-07-27'; 

From 62c3958c684017107ec4bfc1aadcfca8cc0c7e33 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 21:57:41 +0800
Subject: [PATCH 1532/3374] Create 874-walking-robot-simulation.js

---
 874-walking-robot-simulation.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 874-walking-robot-simulation.js

diff --git a/874-walking-robot-simulation.js b/874-walking-robot-simulation.js
new file mode 100644
index 00000000..546f5da6
--- /dev/null
+++ b/874-walking-robot-simulation.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} commands
+ * @param {number[][]} obstacles
+ * @return {number}
+ */
+const robotSim = function(commands, obstacles) {
+  const dirs = [[1, 0], [0, -1], [-1, 0], [0, 1]] // east, south, west, north
+  const set = new Set()
+  obstacles.forEach(([x, y]) => set.add(`${x},${y}`))
+  let idx = 3, x = 0, y = 0, res = 0
+  for(let e of commands) {
+    if(e === -2) idx = (3 + idx) % 4
+    else if(e === -1) idx = (1 + idx) % 4
+    else {
+      const [dx, dy] = dirs[idx]
+      let dis = 0
+      while(dis < e) {
+        const nx = x + dx, ny = y + dy
+        const k = `${nx},${ny}`
+        if(set.has(k)) break
+        x = nx
+        y = ny
+        dis++
+        res = Math.max(res, x * x + y * y)
+      }
+    }
+  }
+  
+  return res
+};

From 7da1019c85520b3b9319e3c72fea7311bc309bb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Jul 2021 22:08:39 +0800
Subject: [PATCH 1533/3374] Create
 1304-find-n-unique-integers-sum-up-to-zero.js

---
 1304-find-n-unique-integers-sum-up-to-zero.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1304-find-n-unique-integers-sum-up-to-zero.js

diff --git a/1304-find-n-unique-integers-sum-up-to-zero.js b/1304-find-n-unique-integers-sum-up-to-zero.js
new file mode 100644
index 00000000..ed551311
--- /dev/null
+++ b/1304-find-n-unique-integers-sum-up-to-zero.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const sumZero = function(n) {
+  const num = ~~(n / 2)
+  const odd = n % 2 === 1
+  const res = pair(num)
+  if(odd) res.push(0)
+  return res
+};
+
+function pair(num) {
+  const set = new Set()
+  const res = []
+  for(let i = 1; i <= num; i++) res.push(i, -i)
+  return res
+}

From 07bd61894a91e2f50066092a0d4b42751a17f5c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 09:08:26 +0800
Subject: [PATCH 1534/3374] Update
 421-maximum-xor-of-two-numbers-in-an-array.js

---
 421-maximum-xor-of-two-numbers-in-an-array.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/421-maximum-xor-of-two-numbers-in-an-array.js b/421-maximum-xor-of-two-numbers-in-an-array.js
index ed3ff2a3..1e71476c 100644
--- a/421-maximum-xor-of-two-numbers-in-an-array.js
+++ b/421-maximum-xor-of-two-numbers-in-an-array.js
@@ -21,6 +21,20 @@ const findMaximumXOR = function(nums) {
 
 // another
 
+/*
+
+This algorithm's idea is:
+to iteratively determine what would be each bit of the final result from left to right.
+And it narrows down the candidate group iteration by iteration. e.g. assume input are a,b,c,d,...z, 26 integers in total.
+In first iteration, if you found that a, d, e, h, u differs on the MSB(most significant bit),
+so you are sure your final result's MSB is set. Now in second iteration,
+you try to see if among a, d, e, h, u there are at least two numbers make the 2nd MSB differs,
+if yes, then definitely, the 2nd MSB will be set in the final result.
+And maybe at this point the candidate group shinks from a,d,e,h,u to a, e, h.
+Implicitly, every iteration, you are narrowing down the candidate group,
+but you don't need to track how the group is shrinking, you only cares about the final result.
+
+*/
 /*
  * @lc app=leetcode id=421 lang=javascript
  *

From 09defccfb49ea091e6b30b001944ea87bfd6ec02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 10:25:58 +0800
Subject: [PATCH 1535/3374] Create 925-long-pressed-name.js

---
 925-long-pressed-name.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 925-long-pressed-name.js

diff --git a/925-long-pressed-name.js b/925-long-pressed-name.js
new file mode 100644
index 00000000..68f487ae
--- /dev/null
+++ b/925-long-pressed-name.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} name
+ * @param {string} typed
+ * @return {boolean}
+ */
+const isLongPressedName = function(name, typed) {
+  let i = 0, m = name.length, n = typed.length
+  for(let j = 0; j < n; j++) {
+    if(i < m && name[i] === typed[j]) i++
+    else if(j === 0 || typed[j] !== typed[j - 1]) return false
+  }
+  return i === m
+};

From fa34677c1d2e04229fdf9b1b4b3d1aeea6ad3b75 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 10:38:39 +0800
Subject: [PATCH 1536/3374] Create 976-largest-perimeter-triangle.js

---
 976-largest-perimeter-triangle.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 976-largest-perimeter-triangle.js

diff --git a/976-largest-perimeter-triangle.js b/976-largest-perimeter-triangle.js
new file mode 100644
index 00000000..6cae6005
--- /dev/null
+++ b/976-largest-perimeter-triangle.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const largestPerimeter = function(nums) {
+  nums.sort((a, b) => a - b)
+  for(let i = nums.length - 1; i > 1; i--) {
+    if(nums[i] < nums[i - 1] + nums[i - 2]) return nums[i - 2] + nums[i - 1] + nums[i]
+  }
+  return 0
+};

From 98898d93bd65807ea02d9664835665f7d710de0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 11:15:22 +0800
Subject: [PATCH 1537/3374] Create 989-add-to-array-form-of-integer.js

---
 989-add-to-array-form-of-integer.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 989-add-to-array-form-of-integer.js

diff --git a/989-add-to-array-form-of-integer.js b/989-add-to-array-form-of-integer.js
new file mode 100644
index 00000000..9d43f139
--- /dev/null
+++ b/989-add-to-array-form-of-integer.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} num
+ * @param {number} k
+ * @return {number[]}
+ */
+const addToArrayForm = function(num, k) {
+  const res = []
+  for(let i = num.length - 1; i >= 0; i--) {
+    const tmp = num[i] + k
+    res.push(tmp % 10)
+    k = ~~(tmp / 10)
+  }
+
+  while(k > 0) {
+    res.push(k % 10)
+    k  = ~~(k / 10)
+  }
+  res.reverse()
+  return res
+};

From 74846a457e19f730fb157b33762732eef9a76a58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 13:42:54 +0800
Subject: [PATCH 1538/3374] Create 999-available-captures-for-rook.js

---
 999-available-captures-for-rook.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 999-available-captures-for-rook.js

diff --git a/999-available-captures-for-rook.js b/999-available-captures-for-rook.js
new file mode 100644
index 00000000..d6fb8571
--- /dev/null
+++ b/999-available-captures-for-rook.js
@@ -0,0 +1,18 @@
+/**
+ * @param {character[][]} board
+ * @return {number}
+ */
+const numRookCaptures = function(board) {
+  for (let i = 0; i < board.length; ++i)
+    for (let j = 0; j < board[i].length; ++j)
+      if (board[i][j] == 'R') return cap(board,i,j,0,1)+cap(board,i,j,0,-1)+cap(board,i,j,1,0)+cap(board,i,j,-1,0);
+  return 0;  
+};
+
+function cap(b, x, y, dx, dy) {
+  while (x >= 0 && x < b.length && y >= 0 && y < b[x].length && b[x][y] != 'B') {
+    if (b[x][y] == 'p') return 1;
+    x += dx; y += dy;
+  }
+  return 0;
+}

From 79fcc678ffb29d94ab3b7184b982b6f0f1380c13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 13:50:10 +0800
Subject: [PATCH 1539/3374] Create
 1050-actors-and-directors-who-cooperated-at-least-three-times.sql

---
 ...ors-and-directors-who-cooperated-at-least-three-times.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1050-actors-and-directors-who-cooperated-at-least-three-times.sql

diff --git a/1050-actors-and-directors-who-cooperated-at-least-three-times.sql b/1050-actors-and-directors-who-cooperated-at-least-three-times.sql
new file mode 100644
index 00000000..13ea8e07
--- /dev/null
+++ b/1050-actors-and-directors-who-cooperated-at-least-three-times.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+SELECT actor_id, director_id
+FROM ActorDirector
+GROUP BY actor_id, director_id
+HAVING COUNT(1) >= 3

From f868e22c38aa2a47b2a24cb34c2e5a3baf5a66df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 14:23:23 +0800
Subject: [PATCH 1540/3374] Create 1056-confusing-number.js

---
 1056-confusing-number.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1056-confusing-number.js

diff --git a/1056-confusing-number.js b/1056-confusing-number.js
new file mode 100644
index 00000000..66bb7319
--- /dev/null
+++ b/1056-confusing-number.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const confusingNumber = function(n) {
+  //  0, 1, 6, 8, 9
+  const invalid = new Set(['2', '3', '4', '5', '7'])
+  const valid = new Set(['6', '9'])
+  const arr = ('' + n).split('')
+  let num = 0
+  for(let i = 0; i < arr.length; i++) {
+    const ch = arr[i]
+    if(invalid.has(ch)) return false
+    if(ch === '6') arr[i] = '9'
+    else if(ch  === '9') arr[i] = '6'
+  }
+  arr.reverse()
+  return arr.join('') !== '' + n
+};

From 5c385e22791d5003e5383cde56d06483fa1d5422 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 15:06:13 +0800
Subject: [PATCH 1541/3374] Create 1064-fixed-point.js

---
 1064-fixed-point.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1064-fixed-point.js

diff --git a/1064-fixed-point.js b/1064-fixed-point.js
new file mode 100644
index 00000000..39a1113d
--- /dev/null
+++ b/1064-fixed-point.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const fixedPoint = function(arr) {
+  const n = arr.length
+  let l = 0, r = n - 1
+  while(l < r) {
+    const mid = l + ((r - l) >> 1)
+    if(arr[mid] < mid) l =  mid + 1
+    else if(arr[mid] > mid) r = mid - 1
+    else r = mid
+  }
+  return arr[l] === l ? l : -1
+};

From 53415dc40f67e2e4dfe113a46a3f399c5929c682 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 15:54:26 +0800
Subject: [PATCH 1542/3374] Create 1065-index-pairs-of-a-string.js

---
 1065-index-pairs-of-a-string.js | 41 +++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1065-index-pairs-of-a-string.js

diff --git a/1065-index-pairs-of-a-string.js b/1065-index-pairs-of-a-string.js
new file mode 100644
index 00000000..90eca7b8
--- /dev/null
+++ b/1065-index-pairs-of-a-string.js
@@ -0,0 +1,41 @@
+/**
+ * @param {string} text
+ * @param {string[]} words
+ * @return {number[][]}
+ */
+const indexPairs = function(text, words) {
+  const res = [], trie = buildTrie(words)
+  const n = text.length
+  for(let i = 0; i < n; i++) {
+    let node = trie
+    for(let j = i; j < n; j++) {
+      if(node.children[text[j]] == null) break
+      node = node.children[text[j]]
+      if(node.isWord) res.push([i, j])
+    }
+  }
+
+  return res
+};
+
+function buildTrie(words) {
+  const root = new Trie()
+  
+  for(let word of words) {
+    let node = root
+    for(let c of word) {
+      if(node.children[c] == null) node.children[c] = new Trie()
+      node = node.children[c]
+    }
+    node.isWord = true
+  }
+
+  return root
+}
+
+class Trie {
+  constructor() {
+    this.children = {}
+    this.isWord = false
+  }
+}

From 9aaf634cc9768628c3b20f1472f0eebe5e82d8be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 16:24:58 +0800
Subject: [PATCH 1543/3374] Create 1085-sum-of-digits-in-the-minimum-number.js

---
 1085-sum-of-digits-in-the-minimum-number.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1085-sum-of-digits-in-the-minimum-number.js

diff --git a/1085-sum-of-digits-in-the-minimum-number.js b/1085-sum-of-digits-in-the-minimum-number.js
new file mode 100644
index 00000000..13032caf
--- /dev/null
+++ b/1085-sum-of-digits-in-the-minimum-number.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfDigits = function(nums) {
+  let min = Math.min(...nums);
+  let ans = 0;
+  while (min > 0) {
+      ans += min % 10;
+      min = ~~(min / 10);
+  }
+  return 1 - ans % 2;
+};

From 423d2e19b2d13c14a35b907c907217953a57e9b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jul 2021 16:34:41 +0800
Subject: [PATCH 1544/3374] Create 1550-three-consecutive-odds.js

---
 1550-three-consecutive-odds.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1550-three-consecutive-odds.js

diff --git a/1550-three-consecutive-odds.js b/1550-three-consecutive-odds.js
new file mode 100644
index 00000000..d67397a1
--- /dev/null
+++ b/1550-three-consecutive-odds.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} arr
+ * @return {boolean}
+ */
+const threeConsecutiveOdds = function(arr) {
+  for(let i = 1, n = arr.length; i < n - 1; i++) {
+    if(arr[i] & 1 === 1 && arr[i - 1] & 1 === 1 && arr[i + 1] & 1 === 1) return true
+  }
+  return false
+};

From 2d52519aed4fd2589e8d772f3828226c00a5534f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Jul 2021 19:49:10 +0800
Subject: [PATCH 1545/3374] Create 1938-maximum-genetic-difference-query.js

---
 1938-maximum-genetic-difference-query.js | 62 ++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 1938-maximum-genetic-difference-query.js

diff --git a/1938-maximum-genetic-difference-query.js b/1938-maximum-genetic-difference-query.js
new file mode 100644
index 00000000..f90fe783
--- /dev/null
+++ b/1938-maximum-genetic-difference-query.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} parents
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maxGeneticDifference = function (parents, queries) {
+  let pn = parents.length,
+    qn = queries.length
+  let root = parents.indexOf(-1)
+  let children = initializeGraph(pn)
+  for (let i = 0; i < pn; i++) {
+    if (i != root) {
+      children[parents[i]].push(i)
+    }
+  }
+  let freq = Array(1 << 20).fill(0)
+  let queriesByNode = initializeGraph(pn)
+  for (let i = 0; i < qn; i++) {
+    let query = queries[i]
+    queriesByNode[query[0]].push(new Query(i, query[1]))
+  }
+
+  let res = Array(qn).fill(0)
+  const dfs = (idx) => {
+    let y = (1 << 19) + idx
+    while (y > 0) {
+      freq[y]++
+      y >>= 1
+    }
+    for (const qnode of queriesByNode[idx]) {
+      let j = qnode.index,
+        x = qnode.val
+      let cum = 0
+      let bit = 1 << 18
+      while (bit > 0) {
+        let ii = (((1 << 19) ^ cum ^ x ^ bit) / bit) >> 0
+        if (freq[ii] > 0) cum += bit
+        bit >>= 1
+      }
+      res[j] = cum
+    }
+    for (const child of children[idx]) dfs(child)
+    y = (1 << 19) + idx
+    while (y > 0) {
+      freq[y]--
+      y >>= 1
+    }
+  }
+  dfs(root)
+  return res
+}
+
+const initializeGraph = (n) => {
+  let G = []
+  for (let i = 0; i < n; i++) G.push([])
+  return G
+}
+
+function Query(index, val) {
+  this.index = index
+  this.val = val
+}

From b33939c70b3d9cc69aac7da2ed9a922a0d083096 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 13:42:28 +0800
Subject: [PATCH 1546/3374] Update 1882-process-tasks-using-servers.js

---
 1882-process-tasks-using-servers.js | 35 +++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1882-process-tasks-using-servers.js b/1882-process-tasks-using-servers.js
index 2f3a3dfd..17b515bc 100644
--- a/1882-process-tasks-using-servers.js
+++ b/1882-process-tasks-using-servers.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[]} servers
+ * @param {number[]} tasks
+ * @return {number[]}
+ */
+const assignTasks = function(servers, tasks) {
+  const freePQ = new PriorityQueue((a, b) => a.w === b.w ? a.i < b.i : a.w < b.w)
+  const runningPQ = new PriorityQueue((a, b) => a.e === b.e ? (a.w === b.w ? a.i < b.i : a.w < b.w) : a.e < b.e)
+  const m = servers.length, n = tasks.length
+  for(let i = 0; i < m; i++) freePQ.push({w: servers[i], i, e: 0})
+  const res = []
+  for(let i = 0; i < n; i++) {
+    const cur = tasks[i]
+    while(!runningPQ.isEmpty() && runningPQ.peek().e <= i) {
+      const tmp = runningPQ.pop()
+      tmp.e = i
+      freePQ.push(tmp)
+    }
+    if(freePQ.isEmpty()) {
+      const tmp = runningPQ.pop()
+      res[i] = tmp.i
+      tmp.e += cur
+      runningPQ.push(tmp)
+    } else {
+      const tmp = freePQ.pop()
+      res[i] = tmp.i
+      tmp.e = i + cur
+      runningPQ.push(tmp)
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} servers
  * @param {number[]} tasks

From a65c9086b4a7054b5404f3968db888d994ec4e86 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 13:45:37 +0800
Subject: [PATCH 1547/3374] Create 1947-maximum-compatibility-score-sum.js

---
 1947-maximum-compatibility-score-sum.js | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1947-maximum-compatibility-score-sum.js

diff --git a/1947-maximum-compatibility-score-sum.js b/1947-maximum-compatibility-score-sum.js
new file mode 100644
index 00000000..543cc2dd
--- /dev/null
+++ b/1947-maximum-compatibility-score-sum.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} students
+ * @param {number[][]} mentors
+ * @return {number}
+ */
+const maxCompatibilitySum = function(students, mentors) {
+  const obj = { res: 0 }, hash = {}
+  for(let i = 0, n = students.length; i < n; i++) {
+    bt(students, mentors, 0, 0, obj, hash)
+  }
+  return obj.res
+};
+
+function bt(stu, men, i, score, obj, hash) {
+
+  if(i === stu.length) {
+    if(score > obj.res) {
+      obj.res = score
+      // console.log(hash)
+    }
+    return
+  }
+  
+  for(let j = 0; j < men.length; j++) {
+    const k = `${j}`
+    if(hash[k] === 1) continue
+    hash[k] = 1
+    bt(stu, men, i + 1, score + calc(stu[i], men[j]), obj, hash)
+    delete hash[k]
+  }
+}
+
+function calc(a1, a2) {
+  const n = a1.length
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    if(a1[i] === a2[i]) res++
+  }
+  return res
+}

From 6fb3bb5a39dc84cf81581cb102f5fe7a4fc047e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 13:46:24 +0800
Subject: [PATCH 1548/3374] Create
 1946-largest-number-after-mutating-substring.js

---
 ...largest-number-after-mutating-substring.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1946-largest-number-after-mutating-substring.js

diff --git a/1946-largest-number-after-mutating-substring.js b/1946-largest-number-after-mutating-substring.js
new file mode 100644
index 00000000..8c6ed631
--- /dev/null
+++ b/1946-largest-number-after-mutating-substring.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} num
+ * @param {number[]} change
+ * @return {string}
+ */
+const maximumNumber = function(num, change) {
+  let res = ''
+  const arr = num.split('')
+  let prev = false, cnt = 0
+  for(let i = 0, n = num.length; i < n; i++) {
+    const cur = +num[i]
+    if(change[cur] > cur) {
+      cnt++
+      prev = true
+      arr[i] = change[cur]
+    }
+    if(change[cur] < cur) {
+      if(cnt <= 0) continue
+      else break
+    }
+  }
+  
+  return arr.join('')
+};

From 0851cade5219e3709bbdbd56ce56bee9a4d864bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 13:47:16 +0800
Subject: [PATCH 1549/3374] Create
 1945-sum-of-digits-of-string-after-convert.js

---
 1945-sum-of-digits-of-string-after-convert.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1945-sum-of-digits-of-string-after-convert.js

diff --git a/1945-sum-of-digits-of-string-after-convert.js b/1945-sum-of-digits-of-string-after-convert.js
new file mode 100644
index 00000000..138ea154
--- /dev/null
+++ b/1945-sum-of-digits-of-string-after-convert.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const getLucky = function(s, k) {
+  let res = 0
+  const a = 'a'.charCodeAt(0)
+  const arr = []
+  for(let ch of s) {
+    arr.push(ch.charCodeAt(0) - a  + 1)
+  }
+  let str = arr.join('').split('').map(e => +e)
+  let prev = str, sum = 0
+  while(k > 0) {
+    // let tmp = 0
+    let tmp = prev.reduce((ac, e) => ac + e, 0)
+    // console.log(tmp)
+    prev = `${tmp}`.split('').map(e => +e)
+    sum = tmp
+    k--
+  }
+  
+  return sum
+};

From 13403e13e44113399e6e574f73e2a3c3c3bdca92 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 22:23:52 +0800
Subject: [PATCH 1550/3374] Create 1179-reformat-department-table.js

---
 1179-reformat-department-table.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1179-reformat-department-table.js

diff --git a/1179-reformat-department-table.js b/1179-reformat-department-table.js
new file mode 100644
index 00000000..a36706c3
--- /dev/null
+++ b/1179-reformat-department-table.js
@@ -0,0 +1,17 @@
+# Write your MySQL query statement below
+select id, 
+	sum(case when month = 'jan' then revenue else null end) as Jan_Revenue,
+	sum(case when month = 'feb' then revenue else null end) as Feb_Revenue,
+	sum(case when month = 'mar' then revenue else null end) as Mar_Revenue,
+	sum(case when month = 'apr' then revenue else null end) as Apr_Revenue,
+	sum(case when month = 'may' then revenue else null end) as May_Revenue,
+	sum(case when month = 'jun' then revenue else null end) as Jun_Revenue,
+	sum(case when month = 'jul' then revenue else null end) as Jul_Revenue,
+	sum(case when month = 'aug' then revenue else null end) as Aug_Revenue,
+	sum(case when month = 'sep' then revenue else null end) as Sep_Revenue,
+	sum(case when month = 'oct' then revenue else null end) as Oct_Revenue,
+	sum(case when month = 'nov' then revenue else null end) as Nov_Revenue,
+	sum(case when month = 'dec' then revenue else null end) as Dec_Revenue
+from department
+group by id
+order by id

From 4da5f24b339a588e2ab53e0232158e1fb5884314 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Jul 2021 22:24:18 +0800
Subject: [PATCH 1551/3374] Rename 1179-reformat-department-table.js to
 1179-reformat-department-table.sql

---
 ...rmat-department-table.js => 1179-reformat-department-table.sql | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 1179-reformat-department-table.js => 1179-reformat-department-table.sql (100%)

diff --git a/1179-reformat-department-table.js b/1179-reformat-department-table.sql
similarity index 100%
rename from 1179-reformat-department-table.js
rename to 1179-reformat-department-table.sql

From 73f579fa07206b9a7e529d087c079b706f331876 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Jul 2021 20:54:43 +0800
Subject: [PATCH 1552/3374] Create
 1942-the-number-of-the-smallest-unoccupied-chair.js

---
 ...number-of-the-smallest-unoccupied-chair.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1942-the-number-of-the-smallest-unoccupied-chair.js

diff --git a/1942-the-number-of-the-smallest-unoccupied-chair.js b/1942-the-number-of-the-smallest-unoccupied-chair.js
new file mode 100644
index 00000000..4ad49cf1
--- /dev/null
+++ b/1942-the-number-of-the-smallest-unoccupied-chair.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} times
+ * @param {number} targetFriend
+ * @return {number}
+ */
+var smallestChair = function (times, targetFriend) {
+  const [targetArrival] = times[targetFriend]
+  const arrivalQueue = times
+  const leavingQueue = [...times]
+  arrivalQueue.sort((a, b) => a[0] - b[0])
+  leavingQueue.sort((a, b) => a[1] - b[1] || a[0] - b[0])
+  const chairsByLeaveTime = new Map()
+  let chairsCount = 0
+  let arriving = 0,
+    leaving = 0
+
+  while (arriving < arrivalQueue.length) {
+    let chairIdx
+    const arrival = arrivalQueue[arriving][0]
+    const leave = leavingQueue[leaving][1]
+    if (arrival < leave) {
+      chairIdx = chairsCount++
+    } else {
+      let freeChairIdx = leaving
+      chairIdx = chairsByLeaveTime.get(leavingQueue[freeChairIdx++][0])
+      while (arrival >= leavingQueue[freeChairIdx][1]) {
+        const nextChair = chairsByLeaveTime.get(leavingQueue[freeChairIdx][0])
+        if (chairIdx > nextChair) {
+          ;[leavingQueue[leaving], leavingQueue[freeChairIdx]] = [
+            leavingQueue[freeChairIdx],
+            leavingQueue[leaving],
+          ]
+          chairIdx = nextChair
+        }
+        ++freeChairIdx
+      }
+      ++leaving
+    }
+    if (targetArrival === arrival) {
+      return chairIdx
+    }
+    chairsByLeaveTime.set(arrival, chairIdx)
+    arriving++
+  }
+}

From dc4c502b2b3535ace96aafe349ebd7ee14425ba7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Jul 2021 16:32:12 +0800
Subject: [PATCH 1553/3374] Create 1943-describe-the-painting.js

---
 1943-describe-the-painting.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1943-describe-the-painting.js

diff --git a/1943-describe-the-painting.js b/1943-describe-the-painting.js
new file mode 100644
index 00000000..872b3bc2
--- /dev/null
+++ b/1943-describe-the-painting.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} segments
+ * @return {number[][]}
+ */
+const splitPainting = function(segments) {
+  const hash = {}
+  for(let [s, e, c] of segments) {
+    if(hash[s] == null) hash[s] = 0
+    if(hash[e] == null) hash[e] = 0
+    hash[s] += c
+    hash[e] -= c
+  }
+  const keys = Object.keys(hash)
+  keys.sort((a, b) => a - b)
+  let prev, color = 0
+  const res = []
+  for(let k of keys) {
+    if(prev != null && color !== 0) res.push([prev,k,color])
+
+    prev = k
+    color += hash[k]
+  } 
+  return res
+};

From c085ba52ef510801712c460ff42654ace74d5469 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Jul 2021 21:49:21 +0800
Subject: [PATCH 1554/3374] Create 1103-distribute-candies-to-people.js

---
 1103-distribute-candies-to-people.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1103-distribute-candies-to-people.js

diff --git a/1103-distribute-candies-to-people.js b/1103-distribute-candies-to-people.js
new file mode 100644
index 00000000..309ef1a2
--- /dev/null
+++ b/1103-distribute-candies-to-people.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} candies
+ * @param {number} num_people
+ * @return {number[]}
+ */
+const distributeCandies = function(candies, num_people) {
+  const n = num_people
+  const res = Array(n).fill(0)
+  let idx = 0, cur = 0
+  while(candies > 0) {
+    cur++
+    res[idx] += Math.min(cur, candies)
+    idx++
+    candies -= cur
+    if(idx === n) idx = 0
+  }
+  return res
+};

From 2a60640f6b6407cb1b91eb1f9f54f3767332db6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Jul 2021 19:36:35 +0800
Subject: [PATCH 1555/3374] Create 1944-number-of-visible-people-in-a-queue.js

---
 1944-number-of-visible-people-in-a-queue.js | 23 +++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1944-number-of-visible-people-in-a-queue.js

diff --git a/1944-number-of-visible-people-in-a-queue.js b/1944-number-of-visible-people-in-a-queue.js
new file mode 100644
index 00000000..48cccf15
--- /dev/null
+++ b/1944-number-of-visible-people-in-a-queue.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} heights
+ * @return {number[]}
+ */
+const canSeePersonsCount = function(heights) {
+    const ans = new Uint32Array(heights.length);
+    
+    const stack = [];
+    for (let i = heights.length - 1; i >= 0; i--) {
+        const h = heights[i];
+        
+        let del = 0;
+        while (stack.length && stack[stack.length - 1] <= h) {
+            del++;
+            stack.pop();
+        }
+        
+        ans[i] = del + (stack.length ? 1 : 0);
+        stack.push(h);
+    }
+
+    return ans;
+};

From 3a8e743f7678df371cfa8108c1a67fdacedaa73d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Jul 2021 09:04:42 +0800
Subject: [PATCH 1556/3374] Update 1879-minimum-xor-sum-of-two-arrays.js

---
 1879-minimum-xor-sum-of-two-arrays.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1879-minimum-xor-sum-of-two-arrays.js b/1879-minimum-xor-sum-of-two-arrays.js
index 7c6232f3..d85100e7 100644
--- a/1879-minimum-xor-sum-of-two-arrays.js
+++ b/1879-minimum-xor-sum-of-two-arrays.js
@@ -43,3 +43,26 @@ const minimumXORSum = function (nums1, nums2) {
   }
 }
 
+// another
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minimumXORSum = function (nums1, nums2) {
+  const n = nums1.length, dp = Array(1 << n).fill(Infinity)
+  return dfs(0, 0)
+
+  function dfs(i, mask) {
+    if(i >= n) return 0
+    if(dp[mask] !== Infinity) return dp[mask]
+    for(let j = 0; j < n; j++) {
+      if((mask & (1 << j)) === 0) {
+        dp[mask] = Math.min(dp[mask], (nums1[i] ^ nums2[j]) + dfs(i + 1, mask | (1 << j)))
+      }
+    }
+    return dp[mask]
+  }
+}
+

From f24cc0a298d5179c505be4643abc039c4929661b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Jul 2021 16:50:49 +0800
Subject: [PATCH 1557/3374] Update 503-next-greater-element-II.js

---
 503-next-greater-element-II.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/503-next-greater-element-II.js b/503-next-greater-element-II.js
index 6d180376..fc284214 100755
--- a/503-next-greater-element-II.js
+++ b/503-next-greater-element-II.js
@@ -20,3 +20,23 @@ function single(idx, arr) {
   }
   return -1;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+ const nextGreaterElements = function(nums) {
+  const res = [], n = nums.length
+  const stack = []
+  for(let i = 2 * n - 1; i >= 0; i--) {
+    while(stack.length && nums[stack[stack.length - 1]] <= nums[i % n]) {
+      stack.pop()
+    }
+    res[i % n] = stack.length ? nums[stack[stack.length - 1]] : -1
+    stack.push(i % n)
+  }
+
+  return res
+};

From 8371e63b00b956a4610de06d61d3bf27d89b71f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 31 Jul 2021 13:42:39 +0800
Subject: [PATCH 1558/3374] Update 1947-maximum-compatibility-score-sum.js

---
 1947-maximum-compatibility-score-sum.js | 35 +++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1947-maximum-compatibility-score-sum.js b/1947-maximum-compatibility-score-sum.js
index 543cc2dd..893623e4 100644
--- a/1947-maximum-compatibility-score-sum.js
+++ b/1947-maximum-compatibility-score-sum.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[][]} students
+ * @param {number[][]} mentors
+ * @return {number}
+ */
+const maxCompatibilitySum = function(students, mentors) {
+  const n = students.length, dp = Array(1 << n).fill(-Infinity)
+  const m = students[0].length
+  return dfs(0, 0)
+  
+  function dfs(i, mask) {
+    if(i === n) return 0
+    if(dp[mask] !== -Infinity) return dp[mask]
+    for(let j = 0; j < n; j++) {
+      if((mask & (1 << j)) === 0) {
+         dp[mask] = Math.max(dp[mask], calc(i, j) + dfs(i + 1, mask | (1 << j)))
+      }
+    }
+    
+    return dp[mask]
+  }
+  
+  function calc(i, j) {
+    let res = 0
+    const a = students[i], b = mentors[j]
+    for(let k = 0; k < m; k++) {
+      if(a[k] === b[k]) res++
+    }
+    return res
+  }
+};
+
+
+// another
+
 /**
  * @param {number[][]} students
  * @param {number[][]} mentors

From acf4175f84cc9cdc5a87d322760e2428e1f5a835 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Aug 2021 20:37:18 +0800
Subject: [PATCH 1559/3374] Create 1952-three-divisors.js

---
 1952-three-divisors.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1952-three-divisors.js

diff --git a/1952-three-divisors.js b/1952-three-divisors.js
new file mode 100644
index 00000000..54dd076d
--- /dev/null
+++ b/1952-three-divisors.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isThree = function(n) {
+  if(n == 1) return false;
+  let a = ~~Math.sqrt(n);
+  if(n != a * a) return false;
+  for(let i = 2; i < a; i++) {
+      if (n % i == 0)
+          return false;
+  }
+  return true;
+};

From 501e66d9fe36da07715e3231d559ef2f577a26d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Aug 2021 20:38:09 +0800
Subject: [PATCH 1560/3374] Create
 1953-maximum-number-of-weeks-for-which-you-can-work.js

---
 ...um-number-of-weeks-for-which-you-can-work.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1953-maximum-number-of-weeks-for-which-you-can-work.js

diff --git a/1953-maximum-number-of-weeks-for-which-you-can-work.js b/1953-maximum-number-of-weeks-for-which-you-can-work.js
new file mode 100644
index 00000000..17e1830d
--- /dev/null
+++ b/1953-maximum-number-of-weeks-for-which-you-can-work.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} milestones
+ * @return {number}
+ */
+const numberOfWeeks = function(milestones) {
+    let sum = 0;
+    for (let i = 0; i < milestones.length; i++) {
+        sum += milestones[i];
+    }
+
+    let cantWork = 0;
+    for (let i = 0; i < milestones.length; i++) {
+        cantWork = Math.max(cantWork, milestones[i] - (sum - milestones[i]) - 1);
+    }
+
+    return sum - cantWork;
+};

From b6d04040e1689ca7b0c09142279d37e17782dba6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Aug 2021 20:39:09 +0800
Subject: [PATCH 1561/3374] Create
 1954-minimum-garden-perimeter-to-collect-enough-apples.js

---
 ...arden-perimeter-to-collect-enough-apples.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1954-minimum-garden-perimeter-to-collect-enough-apples.js

diff --git a/1954-minimum-garden-perimeter-to-collect-enough-apples.js b/1954-minimum-garden-perimeter-to-collect-enough-apples.js
new file mode 100644
index 00000000..13f18a9d
--- /dev/null
+++ b/1954-minimum-garden-perimeter-to-collect-enough-apples.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} neededApples
+ * @return {number}
+ */
+var minimumPerimeter = function(neededApples) {
+    let l = 0, r = 100000;
+    while (l + 1 < r) {
+        let w = (l + r) >> 1;
+        let apples = 2 * w * (w + 1) * (2 * w + 1);
+        if (apples >= neededApples) {
+            r = w;
+        } else {
+            l = w;
+        }
+    }
+
+    return r * 8;  
+};

From b0e85db1268accbbb6e4f7b9e3fd8b56227bc823 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Aug 2021 20:39:51 +0800
Subject: [PATCH 1562/3374] Create 1955-count-number-of-special-subsequences.js

---
 1955-count-number-of-special-subsequences.js | 36 ++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1955-count-number-of-special-subsequences.js

diff --git a/1955-count-number-of-special-subsequences.js b/1955-count-number-of-special-subsequences.js
new file mode 100644
index 00000000..f8c62b0d
--- /dev/null
+++ b/1955-count-number-of-special-subsequences.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countSpecialSubsequences = function(nums) {
+  const mod = 10 ** 9 + 7
+  const dp = Array.from({length: 10 **5 + 1}, () => Array(4).fill(-1))
+  let n = nums.length, a = nums
+  return f(0, 0)
+  function f(index, firstMandatory) {
+      if (index == n && firstMandatory == 3) {
+          return 1;
+      }
+      if (index == n) {
+          return 0;
+      }
+      if (dp[index][firstMandatory] >= 0) {
+          return dp[index][firstMandatory];
+      }
+      let result = 0;
+      if (a[index] == firstMandatory) {
+          result = (result +
+                  f(index + 1, firstMandatory) +
+                  f(index + 1, firstMandatory + 1)
+          ) % mod;
+      }
+      result = (result + f(index + 1, firstMandatory)) % mod;
+
+      return dp[index][firstMandatory] = result;
+  }
+};
+
+
+
+
+

From ced3ffdd022539c2e8a7ec97a6a1214bb88ac704 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Aug 2021 20:07:39 +0800
Subject: [PATCH 1563/3374] Update 652-find-duplicate-subtrees.js

---
 652-find-duplicate-subtrees.js | 29 ++++++++++++++---------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/652-find-duplicate-subtrees.js b/652-find-duplicate-subtrees.js
index 65949019..d67c62b1 100644
--- a/652-find-duplicate-subtrees.js
+++ b/652-find-duplicate-subtrees.js
@@ -1,27 +1,26 @@
 /**
  * Definition for a binary tree node.
- * function TreeNode(val) {
- *     this.val = val;
- *     this.left = this.right = null;
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
  * }
  */
 /**
  * @param {TreeNode} root
  * @return {TreeNode[]}
  */
-const findDuplicateSubtrees = function (root) {
-  const obj = {},
-    res = []
-  preOrder(root, obj, res)
+const findDuplicateSubtrees = function(root) {
+  const hash = {}, res = []
+  pre(root, hash, res)
   return res
-}
+};
 
-function preOrder(root, map, res) {
-  if (root === null) return '#'
-  const str =
-    root.val + preOrder(root.left, map, res) + preOrder(root.right, map, res)
-  if (!map[str]) map[str] = 0
-  map[str]++
-  if (map[str] === 2) res.push(root)
+function pre(node, hash, res) {
+  if(node == null) return '#'
+  const str = `${node.val},${pre(node.left, hash, res)},${pre(node.right, hash, res)}`
+  if(hash[str] == null) hash[str] = 0
+  hash[str]++
+  if(hash[str] === 2) res.push(node)
   return str
 }

From 0d2645e1f1da34f695704f914b4212f3187ef0ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Aug 2021 20:49:02 +0800
Subject: [PATCH 1564/3374] Update 652-find-duplicate-subtrees.js

---
 652-find-duplicate-subtrees.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/652-find-duplicate-subtrees.js b/652-find-duplicate-subtrees.js
index d67c62b1..8a1a84da 100644
--- a/652-find-duplicate-subtrees.js
+++ b/652-find-duplicate-subtrees.js
@@ -24,3 +24,35 @@ function pre(node, hash, res) {
   if(hash[str] === 2) res.push(node)
   return str
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode[]}
+ */
+const findDuplicateSubtrees = function(root) {
+  const serId = {}, cntId = {}, res = []
+  let id = 1
+  post(root)
+  return res
+  
+  function post(node) {
+    if(node == null) return 0
+    const curId = `${post(node.left)},${node.val},${post(node.right)}`
+    serId[curId] = serId[curId] || id
+    if(serId[curId] === id) id++
+    cntId[curId] = (cntId[curId] || 0) + 1
+    if(cntId[curId] === 2) res.push(node)
+    return serId[curId]
+  }
+};
+

From 479720e8952451c9de43fa4a422339c9c736209e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Aug 2021 20:22:17 +0800
Subject: [PATCH 1565/3374] Create 1948-delete-duplicate-folders-in-system.js

---
 1948-delete-duplicate-folders-in-system.js | 134 +++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 1948-delete-duplicate-folders-in-system.js

diff --git a/1948-delete-duplicate-folders-in-system.js b/1948-delete-duplicate-folders-in-system.js
new file mode 100644
index 00000000..e68d27a4
--- /dev/null
+++ b/1948-delete-duplicate-folders-in-system.js
@@ -0,0 +1,134 @@
+/**
+ * @param {string[][]} paths
+ * @return {string[][]}
+ */
+const deleteDuplicateFolder = function(paths) {
+  const trie = new Trie()
+  for (const path of paths) {
+    let cur = trie.trie
+    cur.countPrefix++
+    for (const name of path) {
+      if(cur.children[name] == null) cur.children[name] = new TrieNode(name)
+      cur = cur.children[name]
+      cur.countPrefix++
+    }
+  }
+  const folders = new Map()
+  dfs1(trie.trie)
+  for (const value of folders.values()) {
+    if (value.length > 1) {
+      // found the same dir, mark as to be deleted
+      for (const node of value) {
+        node.countPrefix = 0
+      }
+    }
+  }
+  const ans = []
+  // traverse un-deleted dir, put them to result
+  dfs2(trie.trie, [])
+  return ans
+  function dfs1 (node) {
+    if (Object.keys(node.children).length === 0) {
+      return `(${node.char})`
+    }
+    const childrenExp = []
+    for (const key in node.children) {
+      childrenExp.push(dfs1(node.children[key]))
+    }
+    const exp = childrenExp.sort((a, b) => a.localeCompare(b)).join('')
+    if (!folders.has(exp)) {
+      folders.set(exp, [])
+    }
+    folders.get(exp).push(node)
+    return `(${node.char}${childrenExp.join('')})`
+  }
+  function dfs2 (node, path) {
+    // already deleted, no need go further
+    if (node.countPrefix === 0) {
+      return
+    }
+    if (node.char !== '/') { path.push(node.char) }
+    if (path.length) ans.push([...path])
+    for (const key in node.children) {
+      dfs2(node.children[key], path)
+    }
+    path.pop()
+  } 
+};
+class TrieNode {
+  constructor (char) {
+    this.char = char
+    this.count = 0
+    this.countPrefix = 0
+    this.children = {}
+  }
+};
+class Trie {
+  /**
+   * @description Initialize the trie
+   */
+  constructor () {
+    this.trie = new TrieNode('/')
+  }
+
+  /**
+   * @description Insert strings into the trie
+   * @param str the string to be inserted
+   * @param count number of `str` to be inserted, can be negative for deleting x from the trie
+   */
+  insert (str, count = 1) {
+    let cur = this.trie
+    for (const char of str) {
+      cur.children[char] ??= new TrieNode(char)
+      cur = cur.children[char]
+      cur.countPrefix += count
+    }
+    cur.count += count
+  }
+
+  /**
+   * Traverse the trie with a callback function
+   * @param str An input string
+   * @param callbackfn A callback function. traverse calls the callbackfn function one time for each char in `str`, however it may skip ending chars in str if the trie has no children to go deeper, the returned char from callbackfn will be used as the direction of traversing
+   * @param thisArg An object to which the this keyword can refer in the callbackfn function. If thisArg is omitted, undefined is used as the this value
+   */
+  traverse (str, callbackfn, thisArg) {
+    let cur = this.trie
+    for (let i = 0; i < str.length; i++) {
+      const retChar = callbackfn.call(thisArg, str[i], i, cur)
+      const tmp = cur.children[retChar]
+      if (!tmp || tmp.countPrefix <= 0) return
+      cur = tmp
+    }
+  }
+
+  /**
+   * @description Search a string in the trie
+   * @returns Number of `str` in the trie
+   */
+  count (str) {
+    let ans = 0
+    this.traverse(str, (char, idx, node) => {
+      const nextNode = node.children[char]
+      if (idx === str.length - 1 && nextNode) {
+        ans = nextNode.count
+      }
+      return char
+    })
+    return ans
+  }
+
+  /**
+   * @description Search a string in the trie
+   * @returns Number of prefix of `str` in the trie
+   */
+  countPrefix (str) {
+    let ans = 0
+    this.traverse(str, (char, idx, node) => {
+      const nextNode = node.children[char]
+      ans += nextNode?.countPrefix ?? 0
+      return char
+    })
+    return ans
+  }
+};

From e5a95a458bab1d99b325bbea3d77a954d6d16df1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Aug 2021 10:53:48 +0800
Subject: [PATCH 1566/3374] Update 1955-count-number-of-special-subsequences.js

---
 1955-count-number-of-special-subsequences.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1955-count-number-of-special-subsequences.js b/1955-count-number-of-special-subsequences.js
index f8c62b0d..8467f496 100644
--- a/1955-count-number-of-special-subsequences.js
+++ b/1955-count-number-of-special-subsequences.js
@@ -1,3 +1,25 @@
+/*
+ * @lc app=leetcode id=1955 lang=javascript
+ *
+ * [1955] Count Number of Special Subsequences
+ */
+
+// @lc code=start
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countSpecialSubsequences = function (nums) {
+  const dp = Array(3).fill(0),
+    mod = 10 ** 9 + 7
+  for (let e of nums) {
+    dp[e] = (((dp[e] + dp[e]) % mod) + (e > 0 ? dp[e - 1] : 1)) % mod
+  }
+  return dp[2]
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From f3f9cbfe09295cdc8cb4466ed26cb267dff4dff9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Aug 2021 21:10:13 +0800
Subject: [PATCH 1567/3374] Create 1515-best-position-for-a-service-centre.js

---
 1515-best-position-for-a-service-centre.js | 39 ++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1515-best-position-for-a-service-centre.js

diff --git a/1515-best-position-for-a-service-centre.js b/1515-best-position-for-a-service-centre.js
new file mode 100644
index 00000000..9d8958a2
--- /dev/null
+++ b/1515-best-position-for-a-service-centre.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} positions
+ * @return {number}
+ */
+const getMinDistSum = function(positions) {
+  const n = positions.length
+  let x = positions.reduce((ac, e) => ac + e[0], 0) / n
+  let y = positions.reduce((ac, e) => ac + e[1], 0) / n
+  
+  const dirs = [[1,0],[-1,0],[0,1],[0,-1]]
+  let res = fn(x, y, positions)
+  let chg = 100
+  while(chg > 1e-6) {
+    let zoom = true
+    for(let [dx, dy] of dirs) {
+      const nx = x + dx * chg
+      const ny = y + dy * chg
+      const nRes = fn(nx, ny, positions)
+      if(nRes < res) {
+        res = nRes
+        x = nx
+        y = ny
+        zoom = false
+        break
+      }
+    }
+    if(zoom) chg /= 2
+  }
+  return res
+};
+
+function fn(x, y, arr) {
+  let res = 0
+  const n = arr.length
+  for(let i = 0; i < n; i++) {
+    res += Math.sqrt((x - arr[i][0]) ** 2 + (y - arr[i][1]) ** 2)
+  }
+  return res
+}

From fc8c5b5892421a7ea020f335b3e6f97410a6147f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Aug 2021 15:12:22 +0800
Subject: [PATCH 1568/3374] Update
 1953-maximum-number-of-weeks-for-which-you-can-work.js

---
 ...um-number-of-weeks-for-which-you-can-work.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/1953-maximum-number-of-weeks-for-which-you-can-work.js b/1953-maximum-number-of-weeks-for-which-you-can-work.js
index 17e1830d..fc834574 100644
--- a/1953-maximum-number-of-weeks-for-which-you-can-work.js
+++ b/1953-maximum-number-of-weeks-for-which-you-can-work.js
@@ -15,3 +15,20 @@ const numberOfWeeks = function(milestones) {
 
     return sum - cantWork;
 };
+
+// another
+
+/**
+ * @param {number[]} milestones
+ * @return {number}
+ */
+const numberOfWeeks = function(milestones) {
+  const max = Math.max(...milestones)
+  let sum = 0
+  for(let i = 0; i < milestones.length; i++) {
+    sum += milestones[i]
+  }
+  const res = sum - max
+  
+  return Math.min(sum, res * 2 + 1)
+};

From 5340d727816d0506381d1260854e17c5a7e767d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Aug 2021 21:21:30 +0800
Subject: [PATCH 1569/3374] Create 1483-kth-ancestor-of-a-tree-node.js

---
 1483-kth-ancestor-of-a-tree-node.js | 41 +++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1483-kth-ancestor-of-a-tree-node.js

diff --git a/1483-kth-ancestor-of-a-tree-node.js b/1483-kth-ancestor-of-a-tree-node.js
new file mode 100644
index 00000000..207305f5
--- /dev/null
+++ b/1483-kth-ancestor-of-a-tree-node.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number} n
+ * @param {number[]} parent
+ */
+var TreeAncestor = function(n, parent) {
+    // initialize
+    this.P = Array.from({length: 20}, () => Array(n).fill(-1))
+    // 2^0
+    for(let i = 0; i < parent.length; i++){
+        this.P[0][i] = parent[i];
+    }
+
+    // 2^i
+    for(let i = 1; i < 20; i++){
+        for(let node = 0; node < parent.length; node++){
+            let nodep = this.P[i-1][node];
+            if(nodep != -1) this.P[i][node] = this.P[i-1][nodep];
+        }
+    }  
+};
+
+/** 
+ * @param {number} node 
+ * @param {number} k
+ * @return {number}
+ */
+TreeAncestor.prototype.getKthAncestor = function(node, k) {
+    for(let i = 0; i < 20; i++){
+        if(k & (1 << i)){
+            node = this.P[i][node];
+            if(node == -1) return -1;
+        }
+    }
+    return node; 
+};
+
+/** 
+ * Your TreeAncestor object will be instantiated and called as such:
+ * var obj = new TreeAncestor(n, parent)
+ * var param_1 = obj.getKthAncestor(node,k)
+ */

From 3fbc63eb0543ebb63112ba57ee9a204750c31e45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Aug 2021 11:37:18 +0800
Subject: [PATCH 1570/3374] Update 767-reorganize-string.js

---
 767-reorganize-string.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/767-reorganize-string.js b/767-reorganize-string.js
index 222a2e25..8cbc6901 100644
--- a/767-reorganize-string.js
+++ b/767-reorganize-string.js
@@ -36,3 +36,41 @@ const reorganizeString = function(S) {
     }
     return parts.join('');
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const reorganizeString = function(s) {
+  const arr = Array(26).fill(0), a = 'a'.charCodeAt(0)
+  for(let ch of s) arr[ch.charCodeAt(0) - a]++
+  let max = 0, idx = -1
+  for(let i = 0; i < 26; i++) {
+    if(arr[i] > max) {
+      max = arr[i]
+      idx = i
+    }
+  }
+  const n = s.length
+  const res = Array(n)
+  if(max > (n + 1) / 2) return ''
+
+  let i = 0
+  while(arr[idx] > 0) {
+    res[i] = String.fromCharCode(a + idx)
+    i += 2
+    arr[idx]--
+  }
+  
+  for(let j = 0; j < 26; j++) {
+    while(arr[j]) {
+      if(i >= n) i = 1
+      res[i] = String.fromCharCode(a + j)
+      i += 2
+      arr[j]--
+    }
+  }
+  return res.join('')
+};

From 849aeb1131f4190528cf9d69817806e7fb7b0d4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Aug 2021 12:11:29 +0800
Subject: [PATCH 1571/3374] Update 160-intersection-of-two-linked-lists.js

---
 160-intersection-of-two-linked-lists.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/160-intersection-of-two-linked-lists.js b/160-intersection-of-two-linked-lists.js
index a44ab1d5..21ae7fec 100644
--- a/160-intersection-of-two-linked-lists.js
+++ b/160-intersection-of-two-linked-lists.js
@@ -1,3 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+
+/**
+ * @param {ListNode} headA
+ * @param {ListNode} headB
+ * @return {ListNode}
+ */
+const getIntersectionNode = function(headA, headB) {
+  let a = headA, b = headB
+  while(a !== b) {
+    a = a == null ? headB : a.next
+    b = b == null ? headA : b.next
+  }
+  return a
+};
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From 2e4c9853af1718cff3bffe7ab2c09d1c092cad21 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Aug 2021 17:15:27 +0800
Subject: [PATCH 1572/3374] Create 928-minimize-malware-spread-ii.js

---
 928-minimize-malware-spread-ii.js | 45 +++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 928-minimize-malware-spread-ii.js

diff --git a/928-minimize-malware-spread-ii.js b/928-minimize-malware-spread-ii.js
new file mode 100644
index 00000000..c9597cb8
--- /dev/null
+++ b/928-minimize-malware-spread-ii.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} graph
+ * @param {number[]} initial
+ * @return {number}
+ */
+var minMalwareSpread = function (graph, initial) {
+  const map = new Map() // node -> initial nodes infect this node
+  for (let i of initial) {
+    const visited = new Set(initial)
+    const q = []
+    q.push(i)
+    while (q.length) {
+      let cur = q.shift()
+      for (let j = 0; j < graph[cur].length; j++) {
+        if (graph[cur][j] == 1) {
+          if (!visited.has(j)) {
+            visited.add(j)
+            q.push(j)
+
+            if (map.get(j) == null) map.set(j, [])
+            map.get(j).push(i)
+          }
+        }
+      }
+    }
+  }
+
+  const res = Array(graph.length).fill(0) // node -> safe nodes it infects
+  for (let node of map.keys()) {
+    if (map.get(node).length == 1) {
+      let i = map.get(node)[0]
+      res[i]++
+    }
+  }
+  let max = 0
+  let removed = -1
+  for (let i = 0; i < res.length; i++) {
+    if (res[i] > max) {
+      max = res[i]
+      removed = i
+    }
+  }
+  initial.sort((a, b) => a - b)
+  return removed == -1 ? initial[0] : removed
+}

From 742d3b19affb361fc798de1fc7899801ea6c7461 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Aug 2021 11:32:44 +0800
Subject: [PATCH 1573/3374] Update 1054-distant-barcodes.js

---
 1054-distant-barcodes.js | 45 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/1054-distant-barcodes.js b/1054-distant-barcodes.js
index 452c9d04..f214d14a 100644
--- a/1054-distant-barcodes.js
+++ b/1054-distant-barcodes.js
@@ -20,3 +20,48 @@ const rearrangeBarcodes = function(barcodes) {
 
 	return barcodes;
 };
+
+// another
+
+/**
+ * @param {number[]} barcodes
+ * @return {number[]}
+ */
+const rearrangeBarcodes = function(barcodes) {
+  const hash = {}, n = barcodes.length
+  for(let e of barcodes) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const res = Array(n)
+  let max = 0, idx = -1
+  for(let k in hash) {
+    if(hash[k] > max) {
+      max = hash[k]
+      idx = +k
+    }
+  }
+  let i = 0
+  // max freq first
+  while(max > 0) {
+    res[i] = idx
+    max--
+    i += 2
+  }
+  // the rest
+  const keys = Object.keys(hash).map(e => +e)
+  for(let j = 0, len = keys.length; j < len; j++) {
+    if(keys[j] !== idx) {
+      const k = keys[j]
+      let freq = hash[k]
+      while(freq > 0) {
+        if(i >= n) i = 1
+        res[i] = k
+        freq--
+        i += 2
+      }
+    }
+  }
+  
+  return res
+};

From a9fc36bec47d288b34d4a38544aec1cf93d1e3a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Aug 2021 19:20:29 +0800
Subject: [PATCH 1574/3374] Update 928-minimize-malware-spread-ii.js

---
 928-minimize-malware-spread-ii.js | 51 +++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/928-minimize-malware-spread-ii.js b/928-minimize-malware-spread-ii.js
index c9597cb8..dbe1249e 100644
--- a/928-minimize-malware-spread-ii.js
+++ b/928-minimize-malware-spread-ii.js
@@ -43,3 +43,54 @@ var minMalwareSpread = function (graph, initial) {
   initial.sort((a, b) => a - b)
   return removed == -1 ? initial[0] : removed
 }
+
+// another
+
+/**
+ * @param {number[][]} graph
+ * @param {number[]} initial
+ * @return {number}
+ */
+const minMalwareSpread = function (graph, initial) {
+  const map = new Map(), n = graph.length
+  for(let init of initial) {
+    const visited = new Set(initial)
+    const q = [init]
+    while(q.length) {
+      const cur = q.pop()
+      for(let i = 0; i < n; i++) {
+        if(graph[cur][i] === 1 && !visited.has(i)) {
+          visited.add(i)
+          q.push(i)
+          if(map.get(i) == null) map.set(i, [])
+          map.get(i).push(init)
+        }
+      }      
+    }
+  }
+  
+  let res = 0, max = -1
+  const arr = Array(n)
+  for(let [k,v] of map) {
+    if(v.length === 1) {
+      if(arr[v[0]] == null) arr[v[0]] = 0
+      arr[v[0]]++
+    }
+  }
+  
+  for(let k = 0; k < n; k++) {
+    const v = arr[k]
+    if(v > max) {
+      max = v
+      res = +k
+    }
+  }
+  
+  let min = Infinity
+  for(let e of initial) {
+    if(e < min) min = e
+  }
+  return max === -1 ? min: res
+  
+}
+

From e76ec4d9f93406d2fe84a0d4e4194740c0be4feb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Aug 2021 12:54:53 +0800
Subject: [PATCH 1575/3374] Create
 1964-find-the-longest-valid-obstacle-course-at-each-position.js

---
 ...-valid-obstacle-course-at-each-position.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1964-find-the-longest-valid-obstacle-course-at-each-position.js

diff --git a/1964-find-the-longest-valid-obstacle-course-at-each-position.js b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
new file mode 100644
index 00000000..bb0f7e46
--- /dev/null
+++ b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} obstacles
+ * @return {number[]}
+ */
+const longestObstacleCourseAtEachPosition = function(obstacles) {
+  const n = obstacles.length
+  const stack = [], res = Array(n).fill(0)
+  let m = 0
+  let j = 0;
+  for (let x of obstacles) {
+    let i = chk(x);
+    if (i == m) {
+      ++m;
+      stack.push(x);
+    } else {
+      stack[i] = x;
+    }
+    res[j++] = i + 1;
+  }
+  return res;
+  function chk(x) {
+      if (m && stack[m - 1] <= x) return m;
+      let l = 0, r = m - 1;
+      while (l < r) {
+        let m = (l + r) >> 1;
+        if (stack[m] > x) {
+          r = m;
+        } else {
+          l = m + 1;
+        }
+      }
+      return l;
+  }
+};
+

From 07e56415316d49f83837ea0d63bc8e9c525d67ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Aug 2021 12:55:25 +0800
Subject: [PATCH 1576/3374] Create
 1963-minimum-number-of-swaps-to-make-the-string-balanced.js

---
 ...er-of-swaps-to-make-the-string-balanced.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1963-minimum-number-of-swaps-to-make-the-string-balanced.js

diff --git a/1963-minimum-number-of-swaps-to-make-the-string-balanced.js b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
new file mode 100644
index 00000000..f2afa49f
--- /dev/null
+++ b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minSwaps = function(s) {
+  const stack = []
+  let num = 0
+  for(let e of s) {
+    if(e === '[') {
+      stack.push(e)
+      num++
+    }
+    if(e === ']') {
+      if(stack[stack.length - 1] === '[') {
+        stack.pop()
+        num--
+      }
+    }
+  }
+  // console.log(num)
+  return Math.ceil(num / 2)
+};

From 6849085e1543f3d112d675cb8feb0255b0a3b4ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Aug 2021 16:44:35 +0800
Subject: [PATCH 1577/3374] Create 1962-remove-stones-to-minimize-the-total.js

---
 1962-remove-stones-to-minimize-the-total.js | 87 +++++++++++++++++++++
 1 file changed, 87 insertions(+)
 create mode 100644 1962-remove-stones-to-minimize-the-total.js

diff --git a/1962-remove-stones-to-minimize-the-total.js b/1962-remove-stones-to-minimize-the-total.js
new file mode 100644
index 00000000..2821846c
--- /dev/null
+++ b/1962-remove-stones-to-minimize-the-total.js
@@ -0,0 +1,87 @@
+/**
+ * @param {number[]} piles
+ * @param {number} k
+ * @return {number}
+ */
+const minStoneSum = function(piles, k) {
+  const pq = new PriorityQueue((a, b) => a > b)
+  for(let e of piles) pq.push(e)
+  while(k > 0) {
+    const tmp = pq.pop()
+    const e = tmp - (~~(tmp / 2))
+    pq.push(e)
+    k--
+  }
+  let res = 0
+  while(!pq.isEmpty()) {
+    res += pq.pop()
+  }
+  return res
+};
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 85bc3a748e6b7b688452236d5254137e63fdbd12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Aug 2021 16:45:08 +0800
Subject: [PATCH 1578/3374] Create 1961-check-if-string-is-a-prefix-of-array.js

---
 1961-check-if-string-is-a-prefix-of-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1961-check-if-string-is-a-prefix-of-array.js

diff --git a/1961-check-if-string-is-a-prefix-of-array.js b/1961-check-if-string-is-a-prefix-of-array.js
new file mode 100644
index 00000000..861c5bec
--- /dev/null
+++ b/1961-check-if-string-is-a-prefix-of-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {boolean}
+ */
+const isPrefixString = function(s, words) {
+  let tmp = ''
+  for(let w of words) {
+    tmp += w
+    if(tmp === s) return true
+  }
+  return false
+};

From 791cabe45062ede9d032d0a90c4521bd3345a60d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Aug 2021 16:21:33 +0800
Subject: [PATCH 1579/3374] Update 621-task-scheduler.js

---
 621-task-scheduler.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/621-task-scheduler.js b/621-task-scheduler.js
index 079639a0..fc6cefe3 100755
--- a/621-task-scheduler.js
+++ b/621-task-scheduler.js
@@ -39,3 +39,32 @@ const leastInterval = function(tasks, n) {
   }
   return Math.max((max - 1) *  (n + 1)  +  count, tasks.length)
 };
+
+// another
+
+/**
+ * @param {character[]} tasks
+ * @param {number} n
+ * @return {number}
+ */
+const leastInterval = function(tasks, n) {
+  let max = 0, maxCnt = 0
+  const len = tasks.length, cnt = Array(26).fill(0), A = 'A'.charCodeAt(0)
+  
+  for(let ch of tasks) {
+    const idx = ch.charCodeAt(0) - A
+    cnt[idx]++
+    if(max === cnt[idx]) maxCnt++
+    else if(max < cnt[idx]) {
+      max = cnt[idx]
+      maxCnt = 1
+    }
+  }
+  
+  const maxSlots = max * maxCnt
+  const avaiSlots = (max - 1) * (n - (maxCnt - 1))
+  const rem = len - maxSlots
+  const emptySlots = Math.max(0, avaiSlots - rem)
+  
+  return len + emptySlots
+};

From a2b79698cf77a2b7085464a864304896daa82336 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Aug 2021 20:30:08 +0800
Subject: [PATCH 1580/3374] Create 984-string-without-aaa-or-bbb.js

---
 984-string-without-aaa-or-bbb.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 984-string-without-aaa-or-bbb.js

diff --git a/984-string-without-aaa-or-bbb.js b/984-string-without-aaa-or-bbb.js
new file mode 100644
index 00000000..bd4832b1
--- /dev/null
+++ b/984-string-without-aaa-or-bbb.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const strWithout3a3b = function(a, b) {
+  let m = a, n = b, ch1 = 'a', ch2 = 'b'
+  if(b > a) {
+    m = b, n = a, ch1 = 'b', ch2 = 'a'
+  }
+  let res = ''
+  while(m-- > 0) {
+    res += ch1
+    if(m > n) {
+      res += ch1
+      m--
+    }
+    if(n > 0) {
+      res += ch2
+      n--
+    }
+  }
+  return res
+};

From 69b79623e0baa849bcc819ec18d428b1ddda5623 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Aug 2021 19:45:54 +0800
Subject: [PATCH 1581/3374] Create 1405-longest-happy-string.js

---
 1405-longest-happy-string.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1405-longest-happy-string.js

diff --git a/1405-longest-happy-string.js b/1405-longest-happy-string.js
new file mode 100644
index 00000000..68d46bef
--- /dev/null
+++ b/1405-longest-happy-string.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {string}
+ */
+const longestDiverseString = function (a, b, c) {
+  return generate(a, b, c, "a", "b", "c");
+};
+
+function generate(a, b, c, ac, bc, cc) {
+  if (a < b) return generate(b, a, c, bc, ac, cc);
+  if (b < c) return generate(a, c, b, ac, cc, bc);
+  if (b === 0) return ac.repeat(Math.min(2, a));
+  let use_a = Math.min(2, a),
+    use_b = a - use_a >= b ? 1 : 0;
+  return (
+    ac.repeat(use_a) +
+    bc.repeat(use_b) +
+    generate(a - use_a, b - use_b, c, ac, bc, cc)
+  );
+}
+

From 381afd1e6476cfb8168762585c7797def77c0d0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Aug 2021 21:35:06 +0800
Subject: [PATCH 1582/3374] Update 1405-longest-happy-string.js

---
 1405-longest-happy-string.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1405-longest-happy-string.js b/1405-longest-happy-string.js
index 68d46bef..9da22977 100644
--- a/1405-longest-happy-string.js
+++ b/1405-longest-happy-string.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {string}
+ */
+const longestDiverseString = function (a, b, c) {
+  const arr = [['a', a], ['b', b], ['c', c]]
+  
+  let res = ''
+  while(true) {
+    arr.sort((a, b) => b[1] - a[1])
+    if(res.length >= 2 && arr[0][0] === res[res.length - 1] && arr[0][0] === res[res.length - 2]) {
+      if(arr[1][1] > 0) {
+        res += arr[1][0]
+        arr[1][1]--
+      } else break
+    } else {
+      if(arr[0][1] > 0) {
+        res += arr[0][0]
+        arr[0][1]--
+      } else break
+    }
+  }
+  
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {number} a
  * @param {number} b

From af0809560fc7c963890decc2d4f77445cfddb156 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Aug 2021 19:17:21 +0800
Subject: [PATCH 1583/3374] Update
 1963-minimum-number-of-swaps-to-make-the-string-balanced.js

---
 ...er-of-swaps-to-make-the-string-balanced.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1963-minimum-number-of-swaps-to-make-the-string-balanced.js b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
index f2afa49f..d54d75be 100644
--- a/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
+++ b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
@@ -20,3 +20,24 @@ const minSwaps = function(s) {
   // console.log(num)
   return Math.ceil(num / 2)
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minSwaps = function(s) {
+  let num = 0
+  for(let e of s) {
+    if(e === '[') {
+      num++
+    }
+    if(e === ']') {
+      if(num > 0) {
+        num--
+      }
+    }
+  }
+  return Math.ceil(num / 2)
+};

From 1995cac0ccb5799f771ff0185460d50ab90ee99a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Aug 2021 11:29:24 +0800
Subject: [PATCH 1584/3374] Create 5745-last-day-where-you-can-still-cross.js

---
 5745-last-day-where-you-can-still-cross.js | 76 ++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 5745-last-day-where-you-can-still-cross.js

diff --git a/5745-last-day-where-you-can-still-cross.js b/5745-last-day-where-you-can-still-cross.js
new file mode 100644
index 00000000..93911f4f
--- /dev/null
+++ b/5745-last-day-where-you-can-still-cross.js
@@ -0,0 +1,76 @@
+/**
+ * @param {number} row
+ * @param {number} col
+ * @param {number[][]} cells
+ * @return {number}
+ */
+const latestDayToCross = function (row, col, cells) {
+  const d = [
+    [-1, 0],
+    [1, 0],
+    [0, 1],
+    [0, -1],
+  ]
+
+  let a = Array.from({ length: row }, () => Array(col).fill(0))
+  let visited = Array.from({ length: row }, () => Array(col).fill(false))
+
+  for (let i = 0; i < cells.length; i++) {
+    a[cells[i][0] - 1][cells[i][1] - 1] = i
+  }
+
+  let l = 0
+  let r = row * col
+  while (l + 1 < r) {
+    let w = ~~((l + r) / 2)
+    if (canCross(w)) {
+      l = w
+    } else {
+      r = w
+    }
+  }
+
+  return l
+
+  function canReachBottom(i, j, day) {
+    if (i == row - 1) {
+      return true
+    }
+    visited[i][j] = true
+
+    for (let diff of d) {
+      let newI = i + diff[0]
+      let newJ = j + diff[1]
+
+      if (newI < 0 || newI >= row || newJ < 0 || newJ >= col) {
+        continue
+      }
+
+      if (visited[newI][newJ] || a[newI][newJ] < day) {
+        continue
+      }
+
+      if (canReachBottom(newI, newJ, day)) {
+        return true
+      }
+    }
+
+    return false
+  }
+
+  function canCross(day) {
+    for (let layer of visited) {
+      layer.forEach((e, idx) => (layer[idx] = false))
+    }
+
+    for (let j = 0; j < col; j++) {
+      if (a[0][j] >= day && canReachBottom(0, j, day)) {
+        return true
+      }
+    }
+
+    return false
+  }
+}
+
+

From 8ee16a600afd486eeecbb4d0587c4701798d6d88 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Aug 2021 11:40:44 +0800
Subject: [PATCH 1585/3374] Create
 5844-minimum-non-zero-product-of-the-array-elements.js

---
 ...-non-zero-product-of-the-array-elements.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 5844-minimum-non-zero-product-of-the-array-elements.js

diff --git a/5844-minimum-non-zero-product-of-the-array-elements.js b/5844-minimum-non-zero-product-of-the-array-elements.js
new file mode 100644
index 00000000..067d8260
--- /dev/null
+++ b/5844-minimum-non-zero-product-of-the-array-elements.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} p
+ * @return {number}
+ */
+const minNonZeroProduct = function(p) {
+  const b = BigInt(p)
+  const mod = BigInt(10 ** 9 + 7)
+
+  return (BigInt(1n << b) - 1n) % mod * pow(BigInt(1n << b) - 2n, BigInt(1n << (b - 1n)) - 1n) % mod;
+
+  function pow(a,  n) {
+    let r = 1n;
+    a %= mod;
+    while (n > 0n) {
+        r = r * a % mod;
+        a = a * a % mod;
+        n /= 2n;
+    }
+    return r;
+  }
+};

From f668bc9d13789f90aea00a4242c852de0002bab2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Aug 2021 11:41:42 +0800
Subject: [PATCH 1586/3374] Create
 5832-array-with-elements-not-equal-to-average-of-neighbors.js

---
 ...ments-not-equal-to-average-of-neighbors.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 5832-array-with-elements-not-equal-to-average-of-neighbors.js

diff --git a/5832-array-with-elements-not-equal-to-average-of-neighbors.js b/5832-array-with-elements-not-equal-to-average-of-neighbors.js
new file mode 100644
index 00000000..ef33751a
--- /dev/null
+++ b/5832-array-with-elements-not-equal-to-average-of-neighbors.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const rearrangeArray = function(nums) {
+  nums.sort((a, b) => a - b)
+  const res = []
+  let idx = 0, i = 0
+  const n = ~~((nums.length + 1) / 2)
+  while(i < nums.length) {
+    if(idx >= nums.length) idx = 1
+    // console.log(idx,i)
+    res[idx] = nums[i]
+    
+    idx += 2
+    i++
+  }
+  
+  return res
+};

From 3041fb8313c9aeb7484120cb5723a262ff7c3db6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Aug 2021 11:42:13 +0800
Subject: [PATCH 1587/3374] Create
 5843-number-of-strings-that-appear-as-substrings-in-word.js

---
 ...r-of-strings-that-appear-as-substrings-in-word.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 5843-number-of-strings-that-appear-as-substrings-in-word.js

diff --git a/5843-number-of-strings-that-appear-as-substrings-in-word.js b/5843-number-of-strings-that-appear-as-substrings-in-word.js
new file mode 100644
index 00000000..3c87e656
--- /dev/null
+++ b/5843-number-of-strings-that-appear-as-substrings-in-word.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string[]} patterns
+ * @param {string} word
+ * @return {number}
+ */
+const numOfStrings = function(patterns, word) {
+  let res = 0
+  for(let e of patterns) {
+    if(word.indexOf(e) !== -1) res++
+  }
+  return res
+};

From 38581beaca6debc09aa9ab91188fc829bbdd55c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Aug 2021 23:12:25 +0800
Subject: [PATCH 1588/3374] Update
 1249-minimum-remove-to-make-valid-parentheses.js

---
 ...inimum-remove-to-make-valid-parentheses.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1249-minimum-remove-to-make-valid-parentheses.js b/1249-minimum-remove-to-make-valid-parentheses.js
index eb294a6e..8f6a909c 100644
--- a/1249-minimum-remove-to-make-valid-parentheses.js
+++ b/1249-minimum-remove-to-make-valid-parentheses.js
@@ -18,3 +18,34 @@
   }
   return arr.join('')
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const minRemoveToMakeValid = function(s) {
+  let cnt = 0
+  let res = s.split('')
+  // console.log(res)
+  for(let i = 0; i < res.length; ) {
+    const ch = res[i]
+    if(ch === '(') cnt++
+    if(ch === ')') cnt--
+    if(cnt < 0) {
+      // console.log(res, i)
+      res.splice(i, 1)
+      cnt++
+    } else i++
+  }
+  // console.log(res)
+  let idx = res.length - 1
+  while(cnt > 0) {
+    if(res[idx] === '(') {
+      res.splice(idx, 1)
+      cnt--
+    } else idx--
+  }
+  return res.join('')
+};

From 397e9b30f5695197348850c49751f1a3ffe3cbe4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Aug 2021 22:11:35 +0800
Subject: [PATCH 1589/3374] Create
 1541-minimum-insertions-to-balance-a-parentheses-string.js

---
 ...ertions-to-balance-a-parentheses-string.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1541-minimum-insertions-to-balance-a-parentheses-string.js

diff --git a/1541-minimum-insertions-to-balance-a-parentheses-string.js b/1541-minimum-insertions-to-balance-a-parentheses-string.js
new file mode 100644
index 00000000..94c39484
--- /dev/null
+++ b/1541-minimum-insertions-to-balance-a-parentheses-string.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minInsertions = function(s) {
+    let res = 0, right = 0;
+    for (let i = 0; i < s.length; ++i) {
+        if (s.charAt(i) == '(') {
+            if (right % 2 > 0) {
+                right--;
+                res++;
+            }
+            right += 2;
+        } else {
+            right--;
+            if (right < 0) {
+                right += 2;
+                res++;
+            }
+        }
+    }
+    return right + res;
+};

From 7cd33e93e4c154bc5ff94f8ea718f740506cbc0b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Aug 2021 09:48:17 +0800
Subject: [PATCH 1590/3374] Update 678-valid-parenthesis-string.js

---
 678-valid-parenthesis-string.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/678-valid-parenthesis-string.js b/678-valid-parenthesis-string.js
index bfac5df3..443a9a4d 100644
--- a/678-valid-parenthesis-string.js
+++ b/678-valid-parenthesis-string.js
@@ -12,3 +12,26 @@ const checkValidString = function(s) {
     }
     return lo === 0;
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+ const checkValidString = function (s) {
+  let lo = 0, hi = 0 // 可能多余的‘(’
+  for(let ch of s) {
+    if(ch === '(') lo++, hi++
+    if(ch === ')') {
+      if(lo > 0) lo--
+      hi--
+    }
+    if(ch === '*') {
+      if(lo > 0) lo--
+      hi++
+    }
+    if(hi < 0) return false
+  }
+  return lo === 0
+}

From 46a41a2959f74b26db0d1acd3f7d7a4b01fd8e56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Aug 2021 19:38:20 +0800
Subject: [PATCH 1591/3374] Update 715-range-module.js

---
 715-range-module.js | 75 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/715-range-module.js b/715-range-module.js
index 65f77cd2..3b9e4b9f 100644
--- a/715-range-module.js
+++ b/715-range-module.js
@@ -123,3 +123,78 @@ RangeModule.prototype.removeRange = function(left, right) {
  * var param_2 = obj.queryRange(left,right)
  * obj.removeRange(left,right)
  */
+
+
+// another
+
+const RangeModule = function () {
+  this.intervals = []
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.addRange = function (left, right) {
+  const n = this.intervals.length
+  const tmp = []
+  for (let i = 0; i <= n; i++) {
+    const cur = this.intervals[i]
+
+    if (i == n || cur[0] > right) {
+      tmp.push([left, right])
+      while (i < n) tmp.push(this.intervals[i++])
+    } else if (cur[1] < left) tmp.push(cur)
+    else {
+      left = Math.min(left, cur[0])
+      right = Math.max(right, cur[1])
+    }
+  }
+  this.intervals = tmp
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {boolean}
+ */
+RangeModule.prototype.queryRange = function (left, right) {
+  const n = this.intervals.length
+  let l = 0,
+    r = n - 1
+  while (l <= r) {
+    let m = ~~(l + (r - l) / 2)
+    if (this.intervals[m][0] >= right) r = m - 1
+    else if (this.intervals[m][1] <= left) l = m + 1
+    else return this.intervals[m][0] <= left && this.intervals[m][1] >= right
+  }
+  return false
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.removeRange = function (left, right) {
+  const n = this.intervals.length
+  const tmp = []
+  for (let i = 0; i < n; i++) {
+    const cur = this.intervals[i]
+    if (cur[1] <= left || cur[0] >= right) tmp.push(cur)
+    else {
+      if (cur[0] < left) tmp.push([cur[0], left])
+      if (cur[1] > right) tmp.push([right, cur[1]])
+    }
+  }
+  this.intervals = tmp
+}
+
+/**
+ * Your RangeModule object will be instantiated and called as such:
+ * var obj = new RangeModule()
+ * obj.addRange(left,right)
+ * var param_2 = obj.queryRange(left,right)
+ * obj.removeRange(left,right)
+ */

From c2123becaf5a8dd57c9f58853b29e5fb2498d93c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Aug 2021 21:58:53 +0800
Subject: [PATCH 1592/3374] Update
 1541-minimum-insertions-to-balance-a-parentheses-string.js

---
 ...ertions-to-balance-a-parentheses-string.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1541-minimum-insertions-to-balance-a-parentheses-string.js b/1541-minimum-insertions-to-balance-a-parentheses-string.js
index 94c39484..30fa00fa 100644
--- a/1541-minimum-insertions-to-balance-a-parentheses-string.js
+++ b/1541-minimum-insertions-to-balance-a-parentheses-string.js
@@ -21,3 +21,32 @@ const minInsertions = function(s) {
     }
     return right + res;
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minInsertions = function(s) {
+  let add = 0, req = 0 // number of parentheses added, number of closing parentheses required
+  for(let ch of s) {
+    if(ch === '(') {
+      req += 2
+      if(req % 2 === 1) {
+         add++
+         req--
+      }
+    } else {
+      if(req === 0) {
+        add++
+        req++
+      }else {
+        req--
+      }
+    }
+  }
+  
+  return add + req
+};
+

From ceee2627d61baaaeee378c654397599c45a94986 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Aug 2021 19:36:20 +0800
Subject: [PATCH 1593/3374] Create
 1959-minimum-total-space-wasted-with-k-resizing-operations.js

---
 ...space-wasted-with-k-resizing-operations.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1959-minimum-total-space-wasted-with-k-resizing-operations.js

diff --git a/1959-minimum-total-space-wasted-with-k-resizing-operations.js b/1959-minimum-total-space-wasted-with-k-resizing-operations.js
new file mode 100644
index 00000000..b20a1d77
--- /dev/null
+++ b/1959-minimum-total-space-wasted-with-k-resizing-operations.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minSpaceWastedKResizing = function(nums, k) {
+  const n = nums.length, INF = 200 * 1e6;
+  const memo = Array.from({ length: 200 }, () => Array(200));
+  return dp(nums, 0, k);  
+  function dp(nums, i, k) {
+    if (i === n) return 0;
+    if (k === -1) return INF;
+    if (memo[i][k] != null) return memo[i][k];
+    let ans = INF, maxNum = nums[i], totalSum = 0;
+    for (let j = i; j < n; j++) {
+      maxNum = Math.max(maxNum, nums[j]);
+      totalSum += nums[j];
+      const wasted = maxNum * (j - i + 1) - totalSum;
+      ans = Math.min(ans, dp(nums, j + 1, k - 1) + wasted);
+    }
+    return memo[i][k] = ans;
+  }
+};
+

From 7b2e52e3a14cf516c1706ed0ee2da2c85913e3b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Aug 2021 22:13:56 +0800
Subject: [PATCH 1594/3374] Update
 1959-minimum-total-space-wasted-with-k-resizing-operations.js

---
 ...space-wasted-with-k-resizing-operations.js | 30 +++++++++----------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/1959-minimum-total-space-wasted-with-k-resizing-operations.js b/1959-minimum-total-space-wasted-with-k-resizing-operations.js
index b20a1d77..3529ed15 100644
--- a/1959-minimum-total-space-wasted-with-k-resizing-operations.js
+++ b/1959-minimum-total-space-wasted-with-k-resizing-operations.js
@@ -4,21 +4,21 @@
  * @return {number}
  */
 const minSpaceWastedKResizing = function(nums, k) {
-  const n = nums.length, INF = 200 * 1e6;
-  const memo = Array.from({ length: 200 }, () => Array(200));
-  return dp(nums, 0, k);  
-  function dp(nums, i, k) {
-    if (i === n) return 0;
-    if (k === -1) return INF;
-    if (memo[i][k] != null) return memo[i][k];
-    let ans = INF, maxNum = nums[i], totalSum = 0;
-    for (let j = i; j < n; j++) {
-      maxNum = Math.max(maxNum, nums[j]);
-      totalSum += nums[j];
-      const wasted = maxNum * (j - i + 1) - totalSum;
-      ans = Math.min(ans, dp(nums, j + 1, k - 1) + wasted);
+  const n = nums.length, INF = 200 * 1e6
+  const memo = Array.from({length: n}, () => Array(k))
+  return dp(0, k)
+  
+  function dp(i, k) {
+    if(i === n) return 0
+    if(k < 0) return INF
+    if(memo[i][k] != null) return memo[i][k]
+    let res = INF, max = nums[i], sum = 0
+    for(let j = i; j < n; j++) {
+      max = Math.max(max, nums[j])
+      sum += nums[j]
+      const waste = max * (j - i + 1) - sum
+      res = Math.min(res, dp(j + 1, k - 1) + waste)
     }
-    return memo[i][k] = ans;
+    return memo[i][k] = res
   }
 };
-

From c6cb30e9ebfa635130a79138ddd82c478e114ef9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Aug 2021 16:22:37 +0800
Subject: [PATCH 1595/3374] Update 1105-filling-bookcase-shelves.js

---
 1105-filling-bookcase-shelves.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1105-filling-bookcase-shelves.js b/1105-filling-bookcase-shelves.js
index 712581f4..aaa4d034 100644
--- a/1105-filling-bookcase-shelves.js
+++ b/1105-filling-bookcase-shelves.js
@@ -18,3 +18,24 @@ const minHeightShelves = function(books, shelf_width) {
   }
   return dp[books.length]
 };
+
+// another
+
+/**
+ * @param {number[][]} books
+ * @param {number} shelf_width
+ * @return {number}
+ */
+const minHeightShelves = function(books, shelf_width) {
+  const n = books.length, dp = Array(1001).fill(Infinity)
+  dp[0] = 0
+  for(let i = 0; i < n; i++) {
+    let sum = 0, mx = 0
+    for(let j = i; j >= 0 && sum + books[j][0] <= shelf_width; j--) {
+      sum += books[j][0]
+      mx = Math.max(mx, books[j][1])
+      dp[i + 1] = Math.min(dp[i + 1], dp[j] + mx)
+    }
+  }
+  return dp[n]
+};

From 4196f6290b37610ae0dff0a74a06a83841224e96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Aug 2021 17:34:40 +0800
Subject: [PATCH 1596/3374] Update 1105-filling-bookcase-shelves.js

---
 1105-filling-bookcase-shelves.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1105-filling-bookcase-shelves.js b/1105-filling-bookcase-shelves.js
index aaa4d034..26f71c83 100644
--- a/1105-filling-bookcase-shelves.js
+++ b/1105-filling-bookcase-shelves.js
@@ -39,3 +39,27 @@ const minHeightShelves = function(books, shelf_width) {
   }
   return dp[n]
 };
+
+// another
+
+/**
+ * @param {number[][]} books
+ * @param {number} shelf_width
+ * @return {number}
+ */
+ const minHeightShelves = function(books, shelf_width) {
+  const n = books.length, dp = Array(1001)
+  dp[0] = 0
+
+  for(let i = 0; i < n; i++) {
+    let [w, h] = books[i]
+    dp[i + 1] = dp[i] + h
+    for(let j = i - 1; j >= 0 && w + books[j][0] <= shelf_width; j--) {
+      h = Math.max(h, books[j][1])
+      w += books[j][0]
+      dp[i + 1] = Math.min(dp[i + 1], dp[j] + h) 
+    }
+  }
+
+  return dp[n]
+};

From 77c53e9f1ad30aa7089f64164531245b2bfc7fd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Aug 2021 22:50:26 +0800
Subject: [PATCH 1597/3374] Create 1114-print-in-order.cpp

---
 1114-print-in-order.cpp | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1114-print-in-order.cpp

diff --git a/1114-print-in-order.cpp b/1114-print-in-order.cpp
new file mode 100644
index 00000000..48110120
--- /dev/null
+++ b/1114-print-in-order.cpp
@@ -0,0 +1,33 @@
+class Foo {
+public:
+    int count = 0;
+    mutex mtx;
+    condition_variable cv;
+    Foo() {
+        count = 1;
+    }
+
+    void first(function<void()> printFirst) {
+        unique_lock<mutex> lck(mtx);
+        // printFirst() outputs "first". Do not change or remove this line.
+        printFirst();
+        count = 2;
+        cv.notify_all();
+    }
+
+    void second(function<void()> printSecond) {
+        unique_lock<mutex> lck(mtx);
+        cv.wait(lck, [this]() { return count == 2;});
+        // printSecond() outputs "second". Do not change or remove this line.
+        printSecond();
+        count = 3;
+        cv.notify_all();
+    }
+
+    void third(function<void()> printThird) {
+        unique_lock<mutex> lck(mtx);
+        cv.wait(lck, [this]() { return count == 3;});
+        // printThird() outputs "third". Do not change or remove this line.
+        printThird();
+    }
+};

From 62f6696875959701ccbc73a4a5ca154e15e05fe1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Aug 2021 23:07:12 +0800
Subject: [PATCH 1598/3374] Create 1588-sum-of-all-odd-length-subarrays.js

---
 1588-sum-of-all-odd-length-subarrays.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1588-sum-of-all-odd-length-subarrays.js

diff --git a/1588-sum-of-all-odd-length-subarrays.js b/1588-sum-of-all-odd-length-subarrays.js
new file mode 100644
index 00000000..3306288b
--- /dev/null
+++ b/1588-sum-of-all-odd-length-subarrays.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const sumOddLengthSubarrays = function(arr) {
+  const n = arr.length, pre = Array(n + 1).fill(0)
+  for(let i = 0; i < n; i++) pre[i + 1] = pre[i] +  arr[i]
+  
+  let res = 0
+  let len = 1
+  while(len <= n) {
+    for(let i = 0; i <= n - len; i++) {
+      res += pre[i + len] - pre[i] // len === 1: 1 - 0, 2 - 1
+                                   // len === 3: 3 - 0, 6 - 3
+    }
+    
+    len += 2
+  }
+  
+  return res
+  
+};

From 63aed9dbe943d6e8240ae19b4c421ba596be380a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Aug 2021 11:13:50 +0800
Subject: [PATCH 1599/3374] Update 1043-partition-array-for-maximum-sum.js

---
 1043-partition-array-for-maximum-sum.js | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1043-partition-array-for-maximum-sum.js b/1043-partition-array-for-maximum-sum.js
index c98797e8..adec52a9 100644
--- a/1043-partition-array-for-maximum-sum.js
+++ b/1043-partition-array-for-maximum-sum.js
@@ -15,3 +15,29 @@ const maxSumAfterPartitioning = function(A, K) {
   }
   return dp[N - 1];
 };
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @return {number}
+ */
+const maxSumAfterPartitioning = function(arr, k) {
+  const n = arr.length, memo = Array(n + 1)
+  memo[0] = 0
+  return dp(n)
+  
+  function dp(i) {
+    if(i === 0) return 0
+    if(memo[i] != null) return memo[i]
+    
+    let sum = 0, max = 0, res = 0
+    for(let j = i; j > 0 && i - j < k; j--) {
+      max = Math.max(max, arr[j - 1])
+      sum = (i - j + 1) * max
+      res = Math.max(res, dp(j - 1) + sum)
+    }
+    return memo[i] = res
+  }
+};

From 5f0f2d9ce014a6109115a63f401b612a40a802e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Aug 2021 11:01:39 +0800
Subject: [PATCH 1600/3374] Update 300-longest-increasing-subsequence.js

---
 300-longest-increasing-subsequence.js | 31 +++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/300-longest-increasing-subsequence.js b/300-longest-increasing-subsequence.js
index 196f7ba3..3d79c6ec 100644
--- a/300-longest-increasing-subsequence.js
+++ b/300-longest-increasing-subsequence.js
@@ -68,3 +68,34 @@ const lengthOfLIS = function(nums) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const lengthOfLIS = function(nums) {
+  const n = nums.length, stack = []
+  let res = 0
+  stack.push(nums[0])
+  for(let i = 1; i < n; i++) {
+    const cur = nums[i]
+    if(cur > stack[stack.length - 1]) {
+      stack.push(cur)
+    } else {
+      let l = 0, r = stack.length - 1
+      while(l < r) {
+        let mid = ~~((l + r) / 2)
+        if(stack[mid] < cur) {
+          l = mid + 1
+        } else {
+          r = mid
+        }
+      }
+      stack[l] = cur
+    }
+  }
+  
+  return stack.length
+};

From b62e13e547ce72277b1c6d38384ca763e27da7d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Aug 2021 19:43:26 +0800
Subject: [PATCH 1601/3374] Create
 1351-count-negative-numbers-in-a-sorted-matrix.js

---
 ...-count-negative-numbers-in-a-sorted-matrix.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1351-count-negative-numbers-in-a-sorted-matrix.js

diff --git a/1351-count-negative-numbers-in-a-sorted-matrix.js b/1351-count-negative-numbers-in-a-sorted-matrix.js
new file mode 100644
index 00000000..3564969e
--- /dev/null
+++ b/1351-count-negative-numbers-in-a-sorted-matrix.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const countNegatives = function(grid) {
+  const m = grid.length, n = grid[0].length
+  let res = 0, r = m - 1, c = 0
+  while(r >= 0 && c < n) {
+    if(grid[r][c] < 0) {
+      res += n - c
+      r--
+    } else c++
+  }
+
+  return res
+};

From 85da8858a58c7b83b68bae0e6e14840cafff9191 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Aug 2021 20:04:18 +0800
Subject: [PATCH 1602/3374] Update
 1964-find-the-longest-valid-obstacle-course-at-each-position.js

---
 ...-valid-obstacle-course-at-each-position.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1964-find-the-longest-valid-obstacle-course-at-each-position.js b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
index bb0f7e46..86eab10a 100644
--- a/1964-find-the-longest-valid-obstacle-course-at-each-position.js
+++ b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
@@ -1,3 +1,47 @@
+/**
+ * @param {number[]} obstacles
+ * @return {number[]}
+ */
+const longestObstacleCourseAtEachPosition = function(obstacles) {
+  const n = obstacles.length
+  const stack = [], res = []
+  let len = 0
+  
+  for(let i = 0; i < n; i++) {
+    const cur = obstacles[i]
+    const idx = chk(cur)
+    if(idx === len) {
+      stack.push(cur)
+      len++
+      res.push(len)
+    }else {
+      stack[idx] = cur
+      res.push(idx + 1)
+    }
+  }
+
+  return res
+  
+  function chk(x) {
+    if(len && stack[len - 1] <= x) return len
+    let l = 0, r = len - 1
+    while(l < r) {
+      const mid = ~~((l + r) / 2)
+      if(stack[mid] <= x) {
+        l = mid + 1
+      } else {
+        r = mid
+      }
+    }
+    return l
+  }
+};
+
+
+
+
+// another
+
 /**
  * @param {number[]} obstacles
  * @return {number[]}

From b81e5e4f4346e02e944fce30960e5523be3343fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Aug 2021 20:04:54 +0800
Subject: [PATCH 1603/3374] Create
 1979-find-greatest-common-divisor-of-array.js

---
 1979-find-greatest-common-divisor-of-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1979-find-greatest-common-divisor-of-array.js

diff --git a/1979-find-greatest-common-divisor-of-array.js b/1979-find-greatest-common-divisor-of-array.js
new file mode 100644
index 00000000..3028ce94
--- /dev/null
+++ b/1979-find-greatest-common-divisor-of-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findGCD = function(nums) {
+  let min = Math.min(...nums)
+  let max = Math.max(...nums)
+  return gcd(min, max)
+};
+
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b)
+}

From eaec25cbc635d85eeeb4e633cbe38b8cee69e863 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Aug 2021 20:05:24 +0800
Subject: [PATCH 1604/3374] Create 1980-find-unique-binary-string.js

---
 1980-find-unique-binary-string.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1980-find-unique-binary-string.js

diff --git a/1980-find-unique-binary-string.js b/1980-find-unique-binary-string.js
new file mode 100644
index 00000000..1e24e6a6
--- /dev/null
+++ b/1980-find-unique-binary-string.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string[]} nums
+ * @return {string}
+ */
+const findDifferentBinaryString = function(nums) {
+  const set = new Set(nums)
+  const len = nums[0].length
+  for(let i = 0, n = 1 << 17; i < n; i++) {
+    const tmp = pad(bin(i), len)
+    if(!set.has(tmp)) return tmp
+  }
+  return ''
+};
+
+function bin(num) {
+  return (num >>> 0).toString(2)
+}
+
+function pad(str,n) {
+  while(str.length < n) str = '0' + str
+  return str
+}

From 90b4a71d208eec93fc652c972eedad6f8f5e4f08 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Aug 2021 20:05:59 +0800
Subject: [PATCH 1605/3374] Create
 1981-minimize-the-difference-between-target-and-chosen-elements.js

---
 ...ence-between-target-and-chosen-elements.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1981-minimize-the-difference-between-target-and-chosen-elements.js

diff --git a/1981-minimize-the-difference-between-target-and-chosen-elements.js b/1981-minimize-the-difference-between-target-and-chosen-elements.js
new file mode 100644
index 00000000..df41deae
--- /dev/null
+++ b/1981-minimize-the-difference-between-target-and-chosen-elements.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} target
+ * @return {number}
+ */
+const minimizeTheDifference = function(mat, target) {
+  const m = mat.length, n = mat[0].length
+  const dp = Array.from({length: m}, () => Array(70*70).fill(-1))
+  return fn(0, 0)
+  
+  function fn(row, sum) {
+    if(row === m) return Math.abs(target - sum)
+    if(dp[row][sum] !== -1) return dp[row][sum]
+    let res = Number.MAX_SAFE_INTEGER
+    for(let j = 0; j < n; j++) {
+      res = Math.min(res, fn(row + 1, sum + mat[row][j]))
+    }
+    return dp[row][sum] = res
+  }
+};
+

From 01a4f237899ff8e74013cf23193a797890eb6c65 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Aug 2021 19:38:06 +0800
Subject: [PATCH 1606/3374] Update
 1713-minimum-operations-to-make-a-subsequence.js

---
 ...inimum-operations-to-make-a-subsequence.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1713-minimum-operations-to-make-a-subsequence.js b/1713-minimum-operations-to-make-a-subsequence.js
index 8e751863..edd5d4c5 100644
--- a/1713-minimum-operations-to-make-a-subsequence.js
+++ b/1713-minimum-operations-to-make-a-subsequence.js
@@ -75,3 +75,41 @@ const minOperations = function(target, arr) {
 
   return target.length - stack.length
 };
+
+// another
+
+/**
+ * @param {number[]} target
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minOperations = function(target, arr) {
+  const hash = {}
+  for(let i = 0, n = target.length; i < n; i++) {
+    hash[target[i]] = i
+  }
+  const stack = []
+  
+  for(let e of arr) {
+    if(hash[e] == null) continue
+    const cur = hash[e]
+    if(stack.length && cur > stack[stack.length - 1]) {
+      stack.push(cur)
+      continue
+    }
+    
+    let l = 0, r = stack.length - 1
+    
+    while(l < r) {
+      const mid = ~~((l + r) / 2)
+      if(stack[mid] < cur) {
+        l = mid + 1
+      } else r = mid
+    }
+    
+    stack[l] = cur
+    
+  }
+  
+  return target.length - stack.length
+};

From bc124356d6bd061306f3d0fbdafa394cc01697ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Aug 2021 21:22:43 +0800
Subject: [PATCH 1607/3374] Create 1534-count-good-triplets.js

---
 1534-count-good-triplets.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1534-count-good-triplets.js

diff --git a/1534-count-good-triplets.js b/1534-count-good-triplets.js
new file mode 100644
index 00000000..8d6d3b96
--- /dev/null
+++ b/1534-count-good-triplets.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} arr
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number}
+ */
+const countGoodTriplets = function(arr, a, b, c) {
+  const  n = arr.length, { abs } = Math
+  let res = 0
+  
+  for(let i = 0; i < n - 2; i++) {
+    for(let j = i + 1; j < n - 1; j++) {
+      if(abs(arr[i] - arr[j]) > a) continue
+      for(let k = j + 1; k < n; k++) {
+        if(abs(arr[j] - arr[k]) <= b && abs(arr[i] - arr[k]) <= c) res++
+      }
+    }
+  }
+  
+  return res
+  
+};

From f11a50a757f8e4cb935f24af083fce9b3f75ccf4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Aug 2021 21:54:09 +0800
Subject: [PATCH 1608/3374] Create 1982-find-array-given-subset-sums.js

---
 1982-find-array-given-subset-sums.js | 43 ++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 1982-find-array-given-subset-sums.js

diff --git a/1982-find-array-given-subset-sums.js b/1982-find-array-given-subset-sums.js
new file mode 100644
index 00000000..b1b71020
--- /dev/null
+++ b/1982-find-array-given-subset-sums.js
@@ -0,0 +1,43 @@
+/**
+ * @param {number} n
+ * @param {number[]} sums
+ * @return {number[]}
+ */
+const recoverArray = function(n, sums) {
+  const res = []
+  sums.sort((a, b)  => a - b)
+  while(res.length < n) {
+    const used = Array(sums.length).fill(false)
+    const v0 = [], v1 = []
+    let d = sums[1] - sums[0]
+    for(let i = 0, j = 1; ;i++, j++) {
+      while(i < sums.length && used[i]) i++
+      if(i === sums.length) break
+      while(j <= i || sums[j] !== sums[i] + d) j++
+      v0.push(sums[i])
+      v1.push(sums[j])
+      used[i] = used[j] = true
+    }
+    
+    if(bs(v0, 0)) {
+      res.push(d)
+      sums = v0
+    }else {
+      res.push(-d)
+      sums = v1
+    }
+  }
+  return res
+};
+
+
+function bs(arr, e) {
+  let l = 0, r = arr.length - 1
+  while(l < r) {
+    const mid = ~~((l + r) / 2)
+    if(arr[mid] < e) l = mid + 1
+    else r = mid
+  }
+  
+  return arr[l] === e
+}

From dbd7d02fda2ffddd99202fb019a1da8595850bfc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Aug 2021 11:18:58 +0800
Subject: [PATCH 1609/3374] Update 354-russian-doll-envelopes.js

---
 354-russian-doll-envelopes.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/354-russian-doll-envelopes.js b/354-russian-doll-envelopes.js
index 81e09efb..bb10c078 100644
--- a/354-russian-doll-envelopes.js
+++ b/354-russian-doll-envelopes.js
@@ -26,3 +26,29 @@ const maxEnvelopes = function(envelopes) {
   }
   return dp.length
 }
+
+// another
+
+/**
+ * @param {number[][]} envelopes
+ * @return {number}
+ */
+const maxEnvelopes = function(envelopes) {
+  envelopes.sort((a, b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])
+  const stack = []
+  for(let e of envelopes) {
+    if(stack.length === 0 || e[1] > stack[stack.length - 1][1]) {
+      stack.push(e)
+      continue
+    }
+    let l = 0, r = stack.length - 1
+    while(l < r) {
+      const mid = ~~((l+r)/2)
+      if(stack[mid][1] < e[1]) {
+        l = mid + 1
+      } else r = mid
+    }
+    stack[l] = e
+  }
+  return stack.length
+};

From 7af9a5537861cffb47a412a60a3b45aee27cd8c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Aug 2021 15:59:57 +0800
Subject: [PATCH 1610/3374] Create 1221-split-a-string-in-balanced-strings.js

---
 1221-split-a-string-in-balanced-strings.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1221-split-a-string-in-balanced-strings.js

diff --git a/1221-split-a-string-in-balanced-strings.js b/1221-split-a-string-in-balanced-strings.js
new file mode 100644
index 00000000..fe5401de
--- /dev/null
+++ b/1221-split-a-string-in-balanced-strings.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const balancedStringSplit = function(s) {
+  let res = 0, num = 0
+  for(let ch of s) {
+    num += ch === 'L' ? 1 : -1
+    if(num === 0) res++
+  }
+  return res
+};

From d8312c0fc9968407dd548fcdbd057dae13c4a299 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Aug 2021 16:12:29 +0800
Subject: [PATCH 1611/3374] Create 1360-number-of-days-between-two-dates.js

---
 1360-number-of-days-between-two-dates.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 1360-number-of-days-between-two-dates.js

diff --git a/1360-number-of-days-between-two-dates.js b/1360-number-of-days-between-two-dates.js
new file mode 100644
index 00000000..3c1a019f
--- /dev/null
+++ b/1360-number-of-days-between-two-dates.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} date1
+ * @param {string} date2
+ * @return {number}
+ */
+const daysBetweenDates = function(date1, date2) {
+  const d1 = new Date(date1)
+  const d2 = new Date(date2)
+  return Math.abs((d1.getTime() - d2.getTime()) / (1000 * 60 * 60 * 24))
+};

From e78a83db37afcc8740d512551699f7be9a010f89 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Aug 2021 21:52:25 +0800
Subject: [PATCH 1612/3374] Update 1982-find-array-given-subset-sums.js

---
 1982-find-array-given-subset-sums.js | 48 ++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1982-find-array-given-subset-sums.js b/1982-find-array-given-subset-sums.js
index b1b71020..e9c93661 100644
--- a/1982-find-array-given-subset-sums.js
+++ b/1982-find-array-given-subset-sums.js
@@ -41,3 +41,51 @@ function bs(arr, e) {
   
   return arr[l] === e
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} sums
+ * @return {number[]}
+ */
+const recoverArray = function(n, sums) {
+  const res = []
+  sums.sort((a, b) => a - b)
+  
+  while(res.length < n) {
+    const visited = Array(sums.length).fill(false)
+    const a1 = [], a2 = []
+    const d = sums[1] - sums[0]
+    for(let i = 0, j = 1; i < sums.length; i++, j++) {
+      while(i < sums.length && visited[i]) i++
+      if(i === sums.length) break
+      while(j <= i || sums[j] !== sums[i] + d) j++
+      a1.push(sums[i])
+      a2.push(sums[j])
+      visited[i] = visited[j] = true
+    }
+    
+    if(bs(a1, 0)) {
+      sums = a1
+      res.push(d)
+    } else {
+      sums = a2
+      res.push(-d)
+    }
+  }
+  
+  return res
+};
+
+function bs(arr, val) {
+  let l = 0, r = arr.length - 1
+  while(l < r) {
+    const mid = ~~((l + r) / 2)
+    if(arr[mid] < val) l = mid + 1
+    else r = mid
+  }
+  
+  return arr[l] === val
+}
+

From 0749af83dede671e42e0c541a2addaaa00748333 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Aug 2021 22:10:19 +0800
Subject: [PATCH 1613/3374] Update
 1981-minimize-the-difference-between-target-and-chosen-elements.js

---
 ...ence-between-target-and-chosen-elements.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1981-minimize-the-difference-between-target-and-chosen-elements.js b/1981-minimize-the-difference-between-target-and-chosen-elements.js
index df41deae..f66a42de 100644
--- a/1981-minimize-the-difference-between-target-and-chosen-elements.js
+++ b/1981-minimize-the-difference-between-target-and-chosen-elements.js
@@ -19,3 +19,29 @@ const minimizeTheDifference = function(mat, target) {
   }
 };
 
+// another
+
+/**
+ * @param {number[][]} mat
+ * @param {number} target
+ * @return {number}
+ */
+const minimizeTheDifference = function(mat, target) {
+  const m = mat.length, n = mat[0].length
+  const memo = Array.from({ length: m }, () => Array())
+  return dfs(0, 0)
+  
+  function dfs(row, sum) {
+    if(row === m) return Math.abs(target - sum)
+    if(memo[row][sum] != null) return memo[row][sum]
+    let res = Number.MAX_SAFE_INTEGER
+    for(let i = 0; i < n; i++) {
+      res = Math.min(res, dfs(row + 1, sum + mat[row][i]))
+    }
+    
+    return memo[row][sum] = res
+  }
+};
+
+
+

From af3b50a770e82dd82a28705b5fd48859a771fb46 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Aug 2021 20:26:40 +0800
Subject: [PATCH 1614/3374] Create
 1969-minimum-non-zero-product-of-the-array-elements.js

---
 ...-non-zero-product-of-the-array-elements.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1969-minimum-non-zero-product-of-the-array-elements.js

diff --git a/1969-minimum-non-zero-product-of-the-array-elements.js b/1969-minimum-non-zero-product-of-the-array-elements.js
new file mode 100644
index 00000000..86883cd5
--- /dev/null
+++ b/1969-minimum-non-zero-product-of-the-array-elements.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} p
+ * @return {number}
+ */
+const minNonZeroProduct = function (p) {
+  const b = BigInt(p)
+  const mod = BigInt(10 ** 9 + 7)
+
+  return (
+    (((BigInt(1n << b) - 1n) % mod) *
+      pow(BigInt(1n << b) - 2n, BigInt(1n << (b - 1n)) - 1n)) %
+    mod
+  )
+
+  function pow(a, n) {
+    let r = 1n
+    a %= mod
+    while (n > 0n) {
+      r = (r * a) % mod
+      a = (a * a) % mod
+      n /= 2n
+    }
+    return r
+  }
+}

From d963fbbb7d44874b9ceccf4bd833116cd0832772 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Aug 2021 21:59:54 +0800
Subject: [PATCH 1615/3374] Update
 1969-minimum-non-zero-product-of-the-array-elements.js

---
 ...-non-zero-product-of-the-array-elements.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1969-minimum-non-zero-product-of-the-array-elements.js b/1969-minimum-non-zero-product-of-the-array-elements.js
index 86883cd5..2b29dade 100644
--- a/1969-minimum-non-zero-product-of-the-array-elements.js
+++ b/1969-minimum-non-zero-product-of-the-array-elements.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} p
+ * @return {number}
+ */
+const minNonZeroProduct = function (p) {
+  const MOD = BigInt(10 ** 9 + 7), bp = BigInt(p)
+  const bpm = BigInt(1n << bp) - 1n, base = BigInt(1n << bp) - 2n, pow = BigInt(1n << (bp - 1n)) - 1n 
+  return Number((bpm % MOD) * fastPow(base, pow, MOD) % MOD)
+
+}
+
+function fastPow(base, power, mod) {
+  if(power === 0n) return 1n
+  base %= mod
+  let res = fastPow(base, power / 2n, mod)
+  res = (res * res) % mod
+  if(power & 1n) res = (res * base) % mod
+  return res
+}
+
+
+// another
+
+
 /**
  * @param {number} p
  * @return {number}

From a33e9e7b76c08dc947585b5f2a259cd9b97d33fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Aug 2021 09:29:14 +0800
Subject: [PATCH 1616/3374] Create 1970-last-day-where-you-can-still-cross.js

---
 1970-last-day-where-you-can-still-cross.js | 66 ++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 1970-last-day-where-you-can-still-cross.js

diff --git a/1970-last-day-where-you-can-still-cross.js b/1970-last-day-where-you-can-still-cross.js
new file mode 100644
index 00000000..4ff89b21
--- /dev/null
+++ b/1970-last-day-where-you-can-still-cross.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number} row
+ * @param {number} col
+ * @param {number[][]} cells
+ * @return {number}
+ */
+const latestDayToCross = function (row, col, cells) {
+  let l = 0,
+    n = cells.length,
+    r = n - 1,
+    res = 0
+  while (l < r) {
+    const mid = ~~((l + r) / 2)
+    if (canWalk(mid)) {
+      l = mid + 1
+      res = mid
+    } else {
+      r = mid
+    }
+  }
+
+  return res + 1
+
+  function canWalk(mid) {
+    const grid = Array.from({ length: row }, () => Array(col).fill(0))
+    const dirs = [
+      [1, 0],
+      [-1, 0],
+      [0, 1],
+      [0, -1],
+    ]
+    for (let i = 0; i <= mid; i++) {
+      const [r, c] = cells[i]
+      grid[r - 1][c - 1] = 1
+    }
+
+    let q = []
+
+    for (let i = 0; i < col; i++) {
+      if (grid[0][i] === 0) {
+        q.push([0, i])
+        grid[0][i] = 1
+      }
+    }
+
+    while (q.length) {
+      const size = q.length,
+        tmp = []
+      for (let i = 0; i < size; i++) {
+        const [r, c] = q[i]
+        if (r === row - 1) return true
+        for (let [dr, dc] of dirs) {
+          const nr = r + dr,
+            nc = c + dc
+          if (nr < 0 || nr >= row || nc < 0 || nc >= col || grid[nr][nc] === 1)
+            continue
+          tmp.push([nr, nc])
+          grid[nr][nc] = 1
+        }
+      }
+      q = tmp
+    }
+
+    return false
+  }
+}

From cb7951b7462ef5596466ae42599ad21f3f57bfee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Aug 2021 10:00:42 +0800
Subject: [PATCH 1617/3374] Update 1970-last-day-where-you-can-still-cross.js

---
 1970-last-day-where-you-can-still-cross.js | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/1970-last-day-where-you-can-still-cross.js b/1970-last-day-where-you-can-still-cross.js
index 4ff89b21..ed44df6b 100644
--- a/1970-last-day-where-you-can-still-cross.js
+++ b/1970-last-day-where-you-can-still-cross.js
@@ -7,19 +7,17 @@
 const latestDayToCross = function (row, col, cells) {
   let l = 0,
     n = cells.length,
-    r = n - 1,
-    res = 0
+    r = n
   while (l < r) {
     const mid = ~~((l + r) / 2)
     if (canWalk(mid)) {
       l = mid + 1
-      res = mid
     } else {
       r = mid
     }
   }
 
-  return res + 1
+  return l
 
   function canWalk(mid) {
     const grid = Array.from({ length: row }, () => Array(col).fill(0))

From 8cc7f5a5c23eb41e4beda8be126e439a88ccf6af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Aug 2021 21:10:28 +0800
Subject: [PATCH 1618/3374] Create 1636-sort-array-by-increasing-frequency.js

---
 1636-sort-array-by-increasing-frequency.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1636-sort-array-by-increasing-frequency.js

diff --git a/1636-sort-array-by-increasing-frequency.js b/1636-sort-array-by-increasing-frequency.js
new file mode 100644
index 00000000..eee5122f
--- /dev/null
+++ b/1636-sort-array-by-increasing-frequency.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const frequencySort = function(nums) {
+  const hash = {}
+  for(let e of nums) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  nums.sort((a, b) => hash[a] === hash[b] ? b - a : hash[a] - hash[b])
+  return nums
+};

From d02b194e31bbea35b922cea3a0395525e308975a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Aug 2021 21:52:47 +0800
Subject: [PATCH 1619/3374] Create 1275-find-winner-on-a-tic-tac-toe-game.js

---
 1275-find-winner-on-a-tic-tac-toe-game.js | 49 +++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 1275-find-winner-on-a-tic-tac-toe-game.js

diff --git a/1275-find-winner-on-a-tic-tac-toe-game.js b/1275-find-winner-on-a-tic-tac-toe-game.js
new file mode 100644
index 00000000..8432a481
--- /dev/null
+++ b/1275-find-winner-on-a-tic-tac-toe-game.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[][]} moves
+ * @return {string}
+ */
+const tictactoe = function(moves) {
+  const grid = Array.from({ length: 3 }, () => Array(3).fill(''))
+  for(let i = 0, n = moves.length; i < n; i++) {
+    const ch = i % 2 === 0 ? 'X' : 'O'
+    const [r, c] = moves[i]
+    grid[r][c] = ch
+    const res = chk(ch, grid)
+    if(res) return ch === 'X' ? 'A' : 'B'
+  }
+  
+  return moves.length < 9 ? 'Pending' : 'Draw'
+};
+
+function chk(ch, grid) {
+  for(let i = 0; i < 3; i++) {
+    if(
+      grid[i][0] === ch &&
+      grid[i][1] === ch &&
+      grid[i][2] === ch
+    ) return true
+  }
+  
+  for(let i = 0; i < 3; i++) {
+    if(
+      grid[0][i] === ch &&
+      grid[1][i] === ch &&
+      grid[2][i] === ch
+    ) return true
+  }
+  
+
+    if(
+      grid[0][0] === ch &&
+      grid[1][1] === ch &&
+      grid[2][2] === ch
+    ) return true  
+  
+    if(
+      grid[0][2] === ch &&
+      grid[1][1] === ch &&
+      grid[2][0] === ch
+    ) return true  
+  
+  return false
+}

From 339d5389152385d4def1125614e601677819f534 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Aug 2021 22:07:10 +0800
Subject: [PATCH 1620/3374] Update 1275-find-winner-on-a-tic-tac-toe-game.js

---
 1275-find-winner-on-a-tic-tac-toe-game.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1275-find-winner-on-a-tic-tac-toe-game.js b/1275-find-winner-on-a-tic-tac-toe-game.js
index 8432a481..d6029d14 100644
--- a/1275-find-winner-on-a-tic-tac-toe-game.js
+++ b/1275-find-winner-on-a-tic-tac-toe-game.js
@@ -47,3 +47,24 @@ function chk(ch, grid) {
   
   return false
 }
+
+// another
+
+/**
+ * @param {number[][]} moves
+ * @return {string}
+ */
+const tictactoe = function(moves) {
+  const aRow = Array(3).fill(0), aCol = Array(3).fill(0), bRow= Array(3).fill(0), bCol =Array(3).fill(0)
+  let ad = 0, ads = 0, bd = 0, bds = 0
+  for(let i = 0; i < moves.length; i++) {
+    const [r, c] = moves[i]
+    if(i % 2===0) {
+      if(++aRow[r] === 3 || ++aCol[c] === 3 || r === c && ++ad === 3 || r + c === 2&& ++ads === 3 ) return 'A'
+    }else {
+      if(++bRow[r] === 3 || ++bCol[c] === 3 || r === c && ++bd === 3 || r + c === 2&& ++bds === 3 ) return 'B'
+    }
+  }
+  
+  return moves.length >= 9 ? 'Draw' : 'Pending'
+};

From e9ef8add0a85d3720719b2435d09dec9daa70deb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Aug 2021 19:44:30 +0800
Subject: [PATCH 1621/3374] Update 803-bricks-falling-when-hit.js

---
 803-bricks-falling-when-hit.js | 55 ++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/803-bricks-falling-when-hit.js b/803-bricks-falling-when-hit.js
index d2cda611..36c09fe0 100644
--- a/803-bricks-falling-when-hit.js
+++ b/803-bricks-falling-when-hit.js
@@ -196,3 +196,58 @@ function isConnected(i, j, grid, dirs) {
   }
   return false
 }
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @param {number[][]} hits
+ * @return {number[]}
+ */
+const hitBricks = function (grid, hits) {
+  const m = grid.length,
+    n = grid[0].length,
+    res = Array(hits.length).fill(0),
+    dirs = [
+      [-1, 0],
+      [1, 0],
+      [0, 1],
+      [0, -1],
+    ];
+  for (let [r, c] of hits) grid[r][c] -= 1;
+
+  for (let i = 0; i < n; i++) dfs(grid, 0, i, m, n, dirs);
+
+  for (let i = hits.length - 1; i >= 0; i--) {
+    const [r, c] = hits[i];
+    grid[r][c] += 1;
+    if (grid[r][c] === 1 && connected(grid, r, c, m, n, dirs)) {
+      res[i] = dfs(grid, r, c, m, n, dirs) - 1;
+    }
+  }
+
+  return res;
+};
+
+function dfs(grid, i, j, m, n, dirs) {
+  if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] !== 1) return 0;
+  grid[i][j] = 2;
+  let res = 1;
+  for (let [dr, dc] of dirs) {
+    res += dfs(grid, i + dr, j + dc, m, n, dirs);
+  }
+  return res;
+}
+
+function connected(grid, i, j, m, n, dirs) {
+  if (i === 0) return true;
+  for (let [dr, dc] of dirs) {
+    const nr = i + dr,
+      nc = j + dc;
+    if (nr >= 0 && nr < m && nc >= 0 && nc < n && grid[nr][nc] === 2)
+      return true;
+  }
+
+  return false;
+}
+

From ac9328b4aa81cedecdda29ac9f681acb6224e55f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Aug 2021 22:48:07 +0800
Subject: [PATCH 1622/3374] Create 1436-destination-city.js

---
 1436-destination-city.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1436-destination-city.js

diff --git a/1436-destination-city.js b/1436-destination-city.js
new file mode 100644
index 00000000..f9d4d15c
--- /dev/null
+++ b/1436-destination-city.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string[][]} paths
+ * @return {string}
+ */
+const destCity = function(paths) {
+  const hash = {}
+  for(let [s, e] of paths) {
+    if(hash[e] == null) hash[e] = true
+    hash[s] = false
+    if(hash[s] === true) hash[s] = false
+  }
+  
+  for(let k in hash) {
+    if(hash[k]) return k
+  }
+};

From 9f86ed0eb6c6c4b7c079e7d185bbe4b6116b6f49 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Aug 2021 22:51:42 +0800
Subject: [PATCH 1623/3374] Update 1436-destination-city.js

---
 1436-destination-city.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/1436-destination-city.js b/1436-destination-city.js
index f9d4d15c..18999109 100644
--- a/1436-destination-city.js
+++ b/1436-destination-city.js
@@ -14,3 +14,17 @@ const destCity = function(paths) {
     if(hash[k]) return k
   }
 };
+
+// another
+
+/**
+ * @param {string[][]} paths
+ * @return {string}
+ */
+const destCity = function(paths) {
+  const set = new Set()
+  for(let [s, e] of paths) set.add(e)
+  for(let [s, e] of paths) set.delete(s)
+  
+  return set[Symbol.iterator]().next().value
+};

From 9562bfa60ea2a2e1daff18b4a68ec7e87554b27a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Aug 2021 23:13:52 +0800
Subject: [PATCH 1624/3374] Create
 1389-create-target-array-in-the-given-order.js

---
 1389-create-target-array-in-the-given-order.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1389-create-target-array-in-the-given-order.js

diff --git a/1389-create-target-array-in-the-given-order.js b/1389-create-target-array-in-the-given-order.js
new file mode 100644
index 00000000..10b922ec
--- /dev/null
+++ b/1389-create-target-array-in-the-given-order.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} index
+ * @return {number[]}
+ */
+const createTargetArray = function(nums, index) {
+  const res = [], n = nums.length
+  for(let i = 0; i < n; i++) {
+    if(res[index[i]] == null) res[index[i]] = nums[i]
+    else res.splice(index[i], 0, nums[i])
+    
+  }
+  
+  return res
+};

From 1a2411a9c75cd1a53fa62649eeca4edb22f49adf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Aug 2021 23:23:51 +0800
Subject: [PATCH 1625/3374] Create
 1413-minimum-value-to-get-positive-step-by-step-sum.js

---
 ...inimum-value-to-get-positive-step-by-step-sum.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1413-minimum-value-to-get-positive-step-by-step-sum.js

diff --git a/1413-minimum-value-to-get-positive-step-by-step-sum.js b/1413-minimum-value-to-get-positive-step-by-step-sum.js
new file mode 100644
index 00000000..8eaf024c
--- /dev/null
+++ b/1413-minimum-value-to-get-positive-step-by-step-sum.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minStartValue = function(nums) {
+  let sum = 0, min = Infinity
+  for(let e of nums) {
+    sum += e
+    min = Math.min(min, sum)
+  }
+  
+  return min >= 0 ? 1 : -min + 1
+};

From 901a37bcd69f43a41d140f6fb41f833d9290f095 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Aug 2021 23:44:52 +0800
Subject: [PATCH 1626/3374] Create 1313-decompress-run-length-encoded-list.js

---
 1313-decompress-run-length-encoded-list.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1313-decompress-run-length-encoded-list.js

diff --git a/1313-decompress-run-length-encoded-list.js b/1313-decompress-run-length-encoded-list.js
new file mode 100644
index 00000000..95417f5a
--- /dev/null
+++ b/1313-decompress-run-length-encoded-list.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const decompressRLElist = function(nums) {
+  const res = []
+  for(let i = 0, n = nums.length; i < n - 1; i += 2) {
+    const [freq, val] = [nums[i], nums[i + 1]]
+    for(let j = 0; j < freq; j++) res.push(val)
+  } 
+  
+  return res
+};

From f1f209d916a403cac1a700512b14bac7f58ce01e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Aug 2021 12:02:44 +0800
Subject: [PATCH 1627/3374] Create 1987-number-of-unique-good-subsequences.js

---
 1987-number-of-unique-good-subsequences.js | 52 ++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 1987-number-of-unique-good-subsequences.js

diff --git a/1987-number-of-unique-good-subsequences.js b/1987-number-of-unique-good-subsequences.js
new file mode 100644
index 00000000..e2aa2fb4
--- /dev/null
+++ b/1987-number-of-unique-good-subsequences.js
@@ -0,0 +1,52 @@
+/**
+ * @param {string} binary
+ * @return {number}
+ */
+const numberOfUniqueGoodSubsequences = function (binary) {
+  const n = binary.length,
+    P = 1e9 + 7
+  let first1Position = -1,
+    first0Position = -1
+  for (let i = 0; i < binary.length; i++) {
+    if (binary[i] === '0' && first0Position == -1) {
+      first0Position = i
+    }
+    if (binary[i] === '1' && first1Position == -1) {
+      first1Position = i
+    }
+    if(first0Position !== -1 && first1Position !== -1) break
+  }
+  if (first1Position === -1) return 1
+  if (first0Position === -1) return n
+
+  const next0 = new Array(n).fill(0)
+  const next1 = new Array(n).fill(0)
+  let nextZero = -1,
+    nextOne = -1
+  for (let i = binary.length - 1; i >= 0; i--) {
+    next0[i] = nextZero
+    next1[i] = nextOne
+    if (binary[i] === '0') {
+      nextZero = i
+    } else {
+      nextOne = i
+    }
+  }
+  const dp = new Array(n).fill(-1)
+  return (1 + fn(first1Position)) % P
+
+  function fn(index) {
+    if (index == n) return 0
+    if (dp[index] !== -1) return dp[index]
+    let result = 1
+    if (next0[index] >= 0) {
+      result += fn(next0[index])
+      result %= P
+    }
+    if (next1[index] >= 0) {
+      result += fn(next1[index])
+      result %= P
+    }
+    return (dp[index] = result)
+  }
+}

From 29ab25a2b987815af8e46cc2be1deeb19267405e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Aug 2021 12:03:19 +0800
Subject: [PATCH 1628/3374] Create
 1986-minimum-number-of-work-sessions-to-finish-the-tasks.js

---
 ...er-of-work-sessions-to-finish-the-tasks.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1986-minimum-number-of-work-sessions-to-finish-the-tasks.js

diff --git a/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
new file mode 100644
index 00000000..e3e4b07a
--- /dev/null
+++ b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} tasks
+ * @param {number} sessionTime
+ * @return {number}
+ */
+const minSessions = function(tasks, sessionTime) {
+  const n = tasks.length
+  const dp = Array.from({ length: 1 << 14 }, () => Array(16).fill(-1))
+  return fn(0, 0)
+  
+  function fn(mask, consumed) {
+    if (mask === (1 << n) - 1) {
+      return consumed === 0 ? 0 : 1
+    }
+    if (dp[mask][consumed] !== -1) {
+     return dp[mask][consumed];
+    }
+
+    let result = Number.MAX_VALUE;
+    if (consumed > 0) {
+        result = Math.min(result, 1 + fn(mask, 0));
+    }
+    for (let i = 0; i < n; i++) {
+        if ((mask & (1 << i)) === 0 && consumed + tasks[i] <= sessionTime) {
+            result = Math.min(result, fn(mask | (1 << i), consumed + tasks[i]));
+        }
+    }
+    return dp[mask][consumed] = result;
+  }
+};

From f89ee0ee0e282d28cbd8d828235f04966e47e36a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Aug 2021 12:03:56 +0800
Subject: [PATCH 1629/3374] Create
 1985-find-the-kth-largest-integer-in-the-array.js

---
 1985-find-the-kth-largest-integer-in-the-array.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1985-find-the-kth-largest-integer-in-the-array.js

diff --git a/1985-find-the-kth-largest-integer-in-the-array.js b/1985-find-the-kth-largest-integer-in-the-array.js
new file mode 100644
index 00000000..3b542d53
--- /dev/null
+++ b/1985-find-the-kth-largest-integer-in-the-array.js
@@ -0,0 +1,9 @@
+/**
+ * @param {string[]} nums
+ * @param {number} k
+ * @return {string}
+ */
+const kthLargestNumber = function(nums, k) {
+  nums.sort((a, b) => BigInt(b) - BigInt(a) === 0n ? 0 : (BigInt(b) - BigInt(a) > 0n ? 1 : -1) )
+  return nums[k - 1]
+};

From c0bd9e10e91392e0c859c0d7d43867e5a7d49c6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Aug 2021 12:04:26 +0800
Subject: [PATCH 1630/3374] Create
 1984-minimum-difference-between-highest-and-lowest-of-k-scores.js

---
 ...ence-between-highest-and-lowest-of-k-scores.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1984-minimum-difference-between-highest-and-lowest-of-k-scores.js

diff --git a/1984-minimum-difference-between-highest-and-lowest-of-k-scores.js b/1984-minimum-difference-between-highest-and-lowest-of-k-scores.js
new file mode 100644
index 00000000..fb38f96a
--- /dev/null
+++ b/1984-minimum-difference-between-highest-and-lowest-of-k-scores.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minimumDifference = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let res = Infinity
+  for(let i = 0, n = nums.length; i < n - k + 1; i++) {
+    res = Math.min(res, nums[i + k - 1] - nums[i])
+  }
+  
+  return res
+  
+};

From 2e6f0f2042afaf76421708a6f671d15f087a3da1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Aug 2021 21:22:44 +0800
Subject: [PATCH 1631/3374] Update 1987-number-of-unique-good-subsequences.js

---
 1987-number-of-unique-good-subsequences.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1987-number-of-unique-good-subsequences.js b/1987-number-of-unique-good-subsequences.js
index e2aa2fb4..9cc21f0f 100644
--- a/1987-number-of-unique-good-subsequences.js
+++ b/1987-number-of-unique-good-subsequences.js
@@ -50,3 +50,25 @@ const numberOfUniqueGoodSubsequences = function (binary) {
     return (dp[index] = result)
   }
 }
+
+// another
+
+/**
+ * @param {string} binary
+ * @return {number}
+ */
+const numberOfUniqueGoodSubsequences = function (binary) {
+  const n = binary.length,
+    mod = 1e9 + 7
+  let hasZero = 0, ends1 = 0, ends0 = 0
+  for(let ch of binary) {
+    if(ch === '1') {
+      ends1 = (ends1 + ends0 + 1) % mod
+    } else {
+      ends0 = (ends1 + ends0) % mod
+      hasZero = 1
+    }
+  }
+  return (ends1 + ends0 + hasZero) % mod
+}
+

From 80552c5ff923485227b68480fe55ad7ac31b08a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Aug 2021 09:27:30 +0800
Subject: [PATCH 1632/3374] Update 647-palindromic-substrings.js

---
 647-palindromic-substrings.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/647-palindromic-substrings.js b/647-palindromic-substrings.js
index 177cd7b5..ebf640e7 100755
--- a/647-palindromic-substrings.js
+++ b/647-palindromic-substrings.js
@@ -30,3 +30,35 @@ const countSubstrings = function(s) {
 
 console.log(countSubstrings("abc"));
 console.log(countSubstrings("aaa"));
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countSubstrings = function(s) {
+  const arr = manachers(s)
+  return arr.map(e => ~~((e + 1) / 2)).reduce((ac, e) => ac + e, 0)
+};
+
+function manachers(s) {
+  const str = `@#${s.split('').join('#')}#$`
+  const arr = Array(str.length).fill(0)
+  
+  let center = right = 0
+  for(let i = 1, n = str.length; i < n - 1; i++) {
+    if(i < right) {
+      arr[i] = Math.min(right - i, arr[2 * center - i])
+    }
+    while(str[i + arr[i] + 1] === str[i - arr[i] - 1]) {
+      arr[i] += 1
+    }
+    if(i + arr[i] > right) {
+      center = i
+      right = i + arr[i]
+    }
+  }
+  
+  return arr
+}

From c1dd84ac4882c170c85603f7f001f5de1aa6a5e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Aug 2021 19:41:45 +0800
Subject: [PATCH 1633/3374] Create
 1960-maximum-product-of-the-length-of-two-palindromic-substrings.js

---
 ...he-length-of-two-palindromic-substrings.js | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 1960-maximum-product-of-the-length-of-two-palindromic-substrings.js

diff --git a/1960-maximum-product-of-the-length-of-two-palindromic-substrings.js b/1960-maximum-product-of-the-length-of-two-palindromic-substrings.js
new file mode 100644
index 00000000..7651f1eb
--- /dev/null
+++ b/1960-maximum-product-of-the-length-of-two-palindromic-substrings.js
@@ -0,0 +1,59 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxProduct = function (s) {
+  const t1 = helper(s),
+    t2 = helper(reverse(s))
+  let res = 0
+  for (let n = s.length, i = 0, j = n - 2; i < n - 1; ++i, --j)
+    res = Math.max(res, t1[i] * t2[j])
+
+  return res
+}
+function reverse(s) {
+  return [...s].reverse().join('')
+}
+function helper(s) {
+  const man = manachers(s).filter(
+    (e, i, ar) => i >= 2 && i < ar.length - 2 && i % 2 === 0
+  )
+  const n = s.length,
+    { max } = Math
+  const ints = man.map((e, i) => [i - ~~(e / 2), i + ~~(e / 2)])
+  const arr = Array(n).fill(0)
+  for (const [a, b] of ints) {
+    arr[b] = max(arr[b], b - a + 1)
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    arr[i] = max(arr[i], arr[i + 1] - 2)
+  }
+  let tmp = 0
+  for (let i = 0; i < n; i++) {
+    if (arr[i] > tmp) {
+      tmp = arr[i]
+    } else arr[i] = tmp
+  }
+  return arr
+}
+function manachers(s) {
+  const str = `@#${s.split('').join('#')}#$`
+  const arr = Array(str.length).fill(0)
+
+  let center = 0,
+    right = 0
+  for (let i = 1, n = str.length; i < n - 1; i++) {
+    if (i < right) {
+      arr[i] = Math.min(right - i, arr[2 * center - i])
+    }
+    while (str[i + arr[i] + 1] === str[i - arr[i] - 1]) {
+      arr[i] += 1
+    }
+    if (i + arr[i] > right) {
+      center = i
+      right = i + arr[i]
+    }
+  }
+
+  return arr
+}

From 22605ba5994135c42d7f88734b6abb1c83a8c0dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Aug 2021 10:07:15 +0800
Subject: [PATCH 1634/3374] Update 214-shortest-palindrome.js

---
 214-shortest-palindrome.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/214-shortest-palindrome.js b/214-shortest-palindrome.js
index fce3267e..a278095f 100644
--- a/214-shortest-palindrome.js
+++ b/214-shortest-palindrome.js
@@ -50,3 +50,37 @@ function getFail(s) {
   return table
 }
 
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const shortestPalindrome = function(s) {
+  const tmp = `${s}#${reverse(s)}`
+  const table = kmp(tmp)
+  return `${reverse(s.slice(table[table.length - 1]))}${s}`
+};
+function reverse(str) {
+  return [...str].reverse().join('')
+}
+
+function kmp(s) {
+  const n = s.length, table = Array(n).fill(0)
+  let idx = 0
+  for(let i = 1; i < n; ) {
+    if(s[i] === s[idx]) {
+      idx++
+      table[i] = idx
+      i++
+    } else {
+      if(idx > 0) {
+        idx = table[idx - 1]
+      } else {
+        idx = 0
+        i++
+      }
+    }
+  }
+  return table
+}

From aaf193604fe9606ab56376c9adda2d27c66a32cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Sep 2021 19:56:51 +0800
Subject: [PATCH 1635/3374] Create
 1976-number-of-ways-to-arrive-at-destination.js

---
 ...number-of-ways-to-arrive-at-destination.js | 111 ++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 1976-number-of-ways-to-arrive-at-destination.js

diff --git a/1976-number-of-ways-to-arrive-at-destination.js b/1976-number-of-ways-to-arrive-at-destination.js
new file mode 100644
index 00000000..b6015baa
--- /dev/null
+++ b/1976-number-of-ways-to-arrive-at-destination.js
@@ -0,0 +1,111 @@
+/**
+ * @param {number} n
+ * @param {number[][]} roads
+ * @return {number}
+ */
+const countPaths = function(n, roads) {
+  const graph = {}
+  for(let r of roads) {
+    const [u, v, t] = r
+    if(graph[u] == null) graph[u] = []
+    if(graph[v] == null) graph[v] = []
+    graph[u].push([v, t])
+    graph[v].push([u, t])
+  }
+  
+  return dijkstra(graph, n, 0)
+
+  function dijkstra(graph, n, src) {
+    const dist = Array(n).fill(Infinity)
+    const ways = Array(n).fill(0), mod = 1e9 + 7
+    ways[src] = 1
+    dist[src] = 0
+    const pq = new PriorityQueue((a, b) => a[0] === b[0] ? a[1] < b[1] : a[0] < b[0])
+    pq.push([0, 0])
+    while(!pq.isEmpty()) {
+      const [d, u] = pq.pop()
+      if(d > dist[u]) continue
+      if(graph[u] == null) graph[u] = []
+      for(const [v, time] of graph[u]) {
+        if(dist[v] > d + time) {
+          ways[v] = ways[u]
+          dist[v] = d + time
+          pq.push([dist[v], v])
+        } else if(dist[v] === d + time) {
+          ways[v] = (ways[v] + ways[u]) % mod
+        }
+      }
+    }
+    return ways[n - 1]
+  }
+  
+};
+  
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+

From 4ccc737e0870bb0215064c1fe69ff4cedf768c83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Sep 2021 11:02:25 +0800
Subject: [PATCH 1636/3374] Create 1977-number-of-ways-to-separate-numbers.js

---
 1977-number-of-ways-to-separate-numbers.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1977-number-of-ways-to-separate-numbers.js

diff --git a/1977-number-of-ways-to-separate-numbers.js b/1977-number-of-ways-to-separate-numbers.js
new file mode 100644
index 00000000..71a4a134
--- /dev/null
+++ b/1977-number-of-ways-to-separate-numbers.js
@@ -0,0 +1,21 @@
+function  numberOfCombinations( num) {
+  let dp = Array(3501).fill(0), dpp=Array(3501).fill(0), pf=Array(3501).fill(0), n = num.length, mod = 1000000007;
+  for (let l = 1; l <= n; ++l) {
+       dpp[0] = 1;
+      for (let i = n; i - l > 0; --i)
+          pf[i - 1] = num[i - 1 - l] == num[i - 1] ? pf[i] + 1 : 0;
+      for (let i = 0; i < n; ++i) {
+          dp[i + 1] = dpp[i + 1];
+          if (l <= i + 1 && num[i + 1 - l] != '0') {
+              if (i + 1 - 2 * l >= 0 && (pf[i + 1 - l] >= l || num[i + 1 - l + pf[i + 1 - l]] > num[i + 1 - 2 * l + pf[i + 1 - l]]))                    
+                  dp[i + 1] = (dp[i + 1] + dp[i + 1 - l]) % mod;
+              else
+                  dp[i + 1] = (dp[i + 1] + dpp[i + 1 - l]) % mod;
+          }
+      }
+      let tmp = dpp
+      dpp = dp
+      dp = tmp
+  }    
+  return dpp[n];
+}

From 4ef906fb8f51682bf9df1bee0a1fd73b9909fa29 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Sep 2021 19:57:26 +0800
Subject: [PATCH 1637/3374] Update 1977-number-of-ways-to-separate-numbers.js

---
 1977-number-of-ways-to-separate-numbers.js | 47 +++++++++++++---------
 1 file changed, 29 insertions(+), 18 deletions(-)

diff --git a/1977-number-of-ways-to-separate-numbers.js b/1977-number-of-ways-to-separate-numbers.js
index 71a4a134..a9e2226b 100644
--- a/1977-number-of-ways-to-separate-numbers.js
+++ b/1977-number-of-ways-to-separate-numbers.js
@@ -1,21 +1,32 @@
-function  numberOfCombinations( num) {
-  let dp = Array(3501).fill(0), dpp=Array(3501).fill(0), pf=Array(3501).fill(0), n = num.length, mod = 1000000007;
+/**
+ * @param {string} num
+ * @return {number}
+ */
+function numberOfCombinations(num) {
+  let dpArr = Array(3501).fill(0),
+    dp = Array(3501).fill(0),
+    prefix = Array(3501).fill(0),
+    n = num.length,
+    mod = 1e9 + 7
   for (let l = 1; l <= n; ++l) {
-       dpp[0] = 1;
-      for (let i = n; i - l > 0; --i)
-          pf[i - 1] = num[i - 1 - l] == num[i - 1] ? pf[i] + 1 : 0;
-      for (let i = 0; i < n; ++i) {
-          dp[i + 1] = dpp[i + 1];
-          if (l <= i + 1 && num[i + 1 - l] != '0') {
-              if (i + 1 - 2 * l >= 0 && (pf[i + 1 - l] >= l || num[i + 1 - l + pf[i + 1 - l]] > num[i + 1 - 2 * l + pf[i + 1 - l]]))                    
-                  dp[i + 1] = (dp[i + 1] + dp[i + 1 - l]) % mod;
-              else
-                  dp[i + 1] = (dp[i + 1] + dpp[i + 1 - l]) % mod;
-          }
+    dp[0] = 1
+    for (let i = n; i - l > 0; --i)
+      prefix[i - 1] = num[i - 1 - l] === num[i - 1] ? prefix[i] + 1 : 0
+    for (let i = 0; i < n; ++i) {
+      dpArr[i + 1] = dp[i + 1]
+      if (l <= i + 1 && num[i + 1 - l] != '0') {
+        if (
+          i + 1 - 2 * l >= 0 &&
+          (prefix[i + 1 - l] >= l ||
+            num[i + 1 - l + prefix[i + 1 - l]] > num[i + 1 - 2 * l + prefix[i + 1 - l]])
+        )
+          dpArr[i + 1] = (dpArr[i + 1] + dpArr[i + 1 - l]) % mod
+        else dpArr[i + 1] = (dpArr[i + 1] + dp[i + 1 - l]) % mod
       }
-      let tmp = dpp
-      dpp = dp
-      dp = tmp
-  }    
-  return dpp[n];
+    }
+    const tmp = dp
+    dp = dpArr
+    dpArr = tmp
+  }
+  return dp[n]
 }

From 89bacef77120b2e70d35d8cb8d5dedf6e2a29cf4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Sep 2021 08:30:43 +0800
Subject: [PATCH 1638/3374] Create
 1385-find-the-distance-value-between-two-arrays.js

---
 ...d-the-distance-value-between-two-arrays.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1385-find-the-distance-value-between-two-arrays.js

diff --git a/1385-find-the-distance-value-between-two-arrays.js b/1385-find-the-distance-value-between-two-arrays.js
new file mode 100644
index 00000000..0e2d726a
--- /dev/null
+++ b/1385-find-the-distance-value-between-two-arrays.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @param {number} d
+ * @return {number}
+ */
+const findTheDistanceValue = function(arr1, arr2, d) {
+  let res = 0
+  for(let i = 0, m = arr1.length; i < m; i++) {
+    let tmp = false, cur = arr1[i]
+    for(let j = 0, n = arr2.length; j < n; j++) {
+      if(Math.abs(cur - arr2[j]) <= d) {
+        tmp = true
+        break
+      }
+    }
+    if(!tmp) res++ 
+  }
+  
+  return res
+};

From 05d394c230e9e8a7f82292bfe500afccf3b1948b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Sep 2021 08:48:02 +0800
Subject: [PATCH 1639/3374] Create
 1475-final-prices-with-a-special-discount-in-a-shop.js

---
 ...rices-with-a-special-discount-in-a-shop.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1475-final-prices-with-a-special-discount-in-a-shop.js

diff --git a/1475-final-prices-with-a-special-discount-in-a-shop.js b/1475-final-prices-with-a-special-discount-in-a-shop.js
new file mode 100644
index 00000000..55eb5749
--- /dev/null
+++ b/1475-final-prices-with-a-special-discount-in-a-shop.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} prices
+ * @return {number[]}
+ */
+const finalPrices = function(prices) {
+  const res = [], n = prices.length
+  for(let i = 0; i < n; i++) {
+    const cur = prices[i]
+    let dis = null
+    for(let j = i + 1; j < n; j++) {
+      if(prices[j] <= cur) {
+        dis = prices[j]
+        break
+      }
+    }
+    res.push(dis == null ? cur : cur - dis)
+  }
+  return res
+};

From 5a3d816ca5a191f134745668d4bcfe8a37776ab0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Sep 2021 18:30:03 +0800
Subject: [PATCH 1640/3374] Create 1995-count-special-quadruplets.js

---
 1995-count-special-quadruplets.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1995-count-special-quadruplets.js

diff --git a/1995-count-special-quadruplets.js b/1995-count-special-quadruplets.js
new file mode 100644
index 00000000..419f45f2
--- /dev/null
+++ b/1995-count-special-quadruplets.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countQuadruplets = function(nums) {
+  let res = 0
+  for(let a = 0, n = nums.length; a < n - 3; a++) {
+    for(let b = a + 1; b < n - 2; b++) {
+      for(let c = b + 1; c < n - 1; c++) {
+        for(let d = c + 1; d < n; d++) {
+          if(nums[a] + nums[b] + nums[c] === nums[d]) res++
+        }
+      }
+    }
+  }
+  
+  
+  return res
+  
+};

From 7a7306bd76bb95a6d4cd64932768871f3f0dfe05 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Sep 2021 18:30:41 +0800
Subject: [PATCH 1641/3374] Create
 1996-the-number-of-weak-characters-in-the-game.js

---
 ...e-number-of-weak-characters-in-the-game.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1996-the-number-of-weak-characters-in-the-game.js

diff --git a/1996-the-number-of-weak-characters-in-the-game.js b/1996-the-number-of-weak-characters-in-the-game.js
new file mode 100644
index 00000000..a68458a7
--- /dev/null
+++ b/1996-the-number-of-weak-characters-in-the-game.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} properties
+ * @return {number}
+ */
+const numberOfWeakCharacters = function(properties) {
+    if (properties == null || properties.length == 0) {
+        return 0;
+    }
+    properties.sort((o1, o2) => {
+        if (o1[0] == o2[0]) {
+            return o1[1] - o2[1];
+        }
+        return o1[0] - o2[0];
+    });
+  const { max } = Math
+    let mmax = Array(1e5 + 10).fill( 0);
+    let ans = 0;
+    let n = properties.length;
+    for (let i = n - 1; i >= 0; i--) mmax[properties[i][0]] = max(properties[i][1], mmax[properties[i][0]]);
+    for (let i = 1e5; i >= 1; i--) mmax[i] = max(mmax[i], mmax[i + 1]);
+    for (let i = 0; i < n; i++) {
+        if (mmax[properties[i][0] + 1] > properties[i][1]) ans++;
+    }
+    return ans;
+};

From 07960056163855686f2a900c05220a604060c74e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Sep 2021 18:31:34 +0800
Subject: [PATCH 1642/3374] Create
 1997-first-day-where-you-have-been-in-all-the-rooms.js

---
 ...day-where-you-have-been-in-all-the-rooms.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1997-first-day-where-you-have-been-in-all-the-rooms.js

diff --git a/1997-first-day-where-you-have-been-in-all-the-rooms.js b/1997-first-day-where-you-have-been-in-all-the-rooms.js
new file mode 100644
index 00000000..815c676c
--- /dev/null
+++ b/1997-first-day-where-you-have-been-in-all-the-rooms.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nextVisit
+ * @return {number}
+ */
+const firstDayBeenInAllRooms = function(nextVisit) {
+        const P = 1e9+7;
+        const n = nextVisit.length;
+        const f = Array(n).fill(0) ;
+        f[0] = 0;
+
+        for (let i = 1; i < n; i++) {
+            f[i] = ((
+                    (2 * f[i - 1]) % P
+                            + P - f[nextVisit[i - 1]]) % P + 2) % P;
+        }
+
+        return f[n - 1];
+};

From 2817bfe21782d06c2aa6cb9b3d44c37ca3ec9704 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Sep 2021 18:32:08 +0800
Subject: [PATCH 1643/3374] Create 1998-gcd-sort-of-an-array.js

---
 1998-gcd-sort-of-an-array.js | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 1998-gcd-sort-of-an-array.js

diff --git a/1998-gcd-sort-of-an-array.js b/1998-gcd-sort-of-an-array.js
new file mode 100644
index 00000000..55c9526d
--- /dev/null
+++ b/1998-gcd-sort-of-an-array.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const gcdSort = function(nums) {
+  const spf = Array(nums.length).fill(0)
+         let maxNum = Math.max(...nums);
+        sieve(maxNum);
+
+        const uf = new UnionFind(maxNum+1);
+        for (let x of nums) {
+            for (let f of getFactors(x)) uf.union(f, x);          
+        }
+
+
+        const sortedArr = nums.slice();
+        sortedArr.sort((a, b) => a - b)
+
+        for (let i = 0; i < nums.length; ++i) {
+            let pu = uf.find(sortedArr[i]);
+            let pv = uf.find(nums[i]);
+            if (pu != pv) return false; // can't swap nums[i] with sortedArr[i]
+        }
+        return true;
+  
+  function sieve( n) { // O(Nlog(logN)) ~ O(N)
+    for (let i = 2; i <= n; ++i) spf[i] = i;
+    for (let i = 2; i * i <= n; i++) {
+      if (spf[i] != i) continue; // skip if `i` is not a prime number
+      for (let j = i * i; j <= n; j += i) {
+        if (spf[j] == j) { // marking spf[j] if it is not previously marked
+          spf[j] = i;
+        }
+      }
+    }
+  }
+  
+  function getFactors(n) { // O(logN)
+    const factors = [];
+    while (n > 1) {
+      factors.push(spf[n]);
+      n = ~~(n /spf[n]);
+    }
+    return factors;
+  }
+};
+
+function gcd( x,  y) {
+    return y == 0 ? x : gcd(y, x % y);
+}
+
+class UnionFind {
+    constructor(n) {
+        this.parent = [];
+        for (let i = 0; i < n; i++) this.parent[i] = i;
+    }
+    find(x) {
+        if (x == this.parent[x]) return x;
+        return this.parent[x] = this.find(this.parent[x]); // Path compression
+    }
+    union( u,  v) {
+        let pu = this.find(u), pv = this.find(v);
+        if (pu != pv) this.parent[pu] = pv;
+    }
+};
+

From e32d4a6e6426b7cc94176fd3824d985a54ca4aed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Sep 2021 20:55:25 +0800
Subject: [PATCH 1644/3374] Create 1757-recyclable-and-low-fat-products.sql

---
 1757-recyclable-and-low-fat-products.sql | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 1757-recyclable-and-low-fat-products.sql

diff --git a/1757-recyclable-and-low-fat-products.sql b/1757-recyclable-and-low-fat-products.sql
new file mode 100644
index 00000000..cec82c14
--- /dev/null
+++ b/1757-recyclable-and-low-fat-products.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT product_id FROM Products WHERE low_fats = 'Y' AND recyclable = 'Y' ORDER BY 1 ASC;

From 64ee05e7e30de5e91269d85b5efca3a35441e242 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Sep 2021 21:04:35 +0800
Subject: [PATCH 1645/3374] Create 1380-lucky-numbers-in-a-matrix.js

---
 1380-lucky-numbers-in-a-matrix.js | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1380-lucky-numbers-in-a-matrix.js

diff --git a/1380-lucky-numbers-in-a-matrix.js b/1380-lucky-numbers-in-a-matrix.js
new file mode 100644
index 00000000..65055f5e
--- /dev/null
+++ b/1380-lucky-numbers-in-a-matrix.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number[]}
+ */
+const luckyNumbers  = function(matrix) {
+  const m = matrix.length, n = matrix[0].length
+  const res = []
+  for(let i = 0; i < m; i++) {
+    let tmp = [i, 0, matrix[i][0]]
+    for(let j = 1; j < n; j++) {
+      if(matrix[i][j] < tmp[2]) {
+        tmp = [i, j, matrix[i][j]]
+      }
+    }
+    res.push(tmp)
+  }
+  
+  const ans = []
+  for(let [r, c, v] of res) {
+    let found = false
+    for(let i = 0; i < m; i++) {
+      if(i !== r && matrix[i][c] > v) {
+        found = true
+        break
+      }
+    }
+    
+    if(found === false) ans.push(v)
+  } 
+  
+  return ans
+};

From 894a06434d963031bb68d5fa43f4704cf3f5fc4d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Sep 2021 21:36:47 +0800
Subject: [PATCH 1646/3374] Create
 1576-replace-all-s-to-avoid-consecutive-repeating-characters.js

---
 ...-avoid-consecutive-repeating-characters.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1576-replace-all-s-to-avoid-consecutive-repeating-characters.js

diff --git a/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js b/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js
new file mode 100644
index 00000000..b6c76f9b
--- /dev/null
+++ b/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const modifyString = function(s) {
+  const arr = s.split('')
+  for(let i = 0, n = s.length; i < n; i++) {
+    const cur = arr[i]
+    if(cur === '?') {
+      for(let j = 0, a = 'a'.charCodeAt(0); j < 26; j++) {
+        const ch = String.fromCharCode(a + j)
+        if(
+          n === 1 ||
+          (i === 0 && i < n - 1 && ch !== arr[i + 1]) ||
+          (i > 0 && ch !== arr[i - 1] && i < n - 1 && ch !== arr[i + 1]) ||
+          (i=== n -1 && i - 1 >= 0 && ch !== arr[i - 1])
+        ) {
+          
+          arr[i] = ch
+          break
+        }
+      }
+    }
+  }
+  
+  return arr.join('')
+};

From bd9e4f991f262548f7ef8a279bc305ced3c3fe74 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Sep 2021 21:42:10 +0800
Subject: [PATCH 1647/3374] Update
 1576-replace-all-s-to-avoid-consecutive-repeating-characters.js

---
 ...-avoid-consecutive-repeating-characters.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js b/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js
index b6c76f9b..51a743c9 100644
--- a/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js
+++ b/1576-replace-all-s-to-avoid-consecutive-repeating-characters.js
@@ -25,3 +25,32 @@ const modifyString = function(s) {
   
   return arr.join('')
 };
+
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const modifyString = function(s) {
+  const arr = s.split('')
+  for(let i = 0, n = s.length; i < n; i++) {
+    const cur = arr[i]
+    if(cur === '?') {
+      for(let j = 0, a = 'a'.charCodeAt(0); j < 26; j++) {
+        const ch = String.fromCharCode(a + j)
+        if(
+          (i === 0 || arr[i - 1] !== ch) &&
+          (i === n - 1 || arr[i + 1] !== ch)
+        ) {
+          
+          arr[i] = ch
+          break
+        }
+      }
+    }
+  }
+  
+  return arr.join('')
+};

From 8e9e2646f1c46cdd4927af182312e80133d8fa52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Sep 2021 21:33:33 +0800
Subject: [PATCH 1648/3374] Update 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 41 +++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
index 8a7b0120..a7d7c2c5 100644
--- a/1655-distribute-repeating-integers.js
+++ b/1655-distribute-repeating-integers.js
@@ -70,3 +70,44 @@ const canDistribute = function (nums, quantity) {
     return (dp[idx][mask] = ans)
   }
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[]} quantity
+ * @return {boolean}
+ */
+const canDistribute = function(nums, quantity) {
+  const freq = {}
+  for(let e of nums) freq[e] = (freq[e] || 0) + 1
+  const fArr = Object.values(freq)
+
+  const m = quantity.length, n = fArr.length
+  const dp = Array.from({ length: n }, () => Array(1 << m).fill(-1))
+  
+  return solve(0, 0)
+  
+  function solve(idx, mask) {
+    if(mask === (1 << m) - 1) return 1
+    if(idx === n) return 0
+    if(dp[idx][mask] !== -1) return dp[idx][mask]
+    
+    let res = solve(idx + 1, mask)
+    for(let i = 0; i < (1 << m); i++) {
+      if(mask !== (mask & i)) continue
+      let tmp = mask
+      let sum = 0
+      for(let j = 0; j < m; j++) {
+        if(mask & (1 << j)) continue
+        if(i & (1 << j)) {
+          sum += quantity[j]
+          tmp |= (1 << j)
+        }
+      }
+      if(sum <= fArr[idx]) res |= solve(idx + 1, tmp)
+    }
+    
+    return dp[idx][mask] = res
+  }
+};

From cfa4ebc50e7e7755f5685fc7df89d2b05db7582a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Sep 2021 19:26:35 +0800
Subject: [PATCH 1649/3374] Update 940-distinct-subsequences-ii.js

---
 940-distinct-subsequences-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/940-distinct-subsequences-ii.js b/940-distinct-subsequences-ii.js
index ba309c5a..723acd12 100644
--- a/940-distinct-subsequences-ii.js
+++ b/940-distinct-subsequences-ii.js
@@ -1,3 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const distinctSubseqII = function(s) {
+  const n = s.length,
+    dp = Array(26).fill(0),
+    a = 'a'.charCodeAt(0),
+    mod = 1e9 + 7
+  let res = 0
+  for(let ch of s) {
+    const idx = ch.charCodeAt(0) - a
+    let tmp = 0
+    for(let i = 0; i < 26; i++) tmp = (tmp + dp[i]) % mod
+    tmp = (tmp + 1) % mod
+    dp[idx] = tmp
+  }
+  return dp.reduce((ac, e) => (ac + e) % mod, 0)
+};
+
+// another
+
 /**
  * @param {string} S
  * @return {number}

From a394e51d269c4100d608f815785b273d2c76e692 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Sep 2021 10:47:29 +0800
Subject: [PATCH 1650/3374] Create 1994-the-number-of-good-subsets.js

---
 1994-the-number-of-good-subsets.js | 94 ++++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 1994-the-number-of-good-subsets.js

diff --git a/1994-the-number-of-good-subsets.js b/1994-the-number-of-good-subsets.js
new file mode 100644
index 00000000..8ca7236d
--- /dev/null
+++ b/1994-the-number-of-good-subsets.js
@@ -0,0 +1,94 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numberOfGoodSubsets = function (nums) {
+  const primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+  const n = nums.length,
+    cnt = {},
+    mod = BigInt(1e9 + 7)
+  const bm = []
+  for (let num of nums) {
+    cnt[num] = (cnt[num] || 0n) + 1n
+  }
+  for (let i = 0; i < 31; i++) {
+    let tmp = 0
+    for (let j = 0, m = primes.length; j < m; j++) {
+      const p = primes[j]
+      if (i % p === 0) tmp += 1 << j
+    }
+    bm[i] = tmp
+  }
+  const bad = new Set([4, 8, 9, 12, 16, 18, 20, 24, 25, 27, 28])
+  const memo = {}
+
+  function dp(mask, num) {
+    if (num === 1) return 1n
+    if (memo[mask] && memo[mask][num] != null) return memo[mask][num]
+    let res = dp(mask, num - 1)
+    if (!bad.has(num) && (mask | bm[num]) === mask) {
+      res += dp(mask ^ bm[num], num - 1) * (cnt[num] || 0n)
+    }
+    if (memo[mask] == null) memo[mask] = {}
+    return (memo[mask][num] = res % mod)
+  }
+
+  return ((dp(1023, 30) - 1n) * pow(2n, cnt[1] || 0n, mod)) % mod
+}
+
+function pow(base, exp, mod) {
+  if (exp === 0n) return 1n
+  // console.log(base, mod)
+  base %= mod
+  let res = pow(base, exp / 2n, mod)
+  res = (res * res) % mod
+  if (exp & 1n) res = (res * base) % mod
+  return res
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numberOfGoodSubsets = function (nums) {
+  const primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+  const n = nums.length,
+    cnt = {},
+    mod = BigInt(1e9 + 7)
+  const bm = []
+  for (let num of nums) {
+    cnt[num] = (cnt[num] || 0n) + 1n
+  }
+  for (let i = 0; i < 31; i++) {
+    let tmp = 0
+    for (let j = 0, m = primes.length; j < m; j++) {
+      const p = primes[j]
+      if (i % p === 0) tmp += 1 << j
+    }
+    bm[i] = tmp
+  }
+  const bad = new Set([4, 8, 9, 12, 16, 18, 20, 24, 25, 27, 28])
+  const memo = {}
+
+  function dp(mask, num) {
+    if (num === 1) return 1n
+    if (memo[mask] && memo[mask][num] != null) return memo[mask][num]
+    let res = dp(mask, num - 1)
+    if (!bad.has(num) && (mask | bm[num]) === mask) {
+      res += dp(mask ^ bm[num], num - 1) * (cnt[num] || 0n)
+    }
+    if (memo[mask] == null) memo[mask] = {}
+    return (memo[mask][num] = res % mod)
+  }
+
+  return ((dp(1023, 30) - 1n) * pow(2n, cnt[1] || 0n, mod)) % mod
+}
+
+function pow(base, exp, mod) {
+  if (exp === 0n) return 1n
+  // console.log(base, mod)
+  base %= mod
+  let res = pow(base, exp / 2n, mod)
+  res = (res * res) % mod
+  if (exp & 1n) res = (res * base) % mod
+  return res
+}

From 436d514b966ae8431971d1eae5bd537caa36d12c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Sep 2021 11:17:27 +0800
Subject: [PATCH 1651/3374] Update
 1996-the-number-of-weak-characters-in-the-game.js

---
 ...he-number-of-weak-characters-in-the-game.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1996-the-number-of-weak-characters-in-the-game.js b/1996-the-number-of-weak-characters-in-the-game.js
index a68458a7..631ae293 100644
--- a/1996-the-number-of-weak-characters-in-the-game.js
+++ b/1996-the-number-of-weak-characters-in-the-game.js
@@ -23,3 +23,21 @@ const numberOfWeakCharacters = function(properties) {
     }
     return ans;
 };
+
+// another
+
+/**
+ * @param {number[][]} properties
+ * @return {number}
+ */
+const numberOfWeakCharacters = function(properties) {
+  properties.sort((a, b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])
+  let max = -Infinity, res = 0
+  for(let n = properties.length, i = n - 1; i >= 0; i--) {
+    const [a, d] = properties[i]
+    if(d < max) res++
+    max = Math.max(max, d)
+  }
+  
+  return res
+};

From a3aa4bbf5f58c39c024f630766b2f66bae15f0e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Sep 2021 11:38:27 +0800
Subject: [PATCH 1652/3374] Update
 1996-the-number-of-weak-characters-in-the-game.js

---
 ...e-number-of-weak-characters-in-the-game.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1996-the-number-of-weak-characters-in-the-game.js b/1996-the-number-of-weak-characters-in-the-game.js
index 631ae293..e5ea1f78 100644
--- a/1996-the-number-of-weak-characters-in-the-game.js
+++ b/1996-the-number-of-weak-characters-in-the-game.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[][]} properties
+ * @return {number}
+ */
+const numberOfWeakCharacters = function(properties) {
+  properties.sort((a, b) => a[0] - b[0] || b[1] - a[1])
+  let stack = [], res = 0
+
+  for(let i = 0, n = properties.length; i < n; i++) {
+    while(stack.length && stack[stack.length - 1] < properties[i][1]) {
+      stack.pop()
+      res++
+    }
+    stack.push(properties[i][1])
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} properties
  * @return {number}

From bfb0fbc3bd3d6638e81a4056db081675783ff807 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Sep 2021 19:08:41 +0800
Subject: [PATCH 1653/3374] Create 2000-reverse-prefix-of-word.js

---
 2000-reverse-prefix-of-word.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2000-reverse-prefix-of-word.js

diff --git a/2000-reverse-prefix-of-word.js b/2000-reverse-prefix-of-word.js
new file mode 100644
index 00000000..3553e662
--- /dev/null
+++ b/2000-reverse-prefix-of-word.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} word
+ * @param {character} ch
+ * @return {string}
+ */
+const reversePrefix = function(word, ch) {
+  const arr = word.split('')
+  let idx = -1
+  for(let i = 0; i < arr.length; i++) {
+    if(arr[i] === ch) {
+      idx = i
+      break
+    }
+  }
+  if(idx !== -1) {
+    const pre = arr.slice(0, idx + 1)
+    const remain = arr.slice(idx + 1)
+    return pre.reverse().concat(remain).join('')
+  }
+  return word
+};

From 93dd34e5514bab2e010ce76196d210e640ee2278 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Sep 2021 19:09:10 +0800
Subject: [PATCH 1654/3374] Create
 2001-number-of-pairs-of-interchangeable-rectangles.js

---
 ...er-of-pairs-of-interchangeable-rectangles.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2001-number-of-pairs-of-interchangeable-rectangles.js

diff --git a/2001-number-of-pairs-of-interchangeable-rectangles.js b/2001-number-of-pairs-of-interchangeable-rectangles.js
new file mode 100644
index 00000000..bd69e8ad
--- /dev/null
+++ b/2001-number-of-pairs-of-interchangeable-rectangles.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[][]} rectangles
+ * @return {number}
+ */
+const interchangeableRectangles = function(rectangles) {
+    const count = new Map()
+
+    for (const [w, h] of rectangles) {
+      count.set( w / h, 1 + (count.get( w / h) || 0))
+    }
+
+    let res = 0
+    for (let c of count.values()) {
+      if(c > 1) res += ((c * (c - 1)) / 2)
+    }
+    return res 
+};

From 0a628811bdcd3c921b9805ef6f2375a1b354ed8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Sep 2021 19:09:42 +0800
Subject: [PATCH 1655/3374] Create
 2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js

---
 ...-length-of-two-palindromic-subsequences.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js

diff --git a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
new file mode 100644
index 00000000..ad4a1b79
--- /dev/null
+++ b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var maxProduct = function(s) {
+  const n = s.length;
+  let max = 0;
+  for (let i = 0; i < (1 << n); i++) {
+    let n0 = palindromic(i, s, true);
+    if (n0 === 0) continue;
+    for (let j = 0; j < (1 << n); j++) {
+      if ((i & j) > 0) continue;
+      max = Math.max(palindromic(j, s) * n0, max);
+    }
+  }
+  return max; 
+};
+function palindromic( i, s) {
+  const n = s.length;
+  let sub = "";
+  for (let x = 0; x < n; x++) {
+    if (i & (1 << x)) sub += s[x]
+  }
+  let len = sub.length;
+  for (let i = 0; i < len; i++) {
+    if (sub[i] !== sub[len - i - 1]) return 0;
+  }
+  return len;
+}

From 3512b727a5bbe14c4a1f6c0821c0a3a20dabd05a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Sep 2021 19:10:14 +0800
Subject: [PATCH 1656/3374] Create
 2003-smallest-missing-genetic-value-in-each-subtree.js

---
 ...t-missing-genetic-value-in-each-subtree.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2003-smallest-missing-genetic-value-in-each-subtree.js

diff --git a/2003-smallest-missing-genetic-value-in-each-subtree.js b/2003-smallest-missing-genetic-value-in-each-subtree.js
new file mode 100644
index 00000000..fccbd9db
--- /dev/null
+++ b/2003-smallest-missing-genetic-value-in-each-subtree.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} parents
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const smallestMissingValueSubtree = function(parents, nums) {
+      let n = parents.length;
+      const ans = new Array(n).fill(0);
+      const fn = new Array(100010).fill(0);
+      const tree = [];
+      const nums1 = nums;
+      for(let idx=0;idx<n;idx++) {
+        tree.push([]);
+      }
+      for (let idx=1;idx<n;idx++) {
+        tree[parents[idx]].push(idx);
+      }
+      let nodeIdx = 0;
+      search(0,0);
+      return ans;
+  
+    function search( root,  rec) {
+      let pos = 1;
+      for(let next of tree[root]) {
+        pos = Math.max(pos, search(next, nodeIdx));
+      }
+      nodeIdx++;
+      fn[nums1[root]] = nodeIdx;
+      while(fn[pos]!=0 && fn[pos]>rec && fn[pos]<=nodeIdx) {
+        pos++;
+      }
+      ans[root] = pos;
+      return pos;
+    }
+};
+

From 0885e2da44e8349df29fac8e3233f0ec5ee36a5d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Sep 2021 21:15:19 +0800
Subject: [PATCH 1657/3374] Update
 1997-first-day-where-you-have-been-in-all-the-rooms.js

---
 ...day-where-you-have-been-in-all-the-rooms.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1997-first-day-where-you-have-been-in-all-the-rooms.js b/1997-first-day-where-you-have-been-in-all-the-rooms.js
index 815c676c..8b503fdd 100644
--- a/1997-first-day-where-you-have-been-in-all-the-rooms.js
+++ b/1997-first-day-where-you-have-been-in-all-the-rooms.js
@@ -16,3 +16,21 @@ const firstDayBeenInAllRooms = function(nextVisit) {
 
         return f[n - 1];
 };
+
+// another
+
+/**
+ * @param {number[]} nextVisit
+ * @return {number}
+ */
+const firstDayBeenInAllRooms = function(nextVisit) {
+  const mod = 1e9 + 7
+  const n = nextVisit.length
+  const dp = Array(n).fill(0)
+  for(let i = 1; i < n; i++) {
+    // i - 1 ---> nextVisit[i - 1] ---> i - 1 ---> i
+    dp[i] = (dp[i - 1] + 1 + dp[i - 1] - dp[nextVisit[i - 1]] + 1 + mod) % mod
+  }
+  
+  return dp[n - 1]
+};

From a9848388bae820b65995d96adb87b4114f9c8fcf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Sep 2021 17:05:44 +0800
Subject: [PATCH 1658/3374] Update 169-majority-element.js

---
 169-majority-element.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/169-majority-element.js b/169-majority-element.js
index 857fce5c..5d97af39 100755
--- a/169-majority-element.js
+++ b/169-majority-element.js
@@ -16,3 +16,22 @@ const majorityElement = function(nums) {
     .map(el => +el[0])
     .sort((a, b) => b - a)[0];
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const majorityElement = function(nums) {
+  let cnt = 1, candidate = nums[0]
+  for(let i = 1, n = nums.length; i < n; i++) {
+    if(candidate === nums[i]) cnt++
+    else cnt--
+    if(cnt === 0) {
+      cnt = 1
+      candidate = nums[i]
+    }
+  }
+  return candidate
+};

From 1e67a7bcf60ecac8955ed0598ae860fcb6b17a0c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Sep 2021 17:07:53 +0800
Subject: [PATCH 1659/3374] Update 169-majority-element.js

---
 169-majority-element.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/169-majority-element.js b/169-majority-element.js
index 5d97af39..91f38a94 100755
--- a/169-majority-element.js
+++ b/169-majority-element.js
@@ -35,3 +35,21 @@ const majorityElement = function(nums) {
   }
   return candidate
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const majorityElement = function(nums) {
+  let cnt = 1, candidate = nums[0]
+  for(let i = 1, n = nums.length; i < n; i++) {
+    if(cnt === 0) {
+      cnt = 1
+      candidate = nums[i]
+    }else if(candidate === nums[i]) cnt++
+    else cnt--
+  }
+  return candidate
+};

From 1b562d2fd09a7a6f592399db2c7997ddb1c103f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Sep 2021 22:49:25 +0800
Subject: [PATCH 1660/3374] Create 2012-sum-of-beauty-in-the-array.js

---
 2012-sum-of-beauty-in-the-array.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2012-sum-of-beauty-in-the-array.js

diff --git a/2012-sum-of-beauty-in-the-array.js b/2012-sum-of-beauty-in-the-array.js
new file mode 100644
index 00000000..62f7b28b
--- /dev/null
+++ b/2012-sum-of-beauty-in-the-array.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfBeauties = function(nums) {
+  const n = nums.length
+  const maxArr = Array(n).fill(0), minArr = Array(n).fill(0)
+  let max = -Infinity, min = Infinity
+  for(let i = 0; i < n; i++) {
+    const tmp = Math.max(max, nums[i])
+    if(tmp > max) max = tmp
+    maxArr[i] = max
+  }
+  
+  for(let i = n - 1; i >= 0; i--) {
+    const tmp = Math.min(min, nums[i])
+    if(tmp < min) min = tmp
+    minArr[i] = min
+  }
+  let res = 0
+  
+  for(let i = 1; i < n - 1; i++) {
+    if(nums[i] > maxArr[i - 1] && nums[i] < minArr[i + 1]) res += 2
+    else if(nums[i] > nums[i - 1] && nums[i] < nums[i + 1]) res += 1
+  }
+  
+  return res
+};

From ebbae815c267c183ff28ede2b4d650b8873c808a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Sep 2021 22:49:56 +0800
Subject: [PATCH 1661/3374] Create
 2011-final-value-of-variable-after-performing-operations.js

---
 ...value-of-variable-after-performing-operations.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2011-final-value-of-variable-after-performing-operations.js

diff --git a/2011-final-value-of-variable-after-performing-operations.js b/2011-final-value-of-variable-after-performing-operations.js
new file mode 100644
index 00000000..300d15a4
--- /dev/null
+++ b/2011-final-value-of-variable-after-performing-operations.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string[]} operations
+ * @return {number}
+ */
+const finalValueAfterOperations = function(operations) {
+  let res = 0
+  for(let op of operations) {
+    if(op.indexOf('++') !== -1) res++
+    else res--
+  }
+  
+  return res
+};

From 1ce1ecdec560ee9684117aa1d1fe1f8e99169055 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Sep 2021 23:53:19 +0800
Subject: [PATCH 1662/3374] Create 2013-detect-squares.js

---
 2013-detect-squares.js | 80 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 2013-detect-squares.js

diff --git a/2013-detect-squares.js b/2013-detect-squares.js
new file mode 100644
index 00000000..cf68cf50
--- /dev/null
+++ b/2013-detect-squares.js
@@ -0,0 +1,80 @@
+
+var DetectSquares = function() {
+    this.xMap = new Map();
+    this.yMap = new Map();
+};
+
+/**
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function(point) {
+    const [ x, y ] = point;
+
+    // X-map
+    if (this.xMap.has(x)) {
+        const xMap = this.xMap.get(x);
+
+        if (xMap.has(y)) {
+            xMap.set(y, xMap.get(y) + 1);
+        } else {
+            xMap.set(y, 1);
+        }
+    } else {
+        const countMap = new Map();
+        countMap.set(y, 1);
+        this.xMap.set(x, countMap);
+    }
+
+    // Y-map
+    if (this.yMap.has(y)) {
+        const yMap = this.yMap.get(y);
+
+        if (yMap.has(x)) {
+            yMap.set(x, yMap.get(x) + 1);
+        } else {
+            yMap.set(x, 1);
+        }
+    } else {
+        const countMap = new Map();
+        countMap.set(x, 1);
+        this.yMap.set(y, countMap);
+    }
+};
+
+/**
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function(point) {
+    const [ x, y ] = point;
+    let ans = 0;
+
+    if (this.xMap.has(x) && this.yMap.has(y)) {
+        for (const y2 of this.xMap.get(x).keys()) {
+            if (y === y2) {
+                continue;
+            }
+
+            // Find parallel
+            const sideLen = Math.abs(y - y2);
+            const possibleX = [ x - sideLen, x + sideLen];
+
+            for (const px of possibleX) {
+                if (this.yMap.get(y).has(px) && this.xMap.has(px) && this.xMap.get(px).has(y2)) {
+                    ans += this.xMap.get(x).get(y2) * this.yMap.get(y).get(px)
+                        * this.xMap.get(px).get(y2);
+                }
+            }
+        }
+    }
+
+    return ans;
+};
+
+/** 
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */

From 7b38fc59ab6d86ee3507f979e691e438ede6cb61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Sep 2021 23:54:40 +0800
Subject: [PATCH 1663/3374] Create 2014-longest-subsequence-repeated-k-times.js

---
 2014-longest-subsequence-repeated-k-times.js | 83 ++++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 2014-longest-subsequence-repeated-k-times.js

diff --git a/2014-longest-subsequence-repeated-k-times.js b/2014-longest-subsequence-repeated-k-times.js
new file mode 100644
index 00000000..8767d8f7
--- /dev/null
+++ b/2014-longest-subsequence-repeated-k-times.js
@@ -0,0 +1,83 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+var longestSubsequenceRepeatedK = function(s, k) {
+    // Max length of the subsequence can be determined by the length of the string and k
+    const maxLen = Math.floor(s.length / k);
+
+    // Find all possible characters that can appear in the subsequence (characters must appear at
+    // least k times in s)
+    const charCount = new Map();
+    const possibleChars = []
+
+    for (const char of s) {
+        if (charCount.has(char)) {
+            charCount.set(char, charCount.get(char) + 1);
+        } else {
+            charCount.set(char, 1);
+        }
+    }
+
+    for (const char of charCount.keys()) {
+        if (charCount.get(char) >= k) {
+            possibleChars.push(char);
+        }
+    }
+
+    // Test possibilities
+    let ans = "";
+    dfs("");
+
+    return ans;
+
+    // Recursive function, tests if the given subsequence repeats k times in s
+    function dfs(seq) {
+        // Does not have enough repeats, return
+        if (countRepeats(seq) < k) {
+            return;
+        }
+
+        // Update our answer if the new subsequence is better
+        if (seq.length > ans.length || (seq.length === ans.length && seq > ans)) {
+            ans = seq;
+        }
+
+        // Append possible characters to the subsequence and test again
+        if (seq.length < maxLen) {
+            for (const char of possibleChars) {
+                dfs(seq + char);
+            }
+        }
+    }
+
+    // Counts the number of times the given subsequence repeats in s (up to k)
+    function countRepeats(seq) {
+
+        // Empty string, return k
+        if (!seq) {
+            return k;
+        }
+
+        let repeats = 0;
+        let seqIdx = 0;
+
+        for (const char of s) {
+            if (char === seq[seqIdx]) {
+                seqIdx += 1;
+
+                if (seqIdx >= seq.length) {
+                    seqIdx = 0;
+                    repeats += 1;
+
+                    if (repeats >= k) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        return repeats;
+    } 
+};

From 5375fee8c10850c2de4bb19b5273b41413714668 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Sep 2021 15:33:15 +0800
Subject: [PATCH 1664/3374] Update 2014-longest-subsequence-repeated-k-times.js

---
 2014-longest-subsequence-repeated-k-times.js | 50 ++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/2014-longest-subsequence-repeated-k-times.js b/2014-longest-subsequence-repeated-k-times.js
index 8767d8f7..57941aba 100644
--- a/2014-longest-subsequence-repeated-k-times.js
+++ b/2014-longest-subsequence-repeated-k-times.js
@@ -1,3 +1,53 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const longestSubsequenceRepeatedK = function(s, k) {
+  const n = s.length, a = 'a'.charCodeAt(0)
+  
+  let res = ''
+  const q = ['']
+  
+  while(q.length) {
+    const size = q.length
+    for(let i = 0; i < size; i++) {
+      const cur = q.shift()
+      for(let j = 0; j < 26; j++) {
+        const next = cur + String.fromCharCode(a + j)
+        if(isSub(s, next, k)) {
+          res = next
+          q.push(next)
+        }
+      }
+      
+    }
+  }
+  
+  return res
+  
+  
+  function isSub(s, p, k) {
+    let repeated = 0
+    for(let i = 0, j = 0, n = s.length, m = p.length; i < n; i++) {
+      if(s[i] === p[j]) {
+        j++
+        if(j === m) {
+          repeated++
+          j = 0
+          if(repeated === k) {
+            return true
+          }
+        }
+      }
+    }
+    
+    return false
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {number} k

From 5632cf9cda0c4aba14dbde29fc358da57469c627 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Sep 2021 16:03:29 +0800
Subject: [PATCH 1665/3374] Update 2013-detect-squares.js

---
 2013-detect-squares.js | 42 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2013-detect-squares.js b/2013-detect-squares.js
index cf68cf50..3cb84312 100644
--- a/2013-detect-squares.js
+++ b/2013-detect-squares.js
@@ -1,4 +1,46 @@
 
+const DetectSquares = function() {
+  this.pts = []
+  this.ptsCnt = {}
+};
+
+/** 
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function(point) {
+  this.pts.push(point)
+  const key = `${point[0]},${point[1]}`
+  this.ptsCnt[key] = (this.ptsCnt[key] || 0) + 1
+};
+
+/** 
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function(point) {
+  let res = 0
+  const [px, py] = point
+  for(const [x, y] of this.pts) {
+    if(px === x || py === y || Math.abs(px - x) !== Math.abs(py - y)) {
+       continue
+    }
+    res += (this.ptsCnt[`${px},${y}`] || 0) * (this.ptsCnt[`${x},${py}`] || 0)
+  }
+  
+  return res
+};
+
+/** 
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */
+
+
+// another
+
 var DetectSquares = function() {
     this.xMap = new Map();
     this.yMap = new Map();

From b0427fba3e8e90fafec6255cc2940e3bfe491739 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Sep 2021 09:03:56 +0800
Subject: [PATCH 1666/3374] Update 973-k-closest-points-to-origin.js

---
 973-k-closest-points-to-origin.js | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/973-k-closest-points-to-origin.js b/973-k-closest-points-to-origin.js
index 5e110353..b02f1611 100644
--- a/973-k-closest-points-to-origin.js
+++ b/973-k-closest-points-to-origin.js
@@ -132,3 +132,37 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number[][]}
+ */
+const kClosest = function(points, k) {
+  let len = points.length, l = 0, r = len - 1
+  while (l <= r) {
+    let mid = helper(points, l, r)
+    if (mid === k) break
+    if (mid  < k) l = mid + 1
+    else r = mid - 1
+  }
+  return points.slice(0, k)
+
+  function helper(arr, l, r) {
+    const pivot = arr[l]
+    while(l < r) {
+      while(l < r && cmp(arr[r], pivot) >= 0) r--
+      arr[l] = arr[r]
+      while(l < r && cmp(arr[l], pivot) <= 0) l++
+      arr[r] = arr[l]
+    }
+    arr[l] = pivot
+    return l
+  }
+  
+  function cmp(a, b) {
+    return a[0] * a[0] + a[1] * a[1] - b[0] * b[0] - b[1] * b[1]
+  }
+};

From 2e5b3bf615d4c7cdf8f64ad9e14669f42f7416eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Sep 2021 21:19:34 +0800
Subject: [PATCH 1667/3374] Create 1572-matrix-diagonal-sum.js

---
 1572-matrix-diagonal-sum.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1572-matrix-diagonal-sum.js

diff --git a/1572-matrix-diagonal-sum.js b/1572-matrix-diagonal-sum.js
new file mode 100644
index 00000000..88866342
--- /dev/null
+++ b/1572-matrix-diagonal-sum.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const diagonalSum = function(mat) {
+  let res = 0, n = mat.length
+  for(let i = 0; i < n; i++) {
+    const j = i, ii = i, jj = n - 1 - i
+    if(j == jj) res += mat[i][j]
+    else {
+      res += mat[i][j] + mat[ii][jj]
+    }
+  }
+  
+  return res
+};

From f8657b43083ce05e79f1578672e3cbc1ec324f82 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Sep 2021 21:24:41 +0800
Subject: [PATCH 1668/3374] Create 1331-rank-transform-of-an-array.js

---
 1331-rank-transform-of-an-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1331-rank-transform-of-an-array.js

diff --git a/1331-rank-transform-of-an-array.js b/1331-rank-transform-of-an-array.js
new file mode 100644
index 00000000..11f7335f
--- /dev/null
+++ b/1331-rank-transform-of-an-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+const arrayRankTransform = function(arr) {
+  const hash = {}
+  for(let e of arr) {
+    hash[e] = 1
+  }
+  const keys = Object.keys(hash)
+  keys.sort((a, b) => a - b)
+  const rank = {}
+  for(let i = 0, n= keys.length; i < n; i++) {
+    rank[keys[i]] = i + 1
+  }
+  
+  return arr.map(e => rank[e])
+};

From 118d8ac08d486cc60392ec6b577a71bb41e9fdcd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Sep 2021 09:33:05 +0800
Subject: [PATCH 1669/3374] Update 215-kth-largest-element-in-an-array.js

---
 215-kth-largest-element-in-an-array.js | 36 ++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/215-kth-largest-element-in-an-array.js b/215-kth-largest-element-in-an-array.js
index f8544874..cbf5ce05 100755
--- a/215-kth-largest-element-in-an-array.js
+++ b/215-kth-largest-element-in-an-array.js
@@ -100,4 +100,40 @@ function swap(arr, i, j) {
   arr[j] = tmp
 }
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const findKthLargest = function(nums, k) {
+  const n = nums.length
+  let l = 0, r = n - 1, t = n - k
+  while(l < r) {
+    const idx = partition(nums, l, r)
+    if (idx === t) return nums[t]
+    if (idx < t) l = idx + 1
+    else r = idx - 1
+  }
+  return nums[l]
+};
+
+function partition(arr, l, r) {
+  let tmp = l, pivot = arr[l]
+  while(l < r) {
+    while(l < r && arr[r] >= pivot) r--
+    while(l < r && arr[l] <= pivot) l++
+    swap(arr, l, r)
+  }
+  swap(arr, l, tmp)
+  return l
+}
+
+function swap(arr, i, j) {
+  const tmp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = tmp
+}
+
 

From eac60491e9a4bf1faf828e8da35e4e5f6fa4d9df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Sep 2021 14:41:04 +0800
Subject: [PATCH 1670/3374] Create
 1128-number-of-equivalent-domino-pairsnumber-of-equivalent-domino-pairs.js

---
 ...-pairsnumber-of-equivalent-domino-pairs.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1128-number-of-equivalent-domino-pairsnumber-of-equivalent-domino-pairs.js

diff --git a/1128-number-of-equivalent-domino-pairsnumber-of-equivalent-domino-pairs.js b/1128-number-of-equivalent-domino-pairsnumber-of-equivalent-domino-pairs.js
new file mode 100644
index 00000000..eebd4674
--- /dev/null
+++ b/1128-number-of-equivalent-domino-pairsnumber-of-equivalent-domino-pairs.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} dominoes
+ * @return {number}
+ */
+const numEquivDominoPairs = function(dominoes) {
+  const hash = {}
+  for (let dom of dominoes) {
+    const [a, b] = dom
+    const key = `${a},${b}`, alterKey = `${b},${a}`
+    if (hash[key] == null && hash[alterKey] == null) {
+      hash[key] = 1
+    } else {
+      if(hash[key] != null) hash[key] += 1
+      else hash[alterKey] += 1
+    }
+  }
+
+  let res = 0
+
+  Object.keys(hash).forEach(k => {
+    if(hash[k] > 1) res += sum(hash[k])
+  })
+
+  return res
+};
+
+function sum(n) {
+  let res = 0
+  while(n > 1) {
+    res += n - 1
+    n--
+  }
+  return res
+}

From 8e307d14364e3e5ea248b1542083041fc6481989 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Sep 2021 16:32:42 +0800
Subject: [PATCH 1671/3374] Create
 2009-minimum-number-of-operations-to-make-array-continuous.js

---
 ...-of-operations-to-make-array-continuous.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2009-minimum-number-of-operations-to-make-array-continuous.js

diff --git a/2009-minimum-number-of-operations-to-make-array-continuous.js b/2009-minimum-number-of-operations-to-make-array-continuous.js
new file mode 100644
index 00000000..be0adb9f
--- /dev/null
+++ b/2009-minimum-number-of-operations-to-make-array-continuous.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minOperations = function(nums) {
+  const N = nums.length;
+  if(N === 1) return 0;
+  nums.sort((a, b) => a - b)
+  let M = 1;
+  for(let i = 1; i < N; i++) {
+    if(nums[i] != nums[i-1]) nums[M++] = nums[i];
+  }
+  
+  let j = 0;
+  let ans = N;
+  for(let i = 0; i < M; i++) {
+    while(j < M && nums[j] <= N + nums[i] - 1) j++;
+    ans = Math.min(ans, N - (j - i));
+  }
+  
+  return ans;
+};

From c8f5cac1ed0ebd9251ed0cebb8251cc7e5541fef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Sep 2021 16:46:06 +0800
Subject: [PATCH 1672/3374] Update
 2009-minimum-number-of-operations-to-make-array-continuous.js

---
 ...imum-number-of-operations-to-make-array-continuous.js | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/2009-minimum-number-of-operations-to-make-array-continuous.js b/2009-minimum-number-of-operations-to-make-array-continuous.js
index be0adb9f..4595f1b3 100644
--- a/2009-minimum-number-of-operations-to-make-array-continuous.js
+++ b/2009-minimum-number-of-operations-to-make-array-continuous.js
@@ -12,11 +12,14 @@ const minOperations = function(nums) {
   }
   
   let j = 0;
-  let ans = N;
+  let res = N;
   for(let i = 0; i < M; i++) {
+    // let `j` point to the first element that is out of range -- `> nums[i] + N - 1`.
     while(j < M && nums[j] <= N + nums[i] - 1) j++;
-    ans = Math.min(ans, N - (j - i));
+    // The length of this subarray is `j - i`. 
+    // We need to replace `N - (j - i)` elements to make it continuous.
+    res = Math.min(res, N - (j - i));
   }
   
-  return ans;
+  return res;
 };

From b48a8cba8ca21630a59f012322cc2f9f76459024 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Sep 2021 18:36:19 +0800
Subject: [PATCH 1673/3374] Create 2008-maximum-earnings-from-taxi.js

---
 2008-maximum-earnings-from-taxi.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2008-maximum-earnings-from-taxi.js

diff --git a/2008-maximum-earnings-from-taxi.js b/2008-maximum-earnings-from-taxi.js
new file mode 100644
index 00000000..e1b42d22
--- /dev/null
+++ b/2008-maximum-earnings-from-taxi.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @param {number[][]} rides
+ * @return {number}
+ */
+const maxTaxiEarnings = function(n, rides) {
+  const { max } = Math
+  const rideStartAt = Array.from({length: n}, () => []);
+  for (let ride of rides) {
+    let s = ride[0], e = ride[1], t = ride[2];
+    rideStartAt[s].push([e, e - s + t]);  // [end, dollar]
+  }
+  const dp = Array(n+1).fill(0);
+  for (let i = n-1; i >= 1; --i) {
+    for (let [e, d] of rideStartAt[i]) {
+      dp[i] = max(dp[i], dp[e] + d);
+    }
+    dp[i] = max(dp[i], dp[i + 1]);
+  }
+  return dp[1];
+};

From 3aff380d72db3abc181e93bebea3ad48db33bab0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Sep 2021 21:42:33 +0800
Subject: [PATCH 1674/3374] Create
 1356-sort-integers-by-the-number-of-1-bits.js

---
 1356-sort-integers-by-the-number-of-1-bits.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1356-sort-integers-by-the-number-of-1-bits.js

diff --git a/1356-sort-integers-by-the-number-of-1-bits.js b/1356-sort-integers-by-the-number-of-1-bits.js
new file mode 100644
index 00000000..30f0ee20
--- /dev/null
+++ b/1356-sort-integers-by-the-number-of-1-bits.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+const sortByBits = function(arr) {
+  arr.sort((a, b) => {
+    const an = numOfBits(a), bn = numOfBits(b)
+    return an === bn ? a - b : an - bn
+  })
+  return arr
+};
+
+function numOfBits(n) {
+  let res = 0
+  for(let i = 0; i < 32; i++) {
+    if((1 << i) & n) res++
+  }
+  return res
+}

From d2c01fed888bd236751a3c570f16595aba96978b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Sep 2021 09:43:29 +0800
Subject: [PATCH 1675/3374] Create
 1560-most-visited-sector-in-a-circular-track.js

---
 ...most-visited-sector-in-a-circular-track.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1560-most-visited-sector-in-a-circular-track.js

diff --git a/1560-most-visited-sector-in-a-circular-track.js b/1560-most-visited-sector-in-a-circular-track.js
new file mode 100644
index 00000000..62d2eea1
--- /dev/null
+++ b/1560-most-visited-sector-in-a-circular-track.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @param {number[]} rounds
+ * @return {number[]}
+ */
+const mostVisited = function(n, rounds) {
+  const arr = Array(n + 1).fill(0)
+  for(let i = 1, m = rounds.length; i < m; i++) {
+    let start = rounds[i - 1], end = rounds[i]
+
+    if(i == 1) arr[start]++
+    while(start !== end) {
+      start += 1
+      if (start === n + 1) start = 1
+      arr[start]++
+    }
+  }
+  const max = Math.max(...arr)
+  const res = []
+  for(let i = 1; i <= n; i++) {
+    if(arr[i] === max) res.push(i)
+  }
+  return res
+};

From 822dff0c934595131d66c89bfb0d952b1d945770 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Sep 2021 19:39:39 +0800
Subject: [PATCH 1676/3374] Update 1235-maximum-profit-in-job-scheduling.js

---
 1235-maximum-profit-in-job-scheduling.js | 37 ++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/1235-maximum-profit-in-job-scheduling.js b/1235-maximum-profit-in-job-scheduling.js
index 5870bc35..a5a0fa3b 100644
--- a/1235-maximum-profit-in-job-scheduling.js
+++ b/1235-maximum-profit-in-job-scheduling.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number[]} startTime
+ * @param {number[]} endTime
+ * @param {number[]} profit
+ * @return {number}
+ */
+const jobScheduling = function (startTime, endTime, profit) {
+  const n = startTime.length
+  const items = Array(n)
+  for(let i = 0;i < n; i++) items[i] = [startTime[i], endTime[i], profit[i]]
+  items.sort((a, b) => a[1] - b[1])
+  const dpEndTime = [0]
+  const dpProfit = [0]
+  for(const [s, e, p] of items) {
+    const prevIdx = binarySearch(dpEndTime, 0, dpEndTime.length - 1, s)
+    const curProfit = dpProfit[prevIdx] + p, maxProfit = dpProfit[dpProfit.length - 1]
+    if(curProfit > maxProfit) {
+      dpProfit.push(curProfit)
+      dpEndTime.push(e)
+    }
+  }
+  
+  return dpProfit[dpProfit.length - 1]
+}
+
+function binarySearch(arr, l, r, x) {
+  while (l < r) {
+    const mid = r - ((r - l) >> 1)
+    if (arr[mid] > x) r = mid - 1
+    else l = mid
+  }
+  return l
+}
+
+
+// another
+
 /**
  * @param {number[]} startTime
  * @param {number[]} endTime

From 19b9b62dd2e26a6a19231635a617a0fa29776ada Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Sep 2021 10:52:11 +0800
Subject: [PATCH 1677/3374] Update
 1751-maximum-number-of-events-that-can-be-attended-ii.js

---
 ...umber-of-events-that-can-be-attended-ii.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1751-maximum-number-of-events-that-can-be-attended-ii.js b/1751-maximum-number-of-events-that-can-be-attended-ii.js
index 0de7c6d0..6f1ce829 100644
--- a/1751-maximum-number-of-events-that-can-be-attended-ii.js
+++ b/1751-maximum-number-of-events-that-can-be-attended-ii.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[][]} events
+ * @param {number} k
+ * @return {number}
+ */
+const maxValue = function (events, k) {
+  const n = events.length
+  const memo = Array.from({ length: n + 1 }, () => Array(k + 1).fill(-1))
+  events.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  return helper(memo, events, n, 0, k)
+}
+
+function helper(memo, events, n, i, k) {
+  if(i === n || k === 0) return 0
+  if(memo[i][k] !== -1) return memo[i][k]
+  let ni = i + 1
+  for(; ni < n; ni++) {
+    if(events[ni][0] > events[i][1]) break
+  }
+
+  return memo[i][k] = Math.max(
+    helper(memo, events, n, i + 1, k),
+    events[i][2] + helper(memo, events, n, ni, k - 1)
+  )
+}
+
+// another
+
 /**
  * @param {number[][]} events
  * @param {number} k

From 8f619eed7f6f34b88d4362a31b2242d37c657837 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Sep 2021 19:56:17 +0800
Subject: [PATCH 1678/3374] Create
 1281-subtract-the-product-and-sum-of-digits-of-an-integer.js

---
 ...-the-product-and-sum-of-digits-of-an-integer.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1281-subtract-the-product-and-sum-of-digits-of-an-integer.js

diff --git a/1281-subtract-the-product-and-sum-of-digits-of-an-integer.js b/1281-subtract-the-product-and-sum-of-digits-of-an-integer.js
new file mode 100644
index 00000000..81d0a338
--- /dev/null
+++ b/1281-subtract-the-product-and-sum-of-digits-of-an-integer.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const subtractProductAndSum = function(n) {
+  if(n === 0) return 0
+  let sum = 0, product = 1
+  n = '' + n
+  for(let ch of n) {
+    sum += +(ch)
+    product *= +(ch)
+  }
+  return product - sum
+};

From b19d5f109b95c712b1c748990aae9d73b87915f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Sep 2021 19:29:32 +0800
Subject: [PATCH 1679/3374] Create 1528-shuffle-string.js

---
 1528-shuffle-string.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1528-shuffle-string.js

diff --git a/1528-shuffle-string.js b/1528-shuffle-string.js
new file mode 100644
index 00000000..1c965ce1
--- /dev/null
+++ b/1528-shuffle-string.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @param {number[]} indices
+ * @return {string}
+ */
+const restoreString = function(s, indices) {
+  const n = s.length
+  const arr = Array(n)
+  for(let i = 0; i < n; i++) {
+    arr[indices[i]] = s[i]
+  }
+  return arr.join('')
+};

From 9f9fb42cb48af9dbb7101146df8a6559717bad53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Sep 2021 19:41:53 +0800
Subject: [PATCH 1680/3374] Create 1486-xor-operation-in-an-array.js

---
 1486-xor-operation-in-an-array.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1486-xor-operation-in-an-array.js

diff --git a/1486-xor-operation-in-an-array.js b/1486-xor-operation-in-an-array.js
new file mode 100644
index 00000000..32db560e
--- /dev/null
+++ b/1486-xor-operation-in-an-array.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number} start
+ * @return {number}
+ */
+const xorOperation = function(n, start) {
+  const nums = []
+  let i = 0
+  while (i < n) {
+    nums[i] = start + 2 * i
+    i++
+  }
+  // console.log(nums)
+  let res = nums[0]
+  for(let i = 1; i < n; i++) res ^= nums[i]
+  return res
+};

From c0f32ef7af5a3171f200789ebfb8dd9ab1e2aa59 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Sep 2021 18:38:47 +0800
Subject: [PATCH 1681/3374] Create
 2018-check-if-word-can-be-placed-in-crossword.js

---
 ...heck-if-word-can-be-placed-in-crossword.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2018-check-if-word-can-be-placed-in-crossword.js

diff --git a/2018-check-if-word-can-be-placed-in-crossword.js b/2018-check-if-word-can-be-placed-in-crossword.js
new file mode 100644
index 00000000..059c6731
--- /dev/null
+++ b/2018-check-if-word-can-be-placed-in-crossword.js
@@ -0,0 +1,33 @@
+/**
+ * @param {character[][]} board
+ * @param {string} word
+ * @return {boolean}
+ */
+const placeWordInCrossword = function(board, word) {
+  for (let state of [board, getRotated(board)])
+    for (let chars of state)
+      for (let token of chars.join('').split("#"))
+        for (let letters of [word, word.split('').reverse().join('')])
+          if (letters.length == token.length)
+            if (canFit(letters, token))
+              return true;
+  return false;
+}
+
+function getRotated(board) {
+  const m = board.length;
+  const n = board[0].length;
+
+  const rotated = Array.from({length: n}, () => Array(m));
+  for (let i = 0; i < m; ++i)
+    for (let j = 0; j < n; ++j)
+      rotated[j][i] = board[i][j];
+  return rotated;
+}
+
+function canFit(letters, token) {
+  for (let i = 0; i < letters.length; ++i)
+    if (token.charAt(i) != ' ' && token.charAt(i) != letters.charAt(i))
+      return false;
+  return true;
+}

From 1fa1b9b054195e0d81c013bc5f1f0627519b0c33 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Oct 2021 00:15:27 +0800
Subject: [PATCH 1682/3374] Create
 1217-minimum-cost-to-move-chips-to-the-same-position.js

---
 ...inimum-cost-to-move-chips-to-the-same-position.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1217-minimum-cost-to-move-chips-to-the-same-position.js

diff --git a/1217-minimum-cost-to-move-chips-to-the-same-position.js b/1217-minimum-cost-to-move-chips-to-the-same-position.js
new file mode 100644
index 00000000..c9c72ba9
--- /dev/null
+++ b/1217-minimum-cost-to-move-chips-to-the-same-position.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} position
+ * @return {number}
+ */
+const minCostToMoveChips = function(position) {
+  let oddSum = 0, evenSum = 0
+  for(let i = 0; i < position.length; i++) {
+    if(position[i] % 2 === 0) evenSum++
+    else oddSum++
+  }
+  return Math.min(oddSum, evenSum)
+};

From c00ff0d66933286b25927a1ccc418c528a61adc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Oct 2021 17:44:53 +0800
Subject: [PATCH 1683/3374] Create 1332-remove-palindromic-subsequences.js

---
 1332-remove-palindromic-subsequences.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1332-remove-palindromic-subsequences.js

diff --git a/1332-remove-palindromic-subsequences.js b/1332-remove-palindromic-subsequences.js
new file mode 100644
index 00000000..747c066d
--- /dev/null
+++ b/1332-remove-palindromic-subsequences.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const removePalindromeSub = function(s) {
+  if(s == null || s === '') return 0
+  if(chk(s)) return 1
+  return 2
+};
+
+function chk(s) {
+  let l = 0, r = s.length - 1
+  while(l < r) {
+    if(s[l] !== s[r]) return false
+    l++
+    r--
+  }
+  
+  return true
+}

From 1f1d966ba145e28a24c45e8d5633b725c681db12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Oct 2021 12:21:21 +0800
Subject: [PATCH 1684/3374] Create
 2019-the-score-of-students-solving-math-expression.js

---
 ...ore-of-students-solving-math-expression.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 2019-the-score-of-students-solving-math-expression.js

diff --git a/2019-the-score-of-students-solving-math-expression.js b/2019-the-score-of-students-solving-math-expression.js
new file mode 100644
index 00000000..9dee9e18
--- /dev/null
+++ b/2019-the-score-of-students-solving-math-expression.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @param {number[]} answers
+ * @return {number}
+ */
+const op = {
+    '+': ((a, b) => Number(a) + Number(b)),
+    '*':((a, b) => a * b),
+}
+let dp = {};
+const dfs = (s) => {
+    if(s.length == 0) return {};
+    if(s.length == 1) return { [s[0]] : 1};
+    const dps = dp[s];
+    if(dps) return dps;
+    const res = {};
+    for(let i = 0; i < s.length - 2; i += 2) {
+        const l = dfs(s.substr(0, i + 1))
+        const r = dfs(s.substr(i + 2, s.length - i - 2));
+        for(let x in l) {
+            for(let y in r) {
+                const z = op[s[i + 1]](x, y);
+                if(z > 1000) continue;
+                res[z] = 1;
+            }
+        }
+        
+    }
+    dp[s] = res;
+    return res;
+}
+
+const scoreOfStudents = function(s, answers) {
+    const correct = eval(s);
+    dp = {};
+    const allAns = dfs(s);
+    let ans = 0;
+    answers.forEach(x => {
+        if(  x == correct) ans += 5;
+        else if(allAns[x]) ans += 2;
+    })
+    return ans;
+};

From ac59868e1a3abc7f14e2effc26a63266e03d5ed0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Oct 2021 17:50:39 +0800
Subject: [PATCH 1685/3374] Create
 2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js

---
 ...ubsequence-with-occurrences-of-a-letter.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js

diff --git a/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js b/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js
new file mode 100644
index 00000000..881d96aa
--- /dev/null
+++ b/2030-smallest-k-length-subsequence-with-occurrences-of-a-letter.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @param {character} letter
+ * @param {number} repetition
+ * @return {string}
+ */
+const smallestSubsequence = function (s, k, letter, repetition) {
+  let n_letters = 0
+  for (let i = 0; i < s.length; i++) if (s.charAt(i) == letter) n_letters++
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
+    let c = s.charAt(i)
+    while (
+      stack.length &&
+      stack[stack.length - 1] > c &&
+      s.length - i + stack.length > k &&
+      (stack[stack.length - 1] != letter || n_letters > repetition)
+    ) {
+      if (stack.pop() == letter) repetition++
+    }
+    if (stack.length < k) {
+      if (c == letter) {
+        stack.push(c)
+        repetition--
+      } else if (k - stack.length > repetition) {
+        stack.push(c)
+      }
+    }
+    if (c == letter) n_letters--
+  }
+
+  let sb = ''
+  for (let c of stack) sb += c
+  return sb
+}

From 26c177d977c25c10640a26e0a6904a9ca0968ca8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Oct 2021 13:05:48 +0800
Subject: [PATCH 1686/3374] Create 2024-maximize-the-confusion-of-an-exam.js

---
 2024-maximize-the-confusion-of-an-exam.js | 25 +++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2024-maximize-the-confusion-of-an-exam.js

diff --git a/2024-maximize-the-confusion-of-an-exam.js b/2024-maximize-the-confusion-of-an-exam.js
new file mode 100644
index 00000000..d1a382f2
--- /dev/null
+++ b/2024-maximize-the-confusion-of-an-exam.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} answerKey
+ * @param {number} k
+ * @return {number}
+ */
+const maxConsecutiveAnswers = function(answerKey, k) {
+  const helper = (str, transT) => {
+    let res = 0, l = 0, r = 0, num = 0
+    const n = str.length
+    const target = transT === 1 ? 'T' : 'F'
+    while(r < n) {
+      if(str[r] === target) num++
+      while(num > k) {
+        if(str[l] === target) num--
+        l++
+      }
+      res = Math.max(res, r - l + 1)
+      r++
+    }
+    return res
+  }
+  
+  return Math.max(helper(answerKey, 0), helper(answerKey, 1))
+};
+

From 69fb0020b050c8030dafe42ad856ddd3e5154484 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Oct 2021 13:58:09 +0800
Subject: [PATCH 1687/3374] Update
 424-longest-repeating-character-replacement.js

---
 ...longest-repeating-character-replacement.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/424-longest-repeating-character-replacement.js b/424-longest-repeating-character-replacement.js
index 8a17a9fa..dca0fa47 100755
--- a/424-longest-repeating-character-replacement.js
+++ b/424-longest-repeating-character-replacement.js
@@ -23,3 +23,27 @@ const characterReplacement = function(s, k) {
 
 console.log(characterReplacement("ABAB", 2));
 console.log(characterReplacement("AABABBA", 1));
+
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const characterReplacement = function(s, k) {
+  const freq = Array(26).fill(0), n = s.length, A = 'A'.charCodeAt(0)
+  let res = 0, l = 0, r = 0, maxFreq = 0
+  while(r < n) {
+    maxFreq = Math.max(maxFreq, ++freq[s.charCodeAt(r) - A])
+    if(r - l + 1 - maxFreq > k) {
+      freq[s.charCodeAt(l) - A]--
+      l++
+    }
+    res = Math.max(res, r - l + 1)
+    r++
+  }
+  
+  return res
+};

From a35a0e0e49e5cc1e8f5aabb6108ff345b364370e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Oct 2021 13:59:15 +0800
Subject: [PATCH 1688/3374] Update 2024-maximize-the-confusion-of-an-exam.js

---
 2024-maximize-the-confusion-of-an-exam.js | 25 +++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2024-maximize-the-confusion-of-an-exam.js b/2024-maximize-the-confusion-of-an-exam.js
index d1a382f2..a181942c 100644
--- a/2024-maximize-the-confusion-of-an-exam.js
+++ b/2024-maximize-the-confusion-of-an-exam.js
@@ -23,3 +23,28 @@ const maxConsecutiveAnswers = function(answerKey, k) {
   return Math.max(helper(answerKey, 0), helper(answerKey, 1))
 };
 
+// another
+
+/**
+ * @param {string} answerKey
+ * @param {number} k
+ * @return {number}
+ */
+const maxConsecutiveAnswers = function(answerKey, k) {
+  let s = answerKey
+  const freq = Array(26).fill(0), n = s.length, A = 'A'.charCodeAt(0)
+  let res = 0, l = 0, r = 0, maxFreq = 0
+  while(r < n) {
+    maxFreq = Math.max(maxFreq, ++freq[s.charCodeAt(r) - A])
+    if(r - l + 1 - maxFreq > k) {
+      freq[s.charCodeAt(l) - A]--
+      l++
+    }
+    res = Math.max(res, r - l + 1)
+    r++
+  }
+  
+  return res
+};
+
+

From 05a7864e5da3681cf3ebfad5edc1e7f1d7c73e15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Oct 2021 11:53:13 +0800
Subject: [PATCH 1689/3374] Update
 424-longest-repeating-character-replacement.js

---
 ...longest-repeating-character-replacement.js | 25 ++++++++++++-------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/424-longest-repeating-character-replacement.js b/424-longest-repeating-character-replacement.js
index dca0fa47..7a49780e 100755
--- a/424-longest-repeating-character-replacement.js
+++ b/424-longest-repeating-character-replacement.js
@@ -32,18 +32,25 @@ console.log(characterReplacement("AABABBA", 1));
  * @param {number} k
  * @return {number}
  */
-const characterReplacement = function(s, k) {
-  const freq = Array(26).fill(0), n = s.length, A = 'A'.charCodeAt(0)
-  let res = 0, l = 0, r = 0, maxFreq = 0
-  while(r < n) {
-    maxFreq = Math.max(maxFreq, ++freq[s.charCodeAt(r) - A])
-    if(r - l + 1 - maxFreq > k) {
+const characterReplacement = function (s, k) {
+  const freq = Array(26).fill(0),
+    n = s.length,
+    { max } = Math,
+    A = 'A'.charCodeAt(0)
+  let res = 0,
+    l = 0,
+    r = 0,
+    maxFreq = 0
+  while (r < n) {
+    maxFreq = max(maxFreq, ++freq[s.charCodeAt(r) - A])
+    if (r - l + 1 - maxFreq > k) {
       freq[s.charCodeAt(l) - A]--
       l++
     }
-    res = Math.max(res, r - l + 1)
+    res = max(res, r - l + 1)
     r++
   }
-  
+
   return res
-};
+}
+

From 89d6ad2bada3bcd934debfac8ab77fb169229a48 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Oct 2021 19:08:28 +0800
Subject: [PATCH 1690/3374] Create
 2025-maximum-number-of-ways-to-partition-an-array.js

---
 ...um-number-of-ways-to-partition-an-array.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2025-maximum-number-of-ways-to-partition-an-array.js

diff --git a/2025-maximum-number-of-ways-to-partition-an-array.js b/2025-maximum-number-of-ways-to-partition-an-array.js
new file mode 100644
index 00000000..759d33fc
--- /dev/null
+++ b/2025-maximum-number-of-ways-to-partition-an-array.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const waysToPartition = function (nums, k) {
+  const n = nums.length
+  const pref = Array(n).fill(0),
+    suff = Array(n).fill(0)
+  pref[0] = nums[0]
+  suff[n - 1] = nums[n - 1]
+  for (let i = 1; i < n; ++i) {
+    pref[i] = pref[i - 1] + nums[i]
+    suff[n - 1 - i] = suff[n - i] + nums[n - 1 - i]
+  }
+  let ans = 0
+  const left = {},
+    right = {}
+
+  for (let i = 0; i < n - 1; ++i) {
+    const delta = pref[i] - suff[i + 1]
+    if (right[delta] == null) right[delta] = 0
+    right[delta]++
+  }
+
+  if (right[0]) ans = right[0]
+  for (let i = 0; i < n; ++i) {
+    //find the number of pivot indexes when nums[i] is changed to k
+    let curr = 0,
+      diff = k - nums[i]
+    if (left[diff]) curr += left[diff]
+    if (right[-diff]) curr += right[-diff]
+
+    //update answer
+    ans = Math.max(ans, curr)
+
+    //transfer the current element from right to left
+    if (i < n - 1) {
+      let dd = pref[i] - suff[i + 1]
+      if(left[dd] == null) left[dd] = 0
+      if(right[dd] == null) right[dd] = 0
+      left[dd]++
+      right[dd]--
+      if (right[dd] == 0) delete right[dd]
+    }
+  }
+  return ans
+}

From 2c29a1ba94557a9d56dea0accb77c23d25ed5cad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Oct 2021 22:11:48 +0800
Subject: [PATCH 1691/3374] Update
 2025-maximum-number-of-ways-to-partition-an-array.js

---
 ...um-number-of-ways-to-partition-an-array.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2025-maximum-number-of-ways-to-partition-an-array.js b/2025-maximum-number-of-ways-to-partition-an-array.js
index 759d33fc..ed96ae1e 100644
--- a/2025-maximum-number-of-ways-to-partition-an-array.js
+++ b/2025-maximum-number-of-ways-to-partition-an-array.js
@@ -1,3 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const waysToPartition = function (nums, k) {
+  const n = nums.length, pre = Array(n).fill(0), suf = Array(n).fill(0)
+  pre[0] = nums[0], suf[n - 1] = nums[n - 1]
+  for(let i = 1; i < n; i++) {
+    pre[i] = pre[i - 1] + nums[i]
+    suf[n - 1 - i] = suf[n - i] + nums[n - 1 - i]
+  }
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  let res = 0
+  for(let i = 0; i < n - 1; i++) {
+    if(pre[i] === suf[i + 1]) res++
+  }
+  const cnt = new Map()
+  const arr = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    const newSum = sum - nums[i] + k
+    if(newSum % 2 === 0) arr[i] += (cnt.get(newSum / 2) || 0)
+    cnt.set(pre[i], (cnt.get(pre[i]) || 0) + 1)
+  }
+  cnt.clear()
+  for(let i = n - 1; i >= 0; i--) {
+    const newSum = sum - nums[i] + k
+    if(newSum % 2 === 0) arr[i] += (cnt.get(newSum / 2) || 0)
+    cnt.set(suf[i], (cnt.get(suf[i]) || 0) + 1)
+  }
+  
+  for(let e of arr) {
+    if(e > res) res = e
+  }
+  
+  return res
+}
+
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From bda7e5e88321c6a4a9696bb056b6728920bcb19d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Oct 2021 09:35:11 +0800
Subject: [PATCH 1692/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 2617178c..42f649fc 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -18,3 +18,28 @@ var findTheLongestSubstring = function (s, V = 'aeiou', max = 0) {
   }
   return max
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestSubstring = function(s) {
+  const n = s.length
+  const ch2num = ch => {
+    const idx = 'aeiou'.indexOf(ch)
+    return idx === -1 ? 0 : (1 << idx)
+  }
+  let res = 0
+  const arr = Array(n + 1).fill(0)
+  const hash = new Map([[0, 0]])
+  for(let i = 1; i <= n; i++) {
+    arr[i] = arr[i - 1] ^ ch2num(s[i - 1])
+    const first = hash.has(arr[i]) ? hash.get(arr[i]) : i
+    if (!hash.has(arr[i])) hash.set(arr[i], i)
+    res = Math.max(res, i - first)
+  }
+
+  return res
+};

From b5acc53d39e138eab5216af1753a1b28aede8636 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Oct 2021 09:41:49 +0800
Subject: [PATCH 1693/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...ngest-substring-containing-vowels-in-even-counts.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 42f649fc..9260de39 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -32,12 +32,12 @@ const findTheLongestSubstring = function(s) {
     return idx === -1 ? 0 : (1 << idx)
   }
   let res = 0
-  const arr = Array(n + 1).fill(0)
+  let mask = 0
   const hash = new Map([[0, 0]])
-  for(let i = 1; i <= n; i++) {
-    arr[i] = arr[i - 1] ^ ch2num(s[i - 1])
-    const first = hash.has(arr[i]) ? hash.get(arr[i]) : i
-    if (!hash.has(arr[i])) hash.set(arr[i], i)
+  for (let i = 1; i <= n; i++) {
+    mask ^= ch2num(s[i - 1])
+    const first = hash.has(mask) ? hash.get(mask) : i
+    if (!hash.has(mask)) hash.set(mask, i)
     res = Math.max(res, i - first)
   }
 

From 6756d846dfc289c05e9c92ec35abcff7d3d31d54 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Oct 2021 10:44:19 +0800
Subject: [PATCH 1694/3374] Create 1507-reformat-date.js

---
 1507-reformat-date.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1507-reformat-date.js

diff --git a/1507-reformat-date.js b/1507-reformat-date.js
new file mode 100644
index 00000000..2057763c
--- /dev/null
+++ b/1507-reformat-date.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} date
+ * @return {string}
+ */
+const reformatDate = function(date) {
+  const months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+  const map = new Map();
+  for (let i = 0; i < months.length; ++i) {
+    map.set(months[i], (i + 1 < 10 ? "0" : "") + (i+1));    
+  }
+  const parts = date.split(" "); 
+  const day = (parts[0].length == 3 ? "0" : "") + parts[0].slice(0, parts[0].length - 2);
+  return parts[2] + "-" + map.get(parts[1]) + "-" + day;  
+};

From b9c069e1c09fd403281426d8d45b46be744aa7a9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Oct 2021 11:48:35 +0800
Subject: [PATCH 1695/3374] Create 1337-the-k-weakest-rows-in-a-matrix.js

---
 1337-the-k-weakest-rows-in-a-matrix.js | 94 ++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 1337-the-k-weakest-rows-in-a-matrix.js

diff --git a/1337-the-k-weakest-rows-in-a-matrix.js b/1337-the-k-weakest-rows-in-a-matrix.js
new file mode 100644
index 00000000..77ba5790
--- /dev/null
+++ b/1337-the-k-weakest-rows-in-a-matrix.js
@@ -0,0 +1,94 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} k
+ * @return {number[]}
+ */
+const kWeakestRows = function(mat, k) {
+  const pq = new PriorityQueue((a,  b) => a[0] === b[0] ? a[1] > b[1] : a[0] > b[0])
+  const res = [], m = mat.length
+  for(let i = 0; i < m; i++) {
+    pq.push([oneNum(mat[i]), i])
+    if(pq.size() > k) pq.pop()
+  }
+  while(k > 0) res[--k] = pq.pop()[1]
+  return res
+};
+
+function oneNum(arr) {
+  let l = 0, h = arr.length
+  while(l < h) {
+    const mid  = l + ((h - l) >> 1)
+    if(arr[mid] === 1) l = mid + 1
+    else h = mid
+  }
+  return l
+}
+
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 0a5d727cf0417926be1def006e5bf3d01dd6ad32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Oct 2021 12:01:28 +0800
Subject: [PATCH 1696/3374] Create 2032-two-out-of-three.js

---
 2032-two-out-of-three.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2032-two-out-of-three.js

diff --git a/2032-two-out-of-three.js b/2032-two-out-of-three.js
new file mode 100644
index 00000000..e392cbbe
--- /dev/null
+++ b/2032-two-out-of-three.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number[]} nums3
+ * @return {number[]}
+ */
+const twoOutOfThree = function(nums1, nums2, nums3) {
+  const res = []
+  const hash = {}
+  for(let e of new Set(nums1)) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e] = 1
+  }
+
+  for(let e of new Set(nums2)) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  
+
+  for(let e of new Set(nums3)) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  
+  Object.keys(hash).forEach(k => {
+    if(hash[k] > 1) res.push(k)
+  })
+
+  
+  return res
+};

From 0c50b87c22aedc2edaa752346a7ace2f397f4f9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Oct 2021 12:02:03 +0800
Subject: [PATCH 1697/3374] Create
 2033-minimum-operations-to-make-a-uni-value-grid.js

---
 ...mum-operations-to-make-a-uni-value-grid.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 2033-minimum-operations-to-make-a-uni-value-grid.js

diff --git a/2033-minimum-operations-to-make-a-uni-value-grid.js b/2033-minimum-operations-to-make-a-uni-value-grid.js
new file mode 100644
index 00000000..b434220d
--- /dev/null
+++ b/2033-minimum-operations-to-make-a-uni-value-grid.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function(grid, x) {
+  const arr = []
+  const m = grid.length, n = grid[0].length
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      arr.push(grid[i][j])
+    }
+  }
+  arr.sort((a, b) => a - b)
+  
+  for(let i = 1; i < m * n; i++) {
+    if((arr[i] - arr[i - 1]) % x !== 0) return -1
+  }
+  const sum = arr.reduce((ac, e) => ac + e, 0)
+  const pre = []
+  pre.push(arr[0])
+  for(let i = 1; i < m * n; i++) {
+    pre[i] = pre[i - 1] + arr[i]
+  }
+  
+  let res = 0, num = 0, min = sum - arr[0] * m * n, idx = 0
+  for(let i = 1; i < m * n; i++) {
+    const cur = (i + 1) * arr[i] - pre[i] + (sum - pre[i] - arr[i] * (m * n - i - 1))
+    // console.log(cur, (i + 1) * arr[i] - pre[i], sum - pre[i] - arr[i] * (m * n - i - 1))
+    // const cur = sum - arr[i] * (m * n - i)
+    if(cur < min) {
+      idx = i
+      min = cur
+    }
+  }
+  
+  // console.log(idx)
+  
+  for(let i = 0; i < m * n; i++) {
+    if(i === idx) continue
+    res += Math.abs(arr[i] - arr[idx]) / x
+  }
+  
+  return res
+};
+// 20 - 6 - 4 * 2
+// 2 4 6 8
+// 1 2 3 5
+

From 80a8b9e0d09b96ae398f2ee8991d5a51b8c4ac11 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Oct 2021 13:59:14 +0800
Subject: [PATCH 1698/3374] Create 2034-stock-price-fluctuation.js

---
 2034-stock-price-fluctuation.js | 62 +++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 2034-stock-price-fluctuation.js

diff --git a/2034-stock-price-fluctuation.js b/2034-stock-price-fluctuation.js
new file mode 100644
index 00000000..67eecd73
--- /dev/null
+++ b/2034-stock-price-fluctuation.js
@@ -0,0 +1,62 @@
+const StockPrice = function () {
+  this.timeToPrice = new Map()
+  this.lastTime = 0
+  this.minPrices = new MinPriorityQueue({ priority: (stock) => stock.price })
+  this.maxPrices = new MaxPriorityQueue({ priority: (stock) => stock.price })
+}
+
+/**
+ * @param {number} timestamp
+ * @param {number} price
+ * @return {void}
+ */
+StockPrice.prototype.update = function (timestamp, price) {
+  this.timeToPrice.set(timestamp, price)
+  this.lastTime = Math.max(this.lastTime, timestamp)
+  this.minPrices.enqueue({ timestamp, price })
+  this.maxPrices.enqueue({ timestamp, price })
+}
+
+/**
+ * @return {number}
+ */
+StockPrice.prototype.current = function () {
+  return this.timeToPrice.get(this.lastTime)
+}
+
+/**
+ * @return {number}
+ */
+StockPrice.prototype.maximum = function () {
+  while (
+    this.maxPrices.front().element.price !==
+    this.timeToPrice.get(this.maxPrices.front().element.timestamp)
+  ) {
+    this.maxPrices.dequeue()
+  }
+
+  return this.maxPrices.front().element.price
+}
+
+/**
+ * @return {number}
+ */
+StockPrice.prototype.minimum = function () {
+  while (
+    this.minPrices.front().element.price !==
+    this.timeToPrice.get(this.minPrices.front().element.timestamp)
+  ) {
+    this.minPrices.dequeue()
+  }
+
+  return this.minPrices.front().element.price
+}
+
+/**
+ * Your StockPrice object will be instantiated and called as such:
+ * var obj = new StockPrice()
+ * obj.update(timestamp,price)
+ * var param_2 = obj.current()
+ * var param_3 = obj.maximum()
+ * var param_4 = obj.minimum()
+ */

From 78d53fc631c3a6a040b6a5d70c5ff28ab533b140 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Oct 2021 18:21:26 +0800
Subject: [PATCH 1699/3374] Create
 2035-partition-array-into-two-arrays-to-minimize-sum-difference.js

---
 ...o-two-arrays-to-minimize-sum-difference.js | 97 +++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 2035-partition-array-into-two-arrays-to-minimize-sum-difference.js

diff --git a/2035-partition-array-into-two-arrays-to-minimize-sum-difference.js b/2035-partition-array-into-two-arrays-to-minimize-sum-difference.js
new file mode 100644
index 00000000..630caf18
--- /dev/null
+++ b/2035-partition-array-into-two-arrays-to-minimize-sum-difference.js
@@ -0,0 +1,97 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const mi = Math.min,
+  abs = Math.abs
+const minimumDifference = (nums) => {
+  let m = nums.length,
+    n = m >> 1
+  let a = initializeGraph(n + 1)
+  let b = initializeGraph(n + 1)
+  for (let i = 0; i < 1 << n; i++) {
+    // mask
+    let sum = 0,
+      cnt = 0
+    for (let j = 0; j < n; j++) {
+      if (i & (1 << j)) {
+        // bit of 1's
+        sum += nums[j]
+        cnt++ // bit count
+      } else {
+        sum -= nums[j]
+      }
+    }
+    a[cnt].push(sum)
+    ;(sum = 0), (cnt = 0)
+    for (let j = 0; j < n; j++) {
+      if (i & (1 << j)) {
+        sum += nums[n + j]
+        cnt++
+      } else {
+        sum -= nums[n + j]
+      }
+    }
+    b[cnt].push(sum)
+  }
+  for (let i = 0; i < n; i++) {
+    a[i].sort((x, y) => x - y)
+    b[i].sort((x, y) => x - y)
+  }
+  let res = Number.MAX_SAFE_INTEGER
+  let bi = new Bisect()
+  for (let i = 0; i <= n; i++) {
+    for (const x of a[i]) {
+      let idx = bi.bisect_left(b[n - i], -x) // binary search   lower_bound
+      if (idx != b[n - i].length) res = mi(res, abs(x + b[n - i][idx]))
+      if (idx != 0) {
+        idx--
+        res = mi(res, abs(x + b[n - i][idx]))
+      }
+    }
+  }
+  return res
+}
+
+//////////////////////////////////////// Template ////////////////////////////////////////////////////////
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = (lo + hi) >> 1
+      x < a[mid] ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = (lo + hi) >> 1
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+
+const initializeGraph = (n) => {
+  let G = []
+  for (let i = 0; i < n; i++) {
+    G.push([])
+  }
+  return G
+}
+/////////////////////////////////////////////////////////////////////////////////////////////////////////////
+

From 7778473ec7d122914fd328a02108db9cef0b72d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Oct 2021 10:29:07 +0800
Subject: [PATCH 1700/3374] Update
 2033-minimum-operations-to-make-a-uni-value-grid.js

---
 ...mum-operations-to-make-a-uni-value-grid.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2033-minimum-operations-to-make-a-uni-value-grid.js b/2033-minimum-operations-to-make-a-uni-value-grid.js
index b434220d..11b9f977 100644
--- a/2033-minimum-operations-to-make-a-uni-value-grid.js
+++ b/2033-minimum-operations-to-make-a-uni-value-grid.js
@@ -47,3 +47,31 @@ const minOperations = function(grid, x) {
 // 2 4 6 8
 // 1 2 3 5
 
+// another
+
+/**
+ * @param {number[][]} grid
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function(grid, x) {
+  const arr = [], m = grid.length, n = grid[0].length
+  for(let i  =  0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      arr.push(grid[i][j])
+    }
+  }
+  arr.sort((a,  b) => a - b)
+  const mid = arr[~~((m * n) / 2)]
+  let res = 0
+
+  for(let e of arr) {
+    if (e !== mid) {
+      const cur  = Math.abs(e - mid)
+      if(cur  % x !== 0) return -1
+      res += cur / x
+    }
+  }
+  return res
+};
+

From 9b6f4b40e27d1e1e28f228aae1132b2e3549212d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Oct 2021 20:52:37 +0800
Subject: [PATCH 1701/3374] Update 1542-find-longest-awesome-substring.js

---
 1542-find-longest-awesome-substring.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1542-find-longest-awesome-substring.js b/1542-find-longest-awesome-substring.js
index a4597cc6..aaa37653 100644
--- a/1542-find-longest-awesome-substring.js
+++ b/1542-find-longest-awesome-substring.js
@@ -15,3 +15,27 @@ const longestAwesome = function (s) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestAwesome = function(s) {
+  const n = s.length, { max, min } = Math
+  const dp = Array(2 ** 10).fill(n)
+  let res = 0, mask = 0
+  dp[0] = -1
+  for(let i = 0; i < n; i++) {
+    mask ^= (1 << parseInt(s[i]))
+    res = max(res, i - dp[mask])
+    for(let j = 0; j <= 9; j++) {
+      const tmp = mask ^ (1 << j)
+      res = max(res, i - dp[tmp])
+    }
+    dp[mask] = min(i, dp[mask])
+  }
+  
+  return res
+};

From 7bf6cf748f326a9d5d429bb324a1baf24724679b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Oct 2021 21:15:48 +0800
Subject: [PATCH 1702/3374] Create 2029-stone-game-ix.js

---
 2029-stone-game-ix.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 2029-stone-game-ix.js

diff --git a/2029-stone-game-ix.js b/2029-stone-game-ix.js
new file mode 100644
index 00000000..eea5b685
--- /dev/null
+++ b/2029-stone-game-ix.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} stones
+ * @return {boolean}
+ */
+const stoneGameIX = function(stones) {
+  const cnt = Array(3).fill(0), { abs } = Math 
+  for (let a of stones) cnt[a % 3]++;
+  if (cnt[0] % 2 == 0) return cnt[1] && cnt[2]
+  return abs(cnt[1] - cnt[2]) >= 3
+};

From 2ef0925d86fe8ea8bc640bdd5ed9e25b61517984 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Oct 2021 19:29:44 +0800
Subject: [PATCH 1703/3374] Update 1316-distinct-echo-substrings.js

---
 1316-distinct-echo-substrings.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1316-distinct-echo-substrings.js b/1316-distinct-echo-substrings.js
index 26c3b1d7..4d8ecaee 100644
--- a/1316-distinct-echo-substrings.js
+++ b/1316-distinct-echo-substrings.js
@@ -17,3 +17,27 @@ const distinctEchoSubstrings = function (text) {
   }
   return set.size
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const removeDuplicateLetters = function(s) {
+  const last = {}
+  for (let i = 0; i < s.length; i++) last[s.charAt(i)] = i
+  const added = {}
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
+    const char = s.charAt(i)
+    if (added[char]) continue
+    while (stack.length && char < stack[stack.length - 1] && last[stack[stack.length - 1]] > i) {
+      added[stack[stack.length - 1]] = false
+      stack.pop()
+    }
+    stack.push(char)
+    added[char] = true
+  }
+  return stack.join('')
+}

From ae206e3bceb1223666b1378f9496eea02180eb12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Oct 2021 19:31:30 +0800
Subject: [PATCH 1704/3374] Update 316-remove-duplicate-letters.js

---
 316-remove-duplicate-letters.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/316-remove-duplicate-letters.js b/316-remove-duplicate-letters.js
index e06503f9..a64a93b2 100644
--- a/316-remove-duplicate-letters.js
+++ b/316-remove-duplicate-letters.js
@@ -52,3 +52,27 @@ const removeDuplicateLetters = function(s) {
   }
   return String.fromCharCode(...aChNo)
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const removeDuplicateLetters = function(s) {
+  const last = {}
+  for (let i = 0; i < s.length; i++) last[s.charAt(i)] = i
+  const added = {}
+  const stack = []
+  for (let i = 0; i < s.length; i++) {
+    const char = s.charAt(i)
+    if (added[char]) continue
+    while (stack.length && char < stack[stack.length - 1] && last[stack[stack.length - 1]] > i) {
+      added[stack[stack.length - 1]] = false
+      stack.pop()
+    }
+    stack.push(char)
+    added[char] = true
+  }
+  return stack.join('')
+}

From 3794274330e5b326ff8126e14935e3691ea8cc8f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Oct 2021 19:47:49 +0800
Subject: [PATCH 1705/3374] Update 1316-distinct-echo-substrings.js

---
 1316-distinct-echo-substrings.js | 23 -----------------------
 1 file changed, 23 deletions(-)

diff --git a/1316-distinct-echo-substrings.js b/1316-distinct-echo-substrings.js
index 4d8ecaee..478c3c0a 100644
--- a/1316-distinct-echo-substrings.js
+++ b/1316-distinct-echo-substrings.js
@@ -18,26 +18,3 @@ const distinctEchoSubstrings = function (text) {
   return set.size
 }
 
-// another
-
-/**
- * @param {string} s
- * @return {string}
- */
-const removeDuplicateLetters = function(s) {
-  const last = {}
-  for (let i = 0; i < s.length; i++) last[s.charAt(i)] = i
-  const added = {}
-  const stack = []
-  for (let i = 0; i < s.length; i++) {
-    const char = s.charAt(i)
-    if (added[char]) continue
-    while (stack.length && char < stack[stack.length - 1] && last[stack[stack.length - 1]] > i) {
-      added[stack[stack.length - 1]] = false
-      stack.pop()
-    }
-    stack.push(char)
-    added[char] = true
-  }
-  return stack.join('')
-}

From 27f37c26638cd65df4a6b323bba778ba40d5b52a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Oct 2021 10:24:32 +0800
Subject: [PATCH 1706/3374] Update
 1081-smallest-subsequence-of-distinct-characters.js

---
 ...lest-subsequence-of-distinct-characters.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1081-smallest-subsequence-of-distinct-characters.js b/1081-smallest-subsequence-of-distinct-characters.js
index f27ff2d9..2b5e37c8 100644
--- a/1081-smallest-subsequence-of-distinct-characters.js
+++ b/1081-smallest-subsequence-of-distinct-characters.js
@@ -56,3 +56,26 @@ const smallestSubsequence = function(s) {
   return res.join('') 
 };
 
+// anoother
+
+
+/**
+ * @param {string} text
+ * @return {string}
+ */
+const smallestSubsequence = function(text) {
+  const n = text.length, stack = [], last = {}, visited = {}
+  for(let i = 0; i < n; i++) last[text[i]] = i
+  for(let i = 0; i < n; i++) {
+    const ch = text[i]
+    if (visited[ch]) continue
+    while(stack.length && stack[stack.length - 1] > ch && last[stack[stack.length - 1]] > i) {
+      visited[stack[stack.length - 1]] = 0
+      stack.pop()
+    }
+    visited[ch] = 1
+    stack.push(ch)
+  }
+
+  return stack.join('')
+};

From 4b5d92ba15eed0f11c1535e9c7a6c6127a8cb8ac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Oct 2021 14:28:06 +0800
Subject: [PATCH 1707/3374] Update 402-remove-k-digits.js

---
 402-remove-k-digits.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/402-remove-k-digits.js b/402-remove-k-digits.js
index ea693f3b..21ef2e47 100644
--- a/402-remove-k-digits.js
+++ b/402-remove-k-digits.js
@@ -48,3 +48,28 @@ const removeKdigits = function(num, k) {
   while(stack[0] === '0') stack.shift()
   return stack.length ? stack.join('') : '0'
 };
+
+// another
+
+/**
+ * @param {string} num
+ * @param {number} k
+ * @return {string}
+ */
+const removeKdigits = function(num, k) {
+  const n = num.length, stack = []
+  for(let i = 0; i < n; i++) {
+    const ch = num[i]
+    while(stack.length && k > 0 && ch < stack[stack.length - 1]) {
+      stack.pop()
+      k--
+    }
+    stack.push(ch)
+  }
+  while(k > 0) {
+    stack.pop()
+    k--
+  }
+  while(stack[0] === '0') stack.shift()
+  return stack.length ? stack.join('') : '0'
+};

From 4b1064824dfb145d5d7b7e6c272beccf6f567831 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Oct 2021 15:10:03 +0800
Subject: [PATCH 1708/3374] Update
 1673-find-the-most-competitive-subsequence.js

---
 1673-find-the-most-competitive-subsequence.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1673-find-the-most-competitive-subsequence.js b/1673-find-the-most-competitive-subsequence.js
index 51acc346..bf913f46 100644
--- a/1673-find-the-most-competitive-subsequence.js
+++ b/1673-find-the-most-competitive-subsequence.js
@@ -43,3 +43,27 @@ const mostCompetitive = function (nums, k) {
   }
   return stack
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const mostCompetitive = function (nums, k) {
+  const n = nums.length, stack = []
+  for(let i = 0; i < n; i++) {
+    const ch = nums[i]
+    while(
+      stack.length &&
+      ch < stack[stack.length - 1] &&
+      stack.length + (n - 1 - i) >= k
+    ) {
+      stack.pop()
+    }
+    if(stack.length < k) stack.push(ch)
+  }
+  return stack
+}
+

From 834468074493c973c30354fa3471c7836e16ca01 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Oct 2021 21:10:48 +0800
Subject: [PATCH 1709/3374] Create
 2044-count-number-of-maximum-bitwise-or-subsets.js

---
 ...unt-number-of-maximum-bitwise-or-subsets.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2044-count-number-of-maximum-bitwise-or-subsets.js

diff --git a/2044-count-number-of-maximum-bitwise-or-subsets.js b/2044-count-number-of-maximum-bitwise-or-subsets.js
new file mode 100644
index 00000000..496a388c
--- /dev/null
+++ b/2044-count-number-of-maximum-bitwise-or-subsets.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countMaxOrSubsets = function(nums) {
+  let res = 0, max = 0, n = nums.length
+  for(let num of nums) max |= num
+  dfs(0, 0)
+  dfs(0, nums[0])
+  return res
+  
+  function dfs(i, cur) {
+    if(i === n) return
+    if(cur === max) return res += Math.pow(2, n - 1 - i)
+    dfs(i + 1, cur)
+    dfs(i + 1, cur | nums[i + 1])
+  }
+};

From fc303b0499794c0f9eb8ddf27aca3055cb618f73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Oct 2021 21:11:23 +0800
Subject: [PATCH 1710/3374] Create 2043-simple-bank-system.js

---
 2043-simple-bank-system.js | 56 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2043-simple-bank-system.js

diff --git a/2043-simple-bank-system.js b/2043-simple-bank-system.js
new file mode 100644
index 00000000..95ac0446
--- /dev/null
+++ b/2043-simple-bank-system.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} balance
+ */
+const Bank = function(balance) {
+  this.n = balance.length
+  balance.unshift(0)
+  this.b = balance
+  
+};
+
+/** 
+ * @param {number} account1 
+ * @param {number} account2 
+ * @param {number} money
+ * @return {boolean}
+ */
+Bank.prototype.transfer = function(account1, account2, money) {
+  let res = true
+  if(account1 > this.n || account1 < 1) return false
+  if(account2 > this.n || account2 < 1) return false
+  if(this.b[account1]< money) return false
+  this.b[account1] -= money
+  this.b[account2] += money
+  return true
+};
+
+/** 
+ * @param {number} account 
+ * @param {number} money
+ * @return {boolean}
+ */
+Bank.prototype.deposit = function(account, money) {
+  if(account > this.n || account < 1) return false
+  this.b[account] += money
+  return true
+};
+
+/** 
+ * @param {number} account 
+ * @param {number} money
+ * @return {boolean}
+ */
+Bank.prototype.withdraw = function(account, money) {
+  if(account > this.n || account < 1) return false
+  if(this.b[account] < money) return false
+  this.b[account] -= money
+  return true
+};
+
+/** 
+ * Your Bank object will be instantiated and called as such:
+ * var obj = new Bank(balance)
+ * var param_1 = obj.transfer(account1,account2,money)
+ * var param_2 = obj.deposit(account,money)
+ * var param_3 = obj.withdraw(account,money)
+ */

From 90bfb30666faab962f027d65fb8960da7cd0476b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Oct 2021 21:11:52 +0800
Subject: [PATCH 1711/3374] Create
 2042-check-if-numbers-are-ascending-in-a-sentence.js

---
 ...check-if-numbers-are-ascending-in-a-sentence.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2042-check-if-numbers-are-ascending-in-a-sentence.js

diff --git a/2042-check-if-numbers-are-ascending-in-a-sentence.js b/2042-check-if-numbers-are-ascending-in-a-sentence.js
new file mode 100644
index 00000000..1f128e49
--- /dev/null
+++ b/2042-check-if-numbers-are-ascending-in-a-sentence.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const areNumbersAscending = function(s) {
+  const arr =s.split(' ')
+  const f = arr.filter(e => !Number.isNaN(+e)).map(e => +e)
+  let res = true
+  for(let i = 1; i < f.length; i++) {
+    if(f[i] <= f[i - 1]) return false
+  }
+  
+  return res
+};

From e61b0ce6fd1519925d2344429a33b446050db887 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Oct 2021 21:13:45 +0800
Subject: [PATCH 1712/3374] Create
 2045-second-minimum-time-to-reach-destination.js

---
 ...econd-minimum-time-to-reach-destination.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2045-second-minimum-time-to-reach-destination.js

diff --git a/2045-second-minimum-time-to-reach-destination.js b/2045-second-minimum-time-to-reach-destination.js
new file mode 100644
index 00000000..d77c8c8c
--- /dev/null
+++ b/2045-second-minimum-time-to-reach-destination.js
@@ -0,0 +1,51 @@
+const initializeGraph = (n) => {
+  let G = []
+  for (let i = 0; i < n; i++) {
+    G.push([])
+  }
+  return G
+}
+const addEdgeToG = (G, Edges) => {
+  for (const [u, v] of Edges) {
+    G[u].push(v)
+    G[v].push(u)
+  }
+}
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} time
+ * @param {number} change
+ * @return {number}
+ */
+const secondMinimum = (n, edges, time, change) => {
+  let adj = initializeGraph(n + 1)
+  addEdgeToG(adj, edges)
+  let cost = initializeGraph(n + 1)
+  let pq = new MinPriorityQueue({ priority: (x) => x[0] })
+  pq.enqueue([0, 1])
+  let green = 2 * change
+  while (pq.size()) {
+    let cur = pq.dequeue().element
+    let [t, node] = cur
+    if (cost[node].length == 2) continue
+    let nextT =
+      t % green < change ? t : (((t + green - 1) / green) >> 0) * green
+    let cn = cost[node].length
+    if (node == n) {
+      if (cn == 0 || cost[node][cn - 1] != t) {
+        cost[node].push(t)
+      } else {
+        continue
+      }
+    } else {
+      if (cn == 0 || cost[node][cn - 1] != nextT) {
+        cost[node].push(nextT)
+      } else {
+        continue
+      }
+    }
+    for (const next_node of adj[node]) pq.enqueue([nextT + time, next_node])
+  }
+  return cost[n][1]
+}

From 1a2f1f3f1e0a437c5943fd80a42875e45d834325 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Oct 2021 15:49:18 +0800
Subject: [PATCH 1713/3374] Update
 2033-minimum-operations-to-make-a-uni-value-grid.js

---
 ...mum-operations-to-make-a-uni-value-grid.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2033-minimum-operations-to-make-a-uni-value-grid.js b/2033-minimum-operations-to-make-a-uni-value-grid.js
index 11b9f977..4f4698c3 100644
--- a/2033-minimum-operations-to-make-a-uni-value-grid.js
+++ b/2033-minimum-operations-to-make-a-uni-value-grid.js
@@ -75,3 +75,31 @@ const minOperations = function(grid, x) {
   return res
 };
 
+// another
+
+/**
+ * @param {number[][]} grid
+ * @param {number} x
+ * @return {number}
+ */
+function minOperations(grid, x) {
+  const m = grid.length, n = grid[0].length, mn = m * n, arr = []
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      arr.push(grid[i][j])
+    }
+  }
+  arr.sort((a, b) => a - b)
+  const mid = arr[~~(mn / 2)]
+  let res = 0
+
+  for(let e of arr) {
+    if(e !== mid) {
+      const delta = Math.abs(e - mid)
+      if(delta % x !== 0) return -1
+      res += delta / x
+    }
+  }
+
+  return res
+};

From fed0822391d356db14683e1887eaf2cda545257d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Oct 2021 21:23:00 +0800
Subject: [PATCH 1714/3374] Create 1113-reported-posts.sql

---
 1113-reported-posts.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 1113-reported-posts.sql

diff --git a/1113-reported-posts.sql b/1113-reported-posts.sql
new file mode 100644
index 00000000..5322b458
--- /dev/null
+++ b/1113-reported-posts.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+select 
+  extra as report_reason
+  ,count(distinct post_id) as report_count
+from Actions
+where action_date = '2019-07-04'
+  and action = 'report'
+group by extra;

From d042d85e4f03108f3c299cf2c7265b6a830727c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Oct 2021 21:29:40 +0800
Subject: [PATCH 1715/3374] Create 1133-largest-unique-number.js

---
 1133-largest-unique-number.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1133-largest-unique-number.js

diff --git a/1133-largest-unique-number.js b/1133-largest-unique-number.js
new file mode 100644
index 00000000..8e9ec0ca
--- /dev/null
+++ b/1133-largest-unique-number.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const largestUniqueNumber = function(nums) {
+   const hash = {}
+   for(let e of nums) {
+     hash[e] = (hash[e] || 0) + 1
+   }
+   let res = -Infinity
+   Object.keys(hash).forEach(k => {
+     if(hash[k] === 1) {
+       if(+k > res) {
+         res = +k
+       }
+     }
+   })
+   return res === -Infinity ? -1 : res
+};

From b6c24d148c8260e4163fac23c10ec306290555fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Oct 2021 21:41:25 +0800
Subject: [PATCH 1716/3374] Create 1134-armstrong-number.js

---
 1134-armstrong-number.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1134-armstrong-number.js

diff --git a/1134-armstrong-number.js b/1134-armstrong-number.js
new file mode 100644
index 00000000..5884e3f4
--- /dev/null
+++ b/1134-armstrong-number.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} n
+ * @return {boolean}
+ */
+const isArmstrong = function(n) {
+    //number of digits in N
+    let k = ~~(Math.log10(n) + 1);
+    //temporary variable (so we dont modify N)
+    let x = n;
+    //to hold sum
+    let sum = 0;
+    //get each digit
+    while (x !== 0) {
+        //add this digit^k to sum
+        sum += Math.pow(x % 10, k);
+        //get next digit
+        x = ~~(x/10);
+    }
+    return sum == n;
+};

From 014b3c168b3398b95e60b0669e0994dcd68e9de8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Oct 2021 09:11:52 +0800
Subject: [PATCH 1717/3374] Update 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 38 ++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
index 4a61666c..e402f90d 100644
--- a/1723-find-minimum-time-to-finish-all-jobs.js
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -45,3 +45,41 @@ const minimumTimeRequired = function (jobs, k) {
   dfs(0)
   return minLongestWorkingTime
 }
+
+// another
+
+/**
+ * @param {number[]} jobs
+ * @param {number} k
+ * @return {number}
+ */
+const minimumTimeRequired = function(jobs, k) {
+  return solution(jobs, k)
+};
+
+function solution(jobs, k) {
+  const n = jobs.length
+  let res = Infinity, arr = Array(k).fill(0)
+
+  let start = 0
+  bt(0)
+  return res
+
+  function bt(idx) {
+   start++
+   if(idx === n) {
+     res = Math.min(res, Math.max(...arr))
+     return
+   }
+   const visited = new Set()
+   for(let j = start; j < start + k; j++) {
+     const i = j % k
+     if(visited.has(arr[i])) continue
+     if(arr[i] + jobs[idx] > res) continue
+     visited.add(arr[i])
+     arr[i] += jobs[idx]
+     bt(idx + 1)
+     arr[i] -= jobs[idx]
+   }
+  } 
+}

From 833b3b2607ec8220e2e1bca22ff22967c9181c07 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Oct 2021 09:30:57 +0800
Subject: [PATCH 1718/3374] Create
 1141-user-activity-for-the-past-30-days-i.sql

---
 1141-user-activity-for-the-past-30-days-i.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 1141-user-activity-for-the-past-30-days-i.sql

diff --git a/1141-user-activity-for-the-past-30-days-i.sql b/1141-user-activity-for-the-past-30-days-i.sql
new file mode 100644
index 00000000..8b46b0d9
--- /dev/null
+++ b/1141-user-activity-for-the-past-30-days-i.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+select activity_date as day, count(distinct user_id) as active_users 
+from Activity
+where datediff('2019-07-27', activity_date) < 30
+group by activity_date;

From b3e5b2668d6177b8abe910243b537cfafe2de597 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Oct 2021 09:40:03 +0800
Subject: [PATCH 1719/3374] Create 1148-article-views-i.sql

---
 1148-article-views-i.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1148-article-views-i.sql

diff --git a/1148-article-views-i.sql b/1148-article-views-i.sql
new file mode 100644
index 00000000..47b0221c
--- /dev/null
+++ b/1148-article-views-i.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT DISTINCT author_id AS id FROM Views 
+where author_id = viewer_id 
+ORDER BY id;

From e56488e00e1d36cd242abcd33eff12aa68dd8ffe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Oct 2021 14:07:14 +0800
Subject: [PATCH 1720/3374] Create
 1150-check-if-a-number-is-majority-element-in-a-sorted-array.js

---
 ...r-is-majority-element-in-a-sorted-array.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1150-check-if-a-number-is-majority-element-in-a-sorted-array.js

diff --git a/1150-check-if-a-number-is-majority-element-in-a-sorted-array.js b/1150-check-if-a-number-is-majority-element-in-a-sorted-array.js
new file mode 100644
index 00000000..53b5b874
--- /dev/null
+++ b/1150-check-if-a-number-is-majority-element-in-a-sorted-array.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {boolean}
+ */
+function isMajorityElement(nums, target) {
+  let firstIdx = bs(nums, target)
+  let endIdx = firstIdx + (~~(nums.length / 2))
+  if(endIdx < nums.length && nums[endIdx] === target) return true
+  return false
+}
+
+function bs(arr, target) {
+  let l = 0, h = arr.length - 1
+  while(l < h) {
+    const mid = l + ((h - l) >> 1)
+    if (arr[mid] < target) l = mid + 1
+    else h = mid
+  }
+  return l
+}

From 0ce2abed300f5869ac45e95113a3b3b2a46a9507 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Oct 2021 14:31:25 +0800
Subject: [PATCH 1721/3374] Create 1165-single-row-keyboard.js

---
 1165-single-row-keyboard.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1165-single-row-keyboard.js

diff --git a/1165-single-row-keyboard.js b/1165-single-row-keyboard.js
new file mode 100644
index 00000000..6a8039f2
--- /dev/null
+++ b/1165-single-row-keyboard.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} keyboard
+ * @param {string} word
+ * @return {number}
+ */
+const calculateTime = function(keyboard, word) {
+  const hash = {}, { abs } = Math
+  for(let i = 0; i < 26; i++) {
+    hash[keyboard[i]] = i
+  }
+  let pre = 0, sum = 0
+  for(const ch of word) {
+    sum += abs(hash[ch] - pre)
+    pre = hash[ch]
+  }
+  return sum
+};

From 8548592a9eb9e45f4558c5b10e35c83dd0574181 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Oct 2021 14:21:59 +0800
Subject: [PATCH 1722/3374] Update 1478-allocate-mailboxes.js

---
 1478-allocate-mailboxes.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1478-allocate-mailboxes.js b/1478-allocate-mailboxes.js
index aac971f9..0281bb7c 100644
--- a/1478-allocate-mailboxes.js
+++ b/1478-allocate-mailboxes.js
@@ -24,3 +24,39 @@ const minDistance = function (A, K) {
   }
   return dp[n - 1]
 }
+
+// another
+
+/**
+ * @param {number[]} houses
+ * @param {number} k
+ * @return {number}
+ */
+function minDistance(houses, k) {
+  const n = houses.length, { abs, min } = Math, INF = Infinity
+  houses.sort((a, b) => a - b)
+  const costs = Array.from({ length: 100 }, () => Array(100).fill(0))
+  const memo = Array.from({ length: 100 }, () => Array(100).fill(null))
+
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < n; j++) {
+      const mid = houses[~~((i + j) >> 1)]
+      for (let k = i; k <= j; k++) costs[i][j] += abs(mid - houses[k])
+    }
+  }
+  
+  return dp(k, 0)
+
+  function dp(k, i) {
+    if (k === 0 && i === n) return 0
+    if (k === 0 || i === n) return INF
+    if (memo[k][i] != null) return memo[k][i]
+    let res = INF
+    for (let j = i; j < n; j++) {
+      res = min(res, costs[i][j] + dp(k - 1, j + 1))
+    }
+
+    return memo[k][i] = res
+  }
+}
+

From ec07531427d0f79ac4c0b90ee3bcec378d889b56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Oct 2021 16:04:40 +0800
Subject: [PATCH 1723/3374] Create 2050-parallel-courses-iii.js

---
 2050-parallel-courses-iii.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2050-parallel-courses-iii.js

diff --git a/2050-parallel-courses-iii.js b/2050-parallel-courses-iii.js
new file mode 100644
index 00000000..288ee388
--- /dev/null
+++ b/2050-parallel-courses-iii.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+const minimumTime = function(n, relations, time) {
+  const graph = {}, dist = Array(n).fill(0), inDegree = Array(n).fill(0)
+  for(let [from, to] of relations) {
+    from--, to--
+    if (graph[from] == null) graph[from] = []
+    graph[from].push(to)
+    inDegree[to]++
+  }
+  const q = []
+  for(let i = 0; i < n; i++) {
+    if(inDegree[i] === 0) {
+      q.push(i)
+      dist[i] = time[i]
+    }
+  }
+
+  while(q.length) {
+    const u = q.shift()
+    for(const v of (graph[u] || [])) {
+      dist[v] = Math.max(dist[v], dist[u] + time[v])
+      if(--inDegree[v] === 0) q.push(v)
+    }
+  }
+
+  let res = 0
+  for(let e of dist) {
+    if(e > res) res = e
+  }
+  return res
+};

From 57f1c620ef9e29d7f30a6556e82a07eb55ec2493 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Oct 2021 16:17:09 +0800
Subject: [PATCH 1724/3374] Create 2047-number-of-valid-words-in-a-sentence.js

---
 2047-number-of-valid-words-in-a-sentence.js | 42 +++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2047-number-of-valid-words-in-a-sentence.js

diff --git a/2047-number-of-valid-words-in-a-sentence.js b/2047-number-of-valid-words-in-a-sentence.js
new file mode 100644
index 00000000..689fb933
--- /dev/null
+++ b/2047-number-of-valid-words-in-a-sentence.js
@@ -0,0 +1,42 @@
+/**
+ * @param {string} sentence
+ * @return {number}
+ */
+const countValidWords = function(s) {
+  const arr = s.split(' ')
+  let res = 0
+  for(const e of arr) {
+    if(e.trim() && valid(e.trim())) res ++
+  }
+  return res
+};
+ 
+function valid(e) {
+  const zi = '0'.charCodeAt(0), ni = '9'.charCodeAt(0)
+  const len = e.length
+  for(const el of e) {
+    if(el.charCodeAt(0) >= zi && el.charCodeAt(0) <= ni) return false
+  }
+  const num = (p, n) => (p >= 'a' && p <= 'z') && (n >= 'a' && n <= 'z')
+  const hi = e.indexOf('-')
+  if(hi !== -1) {
+    if(hi === 0 || hi === e.length - 1 || e.indexOf('-', hi + 1) !== -1 || !num(e[hi - 1], e[hi + 1])) return false
+  }
+  
+  const p1 = e.indexOf('!')
+  if(p1 !== -1) {
+    if((len > 1 && p1 !== e.length - 1) || e.indexOf('-', p1 + 1) !== -1) return false
+  }
+  
+  const p2 = e.indexOf('.')
+  if(p2 !== -1) {
+    if((len > 1 && p2 !== e.length - 1) || e.indexOf('-', p2 + 1) !== -1) return false
+  }
+  
+  const p3 = e.indexOf(',')
+  if(p3 !== -1) {
+    if((len > 1 && p3 !== e.length - 1) || e.indexOf('-', p3 + 1) !== -1) return false
+  }
+  
+  return true
+}

From 70538c736e16eaa575b856b0697d5046480533f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Oct 2021 17:54:32 +0800
Subject: [PATCH 1725/3374] Create
 2048-next-greater-numerically-balanced-number.js

---
 ...ext-greater-numerically-balanced-number.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2048-next-greater-numerically-balanced-number.js

diff --git a/2048-next-greater-numerically-balanced-number.js b/2048-next-greater-numerically-balanced-number.js
new file mode 100644
index 00000000..b19e9e7a
--- /dev/null
+++ b/2048-next-greater-numerically-balanced-number.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const nextBeautifulNumber = function(n) {
+    while (true) {
+        ++n;
+        if (balance(n)) return n;
+    } 
+    function balance(n) {
+        let cnt = Array(10).fill(0);
+        while (n) {
+            if (n % 10 == 0) return false; // no 0 allowed
+            cnt[n % 10]++;
+            n = ~~(n / 10);
+        }
+        for (let i = 1; i < 10; ++i) {
+            if (cnt[i] && cnt[i] !== i) return false;
+        }
+        return true;
+    }
+};
+

From c8103af8d8053b5ad7635e835d57d7f00ae4c3b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Oct 2021 21:23:52 +0800
Subject: [PATCH 1726/3374] Update 373-find-k-pairs-with-smallest-sums.js

---
 373-find-k-pairs-with-smallest-sums.js | 93 ++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/373-find-k-pairs-with-smallest-sums.js b/373-find-k-pairs-with-smallest-sums.js
index 6b4c9123..35fd1146 100644
--- a/373-find-k-pairs-with-smallest-sums.js
+++ b/373-find-k-pairs-with-smallest-sums.js
@@ -1,3 +1,96 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number[][]}
+ */
+const kSmallestPairs = function (nums1, nums2, k) {
+  const pq = new PriorityQueue((a, b) => a[0] + a[1] < b[0] + b[1])
+  for(let i = 0; i < nums1.length && i < k; i++) {
+    pq.push([nums1[i], nums2[0], 0])
+  }
+  const res = []
+  while(k > 0 && !pq.isEmpty()) {
+    const [e1, e2, e2i] = pq.pop()
+    res.push([e1, e2])
+    if(e2i + 1 < nums2.length) pq.push([e1, nums2[e2i + 1], e2i + 1])
+    k--
+  }
+  
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+
+// another
+
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2

From bcede51b99acba3b19bb12b4e34b639ffb4dda30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Oct 2021 08:45:29 +0800
Subject: [PATCH 1727/3374] Update 560-subarray-sum-equals-k.js

---
 560-subarray-sum-equals-k.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/560-subarray-sum-equals-k.js b/560-subarray-sum-equals-k.js
index 5024c772..fd6021d0 100644
--- a/560-subarray-sum-equals-k.js
+++ b/560-subarray-sum-equals-k.js
@@ -21,3 +21,26 @@ const subarraySum = function(nums, k) {
   }
   return totalNum
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarraySum = function (nums, k) {
+  const n = nums.length, hash = { 0: 1 }
+  let pre = 0
+  if (nums.length === 1) {
+    return nums[0] === k ? 1 : 0
+  }
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    const cur = pre + nums[i]
+    if (hash[cur - k] != null) res += hash[cur - k]
+    hash[cur] = (hash[cur] || 0) + 1
+    pre = cur
+  }
+  return res
+}

From 8d357ccf6c34ccf2161cc24a2fda080eabd8992c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Oct 2021 08:46:13 +0800
Subject: [PATCH 1728/3374] Update 560-subarray-sum-equals-k.js

---
 560-subarray-sum-equals-k.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/560-subarray-sum-equals-k.js b/560-subarray-sum-equals-k.js
index fd6021d0..c81bff23 100644
--- a/560-subarray-sum-equals-k.js
+++ b/560-subarray-sum-equals-k.js
@@ -32,9 +32,6 @@ const subarraySum = function(nums, k) {
 const subarraySum = function (nums, k) {
   const n = nums.length, hash = { 0: 1 }
   let pre = 0
-  if (nums.length === 1) {
-    return nums[0] === k ? 1 : 0
-  }
   let res = 0
   for (let i = 0; i < n; i++) {
     const cur = pre + nums[i]

From 3e92383d400a6426fdde576c098b8d13c42991f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Oct 2021 11:25:48 +0800
Subject: [PATCH 1729/3374] Update 719-find-k-th-smallest-pair-distance.js

---
 719-find-k-th-smallest-pair-distance.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/719-find-k-th-smallest-pair-distance.js b/719-find-k-th-smallest-pair-distance.js
index 1ef7c937..63e8a619 100644
--- a/719-find-k-th-smallest-pair-distance.js
+++ b/719-find-k-th-smallest-pair-distance.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+function smallestDistancePair(nums, k) {
+  nums.sort((a, b) => a - b)
+  let l = 0, n = nums.length, r = nums[n - 1] - nums[0]
+  
+  let res = 0
+  while(l < r) {
+    let cnt = 0, mid = l + ((r - l) >> 1)
+    for(let i = 0, j = 0; i < n; i++) {
+      while(j < n && nums[j] <= nums[i] + mid) j++
+      cnt += j - 1 - i
+    }
+    if(cnt < k) l = mid + 1
+    else r = mid
+  }
+
+  return l
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From a25d1a8b64a32b0e5b9d06b3fbb8e288fa75dbb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Oct 2021 20:03:03 +0800
Subject: [PATCH 1730/3374] Create 2049-count-nodes-with-the-highest-score.js

---
 2049-count-nodes-with-the-highest-score.js | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2049-count-nodes-with-the-highest-score.js

diff --git a/2049-count-nodes-with-the-highest-score.js b/2049-count-nodes-with-the-highest-score.js
new file mode 100644
index 00000000..cc8176fc
--- /dev/null
+++ b/2049-count-nodes-with-the-highest-score.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} parents
+ * @return {number}
+ */
+const countHighestScoreNodes = function(parents) {
+  const n = parents.length, graph = {}, hash = {}
+  for(let i = 1; i < n; i++) {
+    if(graph[parents[i]] == null) graph[parents[i]] = []
+    graph[parents[i]].push(i)
+  }
+  dfs(0)
+  
+  function dfs(node) {
+    let product = 1, num = 0
+    for(let child of (graph[node] || [])) {
+      const tmp = dfs(child)
+      product *= tmp
+      num += tmp
+    }
+    if(n - 1 - num > 0) product *= (n - 1 - num)
+    hash[product] = (hash[product] || 0) + 1
+    return num + 1
+  }
+  const maxKey = Math.max(...Object.keys(hash))
+  return hash[maxKey]
+};

From 7f7abea4c59849607ec176f91872ce16bc4ac6ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Oct 2021 09:26:20 +0800
Subject: [PATCH 1731/3374] Create 1918-kth-smallest-subarray-sum.js

---
 1918-kth-smallest-subarray-sum.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1918-kth-smallest-subarray-sum.js

diff --git a/1918-kth-smallest-subarray-sum.js b/1918-kth-smallest-subarray-sum.js
new file mode 100644
index 00000000..cea6e615
--- /dev/null
+++ b/1918-kth-smallest-subarray-sum.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const kthSmallestSubarraySum = function(nums, k) {
+  const sum = nums.reduce((ac, e) => ac + e, 0), n = nums.length
+  let l = 0, r = sum
+  while(l < r) {
+    const mid = l + ((r - l) >> 1)
+    let cnt = 0
+    for(let i = 0, j = 0, tmp = 0; i < n; i++) {
+      tmp += nums[i]
+      while(tmp > mid) tmp -= nums[j++]
+      cnt += i - (j - 1)
+    }
+    if (cnt < k) l = mid + 1
+    else r = mid
+  }
+  return l
+};

From 29724dbdac4679a32502699b37561d3df48c1240 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Oct 2021 10:37:52 +0800
Subject: [PATCH 1732/3374] Create
 2040-kth-smallest-product-of-two-sorted-arrays.js

---
 ...h-smallest-product-of-two-sorted-arrays.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2040-kth-smallest-product-of-two-sorted-arrays.js

diff --git a/2040-kth-smallest-product-of-two-sorted-arrays.js b/2040-kth-smallest-product-of-two-sorted-arrays.js
new file mode 100644
index 00000000..b1f3dadb
--- /dev/null
+++ b/2040-kth-smallest-product-of-two-sorted-arrays.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number}
+ */
+const kthSmallestProduct = function(nums1, nums2, k) {
+  const neg = nums1.filter(e => e < 0)  
+  const pos = nums1.filter(e => e >= 0)
+  const negRev = neg.slice(), posRev = pos.slice()
+  negRev.reverse()
+  posRev.reverse()
+
+  let l = - (10 ** 10), r = 10 ** 10
+  while(l < r) {
+    const mid = l + Math.floor((r - l) / 2)
+    if(fn(mid) < k) l = mid + 1
+    else r = mid
+  } 
+
+  return l
+
+  function fn(val) {
+    let res = 0, n = nums2.length
+    let l = 0, r = n - 1
+    const list = val >= 0 ? negRev.concat(pos) : neg.concat(posRev)
+    for(let e of list) {
+      if(e < 0) {
+        while(l < n && e * nums2[l] > val) l++
+        res += n - l
+      } else if (e === 0) {
+        if(val >= 0) res += n
+      } else {
+        while(r >= 0 && e * nums2[r] > val) r--
+        res += r + 1
+      }
+    }
+    return res
+  }
+};

From 365dd7962c80e58aa16164fb75465cf9c3dc89ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Oct 2021 14:36:57 +0800
Subject: [PATCH 1733/3374] Update
 668-kth-smallest-number-in-multiplication-table.js

---
 ...smallest-number-in-multiplication-table.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/668-kth-smallest-number-in-multiplication-table.js b/668-kth-smallest-number-in-multiplication-table.js
index 41128049..6e15d6e4 100644
--- a/668-kth-smallest-number-in-multiplication-table.js
+++ b/668-kth-smallest-number-in-multiplication-table.js
@@ -30,3 +30,33 @@ function count(m, n, target) {
   }
   return nSmaller;
 }
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const findKthNumber = function(m, n, k) {
+  let left = 1;
+  let right = m * n;
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const num = count(m, n, mid);
+    if (num < k) left = mid + 1;
+    else right = mid;
+  }
+  return left;
+};
+
+function count(m, n, target) {
+  let res = 0;
+  let j = n;
+  for (let i = 1; i <= m; i++) {
+    while (i * j > target) j--
+    res += j;
+  }
+  return res;
+}

From 5b62f50dfb8f29d9bd70eb48fa29996feda18b2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Oct 2021 13:03:24 +0800
Subject: [PATCH 1734/3374] Create
 2060-check-if-an-original-string-exists-given-two-encoded-strings.js

---
 ...string-exists-given-two-encoded-strings.js | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 2060-check-if-an-original-string-exists-given-two-encoded-strings.js

diff --git a/2060-check-if-an-original-string-exists-given-two-encoded-strings.js b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
new file mode 100644
index 00000000..316408e8
--- /dev/null
+++ b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
@@ -0,0 +1,57 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+var possiblyEquals = function (s1, s2) {
+  let n = s1.length
+  let m = s2.length
+  const f = Array.from({ length: 41 }, () =>
+    Array.from({ length: 41 }, () => Array(1001).fill(false))
+  )
+  f[0][0][1000] = true
+
+  for (let i = 0; i <= n; i++)
+    for (let j = 0; j <= m; j++)
+      for (let k = 0; k < 2000; k++) {
+        if (!f[i][j][k]) continue
+        // if k==1000 means length diff is 0, so check both next charactors.
+        if (i + 1 <= n && j + 1 <= m && k == 1000 && s1[i] == s2[j]) {
+          f[i + 1][j + 1][k] = true
+        }
+        // if first string is longer or same length, extend second string.
+        if (k >= 1000 && j + 1 <= m) {
+          if (s2[j] >= 'a' && s2[j] <= 'z') {
+            // do not extend to be a longer string using a-z.
+            if (k > 1000) {
+              f[i][j + 1][k - 1] = true
+            }
+          } else if (s2[j] > '0') {
+            let cur = 0
+            for (let r = j; r < m; r++) {
+              if (s2[r] >= '0' && s2[r] <= '9') {
+                cur = cur * 10 + (s2[r] - '0')
+                f[i][r + 1][k - cur] = true
+              } else break
+            }
+          }
+        }
+        // if second string is longer or same length, extend first string.
+        if (k <= 1000 && i + 1 <= n) {
+          if (s1[i] >= 'a' && s1[i] <= 'z') {
+            if (k < 1000) {
+              f[i + 1][j][k + 1] = true
+            }
+          } else if (s1[i] > '0') {
+            let cur = 0
+            for (let r = i; r < n; r++) {
+              if (s1[r] >= '0' && s1[r] <= '9') {
+                cur = cur * 10 + (s1[r] - '0')
+                f[r + 1][j][k + cur] = true
+              } else break
+            }
+          }
+        }
+      }
+  return f[n][m][1000]
+}

From 81bb83fe911a5836b76d724c9e74a4d6cf1b6e82 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Oct 2021 13:04:11 +0800
Subject: [PATCH 1735/3374] Create 2059-minimum-operations-to-convert-number.js

---
 2059-minimum-operations-to-convert-number.js | 36 ++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2059-minimum-operations-to-convert-number.js

diff --git a/2059-minimum-operations-to-convert-number.js b/2059-minimum-operations-to-convert-number.js
new file mode 100644
index 00000000..05e7efd5
--- /dev/null
+++ b/2059-minimum-operations-to-convert-number.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} start
+ * @param {number} goal
+ * @return {number}
+ */
+var minimumOperations = function (nums, start, goal) {
+  const visited = Array(1001).fill(0)
+  const q = []
+  q.push([start, 0])
+  visited[start] = 1
+  while (q.length) {
+    const [val, idx] = q.shift()
+    if (val === goal) return idx
+    for (let e of nums) {
+      if (val + e === goal) return idx + 1
+      if (val + e <= 1000 && val + e >= 0 && !visited[val + e]) {
+        visited[val + e] = 1
+        q.push([val + e, idx + 1])
+      }
+      if (val - e === goal) return idx + 1
+      if (val - e <= 1000 && val - e >= 0 && !visited[val - e]) {
+        visited[val - e] = 1
+        q.push([val - e, idx + 1])
+      }
+
+      if ((val ^ e) === goal) return idx + 1
+      if ((val ^ e) <= 1000 && (val ^ e) >= 0 && !visited[val ^ e]) {
+        visited[val ^ e] = 1
+        q.push([val ^ e, idx + 1])
+      }
+    }
+  }
+
+  return -1
+}

From f9283c29f478a637c10b4a7f216f1e7b73d7b4d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Oct 2021 13:04:40 +0800
Subject: [PATCH 1736/3374] Create
 2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js

---
 ...number-of-nodes-between-critical-points.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js

diff --git a/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js b/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js
new file mode 100644
index 00000000..efd5d273
--- /dev/null
+++ b/2058-find-the-minimum-and-maximum-number-of-nodes-between-critical-points.js
@@ -0,0 +1,33 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {number[]}
+ */
+const nodesBetweenCriticalPoints = function(head) {
+  const arr = []
+  let cur = head
+  while(cur) {
+    arr.push(cur.val)
+    cur = cur.next
+  }
+  const idxArr = []
+  const n = arr.length
+  for(let i = 1; i < n - 1; i++) {
+    if((arr[i] > arr[i - 1] && arr[i] > arr[i + 1]) || (arr[i] < arr[i - 1] && arr[i] < arr[i + 1])) {
+      idxArr.push(i)
+    }
+  }
+  
+  let min = Infinity, max = -1
+  for(let i = 1; i < idxArr.length; i++) {
+    if(idxArr[i] - idxArr[i - 1] < min) min = idxArr[i] - idxArr[i - 1]
+  }
+  if(idxArr.length > 1) max = idxArr[idxArr.length - 1] - idxArr[0]
+  return [min === Infinity ? -1 : min, max]
+};

From 323b9dc3756684d252edec968ce77457fc010cca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Oct 2021 13:05:04 +0800
Subject: [PATCH 1737/3374] Create 2057-smallest-index-with-equal-value.js

---
 2057-smallest-index-with-equal-value.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 2057-smallest-index-with-equal-value.js

diff --git a/2057-smallest-index-with-equal-value.js b/2057-smallest-index-with-equal-value.js
new file mode 100644
index 00000000..c928e0da
--- /dev/null
+++ b/2057-smallest-index-with-equal-value.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var smallestEqual = function(nums) {
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    if(i % 10 === nums[i]) return i
+  }
+  return -1
+};

From d413d0659a3c0062f49346941446b65baaf86719 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Nov 2021 17:25:38 +0800
Subject: [PATCH 1738/3374] Update
 1263-minimum-moves-to-move-a-box-to-their-target-location.js

---
 ...-to-move-a-box-to-their-target-location.js | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/1263-minimum-moves-to-move-a-box-to-their-target-location.js b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
index 0d950897..b92dbab3 100644
--- a/1263-minimum-moves-to-move-a-box-to-their-target-location.js
+++ b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
@@ -281,3 +281,86 @@ const minPushBox = function (grid) {
   }
 }
 
+// another
+
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+ const minPushBox = function (grid) {
+  const m = grid.length,
+    n = grid[0].length
+  let target, person, box
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] === 'T') target = [i, j]
+      else if (grid[i][j] === 'B') box = [i, j]
+      else if (grid[i][j] === 'S') person = [i, j]
+    }
+  }
+
+  const valid = ([x, y]) => {
+    return x >= 0 && x < m && y >= 0 && y < n && grid[x][y] !== '#'
+  }
+
+  const check = (cur, dest, box) => {
+    const q = [cur]
+    const visited = new Set([`${box[0]},${box[1]}`])
+    const dirs = [
+      [-1, 0],
+      [1, 0],
+      [0, 1],
+      [0, -1],
+    ]
+
+    while (q.length) {
+      const pos = q.shift()
+      if (pos.join(',') === dest.join(',')) return true
+      const newPos = []
+      for (const [dx, dy] of dirs) newPos.push([pos[0] + dx, pos[1] + dy])
+      for (const [nx, ny] of newPos) {
+        const k = `${nx},${ny}`
+        if (valid([nx, ny]) && !visited.has(k)) {
+          visited.add(k)
+          q.push([nx, ny])
+        }
+      }
+    }
+
+    return false
+  }
+
+  const q = [[0, box, person]]
+  const vis = new Set([`${box.join(',')},${person.join(',')}`])
+  while (q.length) {
+    const [dist, box, person] = q.shift()
+    if (box.join(',') === target.join(',')) return dist
+
+    const bCoord = [
+      [box[0] + 1, box[1]],
+      [box[0] - 1, box[1]],
+      [box[0], box[1] + 1],
+      [box[0], box[1] - 1],
+    ]
+    const pCoord = [
+      [box[0] - 1, box[1]],
+      [box[0] + 1, box[1]],
+      [box[0], box[1] - 1],
+      [box[0], box[1] + 1],
+    ]
+
+    for (let i = 0; i < 4; i++) {
+      const [newBox, newPerson] = [bCoord[i], pCoord[i]]
+      const key = `${newBox.join(',')},${box.join(',')}`
+      if (valid(newBox) && !vis.has(key)) {
+        if (valid(newPerson) && check(person, newPerson, box)) {
+          vis.add(key)
+          q.push([dist + 1, newBox, box])
+        }
+      }
+    }
+  }
+
+  return -1
+}
+

From 222e3fa75622394cb7124aa5a23f6989cd7e5ca9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Nov 2021 09:33:23 +0800
Subject: [PATCH 1739/3374] Update 543-diameter-of-binary-tree.js

---
 543-diameter-of-binary-tree.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/543-diameter-of-binary-tree.js b/543-diameter-of-binary-tree.js
index a8d6dd5f..aa2efec2 100755
--- a/543-diameter-of-binary-tree.js
+++ b/543-diameter-of-binary-tree.js
@@ -23,3 +23,30 @@ const diameterOfBinaryTree = function (root) {
   return longest - 1
 }
 
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const diameterOfBinaryTree = function(root) {
+  let res = 0
+  dfs(root)
+  return res
+
+  function dfs(node) {
+    if(node == null) return 0
+    const left = dfs(node.left), right = dfs(node.right)
+    res = Math.max(res, left + right)
+    return Math.max(left, right) + 1
+  }
+};
+

From 45fb60ae65a5e4ee7180ee5fea1c7bfff39ddacb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Nov 2021 10:11:18 +0800
Subject: [PATCH 1740/3374] Update 687-longest-univalue-path.js

---
 687-longest-univalue-path.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/687-longest-univalue-path.js b/687-longest-univalue-path.js
index baa86b5f..123bfd54 100644
--- a/687-longest-univalue-path.js
+++ b/687-longest-univalue-path.js
@@ -1,3 +1,37 @@
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const longestUnivaluePath = function(root) {
+  let res = 0
+  dfs(root)
+  return res
+
+  function dfs(node) {
+    if(node == null) return 0
+    let left = dfs(node.left), right = dfs(node.right)
+    if(node.left && node.left.val === node.val) left++
+    else left = 0
+
+    if(node.right && node.right.val === node.val) right++
+    else right = 0
+
+    res = Math.max(res, left + right)
+    return Math.max(left, right)
+  }
+};
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From a6835c80e891d67c55f59c7a1f85ae4736556b17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Nov 2021 22:17:59 +0800
Subject: [PATCH 1741/3374] Update 224-basic-calculator.js

---
 224-basic-calculator.js | 43 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/224-basic-calculator.js b/224-basic-calculator.js
index 9705eb73..002c0d40 100644
--- a/224-basic-calculator.js
+++ b/224-basic-calculator.js
@@ -34,3 +34,46 @@ const calculate = function(s) {
   }
   return res + sign * num
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  s = s.split(' ').join('')
+  const n = s.length, stack = []
+  const isNum = ch => ch >= '0' && ch <= '9'
+  let num = 0, op = 1, res = 0
+  for(let i = 0; i < n; i++) {
+    const ch = s[i]
+    if(isNum(ch)) {
+      num = num * 10 + (+ch)
+    } else {
+      if(ch === '(') {
+        stack.push(res)
+        stack.push(op)
+        num = 0
+        op = 1
+        res = 0
+      } else if(ch === ')') {
+        res += num * op
+        res *= stack.pop()
+        res += stack.pop()
+        num = 0
+        op = 1
+      } else if(ch === '+') {
+        res += op * num
+        op = 1
+        num = 0
+      } else if(ch === '-') {
+        res += op * num
+        op = -1
+        num = 0
+      }
+    }
+  }
+  
+  return res + op * num
+};

From b1edcb0253691afbf44b80de10f551ba91e2d578 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Nov 2021 20:56:31 +0800
Subject: [PATCH 1742/3374] Create 1266-minimum-time-visiting-all-points.js

---
 1266-minimum-time-visiting-all-points.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1266-minimum-time-visiting-all-points.js

diff --git a/1266-minimum-time-visiting-all-points.js b/1266-minimum-time-visiting-all-points.js
new file mode 100644
index 00000000..3cd447b9
--- /dev/null
+++ b/1266-minimum-time-visiting-all-points.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const minTimeToVisitAllPoints = function(points) {
+  let res = 0
+  for(let i = 1; i < points.length; i++) {
+    res += calc(points[i], points[i - 1])
+  }
+  return res
+  
+  function calc(p1, p2) {
+    const [x1, y1] = p1,  [x2, y2] = p2
+    const { abs, min } = Math
+    const deltaX = abs(x1 - x2), deltaY = abs(y1 - y2)
+    
+    return min(deltaX, deltaY) + abs(deltaX - deltaY)
+  }
+};

From 622269895abf1d4e8cf7d63993afc347196ed0ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Nov 2021 21:00:50 +0800
Subject: [PATCH 1743/3374] Create
 1342-number-of-steps-to-reduce-a-number-to-zero.js

---
 ...-number-of-steps-to-reduce-a-number-to-zero.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1342-number-of-steps-to-reduce-a-number-to-zero.js

diff --git a/1342-number-of-steps-to-reduce-a-number-to-zero.js b/1342-number-of-steps-to-reduce-a-number-to-zero.js
new file mode 100644
index 00000000..9da8bfa9
--- /dev/null
+++ b/1342-number-of-steps-to-reduce-a-number-to-zero.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+const numberOfSteps = function(num) {
+  let res = 0
+  while(num !== 0) {
+    if(num % 2 === 0) {
+      num /= 2
+    } else num--
+    res++
+  }
+  
+  return res
+};

From 46fbc777cb8cf911d06a4fccb32e3f054b04ce57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Nov 2021 21:09:59 +0800
Subject: [PATCH 1744/3374] Create 1213-intersection-of-three-sorted-arrays.js

---
 1213-intersection-of-three-sorted-arrays.js | 31 +++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1213-intersection-of-three-sorted-arrays.js

diff --git a/1213-intersection-of-three-sorted-arrays.js b/1213-intersection-of-three-sorted-arrays.js
new file mode 100644
index 00000000..d0ff8fb3
--- /dev/null
+++ b/1213-intersection-of-three-sorted-arrays.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @param {number[]} arr3
+ * @return {number[]}
+ */
+const arraysIntersection = function(arr1, arr2, arr3) {
+  const common = [], n1 = arr1.length, n2 = arr2.length, n3 = arr3.length
+  let p1 = 0, p2 = 0, p3 = 0
+  while(p1 < n1 && p2 < n2) {
+    if(arr1[p1] === arr2[p2]) {
+      common.push(arr1[p1])
+      p1++
+      p2++
+    } else if(arr1[p1] < arr2[p2]) p1++
+    else p2++
+  }
+  const res = [], nc = common.length
+  let pc = 0
+  while(pc < nc && p3 < n3) {
+    if(common[pc] === arr3[p3]) {
+      res.push(arr3[p3])
+      pc++
+      p3++
+    } else if(common[pc] < arr3[p3]) pc++
+    else p3++
+  }
+  
+  
+  return res
+};

From 505fdea1d9d3328d0400e00c8b620f13a73e7c67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Nov 2021 21:13:17 +0800
Subject: [PATCH 1745/3374] Update 1213-intersection-of-three-sorted-arrays.js

---
 1213-intersection-of-three-sorted-arrays.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1213-intersection-of-three-sorted-arrays.js b/1213-intersection-of-three-sorted-arrays.js
index d0ff8fb3..3984750c 100644
--- a/1213-intersection-of-three-sorted-arrays.js
+++ b/1213-intersection-of-three-sorted-arrays.js
@@ -29,3 +29,24 @@ const arraysIntersection = function(arr1, arr2, arr3) {
   
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @param {number[]} arr3
+ * @return {number[]}
+ */
+const arraysIntersection = function(arr1, arr2, arr3) {
+  let a=0,b=0,c=0;
+  const res = [];
+  while(a<arr1.length && b<arr2.length && c<arr3.length) {
+    let min = Math.min(arr1[a], Math.min(arr2[b],arr3[c]));
+    if(arr1[a] === min && arr2[b] === min && arr3[c] === min) res.push(min);
+    if(arr1[a] === min) a++;
+    if(arr2[b] === min) b++;
+    if(arr3[c] === min) c++;
+  }
+  return res;
+};

From ff5fb9df92efc8f1cf88620a3c44c61657564109 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Nov 2021 21:29:18 +0800
Subject: [PATCH 1746/3374] Create
 1228-missing-number-in-arithmetic-progression.js

---
 1228-missing-number-in-arithmetic-progression.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1228-missing-number-in-arithmetic-progression.js

diff --git a/1228-missing-number-in-arithmetic-progression.js b/1228-missing-number-in-arithmetic-progression.js
new file mode 100644
index 00000000..6bccbb36
--- /dev/null
+++ b/1228-missing-number-in-arithmetic-progression.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const missingNumber = function(arr) {
+  const n = arr.length
+
+  for(let i = 1 ; i < n - 1; i++) {
+    const d1 = arr[i] - arr[i - 1], d2 = arr[i + 1] - arr[i]
+    if(d1 === d2) continue
+    if(d1 / d2 === 2) return arr[i - 1] + d1 / 2
+    if(d2 / d1 === 2) return arr[i] + d2 / 2
+  }
+  return arr[0]
+};

From 9845a381a70e855cdb3aa71e17409729ed976f56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 09:24:50 +0800
Subject: [PATCH 1747/3374] Update 124-binary-tree-maximum-path-sum.js

---
 124-binary-tree-maximum-path-sum.js | 32 +++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/124-binary-tree-maximum-path-sum.js b/124-binary-tree-maximum-path-sum.js
index 5f53f2dc..68e174a9 100644
--- a/124-binary-tree-maximum-path-sum.js
+++ b/124-binary-tree-maximum-path-sum.js
@@ -26,3 +26,35 @@ function traverse(node, obj) {
   return node.val + Math.max(left, right)
 }
 
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const maxPathSum = function(root) {
+  let res = -Infinity
+  dfs(root)
+  return res
+
+  function dfs(node) {
+    if(node == null) return 0
+    let left = dfs(node.left), right = dfs(node.right)
+    res = Math.max(
+      res,
+      node.val,
+      node.val + left,
+      node.val + right,
+      node.val + left + right,
+    )
+    return Math.max(node.val, node.val + left, node.val + right)
+  }
+};

From de52b1418285486d5ef7ccb03ba39bb194004263 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 15:01:58 +0800
Subject: [PATCH 1748/3374] Create 1394-find-lucky-integer-in-an-array.js

---
 1394-find-lucky-integer-in-an-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1394-find-lucky-integer-in-an-array.js

diff --git a/1394-find-lucky-integer-in-an-array.js b/1394-find-lucky-integer-in-an-array.js
new file mode 100644
index 00000000..8805447d
--- /dev/null
+++ b/1394-find-lucky-integer-in-an-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const findLucky = function(arr) {
+  const hash = {}
+  for(let e of arr) hash[e] = (hash[e] || 0) + 1
+  let res
+  Object.keys(hash).forEach(k => {
+    if(+k === hash[k]) {
+      if (res == null) res = hash[k]
+      else {
+        if (hash[k] > res) res = hash[k]
+      }
+    } 
+  })
+  return res == null ? -1 : res
+};

From f6f52d04e71a46b43aa395590160587783590c4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 15:33:51 +0800
Subject: [PATCH 1749/3374] Create 1441-build-an-array-with-stack-operations.js

---
 1441-build-an-array-with-stack-operations.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1441-build-an-array-with-stack-operations.js

diff --git a/1441-build-an-array-with-stack-operations.js b/1441-build-an-array-with-stack-operations.js
new file mode 100644
index 00000000..7cadddb6
--- /dev/null
+++ b/1441-build-an-array-with-stack-operations.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} target
+ * @param {number} n
+ * @return {string[]}
+ */
+ const buildArray = function(target, n) {
+  const res = []
+  let ti = 0, ni = 1, num = 0
+  while(num !== target.length && ni <= n) {
+    if(ni !== target[ti]) {
+      res.push('Push', 'Pop')
+      ni++
+    }else {
+      res.push('Push')
+      ni++
+      num++
+      ti++
+    }
+  }
+
+  return res
+};

From 83fb8fd2a2eb04b09ed7f2afc784a74285729926 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 16:12:37 +0800
Subject: [PATCH 1750/3374] Create 1991-find-the-middle-index-in-array.js

---
 1991-find-the-middle-index-in-array.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1991-find-the-middle-index-in-array.js

diff --git a/1991-find-the-middle-index-in-array.js b/1991-find-the-middle-index-in-array.js
new file mode 100644
index 00000000..7cd927ea
--- /dev/null
+++ b/1991-find-the-middle-index-in-array.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMiddleIndex = function(nums) {
+  const n = nums.length, leftSum = Array(n + 1).fill(0)
+  const sum = nums.reduce((ac, e) => ac + e, 0) 
+  for(let i = 0; i < n; i++) {
+    leftSum[i+1] = leftSum[i] + nums[i]
+  }
+
+  let res
+  for(let i = 0; i < n; i++) {
+    if(leftSum[i] === sum - leftSum[i] - nums[i]) {
+      res = i
+      break
+    }
+  }
+
+  return res == null ? -1 : res
+};

From 9004782b244ed266ca464cc80d028a30251f075c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 16:14:47 +0800
Subject: [PATCH 1751/3374] Update 1991-find-the-middle-index-in-array.js

---
 1991-find-the-middle-index-in-array.js | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/1991-find-the-middle-index-in-array.js b/1991-find-the-middle-index-in-array.js
index 7cd927ea..e2d5fcea 100644
--- a/1991-find-the-middle-index-in-array.js
+++ b/1991-find-the-middle-index-in-array.js
@@ -3,18 +3,16 @@
  * @return {number}
  */
 const findMiddleIndex = function(nums) {
-  const n = nums.length, leftSum = Array(n + 1).fill(0)
+  const n = nums.length
   const sum = nums.reduce((ac, e) => ac + e, 0) 
+  
+  let res, leftSum = 0
   for(let i = 0; i < n; i++) {
-    leftSum[i+1] = leftSum[i] + nums[i]
-  }
-
-  let res
-  for(let i = 0; i < n; i++) {
-    if(leftSum[i] === sum - leftSum[i] - nums[i]) {
+    if(leftSum === sum - leftSum - nums[i]) {
       res = i
       break
     }
+    leftSum += nums[i]
   }
 
   return res == null ? -1 : res

From 095273b830e384c3536427e845a6e30b1c8be165 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Nov 2021 16:46:58 +0800
Subject: [PATCH 1752/3374] Create
 1309-decrypt-string-from-alphabet-to-integer-mapping.js

---
 ...string-from-alphabet-to-integer-mapping.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1309-decrypt-string-from-alphabet-to-integer-mapping.js

diff --git a/1309-decrypt-string-from-alphabet-to-integer-mapping.js b/1309-decrypt-string-from-alphabet-to-integer-mapping.js
new file mode 100644
index 00000000..01066f4f
--- /dev/null
+++ b/1309-decrypt-string-from-alphabet-to-integer-mapping.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const freqAlphabets = function(s) {
+  const n = s.length, a = 'a'.charCodeAt(0) - 1
+  let res = '', cur = '', num = 0
+
+  for(let i = n - 1; i >= 0; i--) {
+    const ch = s[i]
+    if(cur === '') {
+      if(ch === '#') {
+        cur = ch
+        num = 0
+      } else{
+        res = (String.fromCharCode(a + (+ch))) + res
+      }
+    } else {
+      if (num < 1) {
+        cur = ch + cur
+        num++
+      } else {
+        cur = ch + cur
+        const tmp = cur.slice(0,cur.length - 1)
+        res = (String.fromCharCode(a + (+tmp))) + res
+        cur = ''
+        num = 0
+      }
+    }
+  }
+  return res
+};

From aeaa1dc22481f71364422b053ecd26b4e25664ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Nov 2021 18:51:46 +0800
Subject: [PATCH 1753/3374] Update 207-course-schedule.js

---
 207-course-schedule.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/207-course-schedule.js b/207-course-schedule.js
index bbec50c5..1b6c9473 100644
--- a/207-course-schedule.js
+++ b/207-course-schedule.js
@@ -72,3 +72,40 @@ const canFinish = function(vertices, edges) {
   }
   return sortedOrder.length === vertices ? true : false
 }
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+const canFinish = function(numCourses, prerequisites) {
+  const set = new Set(), hash = {}
+  for(let i = 0; i < prerequisites.length; i++) {
+    const [cur, pre] = prerequisites[i]
+    if(hash[cur] == null) hash[cur] = new Set()
+    hash[cur].add(pre)
+  }
+  const q = []
+
+  for(let i = 0; i < numCourses; i++) {
+    if(hash[i] == null) q.push(i)
+  }
+  let visited = 0
+
+  while(q.length) {
+    const cur = q.shift()
+    visited++
+    Object.keys(hash).forEach(k => {
+       if(hash[k].has(cur)) {
+         hash[k].delete(cur)
+       }
+       if(hash[k].size === 0) {
+         delete hash[k]
+         q.push(+k)
+       }
+    })
+  }
+  return visited === numCourses
+};

From eff4d7da456238603eee58b079ee42409b0d7112 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Nov 2021 21:36:56 +0800
Subject: [PATCH 1754/3374] Update 207-course-schedule.js

---
 207-course-schedule.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/207-course-schedule.js b/207-course-schedule.js
index 1b6c9473..26831e37 100644
--- a/207-course-schedule.js
+++ b/207-course-schedule.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+const canFinish = function(numCourses, prerequisites) {
+  const [graph, inDegree] = buildGraph(numCourses, prerequisites)
+  
+  const q = []
+  for(let i = 0; i < numCourses; i++) {
+    if(inDegree.get(i) == null) q.push(i)
+  }
+  let num = 0
+  while(q.length) {
+    const pre = q.pop()
+    num++
+    for(const next of (graph.get(pre) || [])) {
+      inDegree.set(next, inDegree.get(next) - 1)
+      if(inDegree.get(next) === 0) q.push(next)
+    }
+  }
+  return num === numCourses
+  
+  
+  function buildGraph(n, arr) {
+    const res = new Map(), inDegree = new Map()
+    for(const [cur, pre] of arr) {
+      if(res.get(pre) == null) res.set(pre, new Set())
+      res.get(pre).add(cur)
+      if(inDegree.get(cur) == null) inDegree.set(cur, 0)
+      inDegree.set(cur, inDegree.get(cur) + 1)
+    }
+    return [res, inDegree]
+  }
+};
+
+// another
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From ecdade323771b1277da83a9cf38c5c8757bef171 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Nov 2021 12:50:12 +0800
Subject: [PATCH 1755/3374] Create 2065-maximum-path-quality-of-a-graph.js

---
 2065-maximum-path-quality-of-a-graph.js | 39 +++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2065-maximum-path-quality-of-a-graph.js

diff --git a/2065-maximum-path-quality-of-a-graph.js b/2065-maximum-path-quality-of-a-graph.js
new file mode 100644
index 00000000..419e1986
--- /dev/null
+++ b/2065-maximum-path-quality-of-a-graph.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} values
+ * @param {number[][]} edges
+ * @param {number} maxTime
+ * @return {number}
+ */
+const maximalPathQuality = function(values, edges, maxTime) {
+    let zeroMax = 0;
+    let n = values.length;
+    let ll = Array.from({length: n + 1}, () => [])
+    for (let edge of edges) {
+      let u = edge[0];
+      let v = edge[1];
+      let t = edge[2];
+      ll[u].push([v, t]);
+      ll[v].push([u, t]);
+    }
+    const visited = Array(n + 1).fill(false);
+    dfs(0, 0, 0, maxTime, visited);
+    return zeroMax;
+
+    function dfs(val,  curNode,  curTime,  maxTime, visited) {
+      if (curTime > maxTime) {
+        return;
+      }
+      let before = visited[curNode];
+      if (!visited[curNode]) {
+        val += values[curNode];
+        visited[curNode] = true;
+      }
+      if (curNode == 0) {
+        zeroMax = Math.max(zeroMax, val);
+      }
+      for (let next of (ll[curNode] || [])) {
+        dfs(val, next[0], curTime + next[1], maxTime, visited);
+      }
+      visited[curNode] = before;
+    }
+};

From 7c0abb666675ce552e02983bae779dda4a9dd35a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Nov 2021 12:50:56 +0800
Subject: [PATCH 1756/3374] Create
 2064-minimized-maximum-of-products-distributed-to-any-store.js

---
 ...um-of-products-distributed-to-any-store.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2064-minimized-maximum-of-products-distributed-to-any-store.js

diff --git a/2064-minimized-maximum-of-products-distributed-to-any-store.js b/2064-minimized-maximum-of-products-distributed-to-any-store.js
new file mode 100644
index 00000000..d6b13e04
--- /dev/null
+++ b/2064-minimized-maximum-of-products-distributed-to-any-store.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @param {number[]} quantities
+ * @return {number}
+ */
+var minimizedMaximum = function(n, quantities) {
+     let MAX = 0;
+    for (let x of quantities) MAX = Math.max(x, MAX);
+    let l = 1, r = MAX;
+    while (l < r) {
+        let mid = Math.floor((l + r) / 2);
+        if (valid(quantities, mid) <= n) r = mid;
+        else l = mid + 1;
+    }
+    return l; 
+};
+
+
+
+  function valid(quantities,  max) {
+      let cnt = 0;
+      for (let x of quantities) cnt += Math.floor(x / max) + ((x % max) ? 1 : 0);
+      return cnt;
+  }

From 45646058d4180cf6213dce9dcca5470774b4ba20 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Nov 2021 12:51:37 +0800
Subject: [PATCH 1757/3374] Create 2063-vowels-of-all-substrings.js

---
 2063-vowels-of-all-substrings.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2063-vowels-of-all-substrings.js

diff --git a/2063-vowels-of-all-substrings.js b/2063-vowels-of-all-substrings.js
new file mode 100644
index 00000000..f05e18ed
--- /dev/null
+++ b/2063-vowels-of-all-substrings.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const countVowels = function(word) {
+  let res = 0n
+  const n = BigInt(word.length)
+  const set = new Set(['a', 'e', 'i', 'o', 'u'])
+  const dp = Array(n + 1n).fill(0n)
+  for(let i = 0n; i < n; i++) {
+    const ch = word[i]
+    if(set.has(ch)) dp[i + 1n] = dp[i] + (i + 1n)
+    else dp[i + 1n] = dp[i]
+  }
+  
+  for(const e of dp) res += e
+  return res
+};
+
+

From 8e571f757b134e66f6bab0d2e7dcfd4ed0b61bf1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Nov 2021 12:52:07 +0800
Subject: [PATCH 1758/3374] Create 2062-count-vowel-substrings-of-a-string.js

---
 2062-count-vowel-substrings-of-a-string.js | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2062-count-vowel-substrings-of-a-string.js

diff --git a/2062-count-vowel-substrings-of-a-string.js b/2062-count-vowel-substrings-of-a-string.js
new file mode 100644
index 00000000..6645120c
--- /dev/null
+++ b/2062-count-vowel-substrings-of-a-string.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const countVowelSubstrings = function(word) {
+  let res = 0, n= word.length
+  for(let i = 0; i < n - 1;i++) {
+    for(let j = i + 1;j < n; j++) {
+      if(valid(word, i, j)) res++
+    }
+  }
+  
+  return res
+  
+  function valid(s, i, j) {
+    const set = new Set(['a', 'e', 'i', 'o','u'])
+    const vis = new Set()
+    for(let idx = i; idx <= j; idx++) {
+      if(!set.has(s[idx])) return false
+      else {
+        vis.add(s[idx])
+      }
+    }
+    // console.log(vis)
+    return vis.size === 5
+  }
+};

From e6a54230c86969051548a000f8d29a47b2f76fc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Nov 2021 19:44:20 +0800
Subject: [PATCH 1759/3374] Update 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index 33ec5f9c..f9a76d50 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -20,3 +20,28 @@ const checkIfPrerequisite = function(numCourses, prerequisites, queries) {
   for(let q of queries) res.push(connected[q[0]][q[1]])
   return res
 };
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const checkIfPrerequisite = function (numCourses, prerequisites, queries) {
+  const n = numCourses
+  const connected = Array.from({ length: n }, () => Array(n).fill(false))
+  for (let p of prerequisites) connected[p[0]][p[1]] = true
+  for (let k = 0; k < n; k++) {
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        connected[i][j] =
+          connected[i][j] || (connected[i][k] && connected[k][j])
+      }
+    }
+  }
+  const res = []
+  for (let q of queries) res.push(connected[q[0]][q[1]])
+  return res
+}

From 1d6d10abde06a96ea113719bd21fcaf7642850dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Nov 2021 21:23:02 +0800
Subject: [PATCH 1760/3374] Update 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index f9a76d50..3d882210 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -45,3 +45,41 @@ const checkIfPrerequisite = function (numCourses, prerequisites, queries) {
   for (let q of queries) res.push(connected[q[0]][q[1]])
   return res
 }
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const checkIfPrerequisite = function (numCourses, prerequisites, queries) {
+  const graph = {},
+    connected = Array.from({ length: numCourses }, () =>
+      Array(numCourses).fill(-1)
+    )
+  for (const [u, v] of prerequisites) {
+    if (graph[u] == null) graph[u] = []
+    graph[u].push(v)
+    connected[u][v] = 1
+  }
+
+  const res = []
+  for (const [u, v] of queries) res.push(dfs(u, v))
+
+  return res
+
+  function dfs(u, v) {
+    if (connected[u][v] !== -1) return connected[u][v]
+    let res = false
+    for (const next of graph[u] || []) {
+      if (!res) {
+        res ||= dfs(next, v)
+      } else break
+    }
+    connected[u][v] = res
+    return res
+  }
+}
+

From bee98e332bab4518eac55bfc8c9c84d7a5bb7e53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Nov 2021 16:27:46 +0800
Subject: [PATCH 1761/3374] Update 2050-parallel-courses-iii.js

---
 2050-parallel-courses-iii.js | 39 ++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/2050-parallel-courses-iii.js b/2050-parallel-courses-iii.js
index 288ee388..97ad7213 100644
--- a/2050-parallel-courses-iii.js
+++ b/2050-parallel-courses-iii.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+const minimumTime = function(n, relations, time) {
+  const graph = {}, dist = Array(n).fill(0), inDegree = Array(n).fill(0)
+  
+  for(let [pre, next] of relations) {
+    pre--, next--
+    if(graph[pre] == null) graph[pre] = []
+    graph[pre].push(next)
+    inDegree[next]++
+  }
+
+  const q = []
+  for(let i = 0; i < n; i++) {
+    if(inDegree[i] === 0) {
+      q.push(i)
+      dist[i] = time[i]
+    }
+  }
+
+  let res = 0
+  while(q.length) {
+    const cur = q.shift()
+    for(const next of (graph[cur] || [])) {
+      dist[next] = Math.max(dist[next], dist[cur] + time[next])
+      inDegree[next]--
+      if(inDegree[next] === 0) q.push(next)
+    }
+  }
+  
+  return Math.max(...dist)
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} relations

From 613f7e1862705e461d17d8324353dfaeafaacd17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Nov 2021 19:27:55 +0800
Subject: [PATCH 1762/3374] Create 1260-shift-2d-grid.js

---
 1260-shift-2d-grid.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1260-shift-2d-grid.js

diff --git a/1260-shift-2d-grid.js b/1260-shift-2d-grid.js
new file mode 100644
index 00000000..e5ede767
--- /dev/null
+++ b/1260-shift-2d-grid.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number[][]}
+ */
+const shiftGrid = function(grid, k) {
+  for(let i = 0; i < k; i++) once(grid)
+  return grid
+};
+
+function once(grid) {
+  const m = grid.length, n = grid[0].length
+  let last = grid[m - 1][n - 1]
+  for(let i = 0; i < m; i++) {
+    let pre = grid[i][0]
+    for(let j = 1; j < n; j++) {
+      let cur = grid[i][j]
+      grid[i][j] = pre
+      pre = cur
+    }
+    grid[i][0] = last
+    last = pre
+  }
+}

From 4f6ee0cabfee6e30ece8305460f3a038d6146343 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Nov 2021 13:43:53 +0800
Subject: [PATCH 1763/3374] Update 1246-palindrome-removal.js

---
 1246-palindrome-removal.js | 54 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1246-palindrome-removal.js b/1246-palindrome-removal.js
index a7947edc..0ba60612 100644
--- a/1246-palindrome-removal.js
+++ b/1246-palindrome-removal.js
@@ -34,3 +34,57 @@ const minimumMoves = function (arr) {
   }
   return dp[0][n - 1]
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+ const minimumMoves = function (arr) {
+  const n = arr.length
+  
+  const dp = Array.from({ length: n }, () => Array(n).fill(n))
+ 
+  for(let i = 0; i < n; i++) dp[i][i] = 1
+  for(let i = 0; i < n - 1; i++) {
+    dp[i][i + 1] = arr[i] === arr[i + 1] ? 1 : 2
+  }
+
+  for(let size = 3; size <= n; size++) {
+    for(let i = 0; i + size - 1 < n; i++) {
+      const right = i + size - 1
+      if(arr[i] === arr[right]) dp[i][right] = dp[i + 1][right - 1]
+      for(let j = i; j < right; j++) {
+        dp[i][right] = Math.min(dp[i][right], dp[i][j] + dp[j + 1][right])
+      }
+    }
+  }
+
+  return dp[0][n - 1]
+}/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+ const minimumMoves = function (arr) {
+  const n = arr.length
+  
+  const dp = Array.from({ length: n }, () => Array(n).fill(n))
+ 
+  for(let i = 0; i < n; i++) dp[i][i] = 1
+  for(let i = 0; i < n - 1; i++) {
+    dp[i][i + 1] = arr[i] === arr[i + 1] ? 1 : 2
+  }
+
+  for(let size = 3; size <= n; size++) {
+    for(let i = 0; i + size - 1 < n; i++) {
+      const right = i + size - 1
+      if(arr[i] === arr[right]) dp[i][right] = dp[i + 1][right - 1]
+      for(let j = i; j < right; j++) {
+        dp[i][right] = Math.min(dp[i][right], dp[i][j] + dp[j + 1][right])
+      }
+    }
+  }
+
+  return dp[0][n - 1]
+}

From fa61bf1824dedc8ecbca591fda43a90437b0f63a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Nov 2021 13:44:19 +0800
Subject: [PATCH 1764/3374] Update 1246-palindrome-removal.js

---
 1246-palindrome-removal.js | 25 -------------------------
 1 file changed, 25 deletions(-)

diff --git a/1246-palindrome-removal.js b/1246-palindrome-removal.js
index 0ba60612..f73084af 100644
--- a/1246-palindrome-removal.js
+++ b/1246-palindrome-removal.js
@@ -62,29 +62,4 @@ const minimumMoves = function (arr) {
   }
 
   return dp[0][n - 1]
-}/**
- * @param {number[]} arr
- * @return {number}
- */
- const minimumMoves = function (arr) {
-  const n = arr.length
-  
-  const dp = Array.from({ length: n }, () => Array(n).fill(n))
- 
-  for(let i = 0; i < n; i++) dp[i][i] = 1
-  for(let i = 0; i < n - 1; i++) {
-    dp[i][i + 1] = arr[i] === arr[i + 1] ? 1 : 2
-  }
-
-  for(let size = 3; size <= n; size++) {
-    for(let i = 0; i + size - 1 < n; i++) {
-      const right = i + size - 1
-      if(arr[i] === arr[right]) dp[i][right] = dp[i + 1][right - 1]
-      for(let j = i; j < right; j++) {
-        dp[i][right] = Math.min(dp[i][right], dp[i][j] + dp[j + 1][right])
-      }
-    }
-  }
-
-  return dp[0][n - 1]
 }

From 75c039aa85b698d9265a105c895d6f1c111a0856 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Nov 2021 16:41:43 +0800
Subject: [PATCH 1765/3374] Update 312-burst-balloons.js

---
 312-burst-balloons.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/312-burst-balloons.js b/312-burst-balloons.js
index 1509854d..a6cb9fa8 100644
--- a/312-burst-balloons.js
+++ b/312-burst-balloons.js
@@ -1,3 +1,28 @@
+function maxCoins(arr) {
+  const len = arr.length
+  const nums = Array(len + 2).fill(0);
+  let n = 1;
+  for (const x of arr) if (x > 0) nums[n++] = x;
+  nums[0] = nums[n++] = 1;
+
+  const dp = Array.from({ length: n }, () => Array(n).fill(0));
+  for (let k = 2; k < n; k++) {
+    for (let left = 0; left < n - k; left++) {
+      let right = left + k;
+      for (let i = left + 1; i < right; i++) {
+        dp[left][right] = Math.max(
+          dp[left][right],
+          nums[left] * nums[i] * nums[right] + dp[left][i] + dp[i][right],
+        );
+      }
+    }
+  }
+
+  return dp[0][n - 1];
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From b80d4815f1b6938af99eb81a56e66d3126e41130 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Nov 2021 20:13:18 +0800
Subject: [PATCH 1766/3374] Create 2073-time-needed-to-buy-tickets.js

---
 2073-time-needed-to-buy-tickets.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2073-time-needed-to-buy-tickets.js

diff --git a/2073-time-needed-to-buy-tickets.js b/2073-time-needed-to-buy-tickets.js
new file mode 100644
index 00000000..f468ef72
--- /dev/null
+++ b/2073-time-needed-to-buy-tickets.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} tickets
+ * @param {number} k
+ * @return {number}
+ */
+const timeRequiredToBuy = function(tickets, k) {
+  let res = 0
+  
+  while(tickets[k] !== 0) {
+    res += helper(tickets, k)
+  }
+  
+  return res
+  
+  function helper(arr, k) {
+    let tmp = 0
+    for(let i = 0; i < arr.length; i++) {
+      if(arr[i] > 0) {
+        arr[i]--
+        tmp++
+      }
+      if(arr[k] === 0) break
+    }
+    return tmp
+  }
+  
+};

From cee6733b945d3b3d9e52e73c455b792e8063ae43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Nov 2021 20:13:47 +0800
Subject: [PATCH 1767/3374] Create 2074-reverse-nodes-in-even-length-groups.js

---
 2074-reverse-nodes-in-even-length-groups.js | 41 +++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 2074-reverse-nodes-in-even-length-groups.js

diff --git a/2074-reverse-nodes-in-even-length-groups.js b/2074-reverse-nodes-in-even-length-groups.js
new file mode 100644
index 00000000..357cdfb3
--- /dev/null
+++ b/2074-reverse-nodes-in-even-length-groups.js
@@ -0,0 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const reverseEvenLengthGroups = function(head) {
+  const arr = []
+  let cur = head
+  while(cur) {
+    arr.push(cur)
+    cur = cur.next
+  }
+  let len = 1, res = []
+  for(let i = 0, n = arr.length; i < n; ) {
+    let backup = len, tmp = [], rev = len % 2 === 0
+    while(len && i < n) {
+      tmp.push(arr[i])
+      i++
+      len--
+    }
+    if((tmp.length % 2 === 0) ) {
+      tmp.reverse()
+    }
+    res.push(...tmp)
+    len = backup + 1
+  }
+  for(let i = 0; i < res.length; i++) {
+    if(i === res.length - 1) res[i].next = null
+    else {
+      res[i].next = res[i + 1]
+    }
+  }
+  
+  return res[0]
+};

From 4a0899ba1fe2de8164b43577075835dccd6cb483 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Nov 2021 20:20:15 +0800
Subject: [PATCH 1768/3374] Create 2075-decode-the-slanted-ciphertext.js

---
 2075-decode-the-slanted-ciphertext.js | 29 +++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2075-decode-the-slanted-ciphertext.js

diff --git a/2075-decode-the-slanted-ciphertext.js b/2075-decode-the-slanted-ciphertext.js
new file mode 100644
index 00000000..d0b88b7d
--- /dev/null
+++ b/2075-decode-the-slanted-ciphertext.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} encodedText
+ * @param {number} rows
+ * @return {string}
+ */
+var decodeCiphertext = function(encodedText, rows) {
+    let n = encodedText.length;
+    let cols = ~~(n / rows);
+    const matrix = Array.from({ length: rows }, () => Array(cols).fill('')) 
+    for (let i = 0; i < rows; i++) {
+        for (let j = 0; j < cols; j++) {
+          matrix[i][j] = encodedText[i * cols + j];
+        }
+    }
+    let ans = "";
+    for (let i = 0; i < cols; i++) {
+        let t = Math.min(rows, cols - i);
+        for (let j = 0; j < t; j++) {
+          ans += matrix[j][i + j];
+        }
+    }
+    let idx = ans.length - 1
+    for(; idx >= 0; idx--) {
+      if(ans[idx] === ' ') continue
+      else break
+    }
+    return ans.slice(0, idx + 1);
+};
+

From 8a95fdf908c10c3669d2595a37da51b7a609ab23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Nov 2021 20:29:13 +0800
Subject: [PATCH 1769/3374] Create 2076-process-restricted-friend-requests.js

---
 2076-process-restricted-friend-requests.js | 40 ++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2076-process-restricted-friend-requests.js

diff --git a/2076-process-restricted-friend-requests.js b/2076-process-restricted-friend-requests.js
new file mode 100644
index 00000000..a757b1c9
--- /dev/null
+++ b/2076-process-restricted-friend-requests.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} n
+ * @param {number[][]} restrictions
+ * @param {number[][]} requests
+ * @return {boolean[]}
+ */
+var friendRequests = function(n, restrictions, requests) {
+        function validation(arr) {
+            for (const [x, y] of restrictions) {
+                if (arr[x] == arr[y]) return false              
+            }
+
+            return true
+        }
+
+
+
+        let groupId = []
+        for(let i = 0; i < n; i++) groupId.push(i) 
+
+
+        const ans = []
+        for(let [u, v] of requests) {
+            if (v < u) [u, v] = [v, u]
+            const tmp = groupId.slice()
+
+            for(let i = 0; i < n; i++) {
+                if (tmp[i] == groupId[v]) tmp[i] = groupId[u]              
+            }
+
+            if (validation(tmp)) {
+                ans.push(true)
+                groupId = tmp
+            } else ans.push(false)
+        }
+
+
+        return ans  
+};
+

From 73dff679a61ab180deddf73a848529b52b64a11a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Nov 2021 10:18:44 +0800
Subject: [PATCH 1770/3374] Update
 524-longest-word-in-dictionary-through-deleting.js

---
 ...est-word-in-dictionary-through-deleting.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/524-longest-word-in-dictionary-through-deleting.js b/524-longest-word-in-dictionary-through-deleting.js
index ffd815ae..70141249 100644
--- a/524-longest-word-in-dictionary-through-deleting.js
+++ b/524-longest-word-in-dictionary-through-deleting.js
@@ -1,3 +1,26 @@
+/**
+ * @param {string} s
+ * @param {string[]} dictionary
+ * @return {string}
+ */
+ const findLongestWord = function(s, dictionary) {
+  let res = ''
+  for (const word of dictionary) {
+    let j = 0
+    for (let i = 0, len = s.length; i < len; i++) {
+      if(word[j] === s[i]) j++
+      if(j === word.length) {
+        if(word.length > res.length) res = word
+        else if(word.length === res.length && word < res) res = word
+        break
+      }
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string[]} dictionary

From 6426e976e951b97183e60a2273c0b1cacfd9d540 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Nov 2021 13:51:22 +0800
Subject: [PATCH 1771/3374] Update 727-minimum-window-subsequence.js

---
 727-minimum-window-subsequence.js | 39 +++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/727-minimum-window-subsequence.js b/727-minimum-window-subsequence.js
index c75b04cc..ce26ad1b 100644
--- a/727-minimum-window-subsequence.js
+++ b/727-minimum-window-subsequence.js
@@ -1,3 +1,42 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string}
+ */
+const minWindow = function (s1, s2) {
+  let n1 = s1.length,
+    n2 = s2.length,
+    s1Idx = 0,
+    s2Idx = 0,
+    start = -1,
+    len = n1 + 1
+  while (s1Idx < n1) {
+    if (s1[s1Idx] === s2[s2Idx]) {
+      if (s2Idx === n2 - 1) {
+        const end = s1Idx
+        while (s2Idx >= 0) {
+          while (s1[s1Idx] !== s2[s2Idx]) s1Idx--
+          s2Idx--
+          s1Idx--
+        }
+        const tmp = end - s1Idx
+        if (tmp < len) {
+          len = tmp
+          start = s1Idx + 1
+        }
+        s2Idx++
+        s1Idx += 2
+      } else {
+        s2Idx++
+        s1Idx++
+      }
+    } else s1Idx++
+  }
+  return start === -1 ? '' : s1.slice(start, start + len)
+}
+
+// another
+
 /**
  * @param {string} s1
  * @param {string} s2

From c58974cf14f6dd546e58259149c507ae63d73e15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Nov 2021 15:53:34 +0800
Subject: [PATCH 1772/3374] Create 2055-plates-between-candles.js

---
 2055-plates-between-candles.js | 38 ++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2055-plates-between-candles.js

diff --git a/2055-plates-between-candles.js b/2055-plates-between-candles.js
new file mode 100644
index 00000000..a5f6cc3a
--- /dev/null
+++ b/2055-plates-between-candles.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string} s
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const platesBetweenCandles = function(s, queries) {
+  const n = s.length,
+    leftCandlePos = Array(n).fill(-1)
+    rightCandlePos = Array(n).fill(-1)
+    candleCnt = Array(n).fill(0)
+  let pos = -1
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '|') pos = i
+    leftCandlePos[i] = pos
+  }
+  pos = -1
+  for(let i = n - 1; i >= 0; i--) {
+    if(s[i] === '|') pos = i
+    rightCandlePos[i] = pos
+  }
+  for(let i = 0, cnt = 0; i < n; i++) {
+    if(s[i] === '|') cnt++
+    candleCnt[i] = cnt
+  }
+
+  const len = queries.length, res = Array(len).fill(0)
+
+  for(let i = 0; i < len; i++) {
+    const [left, right] = queries[i]
+    const leftCandle = rightCandlePos[left], rightCandle = leftCandlePos[right]
+    const delta = rightCandle - leftCandle
+    if(leftCandle !== -1 && rightCandle !== -1 && delta > 1) {
+      res[i] = delta + 1 - (candleCnt[rightCandle] - candleCnt[leftCandle] + 1)
+    }
+  }
+
+  return res
+}

From d234e833852920dbb8f153b25900064c4f3393cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 14:22:18 +0800
Subject: [PATCH 1773/3374] Create 2054-two-best-non-overlapping-events.js

---
 2054-two-best-non-overlapping-events.js | 30 +++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2054-two-best-non-overlapping-events.js

diff --git a/2054-two-best-non-overlapping-events.js b/2054-two-best-non-overlapping-events.js
new file mode 100644
index 00000000..a7037b03
--- /dev/null
+++ b/2054-two-best-non-overlapping-events.js
@@ -0,0 +1,30 @@
+
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+const maxTwoEvents = function(events) {
+  const n = events.length
+  events.sort((a, b) => a[0] - b[0])
+  const dp = Array.from({ length: n }, () => Array(3).fill(-1))
+
+  return dfs(0, 0)
+
+  function dfs(idx, cnt) {
+    if(cnt === 2 || idx >= n) return 0
+    if(dp[idx][cnt] === -1) {
+      let end = events[idx][1]
+      let lo = idx + 1, hi = n - 1;
+      while (lo < hi) {
+        const mid = lo + ((hi - lo) >> 1);
+        if (events[mid][0] <= end) lo = mid + 1
+        else hi = mid;
+      }
+      const include = events[idx][2] + (lo < n && events[lo][0] > end ? dfs(lo, cnt + 1) : 0);
+      const exclude = dfs(idx + 1, cnt);
+      dp[idx][cnt] = Math.max(include, exclude);
+    }
+
+    return dp[idx][cnt]
+  }
+};

From a9206f33ebd5baa3bff06a3d39536cf76673a0c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 15:07:49 +0800
Subject: [PATCH 1774/3374] Update 2054-two-best-non-overlapping-events.js

---
 2054-two-best-non-overlapping-events.js | 88 +++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/2054-two-best-non-overlapping-events.js b/2054-two-best-non-overlapping-events.js
index a7037b03..07adffa0 100644
--- a/2054-two-best-non-overlapping-events.js
+++ b/2054-two-best-non-overlapping-events.js
@@ -28,3 +28,91 @@ const maxTwoEvents = function(events) {
     return dp[idx][cnt]
   }
 };
+
+// another
+
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+const maxTwoEvents = function(events) {
+  const n = events.length, { max } = Math
+  let res = 0, maxVal = 0;
+  const pq = new PriorityQueue((a, b) => a[0] < b[0]);
+  events.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  for (let e of events) {
+    for(; !pq.isEmpty() && pq.peek()[0] < e[0]; pq.pop())
+      maxVal = max(maxVal, pq.peek()[1]);
+    res = max(res, maxVal + e[2]);
+    pq.push([e[1], e[2]]);
+  }
+  return res;
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 2790d3df25c466173f5c2989cb7426a5712af189 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 16:42:37 +0800
Subject: [PATCH 1775/3374] Create
 2068-check-whether-two-strings-are-almost-equivalent.js

---
 ...ether-two-strings-are-almost-equivalent.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2068-check-whether-two-strings-are-almost-equivalent.js

diff --git a/2068-check-whether-two-strings-are-almost-equivalent.js b/2068-check-whether-two-strings-are-almost-equivalent.js
new file mode 100644
index 00000000..7c242d12
--- /dev/null
+++ b/2068-check-whether-two-strings-are-almost-equivalent.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {boolean}
+ */
+const checkAlmostEquivalent = function(word1, word2) {
+  const a = 'a'.charCodeAt(0), n = word1.length
+  const arr1 = Array(26).fill(0), arr2 = Array(26).fill(0)
+  
+  for(const ch of word1) {
+    arr1[ch.charCodeAt(0) - a]++
+  }
+  for(const ch of word2) {
+    arr2[ch.charCodeAt(0) - a]++
+  }
+  for(let i = 0; i < 26; i++) {
+    if(Math.abs(arr1[i] - arr2[i]) > 3) return false
+  }
+  
+  return true
+};

From f9ceb590826ad0fd463d6524f651a6a86c0de710 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 16:47:00 +0800
Subject: [PATCH 1776/3374] Create
 1941-check-if-all-characters-have-equal-number-of-occurrences.js

---
 ...aracters-have-equal-number-of-occurrences.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1941-check-if-all-characters-have-equal-number-of-occurrences.js

diff --git a/1941-check-if-all-characters-have-equal-number-of-occurrences.js b/1941-check-if-all-characters-have-equal-number-of-occurrences.js
new file mode 100644
index 00000000..dfc28545
--- /dev/null
+++ b/1941-check-if-all-characters-have-equal-number-of-occurrences.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var areOccurrencesEqual = function(s) {
+  const n = s.length
+  const arr = Array(26).fill(0), a = 'a'.charCodeAt(0)
+  for(const ch of s) {
+    arr[ch.charCodeAt(0) - a]++
+  }
+  const set = new Set()
+  for(const e of arr) {
+    if(e !== 0) set.add(e)
+    if(set.size > 1) return false
+  }
+  return true
+};

From ed827e88b636af62ba6634e42295eb3a158f9e13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 17:13:41 +0800
Subject: [PATCH 1777/3374] Create 1971-find-if-path-exists-in-graph.js

---
 1971-find-if-path-exists-in-graph.js | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1971-find-if-path-exists-in-graph.js

diff --git a/1971-find-if-path-exists-in-graph.js b/1971-find-if-path-exists-in-graph.js
new file mode 100644
index 00000000..154edce0
--- /dev/null
+++ b/1971-find-if-path-exists-in-graph.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} start
+ * @param {number} end
+ * @return {boolean}
+ */
+const validPath = function(n, edges, start, end) {
+  const graph = {}
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = new Set()
+    if(graph[v] == null) graph[v] = new Set()
+    graph[u].add(v)
+    graph[v].add(u)
+  }
+  const q = [start], visited = new Set()
+  visited.add(start)
+  while(q.length) {
+    const cur = q.shift()
+    if(cur === end) return true
+    for(const next of graph[cur]) {
+      if(visited.has(next)) continue
+      q.push(next)
+      visited.add(next)
+    }
+  }
+
+  return false
+};

From 86e71ae7681e2a93d100125f184c2393b396d908 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 17:33:30 +0800
Subject: [PATCH 1778/3374] Create 1925-count-square-sum-triples.js

---
 1925-count-square-sum-triples.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1925-count-square-sum-triples.js

diff --git a/1925-count-square-sum-triples.js b/1925-count-square-sum-triples.js
new file mode 100644
index 00000000..dbc871df
--- /dev/null
+++ b/1925-count-square-sum-triples.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countTriples = function(n) {
+  let res = 0
+  const hash = {}
+  for(let i = 1; i<= n; i++) {
+    hash[i * i] = 1
+  }
+  
+  for(let i = 1; i <= n; i++) {
+    for(let j = i; i * i + j * j <= n * n; j++)  {
+      res += (hash[i * i + j * j] || 0) * 2
+    }
+  }
+
+  return res
+};

From df6d5567a51978b36d30fca26ce06dc28cdb654f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 20:19:46 +0800
Subject: [PATCH 1779/3374] Create
 1464-maximum-product-of-two-elements-in-an-array.js

---
 ...imum-product-of-two-elements-in-an-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1464-maximum-product-of-two-elements-in-an-array.js

diff --git a/1464-maximum-product-of-two-elements-in-an-array.js b/1464-maximum-product-of-two-elements-in-an-array.js
new file mode 100644
index 00000000..cdd33d69
--- /dev/null
+++ b/1464-maximum-product-of-two-elements-in-an-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxProduct = function(nums) {
+  const n = nums.length
+  let res = 0, m1 = 0, m2 = 0
+  for(const e of nums) {
+    if(e > m1) {
+      m2 = m1
+      m1 = e
+    } else if(e > m2) {
+      m2 = e
+    }
+  }
+
+  return (m1 - 1) * (m2 - 1)
+};

From 2817bc8da6eab111cc2118a3aa8cda8b2b0ebd7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 20:46:23 +0800
Subject: [PATCH 1780/3374] Create 1511-customer-order-frequency.sql

---
 1511-customer-order-frequency.sql | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 1511-customer-order-frequency.sql

diff --git a/1511-customer-order-frequency.sql b/1511-customer-order-frequency.sql
new file mode 100644
index 00000000..1994419b
--- /dev/null
+++ b/1511-customer-order-frequency.sql
@@ -0,0 +1,7 @@
+# Write your MySQL query statement below
+SELECT customer_id, name
+FROM Customers JOIN Orders USING(customer_id) 
+    JOIN Product USING(product_id)
+GROUP BY customer_id
+HAVING SUM(IF(LEFT(order_date, 7) = '2020-06', quantity, 0) * price) >= 100
+    AND SUM(IF(LEFT(order_date, 7) = '2020-07', quantity, 0) * price) >= 100;

From 5250cc05dfc83933b6c7b54aa88a7e9d045e0b4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Nov 2021 21:47:35 +0800
Subject: [PATCH 1781/3374] Create
 1460-make-two-arrays-equal-by-reversing-sub-arrays.js

---
 ...wo-arrays-equal-by-reversing-sub-arrays.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1460-make-two-arrays-equal-by-reversing-sub-arrays.js

diff --git a/1460-make-two-arrays-equal-by-reversing-sub-arrays.js b/1460-make-two-arrays-equal-by-reversing-sub-arrays.js
new file mode 100644
index 00000000..843cbe89
--- /dev/null
+++ b/1460-make-two-arrays-equal-by-reversing-sub-arrays.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} target
+ * @param {number[]} arr
+ * @return {boolean}
+ */
+const canBeEqual = function(target, arr) {
+  if(target.length !== arr.length) return false
+  const tHash = {}, aHash = {}
+  for(let i = 0, len = arr.length; i < len;i++) {
+    const t = target[i], a = arr[i]
+    if(tHash[t] == null) tHash[t] = 0
+    if(aHash[a] == null) aHash[a] = 0
+    tHash[t]++
+    aHash[a]++
+  }
+  
+  const keys = Object.keys(tHash)
+  for(let k of keys) {
+    if(tHash[k] !== aHash[k]) return false 
+  }
+  
+  return true
+};

From e0bba0818fc219be581de961bcaf8dc1a071ba08 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Nov 2021 09:23:46 +0800
Subject: [PATCH 1782/3374] Update 69-sqrt(x).js

---
 69-sqrt(x).js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/69-sqrt(x).js b/69-sqrt(x).js
index d392b5ee..3e3da29d 100755
--- a/69-sqrt(x).js
+++ b/69-sqrt(x).js
@@ -1,3 +1,22 @@
+/**
+ * @param {number} x
+ * @return {number}
+ */
+const mySqrt = function(x) {
+  let left = 0, right = x;
+  while (left < right) {
+    let mid = right - ((right - left) >> 1);
+    if (mid * mid > x) {
+      right = mid - 1;
+    } else {
+      left = mid;
+    }
+  }
+  return left;
+};
+
+// another
+
 /**
  * @param {number} x
  * @return {number}

From 73026c57c8fe232af275d7587a9965e71b42bce5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Nov 2021 09:38:44 +0800
Subject: [PATCH 1783/3374] Update 2008-maximum-earnings-from-taxi.js

---
 2008-maximum-earnings-from-taxi.js | 31 ++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2008-maximum-earnings-from-taxi.js b/2008-maximum-earnings-from-taxi.js
index e1b42d22..eb4fb356 100644
--- a/2008-maximum-earnings-from-taxi.js
+++ b/2008-maximum-earnings-from-taxi.js
@@ -19,3 +19,34 @@ const maxTaxiEarnings = function(n, rides) {
   }
   return dp[1];
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} rides
+ * @return {number}
+ */
+const maxTaxiEarnings = function(n, rides) {
+  const size = rides.length
+  rides.sort((a, b) => a[1] - b[1])
+  const dp = [[0,0]]
+  for(const [s, e, t] of rides) {
+    const cur = bs(dp, s) + (e - s + t)
+    if(cur > dp[dp.length - 1][1]) {
+      dp.push([e, cur])
+    }
+  }
+  return dp[dp.length - 1][1]
+
+  function bs(arr, t) {
+    let l = 0, r = arr.length - 1
+    while(l < r) {
+      const mid = r - ((r - l) >> 1)
+      if(arr[mid][0] > t) r = mid - 1
+      else l = mid
+    }
+    // console.log(arr, t, l)
+    return arr[l][1]
+  }
+};

From a9cf2e7786a1d46ba1b4fe5556fbc2addb1ba700 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Nov 2021 15:29:53 +0800
Subject: [PATCH 1784/3374] Create
 2078-two-furthest-houses-with-different-colors.js

---
 ...o-furthest-houses-with-different-colors.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2078-two-furthest-houses-with-different-colors.js

diff --git a/2078-two-furthest-houses-with-different-colors.js b/2078-two-furthest-houses-with-different-colors.js
new file mode 100644
index 00000000..0e3c6406
--- /dev/null
+++ b/2078-two-furthest-houses-with-different-colors.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} colors
+ * @return {number}
+ */
+const maxDistance = function(colors) {
+  const n = colors.length
+  let res = 0
+  for(let i = 1; i < n; i++) {
+    const cur = colors[i]
+    for(let j = 0; j < i; j++) {
+      if(colors[i] !== colors[j]) {
+        res = Math.max(res, i - j)
+        break
+      }
+    }
+  }
+  
+  return res
+};

From fae139a187dd06bf32eb8f6c723089bda67b6207 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Nov 2021 15:30:20 +0800
Subject: [PATCH 1785/3374] Create 2079-watering-plants.js

---
 2079-watering-plants.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2079-watering-plants.js

diff --git a/2079-watering-plants.js b/2079-watering-plants.js
new file mode 100644
index 00000000..b2c784d9
--- /dev/null
+++ b/2079-watering-plants.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} plants
+ * @param {number} capacity
+ * @return {number}
+ */
+const wateringPlants = function(plants, capacity) {
+  let res = 0, cap = capacity, full = capacity
+  for(let i = 0, n = plants.length; i < n; i++) {
+    const cur = plants[i]
+    cap -= cur
+    if(cap >= 0) res++
+    else {
+      res = res + (i + i + 1)
+      cap = full - cur
+    }
+  }
+  
+  return res
+};

From ee1d5c54fa4d3040db934bceb7492e4fff8242c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Nov 2021 15:34:27 +0800
Subject: [PATCH 1786/3374] Create 2080-range-frequency-queries.js

---
 2080-range-frequency-queries.js | 69 +++++++++++++++++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 2080-range-frequency-queries.js

diff --git a/2080-range-frequency-queries.js b/2080-range-frequency-queries.js
new file mode 100644
index 00000000..c474380b
--- /dev/null
+++ b/2080-range-frequency-queries.js
@@ -0,0 +1,69 @@
+//////////////////////////////////////////////Template/////////////////////////////////////////////////////////////
+function Bisect() {
+    return { insort_right, insort_left, bisect_left, bisect_right }
+    function insort_right(a, x, lo = 0, hi = null) {
+        lo = bisect_right(a, x, lo, hi);
+        a.splice(lo, 0, x);
+    }
+    function bisect_right(a, x, lo = 0, hi = null) { // > upper_bound
+        if (lo < 0) throw new Error('lo must be non-negative');
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+            let mid = parseInt((lo + hi) / 2);
+            x < a[mid] ? hi = mid : lo = mid + 1;
+        }
+        return lo;
+    }
+    function insort_left(a, x, lo = 0, hi = null) {
+        lo = bisect_left(a, x, lo, hi);
+        a.splice(lo, 0, x);
+    }
+    function bisect_left(a, x, lo = 0, hi = null) { // >= lower_bound
+        if (lo < 0) throw new Error('lo must be non-negative');
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+            let mid = parseInt((lo + hi) / 2);
+            a[mid] < x ? lo = mid + 1 : hi = mid;
+        }
+        return lo;
+    }
+}
+
+// counter with {value: array indices (increasing order)}
+const counter_value_in_indexA_in = (a_or_s) => { let m = new Map(); let n = a_or_s.length; for (let i = 0; i < n; i++) { if (!m.has(a_or_s[i])) m.set(a_or_s[i], []); m.get(a_or_s[i]).push(i); } return m; };
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * @param {number[]} arr
+ */
+var RangeFreqQuery = function(arr) {
+  let a = arr
+  this.m = counter_value_in_indexA_in(a)
+  this.bi = new Bisect();
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right 
+ * @param {number} value
+ * @return {number}
+ */
+RangeFreqQuery.prototype.query = function(left, right, value) {
+    let l = left, r =right, x = value, m = this.m, bi = this.bi
+    if (!m.has(x)) return 0;
+    let a = m.get(x), len = a.length;
+    let min = a[0], max = a[len - 1];
+    if (l <= min && r >= max) return len; // cover all
+    if (r < min || l > max) return 0; // out of bound
+    let lbs = bi.bisect_left(a, l); // needs lbs >= l  (lower bound will find first >= l)
+    let ubs = bi.bisect_right(a, r); // needs ubs <= r    (upper bound will find first ubs > r, -1 will guarantee <= r)
+    ubs--;
+    return ubs - lbs + 1;
+};
+
+/** 
+ * Your RangeFreqQuery object will be instantiated and called as such:
+ * var obj = new RangeFreqQuery(arr)
+ * var param_1 = obj.query(left,right,value)
+ */
+

From 839e609b68cabf68775adfa801ce1a3f1e5ac4bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Nov 2021 15:36:05 +0800
Subject: [PATCH 1787/3374] Create 2081-sum-of-k-mirror-numbers.js

---
 2081-sum-of-k-mirror-numbers.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2081-sum-of-k-mirror-numbers.js

diff --git a/2081-sum-of-k-mirror-numbers.js b/2081-sum-of-k-mirror-numbers.js
new file mode 100644
index 00000000..118be589
--- /dev/null
+++ b/2081-sum-of-k-mirror-numbers.js
@@ -0,0 +1,26 @@
+const isPalindrome = (s) => { let n = s.length; let i = 0; let j = n - 1; while (i < j) { if (s[i++] != s[j--]) return false; } return true; };
+
+const int = parseInt;
+/**
+ * @param {number} k
+ * @param {number} n
+ * @return {number}
+ */
+var kMirror = function(k, n) {
+    let res = 0;
+    for (let len = 1; ; len++) {
+        let min = 10 ** ((len - 1) >> 1), max = 10 ** ((len + 1) >> 1);
+        for (let base = min; base < max; base++) {
+            let x = base;
+            for (let i = len & 1 ? int(base / 10) : base; i > 0; i = int(i / 10)) {
+                x = x * 10 + i % 10;
+            }
+            let s = x.toString(k);
+            if (isPalindrome(s)) {
+                res += x;
+                n--;
+                if (!n) return res;
+            }
+        }
+    }  
+};

From 8f5595bdaad1e6941ea21e791e242b5fb6420950 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Nov 2021 15:48:26 +0800
Subject: [PATCH 1788/3374] Update
 2060-check-if-an-original-string-exists-given-two-encoded-strings.js

---
 ...string-exists-given-two-encoded-strings.js | 69 ++++++++++++++++++-
 1 file changed, 67 insertions(+), 2 deletions(-)

diff --git a/2060-check-if-an-original-string-exists-given-two-encoded-strings.js b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
index 316408e8..042ee1ec 100644
--- a/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
+++ b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
@@ -1,3 +1,68 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {boolean}
+ */
+const possiblyEquals = function(s1, s2) {
+  const n = s1.length
+  const m = s2.length
+  const memo = Array.from({ length: n + 1 }, () =>
+    Array.from({ length: m + 1 }, () => Array(1001).fill(null))
+  )
+  memo[0][0][1000] = true
+  
+  return dfs(0, 0, 0)
+
+  function dfs(i, j, diff) {
+    if(memo[i][j][diff] != null) return memo[i][j][diff]
+    let res = false
+    if (i == n && j == m) res = diff === 0
+    else if (i < n && isDigit(s1[i])) {
+      let ii = i
+      while (ii < n && isDigit( s1[ii] )) ii += 1
+      for (let x of helper(s1.slice(i, ii))) {
+        if (dfs(ii, j, diff-x)) res = true 
+      }
+    } else if (j < m && isDigit( s2[j] )) {
+      let jj = j 
+      while (jj < m && isDigit( s2[jj] )) jj += 1
+      for (let y of helper(s2.slice(j, jj))) {
+        if (dfs(i, jj, diff+y)) res = true 
+      }
+    } else if (diff == 0) {
+      if (i < n && j < m && s1[i] == s2[j]) res = dfs(i+1, j+1, 0)
+    }  else if (diff > 0) {
+      if (i < n) res = dfs(i+1, j, diff-1)
+    } else {
+      if (j < m) res = dfs(i, j+1, diff+1)
+    }
+
+    memo[i][j][diff] = res
+    return res
+  }
+
+  function isDigit(ch) {
+    return ch >= '0' && ch <= '9'
+  }
+
+  function helper(str) {
+    const ans = new Set()
+    ans.add(+str)
+    for(let i = 1, len = str.length; i < len; i++) {
+      const pre = helper(str.slice(0, i))
+      const post = helper(str.slice(i))
+      for(let p of pre) {
+        for(let n of post) {
+          ans.add(p + n)
+        }
+      }
+    }
+    return Array.from(ans)
+  }
+};
+
+// another
+
 /**
  * @param {string} s1
  * @param {string} s2
@@ -6,8 +71,8 @@
 var possiblyEquals = function (s1, s2) {
   let n = s1.length
   let m = s2.length
-  const f = Array.from({ length: 41 }, () =>
-    Array.from({ length: 41 }, () => Array(1001).fill(false))
+  const f = Array.from({ length: n + 1 }, () =>
+    Array.from({ length: m + 1 }, () => Array(1001).fill(false))
   )
   f[0][0][1000] = true
 

From d7348eeaba32a6c06bc9bc6b602140910df567cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Nov 2021 15:54:18 +0800
Subject: [PATCH 1789/3374] Update
 2060-check-if-an-original-string-exists-given-two-encoded-strings.js

---
 ...string-exists-given-two-encoded-strings.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)

diff --git a/2060-check-if-an-original-string-exists-given-two-encoded-strings.js b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
index 042ee1ec..12be2ab2 100644
--- a/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
+++ b/2060-check-if-an-original-string-exists-given-two-encoded-strings.js
@@ -1,3 +1,64 @@
+function possiblyEquals(s1, s2) {
+  const n = s1.length, m = s2.length;
+  const dp = Array.from({ length: n + 1 }, v => Array.from({ length: m + 1}, w => new Set()));
+  dp[0][0].add(0);
+
+  for (let i = 0; i <= n; i++) {
+    for (let j = 0; j <= m; j++) {
+      for (let delta of dp[i][j]) {
+        // s1 is number
+        let num = 0;
+        if (delta <= 0) {
+          for (let p = i; i < Math.min(i + 3, n); p++) {
+              if (isDigit(s1[p])) {
+                  num = num * 10 + Number(s1[p]);
+                  dp[p + 1][j].add(delta + num);
+              } else {
+                  break;
+              }
+          }
+        }
+
+        // s2 is number
+        num = 0;
+        if (delta >= 0) {
+            for (let q = j; q < Math.min(j + 3, m); q++) {
+                if (isDigit(s2[q])) {
+                    num = num * 10 + Number(s2[q]);
+                    dp[i][q + 1].add(delta - num);
+                } else {
+                    break;
+                }
+            }
+        }
+
+        // match s1 non-digit character
+        if (i < n && delta < 0 && !isDigit(s1[i])) {
+            dp[i + 1][j].add(delta + 1);
+        }
+
+        // match s2 non-digit character
+        if (j < m && delta > 0 && !isDigit(s2[j])) {
+            dp[i][j + 1].add(delta - 1);
+        }
+
+        // two non-digit character match
+        if (i < n && j < m && delta == 0 && s1[i] == s2[j]) {
+            dp[i + 1][j + 1].add(0);
+        }
+
+      }
+    }
+  }
+  return dp[n][m].has(0);
+};
+
+function isDigit(char) {
+  return (/^\d{1}$/g).test(char);
+}
+
+// another
+
 /**
  * @param {string} s1
  * @param {string} s2

From 5cbae3afb0dcd06e81f065ac1f96ef6c34f8328b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Nov 2021 10:05:54 +0800
Subject: [PATCH 1790/3374] Update 2065-maximum-path-quality-of-a-graph.js

---
 2065-maximum-path-quality-of-a-graph.js | 39 +++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/2065-maximum-path-quality-of-a-graph.js b/2065-maximum-path-quality-of-a-graph.js
index 419e1986..73827e0f 100644
--- a/2065-maximum-path-quality-of-a-graph.js
+++ b/2065-maximum-path-quality-of-a-graph.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} values
+ * @param {number[][]} edges
+ * @param {number} maxTime
+ * @return {number}
+ */
+const maximalPathQuality = function(values, edges, maxTime) {
+  const graph = {}, n = values.length
+  for(const [u, v, t] of edges) {
+    if(graph[u] == null) graph[u] = []
+    if(graph[v] == null) graph[v] = []
+    graph[u].push([v, t])
+    graph[v].push([u, t])
+  }
+  let res = 0, visited = Array(n).fill(false)
+  bt(0, 0, 0)
+  return res
+
+  function bt(i, cur, time) {
+    if(time > maxTime) return
+    const backup = visited[i]
+    if(!visited[i]) {
+      visited[i] = true
+      cur += values[i]
+    }
+
+    if(i === 0) {
+      res = Math.max(res, cur)
+    }
+
+    for(const [next, nextTime] of (graph[i] || [])) {
+      bt(next, cur, time + nextTime)
+    }
+    visited[i] = backup
+  }
+};
+
+// another
+
 /**
  * @param {number[]} values
  * @param {number[][]} edges

From 6073326593ac506c815effe409254d0fe0177942 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Nov 2021 10:46:07 +0800
Subject: [PATCH 1791/3374] Update 2065-maximum-path-quality-of-a-graph.js

---
 2065-maximum-path-quality-of-a-graph.js | 35 +++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2065-maximum-path-quality-of-a-graph.js b/2065-maximum-path-quality-of-a-graph.js
index 73827e0f..ced6bb56 100644
--- a/2065-maximum-path-quality-of-a-graph.js
+++ b/2065-maximum-path-quality-of-a-graph.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[]} values
+ * @param {number[][]} edges
+ * @param {number} maxTime
+ * @return {number}
+ */
+const maximalPathQuality = function(values, edges, maxTime) {
+  const graph = {}, n = values.length
+  for(const [u, v, t] of edges) {
+    if(graph[u] == null) graph[u] = []
+    if(graph[v] == null) graph[v] = []
+    graph[u].push([v, t])
+    graph[v].push([u, t])
+  }
+  let res = 0, visited = new Array(n).fill(0)
+  visited[0] = 1
+  bt(0, values[0], 0)
+  return res
+
+  function bt(i, val, time) {
+    if(time > maxTime) return
+    if(i === 0) res = Math.max(res, val)
+    
+    for(const [next, nextTime] of (graph[i] || [])) {
+      const nextVal = visited[next] > 0 ? val : val + values[next]
+      visited[next]++
+      bt(next, nextVal, time + nextTime)
+      visited[next]--
+    }
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} values
  * @param {number[][]} edges

From 41402a32be7594023ca0cf89478e1b1cd47488c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Nov 2021 18:54:37 +0800
Subject: [PATCH 1792/3374] Update
 2064-minimized-maximum-of-products-distributed-to-any-store.js

---
 ...um-of-products-distributed-to-any-store.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2064-minimized-maximum-of-products-distributed-to-any-store.js b/2064-minimized-maximum-of-products-distributed-to-any-store.js
index d6b13e04..ac753600 100644
--- a/2064-minimized-maximum-of-products-distributed-to-any-store.js
+++ b/2064-minimized-maximum-of-products-distributed-to-any-store.js
@@ -22,3 +22,28 @@ var minimizedMaximum = function(n, quantities) {
       for (let x of quantities) cnt += Math.floor(x / max) + ((x % max) ? 1 : 0);
       return cnt;
   }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} quantities
+ * @return {number}
+ */
+const minimizedMaximum = function(n, quantities) {
+  let MAX = 0;
+  for (let x of quantities) MAX = Math.max(x, MAX);
+  let l = 1, r = MAX;
+  while (l < r) {
+    let mid = Math.floor((l + r) / 2);
+    if (valid(quantities, mid, n)) l = mid + 1;
+    else r = mid;
+  }
+  return l; 
+};
+
+function valid(quantities,  max, n) {
+  let cnt = 0;
+  for (let x of quantities) cnt += Math.floor(x / max) + ((x % max) ? 1 : 0);
+  return cnt > n;
+}

From 9497bf0343a4092c515979fb60dc67f7a21db95e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Nov 2021 17:11:09 +0800
Subject: [PATCH 1793/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index 54bbb8c4..9767fb3b 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number} n
+ * @param {number} index
+ * @param {number} maxSum
+ * @return {number}
+ */
+const maxValue = function(n, index, maxSum) {
+  const { floor, sqrt } = Math
+  maxSum -= n
+  if(index < Math.floor(n / 2)) index = n - 1 - index
+  let left = index // number of element to the left of the index
+  let right = n - 1 - index // number of element to the right of the index
+  // the triangle area for the left side if not hitting the boundary
+  let leftSum = floor((left * (left + 1)) / 2)
+  // the triangle area for the right side if not hitting the boundary
+  let rightSum = floor((right * (right + 1)) / 2)
+  // case: perfect pyramid
+  if (maxSum <= (rightSum * 2 + right + 1)) return floor(sqrt(maxSum) + 1)
+  // case: right side hits the boundary
+  if (maxSum <= (leftSum + rightSum + (left - right) * right + left + 1)) {
+    const b = 3 + 2 * right
+    return floor((-b + sqrt(b * b - 8 * (rightSum + 1 - right * right - maxSum))) / 2) + 1 + 1
+  }
+  // case: both sides hit boundaries
+  maxSum -= (leftSum + rightSum + (left - right) * right + left + 1)
+  return left + 1 + 1 + floor(maxSum / n)
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} index

From 04f0eb133550f9b74a2163b593502a283c2e2863 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Nov 2021 17:50:05 +0800
Subject: [PATCH 1794/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index 9767fb3b..897df086 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} index
+ * @param {number} maxSum
+ * @return {number}
+ */
+const maxValue = function(n, index, maxSum) {
+  maxSum -= n;
+  let level = 1;
+  let left = index;
+  let right = index;
+
+  while (maxSum - (right - left + 1) >= 0) {
+    if (left === 0 && right === n - 1) break
+    maxSum -= right - left + 1;
+    if (left - 1 >= 0) left--
+    if (right + 1 <= n - 1) right++;
+    level++;
+  }
+
+  if (maxSum) level += ~~(maxSum / n)
+
+  return level;
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number} index

From 163b834d0906466dca183fbd0c24aa7c47cd4e60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Nov 2021 09:51:47 +0800
Subject: [PATCH 1795/3374] Update 1870-minimum-speed-to-arrive-on-time.js

---
 1870-minimum-speed-to-arrive-on-time.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1870-minimum-speed-to-arrive-on-time.js b/1870-minimum-speed-to-arrive-on-time.js
index 0a59cb8b..df7be0e5 100644
--- a/1870-minimum-speed-to-arrive-on-time.js
+++ b/1870-minimum-speed-to-arrive-on-time.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} dist
+ * @param {number} hour
+ * @return {number}
+ */
+const minSpeedOnTime = function(dist, hour) {
+  let n = dist.length, l = 1, r = 1e7 + 1
+  while(l < r) {
+    const mid = l + ((r - l) >> 1)
+    let time = 0
+    for(let i = 0; i < n - 1; i++) time += Math.ceil(dist[i] / mid)
+    time += dist[dist.length - 1] / mid
+    if(time > hour) l = mid + 1
+    else r = mid
+  }
+  return l > 1e7 ? -1 : l
+};
+
+// another
+
 /**
  * @param {number[]} dist
  * @param {number} hour

From a9bf29e5e6f8bc75e59973ef117d325861006f9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Nov 2021 14:13:10 +0800
Subject: [PATCH 1796/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index 897df086..8788b9cf 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number} index
+ * @param {number} maxSum
+ * @return {number}
+ */
+const maxValue = function(n, index, maxSum) {
+  let res = 1, l = index, r = index
+  maxSum -= n
+
+  while(l > 0 || r < n - 1) {
+    const len = r - l + 1
+    if(maxSum >= len) {
+      maxSum -= len 
+      res++
+    } else break
+    if(l > 0) l--
+    if(r < n - 1) r++
+  }
+  res += ~~(maxSum / n)
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number} index

From dd8964fde2e9cdc53e74096388e8b7e3f04644dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Nov 2021 12:06:24 +0800
Subject: [PATCH 1797/3374] Create
 2089-find-target-indices-after-sorting-array.js

---
 2089-find-target-indices-after-sorting-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2089-find-target-indices-after-sorting-array.js

diff --git a/2089-find-target-indices-after-sorting-array.js b/2089-find-target-indices-after-sorting-array.js
new file mode 100644
index 00000000..ddc093b9
--- /dev/null
+++ b/2089-find-target-indices-after-sorting-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+const targetIndices = function(nums, target) {
+  let res = []
+  nums.sort((a, b) => a - b)
+  for(let i = 0; i < nums.length; i++) {
+    if(nums[i] === target) res.push(i)
+  }
+  return res
+};

From 99384aeb96a1896d9a146ecef6fb0ae48174fccb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Nov 2021 12:06:58 +0800
Subject: [PATCH 1798/3374] Create 2090-k-radius-subarray-averages.js

---
 2090-k-radius-subarray-averages.js | 43 ++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 2090-k-radius-subarray-averages.js

diff --git a/2090-k-radius-subarray-averages.js b/2090-k-radius-subarray-averages.js
new file mode 100644
index 00000000..c99d400c
--- /dev/null
+++ b/2090-k-radius-subarray-averages.js
@@ -0,0 +1,43 @@
+const lowBit = (x) => x & -x
+class FenwickTree {
+  constructor(n) {
+    if (n < 1) return
+    this.sum = Array(n + 1).fill(0)
+  }
+  update(i, delta) {
+    if (i < 1) return
+    while (i < this.sum.length) {
+      this.sum[i] += delta
+      i += lowBit(i)
+    }
+  }
+  query(i) {
+    if (i < 1) return 0
+    let sum = 0
+    while (i > 0) {
+      sum += this.sum[i]
+      i -= lowBit(i)
+    }
+    return sum
+  }
+}
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const getAverages = function(nums, k) {
+  const n = nums.length
+  const bit = new FenwickTree(n)
+  for(let i = 0; i < n; i++) {
+    bit.update(i + 1, nums[i])
+  }
+  const res = Array(n).fill(-1)
+  // console.log(bit)
+  for(let i = k; i < n - k; i++) {
+    const pre = bit.query(i + 1 - k - 1), cur = bit.query(i + 1 + k)
+    res[i] = ~~((cur - pre) / (k * 2 + 1))
+  }
+  
+  return res
+};

From 8c17e67d78a68653a605b4e863955180b0f5c937 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Nov 2021 12:07:23 +0800
Subject: [PATCH 1799/3374] Create
 2091-removing-minimum-and-maximum-from-array.js

---
 ...removing-minimum-and-maximum-from-array.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2091-removing-minimum-and-maximum-from-array.js

diff --git a/2091-removing-minimum-and-maximum-from-array.js b/2091-removing-minimum-and-maximum-from-array.js
new file mode 100644
index 00000000..81d73144
--- /dev/null
+++ b/2091-removing-minimum-and-maximum-from-array.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumDeletions = function(nums) {
+  let mi = Infinity, ma = -Infinity
+  let mii = -1, mai = -1
+  const { max, min, abs } = Math, n = nums.length
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    if(e < mi) {
+      mi = e
+      mii = i
+    }
+    if(e > ma) {
+      ma = e
+      mai = i
+    }
+  }
+  
+  const disMi = abs(mii + 1, n - mii)
+  const disMa = abs(mai + 1, n - mai)
+  let res = 0
+  let lmi = min(mii, mai), lma = max(mii, mai)
+  
+  res += min(lmi + 1 + n - lma, lma + 1, n - lmi)
+  
+  
+  return res
+};

From 3bbaeb29586109bd6438cae0168adf2b94ea057c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Nov 2021 12:07:52 +0800
Subject: [PATCH 1800/3374] Create 2092-find-all-people-with-secret.js

---
 2092-find-all-people-with-secret.js | 46 +++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 2092-find-all-people-with-secret.js

diff --git a/2092-find-all-people-with-secret.js b/2092-find-all-people-with-secret.js
new file mode 100644
index 00000000..69ce4439
--- /dev/null
+++ b/2092-find-all-people-with-secret.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number[][]} meetings
+ * @param {number} firstPerson
+ * @return {number[]}
+ */
+const findAllPeople = function(n, meetings, firstPerson) {
+  meetings.sort((a, b) => a[2] - b[2])
+  const shared = new Set([0, firstPerson])
+  
+  let start = new Set(), links = {}
+  for(let i = 0, len = meetings.length; i < len; i++) {
+    const [x,y,t] = meetings[i]
+    if(i > 0 && t !== meetings[i - 1][2]) {
+      dfs(start, links, shared)
+      start = new Set()
+      links = {}
+    }
+    if(shared.has(x)) start.add(x)
+    if(shared.has(y)) start.add(y)
+    if(links[x] == null) links[x] = []
+    if(links[y] == null) links[y] = []
+    links[x].push(y)
+    links[y].push(x)
+  }
+  
+  
+  dfs(start, links, shared)
+  return Array.from(shared)
+  
+  function dfs(start, links, shared) {
+    const visited = new Set()
+    while(start.size) {
+      const it = start[Symbol.iterator]()
+      const cur = it.next().value
+      start.delete(cur)
+      visited.add(cur)
+      shared.add(cur)
+      for(let e of (links[cur] || [])) {
+        if(!visited.has(e)) start.add(e)
+      }
+    }
+  }
+};
+
+    

From f99cfb02a6de29380a875902bf83fcd7143b067a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Nov 2021 12:17:51 +0800
Subject: [PATCH 1801/3374] Update 2092-find-all-people-with-secret.js

---
 2092-find-all-people-with-secret.js | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/2092-find-all-people-with-secret.js b/2092-find-all-people-with-secret.js
index 69ce4439..88ab147f 100644
--- a/2092-find-all-people-with-secret.js
+++ b/2092-find-all-people-with-secret.js
@@ -12,7 +12,7 @@ const findAllPeople = function(n, meetings, firstPerson) {
   for(let i = 0, len = meetings.length; i < len; i++) {
     const [x,y,t] = meetings[i]
     if(i > 0 && t !== meetings[i - 1][2]) {
-      dfs(start, links, shared)
+      bfs(start, links)
       start = new Set()
       links = {}
     }
@@ -24,11 +24,10 @@ const findAllPeople = function(n, meetings, firstPerson) {
     links[y].push(x)
   }
   
-  
-  dfs(start, links, shared)
+  bfs(start, links)
   return Array.from(shared)
   
-  function dfs(start, links, shared) {
+  function bfs(start, links) {
     const visited = new Set()
     while(start.size) {
       const it = start[Symbol.iterator]()
@@ -42,5 +41,3 @@ const findAllPeople = function(n, meetings, firstPerson) {
     }
   }
 };
-
-    

From 782d09e7fe0910a60ec58f716c2ddbd7f64308ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Nov 2021 15:44:50 +0800
Subject: [PATCH 1802/3374] Update
 1608-special-array-with-x-elements-greater-than-or-equal-x.js

---
 ...-with-x-elements-greater-than-or-equal-x.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1608-special-array-with-x-elements-greater-than-or-equal-x.js b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
index 6964d8c3..b9b51023 100644
--- a/1608-special-array-with-x-elements-greater-than-or-equal-x.js
+++ b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
@@ -30,3 +30,21 @@ const specialArray = function(nums) {
   // larger or equal to i, which makes array not special.
   return left < nums.length && left === nums[left] ? -1 : left
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const specialArray = function(nums) {
+  const n = nums.length
+  nums.sort((a, b) => b - a)
+  let l = 0, r = n
+  while(l < r) {
+    const mid = l + ((r - l) >> 1)
+    if(nums[mid] > mid) l = mid + 1
+    else r = mid
+  }
+  return l < n && l === nums[l] ? -1 : l
+}

From b29f91daa76479d5aebdeebc60381c93bc4f8194 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Nov 2021 11:28:25 +0800
Subject: [PATCH 1803/3374] Create
 2071-maximum-number-of-tasks-you-can-assign.js

---
 ...-maximum-number-of-tasks-you-can-assign.js | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 2071-maximum-number-of-tasks-you-can-assign.js

diff --git a/2071-maximum-number-of-tasks-you-can-assign.js b/2071-maximum-number-of-tasks-you-can-assign.js
new file mode 100644
index 00000000..dabb440a
--- /dev/null
+++ b/2071-maximum-number-of-tasks-you-can-assign.js
@@ -0,0 +1,75 @@
+//////////////////////////////////////////////Template/////////////////////////////////////////////////////////////
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      x < a[mid] ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+/**
+ * @param {number[]} tasks
+ * @param {number[]} workers
+ * @param {number} pills
+ * @param {number} strength
+ * @return {number}
+ */
+const maxTaskAssign = function(tasks, workers, pills, strength) {
+  tasks.sort((a, b) => a - b)
+  workers.sort((a, b) => b - a)
+  const m = tasks.length, n = workers.length
+  const { min, floor } = Math
+  let l = 0, r = min(n, m)
+  while (l < r) {
+    const mid = r - floor((r - l) / 2)
+    if (check(mid)) l = mid
+    else r = mid - 1
+  }
+
+  return l
+
+  function check(k){
+    const wArr = workers.slice(0, k), tArr = tasks.slice(0, k)
+    let tries = pills, bs = new Bisect()
+    wArr.reverse()
+    tArr.reverse()
+  
+    for (let elem of tArr) {
+      const place = bs.bisect_left(wArr, elem)
+      if (place < wArr.length) {
+        wArr.pop()
+      } else if (tries > 0) {
+        const place2 = bs.bisect_left(wArr, elem - strength)
+        if (place2 < wArr.length) {
+          wArr.splice(place2, 1)
+          tries -= 1
+        }
+      } else return false
+    }
+  
+    return wArr.length === 0
+  }
+};

From cee0441786a06d6427fa15bf4393c4b928bd2921 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Dec 2021 10:47:55 +0800
Subject: [PATCH 1804/3374] Create 2069-walking-robot-simulation-ii.js

---
 2069-walking-robot-simulation-ii.js | 49 +++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 2069-walking-robot-simulation-ii.js

diff --git a/2069-walking-robot-simulation-ii.js b/2069-walking-robot-simulation-ii.js
new file mode 100644
index 00000000..50be2e38
--- /dev/null
+++ b/2069-walking-robot-simulation-ii.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number} width
+ * @param {number} height
+ */
+const Robot = function(width, height) {
+  this.i = 0
+  const pos = Array()
+  this.len = width + height - 1 + width - 1 + height - 2
+  pos.push( [0,0,3] )
+  for(let i = 1; i < width; i++) {
+    pos.push([i, 0, 0])
+  }
+  for(let i = 1; i < height; i++) {
+    pos.push([width - 1, i, 1])
+  }
+  for(let i = 1; i < width; i++) {
+    pos.push([width - 1 - i, height - 1, 2])
+  }
+  for(let i = 1; i < height - 1; i++) {
+    pos.push([0, height - 1 - i, 3])
+  }
+  this.pos = pos
+};
+
+/** 
+ * @param {number} num
+ * @return {void}
+ */
+Robot.prototype.step = function(num) {
+  this.i += num
+};
+
+/**
+ * @return {number[]}
+ */
+Robot.prototype.getPos = function() {
+  return this.pos[this.i % this.len].slice(0, 2)
+};
+
+/**
+ * @return {string}
+ */
+Robot.prototype.getDir = function() {
+  const hash = ['East', 'North', 'West', 'South']
+  if(this.i === 0) return hash[0]
+  else {
+    return hash[this.pos[this.i % this.len][2]]
+  }
+};

From 3ec579551c1b5bc9c45d928d3885b27a14c2cefc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Dec 2021 10:03:57 +0800
Subject: [PATCH 1805/3374] Create 1251-average-selling-price.sql

---
 1251-average-selling-price.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 1251-average-selling-price.sql

diff --git a/1251-average-selling-price.sql b/1251-average-selling-price.sql
new file mode 100644
index 00000000..ca95a4c1
--- /dev/null
+++ b/1251-average-selling-price.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT a.product_id,ROUND(SUM(b.units*a.price)/SUM(b.units),2) as average_price
+FROM Prices as a
+JOIN UnitsSold as b
+ON a.product_id=b.product_id AND (b.purchase_date BETWEEN a.start_date AND a.end_date)
+GROUP BY product_id;

From dc2f9557e9a99b6c28166637370f71f5977ba122 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Dec 2021 10:16:40 +0800
Subject: [PATCH 1806/3374] Update 206-reverse-linked-list.js

---
 206-reverse-linked-list.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/206-reverse-linked-list.js b/206-reverse-linked-list.js
index d804118a..94c78a97 100755
--- a/206-reverse-linked-list.js
+++ b/206-reverse-linked-list.js
@@ -1,3 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const reverseList = function(head) {
+  if(head == null) return head
+  const pre = new ListNode(null, head)
+  let cur = head
+  while(cur.next) {
+    let tmp = pre.next
+    pre.next = cur.next
+    cur.next = cur.next.next
+    pre.next.next = tmp
+  }
+
+  return pre.next
+};
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From b1d532f66196a2cb44dc558ee42a0587abec9078 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 12:03:10 +0800
Subject: [PATCH 1807/3374] Update 92-reverse-linked-list-ii.js

---
 92-reverse-linked-list-ii.js | 40 ++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/92-reverse-linked-list-ii.js b/92-reverse-linked-list-ii.js
index e9c73874..8b30ebfb 100644
--- a/92-reverse-linked-list-ii.js
+++ b/92-reverse-linked-list-ii.js
@@ -1,3 +1,43 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} left
+ * @param {number} right
+ * @return {ListNode}
+ */
+const reverseBetween = function(head, left, right) {
+  if(head == null) return head
+  const dummy = new ListNode(null, head)
+  let num = 0, cur = head
+  while (cur) {
+    num++
+    cur = cur.next
+  }
+  let idx = 0, pre = null
+  cur = dummy
+  while (idx < right && idx <= num) {
+    if (idx === left - 1) pre = cur
+    if (idx >= left) {
+      const tmp = pre.next
+      pre.next = cur.next
+      cur.next = cur.next.next
+      pre.next.next = tmp
+    }
+
+    if (idx < left) cur = cur.next
+    idx++
+  }
+  return dummy.next
+};
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From 116c123e35143d17018429e05953efd9b15e7b41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 14:29:24 +0800
Subject: [PATCH 1808/3374] Create
 1374-generate-a-string-with-characters-that-have-odd-counts.js

---
 ...-a-string-with-characters-that-have-odd-counts.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1374-generate-a-string-with-characters-that-have-odd-counts.js

diff --git a/1374-generate-a-string-with-characters-that-have-odd-counts.js b/1374-generate-a-string-with-characters-that-have-odd-counts.js
new file mode 100644
index 00000000..cb124879
--- /dev/null
+++ b/1374-generate-a-string-with-characters-that-have-odd-counts.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} n
+ * @return {string}
+ */
+const generateTheString = function(n, ch = 'a') {
+  const odd = n % 2 === 1
+  const code = ch.charCodeAt(0)
+  if(odd) return ch.repeat(n)
+  const nch = String.fromCharCode(code + 1), nnch = String.fromCharCode(code + 2)
+  const even = (n / 2) % 2 === 0
+  return generateTheString(even ? n / 2 - 1 : n / 2, nch) + generateTheString(even ? n / 2 + 1 : n / 2, nnch)
+};

From f564eff69c653db36a56c1defba640f170978f3a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 14:54:45 +0800
Subject: [PATCH 1809/3374] Create 1370-increasing-decreasing-string.js

---
 1370-increasing-decreasing-string.js | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1370-increasing-decreasing-string.js

diff --git a/1370-increasing-decreasing-string.js b/1370-increasing-decreasing-string.js
new file mode 100644
index 00000000..c9bc2a65
--- /dev/null
+++ b/1370-increasing-decreasing-string.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const sortString = function(s) {
+  const arr = Array(26).fill(0), a = 'a'.charCodeAt(0)
+  for(const ch of s) {
+    arr[ch.charCodeAt(0) - a]++
+  }
+  
+  let res = '', delta = 1
+  const valid = arr => arr.every(e => e === 0)
+  while(!valid(arr)) {
+    if(delta > 0) {
+      for(let i = 0; i< 26; i++) {
+        if(arr[i]) {
+          res += String.fromCharCode(a + i)
+          arr[i]--
+        }
+      }
+    } else {
+      for(let i = 25; i >= 0; i--) {
+        if(arr[i]) {
+          res += String.fromCharCode(a + i)
+          arr[i]--
+        }
+      }
+    }
+    delta = delta === 1 ? -1 : 1
+  }
+  return res
+};

From 3c96de4b9632fb85380669e01eb767b8e6214c09 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 15:55:29 +0800
Subject: [PATCH 1810/3374] Create 2082-the-number-of-rich-customers.sql

---
 2082-the-number-of-rich-customers.sql | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 2082-the-number-of-rich-customers.sql

diff --git a/2082-the-number-of-rich-customers.sql b/2082-the-number-of-rich-customers.sql
new file mode 100644
index 00000000..fa154f5e
--- /dev/null
+++ b/2082-the-number-of-rich-customers.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+SELECT COUNT(DISTINCT customer_id) AS rich_count FROM Store WHERE amount > 500;

From b947456ddd28b070ad616a68f802de4d7a78a5d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 15:57:34 +0800
Subject: [PATCH 1811/3374] Create 1873-calculate-special-bonus.sql

---
 1873-calculate-special-bonus.sql | 2 ++
 1 file changed, 2 insertions(+)
 create mode 100644 1873-calculate-special-bonus.sql

diff --git a/1873-calculate-special-bonus.sql b/1873-calculate-special-bonus.sql
new file mode 100644
index 00000000..9f6862d0
--- /dev/null
+++ b/1873-calculate-special-bonus.sql
@@ -0,0 +1,2 @@
+# Write your MySQL query statement below
+select employee_id, if(employee_id%2=1 and name not like'M%', salary,0) as bonus from Employees;

From a9b131472f5c45d3ae32070e1ea2c5a92c5d00b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 16:03:54 +0800
Subject: [PATCH 1812/3374] Create 1795-rearrange-products-table.sql

---
 1795-rearrange-products-table.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 1795-rearrange-products-table.sql

diff --git a/1795-rearrange-products-table.sql b/1795-rearrange-products-table.sql
new file mode 100644
index 00000000..6a135447
--- /dev/null
+++ b/1795-rearrange-products-table.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+SELECT product_id, 'store1' AS store, store1 AS price FROM Products WHERE store1 IS NOT NULL
+UNION 
+SELECT product_id, 'store2' AS store, store2 AS price FROM Products WHERE store2 IS NOT NULL
+UNION 
+SELECT product_id, 'store3' AS store, store3 AS price FROM Products WHERE store3 IS NOT NULL
+
+ORDER BY 1,2 ASC;

From 54d469a199b79405e20d4eb55577886831c7f734 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 16:32:44 +0800
Subject: [PATCH 1813/3374] Create 1844-replace-all-digits-with-characters.js

---
 1844-replace-all-digits-with-characters.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1844-replace-all-digits-with-characters.js

diff --git a/1844-replace-all-digits-with-characters.js b/1844-replace-all-digits-with-characters.js
new file mode 100644
index 00000000..af554d97
--- /dev/null
+++ b/1844-replace-all-digits-with-characters.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const replaceDigits = function(s) {
+  let arr = s.split('')
+  for(let i = 1; i < s.length; i += 2) {
+    arr[i] = shift(s[i - 1], +s[i])
+  }
+
+  return arr.join('')
+
+  function shift(ch, x) {
+    return String.fromCharCode(ch.charCodeAt(0) + x)
+  }
+};

From cc639a386a7cf04ae2ea29bd196b239e25cdb695 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 16:52:06 +0800
Subject: [PATCH 1814/3374] Create 2053-kth-distinct-string-in-an-array.js

---
 2053-kth-distinct-string-in-an-array.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2053-kth-distinct-string-in-an-array.js

diff --git a/2053-kth-distinct-string-in-an-array.js b/2053-kth-distinct-string-in-an-array.js
new file mode 100644
index 00000000..152a135c
--- /dev/null
+++ b/2053-kth-distinct-string-in-an-array.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string[]} arr
+ * @param {number} k
+ * @return {string}
+ */
+const kthDistinct = function(arr, k) {
+  let num = 0, hash = {}
+  
+  for(let str of arr) {
+    if(hash[str] == null) hash[str] = 0
+    hash[str]++    
+  }
+  for(let str of arr) {
+    if(hash[str] > 1) continue
+    num++
+    if(num === k) return str
+  }
+  return ''
+};

From f9ea4c06ede44da11c09addeae30a115a4b21b5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 17:05:08 +0800
Subject: [PATCH 1815/3374] Create
 2006-count-number-of-pairs-with-absolute-difference-k.js

---
 ...mber-of-pairs-with-absolute-difference-k.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2006-count-number-of-pairs-with-absolute-difference-k.js

diff --git a/2006-count-number-of-pairs-with-absolute-difference-k.js b/2006-count-number-of-pairs-with-absolute-difference-k.js
new file mode 100644
index 00000000..30302a8c
--- /dev/null
+++ b/2006-count-number-of-pairs-with-absolute-difference-k.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countKDifference = function(nums, k) {
+  const hash = {}
+  let res = 0
+  for(let i = 0; i < nums.length; i++) {
+    const cur = nums[i]
+    if(hash[cur + k]) res += hash[cur + k]
+    if(hash[cur - k]) res += hash[cur - k]
+
+    if(hash[cur] == null) hash[cur] = 0
+    hash[cur]++
+  } 
+  return res
+};

From 145e423754b91bebcacf18d2750e04549cb116a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 17:08:11 +0800
Subject: [PATCH 1816/3374] Create 1323-maximum-69-number.js

---
 1323-maximum-69-number.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1323-maximum-69-number.js

diff --git a/1323-maximum-69-number.js b/1323-maximum-69-number.js
new file mode 100644
index 00000000..87e472b9
--- /dev/null
+++ b/1323-maximum-69-number.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+var maximum69Number  = function(num) {
+  const arr = (num+'').split('')
+  for(let i = 0; i < arr.length; i++) {
+    if(arr[i] === '6') {
+      arr[i] = '9'
+      break
+    }
+  }
+  return arr.join('')
+};

From b8d2f4e3e46435b865d14d1b934e6c977a74cec5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Dec 2021 17:21:03 +0800
Subject: [PATCH 1817/3374] Create
 2037-minimum-number-of-moves-to-seat-everyone.js

---
 2037-minimum-number-of-moves-to-seat-everyone.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2037-minimum-number-of-moves-to-seat-everyone.js

diff --git a/2037-minimum-number-of-moves-to-seat-everyone.js b/2037-minimum-number-of-moves-to-seat-everyone.js
new file mode 100644
index 00000000..92ff7134
--- /dev/null
+++ b/2037-minimum-number-of-moves-to-seat-everyone.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} seats
+ * @param {number[]} students
+ * @return {number}
+ */
+const minMovesToSeat = function(seats, students) {
+  let res = 0
+  seats.sort((a, b) => a - b)
+  students.sort((a, b) => a - b)
+  
+  for(let i = 0; i < students.length; i++) {
+    res += Math.abs(seats[i] - students[i])
+  }
+  
+  return res
+};

From 71fda8bff495854bdc2bb1a8c3c4a06bdad6d433 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Dec 2021 12:14:49 +0800
Subject: [PATCH 1818/3374] Create 2094-finding-3-digit-even-numbers.js

---
 2094-finding-3-digit-even-numbers.js | 49 ++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 2094-finding-3-digit-even-numbers.js

diff --git a/2094-finding-3-digit-even-numbers.js b/2094-finding-3-digit-even-numbers.js
new file mode 100644
index 00000000..a3f166fe
--- /dev/null
+++ b/2094-finding-3-digit-even-numbers.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} digits
+ * @return {number[]}
+ */
+const findEvenNumbers = function(digits) {
+  const set = new Set(), visited = new Set()
+  helper(0, [])
+  const res = Array.from(set)
+  res.sort((a, b) => a - b)
+  return res
+  
+  function helper(idx, cur) {
+    if(cur.length === 3) {
+      set.add(+cur.join(''))
+      return
+    }
+    for(let i = 0; i < digits.length; i++) {
+      if(visited.has(i)) continue
+      const d = digits[i]
+      if(d === 0) {
+        if(cur.length === 0) continue
+        else {
+          cur.push(d)
+          visited.add(i)
+          helper(i + 1, cur)
+          visited.delete(i)
+          cur.pop()
+        }
+      } else {
+        const isEven = d % 2 === 0
+        if(cur.length === 3 - 1) {
+          if(isEven) {
+            cur.push(d)
+                      visited.add(i)
+            helper(i + 1, cur)
+                      visited.delete(i)
+            cur.pop()
+          } else continue
+        } else {
+           cur.push(d)
+                    visited.add(i)
+            helper(i + 1, cur)
+                    visited.delete(i)
+            cur.pop()
+        }
+      }
+    }
+  }
+};

From a3eda4f789b438ab283e933f322796b05737b599 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Dec 2021 18:57:25 +0800
Subject: [PATCH 1819/3374] Create
 2095-delete-the-middle-node-of-a-linked-list.js

---
 ...delete-the-middle-node-of-a-linked-list.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2095-delete-the-middle-node-of-a-linked-list.js

diff --git a/2095-delete-the-middle-node-of-a-linked-list.js b/2095-delete-the-middle-node-of-a-linked-list.js
new file mode 100644
index 00000000..7ee0aef7
--- /dev/null
+++ b/2095-delete-the-middle-node-of-a-linked-list.js
@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const deleteMiddle = function(head) {
+  if(head == null) return head
+  const dummy = new ListNode(null, head)
+  let n = 0, cur = head
+  while(cur) {
+    n++
+    cur = cur.next
+  }
+  if(n === 1) return null
+  const mid = Math.floor(n / 2)
+  cur = dummy.next
+  let pre = dummy 
+  for(let i = 0; i < n; i++) {
+    if(i === mid - 1) {
+      pre = cur
+      // pre.next = cur.next.next
+    }
+    if(i === mid) {
+      pre.next = cur.next
+    }
+    if(i > mid) break
+    cur = cur.next
+  }
+  return dummy.next
+};

From cee772b02bf9ad516dadea834144e53232cc00d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Dec 2021 18:59:45 +0800
Subject: [PATCH 1820/3374] Create
 2096-step-by-step-directions-from-a-binary-tree-node-to-another.js

---
 ...ions-from-a-binary-tree-node-to-another.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2096-step-by-step-directions-from-a-binary-tree-node-to-another.js

diff --git a/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js b/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js
new file mode 100644
index 00000000..e8e3943c
--- /dev/null
+++ b/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js
@@ -0,0 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} startValue
+ * @param {number} destValue
+ * @return {string}
+ */
+var getDirections = function(root, startValue, destValue) {
+    let start = "";
+    let end = "";
+    
+    const traverse = (node, path) => {
+        if (node === null) return;
+        
+        if (node.val === startValue) start = path;
+        if (node.val === destValue) end = path;
+        
+        if (start !== "" && end !== "") return;
+        if (node.left !== null) traverse(node.left, path + "L");
+        if (node.right !== null) traverse(node.right, path + "R");
+    }
+    
+    traverse(root, "");
+    
+    let skip = 0;
+    while (start[skip] && start[skip] === end[skip]) ++skip;
+    
+    return "U".repeat(start.length - skip) + end.substring(skip);   
+};

From 75b4bc7c9b4a49f9b5c2ea0ba9d5f0525f48a97a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Dec 2021 20:34:15 +0800
Subject: [PATCH 1821/3374] Update
 2096-step-by-step-directions-from-a-binary-tree-node-to-another.js

---
 ...ions-from-a-binary-tree-node-to-another.js | 38 ++++++++-----------
 1 file changed, 16 insertions(+), 22 deletions(-)

diff --git a/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js b/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js
index e8e3943c..af3be49d 100644
--- a/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js
+++ b/2096-step-by-step-directions-from-a-binary-tree-node-to-another.js
@@ -12,25 +12,19 @@
  * @param {number} destValue
  * @return {string}
  */
-var getDirections = function(root, startValue, destValue) {
-    let start = "";
-    let end = "";
-    
-    const traverse = (node, path) => {
-        if (node === null) return;
-        
-        if (node.val === startValue) start = path;
-        if (node.val === destValue) end = path;
-        
-        if (start !== "" && end !== "") return;
-        if (node.left !== null) traverse(node.left, path + "L");
-        if (node.right !== null) traverse(node.right, path + "R");
-    }
-    
-    traverse(root, "");
-    
-    let skip = 0;
-    while (start[skip] && start[skip] === end[skip]) ++skip;
-    
-    return "U".repeat(start.length - skip) + end.substring(skip);   
-};
+const getDirections = function (root, startValue, destValue) {
+  let start = ''
+  let end = ''
+  const traverse = (node, path) => {
+    if (node === null) return
+    if (node.val === startValue) start = path
+    if (node.val === destValue) end = path
+    if (start !== '' && end !== '') return
+    if (node.left !== null) traverse(node.left, path + 'L')
+    if (node.right !== null) traverse(node.right, path + 'R')
+  }
+  traverse(root, '')
+  let skip = 0
+  while (start[skip] && start[skip] === end[skip]) skip++
+  return 'U'.repeat(start.length - skip) + end.slice(skip)
+}

From 7895f3ab16b539e73e28c8d8b72a38b40e787bdd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Dec 2021 19:18:16 +0800
Subject: [PATCH 1822/3374] Update 143-reorder-list.js

---
 143-reorder-list.js | 54 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/143-reorder-list.js b/143-reorder-list.js
index 366da9b2..ebc5bec4 100644
--- a/143-reorder-list.js
+++ b/143-reorder-list.js
@@ -1,3 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+const reorderList = function(head) {
+  if (!head || !head.next) return head;
+
+  const reverse = head => {
+    if (!head || !head.next) return head;
+    const newHead = reverse(head.next);
+    head.next.next = head;
+    head.next = null;
+    return newHead;
+  };
+
+  const merge = (l1, l2) => {
+    if (!l1) return l2;
+    if (!l2) return l1;
+    while (l1 && l2) {
+      const next1 = l1.next;
+      const next2 = l2.next;
+      l1.next = l2;
+      if (next1 == null) break;
+      l2.next = next1;
+      l1 = next1;
+      l2 = next2;
+    }
+  };
+
+  let fast = head;
+  let slow = head;
+
+  while (fast && fast.next) {
+    fast = fast.next.next;
+    slow = slow.next;
+  }
+
+  fast = slow.next;
+  slow.next = null;
+
+  fast = reverse(fast);
+  merge(head, fast);
+};
+
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From d3ee6ec17f94db2fbb17e277bbd3e4fb3fc3c5b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Dec 2021 20:49:24 +0800
Subject: [PATCH 1823/3374] Update 143-reorder-list.js

---
 143-reorder-list.js | 45 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/143-reorder-list.js b/143-reorder-list.js
index ebc5bec4..5d49c176 100644
--- a/143-reorder-list.js
+++ b/143-reorder-list.js
@@ -1,3 +1,48 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {void} Do not return anything, modify head in-place instead.
+ */
+const reorderList = function(head) {
+  if(head == null) return head
+  let slow = head, fast = head
+  while(fast && fast.next) {
+    slow = slow.next
+    fast = fast.next.next
+  }
+  let head2 = reverse(slow.next)
+  slow.next = null
+  
+  while(head && head2) {
+    const next = head.next, next2 = head2.next
+    head2.next = head.next
+    head.next = head2
+    head = next
+    head2 = next2
+  }
+  
+  function reverse(node) {
+    let pre = null, cur = node
+    while(cur) {
+      const tmp = cur.next
+      cur.next = pre
+      pre = cur
+      cur = tmp
+    }
+    return pre
+  }
+};
+
+
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val) {

From 2d682d35797ff1021d8e179660f9c4049dac8d1a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Dec 2021 10:50:16 +0800
Subject: [PATCH 1824/3374] Create
 2046-sort-linked-list-already-sorted-using-absolute-values.js

---
 ...st-already-sorted-using-absolute-values.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2046-sort-linked-list-already-sorted-using-absolute-values.js

diff --git a/2046-sort-linked-list-already-sorted-using-absolute-values.js b/2046-sort-linked-list-already-sorted-using-absolute-values.js
new file mode 100644
index 00000000..c80d553a
--- /dev/null
+++ b/2046-sort-linked-list-already-sorted-using-absolute-values.js
@@ -0,0 +1,30 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const sortLinkedList = function(head) {
+  if(head == null) return head
+  const dummy = new ListNode(null, head)
+  let pre = dummy, cur = head
+  while(cur) {
+    if(cur.val < 0 && cur !== head) {
+      const tmp = cur.next, tmpHead = dummy.next
+      dummy.next = cur
+      cur.next = tmpHead
+      pre.next = tmp
+      cur = tmp
+    } else {
+      pre = cur
+      cur = cur.next
+    }
+  }
+
+  return dummy.next
+};

From f2ae2ee86d512fe630025df10f12e63065094d59 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Dec 2021 20:43:24 +0800
Subject: [PATCH 1825/3374] Create
 1422-maximum-score-after-splitting-a-string.js

---
 1422-maximum-score-after-splitting-a-string.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1422-maximum-score-after-splitting-a-string.js

diff --git a/1422-maximum-score-after-splitting-a-string.js b/1422-maximum-score-after-splitting-a-string.js
new file mode 100644
index 00000000..4f897b49
--- /dev/null
+++ b/1422-maximum-score-after-splitting-a-string.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxScore = function(s) {
+  const n = s.length
+  let res = 0, numOfOne = 0
+  for(let ch of s) {
+    if(ch === '1') numOfOne++
+  }
+  for(let i = 0, one = 0; i < n - 1; i++) {
+    if(s[i] === '1') one++
+    res = Math.max(res, (i + 1 - one) + (numOfOne - one))
+  }
+
+  return res
+};

From e97508a4bae294444795cc58d4d3375fe03b98da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Dec 2021 20:59:20 +0800
Subject: [PATCH 1826/3374] Update
 1422-maximum-score-after-splitting-a-string.js

---
 1422-maximum-score-after-splitting-a-string.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/1422-maximum-score-after-splitting-a-string.js b/1422-maximum-score-after-splitting-a-string.js
index 4f897b49..916bae85 100644
--- a/1422-maximum-score-after-splitting-a-string.js
+++ b/1422-maximum-score-after-splitting-a-string.js
@@ -15,3 +15,20 @@ const maxScore = function(s) {
 
   return res
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxScore = function(s) {
+  const n = s.length
+  let res = -Infinity, one = 0, zero = 0
+  for(let i = 0; i < n; i++) {
+    s[i] === '0' ? zero++ : one++
+    if(i !== n - 1) res = Math.max(res, zero - one)
+  }
+
+  return res + one
+};

From 3324cfef2a7a1c031e2abfbdcf99ae9f1492fce3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Dec 2021 16:55:37 +0800
Subject: [PATCH 1827/3374] Update 479-largest-palindrome-product.js

---
 479-largest-palindrome-product.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/479-largest-palindrome-product.js b/479-largest-palindrome-product.js
index 515ba62a..43fb57ef 100644
--- a/479-largest-palindrome-product.js
+++ b/479-largest-palindrome-product.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const largestPalindrome = function (n) {
+  if (n === 1) return 9
+  for (let i = 2, limit = 9 * 10 ** (n - 1); i < limit; i++) {
+    let left = 10 ** n - i
+    let right = +('' + left).split('').reverse().join('')
+    if (i ** 2 - 4 * right < 0) continue
+    const tmp = (i ** 2 - 4 * right) ** 0.5
+    if (tmp === Math.floor(tmp)) {
+      return (
+        (BigInt(right) + 10n ** BigInt(n) * (10n ** BigInt(n) - BigInt(i))) %
+        1337n
+      )
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From dbcf4c69f43ab9f4aac3412ab81e8e045a6eae97 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Dec 2021 20:10:46 +0800
Subject: [PATCH 1828/3374] Create
 1295-find-numbers-with-even-number-of-digits.js

---
 1295-find-numbers-with-even-number-of-digits.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 1295-find-numbers-with-even-number-of-digits.js

diff --git a/1295-find-numbers-with-even-number-of-digits.js b/1295-find-numbers-with-even-number-of-digits.js
new file mode 100644
index 00000000..187c8e4e
--- /dev/null
+++ b/1295-find-numbers-with-even-number-of-digits.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findNumbers = function(nums) {
+  let res = 0
+  for(const e of nums) {
+    const str = '' + e
+    if(str.length % 2 === 0) res++
+  }
+  return res
+};

From 47513c88c4a239d9e4b0c6ec8d5764fefce7ebdf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Dec 2021 21:05:36 +0800
Subject: [PATCH 1829/3374] Create
 1287-element-appearing-more-than-25-in-sorted-array.js

---
 ...-appearing-more-than-25-in-sorted-array.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1287-element-appearing-more-than-25-in-sorted-array.js

diff --git a/1287-element-appearing-more-than-25-in-sorted-array.js b/1287-element-appearing-more-than-25-in-sorted-array.js
new file mode 100644
index 00000000..19e42d38
--- /dev/null
+++ b/1287-element-appearing-more-than-25-in-sorted-array.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const findSpecialInteger = function (arr) {
+  const n = arr.length,
+    { floor } = Math,
+    { getWordIndexRange } = Search()
+  const ticks = [n / 4, n / 2, (n * 3) / 4].map((e) => floor(e))
+  for (const i of ticks) {
+    const [s, e] = getWordIndexRange(arr, arr[i])
+    if (e - s > n / 4) return arr[i]
+  }
+  return 0
+}
+
+function Search() {
+  return { getWordIndexRange }
+
+  /**
+   * Searches for the first true value in the predicate.
+   * Returns hi if not found.
+   * [lo, hi)
+   */
+  function binarySearch(lo, hi, predicate) {
+    while (lo != hi) {
+      let mid = ((lo + hi) / 2) | 0
+      if (predicate(mid)) {
+        hi = mid
+      } else {
+        lo = mid + 1
+      }
+    }
+    return lo
+  }
+
+  function getWordIndexRange(keys, word) {
+    let lo = 0,
+      hi = keys.length
+    function greaterOrEqual(index) {
+      return keys[index] >= word
+    }
+    function less(index) {
+      return keys[index] > word
+    }
+    let lower_bound = binarySearch(0, keys.length, greaterOrEqual)
+    let upper_bound = binarySearch(lower_bound, keys.length, less)
+    return [lower_bound, upper_bound]
+  }
+}

From cddd0cbf5f3851ccd2c6a3243bf5a611f1314303 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Dec 2021 09:55:15 +0800
Subject: [PATCH 1830/3374] Update 866-prime-palindrome.js

---
 866-prime-palindrome.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/866-prime-palindrome.js b/866-prime-palindrome.js
index aaa749f5..1b2652f4 100644
--- a/866-prime-palindrome.js
+++ b/866-prime-palindrome.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const primePalindrome = function(n) {
+  if(n >= 8 && n <= 11) return 11
+  const rev = str => str.split('').reverse().join('')
+  for (let i = 1; i < 1e5; i++) {
+    let left = `${i}`, right = rev(left).slice(1)
+    let num = +(left + right)
+    if (num >= n && isPrime(num)) return num
+  }
+  return -1
+
+  function isPrime(num) {
+    if(num < 2 || num % 2 === 0) return num === 2
+    for(let i = 3; i * i <= num; i += 2) {
+      if(num % i === 0) return false
+    }
+    return true
+  }
+};
+
+// another
+
 /**
  * @param {number} N
  * @return {number}

From 67f7b275905673be3030c51c610da9f3f72825f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Dec 2021 14:20:45 +0800
Subject: [PATCH 1831/3374] Update 906-super-palindromes.js

---
 906-super-palindromes.js | 43 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/906-super-palindromes.js b/906-super-palindromes.js
index 5c876add..2335c676 100644
--- a/906-super-palindromes.js
+++ b/906-super-palindromes.js
@@ -110,3 +110,46 @@ const isPalindromeInt = function (nr) {
 const isPalindrome = function (nr) {
   return nr === nr.split('').reverse().join('')
 }
+
+// another
+
+/**
+ * @param {string} left
+ * @param {string} right
+ * @return {number}
+ */
+ const superpalindromesInRange = function(left, right) {
+  const palindromes = []
+  let res = 0
+  for(let i = 1; i < 10; i++) {
+    palindromes.push(`${i}`)
+  }
+  for(let i = 1; i < 1e4; i++) {
+    let l = `${i}`, r = l.split('').reverse().join('')
+    palindromes.push(`${l}${r}`)
+    for(let j = 0; j < 10; j++) {
+      palindromes.push(`${l}${j}${r}`)
+    }
+  }
+
+  for(let p of palindromes) {
+    const square = BigInt(p) * BigInt(p)
+    if(!isPalindrome(`${square}`)) continue
+    if(BigInt(left) <= square && square <= BigInt(right)) res++ 
+  }
+
+  return res
+
+  function isPalindrome(str) {
+    let i = 0;
+    let j = str.length - 1;
+    while (i < j) {
+      if (str.charAt(i) !== str.charAt(j)) {
+        return false;
+      }
+      i++;
+      j--;
+    }
+    return true;
+  }
+};

From e642e874985f1fbb6331fd36b151424ac18f3e8f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Dec 2021 14:21:04 +0800
Subject: [PATCH 1832/3374] Update 906-super-palindromes.js

---
 906-super-palindromes.js | 45 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/906-super-palindromes.js b/906-super-palindromes.js
index 2335c676..9b97b889 100644
--- a/906-super-palindromes.js
+++ b/906-super-palindromes.js
@@ -153,3 +153,48 @@ const isPalindrome = function (nr) {
     return true;
   }
 };
+
+// another
+
+/**
+ * @param {string} left
+ * @param {string} right
+ * @return {number}
+ */
+const superpalindromesInRange = function (left, right) {
+  let ans = 9 >= left && 9 <= right ? 1 : 0
+
+  const isPal = (str) => {
+    for (let i = 0, j = str.length - 1; i < j; i++, j--)
+      if (str.charAt(i) !== str.charAt(j)) return false
+    return true
+  }
+
+  for (let dig = 1; dig < 10; dig++) {
+    let isOdd = dig % 2 && dig !== 1,
+      innerLen = (dig >> 1) - 1,
+      innerLim = Math.max(1, 2 ** innerLen),
+      midPos = dig >> 1,
+      midLim = isOdd ? 3 : 1
+    for (let edge = 1; edge < 3; edge++) {
+      let pal = new Uint8Array(dig)
+      ;(pal[0] = edge), (pal[dig - 1] = edge)
+      if (edge === 2) (innerLim = 1), (midLim = Math.min(midLim, 2))
+      for (let inner = 0; inner < innerLim; inner++) {
+        if (inner > 0) {
+          let innerStr = inner.toString(2).padStart(innerLen, '0')
+          for (let i = 0; i < innerLen; i++)
+            (pal[1 + i] = innerStr[i]), (pal[dig - 2 - i] = innerStr[i])
+        }
+        for (let mid = 0; mid < midLim; mid++) {
+          if (isOdd) pal[midPos] = mid
+          let palin = ~~pal.join(''),
+            square = BigInt(palin) * BigInt(palin)
+          if (square > right) return ans
+          if (square >= left && isPal(square.toString())) ans++
+        }
+      }
+    }
+  }
+  return ans
+}

From a7ba97872b900242725942c79ba905277c22b0df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Dec 2021 12:21:14 +0800
Subject: [PATCH 1833/3374] Create 2103-rings-and-rods.js

---
 2103-rings-and-rods.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2103-rings-and-rods.js

diff --git a/2103-rings-and-rods.js b/2103-rings-and-rods.js
new file mode 100644
index 00000000..eb8abfab
--- /dev/null
+++ b/2103-rings-and-rods.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} rings
+ * @return {number}
+ */
+const countPoints = function(rings) {
+  const hash = {}
+  
+  for(let i = 0, n = rings.length; i < n; i+=2) {
+    const ch = rings[i], num = +rings[i + 1]
+    if(hash[num] == null) hash[num] = new Set()
+    hash[num].add(ch)
+  }
+  
+  
+  
+  let res = 0
+  Object.keys(hash).forEach(k => {
+    if(hash[k].size === 3) res++
+  })
+  
+  return res
+};

From b9163218281d8e1807651ace6635e7a2504f83fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Dec 2021 12:22:21 +0800
Subject: [PATCH 1834/3374] Create 2104-sum-of-subarray-ranges.js

---
 2104-sum-of-subarray-ranges.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2104-sum-of-subarray-ranges.js

diff --git a/2104-sum-of-subarray-ranges.js b/2104-sum-of-subarray-ranges.js
new file mode 100644
index 00000000..c3fae69d
--- /dev/null
+++ b/2104-sum-of-subarray-ranges.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const subArrayRanges = function(nums) {
+  const n = nums.length, { max, min } = Math
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    let [most, least] = [-Infinity, Infinity]
+    for(let j = i; j < n; j++) {
+      most = max(most, nums[j])
+      least = min(least, nums[j])
+      res += most - least     
+    }
+  }
+  return res
+};

From df9998d73d7e22000efa2dcb74dea321746ea3cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Dec 2021 12:23:32 +0800
Subject: [PATCH 1835/3374] Create 2105-watering-plants-ii.js

---
 2105-watering-plants-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2105-watering-plants-ii.js

diff --git a/2105-watering-plants-ii.js b/2105-watering-plants-ii.js
new file mode 100644
index 00000000..3d4f62e6
--- /dev/null
+++ b/2105-watering-plants-ii.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} plants
+ * @param {number} capacityA
+ * @param {number} capacityB
+ * @return {number}
+ */
+const minimumRefill = function(plants, capacityA, capacityB) {
+    const n = plants.length
+    let [left, right] = [0, n - 1]
+    let [A, B] = [capacityA, capacityB]
+    let ans = 0
+    while (left < right) {
+        if (A < plants[left]) {
+            A = capacityA
+            ans += 1              
+        }
+
+        A -= plants[left]
+        left += 1
+        if (B < plants[right]) {
+            B = capacityB
+            ans += 1              
+        }
+
+        B -= plants[right]
+        right -= 1          
+    }
+
+
+    if (left != right || A >= plants[left] || B >= plants[left]) return ans
+    return ans + 1   
+};
+

From 97a9d6f07b0f48406335e285a88854424f65ffc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Dec 2021 12:24:10 +0800
Subject: [PATCH 1836/3374] Create
 2106-maximum-fruits-harvested-after-at-most-k-steps.js

---
 ...-fruits-harvested-after-at-most-k-steps.js | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 2106-maximum-fruits-harvested-after-at-most-k-steps.js

diff --git a/2106-maximum-fruits-harvested-after-at-most-k-steps.js b/2106-maximum-fruits-harvested-after-at-most-k-steps.js
new file mode 100644
index 00000000..95c808c0
--- /dev/null
+++ b/2106-maximum-fruits-harvested-after-at-most-k-steps.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number[][]} fruits
+ * @param {number} startPos
+ * @param {number} k
+ * @return {number}
+ */
+const maxTotalFruits = function(fruits, startPos, k) {
+    let n = fruits.length, { max, min } = Math
+    let pos = fruits.map(([p,a]) => p)
+    const prefix = Array(n).fill(0)
+
+    let curr = 0
+    for (let i = 0; i < n; i++) {
+        curr += fruits[i][1]
+        prefix[i] = curr      
+    }
+
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+    function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      x < a[mid] ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+    function query(left, right) {
+         left = max(left, 0)
+        right = min(right, 200000)
+        let l = bisect_left(pos, left)
+        let r = bisect_right(pos, right) - 1
+        if (l > r) return 0
+        if (!l) return prefix[r]
+        return prefix[r] - prefix[l - 1]      
+    }
+
+
+    let best = 0
+    let idx = 0
+    for(let right = startPos + k; right > startPos - 1; right -= 2) {
+        let cand = query(startPos - idx, right)
+        best = max(best, cand)
+        idx += 1      
+    }
+
+    idx = 0
+      for(let left = startPos - k; left < startPos + 1; left += 2) {
+                let cand = query(left, startPos + idx)
+        best = max(best, cand)
+        idx += 1
+      }
+
+    return best    
+};
+

From 02a362a3590c1cf1a7a49f85e1b964a52c6bee99 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Dec 2021 10:19:33 +0800
Subject: [PATCH 1837/3374] Update
 1277-count-square-submatrices-with-all-ones.js

---
 ...-count-square-submatrices-with-all-ones.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1277-count-square-submatrices-with-all-ones.js b/1277-count-square-submatrices-with-all-ones.js
index f0f1bd44..61494fcb 100644
--- a/1277-count-square-submatrices-with-all-ones.js
+++ b/1277-count-square-submatrices-with-all-ones.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number}
+ */
+const countSquares = function (matrix) {
+  const [m, n] = [matrix.length, matrix[0].length]
+  let res = 0
+  for(let i = 0;  i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(matrix[i][j] && i > 0 && j > 0) {
+        matrix[i][j] = 1 + Math.min(
+          matrix[i - 1][j],
+          matrix[i][j - 1],
+          matrix[i - 1][j - 1],
+        )
+      }
+      res += matrix[i][j]
+    }
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number[][]} matrix
  * @return {number}

From fdcce3a85feba3c04846792a2f83e71efb477951 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Dec 2021 10:32:02 +0800
Subject: [PATCH 1838/3374] Create 2088-count-fertile-pyramids-in-a-land.js

---
 2088-count-fertile-pyramids-in-a-land.js | 48 ++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2088-count-fertile-pyramids-in-a-land.js

diff --git a/2088-count-fertile-pyramids-in-a-land.js b/2088-count-fertile-pyramids-in-a-land.js
new file mode 100644
index 00000000..a44c84c3
--- /dev/null
+++ b/2088-count-fertile-pyramids-in-a-land.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const countPyramids = function(grid) {
+  const rev = clone(grid)
+  let res = count(grid)
+  rev.reverse()
+  res += count(rev)
+  return res
+
+  function clone(grid) {
+    let res = []
+    for (const row of grid) {
+      res.push(row.slice())
+    }
+    return res
+  }
+  function reverse(grid) {
+    let l = 0, r = grid.length - 1
+    while(l < r) {
+      const tmp = grid[l]
+      grid[l] = grid[r]
+      grid[r] = tmp
+      l++
+      r--
+    }
+  }
+
+  function count(grid) {
+    const m = grid.length, n = grid[0].length
+    let res = 0
+
+    for (let i = 1; i < m; i++) {
+      for (let j = 1; j < n - 1; j++) {
+        if (grid[i][j] && grid[i - 1][j]) {
+          grid[i][j] = Math.min(
+            grid[i - 1][j - 1],
+            grid[i - 1][j + 1]
+          ) + 1
+          res += grid[i][j] - 1
+        }
+      }
+    }
+
+    return res
+  }
+};

From fbf647085254a8c7a705f0c6c003a2824d469bfb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Dec 2021 10:34:08 +0800
Subject: [PATCH 1839/3374] Update 2088-count-fertile-pyramids-in-a-land.js

---
 2088-count-fertile-pyramids-in-a-land.js | 23 +++--------------------
 1 file changed, 3 insertions(+), 20 deletions(-)

diff --git a/2088-count-fertile-pyramids-in-a-land.js b/2088-count-fertile-pyramids-in-a-land.js
index a44c84c3..f1677e0d 100644
--- a/2088-count-fertile-pyramids-in-a-land.js
+++ b/2088-count-fertile-pyramids-in-a-land.js
@@ -2,35 +2,19 @@
  * @param {number[][]} grid
  * @return {number}
  */
-const countPyramids = function(grid) {
-  const rev = clone(grid)
+ const countPyramids = function(grid) {
+  const rev = clone(grid).reverse()
   let res = count(grid)
-  rev.reverse()
   res += count(rev)
   return res
 
   function clone(grid) {
-    let res = []
-    for (const row of grid) {
-      res.push(row.slice())
-    }
-    return res
-  }
-  function reverse(grid) {
-    let l = 0, r = grid.length - 1
-    while(l < r) {
-      const tmp = grid[l]
-      grid[l] = grid[r]
-      grid[r] = tmp
-      l++
-      r--
-    }
+    return grid.map(e => e.slice())
   }
 
   function count(grid) {
     const m = grid.length, n = grid[0].length
     let res = 0
-
     for (let i = 1; i < m; i++) {
       for (let j = 1; j < n - 1; j++) {
         if (grid[i][j] && grid[i - 1][j]) {
@@ -42,7 +26,6 @@ const countPyramids = function(grid) {
         }
       }
     }
-
     return res
   }
 };

From b3f0f3c566bec9753b30c12e8e24f38d5ff9631f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Dec 2021 10:59:31 +0800
Subject: [PATCH 1840/3374] Create
 2086-minimum-number-of-buckets-required-to-collect-rainwater-from-houses.js

---
 ...required-to-collect-rainwater-from-houses.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2086-minimum-number-of-buckets-required-to-collect-rainwater-from-houses.js

diff --git a/2086-minimum-number-of-buckets-required-to-collect-rainwater-from-houses.js b/2086-minimum-number-of-buckets-required-to-collect-rainwater-from-houses.js
new file mode 100644
index 00000000..e7193788
--- /dev/null
+++ b/2086-minimum-number-of-buckets-required-to-collect-rainwater-from-houses.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} street
+ * @return {number}
+ */
+var minimumBuckets = function(street) {
+  const arr = street.split(''), n = arr.length
+  let res = 0
+  for(let i = 0; i < arr.length; i++) {
+    if(arr[i] === 'H') {
+      if(i > 0 && arr[i - 1] === 'B') continue
+      if(i < n - 1 && arr[i + 1] === '.') arr[i + 1] = 'B', res++
+      else if(i > 0 && arr[i - 1] === '.') arr[i - 1] = 'B', res++
+      else return -1
+    }
+  }
+  return res
+};

From 25258618fe63611a8994426e51548c0865290e55 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Dec 2021 10:37:49 +0800
Subject: [PATCH 1841/3374] Update 2092-find-all-people-with-secret.js

---
 2092-find-all-people-with-secret.js | 52 +++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/2092-find-all-people-with-secret.js b/2092-find-all-people-with-secret.js
index 88ab147f..fc592271 100644
--- a/2092-find-all-people-with-secret.js
+++ b/2092-find-all-people-with-secret.js
@@ -1,3 +1,55 @@
+/**
+ * @param {number} n
+ * @param {number[][]} meetings
+ * @param {number} firstPerson
+ * @return {number[]}
+ */
+const findAllPeople = function(n, meetings, firstPerson) {
+  meetings.sort((a, b) => a[2] - b[2])
+  const uf = new UnionFind(n);
+  uf.connect(0, firstPerson);
+  let ppl = [];
+  for (let i = 0, len = meetings.length; i < len; ) {
+    ppl = [];
+    let time = meetings[i][2];
+    while (i < len && meetings[i][2] === time) {
+      uf.connect(meetings[i][0], meetings[i][1]);
+      ppl.push(meetings[i][0]);
+      ppl.push(meetings[i][1]);
+      i++
+    }
+    for (let n of ppl) {
+      if (!uf.connected(0, n)) uf.reset(n);
+    }
+  }
+  let ans = [];
+  for (let i = 0; i < n; ++i) {
+    if (uf.connected(0, i)) ans.push(i);
+  }
+  return ans;
+};
+
+class UnionFind {
+  constructor(n) {
+    this.arr = Array(n).fill(null)
+    this.arr.forEach((e, i, arr) => arr[i] = i)
+  }
+  connect(a, b) {
+    this.arr[this.find(a)] = this.find(this.arr[b])
+  }
+  find(a) {
+    return this.arr[a] === a ? a : (this.arr[a] = this.find(this.arr[a]))
+  }
+  connected(a, b) {
+    return this.find(a) === this.find(b)
+  }
+  reset(a) {
+    this.arr[a] = a
+  }
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} meetings

From b3e47618852781b0004cc99147838e2e49ca1301 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Dec 2021 11:36:20 +0800
Subject: [PATCH 1842/3374] Create
 5956-find-first-palindromic-string-in-the-array.js

---
 ...d-first-palindromic-string-in-the-array.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 5956-find-first-palindromic-string-in-the-array.js

diff --git a/5956-find-first-palindromic-string-in-the-array.js b/5956-find-first-palindromic-string-in-the-array.js
new file mode 100644
index 00000000..b496507a
--- /dev/null
+++ b/5956-find-first-palindromic-string-in-the-array.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string[]} words
+ * @return {string}
+ */
+const firstPalindrome = function(words) {
+  for(let str of words) {
+    if(isPa(str)) return str
+  }
+  
+  return ''
+};
+
+function isPa(str) {
+  let l = 0, r = str.length - 1
+  while(l < r) {
+    if(str[l] !== str[r]) return false
+    l++
+    r--
+  }
+  
+  
+  return true
+}

From c32e88e36bac0bc1b9af082caaa28bf62027ad24 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Dec 2021 11:36:48 +0800
Subject: [PATCH 1843/3374] Create 5957-adding-spaces-to-a-string.js

---
 5957-adding-spaces-to-a-string.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 5957-adding-spaces-to-a-string.js

diff --git a/5957-adding-spaces-to-a-string.js b/5957-adding-spaces-to-a-string.js
new file mode 100644
index 00000000..1696b3b6
--- /dev/null
+++ b/5957-adding-spaces-to-a-string.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @param {number[]} spaces
+ * @return {string}
+ */
+var addSpaces = function(s, spaces) {
+  let res = '', j = 0, idx = spaces[j]
+  for(let i = 0, n = s.length; i < n; i++) {
+    if(i === idx) {
+      res += ' '
+      j++
+      idx = spaces[j]
+    }
+    res += s[i]
+  }
+  
+  return res
+};

From 7c68bf66eb05a2f7232cefe21d645455992690af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Dec 2021 11:37:17 +0800
Subject: [PATCH 1844/3374] Create
 5958-number-of-smooth-descent-periods-of-a-stock.js

---
 ...er-of-smooth-descent-periods-of-a-stock.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 5958-number-of-smooth-descent-periods-of-a-stock.js

diff --git a/5958-number-of-smooth-descent-periods-of-a-stock.js b/5958-number-of-smooth-descent-periods-of-a-stock.js
new file mode 100644
index 00000000..d797df08
--- /dev/null
+++ b/5958-number-of-smooth-descent-periods-of-a-stock.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} prices
+ * @return {number}
+ */
+const getDescentPeriods = function(prices) {
+  if(prices.length === 1) return 1
+  let res = 0, idx = 0
+  
+  for (let i = 1, n = prices.length; i < n ; i++) {
+    if(prices[i - 1] - prices[i] === 1) {
+     if (i === n - 1) {
+      const len = i - idx + 1
+      res += (len + 1) * len / 2
+     }
+    } else {
+      const len = i - 1 - idx + 1
+      res += (len + 1) * len / 2
+      idx = i
+      if(i === n - 1) {
+        res += 1
+      }
+    }
+
+  }
+  
+  return res
+};

From 0a82b29a7a84546cc39fd985518a7d5b302a7e80 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Dec 2021 11:37:46 +0800
Subject: [PATCH 1845/3374] Create
 5959-minimum-operations-to-make-the-array-k-increasing.js

---
 ...erations-to-make-the-array-k-increasing.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 5959-minimum-operations-to-make-the-array-k-increasing.js

diff --git a/5959-minimum-operations-to-make-the-array-k-increasing.js b/5959-minimum-operations-to-make-the-array-k-increasing.js
new file mode 100644
index 00000000..75490810
--- /dev/null
+++ b/5959-minimum-operations-to-make-the-array-k-increasing.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @return {number}
+ */
+const kIncreasing = function(arr, k) {
+  const n = arr.length
+  const a = Array.from({ length: k }, () => Array())
+  
+  for(let i = 0; i < k; i++) {
+    for(let j = i; j < n; j += k) {
+      a[i].push(arr[j])
+    }
+  }
+  
+  let res = 0
+  for(let i = 0; i < a.length; i++) {
+    const r = a[i]
+    res += r.length - lis(r)
+  }
+  
+  return res
+  
+  function bisect_right(a, x, lo = 0, hi = null) { // > upper_bound
+      if (lo < 0) throw new Error('lo must be non-negative');
+      if (hi == null) hi = a.length;
+      while (lo < hi) {
+          let mid = parseInt((lo + hi) / 2);
+          x < a[mid] ? hi = mid : lo = mid + 1;
+      }
+      return lo;
+  }
+  
+  function lis(ar) {
+    let q = []
+    for (let x of ar) {
+        let i = bisect_right(q, x)
+        if (i == q.length) q.push(x)
+        else q[i] = x      
+    }
+
+    return q.length
+  }
+};
+

From 279caa1230f2ef319217de70505baac767e810dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Dec 2021 20:12:16 +0800
Subject: [PATCH 1846/3374] Create 2097-valid-arrangement-of-pairs.js

---
 2097-valid-arrangement-of-pairs.js | 36 ++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2097-valid-arrangement-of-pairs.js

diff --git a/2097-valid-arrangement-of-pairs.js b/2097-valid-arrangement-of-pairs.js
new file mode 100644
index 00000000..35ae9f41
--- /dev/null
+++ b/2097-valid-arrangement-of-pairs.js
@@ -0,0 +1,36 @@
+const packDGInOutDegreeMap = (gm, edges, dm) => { for (const [u, v] of edges) { if (!gm.has(u)) gm.set(u, []); gm.get(u).push(v); dm.set(u, (dm.get(u) || 0) + 1); dm.set(v, (dm.get(v) || 0) - 1); } };
+
+/**
+ * @param {number[][]} pairs
+ * @return {number[][]}
+ */
+const validArrangement = (pairs) => {
+    let g = new Map(), deg = new Map(), res = [];
+    packDGInOutDegreeMap(g, pairs, deg);
+    let start = -1;
+    for (const [node, ] of deg) { // looking for starting node
+        if (start == -1 || deg.get(node) == 1) start = node;
+    }
+    let path = eulerianPath(g, start);
+    path.reverse();
+    for (let i = 1; i < path.length; i++) {
+       res.push([path[i-1], path[i]]);
+    }
+    return res;
+};
+
+const eulerianPath = (g, start) => { // eulerian Path with Hierholzer’s Algorithm
+    let st = [start], path = [];
+    while (st.length) {
+        let u = st[st.length - 1], ua = g.get(u) || [];
+        if (ua.length) {
+            let v = ua.pop();
+            g.set(u, ua);
+            st.push(v);
+        } else {
+            path.push(u);
+            st.pop();
+        }
+    }
+    return path;
+};

From 151eddef15e877cb8fb8179f4bf98378e6bbfdb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Dec 2021 11:24:41 +0800
Subject: [PATCH 1847/3374] Update
 1123-lowest-common-ancestor-of-deepest-leaves.js

---
 ...owest-common-ancestor-of-deepest-leaves.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1123-lowest-common-ancestor-of-deepest-leaves.js b/1123-lowest-common-ancestor-of-deepest-leaves.js
index 36148413..ef42ddea 100644
--- a/1123-lowest-common-ancestor-of-deepest-leaves.js
+++ b/1123-lowest-common-ancestor-of-deepest-leaves.js
@@ -1,3 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const lcaDeepestLeaves = function(root) {
+  let maxDepth = 0, lcaNode = null
+
+  function lca(node, depth) {
+    if(node == null) return depth - 1
+    maxDepth = Math.max(depth, maxDepth)
+    const left = lca(node.left, depth + 1)
+    const right = lca(node.right, depth + 1)
+    if(left === maxDepth && right === maxDepth) {
+      lcaNode = node
+    }
+    return Math.max(left, right)
+  }
+
+  lca(root, 0)
+  return lcaNode
+};
+
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 2869cbc81b05b46ac0fe51d1f55426230066eca1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Dec 2021 09:41:50 +0800
Subject: [PATCH 1848/3374] Update 1740-find-distance-in-a-binary-tree.js

---
 1740-find-distance-in-a-binary-tree.js | 40 ++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/1740-find-distance-in-a-binary-tree.js b/1740-find-distance-in-a-binary-tree.js
index 9d982dec..97dae690 100644
--- a/1740-find-distance-in-a-binary-tree.js
+++ b/1740-find-distance-in-a-binary-tree.js
@@ -1,3 +1,43 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} p
+ * @param {number} q
+ * @return {number}
+ */
+const findDistance = function(root, p, q) {
+  if(p === q) return 0
+  return dfs(root, 0)
+
+  function dfs(node, depth) {
+    let res = depth
+    if (node == null) {
+      res = 0
+    } else if(node.val === p || node.val === q) {
+      let left = dfs(node.left, 1)
+      let right = dfs(node.right, 1)
+      res = (left > 0 || right > 0) ? Math.max(left, right) : res
+    } else {
+      let left = dfs(node.left, depth + 1)
+      let right = dfs(node.right, depth + 1)
+      res = left + right
+      if(left !== 0 && right !== 0) {
+        res -= 2 * depth
+      }
+    }
+    return res
+  }
+};
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val, left, right) {

From 0c193c36bf5b165fa9586fb75ffbca0ae0be6c00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Dec 2021 15:14:49 +0800
Subject: [PATCH 1849/3374] Create 2119-a-number-after-a-double-reversal.js

---
 2119-a-number-after-a-double-reversal.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 2119-a-number-after-a-double-reversal.js

diff --git a/2119-a-number-after-a-double-reversal.js b/2119-a-number-after-a-double-reversal.js
new file mode 100644
index 00000000..6d82d7f3
--- /dev/null
+++ b/2119-a-number-after-a-double-reversal.js
@@ -0,0 +1,9 @@
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+var isSameAfterReversals = function(num) {
+  if(('' +num).length === 1) return true
+  const tmp = (''+num).endsWith('0')
+  return !tmp
+};

From bca43de3055be1a8b4a74b5c9e291c7870cadffa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Dec 2021 17:27:26 +0800
Subject: [PATCH 1850/3374] Create 2101-detonate-the-maximum-bombs.js

---
 2101-detonate-the-maximum-bombs.js | 38 ++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2101-detonate-the-maximum-bombs.js

diff --git a/2101-detonate-the-maximum-bombs.js b/2101-detonate-the-maximum-bombs.js
new file mode 100644
index 00000000..8955bd15
--- /dev/null
+++ b/2101-detonate-the-maximum-bombs.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} bombs
+ * @return {number}
+ */
+ const maximumDetonation = function(bombs) {
+  let n = bombs.length, res = 1, graph = {}
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < n; j++) {
+      if (i === j) continue
+      if (bombAdj(bombs[i], bombs[j])) {
+        if (graph[i] == null) graph[i] = []
+        graph[i].push(j)
+      }
+    }
+  }
+  function dfs(node, visited) {
+    for(const next of (graph[node] || [])) {
+      if(!visited.has(next)) {
+        visited.add(next)
+        dfs(next, visited)
+      }
+    }
+  }
+  for (let i = 0; i < n; i++) {
+    const set = new Set([i])
+    dfs(i, set)
+    res = Math.max(res, set.size)
+  }
+
+  return res
+};
+
+function bombAdj(source, target) {
+  const [x1, y1, r1] = source
+  const [x2, y2] = target
+  const { abs } = Math
+  return abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2 <= r1 ** 2
+}

From 4c5514c23ce8877358746c0e41cbe55e502c70cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Dec 2021 15:47:04 +0800
Subject: [PATCH 1851/3374] Update 1944-number-of-visible-people-in-a-queue.js

---
 1944-number-of-visible-people-in-a-queue.js | 22 +++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/1944-number-of-visible-people-in-a-queue.js b/1944-number-of-visible-people-in-a-queue.js
index 48cccf15..6505ef83 100644
--- a/1944-number-of-visible-people-in-a-queue.js
+++ b/1944-number-of-visible-people-in-a-queue.js
@@ -21,3 +21,25 @@ const canSeePersonsCount = function(heights) {
 
     return ans;
 };
+
+// another
+
+/**
+ * @param {number[]} heights
+ * @return {number[]}
+ */
+const canSeePersonsCount = function(heights) {
+  const stack = [], n = heights.length, res = Array(n)
+  for(let i = n - 1; i >= 0; i--) {
+    const h = heights[i]
+    let del = 0
+    while(stack.length && stack[stack.length - 1] <= h) {
+      stack.pop()
+      del++
+    }
+    res[i] = stack.length ? del + 1 : del
+    stack.push(h)
+  }
+
+  return res
+};

From a3b3495fe703bbad571304d84fc995c9e989af7e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Dec 2021 19:12:05 +0800
Subject: [PATCH 1852/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 25 ++++++++++++++-----------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index b9cf6459..c3c785c8 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -2,21 +2,24 @@
  * @param {number[]} arr
  * @return {number}
  */
-const sumSubarrayMins = function(arr) {
-  const n = arr.length, s1 = [], s2 = [], left = Array(n), right = Array(n)
-  for(let i = 0; i < n; i++) {
+const sumSubarrayMins = function (arr) {
+  const n = arr.length,
+    s1 = [],
+    s2 = [],
+    left = Array(n),
+    right = Array(n)
+  for (let i = 0; i < n; i++) {
     let cnt = 1
-    while(s1.length && s1[s1.length - 1][0] > arr[i]) {
+    while (s1.length && s1[s1.length - 1][0] > arr[i]) {
       cnt += s1.pop()[1]
     }
     left[i] = cnt
     s1.push([arr[i], cnt])
   }
-  
-  for(let i = n - 1; i >= 0; i--) {
+
+  for (let i = n - 1; i >= 0; i--) {
     let cnt = 1
-    // use ">=" to deal with duplicate elements
-    while(s2.length && s2[s2.length - 1][0] >= arr[i]) {
+    while (s2.length && s2[s2.length - 1][0] >= arr[i]) {
       cnt += s2.pop()[1]
     }
     right[i] = cnt
@@ -24,11 +27,11 @@ const sumSubarrayMins = function(arr) {
   }
   let res = 0
   const mod = 1e9 + 7
-  for(let i = 0; i < n; i++) {
+  for (let i = 0; i < n; i++) {
     // left[i] number of starting positions
     // right[i] number of ending positions
     res = (res + arr[i] * left[i] * right[i]) % mod
   }
-  
+
   return res
-};
+}

From 28d4e7cac5621ade85ce2521b48fb1e88b3482c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Jan 2022 22:21:55 +0800
Subject: [PATCH 1853/3374] Create 1399-count-largest-group.js

---
 1399-count-largest-group.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1399-count-largest-group.js

diff --git a/1399-count-largest-group.js b/1399-count-largest-group.js
new file mode 100644
index 00000000..c99882aa
--- /dev/null
+++ b/1399-count-largest-group.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countLargestGroup = function(n) {
+  const hash = {}
+  const sum = n => `${n}`.split('').reduce((ac, e) => ac + (+e), 0)
+  for(let i = 1; i <= n; i++) {
+    const tmp = sum(i)
+    if(hash[tmp] == null) hash[tmp] = 0
+    hash[tmp]++
+  }
+  // console.log(hash)
+  const val = Math.max(...Object.values(hash))
+  let res = 0
+  Object.keys(hash).forEach(k => {
+    if(hash[k] === val) res++
+  })
+  
+  return res
+};

From c68b0969a12eea7582bc342a9c19f1359263eba7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jan 2022 17:24:23 +0800
Subject: [PATCH 1854/3374] Create
 2124-check-if-all-as-appears-before-all-bs.js

---
 2124-check-if-all-as-appears-before-all-bs.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 2124-check-if-all-as-appears-before-all-bs.js

diff --git a/2124-check-if-all-as-appears-before-all-bs.js b/2124-check-if-all-as-appears-before-all-bs.js
new file mode 100644
index 00000000..071f480a
--- /dev/null
+++ b/2124-check-if-all-as-appears-before-all-bs.js
@@ -0,0 +1,9 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const checkString = function(s) {
+  const la = s.lastIndexOf('a')
+  const fb = s.indexOf('b')
+  return fb === -1 ? true : la < fb
+};

From c5c7774d0e008aac19fb0e74aa6ca6b42db1175c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jan 2022 17:24:48 +0800
Subject: [PATCH 1855/3374] Create 2125-number-of-laser-beams-in-a-bank.js

---
 2125-number-of-laser-beams-in-a-bank.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2125-number-of-laser-beams-in-a-bank.js

diff --git a/2125-number-of-laser-beams-in-a-bank.js b/2125-number-of-laser-beams-in-a-bank.js
new file mode 100644
index 00000000..cd5bb046
--- /dev/null
+++ b/2125-number-of-laser-beams-in-a-bank.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string[]} bank
+ * @return {number}
+ */
+var numberOfBeams = function(bank) {
+  const comb = (num1, num2) => num1 * num2
+  const m = bank.length, n = bank[0].length
+  if(m === 0 || n === 0) return 0
+  let pre = 0, res = 0
+  for(let j = 0; j < n; j++) {
+    if(bank[0][j] === '1') pre++
+  }
+  for(let i = 1; i < m; i++) {
+    let chk = 0, cur = bank[i]
+    for(let j = 0; j < n; j++) {
+      if(cur[j] === '1') chk++
+    }
+    if(chk) {
+      res += comb(pre, chk)
+      pre = chk
+    }
+  }
+  return res
+};

From 59d7f58e16266639b2ef4a7fdb70c65430902d39 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jan 2022 17:25:18 +0800
Subject: [PATCH 1856/3374] Create 2126-destroying-asteroids.js

---
 2126-destroying-asteroids.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2126-destroying-asteroids.js

diff --git a/2126-destroying-asteroids.js b/2126-destroying-asteroids.js
new file mode 100644
index 00000000..add34396
--- /dev/null
+++ b/2126-destroying-asteroids.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} mass
+ * @param {number[]} asteroids
+ * @return {boolean}
+ */
+const asteroidsDestroyed = function(mass, asteroids) {
+  asteroids.sort((a, b) => a - b)
+  let res = true
+  for(let i = 0, n = asteroids.length; i < n; i++) {
+    const cur = asteroids[i]
+    if(mass >= cur) {
+      mass += cur
+    } else {
+      res = false
+      break
+    }
+  }
+  
+  return res
+};

From 626e3967b3834042a1fccefba2bd3af87a2f18d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jan 2022 17:25:42 +0800
Subject: [PATCH 1857/3374] Create
 2127-maximum-employees-to-be-invited-to-a-meeting.js

---
 ...um-employees-to-be-invited-to-a-meeting.js | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 2127-maximum-employees-to-be-invited-to-a-meeting.js

diff --git a/2127-maximum-employees-to-be-invited-to-a-meeting.js b/2127-maximum-employees-to-be-invited-to-a-meeting.js
new file mode 100644
index 00000000..c0247001
--- /dev/null
+++ b/2127-maximum-employees-to-be-invited-to-a-meeting.js
@@ -0,0 +1,52 @@
+/**
+ * @param {number[]} favorite
+ * @return {number}
+ */
+var maximumInvitations = function(favorite) {
+  const n = favorite.length, m = Array(n).fill(-1), r = Array.from({ length: n }, () => [])
+  for(let i = 0; i < n; i++) r[favorite[i]].push(i)
+  
+  function dfs(u) {
+    if(m[u] !== -1) return m[u]
+    let res = 0
+    for(let v of r[u]) res = Math.max(res, dfs(v))
+    return m[u] = 1 + res
+  }
+  let res = 0, free = 0
+  for(let i = 0; i < n; ++i) {
+    if (m[i] != -1) continue; // skip visited nodes
+    if (favorite[favorite[i]] == i) {
+      m[i] = m[favorite[i]] = 0;
+      let a = 0, b = 0; // find the length of the longest arms starting from `i` and `A[i]`
+      for (let v of r[i]) {
+          if (v == favorite[i]) continue;
+          a = Math.max(a, dfs(v));
+      }
+      for (let v of r[favorite[i]]) {
+          if (v == i) continue;
+          b = Math.max(b, dfs(v));
+      }
+      free += a + b + 2; // this free component is of length `a+b+2`
+    } 
+  }
+  function dfs2(u) {
+    if (m[u] != -1) return[u, m[u], false]; // this is the merge point
+    m[u] = 0;
+    let [mergePoint, depth, mergePointMet] = dfs2(favorite[u]);
+    if (mergePointMet) { // If we've met the merge point again already, this node is outside of the cycle and should be ignored.
+        m[u] = 0;
+        return [mergePoint, depth, true];
+    }
+    m[u] = 1 + depth; // If we haven't met the merge point, we increment the depth.
+    return [mergePoint, m[u], u == mergePoint];
+  }
+  
+  for(let i = 0; i < n; i++) {
+    if(m[i] !== -1) continue
+    let [mergePoint, depth, mergePointMet] = dfs2(i)
+    if(mergePointMet) res = Math.max(res, depth)
+  }
+  
+  return Math.max(res, free)
+};
+

From 3f01dfe6638f05f310a86a23ab78772cc0008cf4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Jan 2022 16:05:12 +0800
Subject: [PATCH 1858/3374] Update
 1964-find-the-longest-valid-obstacle-course-at-each-position.js

---
 ...-valid-obstacle-course-at-each-position.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1964-find-the-longest-valid-obstacle-course-at-each-position.js b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
index 86eab10a..878844f2 100644
--- a/1964-find-the-longest-valid-obstacle-course-at-each-position.js
+++ b/1964-find-the-longest-valid-obstacle-course-at-each-position.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} obstacles
+ * @return {number[]}
+ */
+const longestObstacleCourseAtEachPosition = function(obstacles) {
+  const n = obstacles.length, res = [], stk = []
+  for (let i = 0; i < n; i++) {
+    const cur = obstacles[i]
+    let idx = chk(cur)
+    if (idx === stk.length) {
+      stk.push(cur)
+    } else {
+      stk[idx] = cur
+    }
+    res.push(++idx)
+  }
+
+  return res
+
+  function chk(val) {
+    let l = 0, r = stk.length
+    while(l < r) {
+      const mid = ~~((l + r) / 2)
+      if(stk[mid] <= val) l = mid + 1
+      else r = mid
+    }
+    return l
+  }
+};
+
+// another
+
 /**
  * @param {number[]} obstacles
  * @return {number[]}

From 5d8ef4f5efda1ad241f93bf68da1ded6cf1229eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Jan 2022 10:23:30 +0800
Subject: [PATCH 1859/3374] Update
 5959-minimum-operations-to-make-the-array-k-increasing.js

---
 ...erations-to-make-the-array-k-increasing.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/5959-minimum-operations-to-make-the-array-k-increasing.js b/5959-minimum-operations-to-make-the-array-k-increasing.js
index 75490810..821bceef 100644
--- a/5959-minimum-operations-to-make-the-array-k-increasing.js
+++ b/5959-minimum-operations-to-make-the-array-k-increasing.js
@@ -1,3 +1,45 @@
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @return {number}
+ */
+const kIncreasing = function(arr, k) {
+  let res = 0, matrix = Array.from({ length: k }, () => []), n = arr.length
+  for(let i = 0; i < k; i++) {
+    for(let j = i; j < n; j += k) {
+      matrix[i].push(arr[j])
+    }
+  }
+
+  for (let i = 0; i < k; i++) {
+    res += matrix[i].length - nonDecreasing(matrix[i])
+  }
+
+  return res
+
+  function bisect_right(ar, x, l = 0, r) {
+    if(r == null) r = ar.length
+    while(l < r) {
+      const mid = ~~((l + r) / 2)
+      if(ar[mid] <= x) l = mid + 1
+      else r = mid
+    }
+    return l
+  }
+
+  function nonDecreasing(ar) {
+    let stk = []
+    for(let e of ar) {
+      const idx = bisect_right(stk, e)
+      if(idx === stk.length) stk.push(e)
+      else stk[idx] = e
+    }
+
+    return stk.length
+  }
+};
+
+// another
 /**
  * @param {number[]} arr
  * @param {number} k

From e2688bcdc144e41e50b7c3ddca9dd5ab97b42a6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Jan 2022 10:23:49 +0800
Subject: [PATCH 1860/3374] Rename
 5959-minimum-operations-to-make-the-array-k-increasing.js to
 2111-minimum-operations-to-make-the-array-k-increasing.js

---
 ...s => 2111-minimum-operations-to-make-the-array-k-increasing.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 5959-minimum-operations-to-make-the-array-k-increasing.js => 2111-minimum-operations-to-make-the-array-k-increasing.js (100%)

diff --git a/5959-minimum-operations-to-make-the-array-k-increasing.js b/2111-minimum-operations-to-make-the-array-k-increasing.js
similarity index 100%
rename from 5959-minimum-operations-to-make-the-array-k-increasing.js
rename to 2111-minimum-operations-to-make-the-array-k-increasing.js

From 1664e4a1add4cd69f7b54a4004e07dacdde58c67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Jan 2022 09:50:56 +0800
Subject: [PATCH 1861/3374] Update
 1713-minimum-operations-to-make-a-subsequence.js

---
 ...inimum-operations-to-make-a-subsequence.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1713-minimum-operations-to-make-a-subsequence.js b/1713-minimum-operations-to-make-a-subsequence.js
index edd5d4c5..72b75060 100644
--- a/1713-minimum-operations-to-make-a-subsequence.js
+++ b/1713-minimum-operations-to-make-a-subsequence.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number[]} target
+ * @param {number[]} arr
+ * @return {number}
+ */
+const minOperations = function(target, arr) {
+  const hash = {}
+  for (let i = 0, n = target.length; i < n; i++) {
+    hash[target[i]] = i
+  }
+  const stk = []
+  for(let e of arr) {
+    if(hash[e] == null) continue
+    let l = 0, r = stk.length
+    while(l < r) {
+      const mid = l + (~~((r - l) / 2))
+      if(stk[mid] < hash[e]) l = mid + 1
+      else r = mid
+    }
+    stk[l] = hash[e]
+  }
+  return target.length - stk.length
+};
+
+// another
+
 /**
  * @param {number[]} target
  * @param {number[]} arr

From 9e1a32ef8832180cba6a1bdba7f0d0791b82ef7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jan 2022 11:58:33 +0800
Subject: [PATCH 1862/3374] Create 5979-earliest-possible-day-of-full-bloom.js

---
 5979-earliest-possible-day-of-full-bloom.js | 36 +++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 5979-earliest-possible-day-of-full-bloom.js

diff --git a/5979-earliest-possible-day-of-full-bloom.js b/5979-earliest-possible-day-of-full-bloom.js
new file mode 100644
index 00000000..54a811b2
--- /dev/null
+++ b/5979-earliest-possible-day-of-full-bloom.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} plantTime
+ * @param {number[]} growTime
+ * @return {number}
+ */
+var earliestFullBloom = function(plantTime, growTime) {
+      const sum = arr => arr.reduce((ac, e) => ac +e, 0)
+      let l = 0, r = sum(plantTime) + sum(growTime)
+      let n = plantTime.length
+
+      let a = []
+      for(let i = 0; i < n; i++) {
+        a.push([growTime[i], plantTime[i] ])
+      }
+
+      a.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+      a.reverse()
+      function chk(d) {
+          let total = -1
+          let max_num = 0
+          for(let i = 0; i < n; i++) {
+             total += a[i][1]
+              max_num = Math.max(max_num, total + a[i][0] + 1)
+          }
+          return max_num <= d
+      }
+
+      while (l < r) {
+          let m = ~~((l + r) / 2)
+          if (chk(m)) r = m
+          else l = m + 1          
+      }
+
+      return l
+};
+

From 4c1a7268d88ef13fb8abec4aa486251a446120eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jan 2022 11:59:02 +0800
Subject: [PATCH 1863/3374] Create
 5978-count-words-obtained-after-adding-a-letter.js

---
 ...nt-words-obtained-after-adding-a-letter.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 5978-count-words-obtained-after-adding-a-letter.js

diff --git a/5978-count-words-obtained-after-adding-a-letter.js b/5978-count-words-obtained-after-adding-a-letter.js
new file mode 100644
index 00000000..9136ea31
--- /dev/null
+++ b/5978-count-words-obtained-after-adding-a-letter.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string[]} startWords
+ * @param {string[]} targetWords
+ * @return {number}
+ */
+var wordCount = function(startWords, targetWords) {
+        const set = new Set();
+    for (let startWord of startWords) {
+        const chars = startWord.split('');
+        chars.sort();
+        set.add(chars.join(''));
+    }
+    let res = 0;
+    for (let targetWord of targetWords) {
+        let chars = targetWord.split('');
+        chars.sort()  
+
+        let word = chars.join('');
+        for (let i = 0; i < chars.length; i++) {
+            let subWord = word.substring(0, i) + word.substring(i + 1, chars.length);
+            if (set.has(subWord)) {
+                res++;
+                break;
+            }
+        }
+    }
+    return res;
+};

From cae148115a21b7ac6df5612d161700fd664adcfb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jan 2022 11:59:30 +0800
Subject: [PATCH 1864/3374] Create
 5977-minimum-swaps-to-group-all-1s-together-ii.js

---
 ...nimum-swaps-to-group-all-1s-together-ii.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 5977-minimum-swaps-to-group-all-1s-together-ii.js

diff --git a/5977-minimum-swaps-to-group-all-1s-together-ii.js b/5977-minimum-swaps-to-group-all-1s-together-ii.js
new file mode 100644
index 00000000..a143e4b3
--- /dev/null
+++ b/5977-minimum-swaps-to-group-all-1s-together-ii.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSwaps = function(nums) {
+    let one = 0;
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] == 1)
+            one++;
+    }
+    let maxOne = 0;
+    for (let i = 0; i < one; i++) {
+        if (nums[i] == 1)
+            maxOne++;
+    }
+    let max = maxOne;
+    for (let i = 1; i < nums.length; i++) {
+        if (nums[i - 1] == 1)
+            maxOne--;
+        if (nums[(i + one - 1) % nums.length] == 1)
+            maxOne++;
+        if (maxOne > max)
+            max = maxOne;
+    }
+    return one - max;
+      
+};

From 01b805985d6991eb64a7b6675bc0e46f1c6edd90 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jan 2022 11:59:56 +0800
Subject: [PATCH 1865/3374] Create
 5976-check-if-every-row-and-column-contains-all-numbers.js

---
 ...ery-row-and-column-contains-all-numbers.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 5976-check-if-every-row-and-column-contains-all-numbers.js

diff --git a/5976-check-if-every-row-and-column-contains-all-numbers.js b/5976-check-if-every-row-and-column-contains-all-numbers.js
new file mode 100644
index 00000000..fe00e653
--- /dev/null
+++ b/5976-check-if-every-row-and-column-contains-all-numbers.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} matrix
+ * @return {boolean}
+ */
+var checkValid = function(matrix) {
+  const n = matrix.length
+  let res = true
+  for(let i = 0; i < n; i++) {
+    if(!chkRow(i) || !chkCol(i)) {
+      res = false
+      break
+    }
+  }
+  
+  
+  return res
+  
+  function chkRow(i) {
+    const row = matrix[i], set = new Set()
+    for(let i = 0; i < n; i++) {
+      set.add(row[i])
+    }
+    return set.size === n
+  }
+  
+  function chkCol(j) {
+    const set = new Set()
+    for(let i = 0; i < n; i++) {
+      set.add(matrix[i][j])
+    }
+    
+    return set.size === n
+  }
+};

From 567ce7fa4dbe3e2eda999d659c9c6456b7d9c537 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jan 2022 09:59:24 +0800
Subject: [PATCH 1866/3374] Create
 2115-find-all-possible-recipes-from-given-supplies.js

---
 ...ll-possible-recipes-from-given-supplies.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2115-find-all-possible-recipes-from-given-supplies.js

diff --git a/2115-find-all-possible-recipes-from-given-supplies.js b/2115-find-all-possible-recipes-from-given-supplies.js
new file mode 100644
index 00000000..2704f0cd
--- /dev/null
+++ b/2115-find-all-possible-recipes-from-given-supplies.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string[]} recipes
+ * @param {string[][]} ingredients
+ * @param {string[]} supplies
+ * @return {string[]}
+ */
+const findAllRecipes = function(recipes, ingredients, supplies) {
+  const set = new Set(supplies), res = [], graph = {}, n = recipes.length
+  const inDegree = {}
+  for(let x of recipes) inDegree[x] = 0
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < ingredients[i].length; j++) {
+      const ing = ingredients[i][j]
+      if(!set.has(ing)) {
+        if (graph[ing] == null) graph[ing] = []
+        graph[ing].push(recipes[i])
+        inDegree[recipes[i]]++
+      }
+    }
+  }
+  // Kahn's Algorithm
+  const q = []
+  for(let x in inDegree) {
+    if (inDegree[x] === 0) q.push(x)
+  }
+  while(q.length) {
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const cur = q.pop()
+      res.push(cur)
+      for(let next of (graph[cur] || [])) {
+        inDegree[next]--
+        if(inDegree[next] === 0) {
+          q.push(next)
+        }
+      }
+    }
+  }
+  return res
+};

From 2a8c0177cea9eec674b222edeb52595c10cacd55 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Jan 2022 09:34:13 +0800
Subject: [PATCH 1867/3374] Update
 1963-minimum-number-of-swaps-to-make-the-string-balanced.js

---
 ...er-of-swaps-to-make-the-string-balanced.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/1963-minimum-number-of-swaps-to-make-the-string-balanced.js b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
index d54d75be..90a3793d 100644
--- a/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
+++ b/1963-minimum-number-of-swaps-to-make-the-string-balanced.js
@@ -1,3 +1,22 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minSwaps = function(s) {
+  const stk = []
+  for (let e of s) {
+    if(e === '[') stk.push(e)
+    else {
+      if(stk.length) {
+        stk.pop()
+      } else stk.push(e)
+    }
+  }
+  return Math.ceil(stk.length / 2)
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 38723abf8306694626e9233129261cbd8b493c9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Jan 2022 09:24:41 +0800
Subject: [PATCH 1868/3374] Update 301-remove-invalid-parentheses.js

---
 301-remove-invalid-parentheses.js | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/301-remove-invalid-parentheses.js b/301-remove-invalid-parentheses.js
index c587e840..9cb8bdde 100644
--- a/301-remove-invalid-parentheses.js
+++ b/301-remove-invalid-parentheses.js
@@ -1,3 +1,37 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+const removeInvalidParentheses = function(s) {
+  const res = []
+  helper(s, 0, 0, ['(', ')'])
+  return res
+
+  function helper(str, lastI, lastJ, pair) {
+    let openNum = 0, closeNum = 0
+    for(let i = lastI; i < str.length; i++) {
+      if(str[i] === pair[0]) openNum++
+      if(str[i] === pair[1]) closeNum++
+      if(closeNum > openNum) {
+        for(let j = lastJ; j <= i; j++) {
+          if(str[j] === pair[1] && (j === lastJ || str[j - 1] !== pair[1])) {
+            helper(str.slice(0, j) + str.slice(j + 1), i, j, pair)
+          }
+        }
+        return
+      }
+    }
+    let rev = str.split('').reverse().join('')
+    if(pair[0] === '(') {
+      helper(rev, 0, 0, [')', '('])
+    } else {
+      res.push(rev)
+    }
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {string[]}

From fcb3a022d812622502a67af5552fb0a14cc09b32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Jan 2022 08:59:23 +0800
Subject: [PATCH 1869/3374] Update
 1249-minimum-remove-to-make-valid-parentheses.js

---
 ...inimum-remove-to-make-valid-parentheses.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1249-minimum-remove-to-make-valid-parentheses.js b/1249-minimum-remove-to-make-valid-parentheses.js
index 8f6a909c..1599e395 100644
--- a/1249-minimum-remove-to-make-valid-parentheses.js
+++ b/1249-minimum-remove-to-make-valid-parentheses.js
@@ -49,3 +49,27 @@ const minRemoveToMakeValid = function(s) {
   }
   return res.join('')
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const minRemoveToMakeValid = function(s) {
+  const stk = [], arr = s.split(''), n = s.length
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '(') stk.push(i)
+    if(s[i] === ')') {
+      if(stk.length && stk[stk.length - 1] >= 0) stk.pop()
+      else stk.push(-(i + 1))
+    }
+  }
+  
+  while(stk.length) {
+    const tmp = stk.pop()
+    if(tmp < 0) arr[-tmp - 1] = ''
+    else arr[tmp] = ''
+  }
+  return arr.join('')
+};

From 903cc8d03e2b4db2a20b4e8dd0f175865083c325 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Jan 2022 19:10:48 +0800
Subject: [PATCH 1870/3374] Update
 1541-minimum-insertions-to-balance-a-parentheses-string.js

---
 ...ertions-to-balance-a-parentheses-string.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1541-minimum-insertions-to-balance-a-parentheses-string.js b/1541-minimum-insertions-to-balance-a-parentheses-string.js
index 30fa00fa..f9f78d74 100644
--- a/1541-minimum-insertions-to-balance-a-parentheses-string.js
+++ b/1541-minimum-insertions-to-balance-a-parentheses-string.js
@@ -1,3 +1,34 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minInsertions = function(s) {
+  let insert = 0, idx = 0, open = 0, len = s.length
+  while(idx < len) {
+    const ch = s[idx]
+    if(ch === '(') {
+      open++
+      idx++
+    } else {
+      if(open > 0) {
+        open--
+      } else {
+        insert++
+      }
+      if(idx < len - 1 && s[idx + 1] === ')') {
+        idx += 2
+      } else {
+        insert++
+        idx++
+      }
+    }
+  }
+  if(open) insert += open * 2
+  return insert
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 40f83763e1aedd23375b3ecf34c9a9c613c9c67f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jan 2022 17:20:16 +0800
Subject: [PATCH 1871/3374] Create
 2138-divide-a-string-into-groups-of-size-k.js

---
 2138-divide-a-string-into-groups-of-size-k.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2138-divide-a-string-into-groups-of-size-k.js

diff --git a/2138-divide-a-string-into-groups-of-size-k.js b/2138-divide-a-string-into-groups-of-size-k.js
new file mode 100644
index 00000000..1e532b80
--- /dev/null
+++ b/2138-divide-a-string-into-groups-of-size-k.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @param {character} fill
+ * @return {string[]}
+ */
+var divideString = function(s, k, fill) {
+  let res = [], tmp = ''
+  for(let i = 0, n = s.length; i < n; i++) {
+    tmp += s[i]
+    if(tmp.length === k) {
+      res.push(tmp)
+      tmp = ''
+    }
+  }
+  if(tmp.length) {
+    for(let i = 0, limit = k - tmp.length; i < limit; i++) {
+      tmp += fill
+    }
+    res.push(tmp)
+  }
+  return res
+};

From d7a3f0d48c5283fbb05042fb28d4077bf3ed5d0e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jan 2022 17:20:40 +0800
Subject: [PATCH 1872/3374] Create 2139-minimum-moves-to-reach-target-score.js

---
 2139-minimum-moves-to-reach-target-score.js | 28 +++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2139-minimum-moves-to-reach-target-score.js

diff --git a/2139-minimum-moves-to-reach-target-score.js b/2139-minimum-moves-to-reach-target-score.js
new file mode 100644
index 00000000..abbd61f9
--- /dev/null
+++ b/2139-minimum-moves-to-reach-target-score.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number} target
+ * @param {number} maxDoubles
+ * @return {number}
+ */
+const minMoves = function(target, maxDoubles) {
+        let count = 0;
+        
+        while(target != 1){
+            
+            if(target % 2 != 0){
+                target--;
+                count++;
+            }
+            else{
+                if(maxDoubles != 0){
+                    target /= 2;
+                    count++;
+                    maxDoubles--;
+                }
+                else{
+                    count += target - 1;
+                    break;
+                }
+            }
+        }
+        return count;
+};

From 1fb1cb2a59245efbb82183c198059131ba5dbc67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jan 2022 17:21:13 +0800
Subject: [PATCH 1873/3374] Create 2140-solving-questions-with-brainpower.js

---
 2140-solving-questions-with-brainpower.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2140-solving-questions-with-brainpower.js

diff --git a/2140-solving-questions-with-brainpower.js b/2140-solving-questions-with-brainpower.js
new file mode 100644
index 00000000..908ff28d
--- /dev/null
+++ b/2140-solving-questions-with-brainpower.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[][]} questions
+ * @return {number}
+ */
+var mostPoints = function (questions) {
+  let n = questions.length
+  const temp = Array(n).fill(0)
+
+  temp[n - 1] = questions[n - 1][0]
+
+  for (let i = n - 2; i >= 0; i--) {
+    if (i + questions[i][1] + 1 <= n - 1)
+      temp[i] = Math.max(
+        temp[i + 1],
+        questions[i][0] + temp[Math.min(n - 1, i + questions[i][1] + 1)]
+      )
+    else temp[i] = Math.max(temp[i + 1], questions[i][0])
+  }
+  return temp[0]
+}

From 031ed390443c935ea139388b5c0cde83abd28431 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jan 2022 17:21:45 +0800
Subject: [PATCH 1874/3374] Create 2141-maximum-running-time-of-n-computers.js

---
 2141-maximum-running-time-of-n-computers.js | 37 +++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2141-maximum-running-time-of-n-computers.js

diff --git a/2141-maximum-running-time-of-n-computers.js b/2141-maximum-running-time-of-n-computers.js
new file mode 100644
index 00000000..762b70b4
--- /dev/null
+++ b/2141-maximum-running-time-of-n-computers.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number} n
+ * @param {number[]} batteries
+ * @return {number}
+ */
+var maxRunTime = function (n, batteries) {
+  batteries.sort((a, b) => a - b)
+  const sum = batteries.reduce((ac, e) => ac + BigInt(e), 0n)
+  let hi = ~~(sum / BigInt(n)) + 1n,
+    lo = 0n
+  while (lo < hi) {
+    let mid = ~~((lo + hi) / 2n)
+    if (chk(mid)) {
+      lo = mid + 1n
+    } else {
+      hi = mid
+    }
+  }
+
+  return lo - 1n
+  function chk(x) {
+    let current = 0n
+    let i = 0n
+    for (let b of batteries) {
+      if (i == BigInt(n)) break
+      if (b > x) b = x
+      if (b >= x - current) {
+        i += 1n
+        current = BigInt(b) - (x - current)
+      } else {
+        current += BigInt(b)
+      }
+    }
+
+    return i == n
+  }
+}

From 4c49f6243772ea93bec0b41a2cc420dabf09d56a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jan 2022 20:37:55 +0800
Subject: [PATCH 1875/3374] Update 2140-solving-questions-with-brainpower.js

---
 2140-solving-questions-with-brainpower.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2140-solving-questions-with-brainpower.js b/2140-solving-questions-with-brainpower.js
index 908ff28d..c971f87e 100644
--- a/2140-solving-questions-with-brainpower.js
+++ b/2140-solving-questions-with-brainpower.js
@@ -2,7 +2,7 @@
  * @param {number[][]} questions
  * @return {number}
  */
-var mostPoints = function (questions) {
+const mostPoints = function (questions) {
   let n = questions.length
   const temp = Array(n).fill(0)
 
@@ -12,7 +12,7 @@ var mostPoints = function (questions) {
     if (i + questions[i][1] + 1 <= n - 1)
       temp[i] = Math.max(
         temp[i + 1],
-        questions[i][0] + temp[Math.min(n - 1, i + questions[i][1] + 1)]
+        questions[i][0] + temp[i + questions[i][1] + 1]
       )
     else temp[i] = Math.max(temp[i + 1], questions[i][0])
   }

From 5d1a83828bbc0828392ba309ba6b142eabdb7340 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Jan 2022 17:29:52 +0800
Subject: [PATCH 1876/3374] Create
 2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js

---
 ...ck-if-a-parentheses-string-can-be-valid.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js

diff --git a/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js b/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js
new file mode 100644
index 00000000..fb99fe6e
--- /dev/null
+++ b/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @param {string} locked
+ * @return {boolean}
+ */
+const canBeValid = function (s, locked) {
+  return s.length % 2 === 0 && chk(s, locked, '(') && chk(s, locked, ')')
+
+  function chk(s, locked, op) {
+    let bal = 0,
+      wild = 0,
+      sz = s.length
+    let start = op === '(' ? 0 : sz - 1,
+      dir = op === '(' ? 1 : -1
+    for (let i = start; i >= 0 && i < sz && wild + bal >= 0; i += dir) {
+      if (locked[i] === '1') bal += s[i] === op ? 1 : -1
+      else wild++
+    }
+    return Math.abs(bal) <= wild
+  }
+}

From 910792ac99d0b4bcd40ccbf0f7a20241c5d4d759 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Jan 2022 19:44:45 +0800
Subject: [PATCH 1877/3374] Update
 2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js

---
 ...ck-if-a-parentheses-string-can-be-valid.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js b/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js
index fb99fe6e..9c654fd1 100644
--- a/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js
+++ b/2116-check-if-a-parentheses-string-can-be-validcheck-if-a-parentheses-string-can-be-valid.js
@@ -1,3 +1,28 @@
+/**
+ * @param {string} s
+ * @param {string} locked
+ * @return {boolean}
+ */
+const canBeValid = function(s, locked) {
+  const n = s.length
+  if(n % 2 === 1) return false
+  let x = 0
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '(' || locked[i] === '0') x++
+    else if(x > 0) x--
+    else return false
+  }
+  x = 0
+  for(let i = n - 1; i >= 0; i--) {
+    if(s[i] === ')' || locked[i] === '0') x++
+    else if(x > 0) x--
+    else return false
+  }
+  return true
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string} locked

From b2273cc0d003e0debc4b20bd284fac61499a03a9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Jan 2022 09:09:35 +0800
Subject: [PATCH 1878/3374] Update 32-longest-valid-parentheses.js

---
 32-longest-valid-parentheses.js | 39 +++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/32-longest-valid-parentheses.js b/32-longest-valid-parentheses.js
index d96dceff..cd69003d 100644
--- a/32-longest-valid-parentheses.js
+++ b/32-longest-valid-parentheses.js
@@ -36,3 +36,42 @@ const longestValidParentheses = function(s) {
 
   return longest
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestValidParentheses = function (s) {
+  let res = 0,
+    stk = [],
+    n = s.length,
+    idxStk = []
+  for (let i = 0; i < n; i++) {
+    const ch = s[i]
+    if (stk.length && stk[stk.length - 1] === '(' && ch === ')')
+      stk.pop(), idxStk.pop()
+    else stk.push(ch), idxStk.push(i)
+    res = Math.max(res, i - (idxStk.length ? idxStk[idxStk.length - 1] : -1))
+  }
+  return res
+}
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestValidParentheses = function (s) {
+  let res = 0,
+    stk = [],
+    n = s.length,
+    idxStk = []
+  for (let i = 0; i < n; i++) {
+    const ch = s[i]
+    if (stk.length && stk[stk.length - 1] === '(' && ch === ')')
+      stk.pop(), idxStk.pop()
+    else stk.push(ch), idxStk.push(i)
+    res = Math.max(res, i - (idxStk.length ? idxStk[idxStk.length - 1] : -1))
+  }
+  return res
+}

From 695fae095a6837bcde1088562c12237dba77622f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Jan 2022 10:39:05 +0800
Subject: [PATCH 1879/3374] Update
 1685-sum-of-absolute-differences-in-a-sorted-array.js

---
 ...-sum-of-absolute-differences-in-a-sorted-array.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/1685-sum-of-absolute-differences-in-a-sorted-array.js b/1685-sum-of-absolute-differences-in-a-sorted-array.js
index 0092062e..c9893c3f 100644
--- a/1685-sum-of-absolute-differences-in-a-sorted-array.js
+++ b/1685-sum-of-absolute-differences-in-a-sorted-array.js
@@ -4,14 +4,14 @@
  */
 const getSumAbsoluteDifferences = function(nums) {
   const res = [], n = nums.length
-  let first = 0
-  for(let i = 1; i < n; i++) {
-    first += nums[i] - nums[0]
+  let sum = 0
+  for(let first = nums[0], i = 1; i < n; i++) {
+    sum += nums[i] - first
   }
-  res[0] = first
+  res[0] = sum
   for(let i = 1; i < n; i++) {
-    res[i] = res[i - 1] + (nums[i] - nums[i - 1]) * i - (nums[i] - nums[i - 1]) * (n - i)
+    res[i] = res[i - 1] - (nums[i] - nums[i - 1]) * (n - i - 1) + (nums[i] - nums[i - 1]) * (i - 1)
   }
-  
+
   return res
 };

From 78d3926f464b4313b9e7d5cc18ecf0e227601f7e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Jan 2022 09:29:21 +0800
Subject: [PATCH 1880/3374] Create 2121-intervals-between-identical-elements.js

---
 2121-intervals-between-identical-elements.js | 31 ++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2121-intervals-between-identical-elements.js

diff --git a/2121-intervals-between-identical-elements.js b/2121-intervals-between-identical-elements.js
new file mode 100644
index 00000000..2c99b424
--- /dev/null
+++ b/2121-intervals-between-identical-elements.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+const getDistances = function(arr) {
+  let n = arr.length
+  const pre = Array(n).fill(0), suf = Array(n).fill(0), res = Array(n).fill(0), mp = {}
+  
+  for(let i = 0; i < n; i++) {
+    if(mp[arr[i]] == null) mp[arr[i]] = []
+    mp[arr[i]].push(i)
+  }
+
+  Object.keys(mp).forEach(k => {
+    const idxArr = mp[k]
+    for(let i = 1; i < idxArr.length; i++) {
+      pre[idxArr[i]] = pre[idxArr[i - 1]] + i * (idxArr[i] - idxArr[i - 1])
+    }
+  })
+
+  Object.keys(mp).forEach(k => {
+    const idxArr = mp[k]
+    for(let i = idxArr.length - 2; i >= 0; i--) {
+      suf[idxArr[i]] = suf[idxArr[i + 1]] + (idxArr.length - 1 - i) * (idxArr[i + 1] - idxArr[i])
+    }
+  })
+
+  for(let i = 0; i < n; i++) res[i] = pre[i] + suf[i]
+
+  return res
+};

From 13ea9abe32545d3aec1d108cb9a2265ca70378ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Jan 2022 09:49:24 +0800
Subject: [PATCH 1881/3374] Create
 2007-find-original-array-from-doubled-array.js

---
 ...-find-original-array-from-doubled-array.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2007-find-original-array-from-doubled-array.js

diff --git a/2007-find-original-array-from-doubled-array.js b/2007-find-original-array-from-doubled-array.js
new file mode 100644
index 00000000..937249ae
--- /dev/null
+++ b/2007-find-original-array-from-doubled-array.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} changed
+ * @return {number[]}
+ */
+ const findOriginalArray = function(changed) {
+  const n = changed.length, res = []
+  if(n % 2 === 1 || n === 0) return res
+  const hash = {}
+  for(let e of changed) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  changed.sort((a, b) => a - b)
+
+  for(let i = 0, len = n; i < len; i++) {
+    const cur = changed[i], dVal = cur * 2
+    if (cur === 0 && hash[cur] % 2 === 1) continue
+    if(hash[dVal] && hash[cur]) {
+      res.push(cur)
+      hash[dVal]--
+      hash[cur]--
+    }
+  }
+  return res.length === n / 2 ? res : []
+};

From d66236711b007989e5ba262f16eee1b6354f625b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Jan 2022 10:58:00 +0800
Subject: [PATCH 1882/3374] Update
 2007-find-original-array-from-doubled-array.js

---
 ...-find-original-array-from-doubled-array.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2007-find-original-array-from-doubled-array.js b/2007-find-original-array-from-doubled-array.js
index 937249ae..89e270d2 100644
--- a/2007-find-original-array-from-doubled-array.js
+++ b/2007-find-original-array-from-doubled-array.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} changed
+ * @return {number[]}
+ */
+ const findOriginalArray = function(changed) {
+  const n = changed.length, res = [], { abs } = Math
+  if(n % 2 === 1 || n === 0) return res
+  const hash = {}
+  for(let e of changed) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const keys = Object.keys(hash)
+  keys.sort((a, b) => abs(a) - abs(b))
+
+  for(let k of keys) {
+    if(hash[k] > (hash[k * 2] || 0)) return []
+    for(let i = 0; i < hash[k]; i++) {
+      res.push(k)
+      hash[2 * k]--
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} changed
  * @return {number[]}

From d8873a6fcb1d1acd7300dd67147e8cd8a22fa63c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Jan 2022 17:32:18 +0800
Subject: [PATCH 1883/3374] Create 2122-recover-the-original-array.js

---
 2122-recover-the-original-array.js | 35 ++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2122-recover-the-original-array.js

diff --git a/2122-recover-the-original-array.js b/2122-recover-the-original-array.js
new file mode 100644
index 00000000..daa3a91e
--- /dev/null
+++ b/2122-recover-the-original-array.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const recoverArray = function(nums) {
+  const n = nums.length, cnt = calcHash(nums)
+  nums.sort((a, b) => a - b)
+  for(let i = 1; i < n; i++) {
+    const tk = nums[i] - nums[0]
+    if(tk === 0 || tk % 2 === 1) continue
+    const [valid, res] = helper(tk)
+    if(valid) return res
+  }
+  
+  function helper(tk) {
+    const res = [], hash = Object.assign({}, cnt)
+    for(let i = 0; i < n; i++) {
+      const cur = nums[i]
+      if(hash[cur] === 0) continue
+      if(hash[cur + tk] === 0 || hash[cur + tk] == null) return [false]
+      hash[cur]--
+      hash[cur + tk]--
+      res.push(cur + tk / 2)
+    }
+    return [true, res]
+  }
+  function calcHash(arr) {
+    const hash = {}
+    for(let e of arr) {
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+    }
+    return hash
+  }
+};

From ebe45ffd0852a0c5a2ab46046eacf81b8c267db2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jan 2022 12:01:09 +0800
Subject: [PATCH 1884/3374] Create
 2148-count-elements-with-strictly-smaller-and-greater-elements.js

---
 ...with-strictly-smaller-and-greater-elements.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2148-count-elements-with-strictly-smaller-and-greater-elements.js

diff --git a/2148-count-elements-with-strictly-smaller-and-greater-elements.js b/2148-count-elements-with-strictly-smaller-and-greater-elements.js
new file mode 100644
index 00000000..739a4604
--- /dev/null
+++ b/2148-count-elements-with-strictly-smaller-and-greater-elements.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var countElements = function(nums) {
+  let min = Infinity, max = -Infinity
+  for(let e of nums) {
+    if(e > max) max = e
+    if(e < min) min = e
+  }
+  let res = 0
+  for(let e of nums) {
+    if(e > min && e < max) res++
+  }
+  return res
+};

From e2d30a3864b16ddd55e0a080c6918efeb5e0136b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jan 2022 12:01:37 +0800
Subject: [PATCH 1885/3374] Create 2149-rearrange-array-elements-by-sign.js

---
 2149-rearrange-array-elements-by-sign.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2149-rearrange-array-elements-by-sign.js

diff --git a/2149-rearrange-array-elements-by-sign.js b/2149-rearrange-array-elements-by-sign.js
new file mode 100644
index 00000000..9f4f1d71
--- /dev/null
+++ b/2149-rearrange-array-elements-by-sign.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const rearrangeArray = function(nums) {
+  const pos = [], neg = []
+  for(let e of nums) {
+    if(e >= 0) pos.push(e)
+    else neg.push(e)
+  }
+  const res = []
+  for(let i = 0; i < nums.length; i++) {
+    if(i % 2 === 0) res.push(pos[~~(i / 2)])
+    else res.push(neg[~~(i / 2)])
+  }
+  return res
+};

From aaf409b9e218e1a4e409207d1efdefb364590ca8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jan 2022 12:02:03 +0800
Subject: [PATCH 1886/3374] Create 2150-find-all-lonely-numbers-in-the-array.js

---
 2150-find-all-lonely-numbers-in-the-array.js | 31 ++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2150-find-all-lonely-numbers-in-the-array.js

diff --git a/2150-find-all-lonely-numbers-in-the-array.js b/2150-find-all-lonely-numbers-in-the-array.js
new file mode 100644
index 00000000..ee604c44
--- /dev/null
+++ b/2150-find-all-lonely-numbers-in-the-array.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var findLonely = function(nums) {
+  nums.sort((a, b) => a - b)
+  const cnt = {}
+  for(let e of nums) {
+    if(cnt[e] == null) cnt[e] = 0
+    cnt[e]++
+  }
+  // console.log(cnt)
+  const res = []
+  for(let i = 0, n = nums.length; i < n; i++) {
+    if(i === 0){
+      if(nums[i + 1] !== nums[i] + 1 && cnt[nums[i]] === 1) {
+        res.push(nums[i])  
+      }
+    } 
+    else if(i === n - 1 ) {
+      if(nums[i] !== nums[i - 1] + 1 && cnt[nums[i]] === 1) {
+        res.push(nums[i])
+      }
+    }
+    else if(cnt[nums[i]] === 1 && nums[i] !== nums[i - 1] + 1 && nums[i] !== nums[i + 1] - 1) {
+      res.push(nums[i])
+    }
+  }
+  
+  return res
+};

From aa061d40984de1194a433002411b7527aa546a34 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jan 2022 12:02:48 +0800
Subject: [PATCH 1887/3374] Create
 2151-maximum-good-people-based-on-statements.js

---
 ...maximum-good-people-based-on-statements.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2151-maximum-good-people-based-on-statements.js

diff --git a/2151-maximum-good-people-based-on-statements.js b/2151-maximum-good-people-based-on-statements.js
new file mode 100644
index 00000000..37bc7de5
--- /dev/null
+++ b/2151-maximum-good-people-based-on-statements.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} statements
+ * @return {number}
+ */
+const maximumGood = function (statements) {
+  const n = statements.length
+  let res = 0,
+    c = (1 << n) - 1
+  for (let i = 0; i < c + 1; i++) {
+    let s = dec2bin(i)
+    s = '0'.repeat(n - s.length) + s
+    let arr = [],
+      f = 1
+    for (let i = 0; i < n; i++) {
+      if (s[i] === '1') arr.push(i)
+    }
+    for (let i of arr) {
+      for (let j = 0; j < n; j++) {
+        if (statements[i][j] !== 2 && statements[i][j] !== +s[j]) {
+          f = 0
+          break
+        }
+      }
+      if (!f) break
+    }
+    if (f) res = Math.max(res, cnt(s, '1'))
+  }
+
+  return res
+}
+function cnt(s, ch) {
+  let res = 0
+  for (let e of s) {
+    if (e === ch) res++
+  }
+  return res
+}
+function dec2bin(dec) {
+  return (dec >>> 0).toString(2)
+}

From c36c73d2744b05c9a0c591adcdabca95316bd2ab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jan 2022 20:14:25 +0800
Subject: [PATCH 1888/3374] Update 1982-find-array-given-subset-sums.js

---
 1982-find-array-given-subset-sums.js | 43 ++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1982-find-array-given-subset-sums.js b/1982-find-array-given-subset-sums.js
index e9c93661..ca16e18a 100644
--- a/1982-find-array-given-subset-sums.js
+++ b/1982-find-array-given-subset-sums.js
@@ -89,3 +89,46 @@ function bs(arr, val) {
   return arr[l] === val
 }
 
+// another
+
+/**
+ * @param {number} n
+ * @param {number[]} sums
+ * @return {number[]}
+ */
+const recoverArray = function(n, sums) {
+  const res = []
+  sums.sort((a, b) => a - b)
+  
+  while(res.length < n) {
+    const m = sums.length, visited = Array(m).fill(false)
+    let a1 = [], a2 = [], delta = sums[1] - sums[0]
+    for(let i = 0, j = 1; i < m && j < m; i++, j++) {
+      while(i < m && visited[i]) i++
+      if(i === m) break
+      while(i >= j || sums[j] !== sums[i] + delta) j++
+      if(j === m) break
+      a1.push(sums[i])
+      a2.push(sums[j])
+      visited[i] = visited[j] = true
+    }
+    if(binarySearch(a1, 0)) {
+      sums = a1
+      res.push(delta)
+    } else {
+      sums = a2
+      res.push(-delta)
+    }
+  }
+  return res
+  
+  function binarySearch(arr, val) {
+    let l = 0, r = arr.length - 1
+    while(l < r) {
+      const mid = ~~((l + r) / 2)
+      if(arr[mid] < val) l = mid + 1
+      else r = mid
+    }
+    return arr[l] === val
+  }
+};

From 590f5ee5d699ee5226e82495d0ae2bda12fda4b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Jan 2022 10:49:53 +0800
Subject: [PATCH 1889/3374] Update
 1605-find-valid-matrix-given-row-and-column-sums.js

---
 ...-valid-matrix-given-row-and-column-sums.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1605-find-valid-matrix-given-row-and-column-sums.js b/1605-find-valid-matrix-given-row-and-column-sums.js
index 2aff69a5..f1ab5894 100644
--- a/1605-find-valid-matrix-given-row-and-column-sums.js
+++ b/1605-find-valid-matrix-given-row-and-column-sums.js
@@ -15,3 +15,23 @@ const restoreMatrix = function(rowSum, colSum) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number[]} rowSum
+ * @param {number[]} colSum
+ * @return {number[][]}
+ */
+const restoreMatrix = function(rowSum, colSum) {
+  const m = rowSum.length, n = colSum.length
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      res[i][j] = Math.min(rowSum[i], colSum[j])
+      rowSum[i] -= res[i][j]
+      colSum[j] -= res[i][j]
+    }
+  }
+  return res
+};

From 6dfca51b4ec766023f9785329a8a0b8f479a145d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Jan 2022 11:40:35 +0800
Subject: [PATCH 1890/3374] Create 1408-string-matching-in-an-array.js

---
 1408-string-matching-in-an-array.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1408-string-matching-in-an-array.js

diff --git a/1408-string-matching-in-an-array.js b/1408-string-matching-in-an-array.js
new file mode 100644
index 00000000..17175b3b
--- /dev/null
+++ b/1408-string-matching-in-an-array.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+const stringMatching = function(words) {
+  const res = [], n = words.length
+  for(let i = 0; i < n; i++) {
+    const cur = words[i]
+    for(let j = 0; j < n; j++) {
+      if(i !== j && words[j].indexOf(cur) !== -1) {
+        res.push(cur); 
+        break
+      }
+    }
+  }
+  return res
+};

From 22336944014c6e259b032cdf83a66e2e93dbabc0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Jan 2022 12:01:55 +0800
Subject: [PATCH 1891/3374] Create 1446-consecutive-characters.js

---
 1446-consecutive-characters.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1446-consecutive-characters.js

diff --git a/1446-consecutive-characters.js b/1446-consecutive-characters.js
new file mode 100644
index 00000000..6ef92188
--- /dev/null
+++ b/1446-consecutive-characters.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxPower = function(s) {
+  let prev = '', prevIdx = -1, res = -Infinity
+  for(let i = 0; i < s.length; i++) {
+    const cur = s[i]
+    if(cur !== prev) {
+      res = Math.max(res, i - prevIdx)
+      prev = cur
+      prevIdx = i
+    } else {
+      if(i === s.length - 1) res = Math.max(res, i - prevIdx + 1)
+    }
+  }
+  return res
+};

From db6919b54e1d00cf1ee55a810010a877e0dc3de3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Jan 2022 12:08:07 +0800
Subject: [PATCH 1892/3374] Update 1446-consecutive-characters.js

---
 1446-consecutive-characters.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1446-consecutive-characters.js b/1446-consecutive-characters.js
index 6ef92188..a8e49a47 100644
--- a/1446-consecutive-characters.js
+++ b/1446-consecutive-characters.js
@@ -1,3 +1,21 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxPower = function(s) {
+  let res = 1, cnt = 1
+  for(let i = 1; i < s.length; i++) {
+    if(s[i] === s[i - 1]) {
+      if(++cnt > res) res = cnt
+    } else {
+      cnt = 1
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 6736241e8a3c232181c14e5fef94b5d9496db109 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Jan 2022 09:26:51 +0800
Subject: [PATCH 1893/3374] Update 588-design-in-memory-file-system.js

---
 588-design-in-memory-file-system.js | 74 +++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/588-design-in-memory-file-system.js b/588-design-in-memory-file-system.js
index 61695f2c..e23ea7dd 100644
--- a/588-design-in-memory-file-system.js
+++ b/588-design-in-memory-file-system.js
@@ -73,3 +73,77 @@ FileSystem.prototype.readContentFromFile = function (filePath) {
  * obj.addContentToFile(filePath,content)
  * var param_4 = obj.readContentFromFile(filePath)
  */
+
+// another
+
+const FileSystem = function () {
+  this.root = new Node()
+}
+
+/**
+ * @param {string} path
+ * @return {string[]}
+ */
+FileSystem.prototype.ls = function (path) {
+  const cur = this.find(path)
+  if(cur.content) {
+    const arr = path.split('/')
+    return [arr[arr.length - 1]]
+  }
+  return Object.keys(cur.children).sort()
+}
+
+/**
+ * @param {string} path
+ * @return {void}
+ */
+FileSystem.prototype.mkdir = function (path) {
+  this.find(path)
+}
+
+/**
+ * @param {string} filePath
+ * @param {string} content
+ * @return {void}
+ */
+FileSystem.prototype.addContentToFile = function (filePath, content) {
+  const cur = this.find(filePath)
+  cur.content += content
+}
+
+/**
+ * @param {string} filePath
+ * @return {string}
+ */
+FileSystem.prototype.readContentFromFile = function (filePath) {
+  const cur = this.find(filePath)
+  return cur.content
+}
+
+FileSystem.prototype.find = function (filePath) {
+  if(filePath.length === 1) return this.root
+  const arr = filePath.split('/').slice(1)
+  let cur = this.root
+  for(let e of arr) {
+    if (cur.children[e] == null) cur.children[e] = new Node()
+    cur = cur.children[e]
+  }
+  return cur
+}
+
+/**
+ * Your FileSystem object will be instantiated and called as such:
+ * var obj = new FileSystem()
+ * var param_1 = obj.ls(path)
+ * obj.mkdir(path)
+ * obj.addContentToFile(filePath,content)
+ * var param_4 = obj.readContentFromFile(filePath)
+ */
+
+class Node {
+  constructor() {
+    this.children = {}
+    this.content = ''
+  }
+}
+

From 28ecad193e9488dfb22cc5bf5b3a3d5f6988b52f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Jan 2022 13:38:53 +0800
Subject: [PATCH 1894/3374] Update
 1857-largest-color-value-in-a-directed-graph.js

---
 ...largest-color-value-in-a-directed-graph.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index be5c8ba3..3432baae 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string} colors
+ * @param {number[][]} edges
+ * @return {number}
+ */
+ const largestPathValue = function(colors, edges) {
+  const graph = {}, n = colors.length, a = 'a'.charCodeAt(0)
+  const indegree = Array(n).fill(0)
+  for (const [from, to] of edges) {
+    if (graph[from] == null) graph[from] = []
+    graph[from].push(to)
+    indegree[to]++
+  }
+  const cnt = Array.from({ length: n }, () => Array(26).fill(0))
+  const code = idx => colors.charCodeAt(idx) - a
+  const q = []
+  for (let i = 0; i < n; i++) {
+    if(indegree[i] === 0) {
+      q.push(i)
+      cnt[i][code(i)] = 1
+    }
+  }
+  let res = 0, seen = 0
+
+  while(q.length) {
+    const u = q.pop()
+    const val = cnt[u][code(u)]
+    res = Math.max(res, val)
+    seen++
+    for(const next of (graph[u] || [])) {
+      for(let i = 0; i < 26; i++) {
+        cnt[next][i] = Math.max(cnt[next][i], cnt[u][i] + (i === code(next) ? 1 : 0))
+      }
+      if(--indegree[next] === 0) {
+        q.push(next)
+      }
+    }
+  }
+  return seen < n ? -1 : res
+};
+
+// another
+
+
 /**
  * @param {string} colors
  * @param {number[][]} edges

From b3694be4df7fd5e2e3cdd768b3eaa558149f9ebc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Jan 2022 11:43:53 +0800
Subject: [PATCH 1895/3374] Update 802-find-eventual-safe-states.js

---
 802-find-eventual-safe-states.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/802-find-eventual-safe-states.js b/802-find-eventual-safe-states.js
index 44a5d8b4..d55d224e 100644
--- a/802-find-eventual-safe-states.js
+++ b/802-find-eventual-safe-states.js
@@ -24,3 +24,30 @@ function dfs(graph, node, memo, visited) {
   memo[node] = hasCycle
   return hasCycle
 }
+
+// another
+
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+const eventualSafeNodes = function(graph) {
+  const res = []
+  if(graph == null || graph.length === 0) return res
+  const n = graph.length
+  const color = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    if(bt(graph, i, color)) res.push(i)
+  }
+  return res
+
+  function bt(graph, start, color) {
+    if(color[start] !== 0) return color[start] === 1
+    color[start] = 2
+    for(let next of graph[start]) {
+      if(!bt(graph, next, color)) return false
+    }
+    color[start] = 1
+    return true
+  }
+};

From bd640742bf759bb97aee13d73652c5cdb7ec6488 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 Jan 2022 22:05:26 +0800
Subject: [PATCH 1896/3374] Update 1591-strange-printer-ii.js

---
 1591-strange-printer-ii.js | 76 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/1591-strange-printer-ii.js b/1591-strange-printer-ii.js
index 5e9be1d4..4dd5b521 100644
--- a/1591-strange-printer-ii.js
+++ b/1591-strange-printer-ii.js
@@ -49,3 +49,79 @@ const isPrintable = function (targetGrid) {
     return true
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} targetGrid
+ * @return {boolean}
+ */
+const isPrintable = function (targetGrid) {
+  /*
+     1 -> 3
+     1 -> 4
+     1 -> 5
+     3 -> 4
+    */
+
+  const dependencies = {}
+
+  /*
+    3: [mini, maxi, minj, maxj]
+    */
+  const extents = {}
+
+  for (let i = 0; i < targetGrid.length; i++) {
+    for (let j = 0; j < targetGrid[i].length; j++) {
+      const n = targetGrid[i][j]
+      let inf = Infinity
+      extents[n] = extents[n] || {
+        n,
+        mini: inf,
+        minj: inf,
+        maxi: -inf,
+        maxj: -inf,
+      }
+      extents[n].mini = Math.min(i, extents[n].mini)
+      extents[n].minj = Math.min(j, extents[n].minj)
+      extents[n].maxi = Math.max(i, extents[n].maxi)
+      extents[n].maxj = Math.max(j, extents[n].maxj)
+    }
+  }
+
+  function canRemove(obj) {
+    for (let i = obj.mini; i <= obj.maxi; i++) {
+      for (let j = obj.minj; j <= obj.maxj; j++) {
+        const val = targetGrid[i][j]
+        if (val !== null && val !== obj.n) return false
+      }
+    }
+    return true
+  }
+
+  function remove(obj) {
+    for (let i = obj.mini; i <= obj.maxi; i++) {
+      for (let j = obj.minj; j <= obj.maxj; j++) {
+        targetGrid[i][j] = null
+      }
+    }
+    delete extents[obj.n]
+  }
+
+  while (Object.keys(extents).length > 0) {
+    let found = false
+    for (const n in extents) {
+      const obj = extents[n]
+      if (canRemove(obj)) {
+        remove(obj)
+        found = true
+        break
+      }
+    }
+    if (!found) {
+      return false
+    }
+  }
+  return true
+}
+

From a102910ac50ccaa8cbcfb473f01742ef299fbdcc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Jan 2022 10:59:54 +0800
Subject: [PATCH 1897/3374] Update 310-minimum-height-trees.js

---
 310-minimum-height-trees.js | 38 +++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/310-minimum-height-trees.js b/310-minimum-height-trees.js
index 98e754ee..2a49c6ff 100644
--- a/310-minimum-height-trees.js
+++ b/310-minimum-height-trees.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+ const findMinHeightTrees = function(n, edges) {
+  if(n === 1) return [0]
+  const res = [], graph = {}
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = new Set()
+    if(graph[v] == null) graph[v] = new Set()
+    graph[u].add(v)
+    graph[v].add(u)
+  }
+
+  let leaves = []
+  Object.keys(graph).forEach(k => {
+    if(graph[k].size === 1) leaves.push(+k)
+  })
+  while(n > 2) {
+    const newLeaves = []
+    const size = leaves.length
+    for (let i = 0; i < size; i++) {
+      const cur = leaves.pop()
+      for (const next of graph[cur]) {
+        graph[next].delete(cur)
+        if(graph[next].size === 1) newLeaves.push(next)
+      }
+    }
+    n -= size
+    leaves = newLeaves
+  }
+  
+  return leaves
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 66a8fa90369a3728b4b86eed2d91a3c237d9debb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jan 2022 12:16:20 +0800
Subject: [PATCH 1898/3374] Create 2154-keep-multiplying-found-values-by-two.js

---
 2154-keep-multiplying-found-values-by-two.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2154-keep-multiplying-found-values-by-two.js

diff --git a/2154-keep-multiplying-found-values-by-two.js b/2154-keep-multiplying-found-values-by-two.js
new file mode 100644
index 00000000..398ea7f1
--- /dev/null
+++ b/2154-keep-multiplying-found-values-by-two.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @param {number} original
+ * @return {number}
+ */
+var findFinalValue = function(nums, original) {
+    let res = original
+    while(nums.indexOf(res) !== -1) {
+      // const idx = nums.indexOf(res)
+      res *= 2
+    }
+    return res
+};

From b463e80958f3d84de07536dcfd580f92913548b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jan 2022 12:16:50 +0800
Subject: [PATCH 1899/3374] Create
 2155-all-divisions-with-the-highest-score-of-a-binary-array.js

---
 ...ith-the-highest-score-of-a-binary-array.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2155-all-divisions-with-the-highest-score-of-a-binary-array.js

diff --git a/2155-all-divisions-with-the-highest-score-of-a-binary-array.js b/2155-all-divisions-with-the-highest-score-of-a-binary-array.js
new file mode 100644
index 00000000..adf57c4a
--- /dev/null
+++ b/2155-all-divisions-with-the-highest-score-of-a-binary-array.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var maxScoreIndices = function(nums) {
+  const n = nums.length
+  // if(n === 1) return [0]
+  const leftZero = Array(n).fill(0), rightOne = Array(n).fill(0)
+  for (let i = 0, sum = 0; i < n; i++) {
+    if(nums[i] === 0) sum++
+    leftZero[i] = sum
+  }
+  for (let i = n - 1, sum = 0; i >= 0; i--) {
+    if(nums[i] === 1) sum++
+    rightOne[i] = sum
+  }
+  let hash = {}
+  for (let i = 0, sum = 0; i <= n; i++) {
+    
+    hash[i] = (i === 0 ? 0 : leftZero[i - 1]) + (i === n ? 0 : rightOne[i])
+  }
+  const max = Math.max(...Object.values(hash))
+  const res = []
+  Object.keys(hash).forEach(k => {
+    if(hash[k] === max) res.push(+k)
+  })
+  return res
+};

From d238c5b7bd44c752040d30c2638817dca1309767 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jan 2022 12:33:27 +0800
Subject: [PATCH 1900/3374] Create 2156-find-substring-with-given-hash-value.js

---
 2156-find-substring-with-given-hash-value.js | 30 ++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2156-find-substring-with-given-hash-value.js

diff --git a/2156-find-substring-with-given-hash-value.js b/2156-find-substring-with-given-hash-value.js
new file mode 100644
index 00000000..0549a3b3
--- /dev/null
+++ b/2156-find-substring-with-given-hash-value.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} s
+ * @param {number} power
+ * @param {number} modulo
+ * @param {number} k
+ * @param {number} hashValue
+ * @return {string}
+ */
+var subStrHash = function (s, power, modulo, k, hashValue) {
+  let n = s.length;
+  const p_pow = Array(n + 1);
+  p_pow[0] = 1n;
+  power = BigInt(power);
+  let m = BigInt(modulo);
+  for (let i = 1; i < p_pow.length; i++) p_pow[i] = (p_pow[i - 1] * power) % m;
+
+  const val = (ch) => BigInt(ch.charCodeAt(0) - "a".charCodeAt(0));
+  const h = Array(n + 1).fill(0n);
+  for (let i = n - 1; i >= 0; i--)
+    h[i] = (h[i + 1] * power + val(s[i]) + 1n) % m;
+
+  for (let i = 0; i + k - 1 < n; i++) {
+    let cur_h = (h[i] - h[i + k] * p_pow[k]) % m;
+    let temp = (cur_h + m) % m;
+    if (temp == hashValue) {
+      return s.substr(i, k);
+    }
+  }
+  return "";
+};

From be895f6d84227fb4e7e90bfb1083250b6c0bc983 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Feb 2022 23:47:09 +0800
Subject: [PATCH 1901/3374] Update and rename
 5979-earliest-possible-day-of-full-bloom.js to
 2136-earliest-possible-day-of-full-bloom.js

---
 2136-earliest-possible-day-of-full-bloom.js | 36 +++++++++++++++++++++
 5979-earliest-possible-day-of-full-bloom.js | 36 ---------------------
 2 files changed, 36 insertions(+), 36 deletions(-)
 create mode 100644 2136-earliest-possible-day-of-full-bloom.js
 delete mode 100644 5979-earliest-possible-day-of-full-bloom.js

diff --git a/2136-earliest-possible-day-of-full-bloom.js b/2136-earliest-possible-day-of-full-bloom.js
new file mode 100644
index 00000000..8e118f06
--- /dev/null
+++ b/2136-earliest-possible-day-of-full-bloom.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} plantTime
+ * @param {number[]} growTime
+ * @return {number}
+ */
+const earliestFullBloom = function(plantTime, growTime) {
+  const sum = arr => arr.reduce((ac, e) => ac +e, 0)
+  let l = 0, r = sum(plantTime) + sum(growTime)
+  const n = plantTime.length
+
+  const a = []
+  for(let i = 0; i < n; i++) {
+    a.push([growTime[i], plantTime[i] ])
+  }
+
+  a.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  a.reverse()
+  function chk(d) {
+    let total = -1
+    let max_num = 0
+    for(let i = 0; i < n; i++) {
+      total += a[i][1]
+      max_num = Math.max(max_num, total + a[i][0] + 1)
+    }
+    return max_num <= d
+  }
+
+  while (l < r) {
+    let m = ~~((l + r) / 2)
+    if (chk(m)) r = m
+    else l = m + 1          
+  }
+
+  return l
+};
+
diff --git a/5979-earliest-possible-day-of-full-bloom.js b/5979-earliest-possible-day-of-full-bloom.js
deleted file mode 100644
index 54a811b2..00000000
--- a/5979-earliest-possible-day-of-full-bloom.js
+++ /dev/null
@@ -1,36 +0,0 @@
-/**
- * @param {number[]} plantTime
- * @param {number[]} growTime
- * @return {number}
- */
-var earliestFullBloom = function(plantTime, growTime) {
-      const sum = arr => arr.reduce((ac, e) => ac +e, 0)
-      let l = 0, r = sum(plantTime) + sum(growTime)
-      let n = plantTime.length
-
-      let a = []
-      for(let i = 0; i < n; i++) {
-        a.push([growTime[i], plantTime[i] ])
-      }
-
-      a.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
-      a.reverse()
-      function chk(d) {
-          let total = -1
-          let max_num = 0
-          for(let i = 0; i < n; i++) {
-             total += a[i][1]
-              max_num = Math.max(max_num, total + a[i][0] + 1)
-          }
-          return max_num <= d
-      }
-
-      while (l < r) {
-          let m = ~~((l + r) / 2)
-          if (chk(m)) r = m
-          else l = m + 1          
-      }
-
-      return l
-};
-

From 1f8cc21be613193c5822dbfb52c2085de861c4da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Feb 2022 00:19:38 +0800
Subject: [PATCH 1902/3374] Update 2136-earliest-possible-day-of-full-bloom.js

---
 2136-earliest-possible-day-of-full-bloom.js | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2136-earliest-possible-day-of-full-bloom.js b/2136-earliest-possible-day-of-full-bloom.js
index 8e118f06..6a736966 100644
--- a/2136-earliest-possible-day-of-full-bloom.js
+++ b/2136-earliest-possible-day-of-full-bloom.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} plantTime
+ * @param {number[]} growTime
+ * @return {number}
+ */
+const earliestFullBloom = function(plantTime, growTime) {
+  const n = plantTime.length, arr = Array(n)
+  for(let i = 0; i < n; i++) {
+    arr.push([growTime[i], plantTime[i]])
+  }
+  arr.sort((a, b) => b[0] - a[0])
+  
+  let res = 0, cur = 0
+  for(let i = 0; i < n; i++) {
+    const e = arr[i]
+    res = Math.max(res, cur + e[0] + e[1])
+    cur += e[1]
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} plantTime
  * @param {number[]} growTime

From 64d812d1ea884363f57abcd6b1aed2ebe95d7c43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Feb 2022 00:57:50 +0800
Subject: [PATCH 1903/3374] Update 630-course-schedule-iii.js

---
 630-course-schedule-iii.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/630-course-schedule-iii.js b/630-course-schedule-iii.js
index 824fca51..f9558beb 100644
--- a/630-course-schedule-iii.js
+++ b/630-course-schedule-iii.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} courses
+ * @return {number}
+ */
+const scheduleCourse = function (courses) {
+  const queue = new MaxPriorityQueue({
+    priority: e => e[0]
+  })
+  courses.sort((a, b) => a[1] - b[1])
+  let time = 0
+  for(let e of courses) {
+    time += e[0]
+    queue.enqueue(e)
+    if(time > e[1]) {
+      const tmp = queue.dequeue().element
+      time -= tmp[0]
+    }
+  }
+  return queue.size()
+}
+
+// another
+
 /**
  * @param {number[][]} courses
  * @return {number}

From 77fabe3411e75aec15fe424b27e666e39240abe5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Feb 2022 11:02:25 +0800
Subject: [PATCH 1904/3374] Create 2132-stamping-the-grid.js

---
 2132-stamping-the-grid.js | 59 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 2132-stamping-the-grid.js

diff --git a/2132-stamping-the-grid.js b/2132-stamping-the-grid.js
new file mode 100644
index 00000000..e3e936e4
--- /dev/null
+++ b/2132-stamping-the-grid.js
@@ -0,0 +1,59 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} stampHeight
+ * @param {number} stampWidth
+ * @return {boolean}
+ */
+var possibleToStamp = function(grid, stampHeight, stampWidth) {
+    let d = [];
+    let a = grid;
+    let h = grid.length;
+    let w = grid[0].length;
+    for (let i = 0; i <= h; i++) {
+        d[i] = new Array(w + 1).fill(0);
+    }
+    //d - height of empty cells below
+    for (let i = h - 1; i >= 0; i--) {
+        for (let j = 0; j < w; j++) {
+            if (a[i][j] === 0) d[i][j] = d[i + 1][j] + 1;
+        }
+    }
+    //find stamps, and start to fill matrix
+    for (let i = 0; i < h; i++) {
+        let columns = 0; //width of consecutive empty columns with height>=stampHeight
+        for (let j = 0; j <= w; j++) {
+            if (d[i][j] >= stampHeight) { //column can be part of stamp
+                columns++;
+                if (columns >= stampWidth) {
+                    //fill first row
+                    if (columns === stampWidth) {
+                        //fill previous columns
+                        for (let l = j - stampWidth + 1; l <= j; l++) {
+                            a[i][l] = stampHeight
+                        }
+                    } else {
+                        a[i][j] = stampHeight;
+                    }
+                }
+            } else {
+                columns = 0;
+            }
+        }
+        //fill cells below
+        for (let l = 0; l < w; l++) {
+            if (a[i][l] > 1) {
+                a[i + 1][l] = a[i][l] - 1;
+            }
+        }
+    }
+
+    //check if all cells covered
+    let ans = true;
+    for (let i = 0; i < h; i++) {
+        for (let j = 0; j < w; j++) {
+            if (a[i][j] === 0) ans = false;
+        }
+    }
+
+    return ans;  
+};

From 07d3cf9cd9b39c9b35cfd1f939526cd026d8e27b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 4 Feb 2022 19:09:05 +0800
Subject: [PATCH 1905/3374] Update 304-range-sum-query-2d-immutable.js

---
 304-range-sum-query-2d-immutable.js | 34 +++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/304-range-sum-query-2d-immutable.js b/304-range-sum-query-2d-immutable.js
index 9613134f..8333a777 100644
--- a/304-range-sum-query-2d-immutable.js
+++ b/304-range-sum-query-2d-immutable.js
@@ -40,3 +40,37 @@ NumMatrix.prototype.sumRegion = function(row1, col1, row2, col2) {
  * var obj = Object.create(NumMatrix).createNew(matrix)
  * var param_1 = obj.sumRegion(row1,col1,row2,col2)
  */
+
+// another
+
+/**
+ * @param {number[][]} matrix
+ */
+const NumMatrix = function(matrix) {
+  const m = matrix.length, n = matrix[0].length
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  for(let i = 1; i <= m; i++) {
+    for(let j = 1; j <= n; j++) {
+      dp[i][j] = dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - 1] + matrix[i - 1][j - 1]
+    }
+  }
+  this.dp = dp
+};
+
+/** 
+ * @param {number} row1 
+ * @param {number} col1 
+ * @param {number} row2 
+ * @param {number} col2
+ * @return {number}
+ */
+NumMatrix.prototype.sumRegion = function(row1, col1, row2, col2) {
+  const dp = this.dp
+  return dp[row2 + 1][col2 + 1] - dp[row2 + 1][col1] - dp[row1][col2 + 1] + dp[row1][col1]
+};
+
+/** 
+ * Your NumMatrix object will be instantiated and called as such:
+ * var obj = new NumMatrix(matrix)
+ * var param_1 = obj.sumRegion(row1,col1,row2,col2)
+ */

From eea1d9650bdc4a51ddda4a080e03d125d4eb6a7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Feb 2022 12:12:40 +0800
Subject: [PATCH 1906/3374] Create
 2164-sort-even-and-odd-indices-independently.js

---
 ...sort-even-and-odd-indices-independently.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2164-sort-even-and-odd-indices-independently.js

diff --git a/2164-sort-even-and-odd-indices-independently.js b/2164-sort-even-and-odd-indices-independently.js
new file mode 100644
index 00000000..b57971c9
--- /dev/null
+++ b/2164-sort-even-and-odd-indices-independently.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var sortEvenOdd = function(nums) {
+        let nums_size = nums.length;
+        for (let i = 0; i < nums_size - 2; i++) {
+            for (let j = i + 2; j < nums_size; j += 2) {
+                if (i % 2 == 1) {
+                    if (nums[i] < nums[j]) {
+                        let temp = nums[i];
+                        nums[i] = nums[j];
+                        nums[j] = temp;
+                    }
+                } else {
+                    if (nums[i] > nums[j]) {
+                        let temp = nums[i];
+                        nums[i] = nums[j];
+                        nums[j] = temp;
+                    }
+                }
+            }
+        }
+        return nums;  
+};

From 5167c0496adb7e664d4ea779a8ea9c0421f893fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Feb 2022 12:13:47 +0800
Subject: [PATCH 1907/3374] Create
 2165-smallest-value-of-the-rearranged-number.js

---
 ...smallest-value-of-the-rearranged-number.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2165-smallest-value-of-the-rearranged-number.js

diff --git a/2165-smallest-value-of-the-rearranged-number.js b/2165-smallest-value-of-the-rearranged-number.js
new file mode 100644
index 00000000..7be3004b
--- /dev/null
+++ b/2165-smallest-value-of-the-rearranged-number.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+var smallestNumber = function(num) {
+    const minus = num < 0
+    const nums = Math.abs(num)
+      .toString()
+      .split('')
+      .map(_ => parseInt(_))
+      .sort((a, b) => minus ? b-a : a-b);
+    if(!minus && nums[0] === 0) {
+        let i = 0
+        while(nums[i] === 0 && i < nums.length-1) i++
+        nums[0] = nums[i]
+        nums[i] = 0
+    }
+    const answer = parseInt(nums.map(_ => _.toString()).join(''))
+    return minus ? -answer : answer
+};

From 2e18e1e8f6e9504a2bb9d2c8a2027e0020a85a49 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Feb 2022 12:14:23 +0800
Subject: [PATCH 1908/3374] Create 2166-design-bitset.js

---
 2166-design-bitset.js | 88 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 2166-design-bitset.js

diff --git a/2166-design-bitset.js b/2166-design-bitset.js
new file mode 100644
index 00000000..d38a595a
--- /dev/null
+++ b/2166-design-bitset.js
@@ -0,0 +1,88 @@
+/**
+ * @param {number} size
+ */
+var Bitset = function(size) {
+  this.s = Array.from({ length:2 }, () => Array())
+  this.cnt = 0
+  this.now = 0
+  for (let i = 0; i < size; i++) {
+    this.s[this.now].push( '0');
+    this.s[this.now ^ 1].push( '1');
+  }
+};
+
+/** 
+ * @param {number} idx
+ * @return {void}
+ */
+Bitset.prototype.fix = function(idx) {
+    if (this.s[this.now][idx] == '1') return;
+    // swap(this.s[this.now][idx], this.s[this.now ^ 1][idx]);
+    const tmp = this.s[this.now][idx]
+    this.s[this.now][idx] = this.s[this.now ^ 1][idx]
+    this.s[this.now ^ 1][idx] = tmp
+    this.cnt++;
+};
+
+/** 
+ * @param {number} idx
+ * @return {void}
+ */
+Bitset.prototype.unfix = function(idx) {
+    if (this.s[this.now][idx] == '0') return;
+    // swap(this.s[this.now][idx], this.s[this.now ^ 1][idx]);
+    const tmp = this.s[this.now][idx]
+    this.s[this.now][idx] =  this.s[this.now ^ 1][idx]
+   this.s[this.now ^ 1][idx] = tmp
+    this.cnt--;
+};
+
+/**
+ * @return {void}
+ */
+Bitset.prototype.flip = function() {
+    this.now = this.now ^ 1;
+    this.cnt = this.s[0].length - this.cnt;
+};
+
+/**
+ * @return {boolean}
+ */
+Bitset.prototype.all = function() {
+    return this.cnt == this.s[0].length;
+};
+
+/**
+ * @return {boolean}
+ */
+Bitset.prototype.one = function() {
+    return this.cnt !== 0
+};
+
+/**
+ * @return {number}
+ */
+Bitset.prototype.count = function() {
+    return this.cnt;
+};
+
+/**
+ * @return {string}
+ */
+Bitset.prototype.toString = function() {
+     return this.s[this.now].join('');
+};
+
+
+/** 
+ * Your Bitset object will be instantiated and called as such:
+ * var obj = new Bitset(size)
+ * obj.fix(idx)
+ * obj.unfix(idx)
+ * obj.flip()
+ * var param_4 = obj.all()
+ * var param_5 = obj.one()
+ * var param_6 = obj.count()
+ * var param_7 = obj.toString()
+ */
+

From e92e805eb3cb857d6a04626052be0b4f55958c4d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Feb 2022 12:14:50 +0800
Subject: [PATCH 1909/3374] Create
 2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js

---
 ...emove-all-cars-containing-illegal-goods.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js

diff --git a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
new file mode 100644
index 00000000..db4e36c1
--- /dev/null
+++ b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
@@ -0,0 +1,47 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minimumTime = function(s) {
+
+  const { max, min } = Math
+  
+        let n = s.length;
+    const l = Array.from({ length: n + 1 }, () => Array(2).fill(0))
+  const r = Array.from({ length: n + 1 }, () => Array(2).fill(0))
+        for (let i = 0; i < n; i++) l[i][0] = l[i][1] = r[i][0] = r[i][1] = 0;
+        if (s[0] == '1') {
+            l[0][0] = 1;
+            l[0][1] = 2;
+        }
+        for (let i = 1; i < n; i++) {
+            if (s[i] == '0') {
+                l[i][0] = l[i - 1][0];
+                l[i][1] = l[i - 1][1];
+            } else {
+                l[i][0] = i + 1;
+                l[i][1] = min(l[i - 1][0], l[i - 1][1]) + 2;
+            }
+        }
+        if (s[n - 1] == '1') {
+            r[n - 1][0] = 1;
+            r[n - 1][1] = 2;
+        }
+        for (let i = n - 2; i >= 0; i--) {
+            if (s[i] == '0') {
+                r[i][0] = r[i + 1][0];
+                r[i][1] = r[i + 1][1];
+            } else {
+                r[i][0] = n - i;
+                r[i][1] = min(r[i + 1][0], r[i + 1][1]) + 2;
+            }
+        }
+        let ans = n;
+        for (let i = -1; i < n; i++) {
+            let cost = 0;
+            if (i != -1) cost += min(l[i][0], l[i][1]);
+            if (i != n - 1) cost += min(r[i + 1][0], r[i + 1][1]);
+            ans = min(ans, cost);
+        }
+        return ans;
+};

From 7745e06383b352bee689a8caebd4986f8e4d9757 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Feb 2022 09:04:01 +0800
Subject: [PATCH 1910/3374] Update 2140-solving-questions-with-brainpower.js

---
 2140-solving-questions-with-brainpower.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/2140-solving-questions-with-brainpower.js b/2140-solving-questions-with-brainpower.js
index c971f87e..646ba1d2 100644
--- a/2140-solving-questions-with-brainpower.js
+++ b/2140-solving-questions-with-brainpower.js
@@ -1,3 +1,18 @@
+/**
+ * @param {number[][]} questions
+ * @return {number}
+ */
+const mostPoints = function(questions) {
+  const n = questions.length, dp = Array(n + 1).fill(0)
+  for (let i = n - 1; i >= 0; i--) {
+    const [gain, p] = questions[i]
+    dp[i] = Math.max(dp[i + 1], (dp[p + i + 1] || 0) + gain)
+  }
+  return dp[0]
+};
+
+// another
+
 /**
  * @param {number[][]} questions
  * @return {number}

From c413b748afe2243999c793f7615417401486a0bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Feb 2022 13:51:18 +0800
Subject: [PATCH 1911/3374] Update 1774-closest-dessert-cost.js

---
 1774-closest-dessert-cost.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1774-closest-dessert-cost.js b/1774-closest-dessert-cost.js
index a274115a..6d918079 100644
--- a/1774-closest-dessert-cost.js
+++ b/1774-closest-dessert-cost.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} baseCosts
+ * @param {number[]} toppingCosts
+ * @param {number} target
+ * @return {number}
+ */
+const closestCost = function(baseCosts, toppingCosts, target) {
+  let res = baseCosts[0], n = baseCosts.length, m = toppingCosts.length
+  const { abs } = Math
+  for (let i = 0; i < n; i++) {
+    helper(0, baseCosts[i])
+  }
+  return res
+  function helper(i, cur) {
+    if(
+      abs(cur - target) < abs(res - target)
+      || (abs(cur - target) === abs(res - target) && cur < res)
+    ) {
+      res = cur
+    }
+    if(i === m || cur > target) return
+    helper(i + 1, cur)
+    helper(i + 1, cur + toppingCosts[i])
+    helper(i + 1, cur + toppingCosts[i] * 2)
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} baseCosts
  * @param {number[]} toppingCosts

From d017657646953557e97b0444493780db7f527941 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Feb 2022 10:17:57 +0800
Subject: [PATCH 1912/3374] Update
 1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js

---
 ...to-convert-binary-matrix-to-zero-matrix.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
index 52f950e6..a79ab5e6 100644
--- a/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
+++ b/1284-minimum-number-of-flips-to-convert-binary-matrix-to-zero-matrix.js
@@ -1,3 +1,47 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const minFlips = function (mat) {
+  let start = 0
+  const m = mat.length, n = mat[0].length
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      start |= mat[i][j] << (i * n + j)
+    }
+  }
+  let q = [start]
+  const seen = new Set(), dirs = [[-1, 0], [1, 0], [0, -1], [0, 1], [0, 0]]
+
+  for(let i = 0; q.length; i++) {
+    const tmp = []
+    for (let size = q.length; size > 0; size--) {
+      const cur = q.pop()
+      if(cur === 0) return i
+      for(let i = 0; i < m; i++) {
+        for(let j = 0; j < n; j++) {
+          let next = cur
+          for(const [dx, dy] of dirs) {
+            const r = i + dx, c = j + dy
+            if(r >= 0 && r < m && c >= 0 && c < n) {
+              next ^= (1 << (r * n + c))
+            }
+          }
+          if (!seen.has(next)) {
+            seen.add(next)
+            tmp.push(next)
+          }
+        }
+      }
+    }
+    q = tmp
+  }
+
+  return -1
+}
+
+// another
+
 /**
  * @param {number[][]} mat
  * @return {number}

From b47b14dcb783f06a12f17a7a394f1b09ddf942d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Feb 2022 10:18:42 +0800
Subject: [PATCH 1913/3374] Create
 1452-people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list.js

---
 ...mpanies-is-not-a-subset-of-another-list.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1452-people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list.js

diff --git a/1452-people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list.js b/1452-people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list.js
new file mode 100644
index 00000000..74cce6bb
--- /dev/null
+++ b/1452-people-whose-list-of-favorite-companies-is-not-a-subset-of-another-list.js
@@ -0,0 +1,38 @@
+
+/**
+ * @param {string[][]} favoriteCompanies
+ * @return {number[]}
+ */
+const peopleIndexes = function(favoriteCompanies) {
+  const fcs = []
+  for(const fc of favoriteCompanies) fcs.push(new Set(fc))
+  const n = fcs.length, uf = new Array(n).fill(0)
+  for(let i = 0; i < n; i++) uf[i] = i
+  for(let i = 0; i < n; i++) {
+    for(let j = i + 1; j < n; j++) {
+      const a = find(uf, i), b = find(uf, j)
+      if(a === b) continue
+      else if(contains(fcs[a], fcs[b])) uf[b] = a
+      else if(contains(fcs[b], fcs[a])) uf[a] = b
+    }
+  }
+  const set = new Set()
+  for(const i of uf) set.add(find(uf, i))
+  return Array.from(set).sort((a, b) => a - b)
+
+  function contains(a, b) {
+    if(a.size < b.size) return false
+    for(let e of b) {
+      if(!a.has(e)) return false
+    }    
+    return true
+  }
+
+  function find(uf, e) {
+    while(uf[e] !== e) {
+      uf[e] = uf[uf[e]]
+      e = uf[e]
+    }
+    return e
+  }
+};

From 6dcb918f22258d822a1b5bc2d1ac9f9be9a0850e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Feb 2022 17:19:57 +0800
Subject: [PATCH 1914/3374] Update
 1601-maximum-number-of-achievable-transfer-requests.js

---
 ...-number-of-achievable-transfer-requests.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/1601-maximum-number-of-achievable-transfer-requests.js b/1601-maximum-number-of-achievable-transfer-requests.js
index 969324af..b99d414f 100644
--- a/1601-maximum-number-of-achievable-transfer-requests.js
+++ b/1601-maximum-number-of-achievable-transfer-requests.js
@@ -1,3 +1,37 @@
+// O(n * 2 ^ r) 
+// r: number of requests
+/**
+ * @param {number} n
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maximumRequests = function(n, requests) {
+  const arr = Array(n).fill(0)
+  let res = 0
+  bt(requests, 0, arr, 0)
+  return res
+  function bt(r, idx, arr, num) {
+    if(idx === r.length) {
+      for(let i = 0; i < n; i++) {
+        if(arr[i] !== 0) return
+      }
+      res = Math.max(res, num)
+      return
+    }
+    const [from, to] = r[idx]
+    arr[from]++
+    arr[to]--
+    bt(r, idx + 1, arr, num + 1)
+    arr[from]--
+    arr[to]++
+    
+    bt(r, idx + 1, arr, num)
+  }
+};
+
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} requests

From 24fe085fd832bfad05927329cf01499ed76ddcab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Feb 2022 20:32:59 +0800
Subject: [PATCH 1915/3374] Create 2169-count-operations-to-obtain-zero.js

---
 2169-count-operations-to-obtain-zero.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2169-count-operations-to-obtain-zero.js

diff --git a/2169-count-operations-to-obtain-zero.js b/2169-count-operations-to-obtain-zero.js
new file mode 100644
index 00000000..5d4a260d
--- /dev/null
+++ b/2169-count-operations-to-obtain-zero.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} num1
+ * @param {number} num2
+ * @return {number}
+ */
+var countOperations = function(num1, num2) {
+  let res = 0
+  while(num1 !== 0 && num2 !== 0) {
+    if(num1 >= num2) num1 -= num2
+    else num2 -= num1
+    res++
+  }
+  return res
+};

From 9c461a96a8f5351cddc545cf0e2731dfd2703131 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Feb 2022 20:24:08 +0800
Subject: [PATCH 1916/3374] Update 1879-minimum-xor-sum-of-two-arrays.js

---
 1879-minimum-xor-sum-of-two-arrays.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1879-minimum-xor-sum-of-two-arrays.js b/1879-minimum-xor-sum-of-two-arrays.js
index d85100e7..0225d947 100644
--- a/1879-minimum-xor-sum-of-two-arrays.js
+++ b/1879-minimum-xor-sum-of-two-arrays.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minimumXORSum = function (nums1, nums2) {
+  const n = nums1.length, dp = Array(1 << n).fill(Infinity)
+  return dfs(0, 0)
+  function dfs(i, mask) {
+    if(i === n) return 0
+    if(dp[mask] !== Infinity) return dp[mask]
+    for(let j = 0; j < n; j++) {
+      if((mask & (1 << j)) === 0) {
+        dp[mask] = Math.min(
+          dp[mask], 
+          (nums1[i] ^ nums2[j]) + dfs(i + 1, mask | (1 << j))
+        )
+      }
+    }
+    return dp[mask]
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2

From 0436dd21684e3b77ba0ce01e16cee9e2f84b9e9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Feb 2022 20:51:36 +0800
Subject: [PATCH 1917/3374] Update 1947-maximum-compatibility-score-sum.js

---
 1947-maximum-compatibility-score-sum.js | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/1947-maximum-compatibility-score-sum.js b/1947-maximum-compatibility-score-sum.js
index 893623e4..e6148d33 100644
--- a/1947-maximum-compatibility-score-sum.js
+++ b/1947-maximum-compatibility-score-sum.js
@@ -40,9 +40,8 @@ const maxCompatibilitySum = function(students, mentors) {
  */
 const maxCompatibilitySum = function(students, mentors) {
   const obj = { res: 0 }, hash = {}
-  for(let i = 0, n = students.length; i < n; i++) {
-    bt(students, mentors, 0, 0, obj, hash)
-  }
+  bt(students, mentors, 0, 0, obj, hash)
+
   return obj.res
 };
 
@@ -51,7 +50,6 @@ function bt(stu, men, i, score, obj, hash) {
   if(i === stu.length) {
     if(score > obj.res) {
       obj.res = score
-      // console.log(hash)
     }
     return
   }

From 5f4f96a80545681de3d56f0c674f66931383c714 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Feb 2022 14:04:55 +0800
Subject: [PATCH 1918/3374] Update 1066-campus-bikes-ii.js

---
 1066-campus-bikes-ii.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1066-campus-bikes-ii.js b/1066-campus-bikes-ii.js
index d3d96ed1..0f1f9b3a 100644
--- a/1066-campus-bikes-ii.js
+++ b/1066-campus-bikes-ii.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} workers
+ * @param {number[][]} bikes
+ * @return {number}
+ */
+const assignBikes = function(workers, bikes) {
+  const n = workers.length, m = bikes.length
+  let res = Infinity
+  dfs(0, 0, 0)
+  return res
+  function dfs(i, mask, cur) {
+    if(i === n) {
+      res = Math.min(res, cur)
+      return
+    }
+    for(let j = 0; j < m; j++) {
+      if(((mask >> j) ^ 1) % 2 == 1) {
+        dfs(i + 1, mask | (1 << j), cur + calc(i, j))
+      }
+    }
+  }
+
+  function calc(i, j) {
+    const a = workers[i], b = bikes[j]
+    return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1])
+  }
+
+};
+
+// another
+
 /**
  * @param {number[][]} workers
  * @param {number[][]} bikes

From 015bcdd20845b2f75e4e5c4319aa58961393ba5d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Feb 2022 14:06:52 +0800
Subject: [PATCH 1919/3374] Update 1066-campus-bikes-ii.js

---
 1066-campus-bikes-ii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/1066-campus-bikes-ii.js b/1066-campus-bikes-ii.js
index 0f1f9b3a..ddf46b3d 100644
--- a/1066-campus-bikes-ii.js
+++ b/1066-campus-bikes-ii.js
@@ -14,7 +14,7 @@ const assignBikes = function(workers, bikes) {
       return
     }
     for(let j = 0; j < m; j++) {
-      if(((mask >> j) ^ 1) % 2 == 1) {
+      if((mask & (1 << j)) === 0) {
         dfs(i + 1, mask | (1 << j), cur + calc(i, j))
       }
     }

From 37a41a88cd51ff61a30dc4eceef722e132fbf12b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Feb 2022 12:55:50 +0800
Subject: [PATCH 1920/3374] Create 2180-count-integers-with-even-digit-sum.js

---
 2180-count-integers-with-even-digit-sum.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2180-count-integers-with-even-digit-sum.js

diff --git a/2180-count-integers-with-even-digit-sum.js b/2180-count-integers-with-even-digit-sum.js
new file mode 100644
index 00000000..c15c2dc9
--- /dev/null
+++ b/2180-count-integers-with-even-digit-sum.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} num
+ * @return {number}
+ */
+var countEven = function(num) {
+  let res = 0
+  for(let i = 1; i <= num; i++) {
+    const tmp = sum(i)
+    if(tmp % 2 === 0) res++
+  }
+  
+  return res
+};
+
+function sum(e) {
+  let res = 0
+  while(e) {
+    res += e % 10
+    e = Math.floor(e/10)
+  }
+  return res
+}

From e606b4d2305407197399a1f55f4919bf7b2db117 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Feb 2022 12:56:17 +0800
Subject: [PATCH 1921/3374] Create 2181-merge-nodes-in-between-zeros.js

---
 2181-merge-nodes-in-between-zeros.js | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2181-merge-nodes-in-between-zeros.js

diff --git a/2181-merge-nodes-in-between-zeros.js b/2181-merge-nodes-in-between-zeros.js
new file mode 100644
index 00000000..12bcb723
--- /dev/null
+++ b/2181-merge-nodes-in-between-zeros.js
@@ -0,0 +1,37 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var mergeNodes = function(head) {
+  const dummy = new ListNode()
+  const arr = []
+  let cur = head
+  while(cur) {
+    arr.push(cur)
+    cur = cur.next
+  }
+  let tail = dummy
+  let lastIdx = 0, sum = 0
+  if(arr.length) {
+    for(let i = 1; i < arr.length; i++) {
+      const tmp = arr[i]
+      if(tmp.val === 0 && sum !== 0) {
+        lastIdx = i
+        tail.next = new ListNode(sum)
+        tail = tail.next
+        sum = 0
+      } else {
+        sum += tmp.val
+      }
+    }
+  }
+  
+  return dummy.next
+};

From 0ad002b6b8ceb90f54a2b6491d5abbe1658a7c3b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Feb 2022 12:56:44 +0800
Subject: [PATCH 1922/3374] Create 2182-construct-string-with-repeat-limit.js

---
 2182-construct-string-with-repeat-limit.js | 46 ++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 2182-construct-string-with-repeat-limit.js

diff --git a/2182-construct-string-with-repeat-limit.js b/2182-construct-string-with-repeat-limit.js
new file mode 100644
index 00000000..3672040b
--- /dev/null
+++ b/2182-construct-string-with-repeat-limit.js
@@ -0,0 +1,46 @@
+/**
+ * @param {string} s
+ * @param {number} repeatLimit
+ * @return {string}
+ */
+var repeatLimitedString = function(s, repeatLimit) {
+    const a = 'a'.charCodeAt(0)
+    const ch = Array(26).fill(0)
+    for(let e of s) {
+      const idx = e.charCodeAt(0)
+      ch[idx - a]++
+    }
+    let res = '', last = ''
+    while(true) {
+      let len = res.length
+      let h = false
+      for(let i = 25; i >= 0; i--) {
+        if(ch[i] >= repeatLimit && res[res.length - 1] !== String.fromCharCode(a + i)) {
+
+          res += String.fromCharCode(a + i).repeat(repeatLimit)
+          ch[i] -= repeatLimit
+          
+          if(ch[i]) {
+            for(let j = i - 1; j >= 0; j--) {
+              if(ch[j]) {
+                res += String.fromCharCode(a + j)
+                ch[j]--
+                break
+              }
+            }
+            break
+          }
+
+        }else if(ch[i] > 0 && res[res.length - 1] !== String.fromCharCode(a + i)) {
+          
+          res += String.fromCharCode(a + i).repeat(ch[i])
+          ch[i] = 0
+          break
+        }
+      }
+      if(len === res.length) break
+    }
+    
+    
+    return res
+};

From 10d93e11c48bb203ee5383d8b2cfc7cd7a75ec37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Feb 2022 12:57:13 +0800
Subject: [PATCH 1923/3374] Create 2183-count-array-pairs-divisible-by-k.js

---
 2183-count-array-pairs-divisible-by-k.js | 27 ++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2183-count-array-pairs-divisible-by-k.js

diff --git a/2183-count-array-pairs-divisible-by-k.js b/2183-count-array-pairs-divisible-by-k.js
new file mode 100644
index 00000000..d7ff02ab
--- /dev/null
+++ b/2183-count-array-pairs-divisible-by-k.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const coutPairs = function(nums, k) {
+  let res = 0;
+  let cnt = Array(1e5 + 1).fill(0);
+  const n = nums.length
+  for (let i = 0; i < n; ++i) {
+    if (nums[i] % k == 0) {
+      res += i;
+      ++cnt[0];
+    }
+    else {
+      let div = gcd(k, nums[i]);
+      for (let d = 0; d <= div; ++d) res += cnt[k / div * d];
+      ++cnt[div];
+    }   
+  }
+  return res;
+};
+
+function gcd(a, b) {
+  if(b === 0) return a
+  return gcd(b, a % b)
+}

From d29635fe43e5dd092e5dd3755a6c2c0acd88b638 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Feb 2022 13:36:55 +0800
Subject: [PATCH 1924/3374] Update 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 56 +++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
index a7d7c2c5..ece2391f 100644
--- a/1655-distribute-repeating-integers.js
+++ b/1655-distribute-repeating-integers.js
@@ -111,3 +111,59 @@ const canDistribute = function(nums, quantity) {
     return dp[idx][mask] = res
   }
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[]} quantity
+ * @return {boolean}
+ */
+const canDistribute = function (nums, quantity) {
+  const hash = {}
+  for(const e of nums) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const cnts = Object.values(hash), m = quantity.length, n = cnts.length
+  const dp = Array.from({ length: n }, () => Array(1 << m).fill(null))
+  
+  return helper(0, 0)
+
+  function helper(idx, mask) {
+    // mask are already selected candidates
+    if(mask == (1 << m) - 1) {
+        return true;
+    }
+    if(idx == n) {
+        return false;
+    }
+    if(dp[idx][mask] != null) {
+        return dp[idx][mask];
+    }
+    let ans = helper(idx + 1, mask);
+    
+    for(let i = 1; i < (1 << m); ++i) {
+        // i are potential candidates in addition to already selected ones (from mask)
+        // if i == mask, we can skip as the candidate is selected already
+        // if mask != (mask & i) means that this candidate does not include selected ones e.g
+        // mask = 3 (i.e 2 elements 1,2 in binary) and i = 4 (the third element in binary as 4 does not include 1 & 2), there we skip
+        if(mask == i || mask != (mask & i)) continue;
+        let sum = 0;
+        for(let j = 0; j < m; ++j) {
+            // mask << ~j is just a fancy way to do: if(mask & (1 << j)) that i've learned from @Uwi and this way you don't have to use "(", ")"
+            // what it does is simply pushing the jth bit to the 2^31 bit which is negative
+            // thus if the jth bit is 1 then the value is less than zero and if its 0 then its greater or equal to zero
+            if(mask << ~j >= 0 && i << ~j < 0) {  // check that mask does not contain the new candidate and that the candidate is part of the potential candidate i
+                sum += quantity[j];
+            }
+        }
+        if(sum <= cnts[idx]) {
+            ans |= helper(idx + 1, i);
+        }
+        if(ans) break; // if ans is true, then a solution exists and no further computation is required
+    }
+    dp[idx][mask] = ans;
+    return ans;
+  }
+}

From b2df82666a5e8463f5b32b67c75801f6306d57ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Feb 2022 11:50:37 +0800
Subject: [PATCH 1925/3374] Update
 1986-minimum-number-of-work-sessions-to-finish-the-tasks.js

---
 ...er-of-work-sessions-to-finish-the-tasks.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
index e3e4b07a..2b5b5758 100644
--- a/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
+++ b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
@@ -28,3 +28,35 @@ const minSessions = function(tasks, sessionTime) {
     return dp[mask][consumed] = result;
   }
 };
+
+// another
+
+/**
+ * @param {number[]} tasks
+ * @param {number} sessionTime
+ * @return {number}
+ */
+function minSessions(tasks, sessionTime) {
+  const n = tasks.length
+  const memo = Array.from({ length: 1 << n }, () => Array(15))
+  return helper((1 << n) - 1, 0)
+
+  function helper(mask, remain) {
+    if(mask === 0) return 0
+    if(memo[mask][remain] != null) return memo[mask][remain]
+    let res = n
+    
+    for(let i = 0; i < n; i++) {
+      if((1 << i) & mask) {
+        const newMask = mask & (~(1 << i))
+        if(tasks[i] <= remain) {
+          res = Math.min(res, helper(newMask, remain - tasks[i]))
+        } else {
+          res = Math.min(res, helper(newMask, sessionTime - tasks[i]) + 1)
+        }
+      }
+    }
+
+    return memo[mask][remain] = res
+  }
+}

From a742357fef9293ff3cf86c22bf845cb73e8e2fea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Feb 2022 17:11:33 +0800
Subject: [PATCH 1926/3374] Create
 2152-minimum-number-of-lines-to-cover-points.js

---
 ...minimum-number-of-lines-to-cover-points.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 2152-minimum-number-of-lines-to-cover-points.js

diff --git a/2152-minimum-number-of-lines-to-cover-points.js b/2152-minimum-number-of-lines-to-cover-points.js
new file mode 100644
index 00000000..8c0878b4
--- /dev/null
+++ b/2152-minimum-number-of-lines-to-cover-points.js
@@ -0,0 +1,58 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const minimumLines = function(points) {
+  const n = points.length;
+  const connects = Array.from({ length: n }, () => Array(n).fill(0));
+  for(let i = 0; i < n; ++i) {
+      for(let j = i + 1; j < n; ++j) {
+          connects[i][j] = (1 << i) | (1 << j);
+          let dx = points[j][0] - points[i][0];
+          let dy = points[j][1] - points[i][1];
+          for(let k = j + 1; k < n; ++k) { // check if k will be on the line connecting i and j.
+              let dx2 = points[k][0] - points[i][0];
+              let dy2 = points[k][1] - points[i][1];
+              if (dx * dy2 == dy * dx2) {
+                  connects[i][j] |= (1 << k);
+              }
+          }
+      }
+  }
+  const dp = new Array(1<<n).fill(Infinity);
+  return helper(n, 0, dp, connects);
+};
+
+function helper(n, mask, dp, connects) {
+  if (dp[mask] == Infinity) {
+      let has = numOfOne(mask);
+      if (has == n) { // if all the points have been connected
+          dp[mask] = 0;
+      } else if (has >= n - 2) { // if only 2 points left
+          dp[mask] = 1;
+      } else { // if there are more than 2 points, try a line connecting first to second, third, ...
+          let i = 0;
+          for(let x = (1 << i); i < n; ++i, x <<= 1) {
+              if ((mask & x) == 0) {
+                  break;
+              }
+          }
+          for(let j = i + 1, x = (1 << j); j < n; ++j, x <<= 1) {
+              if ((mask & x) == 0) {
+                  let mask2 = mask | connects[i][j];
+                  dp[mask] = Math.min(dp[mask], 1 + helper(n, mask2, dp, connects));
+              }
+          }
+      }
+  }
+  return dp[mask];
+}
+
+function numOfOne(num) {
+  const str = (num >>> 0).toString(2)
+  let res = 0
+  for(let ch of str) {
+    if(ch === '1') res++
+  }
+  return res
+}

From 0b754135afaa8a5fee877f875314bf4d05b6f3e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Feb 2022 00:09:50 +0800
Subject: [PATCH 1927/3374] Create 2179-count-good-triplets-in-an-array.js

---
 2179-count-good-triplets-in-an-array.js | 37 +++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2179-count-good-triplets-in-an-array.js

diff --git a/2179-count-good-triplets-in-an-array.js b/2179-count-good-triplets-in-an-array.js
new file mode 100644
index 00000000..56aca32c
--- /dev/null
+++ b/2179-count-good-triplets-in-an-array.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} a
+ * @param {number[]} b
+ * @return {number}
+ */
+const goodTriplets = function(a, b) {
+    let n = a.length, m = new Map(), res = 0;
+    for (let i = 0; i < n; i++) m.set(b[i], i);
+    let fen = new Fenwick(n + 3);
+    for (let i = 0; i < n; i++) {
+       let pos = m.get(a[i]);
+       let l = fen.query(pos), r = (n - 1 - pos) - (fen.query(n - 1) - fen.query(pos));
+       res += l * r; 
+       fen.update(pos, 1);
+    }
+    return res;
+};
+function Fenwick(n) {
+    let tree = Array(n).fill(0);
+    return { query, update }
+    function query(i) {
+        let sum = 0;
+        i++;
+        while (i > 0) {
+            sum += tree[i];
+            i -= i & -i;
+        }
+        return sum;
+    }
+    function update(i, v) {
+        i++;
+        while (i < n) {
+            tree[i] += v;
+            i += i & -i;
+        }
+    }
+}

From 2709eabdd1fea7cf076673d425ca4489c0ee1e1a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Mar 2022 15:12:09 +0800
Subject: [PATCH 1928/3374] Create
 2163-minimum-difference-in-sums-after-removal-of-elements.js

---
 ...rence-in-sums-after-removal-of-elements.js | 110 ++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 2163-minimum-difference-in-sums-after-removal-of-elements.js

diff --git a/2163-minimum-difference-in-sums-after-removal-of-elements.js b/2163-minimum-difference-in-sums-after-removal-of-elements.js
new file mode 100644
index 00000000..938e51e7
--- /dev/null
+++ b/2163-minimum-difference-in-sums-after-removal-of-elements.js
@@ -0,0 +1,110 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumDifference = function(nums) {
+  const n = nums.length, len = n / 3
+  const maxHeap = new PriorityQueue((a, b) => a > b)
+  const minHeap = new PriorityQueue((a, b) => a < b)
+  const pre = Array(n).fill(Infinity), suffix = Array(n).fill(-Infinity)
+  for(let i = 0, sum = 0; i < 2 * len; i++) {
+    const cur = nums[i]
+    maxHeap.push(cur)
+    sum += cur
+    if(maxHeap.size() > len) {
+      const tmp = maxHeap.pop()
+      sum -= tmp
+    }
+    if(maxHeap.size() === len) {
+      pre[i] = sum
+    }
+  }
+
+  for(let i = n - 1, sum = 0; i >= len; i--) {
+    const cur = nums[i]
+    minHeap.push(cur)
+    sum += cur
+    if(minHeap.size() > len) {
+      const tmp = minHeap.pop()
+      sum -= tmp
+    }
+    if(minHeap.size() === len) {
+      suffix[i] = sum
+    }
+  }
+
+  // console.log(pre, suffix)
+  let res = Infinity
+  for(let i = len - 1; i < n - len; i++) {
+    res = Math.min(res, pre[i] - suffix[i + 1])
+  }
+  return res
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 6f616b04842ee2843a5b4ae9f45b071289e40427 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Mar 2022 10:40:28 +0800
Subject: [PATCH 1929/3374] Update
 1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js

---
 ...s-to-make-the-binary-string-alternating.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
index da32124d..0255d212 100644
--- a/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
+++ b/1888-minimum-number-of-flips-to-make-the-binary-string-alternating.js
@@ -76,5 +76,40 @@ const minFlips = function (s) {
   return res
 }
 
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minFlips = function (s) {
+  const n = s.length
+  const ss = s + s
+  let s1 = '', s2 = ''
+  for(let i = 0; i < 2 * n; i++) {
+    if(i % 2 === 0) {
+      s1 += '0'
+      s2 += '1'
+    }else{
+      s1 += '1'
+      s2 += '0'
+    }
+  }
 
+  let res = Infinity, res1 = 0, res2 = 0
+
+  for (let i = 0; i < 2 * n; i++) {
+    if(ss[i] !== s1[i]) res1++
+    if(ss[i] !== s2[i]) res2++
+    if(i >= n) {
+      if(ss[i - n] !== s1[i - n]) res1--
+      if(ss[i - n] !== s2[i - n]) res2--
+    }
+    if(i >= n - 1) {
+      res = Math.min(res, res1, res2)
+    }
+  }
+
+  return res
+}
 

From 75f2207bd51144656254d63cd8cf817d9742e8a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Mar 2022 10:42:54 +0800
Subject: [PATCH 1930/3374] Update
 1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js

---
 ...perations-to-move-all-balls-to-each-box.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
index 6364c519..11f47aa6 100644
--- a/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
+++ b/1769-minimum-number-of-operations-to-move-all-balls-to-each-box.js
@@ -45,3 +45,27 @@ function helper(str, idx) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {string} boxes
+ * @return {number[]}
+ */
+ const minOperations = function(boxes) {
+  const n = boxes.length
+  const res = Array(n).fill(0)
+  let cnt = 0, sum = 0
+  for(let i = 0; i < n; i++) {
+    res[i] = sum
+    cnt += boxes[i] === '1' ? 1 : 0
+    sum += cnt
+  }
+  cnt = 0, sum = 0
+  for(let i = n - 1; i >= 0; i--) {
+    res[i] += sum
+    cnt += boxes[i] === '1' ? 1 : 0
+    sum += cnt
+  }
+  return res
+};

From 27250dd73b17fb78695d1f944835ee6e667dc73a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Mar 2022 15:07:06 +0800
Subject: [PATCH 1931/3374] Update
 2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js

---
 ...emove-all-cars-containing-illegal-goods.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
index db4e36c1..e0a246c8 100644
--- a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
+++ b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
@@ -1,3 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumTime = function(s) {
+  const n = s.length
+  const arr = []
+  for(let ch of s) {
+    arr.push(ch === '1' ? 1 : -1)
+  }
+  const score = minSum(arr)
+  return n + score
+
+  function minSum(ar) {
+    const dp = Array(n).fill(0)
+    dp[0] = ar[0]
+    for(let i = 1; i < n; i++) {
+      dp[i] = Math.min(ar[i], ar[i] + dp[i - 1])
+    }
+    return Math.min(0, Math.min(...dp))
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From c5efe094fc52f0af09e7e8a0c5b8b1934f092d17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Mar 2022 15:30:07 +0800
Subject: [PATCH 1932/3374] Update 53-maximum-subarray.js

---
 53-maximum-subarray.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/53-maximum-subarray.js b/53-maximum-subarray.js
index 60de46f4..8cb65d28 100755
--- a/53-maximum-subarray.js
+++ b/53-maximum-subarray.js
@@ -14,6 +14,23 @@ const maxSubArray = function(nums) {
 
 // another
 
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSubArray = function(nums) {
+  const n = nums.length, dp = Array(n).fill(0)
+  dp[0] = nums[0]
+  let res = dp[0]
+  for(let i = 1; i < n; i++) {
+    dp[i] = Math.max(dp[i - 1], 0) + nums[i]
+    res = Math.max(res, dp[i])
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 7ea4451a50556738c3b1f6726990b9e36b6f7dd6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Mar 2022 15:51:34 +0800
Subject: [PATCH 1933/3374] Update
 2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js

---
 ...emove-all-cars-containing-illegal-goods.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
index e0a246c8..f9911016 100644
--- a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
+++ b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
@@ -23,6 +23,35 @@ const minimumTime = function(s) {
 
 // another
 
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumTime = function(s) {
+  if(s.length === 1) return s === '1' ? 1 : 0
+  const n = s.length
+  const arr = []
+  for(let ch of s) {
+    arr.push(ch === '1' ? 1 : -1)
+  }
+  const score = minSum(arr)
+  return n + score
+
+  function minSum(ar) {
+    const dp = Array(n).fill(0)
+    dp[0] = ar[0]
+    let ans = dp[0]
+    for(let i = 1; i < n; i++) {
+      dp[i] = Math.min(ar[i], ar[i] + dp[i - 1])
+      ans = Math.min(0, ans, dp[i])
+    }
+    return ans
+  }
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 44a42319f67093fbd138c70b6bee59d9de83d211 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Mar 2022 16:10:54 +0800
Subject: [PATCH 1934/3374] Update
 2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js

---
 ...emove-all-cars-containing-illegal-goods.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
index f9911016..6f4ca66e 100644
--- a/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
+++ b/2167-minimum-time-to-remove-all-cars-containing-illegal-goods.js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumTime = function(s) {
+  const n = s.length
+  const arr = []
+  for(let ch of s) {
+    arr.push(ch === '1' ? 1 : -1)
+  }
+  const score = minSum(arr)
+  return n + score
+
+  function minSum(ar) {
+    const dp = Array(n).fill(Infinity)
+    dp[0] = ar[0]
+    let ans = dp[0]
+    for(let i = 1; i < n; i++) {
+      dp[i] = Math.min(ar[i], ar[i] + dp[i - 1])
+      ans = Math.min(ans, dp[i])
+    }
+    return ans > 0 ? 0 : ans
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From e2890a54d902751e9b3360326df518ea50652a03 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Mar 2022 09:52:48 +0800
Subject: [PATCH 1935/3374] Update 334-increasing-triplet-subsequence.js

---
 334-increasing-triplet-subsequence.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/334-increasing-triplet-subsequence.js b/334-increasing-triplet-subsequence.js
index a62bf62c..bd231408 100644
--- a/334-increasing-triplet-subsequence.js
+++ b/334-increasing-triplet-subsequence.js
@@ -12,3 +12,26 @@ const increasingTriplet = function(nums) {
     }
     return false;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const increasingTriplet = function(nums) {
+  const n = nums.length, stk = []
+  for(let e of nums) {
+    let l = 0, r = stk.length
+    while(l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if (e > stk[mid]) l = mid + 1
+      else r = mid 
+    }
+
+    stk[l] = e
+    if(stk.length > 2) return true
+  }
+
+  return false
+};

From d9e6fcc703ef0f6412dcf249a548fe2d11c423de Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Mar 2022 10:47:39 +0800
Subject: [PATCH 1936/3374] Update 42-trapping-rain-water.js

---
 42-trapping-rain-water.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/42-trapping-rain-water.js b/42-trapping-rain-water.js
index 4b2a964a..1b31b415 100644
--- a/42-trapping-rain-water.js
+++ b/42-trapping-rain-water.js
@@ -93,3 +93,27 @@ const trap = function(height) {
 
     return res
 };
+
+// another
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+const trap = function(height) {
+  const n = height.length, { max } = Math
+  let res = 0, l = 0, r = n - 1, leftMax = height[0], rightMax = height[n - 1]
+  while(l <= r) {
+    if(leftMax < rightMax) {
+      leftMax = max(leftMax, height[l])
+      res += leftMax - height[l]
+      l++
+    } else {
+      rightMax = max(rightMax, height[r])
+      res += rightMax - height[r]
+      r--
+    }
+  }
+
+  return res
+};

From 44241bcb33f1dcdebdb57bc6bc3613835e2ccbf5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Mar 2022 14:58:43 +0800
Subject: [PATCH 1937/3374] Create LICENSE

---
 LICENSE | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/LICENSE b/LICENSE
index 584ad7e8..be19a0e2 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 everthis
+Copyright (c) 2022 everthis
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

From 7419a713212d9adfa9005654bcaba199576d5095 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Mar 2022 09:02:55 +0800
Subject: [PATCH 1938/3374] Create
 2193-minimum-number-of-moves-to-make-palindrome.js

---
 ...imum-number-of-moves-to-make-palindrome.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2193-minimum-number-of-moves-to-make-palindrome.js

diff --git a/2193-minimum-number-of-moves-to-make-palindrome.js b/2193-minimum-number-of-moves-to-make-palindrome.js
new file mode 100644
index 00000000..266ef822
--- /dev/null
+++ b/2193-minimum-number-of-moves-to-make-palindrome.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minMovesToMakePalindrome = function(s) {
+  let res = 0
+  const arr = s.split('')
+  
+  while(arr.length) {
+    const idx = arr.indexOf(arr[arr.length - 1])
+    if(idx === arr.length - 1) {
+      res += ~~(idx / 2)
+    } else {
+      res += idx
+      arr.splice(idx, 1)
+    }
+    arr.pop()
+  }
+
+  return res
+};

From af5ab66bec3e75fcd22377d734bed57d5f721e66 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Mar 2022 15:14:01 +0800
Subject: [PATCH 1939/3374] Create 1176-diet-plan-performance.js

---
 1176-diet-plan-performance.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1176-diet-plan-performance.js

diff --git a/1176-diet-plan-performance.js b/1176-diet-plan-performance.js
new file mode 100644
index 00000000..c337b2e2
--- /dev/null
+++ b/1176-diet-plan-performance.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} calories
+ * @param {number} k
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+var dietPlanPerformance = function(calories, k, lower, upper) {
+    let res = 0
+    for(let i = 0, n = calories.length; i < n - k + 1; i++) {
+      let tmp = 0
+      for(let j = 0; j < k && i + j < n; j++) {
+        tmp += calories[i + j]
+      }
+      if(tmp < lower) res--
+      else if(tmp > upper) res++
+    }
+    return res
+};

From fc823c28b47576fd0b4a2e380ec9ddd5f1a945fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Mar 2022 15:17:46 +0800
Subject: [PATCH 1940/3374] Update 1176-diet-plan-performance.js

---
 1176-diet-plan-performance.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1176-diet-plan-performance.js b/1176-diet-plan-performance.js
index c337b2e2..4930160b 100644
--- a/1176-diet-plan-performance.js
+++ b/1176-diet-plan-performance.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} calories
+ * @param {number} k
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+var dietPlanPerformance = function(calories, k, lower, upper) {
+    let res = 0
+    for(let i = 0, n = calories.length, tmp = 0; i < n; i++) {
+      tmp += calories[i]
+      if(i >= k - 1) {
+        if(i >= k) {
+          tmp -= calories[i - k]
+        }
+        if(tmp < lower) res--
+        else if(tmp > upper) res++
+      }
+
+    }
+    return res
+};
+
+// another
+
 /**
  * @param {number[]} calories
  * @param {number} k

From ef9c5e265f22ec75cef85d99f85dd4e34dacfead Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Mar 2022 15:44:16 +0800
Subject: [PATCH 1941/3374] Create 1243-array-transformation.js

---
 1243-array-transformation.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1243-array-transformation.js

diff --git a/1243-array-transformation.js b/1243-array-transformation.js
new file mode 100644
index 00000000..b42a84d6
--- /dev/null
+++ b/1243-array-transformation.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+ const transformArray = function(arr) {
+  let cur = arr
+  while(true) {
+    const clone = cur.slice()
+    for(let i = 1; i < clone.length - 1; i++) {
+      if(cur[i] > cur[i - 1] && cur[i] > cur[i + 1]) clone[i]--
+      else if(cur[i] < cur[i - 1] && cur[i] < cur[i + 1]) clone[i]++
+    }
+    if(same(cur, clone)) return clone
+    cur = clone
+  }
+  
+  return cur
+  
+  function same(a1, a2) {
+    for(let i = 0; i< a1.length; i++) {
+      if(a1[i] !== a2[i]) return false
+    }
+    return true
+  }
+};

From 44eac72cf71d0a61f724506a050accc5cd7796a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Mar 2022 17:18:42 +0800
Subject: [PATCH 1942/3374] Create
 1180-count-substrings-with-only-one-distinct-letter.js

---
 ...unt-substrings-with-only-one-distinct-letter.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1180-count-substrings-with-only-one-distinct-letter.js

diff --git a/1180-count-substrings-with-only-one-distinct-letter.js b/1180-count-substrings-with-only-one-distinct-letter.js
new file mode 100644
index 00000000..bf5b3bec
--- /dev/null
+++ b/1180-count-substrings-with-only-one-distinct-letter.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countLetters = function(s) {
+  const str = ` ${s} `
+  let res = 0, cnt = 0
+  for(let i = 1; i < str.length - 1; i++) {
+    if(str[i] !== str[i - 1]) cnt = 1
+    else cnt += 1
+    res += cnt
+  }
+  return res
+};

From 099dbff35acaa1606d74babaeb2ee019ead5791d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Mar 2022 15:59:32 +0800
Subject: [PATCH 1943/3374] Update 765-couples-holding-hands.js

---
 765-couples-holding-hands.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/765-couples-holding-hands.js b/765-couples-holding-hands.js
index 4fec7b3e..3b5aa4d9 100644
--- a/765-couples-holding-hands.js
+++ b/765-couples-holding-hands.js
@@ -72,3 +72,35 @@ const minSwapsCouples = function (row) {
   }
 }
 
+// another
+
+/**
+ * @param {number[]} row
+ * @return {number}
+ */
+const minSwapsCouples = function (row) {
+  let res = 0
+  const n = row.length
+  const ptn = Array(n).fill(0), pos = Array(n).fill(0)
+  
+  for(let i = 0; i < n; i++) {
+    ptn[i] = (i % 2 === 0 ? i + 1 : i - 1)
+    pos[row[i]] = i
+  }
+
+  for (let i  = 0; i < n ;i++) {
+    for (let j = ptn[pos[ptn[row[i]]]]; i != j; j = ptn[pos[ptn[row[i]]]]) {
+			swap(row, i, j);
+			swap(pos, row[i], row[j]);
+			res++;
+		}
+  }
+  
+  return res
+
+  function swap(arr, i, j) {
+    const val = arr[i]
+    arr[i] = arr[j]
+    arr[j] = val
+  }
+}

From fd0f57aad0cde908c1fe2ebcfe39c3e3df41208d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Mar 2022 16:36:11 +0800
Subject: [PATCH 1944/3374] Update 743-network-delay-time.js

---
 743-network-delay-time.js | 101 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)

diff --git a/743-network-delay-time.js b/743-network-delay-time.js
index 153e225e..a827a9ca 100644
--- a/743-network-delay-time.js
+++ b/743-network-delay-time.js
@@ -47,3 +47,104 @@ const networkDelayTime = function(times, N, K) {
     const res = Math.max(...distances);
     return res === Infinity ? -1 : res;
 };
+
+// another
+
+/**
+ * @param {number[][]} times
+ * @param {number} N
+ * @param {number} K
+ * @return {number}
+ */
+const networkDelayTime = function (times, N, K) {
+  const hash = {}
+  for(const [u, v, t] of times) {
+    if(hash[u] == null) hash[u] = {}
+    hash[u][v] = t
+  }
+  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  pq.push([0, K])
+  const visited = Array.from(N + 1)
+  let res = 0
+  while(!pq.isEmpty()) {
+    const [dist, cur] = pq.pop()
+    if(visited[cur]) continue
+    visited[cur] = true
+    res = dist
+    N--
+    if(hash[cur]) {
+      for(let next of Object.keys(hash[cur])) {
+        pq.push([dist + hash[cur][next], next])
+      }
+    }
+  }
+  return N === 0 ? res : -1
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 5b4fffd96e3367de025b3299c19631e77d88c0f5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Mar 2022 09:58:29 +0800
Subject: [PATCH 1945/3374] Update
 1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js

---
 ...-make-at-least-one-valid-path-in-a-grid.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
index 1607e02e..8c9c7b30 100644
--- a/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
+++ b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
@@ -33,3 +33,34 @@ const minCost = function (grid) {
   }
   return dp[n - 1][m - 1]
 }
+
+// another
+
+function minCost(grid) {
+  const INF = 1e9, m = grid.length, n = grid[0].length
+  const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]] // right, left, down, up
+  let cost = 0
+  const dp = Array.from({ length: m }, () => Array(n).fill(INF))
+  const q = []
+  dfs(0, 0, 0)
+  while(q.length) {
+    cost++
+    for (let size = q.length; size > 0; size--) {
+      const [r, c] = q.shift()
+      for(let [dx, dy] of dirs) {
+        dfs(r + dx, c + dy, cost)
+      }
+    }
+  }
+
+  return dp[m - 1][n - 1]
+  function dfs(r, c, cost) {
+    if(r < 0 || r >= m || c < 0 || c >= n || dp[r][c] !== INF) return
+    dp[r][c] = cost
+    q.push([r, c])
+    const nextDir = grid[r][c] - 1
+    const [dx, dy] = dirs[nextDir]
+    dfs(r + dx, c + dy, cost)
+  }
+}
+

From 88be6ffb6f2ee43b090868fa3e6c1ffca0e50561 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Mar 2022 10:28:10 +0800
Subject: [PATCH 1946/3374] Update
 1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js

---
 ...-make-at-least-one-valid-path-in-a-grid.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
index 8c9c7b30..def7dab1 100644
--- a/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
+++ b/1368-minimum-cost-to-make-at-least-one-valid-path-in-a-grid.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+function minCost(grid) {
+  const m = grid.length, n = grid[0].length
+  const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]] // right, left, down, up
+  const dp = Array.from({ length: m }, () => Array(n).fill(Infinity))
+  let q = [[0, 0]]
+  dp[0][0] = 0
+  while(q.length) {
+    const tmp = []
+    for(let idx = q.length - 1; idx >= 0; idx--) {
+      const [r, c] = q[idx]
+      for(let i = 0; i < dirs.length; i++) {
+        const [dr, dc] = dirs[i]
+        const nr = r + dr, nc = c + dc
+        if(nr < 0 || nr >= m || nc < 0 || nc >= n) continue
+        if(dp[nr][nc] > dp[r][c] + (i === grid[r][c] - 1 ? 0 : 1)) {
+          dp[nr][nc] = dp[r][c] + (i === grid[r][c] - 1 ? 0 : 1)
+          tmp.push([nr, nc])
+        }
+      }
+    }
+    q = tmp
+  }
+
+  return dp[m - 1][n - 1]
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 6f36d88100eab89db60007c6fa491480b90b4b3d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Mar 2022 09:49:38 +0800
Subject: [PATCH 1947/3374] Update
 1976-number-of-ways-to-arrive-at-destination.js

---
 ...number-of-ways-to-arrive-at-destination.js | 111 ++++++++++++++++++
 1 file changed, 111 insertions(+)

diff --git a/1976-number-of-ways-to-arrive-at-destination.js b/1976-number-of-ways-to-arrive-at-destination.js
index b6015baa..11572bdd 100644
--- a/1976-number-of-ways-to-arrive-at-destination.js
+++ b/1976-number-of-ways-to-arrive-at-destination.js
@@ -109,3 +109,114 @@ class PriorityQueue {
   }
 }
 
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} roads
+ * @return {number}
+ */
+const countPaths = function(n, roads) {
+  const graph = {}, MOD = 1e9 + 7
+  for(const [u, v, t] of roads) {
+    if(graph[u] == null) graph[u] = {}
+    if(graph[v] == null) graph[v] = {}
+    graph[u][v] = t
+    graph[v][u] = t
+  }
+
+  return dijkstra(graph, n, 0)
+
+  function dijkstra(graph, n, src) {
+    const dist = Array(n).fill(Infinity)
+    const ways = Array(n).fill(0)
+    ways[src] = 1
+    dist[src] = 0
+    const pq = new PriorityQueue((a, b) => a[0] < b[0])
+    pq.push([0, 0])
+    while(!pq.isEmpty()) {
+      const [d, u] = pq.pop()
+      if(d > dist[u]) continue
+      for(const next of Object.keys(graph[u] || {})) {
+        const val = graph[u][next]
+        if(dist[next] > d + val) {
+          dist[next] = d + val
+          ways[next] = ways[u]
+          pq.push([dist[next], next])
+        } else if(dist[next] === d + val) {
+          ways[next] = (ways[next] + ways[u]) % MOD
+        }
+      }
+    }
+
+    return ways[n - 1]
+  }
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 844ef51e0de56eca5b693a896e7f04baff0fe17c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Mar 2022 11:29:31 +0800
Subject: [PATCH 1948/3374] Create 2210-count-hills-and-valleys-in-an-array.js

---
 2210-count-hills-and-valleys-in-an-array.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2210-count-hills-and-valleys-in-an-array.js

diff --git a/2210-count-hills-and-valleys-in-an-array.js b/2210-count-hills-and-valleys-in-an-array.js
new file mode 100644
index 00000000..7ffb12a9
--- /dev/null
+++ b/2210-count-hills-and-valleys-in-an-array.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countHillValley = function(nums) {
+  const arr = [nums[0]], n = nums.length
+  for(let i = 1; i < n; i++) {
+    if(nums[i] !== nums[i - 1]) arr.push(nums[i])
+  }
+  let res = 0
+  for(let i = 1; i < arr.length - 1; i++) {
+     if(
+       arr[i] > arr[i - 1] && arr[i] > arr[i + 1] ||
+       arr[i] < arr[i - 1] && arr[i] < arr[i + 1]
+     ) res++
+  }
+  
+  return res
+};

From 7918704bba8288b0e2c2e7ef6e2c6e8c3b0288ac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Mar 2022 14:02:27 +0800
Subject: [PATCH 1949/3374] Create 2211-count-collisions-on-a-road.js

---
 2211-count-collisions-on-a-road.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2211-count-collisions-on-a-road.js

diff --git a/2211-count-collisions-on-a-road.js b/2211-count-collisions-on-a-road.js
new file mode 100644
index 00000000..98bc465d
--- /dev/null
+++ b/2211-count-collisions-on-a-road.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} directions
+ * @return {number}
+ */
+const countCollisions = function(directions) {
+  let res = 0, n = directions.length
+
+  let flag = false
+  // left -> right
+  for(let i = 0; i < n; i++) {
+    if(directions[i] !== 'L') {
+      flag = true
+    } else {
+      res += flag ? 1 : 0
+    }
+  }
+  flag = false
+  // right -> left
+  for(let i = n - 1; i >= 0; i--) {
+    if(directions[i] !== 'R') {
+      flag = true
+    } else {
+      res += flag ? 1 : 0
+    }
+  }
+
+  return res
+};

From eecacfd4095acd70f56746b97ad1227ccd7e9e0c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Mar 2022 14:59:12 +0800
Subject: [PATCH 1950/3374] Update 2211-count-collisions-on-a-road.js

---
 2211-count-collisions-on-a-road.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/2211-count-collisions-on-a-road.js b/2211-count-collisions-on-a-road.js
index 98bc465d..03ab8347 100644
--- a/2211-count-collisions-on-a-road.js
+++ b/2211-count-collisions-on-a-road.js
@@ -26,3 +26,18 @@ const countCollisions = function(directions) {
 
   return res
 };
+
+// another
+
+/**
+ * @param {string} directions
+ * @return {number}
+ */
+ const countCollisions = function(directions) {
+  let res = 0, n = directions.length
+  let left = 0, right = n - 1
+  while(left < n && directions[left] === 'L') left++
+  while(right >= 0 && directions[right] === 'R') right--
+  for(let i = left; i <= right; i++) res += directions[i] === 'S' ? 0 : 1
+  return res
+};

From d87227a42f4606c55c7653db18ebc902fed44be3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Mar 2022 10:29:51 +0800
Subject: [PATCH 1951/3374] Update
 1786-number-of-restricted-paths-from-first-to-last-node.js

---
 ...estricted-paths-from-first-to-last-node.js | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1786-number-of-restricted-paths-from-first-to-last-node.js b/1786-number-of-restricted-paths-from-first-to-last-node.js
index 0552741f..6a80fd88 100644
--- a/1786-number-of-restricted-paths-from-first-to-last-node.js
+++ b/1786-number-of-restricted-paths-from-first-to-last-node.js
@@ -116,3 +116,57 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countRestrictedPaths = function(n, edges) {
+  if (n === 1) return 0
+  const graph = {}
+  for(const [u, v, t] of edges) {
+    if(graph[u] == null) graph[u] = {}
+    if(graph[v] == null) graph[v] = {}
+    graph[u][v] = t
+    graph[v][u] = t
+  }
+  const dist = dijkstra(n, graph)
+  const memo = Array(n + 1).fill(null)
+  const res = dfs(1)
+  return res
+
+  function dijkstra(n, graph) {
+    const dist = Array(n + 1).fill(Infinity)
+    dist[n] = 0
+    const pq = new PriorityQueue((a, b) => a[0] < b[0])
+    pq.push([0, n])
+    while(!pq.isEmpty()) {
+      const [d, cur] = pq.pop()
+      if(d !== dist[cur]) continue
+      for(const next of Object.keys(graph[cur] || {})) {
+        const delta = graph[cur][next]
+        if(dist[next] > d + delta) {
+          dist[next] = d + delta
+          pq.push([d + delta, next])
+        } 
+      }
+    }
+    return dist
+  }
+
+  function dfs(src) {
+    if(memo[src] != null) return memo[src]
+    if(src === n) return 1
+    let res = 0
+    for(let next of Object.keys(graph[src] || {})) {
+      next = +next
+      if(dist[src] > dist[next]) {
+        res = ((res + dfs(next)) % (1e9 + 7))
+      }
+    }
+    return memo[src] = res
+  }
+}

From a30ef92cdd6e58490480c75532f6ab806468513f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Mar 2022 14:52:35 +0800
Subject: [PATCH 1952/3374] Create
 2212-maximum-points-in-an-archery-competition.js

---
 ...aximum-points-in-an-archery-competition.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2212-maximum-points-in-an-archery-competition.js

diff --git a/2212-maximum-points-in-an-archery-competition.js b/2212-maximum-points-in-an-archery-competition.js
new file mode 100644
index 00000000..fd5ede74
--- /dev/null
+++ b/2212-maximum-points-in-an-archery-competition.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} numArrows
+ * @param {number[]} aliceArrows
+ * @return {number[]}
+ */
+const maximumBobPoints = function(numArrows, aliceArrows) {
+  let bestScore = 0, res = null
+  const sum = arr => arr.reduce((ac, e) => ac + e, 0)
+  bt(0, numArrows, 0, Array(12).fill(0))
+  res[0] += numArrows - sum(res)
+  return res
+
+  function bt(k, remain, score, bobArrows) {
+    if(k == 12) {
+      if(score > bestScore) {
+        bestScore = score
+        res = bobArrows.slice(0)
+      }
+      return
+    }
+    bt(k + 1, remain, score, bobArrows)
+    let arrowsNeeded = aliceArrows[k] + 1
+    if(remain >= arrowsNeeded) {
+      let bak = bobArrows[k]
+      bobArrows[k] = arrowsNeeded
+      bt(k + 1, remain - arrowsNeeded, score + k, bobArrows)
+      bobArrows[k] = bak
+    }
+  }
+};

From 2980bc358ca874624e4e46f2a4f1fba79e145ffb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Mar 2022 10:04:41 +0800
Subject: [PATCH 1953/3374] Update 882-reachable-nodes-in-subdivided-graph.js

---
 882-reachable-nodes-in-subdivided-graph.js | 109 +++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/882-reachable-nodes-in-subdivided-graph.js b/882-reachable-nodes-in-subdivided-graph.js
index 89c1afbe..b0e08400 100644
--- a/882-reachable-nodes-in-subdivided-graph.js
+++ b/882-reachable-nodes-in-subdivided-graph.js
@@ -196,3 +196,112 @@ class PriorityQueue {
     }
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} edges
+ * @param {number} M
+ * @param {number} N
+ * @return {number}
+ */
+const reachableNodes = function(edges, M, N) {
+  const graph = {}
+  for(const [u,v,c] of edges) {
+    if(graph[u] == null) graph[u] = {}
+    if(graph[v] == null) graph[v] = {}
+    graph[u][v] = c
+    graph[v][u] = c
+  }
+  const pq = new PriorityQueue((a, b) => a[0] > b[0])
+  pq.push([M, 0])
+  const visited = {}
+  while(!pq.isEmpty()) {
+    const [moves, i] = pq.pop()
+    if(visited[i] == null) {
+      visited[i] = moves
+      for(const k of Object.keys(graph[i] || {})) {
+        const remain = moves - graph[i][k] - 1
+        if(visited[k] == null && remain >= 0) {
+          pq.push([remain, k])
+        }
+      }
+    }
+  }
+  let res = 0
+  res += Object.keys(visited).length
+  for(const [u, v, c] of edges) {
+    const a = visited[u] || 0, b = visited[v] || 0
+    res += Math.min(a + b, c)
+  }
+
+  return res
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From e6a1fda9575543369992ae86d197570345f6e71b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Mar 2022 11:04:45 +0800
Subject: [PATCH 1954/3374] Update 882-reachable-nodes-in-subdivided-graph.js

---
 882-reachable-nodes-in-subdivided-graph.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/882-reachable-nodes-in-subdivided-graph.js b/882-reachable-nodes-in-subdivided-graph.js
index b0e08400..f83ea6f7 100644
--- a/882-reachable-nodes-in-subdivided-graph.js
+++ b/882-reachable-nodes-in-subdivided-graph.js
@@ -199,6 +199,9 @@ class PriorityQueue {
 
 // another
 
+// time complexity: 
+// Dijkstra + Heap is O(E log E)
+// worst case: O(N ^ 2 * log (N ^ 2))
 /**
  * @param {number[][]} edges
  * @param {number} M

From 98490531c699b4214132060592c46ccc78cfb4f2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Mar 2022 15:10:28 +0800
Subject: [PATCH 1955/3374] Create 2215-find-the-difference-of-two-arrays.js

---
 2215-find-the-difference-of-two-arrays.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2215-find-the-difference-of-two-arrays.js

diff --git a/2215-find-the-difference-of-two-arrays.js b/2215-find-the-difference-of-two-arrays.js
new file mode 100644
index 00000000..07a46f8d
--- /dev/null
+++ b/2215-find-the-difference-of-two-arrays.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[][]}
+ */
+var findDifference = function(nums1, nums2) {
+  const set1 = new Set(nums1), set2 = new Set(nums2)
+  const res = [new Set(), new Set()]
+  for(let e of nums1) {
+    if(set2.has(e)) continue
+    else res[0].add(e)
+  }
+  for(let e of nums2) {
+    if(set1.has(e)) continue
+    else res[1].add(e)
+  }
+  res[0] = Array.from(res[0])
+  res[1] = Array.from(res[1])
+  return res
+};

From 1ac77bc062ae87825c6a8ba0cb8e27ac225de484 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Mar 2022 15:10:53 +0800
Subject: [PATCH 1956/3374] Create
 2216-minimum-deletions-to-make-array-beautiful.js

---
 ...inimum-deletions-to-make-array-beautiful.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2216-minimum-deletions-to-make-array-beautiful.js

diff --git a/2216-minimum-deletions-to-make-array-beautiful.js b/2216-minimum-deletions-to-make-array-beautiful.js
new file mode 100644
index 00000000..f53288d5
--- /dev/null
+++ b/2216-minimum-deletions-to-make-array-beautiful.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minDeletion = function(nums) {
+  let res = 0, i = 0
+  for(i = 0, n = nums.length; i < n - 1;) {
+    if(nums[i] === nums[i + 1]) {
+      res++
+      i++
+    }else{
+      i += 2
+    }
+  }
+  if((nums.length - res) % 2 === 1) res++
+  
+  return res
+};

From 658308f60060d9e22df67f228f7195f5b43dea13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Mar 2022 15:11:32 +0800
Subject: [PATCH 1957/3374] Create 2217-find-palindrome-with-fixed-length.js

---
 2217-find-palindrome-with-fixed-length.js | 45 +++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 2217-find-palindrome-with-fixed-length.js

diff --git a/2217-find-palindrome-with-fixed-length.js b/2217-find-palindrome-with-fixed-length.js
new file mode 100644
index 00000000..400bc1a3
--- /dev/null
+++ b/2217-find-palindrome-with-fixed-length.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} queries
+ * @param {number} intLength
+ * @return {number[]}
+ */
+var kthPalindrome = function(queries, intLength) {
+    if (intLength == 1) {
+        let res = []
+        for (let item of queries) {
+            if (item <= 9) res.push(item)
+            else res.push(-1)          
+        }
+        return res      
+    }
+
+    let n = Math.floor(intLength / 2)
+    let ref = +("1"+"0".repeat(n-1))
+
+    if (intLength % 2 == 0) {
+      let res = []
+      for (let item of queries) res.push(gen_even(item))
+      return res          
+    } else {
+      let res = []
+      for (let item of queries) res.push(gen_odd(item))
+      return res
+    }
+
+    function gen_even(val) {
+        let part = ref + val - 1
+        part = '' + part
+        if (part.length != n) return -1
+        return +(part + part.split('').reverse().join(''))          
+    }
+
+
+    function gen_odd(val) {
+        let mod = (val - 1) % 10
+        let div = Math.floor((val - 1) / 10)
+        let part = ref + div
+        mod = '' + mod, part = '' + part
+        if (part.length != n) return -1
+        return +(part + mod + part.split('').reverse().join(''))          
+    }
+};

From 44b7cd7b00dcd6f9eaff0b23d7c2c5f1bd41c36f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Mar 2022 15:12:00 +0800
Subject: [PATCH 1958/3374] Create 2218-maximum-value-of-k-coins-from-piles.js

---
 2218-maximum-value-of-k-coins-from-piles.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2218-maximum-value-of-k-coins-from-piles.js

diff --git a/2218-maximum-value-of-k-coins-from-piles.js b/2218-maximum-value-of-k-coins-from-piles.js
new file mode 100644
index 00000000..73b66dfe
--- /dev/null
+++ b/2218-maximum-value-of-k-coins-from-piles.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} piles
+ * @param {number} k
+ * @return {number}
+ */
+var maxValueOfCoins = function(piles, k) {
+    let dp = Array(k + 1).fill(0);
+    for (let i = 0; i < piles.length; i++) {
+      const next = Array(k + 1).fill(0);
+      for (let l = 1; l <= k; l++) {
+        let sum = 0;
+        next[l] = dp[l];
+        for (let j = 0; j < Math.min(piles[i].length, l); j++) {
+          sum += piles[i][j];
+          next[l] = Math.max(next[l], dp[l - j - 1] + sum);
+        }
+      }
+      dp = next;
+    }
+    return dp[k];    
+};

From ee3e5e00d1c156eddcdaaa03c66e5d4ac1999ca8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Mar 2022 15:42:20 +0800
Subject: [PATCH 1959/3374] Create 2188-minimum-time-to-finish-the-race.js

---
 2188-minimum-time-to-finish-the-race.js | 59 +++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 2188-minimum-time-to-finish-the-race.js

diff --git a/2188-minimum-time-to-finish-the-race.js b/2188-minimum-time-to-finish-the-race.js
new file mode 100644
index 00000000..a5870ebc
--- /dev/null
+++ b/2188-minimum-time-to-finish-the-race.js
@@ -0,0 +1,59 @@
+/**
+ * @param {number[][]} tires
+ * @param {number} changeTime
+ * @param {number} numLaps
+ * @return {number}
+ */
+ const minimumFinishTime = function (tires, changeTime, numLaps) {
+  tires = preprocess(tires)
+  let n = tires.length
+  const { max, min } = Math
+  // to handle the cases where numLaps is small
+  // pre[i][j]: the total time to run j laps consecutively with tire i
+  const pre = Array.from({ length: n }, () =>
+    Array(20).fill(Infinity)
+  )
+  for (let i = 0; i < n; i++) {
+    pre[i][1] = tires[i][0]
+    for (let j = 2; j < 20; j++) {
+      if (pre[i][j - 1] * tires[i][1] >= 2e9) break
+      pre[i][j] = pre[i][j - 1] * tires[i][1]
+    }
+    // since we define it as the total time, rather than just the time for the j-th lap
+    // we have to make it prefix sum
+    for (let j = 2; j < 20; j++) {
+      if (pre[i][j - 1] + pre[i][j] >= 2e9) break
+      pre[i][j] += pre[i][j - 1]
+    }
+  }
+
+  // dp[x]: the minimum time to finish x laps
+  const dp = Array(numLaps + 1).fill(Infinity)
+  for (let i = 0; i < n; i++) {
+    dp[1] = min(dp[1], tires[i][0])
+  }
+  for (let x = 1; x <= numLaps; x++) {
+    if (x < 20) {
+      // x is small enough, so an optimal solution might never changes tires!
+      for (let i = 0; i < n; i++) {
+        dp[x] = min(dp[x], pre[i][x])
+      }
+    }
+    for (let j = x - 1; j > 0 && j >= x - 18; j--) {
+      dp[x] = min(dp[x], dp[j] + changeTime + dp[x - j])
+    }
+  }
+
+  return dp[numLaps]
+}
+
+function preprocess(tires) {
+  tires.sort((a, b) => (a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]))
+  const res = []
+  for (let t of tires) {
+    if (res.length === 0 || res[res.length - 1][1] > t[1]) {
+      res.push(t)
+    }
+  }
+  return res
+}

From 295a39a4e7f9e2047ca9b936e0db113d5fe56ac6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Mar 2022 18:45:34 +0800
Subject: [PATCH 1960/3374] Update 2188-minimum-time-to-finish-the-race.js

---
 2188-minimum-time-to-finish-the-race.js | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/2188-minimum-time-to-finish-the-race.js b/2188-minimum-time-to-finish-the-race.js
index a5870ebc..2e995cff 100644
--- a/2188-minimum-time-to-finish-the-race.js
+++ b/2188-minimum-time-to-finish-the-race.js
@@ -57,3 +57,47 @@ function preprocess(tires) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} tires
+ * @param {number} changeTime
+ * @param {number} numLaps
+ * @return {number}
+ */
+var minimumFinishTime = function (tires, changeTime, numLaps) {
+  let N = tires.length,
+    len = 0
+  const { max, min } = Math
+  const best = Array(numLaps).fill(Infinity),
+    dp = Array(numLaps + 1).fill(Infinity)
+  for (let i = 0; i < N; ++i) {
+    // We assume we also need `changeTime` time to use the first tire
+    // so that we don't need to treat the first tire as a special case
+    let f = tires[i][0],
+      r = tires[i][1],
+      sum = changeTime,
+      p = 1
+    for (let j = 0; j < numLaps; ++j) {
+      sum += f * p
+      // If using the same tire takes no less time than changing the tire,
+      // stop further using the current tire
+      if (f * p >= f + changeTime) break 
+      best[j] = min(best[j], sum)
+      len = max(len, j + 1)
+      p *= r
+    }
+  }
+  // dp[i + 1] is the minimum time to finish `numLaps` laps
+  dp[0] = 0 
+  for (let i = 0; i < numLaps; ++i) {
+    for (let j = 0; j < len && i - j >= 0; ++j) {
+      // try using the same tire in the last `j+1` laps
+      dp[i + 1] = min(dp[i + 1], dp[i - j] + best[j])
+    }
+  }
+  // minus the `changeTime` we added to the first tire
+  return dp[numLaps] - changeTime 
+}
+

From db80dd52c3b13c93a181bcd5fe3120b04e0b852b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Mar 2022 09:45:11 +0800
Subject: [PATCH 1961/3374] Create
 2209-minimum-white-tiles-after-covering-with-carpets.js

---
 ...white-tiles-after-covering-with-carpets.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2209-minimum-white-tiles-after-covering-with-carpets.js

diff --git a/2209-minimum-white-tiles-after-covering-with-carpets.js b/2209-minimum-white-tiles-after-covering-with-carpets.js
new file mode 100644
index 00000000..a3176f97
--- /dev/null
+++ b/2209-minimum-white-tiles-after-covering-with-carpets.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} floor
+ * @param {number} numCarpets
+ * @param {number} carpetLen
+ * @return {number}
+ */
+const minimumWhiteTiles = function(floor, numCarpets, carpetLen) {
+  // 0: black, 1: white
+  const n = floor.length
+  // dp[i][j]: the minimum number of white tiles still visible
+  // when using j tiles to cover the first i tiles 
+  const dp = Array.from({ length: n + 1 }, () => Array(numCarpets + 1).fill(0))
+
+  for(let i = 1; i <= n; i++) {
+    for(let j = 0; j <= numCarpets; j++) {
+      const skip = dp[i - 1][j] + (floor[i - 1] === '1' ? 1 : 0)
+      const cover = j > 0 ? dp[Math.max(i - carpetLen, 0)][j - 1] : 1000
+      dp[i][j] = Math.min(skip, cover)
+    }
+  }
+
+  return dp[n][numCarpets]
+};

From d6a84aa171e84eba1ce9d64a79170f5a76eda780 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Mar 2022 09:53:54 +0800
Subject: [PATCH 1962/3374] Update
 2209-minimum-white-tiles-after-covering-with-carpets.js

---
 2209-minimum-white-tiles-after-covering-with-carpets.js | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/2209-minimum-white-tiles-after-covering-with-carpets.js b/2209-minimum-white-tiles-after-covering-with-carpets.js
index a3176f97..a964a6c8 100644
--- a/2209-minimum-white-tiles-after-covering-with-carpets.js
+++ b/2209-minimum-white-tiles-after-covering-with-carpets.js
@@ -11,10 +11,15 @@ const minimumWhiteTiles = function(floor, numCarpets, carpetLen) {
   // when using j tiles to cover the first i tiles 
   const dp = Array.from({ length: n + 1 }, () => Array(numCarpets + 1).fill(0))
 
+  const ones = Array(n + 1).fill(0)
   for(let i = 1; i <= n; i++) {
-    for(let j = 0; j <= numCarpets; j++) {
+    ones[i] = ones[i - 1] + (floor[i - 1] === '1' ? 1 : 0) 
+  }
+  for(let i = 1; i <= n; i++) {
+    dp[i][0] = ones[i]
+    for(let j = 1; j <= numCarpets; j++) {
       const skip = dp[i - 1][j] + (floor[i - 1] === '1' ? 1 : 0)
-      const cover = j > 0 ? dp[Math.max(i - carpetLen, 0)][j - 1] : 1000
+      const cover = dp[Math.max(i - carpetLen, 0)][j - 1]
       dp[i][j] = Math.min(skip, cover)
     }
   }

From 4dc7c3bc85d20e80e7e2e7005a86913423efeca2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Mar 2022 10:01:02 +0800
Subject: [PATCH 1963/3374] Update 2218-maximum-value-of-k-coins-from-piles.js

---
 2218-maximum-value-of-k-coins-from-piles.js | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/2218-maximum-value-of-k-coins-from-piles.js b/2218-maximum-value-of-k-coins-from-piles.js
index 73b66dfe..a31a94da 100644
--- a/2218-maximum-value-of-k-coins-from-piles.js
+++ b/2218-maximum-value-of-k-coins-from-piles.js
@@ -19,3 +19,29 @@ var maxValueOfCoins = function(piles, k) {
     }
     return dp[k];    
 };
+
+// another
+
+/**
+ * @param {number[][]} piles
+ * @param {number} k
+ * @return {number}
+ */
+const maxValueOfCoins = function(piles, k) {
+  const n = piles.length
+  const memo = Array.from({ length: n + 1 }, () => Array(k + 1).fill(null))
+  return helper(0, k)
+
+  function helper(i, k) {
+    if(k == 0 || i === n) return 0
+    if(memo[i][k] != null) return memo[i][k]
+    let res = helper(i + 1, k)
+    let cur = 0
+
+    for(let j = 0; j < Math.min(piles[i].length, k); j++) {
+      cur += piles[i][j]
+      res = Math.max(res, cur + helper(i + 1, k - j - 1))
+    }
+    return memo[i][k] = res
+  }
+};

From 89c8431e5cd84370aca9d746ac687a2f28977b89 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Mar 2022 11:08:49 +0800
Subject: [PATCH 1964/3374] Update 2218-maximum-value-of-k-coins-from-piles.js

---
 2218-maximum-value-of-k-coins-from-piles.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/2218-maximum-value-of-k-coins-from-piles.js b/2218-maximum-value-of-k-coins-from-piles.js
index a31a94da..26b960fa 100644
--- a/2218-maximum-value-of-k-coins-from-piles.js
+++ b/2218-maximum-value-of-k-coins-from-piles.js
@@ -32,6 +32,9 @@ const maxValueOfCoins = function(piles, k) {
   const memo = Array.from({ length: n + 1 }, () => Array(k + 1).fill(null))
   return helper(0, k)
 
+  // TC: O(n * m)
+  // n: length of piles
+  // m: sum(piles[i]), total elements of all piles
   function helper(i, k) {
     if(k == 0 || i === n) return 0
     if(memo[i][k] != null) return memo[i][k]

From 6b0a7f342a0efaf85524797d347ec45fda99d1bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Mar 2022 11:55:28 +0800
Subject: [PATCH 1965/3374] Update 2218-maximum-value-of-k-coins-from-piles.js

---
 2218-maximum-value-of-k-coins-from-piles.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/2218-maximum-value-of-k-coins-from-piles.js b/2218-maximum-value-of-k-coins-from-piles.js
index 26b960fa..10f29d22 100644
--- a/2218-maximum-value-of-k-coins-from-piles.js
+++ b/2218-maximum-value-of-k-coins-from-piles.js
@@ -32,7 +32,8 @@ const maxValueOfCoins = function(piles, k) {
   const memo = Array.from({ length: n + 1 }, () => Array(k + 1).fill(null))
   return helper(0, k)
 
-  // TC: O(n * m)
+  // TC: O(k * m)
+  // k: k
   // n: length of piles
   // m: sum(piles[i]), total elements of all piles
   function helper(i, k) {

From e948ebe4d01b1755484f2be4be0aebaeb6e45756 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Mar 2022 09:40:09 +0800
Subject: [PATCH 1966/3374] Create
 2189-number-of-ways-to-build-house-of-cards.js

---
 2189-number-of-ways-to-build-house-of-cards.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2189-number-of-ways-to-build-house-of-cards.js

diff --git a/2189-number-of-ways-to-build-house-of-cards.js b/2189-number-of-ways-to-build-house-of-cards.js
new file mode 100644
index 00000000..986c2152
--- /dev/null
+++ b/2189-number-of-ways-to-build-house-of-cards.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const houseOfCards = function(n) {
+  const memo = Array.from({ length: n + 1 }, () => Array(n + 2).fill(null))
+  return helper(n, n + 1)
+  
+  function helper(remain, preRow) {
+    if(remain === 0 || remain === 2) return 1
+    if(memo[remain][preRow] != null) return memo[remain][preRow]
+    let res = 0
+    for(let i = 5; i <= remain && i < preRow; i += 3) {
+      res += helper(remain - i, i)
+    }
+    return memo[remain][preRow] = res
+  }
+};

From d1c8f76a88ec3f2e8e8d38093e7e08e46fdb9ffa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Apr 2022 10:49:39 +0800
Subject: [PATCH 1967/3374] Update 479-largest-palindrome-product.js

---
 479-largest-palindrome-product.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/479-largest-palindrome-product.js b/479-largest-palindrome-product.js
index 43fb57ef..429c8aa4 100644
--- a/479-largest-palindrome-product.js
+++ b/479-largest-palindrome-product.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+function largestPalindrome(n) {
+  if(n === 1) return 9
+  let max = BigInt(10 ** n - 1), min = max / 10n + 1n
+  for(let h = max; h >= min; h--) {
+    let left = h, right = 0n
+    for(let i = h; i !== 0n; ) {
+      right = right * 10n + i % 10n
+      i = i / 10n
+      left *= 10n
+    }
+    let pal = left + right
+    for(let i = max; i >= min; i--) {
+      let j = pal / i
+      if(j > i) break
+      if(pal % i === 0n) return pal % 1337n
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 6e33cab422e22044cd38ee321f27376402b1dd67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Apr 2022 15:14:09 +0800
Subject: [PATCH 1968/3374] Update 866-prime-palindrome.js

---
 866-prime-palindrome.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/866-prime-palindrome.js b/866-prime-palindrome.js
index 1b2652f4..78d70c50 100644
--- a/866-prime-palindrome.js
+++ b/866-prime-palindrome.js
@@ -44,3 +44,30 @@ function isPrime(x) {
   }
   return true
 }
+
+// another
+
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const primePalindrome = function(n) {
+  if(n >= 8 && n <= 11) return 11
+
+  const rev = num => `${num}`.split('').reverse().join('')
+  for(let i = 1; i < 1e5; i++) {
+    let left = i, right = rev(left).slice(1)
+    const tmp = +(left + right)
+    if(tmp >= n && isPrime(tmp)) return tmp
+  }
+
+  function isPrime(num) {
+    if(num <= 2) return num === 2
+    if(num % 2 === 0) return false
+    for(let i = 3; i ** 2 <= num; i += 2) {
+      if(num % i === 0) return false
+    }
+    return true
+  }
+};

From e7c6e75d0561f6cd679ad02a241d93e77413b404 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Apr 2022 21:57:32 +0800
Subject: [PATCH 1969/3374] Create
 2224-minimum-number-of-operations-to-convert-time.js

---
 ...um-number-of-operations-to-convert-time.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 2224-minimum-number-of-operations-to-convert-time.js

diff --git a/2224-minimum-number-of-operations-to-convert-time.js b/2224-minimum-number-of-operations-to-convert-time.js
new file mode 100644
index 00000000..6b25bb4b
--- /dev/null
+++ b/2224-minimum-number-of-operations-to-convert-time.js
@@ -0,0 +1,41 @@
+/**
+ * @param {string} current
+ * @param {string} correct
+ * @return {number}
+ */
+var convertTime = function(current, correct) {
+  const s = current.split(':').map(e => +e)
+  const t = correct.split(':').map(e => +e)
+  let res = 0
+  // hour
+  if(s[0] < t[0]) res += t[0] - s[0]
+  else if(s[0] > t[0]) res += (24 - (s[0] - t[0]))
+  
+  // min
+  let delta = t[1] - s[1]
+  if(delta > 0) {
+    if(delta >= 15) {
+      res += ~~(delta / 15)
+      delta %= 15
+    }
+    if(delta >= 5) {
+      res += ~~(delta / 5)
+      delta %= 5
+    }
+    res += delta
+  } else if(delta < 0) {
+    res--
+    delta += 60
+    if(delta >= 15) {
+      res += ~~(delta / 15)
+      delta %= 15
+    }
+    if(delta >= 5) {
+      res += ~~(delta / 5)
+      delta %= 5
+    }
+    res += delta
+  }
+  
+  return res
+};

From ab40986e1e98cd0e1167008b53e5ed19cc60d081 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Apr 2022 21:59:39 +0800
Subject: [PATCH 1970/3374] Create 2225-find-players-with-zero-or-one-losses.js

---
 2225-find-players-with-zero-or-one-losses.js | 29 ++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2225-find-players-with-zero-or-one-losses.js

diff --git a/2225-find-players-with-zero-or-one-losses.js b/2225-find-players-with-zero-or-one-losses.js
new file mode 100644
index 00000000..7023be33
--- /dev/null
+++ b/2225-find-players-with-zero-or-one-losses.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} matches
+ * @return {number[][]}
+ */
+var findWinners = function(matches) {
+    const win = {}, lose = {}, total = new Set(), ls = new Set()
+    for(const [w, l] of matches) {
+      if(win[w] == null) win[w] = 0
+      win[w]++
+      if(lose[l] == null) lose[l] = 0
+      lose[l]++
+      total.add(l)
+      total.add(w)
+      ls.add(l)
+    }
+  
+    const loseKeys = Object.keys(lose)
+    const a0 = []
+    for(const e of total) {
+      if(!ls.has(e)) a0.push(e)
+    }
+    const a1 = []
+    for(const e of loseKeys) {
+      if(lose[e] === 1) a1.push(e)
+    }
+    a0.sort((a, b) => a - b)
+    a1.sort((a, b) => a - b)
+    return [a0, a1]
+};

From ca7645b1618b8500ada7d89ef5e090ab2b72dc1c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Apr 2022 22:03:48 +0800
Subject: [PATCH 1971/3374] Create
 2226-maximum-candies-allocated-to-k-children.js

---
 ...maximum-candies-allocated-to-k-children.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2226-maximum-candies-allocated-to-k-children.js

diff --git a/2226-maximum-candies-allocated-to-k-children.js b/2226-maximum-candies-allocated-to-k-children.js
new file mode 100644
index 00000000..b744dc71
--- /dev/null
+++ b/2226-maximum-candies-allocated-to-k-children.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} candies
+ * @param {number} k
+ * @return {number}
+ */
+const maximumCandies = function(candies, k) {
+  let max = 1e12;
+  let min = 0;
+  while (min != max) {
+    let mid = ~~((min + max + 1) / 2);
+    let cnt = 0;
+    for (let cand of candies) {
+      cnt += ~~(cand / mid);
+    }pnjj
+    if (cnt < k) {
+      max = mid - 1;
+    } else {
+      min = mid;
+    }
+  }
+  return min;
+};

From 11eec63a7199f7470b3d808e5b65c762699ce155 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Apr 2022 22:34:24 +0800
Subject: [PATCH 1972/3374] Update
 2226-maximum-candies-allocated-to-k-children.js

---
 2226-maximum-candies-allocated-to-k-children.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/2226-maximum-candies-allocated-to-k-children.js b/2226-maximum-candies-allocated-to-k-children.js
index b744dc71..51a205b3 100644
--- a/2226-maximum-candies-allocated-to-k-children.js
+++ b/2226-maximum-candies-allocated-to-k-children.js
@@ -4,14 +4,14 @@
  * @return {number}
  */
 const maximumCandies = function(candies, k) {
-  let max = 1e12;
+  let max = candies.reduce((ac, e) => ac + e, 0);
   let min = 0;
-  while (min != max) {
-    let mid = ~~((min + max + 1) / 2);
+  while (min < max) {
+    let mid = max - Math.floor((max - min) / 2);
     let cnt = 0;
     for (let cand of candies) {
       cnt += ~~(cand / mid);
-    }pnjj
+    }
     if (cnt < k) {
       max = mid - 1;
     } else {

From fed23952182bd47c354582290051e13bf8358a5e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Apr 2022 20:05:52 +0800
Subject: [PATCH 1973/3374] Create 2223-sum-of-scores-of-built-strings.js

---
 2223-sum-of-scores-of-built-strings.js | 28 ++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2223-sum-of-scores-of-built-strings.js

diff --git a/2223-sum-of-scores-of-built-strings.js b/2223-sum-of-scores-of-built-strings.js
new file mode 100644
index 00000000..18cc57f1
--- /dev/null
+++ b/2223-sum-of-scores-of-built-strings.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var sumScores = function(s) {
+  function z_function(s) {
+      let n = s.length
+      let z = Array(n).fill(0)
+      let l = 0, r = 0
+      for (let i = 1; i < n; i++) {
+          if (i <= r) z[i] = Math.min(r - i + 1, z[i - l])
+          while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
+              z[i] += 1                  
+          }
+
+          if (i + z[i] - 1 > r) {
+              l = i
+              r = i + z[i] - 1                  
+          }
+
+      }
+      return z          
+  }
+
+  const sum = z_function(s).reduce((ac, e) => ac + e, 0)
+  return sum + s.length  
+};
+ 

From 2927963c744ef0726c47f7209d2832d217959733 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Apr 2022 22:19:32 +0800
Subject: [PATCH 1974/3374] Update
 2226-maximum-candies-allocated-to-k-children.js

---
 ...maximum-candies-allocated-to-k-children.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/2226-maximum-candies-allocated-to-k-children.js b/2226-maximum-candies-allocated-to-k-children.js
index 51a205b3..38ed2088 100644
--- a/2226-maximum-candies-allocated-to-k-children.js
+++ b/2226-maximum-candies-allocated-to-k-children.js
@@ -20,3 +20,23 @@ const maximumCandies = function(candies, k) {
   }
   return min;
 };
+
+// another
+
+/**
+ * @param {number[]} candies
+ * @param {number} k
+ * @return {number}
+ */
+const maximumCandies = function(candies, k) {
+  let max = candies.reduce((ac, e) => ac + e, 0)
+  let min = 0
+  while(min < max) {
+    const mid = max - Math.floor((max - min) /2)
+    let num = 0
+    for(let e of candies) num += ~~(e / mid)
+    if(num < k) max = mid - 1
+    else min = mid
+  }
+  return min
+};

From e4b35875c5b31b8d751611079f3c7517678f1c24 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Apr 2022 13:06:53 +0800
Subject: [PATCH 1975/3374] Create
 1011-capacity-to-ship-packages-within-d-days.js

---
 ...capacity-to-ship-packages-within-d-days.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1011-capacity-to-ship-packages-within-d-days.js

diff --git a/1011-capacity-to-ship-packages-within-d-days.js b/1011-capacity-to-ship-packages-within-d-days.js
new file mode 100644
index 00000000..86b274e7
--- /dev/null
+++ b/1011-capacity-to-ship-packages-within-d-days.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} weights
+ * @param {number} days
+ * @return {number}
+ */
+const shipWithinDays = function(weights, days) {
+  let l = Math.max(...weights)
+  let r = weights.reduce((ac, e) => ac + e, 0)
+  while(l < r) {
+     const mid = Math.floor((l + r) / 2)
+     if(valid(mid)) {
+       r = mid
+     } else l = mid + 1
+  }
+  
+  return l
+  
+  function valid(mid) {
+    let res = 1, cur = 0
+    for(let w of weights) {
+      if(cur + w > mid) {
+        cur = 0
+        res++
+      }
+      cur += w
+    }
+    return res <= days
+  }
+};

From d7f68737eb07fbb34c592cad49edd8f435aeac66 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Apr 2022 20:16:10 +0800
Subject: [PATCH 1976/3374] Create 1891-cutting-ribbons.js

---
 1891-cutting-ribbons.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1891-cutting-ribbons.js

diff --git a/1891-cutting-ribbons.js b/1891-cutting-ribbons.js
new file mode 100644
index 00000000..23cd8b8c
--- /dev/null
+++ b/1891-cutting-ribbons.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} ribbons
+ * @param {number} k
+ * @return {number}
+ */
+const maxLength = function(ribbons, k) {
+  let l = 0, r = Math.max(...ribbons)
+  while(l < r) {
+    const mid = r - Math.floor((r - l) / 2)
+    if(valid(mid)) {
+      l = mid
+    } else r = mid - 1
+  }
+  return l
+  
+  function valid(mid) {
+    let res = 0
+    for(let e of ribbons) {
+      res += ~~(e / mid)
+    }
+    return res >= k
+  }
+};

From 26530bc1436d35a1abdd16c15e4a4c0d3573d63e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Apr 2022 16:00:03 +0800
Subject: [PATCH 1977/3374] Update
 1608-special-array-with-x-elements-greater-than-or-equal-x.js

---
 ...with-x-elements-greater-than-or-equal-x.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1608-special-array-with-x-elements-greater-than-or-equal-x.js b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
index b9b51023..9866bd82 100644
--- a/1608-special-array-with-x-elements-greater-than-or-equal-x.js
+++ b/1608-special-array-with-x-elements-greater-than-or-equal-x.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const specialArray = function(nums) {
+  let l = -1, r = 1001
+  while(l <= r) {
+    const mid = r - Math.floor((r - l) / 2)
+    const tmp = valid(mid)
+    if(tmp === mid) return mid
+    else if(tmp > mid) l = mid + 1
+    else r = mid - 1
+  }
+  return -1
+  
+  function valid(mid) {
+    let res = 0
+    for(let e of nums) {
+      if(e >= mid) res++
+    }
+    return res
+  }
+};
+
+// another 
+
 /**
  * @param {number[]} nums
  * @return {number}

From 73847e3906cfe4fe2ecf317fccdcc052d22a0229 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Apr 2022 23:37:57 +0800
Subject: [PATCH 1978/3374] Create
 1283-find-the-smallest-divisor-given-a-threshold.js

---
 ...-the-smallest-divisor-given-a-threshold.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1283-find-the-smallest-divisor-given-a-threshold.js

diff --git a/1283-find-the-smallest-divisor-given-a-threshold.js b/1283-find-the-smallest-divisor-given-a-threshold.js
new file mode 100644
index 00000000..09a7a187
--- /dev/null
+++ b/1283-find-the-smallest-divisor-given-a-threshold.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} threshold
+ * @return {number}
+ */
+const smallestDivisor = function(nums, threshold) {
+  let l = 1, r = 1e6
+  while(l < r) {
+    const mid = l + Math.floor((r - l) / 2)
+    if(valid(mid)) r = mid
+    else l = mid + 1
+  }
+  return l
+  
+  function valid(mid) {
+    let res = 0
+    for(let e of nums) res += Math.ceil(e / mid)
+    return res <= threshold
+  }
+};

From 5af003430e64684b5985f22a99fbb301d380cec8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Apr 2022 16:50:03 +0800
Subject: [PATCH 1979/3374] Create
 2246-longest-path-with-different-adjacent-characters.js

---
 ...path-with-different-adjacent-characters.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2246-longest-path-with-different-adjacent-characters.js

diff --git a/2246-longest-path-with-different-adjacent-characters.js b/2246-longest-path-with-different-adjacent-characters.js
new file mode 100644
index 00000000..62fbe3a2
--- /dev/null
+++ b/2246-longest-path-with-different-adjacent-characters.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} parent
+ * @param {string} s
+ * @return {number}
+ */
+var longestPath = function(parent, s) {
+    let n = s.length, res = 0;
+    const {max} = Math
+    let children = Array.from({ length: n}, () => Array());
+    for (let i = 1; i < n; ++i) children[parent[i]].push(i);
+    dfs(children, s, 0);
+    return res;
+  
+    function dfs(children, s, i) {
+      let big1 = 0, big2 = 0;
+      for (let j of (children[i] || [])) {
+        let cur = dfs(children, s, j);
+        if (s[i] == s[j]) continue;
+        if (cur > big2) big2 = cur;
+        if (big2 > big1) {
+          let tmp = big1
+          big1 = big2
+          big2 = tmp
+        };
+      }
+      res = max(res, big1 + big2 + 1);
+      return big1 + 1;
+    }  
+};
+
+

From 3a1665dbad3f68113c06ac5702638c0b93344049 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Apr 2022 16:51:02 +0800
Subject: [PATCH 1980/3374] Create
 2245-maximum-trailing-zeros-in-a-cornered-path.js

---
 ...ximum-trailing-zeros-in-a-cornered-path.js | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 2245-maximum-trailing-zeros-in-a-cornered-path.js

diff --git a/2245-maximum-trailing-zeros-in-a-cornered-path.js b/2245-maximum-trailing-zeros-in-a-cornered-path.js
new file mode 100644
index 00000000..b2004bcb
--- /dev/null
+++ b/2245-maximum-trailing-zeros-in-a-cornered-path.js
@@ -0,0 +1,57 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maxTrailingZeros = function(grid) {
+    const g = grid
+    const m = g.length;
+    const n = g[0].length;
+    const ta = [...Array(m)].map(i => Array(n).fill(1));
+    const tb = [...Array(m)].map(i => Array(n).fill(1));
+    const tc = [...Array(m)].map(i => Array(n).fill(1));
+    const td = [...Array(m)].map(i => Array(n).fill(1));
+    
+    const c52 = (s) => {
+        let c5 = 0;
+        let c2 = 0;
+        while (s % 2 === 0) {
+            s = s / 2;
+            c2++;
+        }
+        while (s % 5 === 0) {
+            s = s / 5;
+            c5++;
+        }
+        return [c5, c2];
+    }
+    
+    const c10 = ([c5, c2]) => {
+        return Math.min(c5, c2);
+    }
+    
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            ta[i][j] = (j === 0) ? c52(g[i][j]) : [c52(g[i][j])[0] + ta[i][j-1][0], c52(g[i][j])[1] + ta[i][j-1][1]];
+            tb[i][j] = (i === 0) ? c52(g[i][j]) :  [c52(g[i][j])[0] + tb[i-1][j][0], c52(g[i][j])[1] + tb[i-1][j][1]];
+        }
+    }
+    
+    for (let i = m-1; i >= 0; i--) {
+        for (let j = n-1; j >= 0; j--) {
+            tc[i][j] = (j === n-1) ? c52(g[i][j]) : [c52(g[i][j])[0] + tc[i][j+1][0], c52(g[i][j])[1] + tc[i][j+1][1]];  // : ctz(hg(g[i][j]) * tc[i][j+1][0], tc[i][j+1][1]); // hg(g[i][j]) * tc[i][j+1];
+            td[i][j] = (i === m-1) ? c52(g[i][j]) : [c52(g[i][j])[0] + td[i+1][j][0], c52(g[i][j])[1] + td[i+1][j][1]]; // : ctz(hg(g[i][j]) * td[i+1][j][0], td[i+1][j][1]); // hg(g[i][j]) * td[i+1][j];
+        }
+    }
+    
+    let ret = 0;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            let s1 = i === 0 ? c10(ta[i][j]) : c10([ta[i][j][0] + tb[i-1][j][0], ta[i][j][1] + tb[i-1][j][1]]);
+            let s2 = i === m - 1 ? c10(ta[i][j]) : c10([ta[i][j][0] + td[i+1][j][0], ta[i][j][1] + td[i+1][j][1]]);            
+            let s3 = i === 0 ? c10(tc[i][j]) : c10([tc[i][j][0] + tb[i-1][j][0], tc[i][j][1] + tb[i-1][j][1]]);
+            let s4 = i === m - 1 ? c10(tc[i][j]) : c10([tc[i][j][0] + td[i+1][j][0], tc[i][j][1] + td[i+1][j][1]]); 
+            ret = Math.max(ret, s1, s2, s3, s4);
+        }
+    }
+    return ret;
+};

From 114e7056929ef229d31cedf9eb50ea0e1c2fcd60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Apr 2022 16:51:30 +0800
Subject: [PATCH 1981/3374] Create 2244-minimum-rounds-to-complete-all-tasks.js

---
 2244-minimum-rounds-to-complete-all-tasks.js | 23 ++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2244-minimum-rounds-to-complete-all-tasks.js

diff --git a/2244-minimum-rounds-to-complete-all-tasks.js b/2244-minimum-rounds-to-complete-all-tasks.js
new file mode 100644
index 00000000..102e1e54
--- /dev/null
+++ b/2244-minimum-rounds-to-complete-all-tasks.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} tasks
+ * @return {number}
+ */
+const minimumRounds = function(tasks) {
+  let res = 0
+  const hash = {}
+  for(let e of tasks) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+  }
+  const keys = Object.keys(hash).map(e => +e)
+  for(const k of keys) {
+    if(hash[k] / 3 >= 1) res += ~~(hash[k] / 3)
+    if(hash[k] % 3 === 2) res++
+    if(hash[k] % 3 === 1) {
+      if(hash[k] >= 4) res++
+      else return -1
+    }
+  }
+  
+  return res
+};

From 80370942bd632a63df7b406114a33bb463e62365 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Apr 2022 16:52:13 +0800
Subject: [PATCH 1982/3374] Create 2243-calculate-digit-sum-of-a-string.js

---
 2243-calculate-digit-sum-of-a-string.js | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2243-calculate-digit-sum-of-a-string.js

diff --git a/2243-calculate-digit-sum-of-a-string.js b/2243-calculate-digit-sum-of-a-string.js
new file mode 100644
index 00000000..f322e42c
--- /dev/null
+++ b/2243-calculate-digit-sum-of-a-string.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const digitSum = function(s, k) {
+  let cur = s
+  while(cur.length > k) {
+    const arr = []
+    for(let i = 0; i < cur.length; i += k) {
+      let tmp = ''
+      for(let j = 0; j < k && i + j < cur.length; j++) {
+        tmp += cur[i + j]
+      }
+      arr.push(tmp)
+    }
+    arr.forEach((e, i) => {
+      let res = 0
+      for(let ch of e) res += +ch
+      arr[i] = '' +res
+    })
+    cur = arr.join('')
+    
+  }
+  return cur
+};

From 7adf7e40006e58db77293b8d817baa266269f6e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Apr 2022 20:58:42 +0800
Subject: [PATCH 1983/3374] Create
 1300-sum-of-mutated-array-closest-to-target.js

---
 ...-sum-of-mutated-array-closest-to-target.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1300-sum-of-mutated-array-closest-to-target.js

diff --git a/1300-sum-of-mutated-array-closest-to-target.js b/1300-sum-of-mutated-array-closest-to-target.js
new file mode 100644
index 00000000..dd4a35f3
--- /dev/null
+++ b/1300-sum-of-mutated-array-closest-to-target.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} arr
+ * @param {number} target
+ * @return {number}
+ */
+const findBestValue = function(arr, target) {
+  let l, r, mi, s = 0, m = -1;
+  for(let v of arr) { s += v; m = Math.max(m, v); }
+  if(s <= target) return m; 
+
+  for(l = 1, r = m; l < r;) {
+    mi = ~~((l+r)/2);
+    s = 0;
+    for(let v of arr) s += (v > mi) ? mi : v;
+    if(s >= target) r = mi;
+    else          l = mi + 1;
+  }
+  // check if we are 1 step off the target 
+  let s1=0,s2=0;
+  for(let v of arr) {
+    s1 += (v>l)?(l):v;
+    s2 += (v>l-1)?(l-1):v;
+  }
+
+  return (Math.abs(s2-target) <= Math.abs(s1-target)) ? l-1 : l;
+};

From bdc4cdbfe4143f6d1707a74d092218ebb40e00be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Apr 2022 10:21:09 +0800
Subject: [PATCH 1984/3374] Update 1870-minimum-speed-to-arrive-on-time.js

---
 1870-minimum-speed-to-arrive-on-time.js | 27 +++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1870-minimum-speed-to-arrive-on-time.js b/1870-minimum-speed-to-arrive-on-time.js
index df7be0e5..9eebca9b 100644
--- a/1870-minimum-speed-to-arrive-on-time.js
+++ b/1870-minimum-speed-to-arrive-on-time.js
@@ -73,3 +73,30 @@ const minSpeedOnTime = function(dist, hour) {
   
 };
 
+// another
+
+/**
+ * @param {number[]} dist
+ * @param {number} hour
+ * @return {number}
+ */
+const minSpeedOnTime = function(dist, hour) {
+   let l = 1, r = 1e7
+   while(l < r) {
+     const mid = l + Math.floor((r - l) / 2)
+     if(!valid(mid)) l = mid + 1
+     else r = mid
+   }
+   // console.log(l)
+  return valid(l) ? l : -1
+  
+  function valid(mid) {
+    let res = 0
+    for(let i = 0, n = dist.length; i < n; i++) {
+      const d = dist[i] 
+      res += (i === n - 1 ? d / mid : Math.ceil(d / mid))
+    }
+    return res <= hour
+  }
+};
+

From 741ad74273f77801d84ec77722a63fa8e3fd5a85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Apr 2022 20:48:43 +0800
Subject: [PATCH 1985/3374] Create
 1292-maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold.js

---
 ...ith-sum-less-than-or-equal-to-threshold.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1292-maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold.js

diff --git a/1292-maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold.js b/1292-maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold.js
new file mode 100644
index 00000000..6e3157ba
--- /dev/null
+++ b/1292-maximum-side-length-of-a-square-with-sum-less-than-or-equal-to-threshold.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} threshold
+ * @return {number}
+ */
+const maxSideLength = function (mat, threshold) {
+  let m = mat.length
+  let n = mat[0].length
+  const sum = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+
+  let res = 0
+  let len = 1 // square side length
+
+  for (let i = 1; i <= m; i++) {
+    for (let j = 1; j <= n; j++) {
+      sum[i][j] =
+        sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1] + mat[i - 1][j - 1]
+
+      if (
+        i >= len &&
+        j >= len &&
+        sum[i][j] - sum[i - len][j] - sum[i][j - len] + sum[i - len][j - len] <=
+          threshold
+      )
+        res = len++
+    }
+  }
+
+  return res
+}

From 02f6470bd762036cf39cb1b163df79b7f09bc777 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Apr 2022 15:41:11 +0800
Subject: [PATCH 1986/3374] Update
 2064-minimized-maximum-of-products-distributed-to-any-store.js

---
 ...um-of-products-distributed-to-any-store.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/2064-minimized-maximum-of-products-distributed-to-any-store.js b/2064-minimized-maximum-of-products-distributed-to-any-store.js
index ac753600..577fe013 100644
--- a/2064-minimized-maximum-of-products-distributed-to-any-store.js
+++ b/2064-minimized-maximum-of-products-distributed-to-any-store.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number} n
+ * @param {number[]} quantities
+ * @return {number}
+ */
+const minimizedMaximum = function(n, quantities) {
+  const m = quantities.length
+  let l = 0, r = Math.max(...quantities)
+  while(l < r) {
+    const mid = l + Math.floor((r - l) / 2)
+    if(valid(mid)) r = mid
+    else l = mid + 1
+  }
+  
+  return l
+
+  function valid(mid) {
+    if(m > n) return false
+    let res = 0
+    for (let i = 0; i < m; i++) {
+      res += Math.ceil(quantities[i] / mid)
+    }
+    return res <= n
+  }
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[]} quantities

From d7c576171c3f0dc4244e9d46800d1780fba850fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Apr 2022 14:30:13 +0800
Subject: [PATCH 1987/3374] Update
 1898-maximum-number-of-removable-characters.js

---
 ...-maximum-number-of-removable-characters.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1898-maximum-number-of-removable-characters.js b/1898-maximum-number-of-removable-characters.js
index 77c297ac..043796cc 100644
--- a/1898-maximum-number-of-removable-characters.js
+++ b/1898-maximum-number-of-removable-characters.js
@@ -32,3 +32,34 @@ function is_valid(s, p, removable, cnt) {
   }
   return ind2 == len2
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {string} p
+ * @param {number[]} removable
+ * @return {number}
+ */
+const maximumRemovals = function(s, p, removable) {
+  let l = 0, r = removable.length
+  while(l < r) {
+    const mid = r - Math.floor((r - l) / 2)
+    if(valid(mid)) l = mid
+    else r = mid - 1
+  }
+  return l
+  
+  function valid(mid) {
+    let arr = s.split('')
+    for (let i = 0; i < mid; i++) arr[removable[i]] = null
+    arr = arr.filter(e => e !== null)
+    
+    for(let i = 0, j = 0; i < arr.length && j < p.length;) {
+      if(arr[i] === p[j]) i++, j++
+      else i++
+      if(j === p.length) return true
+    }
+    return false
+  }
+};

From 89403f4013e563b38a4f03018e9c12358c9e2695 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Apr 2022 09:36:54 +0800
Subject: [PATCH 1988/3374] Create 1552-magnetic-force-between-two-balls.js

---
 1552-magnetic-force-between-two-balls.js | 34 ++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1552-magnetic-force-between-two-balls.js

diff --git a/1552-magnetic-force-between-two-balls.js b/1552-magnetic-force-between-two-balls.js
new file mode 100644
index 00000000..8596a31a
--- /dev/null
+++ b/1552-magnetic-force-between-two-balls.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} position
+ * @param {number} m
+ * @return {number}
+ */
+const maxDistance = function(position, m) {
+  position.sort((a, b) => a - b)
+  const n = position.length
+  let l = Infinity, r = 1
+  for (let i = 1; i < n; i++) {
+    if (position[i] - position[i - 1] < l) l = position[i] - position[i - 1]
+  }
+  r = position[n - 1] - position[0]
+  while(l < r) {
+    const mid = r - Math.floor((r - l) / 2)
+    if(valid(mid)) l = mid
+    else r = mid - 1
+  }
+  return l
+
+  function valid(mid) {
+    let res = 1, cur = 0
+    for (let i = 1; i < n; i++) {
+      const delta = position[i] - position[i - 1]
+      cur += delta
+      if (cur >= mid) {
+        res++
+        cur = 0
+      }
+      if(res === m) return true
+    }
+    return false
+  }
+};

From d481da81ff4c3218995be5df090465f3f00aada5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Apr 2022 21:38:44 +0800
Subject: [PATCH 1989/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...lue-at-a-given-index-in-a-bounded-array.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index 8788b9cf..d9243f96 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} index
+ * @param {number} maxSum
+ * @return {number}
+ */
+const maxValue = function (n, index, maxSum) {
+  maxSum -= n;
+  let left = 0, right = maxSum, mid;
+  while (left < right) {
+      mid = Math.floor((left + right + 1) / 2);
+      if (v2(mid) <= maxSum)left = mid;
+      else right = mid - 1;
+  }
+  return left + 1;
+  
+  function v2(a) {
+    let b = Math.max(a - index, 0);
+    let res = (a + b) * (a - b + 1) / 2;
+    b = Math.max(a - ((n - 1) - index), 0);
+    res += (a + b) * (a - b + 1) / 2;
+    return res - a;
+  }
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number} index

From be10a57c9a4c6f2815771f3b021c3c45dbe02daa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Apr 2022 22:02:40 +0800
Subject: [PATCH 1990/3374] Update
 1802-maximum-value-at-a-given-index-in-a-bounded-array.js

---
 ...alue-at-a-given-index-in-a-bounded-array.js | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
index d9243f96..64d18833 100644
--- a/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
+++ b/1802-maximum-value-at-a-given-index-in-a-bounded-array.js
@@ -8,18 +8,18 @@ const maxValue = function (n, index, maxSum) {
   maxSum -= n;
   let left = 0, right = maxSum, mid;
   while (left < right) {
-      mid = Math.floor((left + right + 1) / 2);
-      if (v2(mid) <= maxSum)left = mid;
-      else right = mid - 1;
+    const mid = right - Math.floor((right - left) / 2);
+    if (valid(mid))left = mid;
+    else right = mid - 1;
   }
   return left + 1;
   
-  function v2(a) {
-    let b = Math.max(a - index, 0);
-    let res = (a + b) * (a - b + 1) / 2;
-    b = Math.max(a - ((n - 1) - index), 0);
-    res += (a + b) * (a - b + 1) / 2;
-    return res - a;
+  function valid(mid) {
+    let b = Math.max(mid - index, 0);
+    let res = (mid + b) * (mid - b + 1) / 2;
+    b = Math.max(mid - ((n - 1) - index), 0);
+    res += (mid + b) * (mid - b + 1) / 2;
+    return res - mid <= maxSum;
   }
 }
 

From 68da763a38858c296adf763000169bf5d92d9d15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Apr 2022 09:14:27 +0800
Subject: [PATCH 1991/3374] Create
 1482-minimum-number-of-days-to-make-m-bouquets.js

---
 ...nimum-number-of-days-to-make-m-bouquets.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 1482-minimum-number-of-days-to-make-m-bouquets.js

diff --git a/1482-minimum-number-of-days-to-make-m-bouquets.js b/1482-minimum-number-of-days-to-make-m-bouquets.js
new file mode 100644
index 00000000..15c4c10c
--- /dev/null
+++ b/1482-minimum-number-of-days-to-make-m-bouquets.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} bloomDay
+ * @param {number} m
+ * @param {number} k
+ * @return {number}
+ */
+const minDays = function(bloomDay, m, k) {
+  const n = bloomDay.length
+  let l = -1, r = Math.max(...bloomDay)
+  while(l < r) {
+    const mid = l + Math.floor((r - l) / 2)
+    if(valid(mid)) r = mid
+    else l = mid + 1
+  }
+  return valid(l) ? l : -1
+
+  function valid(mid) {
+    let res = 0, cur = 0
+    for (let i = 0; i < n; i++) {
+      const e = bloomDay[i]
+      if(e <= mid) {
+        cur++
+        if(cur >= k) {
+          res++
+          cur = 0
+        }
+      } else {
+        cur = 0
+      }
+    }
+    return res >= m
+  }
+};

From 1eb89d4b4a2a599ce3f85ddf156c5ff8e70b0cb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Apr 2022 13:38:34 +0800
Subject: [PATCH 1992/3374] Create
 2250-count-number-of-rectangles-containing-each-point.js

---
 ...ber-of-rectangles-containing-each-point.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 2250-count-number-of-rectangles-containing-each-point.js

diff --git a/2250-count-number-of-rectangles-containing-each-point.js b/2250-count-number-of-rectangles-containing-each-point.js
new file mode 100644
index 00000000..bd1e3a91
--- /dev/null
+++ b/2250-count-number-of-rectangles-containing-each-point.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[][]} rectangles
+ * @param {number[][]} points
+ * @return {number[]}
+ */
+function countRectangles(rect, points) {
+  const hash = {}
+  for(let [y, x] of rect) {
+    if(hash[x] == null) hash[x] = []
+    hash[x].push(y)
+  }
+  const keys = Object.keys(hash).map(e => +e)
+  for(const k of keys) {
+    hash[k].sort((a, b) => a - b)
+  }
+  keys.sort((a, b) => a - b)
+  const res = []
+  const n = keys.length
+  // console.log(keys, hash)
+  for(const [y, x] of points) {
+    let v = 0
+    const idx = helper(keys, x)
+    for(let i = idx; i < n; i++) {
+      const k = keys[i]
+      const p = helper(hash[k], y)
+      v += p === hash[k].length ? 0 : hash[k].length - p
+    }
+    res.push(v)
+  }
+
+  return res
+
+  function helper(arr, val) {
+    let l = 0, r = arr.length
+    while(l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if(valid(mid)) r = mid
+      else l = mid + 1
+    }
+    // console.log(arr, val, l)
+    return l
+
+    function valid(mid) {
+      return arr[mid] >= val
+    }
+  }
+}

From d4e2bdafe962dc11d721cc11389d3119853cabd6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Apr 2022 14:55:08 +0800
Subject: [PATCH 1993/3374] Create 2251-number-of-flowers-in-full-bloom.js

---
 2251-number-of-flowers-in-full-bloom.js | 27 +++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2251-number-of-flowers-in-full-bloom.js

diff --git a/2251-number-of-flowers-in-full-bloom.js b/2251-number-of-flowers-in-full-bloom.js
new file mode 100644
index 00000000..13158e59
--- /dev/null
+++ b/2251-number-of-flowers-in-full-bloom.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} flowers
+ * @param {number[]} persons
+ * @return {number[]}
+ */
+const fullBloomFlowers = function(flowers, persons) {
+  const arr = []
+  for(const [s, e] of flowers) {
+    arr.push([s, 1])
+    arr.push([e, 3])
+  }
+  for(let i = 0; i < persons.length; i++) {
+    arr.push([persons[i], 2, i])
+  }
+  arr.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  const res = []
+  let cnt = 0
+  for(let e of arr) {
+    if(e[1] === 1) cnt++
+    else if(e[1] === 3) cnt--
+    else {
+      res[e[2]] = cnt
+    }
+  }
+
+  return res
+};

From d8d4564b8c516404568ce26a12dbbb06811c6d49 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Apr 2022 16:22:57 +0800
Subject: [PATCH 1994/3374] Create 2249-count-lattice-points-inside-a-circle.js

---
 2249-count-lattice-points-inside-a-circle.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2249-count-lattice-points-inside-a-circle.js

diff --git a/2249-count-lattice-points-inside-a-circle.js b/2249-count-lattice-points-inside-a-circle.js
new file mode 100644
index 00000000..273add11
--- /dev/null
+++ b/2249-count-lattice-points-inside-a-circle.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[][]} circles
+ * @return {number}
+ */
+var countLatticePoints = function(circles) {
+  const set = new Set()
+  for(let arr of circles) helper(arr)
+  return set.size
+  
+  function helper(arr) {
+    const [cx, cy, r] = arr
+    let bottomLeftX = cx - r, bottomLeftY = cy - r
+    let topRightX = cx + r, topRightY = cy + r
+    for(let i = bottomLeftX; i <= topRightX; i++) {
+      for(let j = bottomLeftY; j <= topRightY; j++) {
+        if (Math.sqrt((i - cx) ** 2 + (j - cy) ** 2) <= r) {
+          set.add(`${i},${j}`)
+        }
+      }
+    }
+  }
+};

From 12877c17d22e03c7f88a184c688314fc1e769322 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Apr 2022 16:24:34 +0800
Subject: [PATCH 1995/3374] Create 2248-intersection-of-multiple-arrays.js

---
 2248-intersection-of-multiple-arrays.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2248-intersection-of-multiple-arrays.js

diff --git a/2248-intersection-of-multiple-arrays.js b/2248-intersection-of-multiple-arrays.js
new file mode 100644
index 00000000..14f26787
--- /dev/null
+++ b/2248-intersection-of-multiple-arrays.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[][]} nums
+ * @return {number[]}
+ */
+var intersection = function(nums) {
+  let set = new Set(nums[0])
+  for (let i = 1; i < nums.length;  i++) {
+    const r = nums[i]
+    const tmp = new Set()
+    for(let e of r) {
+      if(set.has(e)) tmp.add(e)
+    }
+    set = tmp
+  }
+  return Array.from(set).sort((a, b) => a - b)
+};

From 7b87f2fd38f913d5dab161cb1be61977f1e3a1f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Apr 2022 11:33:22 +0800
Subject: [PATCH 1996/3374] Update 1231-divide-chocolate.js

---
 1231-divide-chocolate.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1231-divide-chocolate.js b/1231-divide-chocolate.js
index 3170ce2c..ea4d1768 100644
--- a/1231-divide-chocolate.js
+++ b/1231-divide-chocolate.js
@@ -21,3 +21,34 @@ const maximizeSweetness = function (sweetness, K) {
   }
   return left
 }
+
+// another
+
+/**
+ * @param {number[]} sweetness
+ * @param {number} K
+ * @return {number}
+ */
+const maximizeSweetness = function(sweetness, K) {
+  let l = 1, r = 10 ** 9
+  while(l < r) {
+    const mid = r - Math.floor((r - l) / 2)
+    if(valid(mid)) l = mid
+    else r = mid - 1
+  }
+  return l
+  
+  function valid(mid) {
+    let res = 0, cur = 0
+    const n = sweetness.length
+    for(let i = 0; i < n; i++) {
+      const e = sweetness[i]
+      cur += e
+      if(cur >= mid) {
+        res++
+        cur = 0
+      }
+    }
+    return res >= K + 1
+  }
+};

From 8e206ddf97c33119a00a758e20c46efd97f1b254 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Apr 2022 10:17:02 +0800
Subject: [PATCH 1997/3374] Create 1201-ugly-number-iii.js

---
 1201-ugly-number-iii.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1201-ugly-number-iii.js

diff --git a/1201-ugly-number-iii.js b/1201-ugly-number-iii.js
new file mode 100644
index 00000000..b2d7011a
--- /dev/null
+++ b/1201-ugly-number-iii.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number}
+ */
+const nthUglyNumber = function(n, a, b, c) {
+  let lo = 1, hi = 2 * 1e9;
+  const { floor: f } = Math
+  let ab = a * b / gcd(a, b);
+  let bc = b * c / gcd(b, c);
+  let ac = a * c / gcd(a, c);
+  let abc = a * bc / gcd(a, bc);
+  while(lo < hi) {
+    let mid = lo + Math.floor((hi - lo) / 2);
+    if(valid(mid)) hi = mid;
+    else lo = mid + 1;
+  }
+  return lo;
+
+  function valid(mid) {
+    let res = f(mid / a) + f(mid / b) + f(mid / c) - f(mid / ab) - f(mid / bc) - f(mid / ac) + f(mid / abc)
+    return res >= n
+  }
+
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+};

From 533bc708343446f4192f91b99470c86f61886f7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Apr 2022 13:30:13 +0800
Subject: [PATCH 1998/3374] Update
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
index b0d3d636..62ecf6ee 100644
--- a/1648-sell-diminishing-valued-colored-balls.js
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -65,3 +65,34 @@ const maxProfit = function (inventory, orders) {
   
   return sum % mod
 }
+
+// another
+
+/**
+ * @param {number[]} inventory
+ * @param {number} orders
+ * @return {number}
+ */
+var maxProfit = function(inventory, orders) {
+    inventory.sort((a, b) => b - a)
+    const mod = BigInt(1e9 + 7), n = BigInt(inventory.length)
+    inventory = inventory.map(e => BigInt(e))
+    orders = BigInt(orders)
+    let cur = BigInt(inventory[0]), res = 0n, i = 0n
+    const min = (a, b) => a > b ? b : a
+    while(orders) {
+      while(i < n && inventory[i] === cur) i++
+      let next = i === n ? 0n : inventory[i]
+      let h = cur - next, r = 0n, cnt = min(orders, i * h)
+      if (orders < i * h) {
+        h = orders / i
+        r = orders % i
+      }
+      let val = cur - h
+      res = (res + (cur + val + 1n) * h / 2n * i + val * r) % mod
+      orders -= cnt
+      cur = next
+    }
+
+    return res
+};

From 81c315e0391d16b34abfb7d93e35cb5e4ec0543b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Apr 2022 17:01:34 +0800
Subject: [PATCH 1999/3374] Update
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
index 62ecf6ee..9707f929 100644
--- a/1648-sell-diminishing-valued-colored-balls.js
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -96,3 +96,39 @@ var maxProfit = function(inventory, orders) {
 
     return res
 };
+
+// another
+
+/**
+ * @param {number[]} inventory
+ * @param {number} orders
+ * @return {number}
+ */
+const maxProfit = function (inventory, orders) {
+  inventory.sort((a, b) => b - a)
+  const mod = BigInt(1e9 + 7),
+    n = BigInt(inventory.length)
+  inventory = inventory.map((e) => BigInt(e))
+  orders = BigInt(orders)
+  let cur = BigInt(inventory[0]),
+    res = 0n,
+    i = 0n
+  const min = (a, b) => (a > b ? b : a)
+  while (orders) {
+    while (i < n && inventory[i] === cur) i++
+    let next = i === n ? 0n : inventory[i]
+    let h = cur - next,
+      r = 0n,
+      cnt = min(orders, i * h)
+    if (orders < i * h) {
+      h = orders / i
+      r = orders % i
+    }
+    let val = cur - h
+    res = (res + (((cur + val + 1n) * h) / 2n) * i + val * r) % mod
+    orders -= cnt
+    cur = next
+  }
+
+  return res
+}

From cdab9788e76ec950c84b61105d576245c14e5863 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Apr 2022 22:42:17 +0800
Subject: [PATCH 2000/3374] Update
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
index 9707f929..662d9cbb 100644
--- a/1648-sell-diminishing-valued-colored-balls.js
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} inventory
+ * @param {number} orders
+ * @return {number}
+ */
+const maxProfit = function(inventory, orders) {
+  inventory = inventory.map(e => BigInt(e))
+  orders = BigInt(orders)
+  let l = 0n, r = BigInt(1e9 + 7)
+  while(l < r) {
+    const mid = l + (r - l) / 2n
+    if(valid(mid)) l = mid + 1n
+    else r = mid
+  }
+  
+  // console.log(l)
+  const mod = BigInt(1e9 + 7)
+  let t = l, res = 0n, cnt = 0n
+  for(const e of inventory) {
+    if(e <= t) continue
+    cnt += e - t
+    res = (res + (t + 1n + e) * (e - t) / 2n) % mod
+  }
+  
+  res = (res + (orders - cnt) * t) % mod
+  
+  return res
+  function valid(mid) {
+    let res = 0n
+    for(const e of inventory) {
+      if(e > mid) res += e - mid
+    }
+    return res > orders
+  }
+};
+
+// another
+
 /**
  * @param {number[]} inventory
  * @param {number} orders

From 16a872cc8f8959ac2dbaa4d0b4fc2c4ea6dd89ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Apr 2022 22:55:41 +0800
Subject: [PATCH 2001/3374] Update
 1648-sell-diminishing-valued-colored-balls.js

---
 1648-sell-diminishing-valued-colored-balls.js | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/1648-sell-diminishing-valued-colored-balls.js b/1648-sell-diminishing-valued-colored-balls.js
index 662d9cbb..f38bf0b2 100644
--- a/1648-sell-diminishing-valued-colored-balls.js
+++ b/1648-sell-diminishing-valued-colored-balls.js
@@ -4,9 +4,10 @@
  * @return {number}
  */
 const maxProfit = function(inventory, orders) {
+  const bigIntMax = (...args) => args.reduce((m, e) => e > m ? e : m);
   inventory = inventory.map(e => BigInt(e))
   orders = BigInt(orders)
-  let l = 0n, r = BigInt(1e9 + 7)
+  let l = 0n, r = bigIntMax(...inventory)
   while(l < r) {
     const mid = l + (r - l) / 2n
     if(valid(mid)) l = mid + 1n
@@ -25,6 +26,7 @@ const maxProfit = function(inventory, orders) {
   res = (res + (orders - cnt) * t) % mod
   
   return res
+  
   function valid(mid) {
     let res = 0n
     for(const e of inventory) {

From 55bde14e2fa2bb62832e809c731fbe572ce02f7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Apr 2022 11:52:27 +0800
Subject: [PATCH 2002/3374] Update 2141-maximum-running-time-of-n-computers.js

---
 2141-maximum-running-time-of-n-computers.js | 32 +++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2141-maximum-running-time-of-n-computers.js b/2141-maximum-running-time-of-n-computers.js
index 762b70b4..d71ebb67 100644
--- a/2141-maximum-running-time-of-n-computers.js
+++ b/2141-maximum-running-time-of-n-computers.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number[]} batteries
+ * @return {number}
+ */
+const maxRunTime = function(n, batteries) {
+  n = BigInt(n)
+  batteries = batteries.map(e => BigInt(e))
+  const sum = batteries.reduce((ac, e) => ac + e, 0n)
+  let l = 0n, r = sum / n
+  while(l < r) {
+    const mid = r - (r - l) / 2n
+    if(valid(mid)) l = mid
+    else r = mid - 1n
+  }
+  
+  return l
+  
+  function valid(mid) {
+    let curSum = 0n, target = mid * n
+    for(const e of batteries) {
+      curSum += e > mid ? mid : e
+      if(curSum >= target) return true
+    }
+    return false
+  }
+};
+
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[]} batteries

From 97e019e5fc4b7760fe076808076a14c8ee1f3653 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Apr 2022 23:01:45 +0800
Subject: [PATCH 2003/3374] Update
 2250-count-number-of-rectangles-containing-each-point.js

---
 ...ber-of-rectangles-containing-each-point.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/2250-count-number-of-rectangles-containing-each-point.js b/2250-count-number-of-rectangles-containing-each-point.js
index bd1e3a91..b76d92e0 100644
--- a/2250-count-number-of-rectangles-containing-each-point.js
+++ b/2250-count-number-of-rectangles-containing-each-point.js
@@ -1,3 +1,39 @@
+/**
+ * @param {number[][]} rectangles
+ * @param {number[][]} points
+ * @return {number[]}
+ */
+const countRectangles = function(rectangles, points) {
+  const rect = rectangles
+  const matrix = Array.from({ length: 101 }, () => [])
+  for(const [x, y] of rect) {
+    matrix[y].push(x)
+  }
+  for(const row of matrix) row.sort((a, b) => a - b)
+  const res = []
+  
+  for(const [x, y] of points) {
+    
+    let cnt = 0
+    for(let i = y; i <= 100; i++) {
+       const arr = matrix[i], n = arr.length
+       let l = 0, r = n
+       while(l < r) {
+         const mid = l + Math.floor((r - l) / 2)
+         if(mid === n || arr[mid] >= x) r = mid
+         else l = mid + 1
+       }
+       cnt += n - l
+    }
+    
+    res.push(cnt)
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} rectangles
  * @param {number[][]} points

From 0b70750ce6820d79a24d54744ab59773cdd37137 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Apr 2022 19:44:10 +0800
Subject: [PATCH 2004/3374] Update
 1996-the-number-of-weak-characters-in-the-game.js

---
 ...e-number-of-weak-characters-in-the-game.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1996-the-number-of-weak-characters-in-the-game.js b/1996-the-number-of-weak-characters-in-the-game.js
index e5ea1f78..383d457e 100644
--- a/1996-the-number-of-weak-characters-in-the-game.js
+++ b/1996-the-number-of-weak-characters-in-the-game.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[][]} properties
+ * @return {number}
+ */
+const numberOfWeakCharacters = function(properties) {
+  const props = properties, n = props.length, maxDefFromRight = Array(n)
+  props.sort((a, b) => a[0] - b[0])
+  for(let max = 0, i = n - 1; i >= 0; i--) {
+    max = Math.max(max, props[i][1])
+    maxDefFromRight[i] = max
+  }
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    const cur = props[i]
+    let l = i, r = n
+    while(l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if(props[mid][0] > props[i][0]) r = mid
+      else l = mid + 1
+    }
+    
+    if(l < n && maxDefFromRight[l] > props[i][1]) {
+      res++   
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} properties
  * @return {number}

From 4e060428ba85e46755c12fc5df8df37ab079b064 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 May 2022 12:12:15 +0800
Subject: [PATCH 2005/3374] Create 2262-total-appeal-of-a-string.js

---
 2262-total-appeal-of-a-string.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2262-total-appeal-of-a-string.js

diff --git a/2262-total-appeal-of-a-string.js b/2262-total-appeal-of-a-string.js
new file mode 100644
index 00000000..799c6884
--- /dev/null
+++ b/2262-total-appeal-of-a-string.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var appealSum = function(s) {
+  const cnt = Array(26).fill(-1);
+  let ans = 0;
+  let n = s.length;
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0; i < n; i++) {
+      let tmp = n - i;
+      if (cnt[s[i].charCodeAt(0) - a] !== -1) tmp += (i - cnt[s[i].charCodeAt(0) - a] - 1) * (n - i);
+      else tmp += i * (n - i);
+      ans += tmp;
+      cnt[s[i].charCodeAt(0) - a] = i;
+  }
+  return ans;
+};

From c604488863bc6808829def8a8408785555d818fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 May 2022 12:12:58 +0800
Subject: [PATCH 2006/3374] Create 2261-k-divisible-elements-subarrays.js

---
 2261-k-divisible-elements-subarrays.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2261-k-divisible-elements-subarrays.js

diff --git a/2261-k-divisible-elements-subarrays.js b/2261-k-divisible-elements-subarrays.js
new file mode 100644
index 00000000..8b930531
--- /dev/null
+++ b/2261-k-divisible-elements-subarrays.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} p
+ * @return {number}
+ */
+const countDistinct = function(nums, k, p) {
+    let ans = 0;
+    const se = new Set();
+    let n = nums.length;
+    for (let i = 0; i < n; i++) {
+        let tmp = "";
+        let cnt = 0;
+        for (let j = i; j < n; j++) {
+            if (nums[j] % p == 0)
+                cnt++;
+            if (cnt <= k) {
+                tmp = tmp + (nums[j]) + "-";
+                se.add(tmp);
+            } else break;
+        }
+    }
+    return se.size;
+};

From 1f8bf1f3839d72a18e4884d40ac645e03a58d93d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 May 2022 12:16:10 +0800
Subject: [PATCH 2007/3374] Create 2260-minimum-consecutive-cards-to-pick-up.js

---
 2260-minimum-consecutive-cards-to-pick-up.js | 25 ++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2260-minimum-consecutive-cards-to-pick-up.js

diff --git a/2260-minimum-consecutive-cards-to-pick-up.js b/2260-minimum-consecutive-cards-to-pick-up.js
new file mode 100644
index 00000000..bb2bc53e
--- /dev/null
+++ b/2260-minimum-consecutive-cards-to-pick-up.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} cards
+ * @return {number}
+ */
+var minimumCardPickup = function(cards) {
+  const hash = {}, n = cards.length
+  for(let i = 0; i < n; i++) {
+    const cur = cards[i]
+    if(hash[cur] == null) hash[cur] = []
+    hash[cur].push(i)
+  }
+  let res = Infinity
+  
+  Object.keys(hash).forEach(k => {
+    const arr = hash[k]
+    const len = arr.length
+    for(let i = 1; i < len; i++) {
+      res = Math.min(res, arr[i] - arr[i - 1] + 1)
+    }
+    
+  })
+  
+  
+  return res === Infinity ? -1 :  res
+};

From b956349754766a25938b9c78fc0eca7f69ad5231 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 May 2022 12:16:42 +0800
Subject: [PATCH 2008/3374] Create
 2259-remove-digit-from-number-to-maximize-result.js

---
 ...ve-digit-from-number-to-maximize-result.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2259-remove-digit-from-number-to-maximize-result.js

diff --git a/2259-remove-digit-from-number-to-maximize-result.js b/2259-remove-digit-from-number-to-maximize-result.js
new file mode 100644
index 00000000..d7bc3daa
--- /dev/null
+++ b/2259-remove-digit-from-number-to-maximize-result.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} number
+ * @param {character} digit
+ * @return {string}
+ */
+const removeDigit = function(number, digit) {
+   const arr = number.split('')
+   const idxArr = []
+   arr.forEach((e,i) => {
+     if(e === digit) idxArr.push(i)
+   })
+   const res = []
+   for(const i of idxArr) {
+     const clone = arr.slice()
+     clone.splice(i, 1)
+     res.push(clone.join(''))
+   }
+   return res.reduce((ac, e) => e > ac ? e : ac, res[0])
+};

From 5c46a06ebefaa0a692e636bcf10ad03397ed56c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 May 2022 20:09:37 +0800
Subject: [PATCH 2009/3374] Update 354-russian-doll-envelopes.js

---
 354-russian-doll-envelopes.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/354-russian-doll-envelopes.js b/354-russian-doll-envelopes.js
index bb10c078..efdd4fa9 100644
--- a/354-russian-doll-envelopes.js
+++ b/354-russian-doll-envelopes.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[][]} envelopes
+ * @return {number}
+ */
+const maxEnvelopes = function(envelopes) {
+  const env = envelopes
+  env.sort((a, b) => a[0] - b[0] || b[1] - a[1])
+  const stk = []
+  for(const e of env) {
+    if(stk.length === 0 || e[1] > stk[stk.length - 1][1]) {
+      stk.push(e)
+      continue
+    }
+    let l = 0, r = stk.length - 1
+    while(l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if(stk[mid][1] < e[1]) l = mid + 1
+      else r = mid
+    }
+    
+    stk[l] = e
+  }
+  
+  return stk.length
+};
+
+// another
+
+
 /**
  * @param {number[][]} envelopes
  * @return {number}

From e007b7d797ac7b135d45ece0253fb179bd0bac5d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 May 2022 20:11:25 +0800
Subject: [PATCH 2010/3374] Update 543-diameter-of-binary-tree.js

---
 543-diameter-of-binary-tree.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/543-diameter-of-binary-tree.js b/543-diameter-of-binary-tree.js
index aa2efec2..acf2deac 100755
--- a/543-diameter-of-binary-tree.js
+++ b/543-diameter-of-binary-tree.js
@@ -50,3 +50,30 @@ const diameterOfBinaryTree = function(root) {
   }
 };
 
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const diameterOfBinaryTree = function(root) {
+  let res = -Infinity
+  dfs(root)
+  return res
+  function dfs(node) {
+    if(node == null) return -1
+    const left = dfs(node.left)
+    const right = dfs(node.right)
+    res = Math.max(res, left + right + 2)
+    return Math.max(left, right) + 1
+  }
+};
+

From 88d16d907078269aa3094865adde8d16e73e81e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 May 2022 20:01:56 +0800
Subject: [PATCH 2011/3374] Create 1522-diameter-of-n-ary-tree.js

---
 1522-diameter-of-n-ary-tree.js | 36 ++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1522-diameter-of-n-ary-tree.js

diff --git a/1522-diameter-of-n-ary-tree.js b/1522-diameter-of-n-ary-tree.js
new file mode 100644
index 00000000..e573be5e
--- /dev/null
+++ b/1522-diameter-of-n-ary-tree.js
@@ -0,0 +1,36 @@
+/**
+ * // Definition for a Node.
+ * function Node(val, children) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.children = children === undefined ? [] : children;
+ * };
+ */
+
+/**
+ * @param {Node} root
+ * @return {number}
+ */
+var diameter = function(root) {
+  let res = 0
+  dfs(root)
+  return res
+  function dfs(node) {
+    if(node == null) return 0
+    const arr = []
+    for(const child of node.children) {
+      const tmp = dfs(child)
+      arr.push(tmp)
+    }
+    let max1 = 0, max2 = 0
+    for(const e of arr) {
+      if(e > max1) {
+        max2 = max1
+        max1 = e
+      } else if(e > max2) {
+        max2 = e
+      }
+    }
+    res = Math.max(res, max1 + max2)
+    return max1 + 1
+  }
+};

From 64529983792b5e4325bbeab34b12547639bfce9a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 May 2022 20:06:47 +0800
Subject: [PATCH 2012/3374] Update 1522-diameter-of-n-ary-tree.js

---
 1522-diameter-of-n-ary-tree.js | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/1522-diameter-of-n-ary-tree.js b/1522-diameter-of-n-ary-tree.js
index e573be5e..864b1c25 100644
--- a/1522-diameter-of-n-ary-tree.js
+++ b/1522-diameter-of-n-ary-tree.js
@@ -14,22 +14,20 @@ var diameter = function(root) {
   let res = 0
   dfs(root)
   return res
+
   function dfs(node) {
     if(node == null) return 0
-    const arr = []
+    let max1 = 0, max2 = 0
     for(const child of node.children) {
       const tmp = dfs(child)
-      arr.push(tmp)
-    }
-    let max1 = 0, max2 = 0
-    for(const e of arr) {
-      if(e > max1) {
+      if(tmp > max1) {
         max2 = max1
-        max1 = e
-      } else if(e > max2) {
-        max2 = e
+        max1 = tmp
+      } else if(tmp > max2) {
+        max2 = tmp
       }
     }
+
     res = Math.max(res, max1 + max2)
     return max1 + 1
   }

From 8a3b68a8e01aea766cb6639bf90b12bb6f9bbd69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 May 2022 22:42:04 +0800
Subject: [PATCH 2013/3374] Update 2049-count-nodes-with-the-highest-score.js

---
 2049-count-nodes-with-the-highest-score.js | 32 ++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2049-count-nodes-with-the-highest-score.js b/2049-count-nodes-with-the-highest-score.js
index cc8176fc..5be74015 100644
--- a/2049-count-nodes-with-the-highest-score.js
+++ b/2049-count-nodes-with-the-highest-score.js
@@ -24,3 +24,35 @@ const countHighestScoreNodes = function(parents) {
   const maxKey = Math.max(...Object.keys(hash))
   return hash[maxKey]
 };
+
+// another
+
+/**
+ * @param {number[]} parents
+ * @return {number}
+ */
+const countHighestScoreNodes = function(parents) {
+  const n = parents.length, hash = {}, graph = {}
+  for(let i = 1; i < n; i++) {
+    if(graph[parents[i]] == null) graph[parents[i]] = []
+    graph[parents[i]].push(i)
+  }
+
+  dfs(0)
+  const mk = Math.max(...Object.keys(hash))
+  return hash[mk]
+  
+  function dfs(i) {
+    let num = 0, prod = 1
+    for(const e of (graph[i] || []) ) {
+      const tmp = dfs(e)
+      num += tmp
+      prod *= tmp
+    }
+    
+    if(n - 1 - num > 0) prod *= (n - 1 - num)
+    hash[prod] = (hash[prod] || 0) + 1
+
+    return num + 1
+  }
+};

From 4270cf9fd8f9bff63e6d923cb20ac5eced6c4205 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 May 2022 21:25:02 +0800
Subject: [PATCH 2014/3374] Create 1211-queries-quality-and-percentage.sql

---
 1211-queries-quality-and-percentage.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1211-queries-quality-and-percentage.sql

diff --git a/1211-queries-quality-and-percentage.sql b/1211-queries-quality-and-percentage.sql
new file mode 100644
index 00000000..904006a7
--- /dev/null
+++ b/1211-queries-quality-and-percentage.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT 
+	query_name,
+	ROUND(AVG(rating / position), 2) AS quality,
+	ROUND(AVG(rating < 3) * 100, 2) AS poor_query_percentage 
+FROM 
+	Queries
+GROUP BY 
+	query_name;

From ed20b77dc5b0589bbce1f46c0dcc290b7a6193d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 May 2022 21:34:12 +0800
Subject: [PATCH 2015/3374] Create 1417-reformat-the-string.js

---
 1417-reformat-the-string.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1417-reformat-the-string.js

diff --git a/1417-reformat-the-string.js b/1417-reformat-the-string.js
new file mode 100644
index 00000000..b822d836
--- /dev/null
+++ b/1417-reformat-the-string.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var reformat = function(s) {
+  let str = '', num = ''
+  const isDigit = ch => ch >= '0' && ch <= '9'
+  for(const ch of s) {
+    if(isDigit(ch)) num += ch
+    else str += ch
+  }
+  if(Math.abs(str.length - num.length) > 1) return ''
+  if(str.length > num.length) {
+    let res = ''
+    for (let i = 0; i < str.length; i++) {
+      res += str[i]
+      if(i < num.length) res += num[i]
+    }
+    return res
+  } else {
+    let res = ''
+    for (let i = 0; i < num.length; i++) {
+      res += num[i]
+      if(i < str.length) res += str[i]
+    }
+    return res
+  }
+};

From 510ee904a8015b30431d7d98d5d1ddef6d1606a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 May 2022 21:28:52 +0800
Subject: [PATCH 2016/3374] Update
 2246-longest-path-with-different-adjacent-characters.js

---
 ...path-with-different-adjacent-characters.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2246-longest-path-with-different-adjacent-characters.js b/2246-longest-path-with-different-adjacent-characters.js
index 62fbe3a2..0b9e53e7 100644
--- a/2246-longest-path-with-different-adjacent-characters.js
+++ b/2246-longest-path-with-different-adjacent-characters.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} parent
+ * @param {string} s
+ * @return {number}
+ */
+var longestPath = function(parent, s) {
+  const n = parent.length
+  const hash = {}
+  for(let i = 1; i < n; i++) {
+    if(hash[parent[i]] == null) hash[parent[i]] = []
+    hash[parent[i]].push(i)
+  }
+
+  let res = 0
+  dfs(0)
+  return res
+  
+  function dfs(i) {
+    let max1 = 0, max2 = 0
+    for(const j of (hash[i] || [])) {
+      const len = dfs(j)
+      if(s[i] === s[j]) continue
+      if(len > max1) {
+        const tmp = max1
+        max1 = len
+        max2 = tmp
+      } else if(len > max2) {
+        max2 = len
+      }
+    }
+    res = Math.max(res, max1 + max2 + 1)    
+    return max1 + 1
+  }
+};
+
+
+// another
+
 /**
  * @param {number[]} parent
  * @param {string} s

From c4ee3aa7a9c0cea668261e37db44dd87fe46fc67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 May 2022 15:19:30 +0800
Subject: [PATCH 2017/3374] Create
 2264-largest-3-same-digit-number-in-string.js

---
 2264-largest-3-same-digit-number-in-string.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2264-largest-3-same-digit-number-in-string.js

diff --git a/2264-largest-3-same-digit-number-in-string.js b/2264-largest-3-same-digit-number-in-string.js
new file mode 100644
index 00000000..62acf554
--- /dev/null
+++ b/2264-largest-3-same-digit-number-in-string.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} num
+ * @return {string}
+ */
+var largestGoodInteger = function(num) {
+  let res = ''
+  const n = num.length
+  const isDigit = ch => ch >= '0' && ch <= '9'
+  for(let i = 1; i < n - 1; i++) {
+    const ch = num[i]
+    if(!isDigit(ch)) continue
+    if(!isDigit(num[i - 1])) continue
+    if(!isDigit(num[i + 1])) continue
+    if(num[i - 1] == num[i] && num[i] === num[i + 1]) {
+      if(ch.repeat(3) >  res) res = ch.repeat(3)
+    }
+  }
+  
+  return res
+};

From 487ca64e315c52861a99a0f068e9bfcf4737fa8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 May 2022 15:19:55 +0800
Subject: [PATCH 2018/3374] Create
 2265-count-nodes-equal-to-average-of-subtree.js

---
 ...count-nodes-equal-to-average-of-subtree.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2265-count-nodes-equal-to-average-of-subtree.js

diff --git a/2265-count-nodes-equal-to-average-of-subtree.js b/2265-count-nodes-equal-to-average-of-subtree.js
new file mode 100644
index 00000000..6e8ba21f
--- /dev/null
+++ b/2265-count-nodes-equal-to-average-of-subtree.js
@@ -0,0 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var averageOfSubtree = function(root) {
+  let res = 0
+  dfs(root)
+  return res
+  
+  function dfs(node) {
+    if(node == null) return [0, 0]
+    let [lSum, lNum] = dfs(node.left)
+    let [rSum, rNum] = dfs(node.right)
+    if(node.val === Math.floor((node.val + lSum + rSum) / (lNum + rNum + 1))) {
+      res++
+    }
+    return [node.val + lSum + rSum, lNum + rNum + 1]
+  }
+};

From 51c70259a5a98d3c85fccff45c7bb6b80332ee7e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 May 2022 15:23:20 +0800
Subject: [PATCH 2019/3374] Create 2266-count-number-of-texts.js

---
 2266-count-number-of-texts.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2266-count-number-of-texts.js

diff --git a/2266-count-number-of-texts.js b/2266-count-number-of-texts.js
new file mode 100644
index 00000000..09320bf4
--- /dev/null
+++ b/2266-count-number-of-texts.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} pressedKeys
+ * @return {number}
+ */
+var countTexts = function(pressedKeys) {
+   const s = pressedKeys
+   const mod = 1e9 + 7
+
+    let n = s.length
+    let dp = Array(n + 1).fill(0)
+    dp[0] = 1
+    dp[1] = 1
+    let counter = Array(10).fill(3)
+    counter[0] = 0
+    counter[1] = 0
+    counter[7] = 4
+    counter[9] = 4
+    for(let i = 2; i <= n; i++) {
+        let x = +(s[i - 1])
+        let j = 0
+        while (j < counter[x] && i - 1 >= j && s[i - 1 - j] == s[i - 1]) {
+            dp[i] += dp[i - 1 - j]
+            j += 1              
+        }
+
+        dp[i] %= mod
+    }
+
+    return dp[n]
+  
+};
+
+

From 58d28fc93ed6d410db28973bcb5a7a871d9b96ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 May 2022 15:24:57 +0800
Subject: [PATCH 2020/3374] Create
 2267-check-if-there-is-a-valid-parentheses-string-path.js

---
 ...here-is-a-valid-parentheses-string-path.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 2267-check-if-there-is-a-valid-parentheses-string-path.js

diff --git a/2267-check-if-there-is-a-valid-parentheses-string-path.js b/2267-check-if-there-is-a-valid-parentheses-string-path.js
new file mode 100644
index 00000000..429c229d
--- /dev/null
+++ b/2267-check-if-there-is-a-valid-parentheses-string-path.js
@@ -0,0 +1,43 @@
+/**
+ * @param {character[][]} grid
+ * @return {boolean}
+ */
+var hasValidPath = function(grid) {
+    if (grid[0][0] == ")") return false
+    let m = grid.length, n = grid[0].length
+    const dirs = [[0, 1], [1, 0]]
+
+    if ((m + n - 1) % 2 == 1) return false
+    const a = Array.from({ length: m }, () => Array(n).fill(null))
+    for(let i = 0; i < m; i++) {
+      for(let j = 0; j < n; j++) {
+        if(grid[i][j] === '(') a[i][j] = 1
+        else a[i][j] = -1
+      }
+    }
+  
+  
+    const visited = new Set([`0,0,1`])
+    let q = [[0, 0, 1]]
+
+    while (q.length){
+        const tmp = []
+        for (const [x, y, v] of q) {
+            if (`${x},${y},${v}` == `${m - 1},${n - 1},0`) return true
+            for (const [dx, dy] of dirs) {
+                let i= x + dx,  j = y + dy
+                if (0 <= i && i < m && 0 <= j && j < n) {
+                    let v2 = v + a[i][j]
+                    if (v2 >= 0 && !visited.has(`${i},${j},${v2}`) ) {
+                        tmp.push([i, j, v2])
+                        visited.add(`${i},${j},${v2}`)                           
+                    }
+              
+                }
+            }
+        }
+        q = tmp      
+    }
+    return false
+};
+

From 17a596f92fed6a3cea363f28b736b8e0500a22f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 May 2022 21:34:09 +0800
Subject: [PATCH 2021/3374] Update
 2245-maximum-trailing-zeros-in-a-cornered-path.js

---
 ...ximum-trailing-zeros-in-a-cornered-path.js | 86 +++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/2245-maximum-trailing-zeros-in-a-cornered-path.js b/2245-maximum-trailing-zeros-in-a-cornered-path.js
index b2004bcb..b4914d6d 100644
--- a/2245-maximum-trailing-zeros-in-a-cornered-path.js
+++ b/2245-maximum-trailing-zeros-in-a-cornered-path.js
@@ -1,3 +1,89 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maxTrailingZeros = function maxTrailingZeros(grid) {
+  const m = grid.length
+  const n = grid[0].length
+
+  const factors = (num, k) => {
+    let sum = 0
+    while (!(num % k)) {
+      num /= k
+      sum += 1
+    }
+
+    return sum
+  }
+
+  const getRowPrefixSum = (k) => {
+    const rowPrefixSum = []
+    for (let i = 0; i < m; i++) {
+      rowPrefixSum.push([factors(grid[i][0], k)])
+      for (let j = 1; j < n; j++) {
+        rowPrefixSum[i][j] = factors(grid[i][j], k) + rowPrefixSum[i][j - 1]
+      }
+    }
+
+    return rowPrefixSum
+  }
+
+  const getColPrefixSum = (k) => {
+    const colPrefixSum = [[factors(grid[0][0], k)]]
+    for (let i = 1; i < m; i++) {
+      colPrefixSum.push([factors(grid[i][0], k) + colPrefixSum[i - 1][0]])
+    }
+
+    for (let j = 1; j < n; j++) {
+      colPrefixSum[0][j] = factors(grid[0][j], k)
+      for (let i = 1; i < m; i++) {
+        colPrefixSum[i][j] = factors(grid[i][j], k) + colPrefixSum[i - 1][j]
+      }
+    }
+
+    return colPrefixSum
+  }
+
+  const twoRow = getRowPrefixSum(2)
+  const fiveRow = getRowPrefixSum(5)
+  const twoCol = getColPrefixSum(2)
+  const fiveCol = getColPrefixSum(5)
+
+  let max = 0
+
+  // now check every cell in the whole grid
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const twoLeft = twoRow[i][j]
+      const twoRight = twoRow[i][n - 1] - (j && twoRow[i][j - 1])
+      const twoUp = i && twoCol[i - 1][j]
+      const twoDown = twoCol[m - 1][j] - twoCol[i][j]
+
+      const fiveLeft = fiveRow[i][j]
+      const fiveRight = fiveRow[i][n - 1] - (j && fiveRow[i][j - 1])
+      const fiveUp = i && fiveCol[i - 1][j]
+      const fiveDown = fiveCol[m - 1][j] - fiveCol[i][j]
+
+      const corneredPaths = [
+        Math.min(twoLeft + twoUp, fiveLeft + fiveUp),
+        Math.min(twoLeft + twoDown, fiveLeft + fiveDown),
+        Math.min(twoRight + twoUp, fiveRight + fiveUp),
+        Math.min(twoRight + twoDown, fiveRight + fiveDown),
+      ]
+
+      const trailingZeros = Math.max(...corneredPaths)
+
+      if (trailingZeros > max) {
+        max = trailingZeros
+      }
+    }
+  }
+
+  return max
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 1f09f11541b83bcc04fbeca15927c8925df19411 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 May 2022 18:35:10 +0800
Subject: [PATCH 2022/3374] Update 56-merge-intervals.js

---
 56-merge-intervals.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/56-merge-intervals.js b/56-merge-intervals.js
index 89a5fb3e..a772b911 100644
--- a/56-merge-intervals.js
+++ b/56-merge-intervals.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+const merge = function(intervals) {
+  intervals.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  const res = [intervals[0]]
+  for(let i = 1, n = intervals.length; i < n; i++) {
+    const [s, e] = intervals[i]
+    const pre = res[res.length - 1]
+    if(s <= pre[1]) {
+      pre[1] = Math.max(pre[1], e)
+    } else {
+      res.push(intervals[i])
+    }
+  }
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[][]} intervals
  * @return {number[][]}

From 3f3d2116802a6512be539083ef27779e30153945 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 May 2022 11:21:59 +0800
Subject: [PATCH 2023/3374] Update 732-my-calendar-iii.js

---
 732-my-calendar-iii.js | 77 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/732-my-calendar-iii.js b/732-my-calendar-iii.js
index 952ba97d..ad5f21cc 100644
--- a/732-my-calendar-iii.js
+++ b/732-my-calendar-iii.js
@@ -41,3 +41,80 @@ MyCalendarThree.prototype.book = function(start, end) {
  * var obj = new MyCalendarThree()
  * var param_1 = obj.book(start,end)
  */
+
+// another
+
+
+var MyCalendarThree = function() {
+    this.st = new SegmentTree(0, 10 ** 9);
+};
+
+/** 
+ * @param {number} start 
+ * @param {number} end
+ * @return {number}
+ */
+MyCalendarThree.prototype.book = function(start, end) {
+    this.st.add(start, end);    
+    return this.st.getMax();
+};
+
+/** 
+ * Your MyCalendarThree object will be instantiated and called as such:
+ * var obj = new MyCalendarThree()
+ * var param_1 = obj.book(start,end)
+ */
+
+class SegmentTree {
+    constructor(start, end) {
+        this.root = new TreeNode(start, end);
+    }
+    
+    add(qs, qe, node=this.root) {
+        
+        // completely outside of query range
+        if(qs > node.end || qe <= node.start) {
+            return node.val;
+        }
+        
+        // completely covered by query range
+        if(qs <= node.start && qe > node.end) {
+            node.booked += 1;
+            node.val += 1;
+            return node.val;
+        }
+
+        let mid = (node.start + node.end)/2 >> 0;
+
+        if(!node.left) {
+            node.left = new TreeNode(node.start, mid);
+        }
+
+        if(!node.right) {
+            node.right = new TreeNode(mid+1, node.end);
+        }
+
+        node.val = Math.max(
+            this.add(qs, qe, node.left),
+            this.add(qs, qe, node.right),
+        ) + node.booked;
+
+        return node.val;
+        
+    }
+    
+    getMax() {
+        return this.root.val;
+    }
+    
+}
+
+class TreeNode {
+    constructor(start, end) {
+        this.start = start;
+        this.end = end;
+        this.val = 0;
+        this.booked = 0;
+        this.left = this.right = null;
+    }
+}

From ae9e24aed9482023662ba3cae5ffc909f1d36b3d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 May 2022 14:08:24 +0800
Subject: [PATCH 2024/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index ea7bcd27..62a74dde 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -37,3 +37,33 @@ const minMeetingRooms = function(intervals) {
 
   return res
 }
+
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  let res = 0
+  const sArr = [], eArr = [], n = intervals.length
+  for(const [s, e] of intervals) {
+    sArr.push(s)
+    eArr.push(e)
+  }
+  sArr.sort((a, b) => a - b)
+  eArr.sort((a, b) => a - b)
+  for(let i = 0, j = 0; i < n && j < n;) {
+    const s = sArr[i], e = eArr[j]
+    if(s < e) {
+      res++
+      i++
+    } else {
+      j++
+      i++
+    }
+  }
+  
+  return res
+}

From 9d69acb7db21e9b48f42f5ce63dc6b4b1c3b89e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 May 2022 14:50:49 +0800
Subject: [PATCH 2025/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index 62a74dde..e7f58ed9 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -67,3 +67,25 @@ const minMeetingRooms = function(intervals) {
   
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  intervals.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+  const n = intervals.length
+  const pq = new MinPriorityQueue()
+  let res = 0
+  for(const [s, e] of intervals) {
+    while(!pq.isEmpty() && s >= pq.front().element) {
+       pq.dequeue()
+    }
+    pq.enqueue(e)
+    res = Math.max(res, pq.size())
+  }
+  
+  return res
+}

From 45a5e1d9e20d7013d2fad7b88fc28b1c2175fde2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 May 2022 19:44:27 +0800
Subject: [PATCH 2026/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index e7f58ed9..5fb05b3a 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -89,3 +89,25 @@ const minMeetingRooms = function(intervals) {
   
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  const hash = {}
+  for(const [s, e] of intervals) {
+    hash[s] = (hash[s] || 0) + 1
+    hash[e] = (hash[e] || 0) - 1
+  }
+  let res = 0, cur = 0
+  const keys = Object.keys(hash).map(e => +e)
+  keys.sort((a, b) => a - b)
+  for(const k of keys) {
+    cur += hash[k]
+    res = Math.max(res, cur)
+  }
+  return res
+};

From c5bf290c70787bcf734ebc7bc0b1d9a12cb1c3cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 May 2022 21:14:14 +0800
Subject: [PATCH 2027/3374] Update
 1893-check-if-all-the-integers-in-a-range-are-covered.js

---
 ...all-the-integers-in-a-range-are-covered.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1893-check-if-all-the-integers-in-a-range-are-covered.js b/1893-check-if-all-the-integers-in-a-range-are-covered.js
index 1aff5dee..34d23efe 100644
--- a/1893-check-if-all-the-integers-in-a-range-are-covered.js
+++ b/1893-check-if-all-the-integers-in-a-range-are-covered.js
@@ -38,3 +38,28 @@ const isCovered = function(ranges, left, right) {
 	}
 	return true;
 };
+
+// another
+
+/**
+ * @param {number[][]} ranges
+ * @param {number} left
+ * @param {number} right
+ * @return {boolean}
+ */
+const isCovered = function(ranges, left, right) {
+  const arr = Array(52).fill(0)
+  for(let [s, e] of ranges) {
+    arr[s]++
+    arr[e + 1]--
+  }
+
+  let overlaps = 0
+  for(let i = 1; i <= right; i++) {
+    overlaps += arr[i];
+    if (i >= left && overlaps == 0) return false;
+  }
+  
+  return true
+};
+

From f479af219210c88afcbbdeabb36ff4d55fd9dce4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 May 2022 19:03:06 +0800
Subject: [PATCH 2028/3374] Create
 2273-find-resultant-array-after-removing-anagrams.js

---
 ...resultant-array-after-removing-anagrams.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2273-find-resultant-array-after-removing-anagrams.js

diff --git a/2273-find-resultant-array-after-removing-anagrams.js b/2273-find-resultant-array-after-removing-anagrams.js
new file mode 100644
index 00000000..c9775eff
--- /dev/null
+++ b/2273-find-resultant-array-after-removing-anagrams.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string[]} words
+ * @return {string[]}
+ */
+const removeAnagrams = function(words) {
+  const res = []
+  const n = words.length
+
+  for(let i = 0; i < n;) {
+    let j = i + 1
+    while(j < n && isAna(words[i], words[j])) j++
+    res.push(words[i])
+    i = j
+  }
+  return res
+  
+  function isAna(s1, s2) {
+    const arr = Array(26).fill(0)
+    const a = 'a'.charCodeAt(0)
+    for(let i = 0; i < s1.length; i++) {
+      arr[s1.charCodeAt(i) - a]++
+    }
+    for(let i = 0; i < s2.length; i++) {
+      arr[s2.charCodeAt(i) - a]--
+    }
+    for(const e of arr) {
+      if(e !== 0) return false
+    }
+    return true
+  }
+};
+

From 3c768111fb57d67e207852d41d886dfc43459064 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 May 2022 19:33:03 +0800
Subject: [PATCH 2029/3374] Create
 2274-maximum-consecutive-floors-without-special-floors.js

---
 ...nsecutive-floors-without-special-floors.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2274-maximum-consecutive-floors-without-special-floors.js

diff --git a/2274-maximum-consecutive-floors-without-special-floors.js b/2274-maximum-consecutive-floors-without-special-floors.js
new file mode 100644
index 00000000..aa9e7b72
--- /dev/null
+++ b/2274-maximum-consecutive-floors-without-special-floors.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} bottom
+ * @param {number} top
+ * @param {number[]} special
+ * @return {number}
+ */
+var maxConsecutive = function(bottom, top, special) {
+  special.sort((a, b) => a - b)
+  let res = 0
+  
+  if(bottom < special[0]) {
+    res = special[0] - bottom
+  }
+  for(let i = 1; i < special.length; i++) {
+    res = Math.max(res, special[i] - special[i - 1] - 1)
+  }
+  if(top > special[special.length - 1]) {
+    res = Math.max(res, top - special[special.length - 1])
+  }
+  
+  return res
+};

From 196758fa2ddf46621d364616f0d96e9e1589c08a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 May 2022 21:59:05 +0800
Subject: [PATCH 2030/3374] Update 1094-car-pooling.js

---
 1094-car-pooling.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1094-car-pooling.js b/1094-car-pooling.js
index 3d987e2d..a37547cf 100644
--- a/1094-car-pooling.js
+++ b/1094-car-pooling.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} trips
+ * @param {number} capacity
+ * @return {boolean}
+ */
+const carPooling = function(trips, capacity) {
+  const arr = Array(1001).fill(0)
+  for(const [num, s, e] of trips) {
+    arr[s] += num
+    arr[e] -= num
+  }
+  for(let i = 1; i < 1001; i++) {
+    arr[i] += arr[i - 1]
+  }
+  
+  for(let e of arr) {
+    if(e > capacity) return false
+  }
+  return true
+};
+
+// another
+
 /**
  * @param {number[][]} trips
  * @param {number} capacity

From 630689135e79c462cf56bea9d32a5b36a67871b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 May 2022 22:47:28 +0800
Subject: [PATCH 2031/3374] Create
 2275-largest-combination-with-bitwise-and-greater-than-zero.js

---
 ...bination-with-bitwise-and-greater-than-zero.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2275-largest-combination-with-bitwise-and-greater-than-zero.js

diff --git a/2275-largest-combination-with-bitwise-and-greater-than-zero.js b/2275-largest-combination-with-bitwise-and-greater-than-zero.js
new file mode 100644
index 00000000..615ce874
--- /dev/null
+++ b/2275-largest-combination-with-bitwise-and-greater-than-zero.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} candidates
+ * @return {number}
+ */
+const largestCombination = function(candidates) {
+  let res = 0
+  for(let i = 0; i < 25; i++) {
+    let tmp = 0, bit = 1 << i
+    for(const e of candidates) {
+      if((e & bit) !== 0) tmp++
+    }
+    res = Math.max(res, tmp)
+  }
+  return res
+};

From bca3f783e078b21520607797729577c440996600 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 May 2022 10:21:53 +0800
Subject: [PATCH 2032/3374] Update 1109-corporate-flight-bookings.js

---
 1109-corporate-flight-bookings.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1109-corporate-flight-bookings.js b/1109-corporate-flight-bookings.js
index bb980cc8..8fe83d1c 100644
--- a/1109-corporate-flight-bookings.js
+++ b/1109-corporate-flight-bookings.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[][]} bookings
+ * @param {number} n
+ * @return {number[]}
+ */
+const corpFlightBookings = function(bookings, n) {
+  const arr = Array(n + 2).fill(0)
+  for(const [s, e, num] of bookings) {
+    arr[s] += num
+    arr[e + 1] -= num
+  }
+  for(let i = 1; i < n + 2; i++) {
+    arr[i] += arr[i - 1]
+  }
+  arr.pop()
+  arr.shift()
+  return arr
+};
+
+// another
+
 /**
  * @param {number[][]} bookings
  * @param {number} n

From dc18d3a4f1147836e155842469f811612caeaec8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 May 2022 11:11:36 +0800
Subject: [PATCH 2033/3374] Create 2276-count-integers-in-intervals.js

---
 2276-count-integers-in-intervals.js | 78 +++++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 2276-count-integers-in-intervals.js

diff --git a/2276-count-integers-in-intervals.js b/2276-count-integers-in-intervals.js
new file mode 100644
index 00000000..27e49fca
--- /dev/null
+++ b/2276-count-integers-in-intervals.js
@@ -0,0 +1,78 @@
+var CountIntervals = function () {
+  this.root = new Node(1, 10 ** 9)
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+CountIntervals.prototype.add = function (left, right) {
+  this.root.addInterval(left, right)
+}
+
+/**
+ * @return {number}
+ */
+CountIntervals.prototype.count = function () {
+  return this.root.total
+}
+
+/**
+ * Your CountIntervals object will be instantiated and called as such:
+ * var obj = new CountIntervals()
+ * obj.add(left,right)
+ * var param_2 = obj.count()
+ */
+
+class Node {
+  constructor(min, max) {
+    this.min = min
+    this.max = max
+    this.currentMin = -1
+    this.currentMax = -1
+    this.total = 0
+    this.left = null
+    this.right = null
+  }
+
+  addInterval(left, right) {
+    if (this.currentMin < 0) {
+      this.currentMin = left
+      this.currentMax = right
+      this.total = right - left + 1
+      return this.total
+    }
+
+    const mid = (this.min + this.max) >> 1
+
+    if (this.left) {
+      if (left <= mid) this.left.addInterval(left, Math.min(mid, right))
+      if (right > mid) this.right.addInterval(Math.max(mid + 1, left), right)
+
+      this.total = this.left.total + this.right.total
+      return
+    }
+
+    if (left <= this.currentMax + 1 && right >= this.currentMin - 1) {
+      this.currentMin = Math.min(this.currentMin, left)
+      this.currentMax = Math.max(this.currentMax, right)
+      this.total = this.currentMax - this.currentMin + 1
+      return
+    }
+    this.left = new Node(this.min, mid)
+    this.right = new Node(mid + 1, this.max)
+
+    if (left <= mid) this.left.addInterval(left, Math.min(mid, right))
+    if (right > mid) this.right.addInterval(Math.max(left, mid + 1), right)
+    if (this.currentMin <= mid)
+      this.left.addInterval(this.currentMin, Math.min(mid, this.currentMax))
+    if (this.currentMax > mid)
+      this.right.addInterval(
+        Math.max(mid + 1, this.currentMin),
+        this.currentMax
+      )
+
+    this.total = this.left.total + this.right.total
+  }
+}

From a197b4fe8302c7ddf910227d23eda18bb04275ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 May 2022 12:14:14 +0800
Subject: [PATCH 2034/3374] Update 759-employee-free-time.js

---
 759-employee-free-time.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/759-employee-free-time.js b/759-employee-free-time.js
index ff19b672..1bb666d6 100644
--- a/759-employee-free-time.js
+++ b/759-employee-free-time.js
@@ -145,3 +145,37 @@ const employeeFreeTime = function (schedule) {
   return res
 }
 
+// another
+
+/**
+ * // Definition for an Interval.
+ * function Interval(start, end) {
+ *    this.start = start;
+ *    this.end = end;
+ * };
+ */
+
+/**
+ * @param {Interval[][]} schedule
+ * @return {Interval[]}
+ */
+var employeeFreeTime = function(schedule) {
+  const arr = schedule.reduce((ac, e) => {
+    ac.push(...e)
+    return ac
+  }, [])
+  arr.sort((a, b) => a.start - b.start || b.end - a.end)
+  const n = arr.length
+  const res = []
+  let end = arr[0].end
+  for(let i = 1; i < n; i++) {
+    const cur = arr[i]
+    if(cur.start > end) {
+      res.push(new Interval(end, cur.start))
+    }
+    
+    end = Math.max(end, cur.end)
+  }
+  
+  return res
+};

From 03867fff4a1aa017d64aa9db6a425ebebc4dd9c7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 May 2022 12:29:19 +0800
Subject: [PATCH 2035/3374] Update 1871-jump-game-vii.js

---
 1871-jump-game-vii.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1871-jump-game-vii.js b/1871-jump-game-vii.js
index ace67d12..55fd6fcf 100644
--- a/1871-jump-game-vii.js
+++ b/1871-jump-game-vii.js
@@ -74,3 +74,26 @@ const canReach = function(s, minJump, maxJump) {
   }
   return dp[n - 1]
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number} minJump
+ * @param {number} maxJump
+ * @return {boolean}
+ */
+const canReach = function(s, minJump, maxJump) {
+  const n = s.length
+  const dp = Array(n).fill(0)
+  dp[0] = 1
+  let pre = 0
+  for(let i = 1; i < n; i++) {
+    if(i < minJump) continue
+    if(i >= minJump) pre += dp[i - minJump]
+    if(i > maxJump) pre -= dp[i - maxJump - 1]
+    dp[i] = pre > 0 && s[i] === '0' ? 1 : 0
+  }
+  
+  return dp[n - 1] ? true : false
+};

From 841839f369d99e702576bfecb397fd0412195d8a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 May 2022 16:46:56 +0800
Subject: [PATCH 2036/3374] Create 1271-hexspeak.js

---
 1271-hexspeak.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1271-hexspeak.js

diff --git a/1271-hexspeak.js b/1271-hexspeak.js
new file mode 100644
index 00000000..446c5713
--- /dev/null
+++ b/1271-hexspeak.js
@@ -0,0 +1,15 @@
+/**
+ * @param {string} num
+ * @return {string}
+ */
+var toHexspeak = function(num) {
+  const hex = ((+num)).toString(16).toUpperCase()
+  let res = ''
+  for(let ch of hex) {
+    if(ch > '1' && ch <= '9') return 'ERROR'
+    else if(ch === '0') res += 'O'
+    else if(ch === '1') res += 'I'
+    else res += ch
+  }
+  return res
+};

From 4dc5c7291e39ee92a1a2383d11d65e346b05c4f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 May 2022 16:52:07 +0800
Subject: [PATCH 2037/3374] Create 2235-add-two-integers.js

---
 2235-add-two-integers.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 2235-add-two-integers.js

diff --git a/2235-add-two-integers.js b/2235-add-two-integers.js
new file mode 100644
index 00000000..f90c2657
--- /dev/null
+++ b/2235-add-two-integers.js
@@ -0,0 +1,8 @@
+/**
+ * @param {number} num1
+ * @param {number} num2
+ * @return {number}
+ */
+var sum = function(num1, num2) {
+  return num1 + num2
+};

From af5dcf041da331f349af3132b71fd3c6868c8c72 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 May 2022 17:37:52 +0800
Subject: [PATCH 2038/3374] Create 2270-number-of-ways-to-split-array.js

---
 2270-number-of-ways-to-split-array.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2270-number-of-ways-to-split-array.js

diff --git a/2270-number-of-ways-to-split-array.js b/2270-number-of-ways-to-split-array.js
new file mode 100644
index 00000000..ac92367e
--- /dev/null
+++ b/2270-number-of-ways-to-split-array.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var waysToSplitArray = function(nums) {
+  let res = 0, sum = 0
+  const n = nums.length
+  if(n === 0) return res
+  const pre = Array(n).fill(0)
+  pre[0] = nums[0]
+  sum += nums[0]
+  for(let i = 1; i < n; i++) {
+    pre[i] = nums[i] + pre[i - 1]
+    sum += nums[i]
+  }
+  for(let i = 0; i < n - 1; i++) {
+    if(pre[i] >= sum - pre[i]) res++
+  }
+  
+  return res
+};

From 3c4b7ce9e7d8a8891e24caa6a70dfc3e6da0e2ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 May 2022 13:58:39 +0800
Subject: [PATCH 2039/3374] Update
 1589-maximum-sum-obtained-of-any-permutation.js

---
 ...maximum-sum-obtained-of-any-permutation.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1589-maximum-sum-obtained-of-any-permutation.js b/1589-maximum-sum-obtained-of-any-permutation.js
index 0baa6812..54b7f955 100644
--- a/1589-maximum-sum-obtained-of-any-permutation.js
+++ b/1589-maximum-sum-obtained-of-any-permutation.js
@@ -46,3 +46,34 @@ const maxSumRangeQuery = function (nums, requests) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maxSumRangeQuery = function (nums, requests) {
+  const n = nums.length
+
+  const arr = Array(n + 1).fill(0) 
+  for(const [s, e] of requests) {
+    arr[s] += 1
+    arr[e + 1] -= 1
+  }
+  for(let i = 1; i <= n; i++) {
+    arr[i] += arr[i - 1] 
+  }
+  arr.sort((a, b) => b - a)
+  nums.sort((a, b) => b - a)
+  let res = 0
+  const mod = 1e9 + 7
+  
+  for (let i = 0; i < n; i++) {
+    if(arr[i] <= 0) break
+    res = (res + nums[i] * arr[i]) % mod
+  }
+  
+  return res
+}

From 822980d8f86b77832db0a61597485cd210198c5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 May 2022 12:54:08 +0800
Subject: [PATCH 2040/3374] Create
 2015-average-height-of-buildings-in-each-segment.js

---
 ...age-height-of-buildings-in-each-segment.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 2015-average-height-of-buildings-in-each-segment.js

diff --git a/2015-average-height-of-buildings-in-each-segment.js b/2015-average-height-of-buildings-in-each-segment.js
new file mode 100644
index 00000000..9a33b888
--- /dev/null
+++ b/2015-average-height-of-buildings-in-each-segment.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} buildings
+ * @return {number[][]}
+ */
+const averageHeightOfBuildings = function (buildings) {
+  const hash = {},
+    cnt = {}
+  for (const [s, e, h] of buildings) {
+    if (hash[s] == null) hash[s] = 0
+    if (hash[e] == null) hash[e] = 0
+    if (cnt[s] == null) cnt[s] = 0
+    if (cnt[e] == null) cnt[e] = 0
+    hash[s] += h
+    hash[e] -= h
+    cnt[s]++
+    cnt[e]--
+  }
+
+  const res = []
+  const keys = Object.keys(hash).map((e) => +e)
+  keys.sort((a, b) => a - b)
+
+  let h = 0,
+    c = 0
+  for (let i = 0; i < keys.length; i++) {
+    const p = keys[i],
+      hc = cnt[p]
+    if (h) res[res.length - 1][1] = p
+    h += hash[p]
+    c += cnt[p]
+    if (
+      h &&
+      (res.length === 0 ||
+        res[res.length - 1][1] != p ||
+        res[res.length - 1][2] != ~~(h / c))
+    )
+      res.push([p, p, ~~(h / c)])
+  }
+
+  return res
+}

From 33ac4f4290fce6c9bb028a0635ed2833862ac582 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 May 2022 12:57:28 +0800
Subject: [PATCH 2041/3374] Update
 2015-average-height-of-buildings-in-each-segment.js

---
 ...verage-height-of-buildings-in-each-segment.js | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/2015-average-height-of-buildings-in-each-segment.js b/2015-average-height-of-buildings-in-each-segment.js
index 9a33b888..9d50ac58 100644
--- a/2015-average-height-of-buildings-in-each-segment.js
+++ b/2015-average-height-of-buildings-in-each-segment.js
@@ -23,18 +23,18 @@ const averageHeightOfBuildings = function (buildings) {
   let h = 0,
     c = 0
   for (let i = 0; i < keys.length; i++) {
-    const p = keys[i],
-      hc = cnt[p]
-    if (h) res[res.length - 1][1] = p
-    h += hash[p]
-    c += cnt[p]
+    const k = keys[i],
+      hc = cnt[k]
+    if (h) res[res.length - 1][1] = k
+    h += hash[k]
+    c += cnt[k]
     if (
       h &&
       (res.length === 0 ||
-        res[res.length - 1][1] != p ||
-        res[res.length - 1][2] != ~~(h / c))
+        res[res.length - 1][1] !== k ||
+        res[res.length - 1][2] !== ~~(h / c))
     )
-      res.push([p, p, ~~(h / c)])
+      res.push([k, k, ~~(h / c)])
   }
 
   return res

From 2173a6f2ac9887f7fe67283c77f7b259882f452e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 May 2022 21:16:52 +0800
Subject: [PATCH 2042/3374] Update
 2015-average-height-of-buildings-in-each-segment.js

---
 ...age-height-of-buildings-in-each-segment.js | 47 +++++++++----------
 1 file changed, 21 insertions(+), 26 deletions(-)

diff --git a/2015-average-height-of-buildings-in-each-segment.js b/2015-average-height-of-buildings-in-each-segment.js
index 9d50ac58..c58a3b4f 100644
--- a/2015-average-height-of-buildings-in-each-segment.js
+++ b/2015-average-height-of-buildings-in-each-segment.js
@@ -2,40 +2,35 @@
  * @param {number[][]} buildings
  * @return {number[][]}
  */
-const averageHeightOfBuildings = function (buildings) {
-  const hash = {},
-    cnt = {}
-  for (const [s, e, h] of buildings) {
-    if (hash[s] == null) hash[s] = 0
-    if (hash[e] == null) hash[e] = 0
-    if (cnt[s] == null) cnt[s] = 0
-    if (cnt[e] == null) cnt[e] = 0
+const averageHeightOfBuildings = function(buildings) {
+  const hash = {}, cnt = {}
+  for(const [s, e, h] of buildings) {
+    if(hash[s] == null) hash[s] = 0
+    if(hash[e] == null) hash[e] = 0
+    if(cnt[s] == null) cnt[s] = 0
+    if(cnt[e] == null) cnt[e] = 0
     hash[s] += h
     hash[e] -= h
     cnt[s]++
     cnt[e]--
   }
-
+  
   const res = []
-  const keys = Object.keys(hash).map((e) => +e)
+  const keys = Object.keys(hash).map(e => +e)
   keys.sort((a, b) => a - b)
-
-  let h = 0,
-    c = 0
-  for (let i = 0; i < keys.length; i++) {
-    const k = keys[i],
-      hc = cnt[k]
-    if (h) res[res.length - 1][1] = k
+  let h = 0, c = 0
+  for(const k of keys) {
+    if(h) res[res.length - 1][1] = k
     h += hash[k]
     c += cnt[k]
-    if (
-      h &&
-      (res.length === 0 ||
-        res[res.length - 1][1] !== k ||
-        res[res.length - 1][2] !== ~~(h / c))
-    )
-      res.push([k, k, ~~(h / c)])
+    const avg = ~~(h / c)
+    if(h && (
+      res.length === 0 ||
+      res[res.length - 1][1] !== k ||
+      res[res.length - 1][2] !== avg
+    )) {
+      res.push([k, k, avg])   
+    }
   }
-
   return res
-}
+};

From 8d89d6d87173f1db17573d3b080197aaeeccfb11 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 May 2022 10:51:08 +0800
Subject: [PATCH 2043/3374] Update 1943-describe-the-painting.js

---
 1943-describe-the-painting.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1943-describe-the-painting.js b/1943-describe-the-painting.js
index 872b3bc2..59191bb1 100644
--- a/1943-describe-the-painting.js
+++ b/1943-describe-the-painting.js
@@ -22,3 +22,34 @@ const splitPainting = function(segments) {
   } 
   return res
 };
+
+// another
+
+/**
+ * @param {number[][]} segments
+ * @return {number[][]}
+ */
+const splitPainting = function(segments) {
+  const sum = {}
+  for(const [s, e, v] of segments) {
+    if(sum[s] == null) sum[s] = 0
+    if(sum[e] == null) sum[e] = 0
+    sum[s] += v
+    sum[e] -= v
+  }
+  const keys = Object.keys(sum).map(e => +e)
+  keys.sort((a, b) => a - b)
+  const res = []
+  let pre = 0, s = 0, n = keys.length
+  for(let i = 0; i < n; i++) {
+    const k = keys[i]
+    
+    if(s) {
+      res.push([pre, k, s])
+    }
+    s += sum[k]
+    pre = k
+  }
+  
+  return res
+};

From d3400258ec85508c41353a0712d2d60b00ba4d1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 May 2022 21:30:01 +0800
Subject: [PATCH 2044/3374] Create
 2237-count-positions-on-street-with-required-brightness.js

---
 ...ions-on-street-with-required-brightness.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2237-count-positions-on-street-with-required-brightness.js

diff --git a/2237-count-positions-on-street-with-required-brightness.js b/2237-count-positions-on-street-with-required-brightness.js
new file mode 100644
index 00000000..8ee6b11e
--- /dev/null
+++ b/2237-count-positions-on-street-with-required-brightness.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} n
+ * @param {number[][]} lights
+ * @param {number[]} requirement
+ * @return {number}
+ */
+var meetRequirement = function(n, lights, requirement) {
+  const arr = Array(n + 1).fill(0)
+  for(const [pos, ra] of lights) {
+    const start = Math.max(0, pos - ra)
+    const end = Math.min(n - 1, pos + ra)
+    arr[start]++
+    arr[end + 1]--
+  }
+  for(let i = 1; i <= n; i++) {
+    arr[i] += arr[i - 1]
+  }
+  
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    if(arr[i] >= requirement[i]) res++
+  }
+  
+  return res
+};

From 5b4cfd52c7faa9bc16c404963c0d804e14dc82d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 May 2022 21:36:21 +0800
Subject: [PATCH 2045/3374] Create
 2280-minimum-lines-to-represent-a-line-chart.js

---
 ...minimum-lines-to-represent-a-line-chart.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2280-minimum-lines-to-represent-a-line-chart.js

diff --git a/2280-minimum-lines-to-represent-a-line-chart.js b/2280-minimum-lines-to-represent-a-line-chart.js
new file mode 100644
index 00000000..96ae3aa4
--- /dev/null
+++ b/2280-minimum-lines-to-represent-a-line-chart.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} stockPrices
+ * @return {number}
+ */
+var minimumLines = function(stockPrices) {
+  let res = 1
+  const ma = stockPrices
+  const n = ma.length
+  if(n === 0 || n === 1) return 0
+  ma.sort((a, b) => a[0] - b[0])
+  const eps = 1e-30
+  let dx = ma[1][0] - ma[0][0], dy = ma[1][1] - ma[0][1]
+  for(let i = 2; i < n; i++) {
+    const cur = ma[i], pre = ma[i - 1]
+    const dxx = cur[0] - pre[0], dyy = cur[1] - pre[1]
+    if(BigInt(dxx) * BigInt(dy) !== BigInt(dx) * BigInt(dyy)) res++
+    dx = dxx
+    dy = dyy
+  }
+  
+  return res
+};
+
+function product(p1, p2, p3) {
+    // 首先根据坐标计算p1p2和p1p3的向量，然后再计算叉乘
+    // p1p2 向量表示为 (p2.x-p1.x,p2.y-p1.y)
+    // p1p3 向量表示为 (p3.x-p1.x,p3.y-p1.y)
+    return (p2.x-p1.x)*(p3.y-p1.y) - (p2.y-p1.y)*(p3.x-p1.x);
+}

From 721e107d2b4a3c18b7cdfaaa228c4a6ff3e794be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 May 2022 20:41:02 +0800
Subject: [PATCH 2046/3374] Update
 995-minimum-number-of-k-consecutive-bit-flips.js

---
 ...nimum-number-of-k-consecutive-bit-flips.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/995-minimum-number-of-k-consecutive-bit-flips.js b/995-minimum-number-of-k-consecutive-bit-flips.js
index 4b26d18b..90a4ad92 100644
--- a/995-minimum-number-of-k-consecutive-bit-flips.js
+++ b/995-minimum-number-of-k-consecutive-bit-flips.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minKBitFlips = function(nums, k) {
+  let cur = 0, res = 0
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    if(i >= k && nums[i - k] === 2) cur--
+    if(cur % 2 === nums[i]) {
+      if(i + k > n) return -1
+      nums[i] = 2
+      cur++
+      res++
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} K

From 1180f9e8579cbb39fc1d23a73103ac916e97ae4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 May 2022 21:10:01 +0800
Subject: [PATCH 2047/3374] Update
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
index 2fbf8c14..a8b1835b 100644
--- a/1674-minimum-moves-to-make-array-complementary.js
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -56,3 +56,31 @@ const minMoves = function (nums, limit) {
   
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const minMoves = function (nums, limit) {
+  const n = nums.length, { min, max } = Math
+  const arr = Array(2 * limit + 2).fill(0)
+  for(let i = 0, r = n / 2; i < r; i++) {
+    const a = nums[i], b = nums[n - 1 - i]
+    arr[2] += 2
+    arr[min(a, b) + 1]--
+    arr[a + b]--
+    arr[a + b + 1]++
+    arr[max(a, b) + limit + 1]++
+  }
+  let res = Infinity, cur = 0
+  for(let i = 2, r = 2 * limit; i <= r; i++) {
+    cur += arr[i]
+    res = min(res, cur)
+  }
+  
+  return res
+}
+

From 044aca28b086f1be48d23ee3dc037ee29ff9d07b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 May 2022 21:34:59 +0800
Subject: [PATCH 2048/3374] Update
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
index a8b1835b..c257d2e2 100644
--- a/1674-minimum-moves-to-make-array-complementary.js
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -84,3 +84,36 @@ const minMoves = function (nums, limit) {
   return res
 }
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const minMoves = function (nums, limit) {
+  const n = nums.length, { min, max } = Math
+  const arr = Array(2 * limit + 2).fill(0)
+  for(let i = 0, r = n / 2; i < r; i++) {
+    const a = nums[i], b = nums[n - 1 - i]
+    // [2, 2 * limit]
+    arr[2] += 2
+    arr[2 * limit + 1] -= 2
+    // [min(a, b) + 1, max(a, b) + limit]
+    arr[min(a, b) + 1]--
+    arr[max(a, b) + limit + 1]++
+    // a + b
+    arr[a + b]--
+    arr[a + b + 1]++
+
+  }
+  let res = Infinity, cur = 0
+  for(let i = 2, r = 2 * limit; i <= r; i++) {
+    cur += arr[i]
+    res = min(res, cur)
+  }
+  
+  return res
+}
+
+

From ada43cb63cc647bd7a174fe2d0dff0f80325c409 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 May 2022 20:42:31 +0800
Subject: [PATCH 2049/3374] Update 798-smallest-rotation-with-highest-score.js

---
 798-smallest-rotation-with-highest-score.js | 32 ++++++++++++---------
 1 file changed, 19 insertions(+), 13 deletions(-)

diff --git a/798-smallest-rotation-with-highest-score.js b/798-smallest-rotation-with-highest-score.js
index fcb6fb0f..a76fca03 100644
--- a/798-smallest-rotation-with-highest-score.js
+++ b/798-smallest-rotation-with-highest-score.js
@@ -28,16 +28,22 @@ const bestRotation = function(A) {
 
 // another
 
-const bestRotation = function(A) {
-    let n = A.length;
-    let c = new Array(n).fill(0);
-    for(let i = 0; i < n; i++) {
-        c[(i - A[i] + 1 + n) % n] -= 1;
-    }
-    let max = 0;
-    for(let i = 1; i < n; i++) {
-        c[i] += c[i-1] + 1;
-        max = c[i] > c[max] ? i : max;
-    }
-    return max;
-}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var bestRotation = function(nums) {
+  const n = nums.length
+  const arr = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    arr[(i - nums[i] + 1 + n) % n] -= 1
+  }
+  let res = 0
+  for(let i = 1; i < n; i++) {
+    arr[i] += arr[i - 1] + 1
+    if(arr[i] > arr[res]) res = i
+  }
+  return res
+};
+
+

From bbc58d54c074dc65de6139d45e3e8ea3aa7699d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 13:57:34 +0800
Subject: [PATCH 2050/3374] Create
 2290-minimum-obstacle-removal-to-reach-corner.js

---
 ...inimum-obstacle-removal-to-reach-corner.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2290-minimum-obstacle-removal-to-reach-corner.js

diff --git a/2290-minimum-obstacle-removal-to-reach-corner.js b/2290-minimum-obstacle-removal-to-reach-corner.js
new file mode 100644
index 00000000..84e799ff
--- /dev/null
+++ b/2290-minimum-obstacle-removal-to-reach-corner.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumObstacles = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const dist = Array.from({ length: m }, () => Array(n).fill(Infinity))
+  const pq = new MinPriorityQueue({ priority: (x) => x[0] })
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  dist[0][0] = 0
+  pq.enqueue([dist[0][0], 0, 0])
+  while(pq.size()) {
+    const [v, i, j] = pq.dequeue().element
+    if(i === m - 1 && j === n - 1) return v
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      if(nx >= 0 && nx < m && ny >= 0 && ny < n && v + grid[nx][ny] < dist[nx][ny]) {
+        dist[nx][ny] = v + grid[nx][ny]
+        pq.enqueue([dist[nx][ny], nx, ny])
+      }
+    }
+  }
+};

From 881ef4058b4cbc6ecc47871f8f54d74510f9c1a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 14:02:51 +0800
Subject: [PATCH 2051/3374] Create 2288-apply-discount-to-prices.js

---
 2288-apply-discount-to-prices.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2288-apply-discount-to-prices.js

diff --git a/2288-apply-discount-to-prices.js b/2288-apply-discount-to-prices.js
new file mode 100644
index 00000000..c353d5c3
--- /dev/null
+++ b/2288-apply-discount-to-prices.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} sentence
+ * @param {number} discount
+ * @return {string}
+ */
+var discountPrices = function(sentence, discount) {
+   const arr = sentence.split(' '), n = arr.length
+   for(let i = 0; i < n; i++) {
+     const cur = arr[i]
+     const rest = cur.slice(1)
+     if(cur.startsWith('$') && rest.length && !Number.isNaN(+rest)) {
+       arr[i] = '$' + ((+rest) * (100 - discount) / 100).toFixed(2)
+     }
+   }
+  return arr.join(' ')
+};

From 92d492ffe30e9a55808cd915d2c23a08a183bc3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 14:03:24 +0800
Subject: [PATCH 2052/3374] Create
 2287-rearrange-characters-to-make-target-string.js

---
 ...rrange-characters-to-make-target-string.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2287-rearrange-characters-to-make-target-string.js

diff --git a/2287-rearrange-characters-to-make-target-string.js b/2287-rearrange-characters-to-make-target-string.js
new file mode 100644
index 00000000..d7eb46f9
--- /dev/null
+++ b/2287-rearrange-characters-to-make-target-string.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {string} target
+ * @return {number}
+ */
+var rearrangeCharacters = function(s, target) {
+  const a = 'a'.charCodeAt(0), arr = Array(26).fill(0)
+  for(let ch of target) {
+    arr[ch.charCodeAt(0) - a]++
+  }
+  let min = Math.min(...arr.filter(e => e > 0))
+  const sa = Array(26).fill(0)
+  for(const e of s) {
+    sa[e.charCodeAt(0) - a]++
+  }
+  let res = -1
+  for(let i = 0; i < 26; i++) {
+    const sv = sa[i], tv = arr[i]
+    if(tv === 0) continue
+    const v = ~~(sv / tv)
+    if(res === -1) res = v
+    else res = Math.min(res, v)
+  }
+  
+  return res
+};

From 1e058a855de9506205665c3218e02759a8b55c47 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 14:14:31 +0800
Subject: [PATCH 2053/3374] Create 2289-steps-to-make-array-non-decreasing.js

---
 2289-steps-to-make-array-non-decreasing.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2289-steps-to-make-array-non-decreasing.js

diff --git a/2289-steps-to-make-array-non-decreasing.js b/2289-steps-to-make-array-non-decreasing.js
new file mode 100644
index 00000000..9e61e117
--- /dev/null
+++ b/2289-steps-to-make-array-non-decreasing.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var totalSteps = function(nums) {
+  const n = nums.length
+  let res = 0, j = -1;
+  const dp = Array(n).fill(0), stack = Array(n).fill(0);
+  for (let i = n - 1; i >= 0; --i) {
+    while (j >= 0 && nums[i] > nums[stack[j]]) {
+      dp[i] = Math.max(++dp[i], dp[stack[j--]])
+      res = Math.max(res, dp[i])
+    }
+    stack[++j] = i
+  }
+  return res
+};

From 47cdc19372b5970635ad3b711aa4eac07418ccb8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 20:38:07 +0800
Subject: [PATCH 2054/3374] Update 2262-total-appeal-of-a-string.js

---
 2262-total-appeal-of-a-string.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/2262-total-appeal-of-a-string.js b/2262-total-appeal-of-a-string.js
index 799c6884..5c49b49f 100644
--- a/2262-total-appeal-of-a-string.js
+++ b/2262-total-appeal-of-a-string.js
@@ -1,3 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var appealSum = function (s) {
+  const pos = Array(26).fill(-1)
+  let ans = 0
+  const n = s.length
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0; i < n; i++) {
+    let tmp = n - i
+    if (pos[s.charCodeAt(i) - a] !== -1)
+      tmp += (i - pos[s.charCodeAt(i) - a] - 1) * (n - i)
+    else tmp += i * (n - i)
+    ans += tmp
+    pos[s.charCodeAt(i) - a] = i
+  }
+  return ans
+}
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From e1fbc0db0fd0ffd8ab614515b1ec4185bd6c733d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 May 2022 20:53:52 +0800
Subject: [PATCH 2055/3374] Update 2262-total-appeal-of-a-string.js

---
 2262-total-appeal-of-a-string.js | 25 +++++++++++++------------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/2262-total-appeal-of-a-string.js b/2262-total-appeal-of-a-string.js
index 5c49b49f..96fdec98 100644
--- a/2262-total-appeal-of-a-string.js
+++ b/2262-total-appeal-of-a-string.js
@@ -2,22 +2,23 @@
  * @param {string} s
  * @return {number}
  */
-var appealSum = function (s) {
-  const pos = Array(26).fill(-1)
-  let ans = 0
-  const n = s.length
+const appealSum = function (s) {
+  const n = s.length, pos = Array(26).fill(-1)
+  let res = 0
   const a = 'a'.charCodeAt(0)
-  for (let i = 0; i < n; i++) {
-    let tmp = n - i
-    if (pos[s.charCodeAt(i) - a] !== -1)
-      tmp += (i - pos[s.charCodeAt(i) - a] - 1) * (n - i)
-    else tmp += i * (n - i)
-    ans += tmp
-    pos[s.charCodeAt(i) - a] = i
+  for(let i = 0; i < n; i++) {
+    let tmp = n - i, idx = s.charCodeAt(i) - a
+    if(pos[idx] !== -1) {
+       tmp += (i - pos[idx] - 1) * (n - i)
+    } else tmp += i * (n - i)
+    res += tmp
+    pos[idx] = i
   }
-  return ans
+  
+  return res
 }
 
+
 // another
 
 /**

From 2808f120bf47dad7eadcbac083b1256af96cf710 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 May 2022 20:58:34 +0800
Subject: [PATCH 2056/3374] Update 828-unique-letter-string.js

---
 828-unique-letter-string.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/828-unique-letter-string.js b/828-unique-letter-string.js
index aa19ae71..62fa088a 100644
--- a/828-unique-letter-string.js
+++ b/828-unique-letter-string.js
@@ -1,3 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const uniqueLetterString = function(s) {
+  const n = s.length
+  const arr = Array.from({ length: 26 }, () => Array(2).fill(-1))
+  const A = 'A'.charCodeAt(0)
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const idx = s.charCodeAt(i) - A
+    res += (i - arr[idx][1]) * (arr[idx][1] - arr[idx][0])
+    arr[idx] = [arr[idx][1], i]
+  }
+  
+  for(let i = 0; i < 26; i++) {
+    res += (n - arr[i][1]) * (arr[i][1] - arr[i][0])
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} S
  * @return {number}

From fce34a391d773b59cea3f1c8d5ad9bc7401163af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 May 2022 22:09:33 +0800
Subject: [PATCH 2057/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index c3c785c8..52e0a139 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -1,3 +1,35 @@
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+ const sumSubarrayMins = function (arr) {
+  const n = arr.length
+  const mod = 1e9 + 7, stk = []
+  const left = Array(n), right = Array(n)
+  for(let i = 0; i< n; i++) {
+    left[i] = i + 1
+    right[i] = n - i
+  }
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    while(stk.length && arr[stk[stk.length - 1]] > arr[i]) {
+      const idx = stk.pop()
+      right[idx] = i - idx
+    }
+    if (stk.length) left[i] = i - stk[stk.length - 1]
+    stk.push(i)
+    
+  }
+  for(let i = 0; i < n; i++) {
+    res = (res + arr[i] * left[i] * right[i]) % mod
+  }
+  
+  return res
+}
+ 
+// another
+
 /**
  * @param {number[]} arr
  * @return {number}

From 303f4de76de28ab017cd23b8c388b7953baedb91 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Jun 2022 21:02:23 +0800
Subject: [PATCH 2058/3374] Update 1856-maximum-subarray-min-product.js

---
 1856-maximum-subarray-min-product.js | 47 ++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1856-maximum-subarray-min-product.js b/1856-maximum-subarray-min-product.js
index 163784e3..aef4a778 100644
--- a/1856-maximum-subarray-min-product.js
+++ b/1856-maximum-subarray-min-product.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSumMinProduct = function(nums) {
+  const n = nums.length, left = Array(n).fill(0), right = Array(n).fill(n - 1)
+  const mod = BigInt(1e9 + 7)
+  let res = 0n
+  let stk = []
+  for(let i = 0; i < n; i++) {
+    while(stk.length && nums[stk[stk.length - 1]] >= nums[i]) {
+      stk.pop()
+    }
+    left[i] = stk.length ? stk[stk.length - 1] + 1 : 0
+    stk.push(i)
+  }
+  
+  stk = []
+  for(let i = n - 1; i >= 0; i--) {
+    while(stk.length && nums[stk[stk.length - 1]] >= nums[i]) {
+      stk.pop()
+    }
+    right[i] = stk.length ? stk[stk.length - 1] - 1 : n - 1
+    stk.push(i)
+  }
+  
+  const preSum = []
+  for(let i = 0; i < n; i++) {
+    preSum[i] = (i === 0 ? 0n : preSum[i - 1]) + BigInt(nums[i])
+  }
+  for(let i = 0; i < n; i++) {
+    res = max(res, fn(nums[i], left[i], right[i]))
+  }
+  
+  return res % mod
+  
+  function max(a, b) {
+    return a > b ? a : b
+  }
+  function fn(v, l, r) {
+    return BigInt(v) * (l === 0 ? preSum[r] : preSum[r] - preSum[l - 1])
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From 2d3c5ba09b0329d3d724b39ceee9c0c09fd163fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jun 2022 22:31:22 +0800
Subject: [PATCH 2059/3374] Update 2104-sum-of-subarray-ranges.js

---
 2104-sum-of-subarray-ranges.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/2104-sum-of-subarray-ranges.js b/2104-sum-of-subarray-ranges.js
index c3fae69d..2feb3f2e 100644
--- a/2104-sum-of-subarray-ranges.js
+++ b/2104-sum-of-subarray-ranges.js
@@ -16,3 +16,22 @@ const subArrayRanges = function(nums) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const subArrayRanges = function(nums) {
+  let res = 0, n = nums.length
+  for(let i = 0; i < n; i++) {
+    let max = nums[i], min = nums[i]
+    for(let j = i; j < n; j++) {
+      max = Math.max(max, nums[j])
+      min = Math.min(min, nums[j])
+      res += max - min
+    }
+  }
+  return res
+};

From 53c020ba130298f96b4100b78e285ab987aa3d81 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Jun 2022 18:41:22 +0800
Subject: [PATCH 2060/3374] Create
 1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js

---
 ...es-that-satisfy-the-given-sum-condition.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js

diff --git a/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js b/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js
new file mode 100644
index 00000000..8803f183
--- /dev/null
+++ b/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const numSubseq = function(nums, target) {
+  const n = nums.length, pow = Array(n), mod = 1e9 + 7
+  pow[0] = 1
+  for(let i = 1; i < n; i++) {
+    pow[i] = (pow[i - 1] * 2) % mod
+  }
+  nums.sort((a, b) => a - b)
+  let l = 0, r = n - 1, res = 0
+  while(l <= r) {
+    if(nums[l] + nums[r] > target) r--
+    else {
+      res = (res + pow[r - l]) % mod
+      l++
+    }
+  }
+  
+  return res
+};

From 2bb34c6d01715b4f5eb071161b323006572fcb5e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Jun 2022 22:42:31 +0800
Subject: [PATCH 2061/3374] Create 799-champagne-tower.js

---
 799-champagne-tower.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 799-champagne-tower.js

diff --git a/799-champagne-tower.js b/799-champagne-tower.js
new file mode 100644
index 00000000..fba3c3bd
--- /dev/null
+++ b/799-champagne-tower.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} poured
+ * @param {number} query_row
+ * @param {number} query_glass
+ * @return {number}
+ */
+const champagneTower = function(poured, query_row, query_glass) {
+  let curRow = [poured]
+  for(let i = 0; i <= query_row; i++) {
+    const nxtRow = Array(i + 2).fill(0)
+    for(let j = 0; j <= i; j++) {
+      if(curRow[j] > 1) {
+        nxtRow[j] += (curRow[j] - 1) / 2
+        nxtRow[j + 1] += (curRow[j] - 1) / 2
+        curRow[j] = 1
+      }
+    }
+    if(i !== query_row) curRow = nxtRow
+  }
+  
+  return curRow[query_glass]
+};

From 7b266620321fe3323bf92a1474afdd95cc4c228e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Jun 2022 23:20:42 +0800
Subject: [PATCH 2062/3374] Create 789-escape-the-ghosts.js

---
 789-escape-the-ghosts.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 789-escape-the-ghosts.js

diff --git a/789-escape-the-ghosts.js b/789-escape-the-ghosts.js
new file mode 100644
index 00000000..56e18c45
--- /dev/null
+++ b/789-escape-the-ghosts.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[][]} ghosts
+ * @param {number[]} target
+ * @return {boolean}
+ */
+var escapeGhosts = function(ghosts, target) {
+  let res = true 
+  const { abs } = Math, steps = abs(target[0]) + abs(target[1])
+  const [tx, ty] = target
+  for(const [x, y] of ghosts) {
+    if(abs(tx - x) + abs(ty - y) <= steps) return false
+  }
+  
+  return res
+};

From 6216f1cac449f172de105ff3ff1aeae77a974291 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Jun 2022 21:53:41 +0800
Subject: [PATCH 2063/3374] Create 2281-sum-of-total-strength-of-wizards.js

---
 2281-sum-of-total-strength-of-wizards.js | 53 ++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 2281-sum-of-total-strength-of-wizards.js

diff --git a/2281-sum-of-total-strength-of-wizards.js b/2281-sum-of-total-strength-of-wizards.js
new file mode 100644
index 00000000..5c6e9e1f
--- /dev/null
+++ b/2281-sum-of-total-strength-of-wizards.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number[]} strength
+ * @return {number}
+ */
+const totalStrength = function (strength) {
+  const mod = BigInt(1e9 + 7)
+  let res = 0n
+  const n = strength.length
+  strength = strength.map(e => BigInt(e))
+  const leftsum = Array(n + 1).fill(0n),
+    rightsum = Array(n + 1).fill(0n),
+    leftmul = Array(n + 1).fill(0n),
+    rightmul = Array(n + 1).fill(0n)
+  const asc = []
+  const big = BigInt
+
+  for (let i = 0; i < n; i++) {
+    leftsum[i + 1] = (leftsum[i] + strength[i]) % mod
+    leftmul[i + 1] = (leftmul[i] + big(i + 1) * strength[i]) % mod
+  }
+
+  for (let i = n - 1; i >= 0; i--) {
+    rightsum[i] = (rightsum[i + 1] + strength[i]) % mod
+    rightmul[i] = (rightmul[i + 1] + big(n - i) * strength[i]) % mod
+  }
+
+  // j is the exclusive right index
+  for (let j = 0; j <= n; j++) {
+    while (
+      asc.length &&
+      (j === n || strength[asc[asc.length - 1]] >= strength[j])
+    ) {
+      const k = asc.pop()
+      const i = asc.length === 0 ? 0 : asc[asc.length - 1] + 1
+      const left =
+        (mod +
+          leftmul[k + 1] -
+          leftmul[i] -
+          ((big(i) * (leftsum[k + 1] - leftsum[i])) % mod)) %
+        mod
+      const right =
+        (mod +
+          rightmul[k + 1] -
+          rightmul[j] -
+          ((big(n - j) * (rightsum[k + 1] - rightsum[j])) % mod)) %
+        mod
+      const sum = (left * big(j - k) + right * big(k - i + 1)) % mod
+      res = (res + sum * strength[k]) % mod
+    }
+    asc.push(j)
+  }
+  return res
+}

From 005aaf41b70377379acb4a6390b2343b2ad536d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jun 2022 12:26:26 +0800
Subject: [PATCH 2064/3374] Create 2293-min-max-game.js

---
 2293-min-max-game.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2293-min-max-game.js

diff --git a/2293-min-max-game.js b/2293-min-max-game.js
new file mode 100644
index 00000000..ba574743
--- /dev/null
+++ b/2293-min-max-game.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minMaxGame = function(nums) {
+  let cur = nums
+  while(cur.length > 1) {
+    const n = cur.length
+    const tmp = Array(n / 2)
+    for(let i = 0; i < n / 2; i++) {
+      const odd = i % 2 === 1
+      if(odd) {
+        tmp[i] = Math.max(cur[2 * i], cur[2 * i + 1])        
+      } else {
+        tmp[i] = Math.min(cur[2 * i], cur[2 * i + 1])
+      }
+    }
+    cur = tmp
+  }
+  
+  return cur[0]
+};

From 4685af942a30289fc57d09fae7771819fe62f04d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jun 2022 12:26:55 +0800
Subject: [PATCH 2065/3374] Create
 2294-partition-array-such-that-maximum-difference-is-k.js

---
 ...-array-such-that-maximum-difference-is-k.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2294-partition-array-such-that-maximum-difference-is-k.js

diff --git a/2294-partition-array-such-that-maximum-difference-is-k.js b/2294-partition-array-such-that-maximum-difference-is-k.js
new file mode 100644
index 00000000..86db6794
--- /dev/null
+++ b/2294-partition-array-such-that-maximum-difference-is-k.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var partitionArray = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let res = 1, pre = nums[0], n = nums.length
+  for(let i = 1; i < n; i++) {
+    const cur = nums[i]
+    if(cur - pre > k) {
+      res++
+      pre = cur
+    }
+  }
+  
+  return res
+};

From 67e3454e9302e9be71dca8cce98212a4cbe66de9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jun 2022 12:27:20 +0800
Subject: [PATCH 2066/3374] Create 2295-replace-elements-in-an-array.js

---
 2295-replace-elements-in-an-array.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2295-replace-elements-in-an-array.js

diff --git a/2295-replace-elements-in-an-array.js b/2295-replace-elements-in-an-array.js
new file mode 100644
index 00000000..97a9fd71
--- /dev/null
+++ b/2295-replace-elements-in-an-array.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} operations
+ * @return {number[]}
+ */
+var arrayChange = function(nums, operations) {
+  const map = new Map(), n = nums.length
+  const res = Array(n)
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    map.set(cur, i)
+    res[i] = cur
+  }
+  
+  for(const [v, vv] of operations) {
+    const idx = map.get(v)
+    res[idx] = vv
+    map.set(vv, idx)
+  }
+  
+  return res
+};

From bd78e5056835b30b32ce32f7448dbd4d3a3e531e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jun 2022 12:27:48 +0800
Subject: [PATCH 2067/3374] Create 2296-design-a-text-editor.js

---
 2296-design-a-text-editor.js | 73 ++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 2296-design-a-text-editor.js

diff --git a/2296-design-a-text-editor.js b/2296-design-a-text-editor.js
new file mode 100644
index 00000000..d7e1b392
--- /dev/null
+++ b/2296-design-a-text-editor.js
@@ -0,0 +1,73 @@
+class Node {
+  constructor(val) {
+    this.val = val
+    this.prev = null
+    this.next = null
+  }
+}
+
+var TextEditor = function() {
+ this.left = []
+ this.right = []
+ this.idx = 0
+};
+
+/** 
+ * @param {string} text
+ * @return {void}
+ */
+TextEditor.prototype.addText = function(text) {
+ for(const ch of text) this.left.push(ch)
+};
+
+/** 
+ * @param {number} k
+ * @return {number}
+ */
+TextEditor.prototype.deleteText = function(k) {
+  let res = 0
+  while(this.left.length && k) {
+    res++
+    this.left.pop()
+    k--
+  }
+  return res
+};
+
+/** 
+ * @param {number} k
+ * @return {string}
+ */
+TextEditor.prototype.cursorLeft = function(k) {
+  while(k && this.left.length) {
+  const tmp = this.left.pop()
+  this.right.push(tmp)
+    k--
+  }
+
+  return this.left.slice(Math.max(0, this.left.length - 10), this.left.length).join('')
+};
+
+/** 
+ * @param {number} k
+ * @return {string}
+ */
+TextEditor.prototype.cursorRight = function(k) {
+  while(k && this.right.length) {
+  const tmp = this.right.pop()
+  this.left.push(tmp)  
+    k--
+  }
+
+  return this.left.slice(Math.max(0, this.left.length - 10), this.left.length).join('')
+};
+
+
+/** 
+ * Your TextEditor object will be instantiated and called as such:
+ * var obj = new TextEditor()
+ * obj.addText(text)
+ * var param_2 = obj.deleteText(k)
+ * var param_3 = obj.cursorLeft(k)
+ * var param_4 = obj.cursorRight(k)
+ */

From dda0512f46b59fa1f179a3de72c9b4413351c665 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Jun 2022 21:42:49 +0800
Subject: [PATCH 2068/3374] Update 715-range-module.js

---
 715-range-module.js | 84 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/715-range-module.js b/715-range-module.js
index 3b9e4b9f..abeb83e4 100644
--- a/715-range-module.js
+++ b/715-range-module.js
@@ -198,3 +198,87 @@ RangeModule.prototype.removeRange = function (left, right) {
  * var param_2 = obj.queryRange(left,right)
  * obj.removeRange(left,right)
  */
+
+// another
+
+const RangeModule = function () {
+  this.intervals = []
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.addRange = function (left, right) {
+  const tmp = []
+  const n = this.intervals.length
+  for(let i = 0; i <= n; i++) {
+    const cur = this.intervals[i]
+    if(i === n || cur[0] > right) {
+      tmp.push([left, right])
+      while(i < n) tmp.push(this.intervals[i++])
+    }else if(cur[1] < left) {
+      tmp.push(cur)
+    }else {
+      //      cur[0] <=    right
+      // left      <= cur[1]
+      left = Math.min(left, cur[0])
+      right = Math.max(right, cur[1])
+    }
+  }
+    // console.log(tmp)
+  this.intervals = tmp
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {boolean}
+ */
+RangeModule.prototype.queryRange = function (left, right) {
+  const n = this.intervals.length, arr = this.intervals
+  let l = 0, r = n - 1
+  while(l <= r) {
+    const mid = ~~(l + (r - l) / 2)
+    if(arr[mid][0] >= right) r = mid - 1
+    else if(arr[mid][1] <= left) l = mid + 1
+    else return arr[mid][0] <= left && arr[mid][1] >= right
+  }
+  
+  return false
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.removeRange = function (left, right) {
+  const tmp = []
+  const n = this.intervals.length
+  
+  for(let i = 0; i < n; i++) {
+    const cur = this.intervals[i]
+    if(cur[1] < left) {
+      tmp.push(cur)
+    }else if(cur[0] > right) tmp.push(cur)
+    else {
+      // left <= cur[1]
+      //     cur[0]    <= right
+      if(left > cur[0]) tmp.push([cur[0], left])
+      if(right < cur[1]) tmp.push([right, cur[1]])
+    }
+  }
+  // console.log(tmp)
+  this.intervals = tmp
+}
+
+/**
+ * Your RangeModule object will be instantiated and called as such:
+ * var obj = new RangeModule()
+ * obj.addRange(left,right)
+ * var param_2 = obj.queryRange(left,right)
+ * obj.removeRange(left,right)
+ */
+

From 73e0fdd8800dcb1700339bd949a1bbce2baf6459 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jun 2022 10:38:13 +0800
Subject: [PATCH 2069/3374] Update 2276-count-integers-in-intervals.js

---
 2276-count-integers-in-intervals.js | 80 +++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)

diff --git a/2276-count-integers-in-intervals.js b/2276-count-integers-in-intervals.js
index 27e49fca..1fb492ad 100644
--- a/2276-count-integers-in-intervals.js
+++ b/2276-count-integers-in-intervals.js
@@ -1,3 +1,83 @@
+function binarySearch(l, r, fn) {
+  while (l <= r) {
+    const m = Math.floor((l + r) / 2)
+    if (fn(m)) {
+      l = m + 1
+    } else {
+      r = m - 1
+    }
+  }
+  return r
+}
+
+var CountIntervals = function () {
+  this.intervals = []
+  this.size = 0
+}
+
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {void}
+ */
+CountIntervals.prototype.add = function (left, right) {
+  const intervals = this.intervals
+  if (!intervals.length) {
+    intervals.push({ left, right })
+    this.size += right - left + 1
+  } else if (left > intervals[intervals.length - 1].right) {
+    intervals.push({ left, right })
+    this.size += right - left + 1
+  } else if (right < intervals[0].left) {
+    intervals.unshift({ left, right })
+    this.size += right - left + 1
+  } else {
+    const i = binarySearch(0, intervals.length - 1, (x) => {
+      return intervals[x].left < left
+    })
+    let j,
+      start,
+      end,
+      sum = 0
+    if (i < 0 || intervals[i].right < left) {
+      j = i + 1
+      start = left
+      end = right
+    } else {
+      j = i
+      start = intervals[j].left
+      end = right
+    }
+    let first = -1
+    while (j < intervals.length && right >= intervals[j].left) {
+      if (first < 0) first = j
+      end = Math.max(end, intervals[j].right)
+      sum += intervals[j].right - intervals[j].left + 1
+      j++
+    }
+    // delete [first, j)
+    // console.log('delete', j - first, '-', first, j)
+    this.size += end - start + 1 - sum
+    if (first < 0) {
+      this.intervals.splice(i + 1, 0, { left: start, right: end })
+    } else {
+      this.intervals.splice(first, j - first, { left: start, right: end })
+    }
+  }
+}
+
+/**
+ * @return {number}
+ */
+CountIntervals.prototype.count = function () {
+  return this.size
+}
+
+
+// another
+
+
+
 var CountIntervals = function () {
   this.root = new Node(1, 10 ** 9)
 }

From 26c9daa1a599915276f90151ac9ada8de2cee967 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jun 2022 21:00:00 +0800
Subject: [PATCH 2070/3374] Update 2276-count-integers-in-intervals.js

---
 2276-count-integers-in-intervals.js | 42 +++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2276-count-integers-in-intervals.js b/2276-count-integers-in-intervals.js
index 1fb492ad..2647fd6b 100644
--- a/2276-count-integers-in-intervals.js
+++ b/2276-count-integers-in-intervals.js
@@ -1,3 +1,45 @@
+var CountIntervals = function() {
+  this.intervals = []
+  this.ans = 0
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right
+ * @return {void}
+ */
+CountIntervals.prototype.add = function(left, right) {
+  let l = 0, r = this.intervals.length
+  while (l < r) {
+    const m = Math.floor((l + r) / 2)
+    if (this.intervals[m][1] >= left) {
+      r = m
+    } else {
+      l = m + 1
+    }
+  }
+  
+  let index = l
+  while (index < this.intervals.length && this.intervals[index][0] <= right) {
+    left = Math.min(left, this.intervals[index][0])
+    right = Math.max(right, this.intervals[index][1])
+    this.ans -= this.intervals[index][1] - this.intervals[index][0] + 1
+    index += 1
+  }
+  this.ans += right - left + 1
+  this.intervals.splice(l, index - l, [left, right])
+};
+
+
+/**
+ * @return {number}
+ */
+CountIntervals.prototype.count = function() {
+  return this.ans
+};
+
+// another
+
 function binarySearch(l, r, fn) {
   while (l <= r) {
     const m = Math.floor((l + r) / 2)

From e75e86a02398a81cfc2a9bd6ea87436cb3e3bfb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jun 2022 22:13:25 +0800
Subject: [PATCH 2071/3374] Create 1825-finding-mk-average.js

---
 1825-finding-mk-average.js | 109 +++++++++++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 1825-finding-mk-average.js

diff --git a/1825-finding-mk-average.js b/1825-finding-mk-average.js
new file mode 100644
index 00000000..a6936047
--- /dev/null
+++ b/1825-finding-mk-average.js
@@ -0,0 +1,109 @@
+/**
+ * @param {number} m
+ * @param {number} k
+ */
+const MKAverage = function (m, k) {
+  this.sum = 0
+  this.dataBuff = []
+  this.dataM = []
+  this.m = m
+  this.k = k
+  this.count = m - k - k
+}
+/**
+ * @param {number} num
+ * @return {void}
+ */
+MKAverage.prototype.addElement = function (num) {
+  const total = this.dataBuff.length
+  this.dataBuff.push(num)
+  if (total >= this.m) {
+    let index = binarySearch(
+      this.dataBuff,
+      this.dataM,
+      this.dataBuff[total - this.m]
+    )
+    this.dataM[index] = this.dataBuff.length - 1
+    if (index === 0 || num > this.dataBuff[this.dataM[index - 1]]) {
+      move2End(this.dataBuff, this.dataM, index)
+    } else if (
+      index === this.m - 1 ||
+      num < this.dataBuff[this.dataM[index - 1]]
+    ) {
+      move2Start(this.dataBuff, this.dataM, index)
+    }
+
+    this.sum = 0
+  } else {
+    this.dataM.push(this.dataBuff.length - 1)
+    move2Start(this.dataBuff, this.dataM, this.dataBuff.length - 1)
+  }
+}
+
+/**
+ * @return {number}
+ */
+MKAverage.prototype.calculateMKAverage = function () {
+  if (this.dataM.length < this.m) {
+    return -1
+  } else {
+    if (!this.sum) {
+      this.sum = calcSum(this.dataBuff, this.dataM, this.k, this.count)
+    }
+    return Math.floor(this.sum / this.count)
+  }
+}
+
+/**
+ * Your MKAverage object will be instantiated and called as such:
+ * var obj = new MKAverage(m, k)
+ * obj.addElement(num)
+ * var param_2 = obj.calculateMKAverage()
+ */
+function binarySearch(numArr, indexArr, tar) {
+  let left = 0
+  let right = indexArr.length - 1
+
+  while (left <= right) {
+    let mid = (left + right) >>> 1
+
+    if (numArr[indexArr[mid]] > tar) {
+      right = mid - 1
+    } else if (numArr[indexArr[mid]] < tar) {
+      left = mid + 1
+    } else {
+      return mid
+    }
+  }
+}
+function move2Start(numArr, indexArr, index) {
+  let tmp
+
+  while (index > 0 && numArr[indexArr[index]] < numArr[indexArr[index - 1]]) {
+    tmp = indexArr[index]
+    indexArr[index] = indexArr[index - 1]
+    indexArr[index - 1] = tmp
+    index--
+  }
+}
+function move2End(numArr, indexArr, index) {
+  let tmp
+
+  while (
+    index < indexArr.length - 1 &&
+    numArr[indexArr[index]] > numArr[indexArr[index + 1]]
+  ) {
+    tmp = indexArr[index]
+    indexArr[index] = indexArr[index + 1]
+    indexArr[index + 1] = tmp
+    index++
+  }
+}
+
+function calcSum(numArr, indexArr, start, count) {
+  let sum = 0
+  for (let i = 0; i < count; i++) {
+    sum += numArr[indexArr[i + start]]
+  }
+  return sum
+}

From 0b760be5440fb25f314045fc51e7f36cc81859b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Jun 2022 21:13:34 +0800
Subject: [PATCH 2072/3374] Create 2102-sequentially-ordinal-rank-tracker.js

---
 2102-sequentially-ordinal-rank-tracker.js | 112 ++++++++++++++++++++++
 1 file changed, 112 insertions(+)
 create mode 100644 2102-sequentially-ordinal-rank-tracker.js

diff --git a/2102-sequentially-ordinal-rank-tracker.js b/2102-sequentially-ordinal-rank-tracker.js
new file mode 100644
index 00000000..dd976e51
--- /dev/null
+++ b/2102-sequentially-ordinal-rank-tracker.js
@@ -0,0 +1,112 @@
+const maxComp = (a, b) => {
+  return a[1] === b[1] ? b[0].localeCompare(a[0]) > 0 : a[1] > b[1]
+}
+
+const minComp = (a, b) => {
+  return a[1] === b[1] ? a[0].localeCompare(b[0]) > 0: a[1] < b[1]
+}
+
+const SORTracker = function() {
+  // max
+  this.pq = new PriorityQueue(maxComp)
+  // min
+  this.best = new PriorityQueue(minComp)
+};
+
+/** 
+ * @param {string} name 
+ * @param {number} score
+ * @return {void}
+ */
+SORTracker.prototype.add = function(name, score) {
+  this.pq.push([name, score])
+  while(!this.best.isEmpty() && maxComp(this.pq.peek(), this.best.peek())) {
+    const a = this.best.pop(), b = this.pq.pop()
+    this.best.push(b)
+    this.pq.push(a)
+  }
+};
+
+/**
+ * @return {string}
+ */
+SORTracker.prototype.get = function() {
+  const tmp = this.pq.pop()
+  this.best.push(tmp)
+  return tmp[0]
+};
+
+/** 
+ * Your SORTracker object will be instantiated and called as such:
+ * var obj = new SORTracker()
+ * obj.add(name,score)
+ * var param_2 = obj.get()
+ */
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From dee7d338e400e4392706b8d34ab069af00115856 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jun 2022 19:19:55 +0800
Subject: [PATCH 2073/3374] Create
 2213-longest-substring-of-one-repeating-character.js

---
 ...st-substring-of-one-repeating-character.js | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 2213-longest-substring-of-one-repeating-character.js

diff --git a/2213-longest-substring-of-one-repeating-character.js b/2213-longest-substring-of-one-repeating-character.js
new file mode 100644
index 00000000..cb527cb1
--- /dev/null
+++ b/2213-longest-substring-of-one-repeating-character.js
@@ -0,0 +1,105 @@
+/**
+ * @param {string} s
+ * @param {string} queryCharacters
+ * @param {number[]} queryIndices
+ * @return {number[]}
+ */
+const longestRepeating = function(s, queryCharacters, queryIndices) {
+  let n = queryCharacters.length
+  const ans = []
+
+  const segmentTree = new SegmentTree(s)
+  for (let i = 0; i < n; i++) {
+    segmentTree.update(1, 0, s.length - 1, queryIndices[i], queryCharacters[i])
+    ans.push(segmentTree.getMax())
+  }
+
+  return ans
+};
+
+class TreeNode {
+  constructor(max, preStart, preEnd, sufStart, sufEnd) {
+    this.max = max
+    this.preStart = preStart
+    this.preEnd = preEnd
+    this.sufStart = sufStart
+    this.sufEnd = sufEnd
+  }
+}
+
+class SegmentTree {
+  constructor(s) {
+    this.n = s.length
+    this.s = s.split('')
+    this.tree = new Array(4 * s.length)
+    this.build(s, 1, 0, s.length - 1)
+  }
+
+  build(s, treeIndex, left, right) {
+    if (left === right) {
+      this.tree[treeIndex] = new TreeNode(1, left, left, right, right)
+      return
+    }
+
+    let mid = left + Math.floor((right - left) / 2)
+    this.build(s, treeIndex * 2, left, mid)
+    this.build(s, treeIndex * 2 + 1, mid + 1, right)
+
+    this.tree[treeIndex] = this.merge(
+      this.tree[treeIndex * 2],
+      this.tree[treeIndex * 2 + 1],
+      left,
+      mid,
+      right
+    )
+  }
+
+  update(treeIndex, left, right, index, val) {
+    if (left === right) {
+      this.tree[treeIndex] = new TreeNode(1, left, left, right, right)
+      this.s[index] = val
+      return
+    }
+
+    let mid = left + Math.floor((right - left) / 2)
+    if (mid < index) {
+      this.update(treeIndex * 2 + 1, mid + 1, right, index, val)
+    } else {
+      this.update(treeIndex * 2, left, mid, index, val)
+    }
+
+    this.tree[treeIndex] = this.merge(
+      this.tree[treeIndex * 2],
+      this.tree[treeIndex * 2 + 1],
+      left,
+      mid,
+      right
+    )
+  }
+
+  merge(l, r, left, mid, right) {
+    let max = Math.max(l.max, r.max)
+    let preStart = l.preStart
+    let preEnd = l.preEnd
+    let sufStart = r.sufStart
+    let sufEnd = r.sufEnd
+
+    if (this.s[mid] === this.s[mid + 1]) {
+      max = Math.max(max, r.preEnd - l.sufStart + 1)
+      if (l.preEnd - l.preStart + 1 === mid - left + 1) {
+        preEnd = r.preEnd
+      }
+      if (r.sufEnd - r.sufStart + 1 === right - mid) {
+        sufStart = l.sufStart
+      }
+    }
+
+    return new TreeNode(max, preStart, preEnd, sufStart, sufEnd)
+  }
+
+  getMax() {
+    return this.tree[1].max
+  }
+}
+
+

From 2fba763f234526a6aa5798dd122366c27a6cb57d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Jun 2022 19:57:53 +0800
Subject: [PATCH 2074/3374] Create 2286-booking-concert-tickets-in-groups.js

---
 2286-booking-concert-tickets-in-groups.js | 123 ++++++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 2286-booking-concert-tickets-in-groups.js

diff --git a/2286-booking-concert-tickets-in-groups.js b/2286-booking-concert-tickets-in-groups.js
new file mode 100644
index 00000000..231a0e73
--- /dev/null
+++ b/2286-booking-concert-tickets-in-groups.js
@@ -0,0 +1,123 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ */
+function BookMyShow(n, m) {
+    let a = Array(n).fill(0), st = new SegmentTreeRMQ(a), fen = new Fenwick(n + 3);
+    for (let i = 0; i < n; i++) fen.update(i, m);
+    return { gather, scatter }
+    function gather(k, maxRow) {
+        let idx = st.indexOf(0, m - k);
+        if (idx == -1 || idx > maxRow) return [];
+        let min = st.minx(idx, idx + 1);
+        st.update(idx, min + k);
+        fen.update(idx, -k);
+        return [idx, min];
+    }
+    function scatter(k, maxRow) {
+        let totToMaxRow = fen.query(maxRow);
+        if (totToMaxRow < k) return false;
+        while (k > 0) {
+            let idx = st.indexOf(0, m - 1);
+            if (idx == -1 || idx > maxRow) break;
+            let min = st.minx(idx, idx + 1);
+            let use = Math.min(k, m - min);
+            k -= use;
+            st.update(idx, min + use);
+            fen.update(idx, -use);
+        }
+        return true;
+    }
+}
+
+/** 
+ * Your BookMyShow object will be instantiated and called as such:
+ * var obj = new BookMyShow(n, m)
+ * var param_1 = obj.gather(k,maxRow)
+ * var param_2 = obj.scatter(k,maxRow)
+ */
+////////////////////////////////////////////////// Template ////////////////////////////////////////////////////////////////////
+function Fenwick(n) {
+    let a = Array(n).fill(0);
+    return { query, update, rangeSum, tree }
+    function query(i) { // [0, i] prefix sum
+        let sum = 0;
+        for (i++; i > 0; i = parent(i)) sum += a[i];
+        return sum;
+    }
+    function update(i, v) {
+        for (i++; i < n; i = next(i)) a[i] += v;
+    }
+    function rangeSum(l, r) {
+        return query(r) - query(l - 1);
+    }
+    function parent(x) {
+        return x - lowestOneBit(x);
+    }
+    function next(x) {
+        return x + lowestOneBit(x);
+    }
+    function lowestOneBit(x) {
+        return x & -x;
+    }
+    function tree() {
+        return a;
+    }
+}
+
+function SegmentTreeRMQ(A) {
+    let n = A.length, h = Math.ceil(Math.log2(n)), len = 2 * 2 ** h, a = Array(len).fill(Number.MAX_SAFE_INTEGER);
+    h = 2 ** h;
+    initializeFromArray();
+    return { update, minx, indexOf, tree }
+    function initializeFromArray() {
+        for (let i = 0; i < n; i++) a[h + i] = A[i];
+        for (let i = h - 1; i >= 1; i--) propagate(i);
+    }
+    function update(pos, v) {
+        a[h + pos] = v;
+        for (let i = parent(h + pos); i >= 1; i = parent(i)) propagate(i);
+    }
+    function propagate(i) {
+        a[i] = Math.min(a[left(i)], a[right(i)]);
+    }
+    function minx(l, r) {
+        let min = Number.MAX_SAFE_INTEGER;
+        if (l >= r) return min;
+        l += h;
+        r += h;
+        for (; l < r; l = parent(l), r = parent(r)) {
+            if (l & 1) min = Math.min(min, a[l++]);
+            if (r & 1) min = Math.min(min, a[--r]);
+        }
+        return min;
+    }
+    function indexOf(l, v) {
+        if (l >= h) return -1;
+        let cur = h + l;
+        while (1) {
+            if (a[cur] <= v) {
+                if (cur >= h) return cur - h;
+                cur = left(cur);
+            } else {
+                cur++;
+                if ((cur & cur - 1) == 0) return -1;
+                if (cur % 2 == 0) cur = parent(cur);
+            }
+        }
+    }
+    function parent(i) {
+        return i >> 1;
+    }
+    function left(i) {
+        return 2 * i;
+    }
+    function right(i) {
+        return 2 * i + 1;
+    }
+    function tree() {
+        return a;
+    }
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+

From 5857549cfda071aed60c4efe0e63f7718986802b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jun 2022 21:02:45 +0800
Subject: [PATCH 2075/3374] Create
 2271-maximum-white-tiles-covered-by-a-carpet.js

---
 ...maximum-white-tiles-covered-by-a-carpet.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2271-maximum-white-tiles-covered-by-a-carpet.js

diff --git a/2271-maximum-white-tiles-covered-by-a-carpet.js b/2271-maximum-white-tiles-covered-by-a-carpet.js
new file mode 100644
index 00000000..18c428b1
--- /dev/null
+++ b/2271-maximum-white-tiles-covered-by-a-carpet.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} tiles
+ * @param {number} carpetLen
+ * @return {number}
+ */
+const maximumWhiteTiles = function (tiles, carpetLen) {
+  const sorted = tiles.sort((a, b) => a[0] - b[0])
+  let res = 0
+
+  let total = 0
+  let right = 0
+
+  for (let tile of sorted) {
+    const start = tile[0]
+    const end = start + carpetLen - 1
+    while (right < sorted.length && tiles[right][1] < end) {
+      total += tiles[right][1] - tiles[right][0] + 1
+      right++
+    }
+    if (right === sorted.length || sorted[right][0] > end) {
+      res = Math.max(res, total)
+    } else {
+      res = Math.max(res, total + (end - tiles[right][0] + 1))
+    }
+    total -= tile[1] - tile[0] + 1
+  }
+
+  return res
+}

From ada8e8049acb424fedbe338c103db6044a48093a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jun 2022 21:22:27 +0800
Subject: [PATCH 2076/3374] Update
 2271-maximum-white-tiles-covered-by-a-carpet.js

---
 ...maximum-white-tiles-covered-by-a-carpet.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2271-maximum-white-tiles-covered-by-a-carpet.js b/2271-maximum-white-tiles-covered-by-a-carpet.js
index 18c428b1..f19e23d8 100644
--- a/2271-maximum-white-tiles-covered-by-a-carpet.js
+++ b/2271-maximum-white-tiles-covered-by-a-carpet.js
@@ -27,3 +27,34 @@ const maximumWhiteTiles = function (tiles, carpetLen) {
 
   return res
 }
+
+// another
+
+/**
+ * @param {number[][]} tiles
+ * @param {number} carpetLen
+ * @return {number}
+ */
+const maximumWhiteTiles = function (tiles, carpetLen) {
+  tiles.sort((a, b) => a[0] - b[0])
+  let res = 0, total = 0, right = 0
+  const n = tiles.length
+  for(let i = 0; i < n; i++) {
+    const [l, r] = tiles[i]
+    const end = l + carpetLen - 1
+    while(right < n && tiles[right][1] <= end) {
+      total += tiles[right][1] - tiles[right][0] + 1 
+      right++
+    }
+    
+    if(right === n || tiles[right][0] > end) {
+      res = Math.max(res, total)
+    } else {
+      res = Math.max(res, total + end - tiles[right][0] + 1)
+    }
+    
+    total -= r - l + 1
+  }
+  
+  return res
+}

From 6879876322971801516a1beb8c5fc2f2f1c0aada Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Jun 2022 21:30:38 +0800
Subject: [PATCH 2077/3374] Create 2304-minimum-path-cost-in-a-grid.js

---
 2304-minimum-path-cost-in-a-grid.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2304-minimum-path-cost-in-a-grid.js

diff --git a/2304-minimum-path-cost-in-a-grid.js b/2304-minimum-path-cost-in-a-grid.js
new file mode 100644
index 00000000..65d117c1
--- /dev/null
+++ b/2304-minimum-path-cost-in-a-grid.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} grid
+ * @param {number[][]} moveCost
+ * @return {number}
+ */
+var minPathCost = function(grid, moveCost) {
+  const m = grid.length, n = grid[0].length
+  const memo = Array.from({ length: 2 }, () => Array(n))
+  for(let i = 0; i < n; i++) {
+    memo[0][i] = grid[0][i]
+  }
+  let cur = 0
+  for(let i = 0; i < m - 1; i++) {
+    const nxt = cur ^ 1
+    for(let t = 0; t < n; t++) {
+      memo[nxt][t] = Infinity
+    }
+    for(let j = 0; j < n; j++) {
+      const v = grid[i][j]
+      for(let k = 0; k < n; k++) {
+        const cost = moveCost[v][k]
+        memo[nxt][k] = Math.min(memo[nxt][k], memo[cur][j] + grid[i + 1][k] + cost)
+      }
+    }
+    cur ^= 1
+  }
+  
+  return Math.min(...memo[cur])
+};

From a9eed43e3bc05697257b5ac1900dd4b803537679 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Jun 2022 21:31:13 +0800
Subject: [PATCH 2078/3374] Create 2303-calculate-amount-paid-in-taxes.js

---
 2303-calculate-amount-paid-in-taxes.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2303-calculate-amount-paid-in-taxes.js

diff --git a/2303-calculate-amount-paid-in-taxes.js b/2303-calculate-amount-paid-in-taxes.js
new file mode 100644
index 00000000..fd731f22
--- /dev/null
+++ b/2303-calculate-amount-paid-in-taxes.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[][]} brackets
+ * @param {number} income
+ * @return {number}
+ */
+var calculateTax = function(brackets, income) {
+  let res = 0
+  const arr = brackets
+  let first = Math.min(income, arr[0][0])
+  res = first * arr[0][1] / 100
+  let remain = income - first
+  for(let i = 1; i < arr.length; i++) {
+    if(remain === 0) break
+    const [cur, r] = arr[i]
+    const gap = cur - arr[i - 1][0]
+    const real = Math.min(gap, remain)
+    res += real * r / 100
+    remain -= real
+  }
+  
+  return res
+};

From f6c894f3c02369826c2b834af346b9fa2b4fe7a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Jun 2022 22:09:58 +0800
Subject: [PATCH 2079/3374] Create 2233-maximum-product-after-k-increments.js

---
 2233-maximum-product-after-k-increments.js | 90 ++++++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 2233-maximum-product-after-k-increments.js

diff --git a/2233-maximum-product-after-k-increments.js b/2233-maximum-product-after-k-increments.js
new file mode 100644
index 00000000..d65aa854
--- /dev/null
+++ b/2233-maximum-product-after-k-increments.js
@@ -0,0 +1,90 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumProduct = function (nums, k) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  let res = 1
+  for(const e of nums) pq.push(e)
+  const mod = 1e9 + 7
+  while(k) {
+    const e = pq.pop()
+    pq.push(e + 1)
+    k--
+  }
+  while(!pq.isEmpty()) {
+    const e = pq.pop()
+    res = (res * e) % mod
+  }
+  
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 0c30db186e97217ffcf64fdb3a16519adb6a9a97 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jun 2022 19:23:58 +0800
Subject: [PATCH 2080/3374] Create 2234-maximum-total-beauty-of-the-gardens.js

---
 2234-maximum-total-beauty-of-the-gardens.js | 93 +++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 2234-maximum-total-beauty-of-the-gardens.js

diff --git a/2234-maximum-total-beauty-of-the-gardens.js b/2234-maximum-total-beauty-of-the-gardens.js
new file mode 100644
index 00000000..01af8481
--- /dev/null
+++ b/2234-maximum-total-beauty-of-the-gardens.js
@@ -0,0 +1,93 @@
+/**
+ * @param {number[]} flowers
+ * @param {number} newFlowers
+ * @param {number} target
+ * @param {number} full
+ * @param {number} partial
+ * @return {number}
+ */
+const maximumBeauty = function (flowers, newFlowers, target, full, partial) {
+  flowers.sort((x, y) => x - y)
+  flowers = flowers.map((x) => Math.min(x, target))
+  let a = flowers,
+    n = a.length,
+    k = newFlowers,
+    pre = preSum(a),
+    bi = new Bisect()
+  let res = 0
+  for (let i = 0; i <= n; i++) {
+    if (i < n && a[n - 1 - i] == target) continue
+    let step = i * target - (pre[n] - pre[n - i])
+    if (step <= k) {
+      let beauty
+      if (i == n) {
+        beauty = i * full
+      } else {
+        let minPartial = BinarySearch(a[0], target, step, i)
+        beauty = i * full + minPartial * partial
+      }
+      if (beauty > res) res = beauty
+    }
+  }
+  return res
+
+  function BinarySearch (low, high, step, i) {
+    while (low < high - 1) {
+      let mid = low + parseInt((high - low) / 2)
+      if (possible(mid, step, i)) {
+        low = mid
+      } else {
+        high = mid
+      }
+    }
+    return low
+  }
+
+  function possible (m, step, i) {
+    let idx = bi.bisect_left(a, m, 0, n - i)
+    let need = m * idx - pre[idx]
+    return need <= k - step
+  }
+}
+
+/////////////////// Template /////////////////////////////////
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] > x ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+
+const preSum = (a) => {
+  let pre = [0]
+  for (let i = 0; i < a.length; i++) {
+    pre.push(pre[i] + a[i])
+  }
+  return pre
+}
+//////////////////////////////////////////////////////////////////

From bf9013997876f726c02b582efeec6d390763efdb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Jun 2022 20:28:19 +0800
Subject: [PATCH 2081/3374] Update
 2216-minimum-deletions-to-make-array-beautiful.js

---
 ...nimum-deletions-to-make-array-beautiful.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/2216-minimum-deletions-to-make-array-beautiful.js b/2216-minimum-deletions-to-make-array-beautiful.js
index f53288d5..4c7f09dd 100644
--- a/2216-minimum-deletions-to-make-array-beautiful.js
+++ b/2216-minimum-deletions-to-make-array-beautiful.js
@@ -1,3 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minDeletion = function(nums) {
+  let res = 0, n = nums.length
+
+  for(let i = 0; i < n; i += 2) {
+    while(i < n - 1 && nums[i] === nums[i + 1]) {
+      i++
+      res++
+    }
+  }
+  if((n - res) % 2 === 1) res++
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From df308a8e3037c03c2bea1b3e081128db71047de9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jun 2022 17:34:51 +0800
Subject: [PATCH 2082/3374] Update
 2275-largest-combination-with-bitwise-and-greater-than-zero.js

---
 ...tion-with-bitwise-and-greater-than-zero.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/2275-largest-combination-with-bitwise-and-greater-than-zero.js b/2275-largest-combination-with-bitwise-and-greater-than-zero.js
index 615ce874..e08649e4 100644
--- a/2275-largest-combination-with-bitwise-and-greater-than-zero.js
+++ b/2275-largest-combination-with-bitwise-and-greater-than-zero.js
@@ -13,3 +13,29 @@ const largestCombination = function(candidates) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} candidates
+ * @return {number}
+ */
+const largestCombination = function(candidates) {
+  const arr = Array(24).fill(0), len = 24
+  for(const e of candidates) {
+    const str = toBin(e)
+    for(let n = str.length, i = n - 1; i >= 0; i--) {
+      const cur = str[i]
+      if(cur === '1') {
+        arr[len - 1 - (n - 1 - i)]++
+      }
+    }
+  }
+  
+  return Math.max(...arr)
+  
+  function toBin(num) {
+    return (num >>> 0).toString(2)
+  }
+};
+

From bbc49a3d17a55b197012a92ffae035076c0a6714 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jun 2022 19:40:17 +0800
Subject: [PATCH 2083/3374] Create 1762-buildings-with-an-ocean-view.js

---
 1762-buildings-with-an-ocean-view.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1762-buildings-with-an-ocean-view.js

diff --git a/1762-buildings-with-an-ocean-view.js b/1762-buildings-with-an-ocean-view.js
new file mode 100644
index 00000000..85122399
--- /dev/null
+++ b/1762-buildings-with-an-ocean-view.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} heights
+ * @return {number[]}
+ */
+const findBuildings = function(heights) {
+  const n = heights.length, suffix = Array(n).fill(0)
+  let max = 0
+  const res = [n - 1]
+  for(let i = n - 2; i >= 0; i--) {
+    max = Math.max(max, heights[i + 1])
+    suffix[i] = max
+    if(max < heights[i]) res.push(i)
+  }
+  res.reverse()
+  return res
+};

From e37f67a35ba11ce1f28a33a4fea632d756c95288 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jun 2022 21:38:38 +0800
Subject: [PATCH 2084/3374] Create 1396-design-underground-system.js

---
 1396-design-underground-system.js | 49 +++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 1396-design-underground-system.js

diff --git a/1396-design-underground-system.js b/1396-design-underground-system.js
new file mode 100644
index 00000000..49f3866d
--- /dev/null
+++ b/1396-design-underground-system.js
@@ -0,0 +1,49 @@
+
+const UndergroundSystem = function() {
+  this.h = new Map()
+  this.routeMap = new Map()
+};
+
+/** 
+ * @param {number} id 
+ * @param {string} stationName 
+ * @param {number} t
+ * @return {void}
+ */
+UndergroundSystem.prototype.checkIn = function(id, stationName, t) {
+  this.h.set(id, [stationName, t])
+};
+
+/** 
+ * @param {number} id 
+ * @param {string} stationName 
+ * @param {number} t
+ * @return {void}
+ */
+UndergroundSystem.prototype.checkOut = function(id, stationName, t) {
+  const [sn, st] = this.h.get(id)
+  this.h.delete(id)
+  const route = `${sn},${stationName}`
+  const duration = t - st
+  const [totalTime, totalValue] = this.routeMap.get(route) || ([0, 0])
+  this.routeMap.set(route, [totalTime + duration, totalValue + 1])
+};
+
+/** 
+ * @param {string} startStation 
+ * @param {string} endStation
+ * @return {number}
+ */
+UndergroundSystem.prototype.getAverageTime = function(startStation, endStation) {
+  const k = `${startStation},${endStation}`
+  const [time, number] = this.routeMap.get(k)
+  return time / number
+};
+
+/** 
+ * Your UndergroundSystem object will be instantiated and called as such:
+ * var obj = new UndergroundSystem()
+ * obj.checkIn(id,stationName,t)
+ * obj.checkOut(id,stationName,t)
+ * var param_3 = obj.getAverageTime(startStation,endStation)
+ */

From 5014622e39e9c95ab9aba5e36a704a033d566f4e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jun 2022 22:21:07 +0800
Subject: [PATCH 2085/3374] Create 1268-search-suggestions-system.js

---
 1268-search-suggestions-system.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 1268-search-suggestions-system.js

diff --git a/1268-search-suggestions-system.js b/1268-search-suggestions-system.js
new file mode 100644
index 00000000..a583dd0f
--- /dev/null
+++ b/1268-search-suggestions-system.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string[]} products
+ * @param {string} searchWord
+ * @return {string[][]}
+ */
+const suggestedProducts = function(products, searchWord) {
+  const res = []
+  for(let i = 0, n = searchWord.length; i < n; i++) {
+    const tmp = [], pre = searchWord.slice(0, i + 1)
+    for(const e of products) {
+      if(e.startsWith(pre)) {
+        tmp.push(e)
+        tmp.sort((a, b) => a.localeCompare(b))
+        if(tmp.length > 3) tmp.pop()
+      }
+    }
+    res.push(tmp)
+  }
+  return res
+};

From 2c1121ca70907ddc7a69fee9151f257cecceb292 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jun 2022 22:56:53 +0800
Subject: [PATCH 2086/3374] Update 1268-search-suggestions-system.js

---
 1268-search-suggestions-system.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1268-search-suggestions-system.js b/1268-search-suggestions-system.js
index a583dd0f..c2b9ba09 100644
--- a/1268-search-suggestions-system.js
+++ b/1268-search-suggestions-system.js
@@ -1,3 +1,23 @@
+/**
+ * @param {string[]} products
+ * @param {string} searchWord
+ * @return {string[][]}
+ */
+const suggestedProducts = function(products, searchWord) {
+  products.sort()
+  let res = [], left = 0, right = products.length - 1
+  for (let i = 0; i < searchWord.length; i++) {
+    let c = searchWord.charAt(i), tmp = []
+    while (products[left]?.charAt(i) < c) left++
+    while (products[right]?.charAt(i) > c) right--
+    for (let j = 0; j < 3 && left + j <= right; j++) tmp.push(products[left+j])
+    res.push(tmp)
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {string[]} products
  * @param {string} searchWord

From 1e122fca29951145a0e7f45709a1320f19c65c8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jun 2022 20:33:56 +0800
Subject: [PATCH 2087/3374] Create 2306-naming-a-company.js

---
 2306-naming-a-company.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2306-naming-a-company.js

diff --git a/2306-naming-a-company.js b/2306-naming-a-company.js
new file mode 100644
index 00000000..626417ca
--- /dev/null
+++ b/2306-naming-a-company.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string[]} ideas
+ * @return {number}
+ */
+const distinctNames = function (ideas) {
+  let smap = Array.from({ length: 26 }, (_) => new Set()),
+    ans = 0
+  for (let i = 0; i < ideas.length; i++) {
+    let word = ideas[i]
+    smap[word.charCodeAt(0) - 97].add(word.slice(1))
+  }
+  for (let i = 0; i < 25; i++) {
+    let a = smap[i]
+    for (let j = i + 1; j < 26; j++) {
+      let b = smap[j],
+        count = 0
+      for (let w of a) if (b.has(w)) count++
+      ans += (a.size - count) * (b.size - count) * 2
+    }
+  }
+  return ans
+}

From f377ac3e309f43ab5345d16eafe8e88113507f9c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Jun 2022 21:14:12 +0800
Subject: [PATCH 2088/3374] Update 490-the-maze.js

---
 490-the-maze.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/490-the-maze.js b/490-the-maze.js
index ff002f72..11942f9a 100644
--- a/490-the-maze.js
+++ b/490-the-maze.js
@@ -138,3 +138,44 @@ function isValid(maze, row, col) {
     maze[row][col] !== 1
   )
 }
+
+// another
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} start
+ * @param {number[]} destination
+ * @return {boolean}
+ */
+const hasPath = function(maze, start, destination) {
+  const m = maze.length, n = maze[0].length
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  const visited = new Set()
+  let res = false
+  dfs(start[0], start[1])
+  return res
+  
+  function dfs(i, j) {
+    if(i < 0 || i >= m || j < 0 || j >= n || maze[i][j] === 1 || visited.has(`${i},${j}`)) return
+    if(i === destination[0] && j === destination[1]) {
+      res = true
+      return
+    }
+    visited.add(`${i},${j}`)
+    const ib = i, jb = j
+    for(const [dx, dy] of dirs) {
+      let ii = i, jj = j
+      while(
+        ii + dx >= 0 &&
+        ii + dx < m &&
+        jj + dy >= 0 &&
+        jj + dy < n &&
+        maze[ii + dx][jj + dy] === 0
+      ) {
+          ii += dx
+          jj += dy
+      }
+      dfs(ii, jj)
+    }
+  }
+};

From 656f155584174b2d8193743b2ff2a6ced4700b37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Jun 2022 22:06:37 +0800
Subject: [PATCH 2089/3374] Update 490-the-maze.js

---
 490-the-maze.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/490-the-maze.js b/490-the-maze.js
index 11942f9a..a19f6cb2 100644
--- a/490-the-maze.js
+++ b/490-the-maze.js
@@ -179,3 +179,37 @@ const hasPath = function(maze, start, destination) {
     }
   }
 };
+
+// another
+
+/**
+ * @param {number[][]} maze
+ * @param {number[]} start
+ * @param {number[]} destination
+ * @return {boolean}
+ */
+const hasPath = function(maze, start, destination) {
+  const m = maze.length, n = maze[0].length
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  const visited = new Set()
+  const q = [start]
+  while(q.length) {
+    const [i, j] = q.pop()
+    if(i === destination[0] && j === destination[1]) return true
+    visited.add(`${i},${j}`)
+    for(const [dx, dy] of dirs) {
+      let ni = i, nj = j
+      while(valid(ni + dx, nj + dy)) {
+        ni += dx
+        nj += dy
+      }
+      if(!visited.has(`${ni},${nj}`)) q.push([ni, nj])
+    }
+  }
+  
+  return false
+  
+  function valid(i, j) {
+    return i >= 0 && i < m && j >= 0 && j < n && maze[i][j] === 0
+  }
+};

From ac2e78eb7426e22255881fd68ad096f61c190d2f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 18 Jun 2022 22:58:50 +0800
Subject: [PATCH 2090/3374] Create 2258-escape-the-spreading-fire.js

---
 2258-escape-the-spreading-fire.js | 103 ++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 2258-escape-the-spreading-fire.js

diff --git a/2258-escape-the-spreading-fire.js b/2258-escape-the-spreading-fire.js
new file mode 100644
index 00000000..b5520376
--- /dev/null
+++ b/2258-escape-the-spreading-fire.js
@@ -0,0 +1,103 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maximumMinutes = function (grid) {
+  const [m, n] = [grid.length, grid[0].length]
+  const dir = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+
+  function isValidCell(x, y) {
+    return x >= 0 && x < m && y >= 0 && y < n
+  }
+
+  const fireDist = new Array(m)
+  for (let i = 0; i < m; i++) {
+    fireDist[i] = new Array(n).fill(Infinity)
+  }
+
+  const firePoints = []
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] === 1) {
+        firePoints.push([i, j])
+        fireDist[i][j] = 0
+      }
+    }
+  }
+
+  while (firePoints.length) {
+    const [x0, y0] = firePoints.shift()
+
+    for (const [dx, dy] of dir) {
+      const [x1, y1] = [x0 + dx, y0 + dy]
+
+      if (
+        isValidCell(x1, y1) &&
+        grid[x1][y1] === 0 &&
+        fireDist[x0][y0] + 1 < fireDist[x1][y1]
+      ) {
+        fireDist[x1][y1] = fireDist[x0][y0] + 1
+        firePoints.push([x1, y1])
+      }
+    }
+  }
+
+  function canEscape(delay) {
+    const visited = new Array(m)
+    for (let i = 0; i < m; i++) {
+      visited[i] = new Array(n).fill(false)
+    }
+
+    const queue = [[0, 0]]
+    let currMinutes = delay
+
+    while (queue.length) {
+      currMinutes++
+
+      for (let i = queue.length; i > 0; i--) {
+        const [i0, j0] = queue.shift()
+        visited[i0][j0] = true
+
+        for (const [di, dj] of dir) {
+          const [i1, j1] = [i0 + di, j0 + dj]
+
+          if (
+            isValidCell(i1, j1) &&
+            grid[i1][j1] === 0 &&
+            !visited[i1][j1] &&
+            (currMinutes < fireDist[i1][j1] ||
+              (currMinutes === fireDist[i1][j1] &&
+                i1 === m - 1 &&
+                j1 === n - 1))
+          ) {
+            if (i1 === m - 1 && j1 === n - 1) {
+              return true
+            }
+            queue.push([i1, j1])
+          }
+        }
+      }
+    }
+
+    return false
+  }
+
+  let [left, right] = [-1, 1_000_000_000]
+
+  while (left < right) {
+    const middle = Math.floor((left + right + 1) / 2)
+
+    if (canEscape(middle)) {
+      left = middle
+    } else {
+      right = middle - 1
+    }
+  }
+
+  return left
+}

From cd66066f09057fe88c62e30d0ed2da34994a5edf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Jun 2022 15:25:11 +0800
Subject: [PATCH 2091/3374] Create 2312-selling-pieces-of-wood.js

---
 2312-selling-pieces-of-wood.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2312-selling-pieces-of-wood.js

diff --git a/2312-selling-pieces-of-wood.js b/2312-selling-pieces-of-wood.js
new file mode 100644
index 00000000..073b0b4f
--- /dev/null
+++ b/2312-selling-pieces-of-wood.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} prices
+ * @return {number}
+ */
+const sellingWood = function(m, n, prices) {
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  for(const [h, w, p] of prices) {
+    dp[h][w] = p
+  }
+
+  for (let i = 1; i <= m; ++i) {
+    for (let j = 1; j <= n; ++j) {
+      for (let k = 1; k <= i / 2; ++k) {
+        dp[i][j] = Math.max(dp[i][j], dp[k][j] + dp[i - k][j]);
+      }
+      for (let k = 1; k <= j / 2; ++k) {
+        dp[i][j] = Math.max(dp[i][j], dp[i][k] + dp[i][j - k]);
+      }
+    }
+  }
+  return dp[m][n];
+};

From 29d9d8c7f71ea52873649f2e3d02845c9f577875 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Jun 2022 20:17:35 +0800
Subject: [PATCH 2092/3374] Update 2289-steps-to-make-array-non-decreasing.js

---
 2289-steps-to-make-array-non-decreasing.js | 25 ++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2289-steps-to-make-array-non-decreasing.js b/2289-steps-to-make-array-non-decreasing.js
index 9e61e117..a4b4c08f 100644
--- a/2289-steps-to-make-array-non-decreasing.js
+++ b/2289-steps-to-make-array-non-decreasing.js
@@ -15,3 +15,28 @@ var totalSteps = function(nums) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const totalSteps = function(nums) {
+  let res = 0, stk = []
+  stk.push([nums[0], 0])
+  for(let i = 1, n = nums.length; i < n; i++) {
+    let steps = 0
+    while(stk.length && stk[stk.length - 1][0] <= nums[i]) {
+      const peek = stk.pop() 
+      steps = Math.max(steps, peek[1])
+    }
+    if(stk.length === 0) steps = 0
+    else steps++
+    
+    res = Math.max(res, steps)
+    stk.push([nums[i], steps])
+  }  
+   
+   return res
+};

From 03733ab84e684f557594b9d8aa22a2aa3447e259 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Jun 2022 20:57:52 +0800
Subject: [PATCH 2093/3374] Update 2289-steps-to-make-array-non-decreasing.js

---
 2289-steps-to-make-array-non-decreasing.js | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/2289-steps-to-make-array-non-decreasing.js b/2289-steps-to-make-array-non-decreasing.js
index a4b4c08f..1fdfc322 100644
--- a/2289-steps-to-make-array-non-decreasing.js
+++ b/2289-steps-to-make-array-non-decreasing.js
@@ -40,3 +40,29 @@ const totalSteps = function(nums) {
    
    return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const totalSteps = function(nums) {
+  let res = 0
+  const stk = []
+  for(const e of nums) {
+    let steps = 1
+    while(stk.length && e >= stk[stk.length - 1][0]) {
+      const tmp = stk.pop()
+      steps = Math.max(tmp[1] + 1, steps)
+    }
+    if(stk.length === 0) steps = 0
+    else {
+      res = Math.max(res, steps)
+    }
+    stk.push([e, steps])
+  }
+  return res
+};
+
+

From 71618eb935a9d7f8500b28edec6d287bd8c54500 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jun 2022 10:58:02 +0800
Subject: [PATCH 2094/3374] Update 2101-detonate-the-maximum-bombs.js

---
 2101-detonate-the-maximum-bombs.js | 44 ++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/2101-detonate-the-maximum-bombs.js b/2101-detonate-the-maximum-bombs.js
index 8955bd15..7abf5737 100644
--- a/2101-detonate-the-maximum-bombs.js
+++ b/2101-detonate-the-maximum-bombs.js
@@ -36,3 +36,47 @@ function bombAdj(source, target) {
   const { abs } = Math
   return abs(x1 - x2) ** 2 + abs(y1 - y2) ** 2 <= r1 ** 2
 }
+
+// another
+
+/**
+ * @param {number[][]} bombs
+ * @return {number}
+ */
+const maximumDetonation = function(bombs) {
+  const n = bombs.length, graph = {}
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < n; j++) {
+      if(i === j) continue
+      if(adjValid(bombs[i], bombs[j])) {
+        if(graph[i] == null) graph[i] = []
+        graph[i].push(j)
+      }
+    }
+  }
+  
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const set = new Set([i])
+    dfs(i, set)
+    res = Math.max(res, set.size)
+  }
+  return res
+  
+  function dfs(node, visited){
+    for (const e of (graph[node] || [])) {
+      if(!visited.has(e)) {
+        visited.add(e)
+        dfs(e, visited)
+      }
+    }
+  }
+  
+  function adjValid(start, target) {
+    const [sx, sy, r] = start
+    const [ex, ey] = target
+    return Math.abs(sx - ex) ** 2 + Math.abs(sy - ey) ** 2 <= r ** 2
+  }
+};
+
+

From e33725c40197983c78e5bfcabb171f00f23a0f70 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jun 2022 21:26:11 +0800
Subject: [PATCH 2095/3374] Create
 2038-remove-colored-pieces-if-both-neighbors-are-the-same-color.js

---
 ...ed-pieces-if-both-neighbors-are-the-same-color.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 2038-remove-colored-pieces-if-both-neighbors-are-the-same-color.js

diff --git a/2038-remove-colored-pieces-if-both-neighbors-are-the-same-color.js b/2038-remove-colored-pieces-if-both-neighbors-are-the-same-color.js
new file mode 100644
index 00000000..e1dc029f
--- /dev/null
+++ b/2038-remove-colored-pieces-if-both-neighbors-are-the-same-color.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} colors
+ * @return {boolean}
+ */
+const winnerOfGame = function(colors) {
+  let ac = 0, bc = 0
+  for(let i = 1, n = colors.length; i < n - 1; i++) {
+    if(colors[i] === 'A' && colors[i - 1] === 'A' && colors[i + 1] === 'A') ac++
+    if(colors[i] === 'B' && colors[i - 1] === 'B' && colors[i + 1] === 'B') bc++
+  }
+  return ac > bc
+};

From 3e65329176e9ebd78244947d8891fa730eb4162a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jun 2022 22:12:55 +0800
Subject: [PATCH 2096/3374] Create 926-flip-string-to-monotone-increasing.js

---
 926-flip-string-to-monotone-increasing.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 926-flip-string-to-monotone-increasing.js

diff --git a/926-flip-string-to-monotone-increasing.js b/926-flip-string-to-monotone-increasing.js
new file mode 100644
index 00000000..22a94654
--- /dev/null
+++ b/926-flip-string-to-monotone-increasing.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minFlipsMonoIncr = function(s) {
+  const n = s.length
+  const arr = Array(n).fill(0)
+  let oneCnt = 0
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '1') oneCnt++
+    arr[i] = oneCnt
+  }
+  const zeroCnt = n - oneCnt
+  let res = Infinity
+  
+  for(let i = 0; i < n; i++) {
+    const cnt = arr[i]
+    const tmp = cnt + (zeroCnt - (i + 1 - cnt))
+    res = Math.min(res, tmp)
+  }
+  res = Math.min(res, oneCnt, zeroCnt)
+  return res
+};

From c6c5b8f88abd8d86811e43d923c3dfd3f6ef6fa4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Jun 2022 22:23:46 +0800
Subject: [PATCH 2097/3374] Update 926-flip-string-to-monotone-increasing.js

---
 926-flip-string-to-monotone-increasing.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/926-flip-string-to-monotone-increasing.js b/926-flip-string-to-monotone-increasing.js
index 22a94654..71f6bfff 100644
--- a/926-flip-string-to-monotone-increasing.js
+++ b/926-flip-string-to-monotone-increasing.js
@@ -1,3 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minFlipsMonoIncr = function(s) {
+  const n = s.length
+  let res = 0, oneCnt = 0
+  for(const e of s) {
+    if(e === '1') oneCnt++
+    else {
+      const stayZero = oneCnt
+      const flipToOne = res + 1
+      res = Math.min(stayZero, flipToOne)
+    }
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 6f123558b1c565bd4291a9e90f0f74d786e99596 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Jun 2022 14:28:29 +0800
Subject: [PATCH 2098/3374] Update
 2045-second-minimum-time-to-reach-destination.js

---
 ...econd-minimum-time-to-reach-destination.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/2045-second-minimum-time-to-reach-destination.js b/2045-second-minimum-time-to-reach-destination.js
index d77c8c8c..bec00cad 100644
--- a/2045-second-minimum-time-to-reach-destination.js
+++ b/2045-second-minimum-time-to-reach-destination.js
@@ -49,3 +49,46 @@ const secondMinimum = (n, edges, time, change) => {
   }
   return cost[n][1]
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} time
+ * @param {number} change
+ * @return {number}
+ */
+ var secondMinimum = function (n, edges, time, change) {
+  const graph = new Map()
+  for (let i = 1; i <= n; i++) graph.set(i, [])
+  for (const [u, v] of edges) {
+    graph.get(u).push(v)
+    graph.get(v).push(u)
+  }
+  const first = Array(n + 1).fill(Infinity)
+  const second = Array(n + 1).fill(Infinity)
+  first[1] = 0
+
+  const q = new MinPriorityQueue()
+  q.enqueue(1, 0)
+
+  while (q.size()) {
+    let {element: node, priority: cur} = q.dequeue()
+    cur += time // cur: arrival time
+    let leave = cur
+    if (~~(cur / change) & 1) leave += change - (cur % change)
+    for (let nei of graph.get(node)) {
+      if (second[nei] <= cur) continue
+      if (first[nei] === cur) continue
+      if (first[nei] > cur) {
+        second[nei] = first[nei]
+        first[nei] = cur
+      } else {
+        second[nei] = cur
+      }
+      q.enqueue(nei, leave)
+    }
+  }
+  return second[n]
+}

From bab4d27ba43734db15780ec2ad2b63c209f8c774 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Jun 2022 11:05:55 +0800
Subject: [PATCH 2099/3374] Update
 1263-minimum-moves-to-move-a-box-to-their-target-location.js

---
 ...-to-move-a-box-to-their-target-location.js | 96 +++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/1263-minimum-moves-to-move-a-box-to-their-target-location.js b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
index b92dbab3..2ec22d2d 100644
--- a/1263-minimum-moves-to-move-a-box-to-their-target-location.js
+++ b/1263-minimum-moves-to-move-a-box-to-their-target-location.js
@@ -1,3 +1,99 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+const minPushBox = function (grid) {
+  let box, person, target
+  const m = grid.length,
+    n = grid[0].length
+  const dirs = [
+    [-1, 0],
+    [1, 0],
+    [0, -1],
+    [0, 1],
+  ]
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const e = grid[i][j]
+      if (e === 'B') box = [i, j]
+      else if (e === 'T') target = [i, j]
+      else if (e === 'S') person = [i, j]
+    }
+  }
+
+  const valid = ([i, j]) => {
+    return i >= 0 && i < m && j >= 0 && j < n && grid[i][j] !== '#'
+  }
+  const key = ([i, j]) => `${i},${j}`
+
+  const chk = (person, newPerson, box) => {
+    const set = new Set()
+    set.add(key(box))
+    let q = [person]
+    while (q.length) {
+      const tmp = []
+      const size = q.length
+      for (let i = 0; i < size; i++) {
+        const [x, y] = q[i]
+        if (key([x, y]) === key(newPerson)) return true
+        for (const [dx, dy] of dirs) {
+          const [nx, ny] = [x + dx, y + dy]
+          if (valid([nx, ny]) && !set.has(key([nx, ny]))) {
+            set.add(key([nx, ny]))
+            tmp.push([nx, ny])
+          }
+        }
+      }
+      q = tmp
+    }
+    return false
+  }
+
+
+  let q = [[0, box, person]]
+  const dkey = (a, b) => `${a[0]},${a[1]}_${b[0]},${b[1]}`
+  const set = new Set()
+  set.add(dkey(box, person))
+  while (q.length) {
+    const size = q.length
+    const tmp = []
+    for (let i = 0; i < size; i++) {
+      const [v, b, p] = q[i]
+      if (key(b) === key(target)) return v
+      const bArr = [
+        [b[0], b[1] + 1],
+        [b[0], b[1] - 1],
+        [b[0] + 1, b[1]],
+        [b[0] - 1, b[1]],
+      ]
+      const pArr = [
+        [b[0], b[1] - 1],
+        [b[0], b[1] + 1],
+        [b[0] - 1, b[1]],
+        [b[0] + 1, b[1]],
+      ]
+
+      for (let j = 0; j < 4; j++) {
+        const nb = bArr[j],
+          np = pArr[j]
+        const nk = dkey(nb, b)
+
+        if (set.has(nk)) continue
+        if (valid(nb) && valid(np) && chk(p, np, b)) {
+          tmp.push([v + 1, nb, b])
+          set.add(nk)
+        }
+      }
+    }
+    q = tmp
+  }
+
+  return -1
+}
+
+// another
+
+
 /**
  * @param {character[][]} grid
  * @return {number}

From d1eb3180b965a66480135a7f800cfdb360f96ddc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Jun 2022 00:51:08 +0800
Subject: [PATCH 2100/3374] Update 1654-minimum-jumps-to-reach-home.js

---
 1654-minimum-jumps-to-reach-home.js | 47 +++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1654-minimum-jumps-to-reach-home.js b/1654-minimum-jumps-to-reach-home.js
index 6969ab4a..11ce519d 100644
--- a/1654-minimum-jumps-to-reach-home.js
+++ b/1654-minimum-jumps-to-reach-home.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number[]} forbidden
+ * @param {number} a
+ * @param {number} b
+ * @param {number} x
+ * @return {number}
+ */
+const minimumJumps = function (forbidden, a, b, x) {
+  const bad = new Set()
+  const set = new Set()
+  for (let i of forbidden) {
+    bad.add(i)
+  }
+  let q = []
+  q.push([0, 0, 0])
+  set.add('0,0')
+  while (q.length) {
+    const tmp = []
+    const size = q.length
+    for(let i = 0; i < size; i++) {
+      const [pos, level, state] = q[i]
+
+      if (pos === x) return level
+      if (state >= 0) {
+        if (pos <= 4000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+          set.add(pos + a + ',0')
+          tmp.push([pos + a, level + 1, 0])
+        }
+        if (!set.has(pos - b + ',-1') && !bad.has(pos - b) && pos - b >= 0) {
+          set.add(pos - b + ',-1')
+          tmp.push([pos - b, level + 1, -1])
+        }
+      } else if (state < 0) {
+        if (pos <= 4000 && !set.has(pos + a + ',0') && !bad.has(pos + a)) {
+          set.add(pos + a + ',0')
+          tmp.push([pos + a, level + 1, 0])
+        }
+      }      
+    }
+
+    q = tmp
+  }
+  return -1
+}
+
+// another
+
 /**
  * @param {number[]} forbidden
  * @param {number} a

From 46a6a07cca8025acf982761db268bc36d671e30e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Jun 2022 19:57:02 +0800
Subject: [PATCH 2101/3374] Update
 1617-count-subtrees-with-max-distance-between-cities.js

---
 ...btrees-with-max-distance-between-cities.js | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/1617-count-subtrees-with-max-distance-between-cities.js b/1617-count-subtrees-with-max-distance-between-cities.js
index aa468b83..3cc321c8 100644
--- a/1617-count-subtrees-with-max-distance-between-cities.js
+++ b/1617-count-subtrees-with-max-distance-between-cities.js
@@ -49,3 +49,70 @@ const countSubgraphsForEachDiameter = function (n, edges) {
     return ans;
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const countSubgraphsForEachDiameter = function(n, edges) {
+  const graph = {}
+  for(const [u, v] of edges) {
+    if(graph[u - 1] == null) graph[u - 1] = []
+    if(graph[v - 1] == null) graph[v - 1] = []
+    graph[u - 1].push(v - 1)
+    graph[v - 1].push(u - 1)
+  }
+  const res = Array(n - 1).fill(0)
+  
+  for(let i = 0, len = 2 ** n; i < len; i++) {
+    const dis = maxDistance(i)
+    if(dis > 0) res[dis - 1]++
+  }
+  
+  return res
+  
+  function bfs(src, cities) {
+    const visited = new Set([src])
+    let q = [[src, 0]]
+    let maxDist = 0
+    while(q.length) {
+      const tmp = []
+      const size = q.length
+      for(let i = 0; i < size; i++) {
+        const [u, d] = q[i]
+        maxDist = d
+        for(const v of (graph[u] || [])) {
+          if(cities.has(v) && !visited.has(v)) {
+            visited.add(v)
+            tmp.push([v, d + 1])
+          }
+        }
+      }
+      
+      q = tmp
+    }
+    
+    return [maxDist, visited]
+  }
+  
+  function maxDistance(state) {
+    const cities = new Set()
+    for(let i = 0; i < n; i++) {
+      if(state & (1 << i)) cities.add(i)
+    }
+    
+    let res = 0
+    for(const e of cities) {
+      const [maxDist, visited] = bfs(e, cities)
+      if(visited.size < cities.size) return 0
+      res = Math.max(res, maxDist) 
+    }
+    
+    return res
+  }
+}; 
+
+

From f60861577527bcc4fd725cd4b14d81ca445ca8b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jun 2022 18:05:17 +0800
Subject: [PATCH 2102/3374] Create
 2322-minimum-score-after-removals-on-a-tree.js

---
 ...-minimum-score-after-removals-on-a-tree.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 2322-minimum-score-after-removals-on-a-tree.js

diff --git a/2322-minimum-score-after-removals-on-a-tree.js b/2322-minimum-score-after-removals-on-a-tree.js
new file mode 100644
index 00000000..def6f468
--- /dev/null
+++ b/2322-minimum-score-after-removals-on-a-tree.js
@@ -0,0 +1,60 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var minimumScore = function (nums, edges) {
+  let n = nums.length,
+    ans = Infinity
+  let visited = Array(n).fill(0)
+  let pc = []
+  let adj = Array.from({ length: n }, () => [])
+  let child_xor = Array(n).fill(0)
+  let childs = Array.from({ length: n }, () => Array(n).fill(false))
+  const { min, max } = Math
+  let par = Array(n).fill(0)
+
+  // Creating an adjacency matrix
+  for (const edge of edges)
+    adj[edge[0]].push(edge[1]), adj[edge[1]].push(edge[0])
+
+  dfs(0)
+
+  // console.log(childs)
+  // console.log(pc)
+  for (let i = 0; i < pc.length; i++)
+    for (let j = i + 1; j < pc.length; j++) {
+      // removing an edge i and j
+      let a = pc[i][1],
+        b = pc[j][1] // node that will come below when you delete an edge i and j
+      let xa = child_xor[a],
+        xb = child_xor[b],
+        xc = child_xor[0]
+      // console.log(a,b)
+      if (childs[a][b]) (xc ^= xa), (xa ^= xb)
+      else (xc ^= xa), (xc ^= xb)
+
+      ans = min(max(xa, max(xb, xc)) - min(xa, min(xb, xc)), ans)
+    }
+
+  return ans
+
+  function dfs(i) {
+    let ans = nums[i]
+    visited[i] = true
+
+    for (let p of par) childs[p][i] = true // Defining this node as the child of all its parents
+
+    par.push(i)
+
+    for (let child of adj[i] || [])
+      if (!visited[child]) {
+        pc.push([i, child])
+        ans ^= dfs(child) // Recurcively calculating xors
+      }
+
+    par.pop()
+
+    return (child_xor[i] = ans)
+  }
+}

From f51cf4d4f8d7f4bb22fd6893e14cfc77cc392ee7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jun 2022 18:09:39 +0800
Subject: [PATCH 2103/3374] Create 2321-maximum-score-of-spliced-array.js

---
 2321-maximum-score-of-spliced-array.js | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2321-maximum-score-of-spliced-array.js

diff --git a/2321-maximum-score-of-spliced-array.js b/2321-maximum-score-of-spliced-array.js
new file mode 100644
index 00000000..7f1fec21
--- /dev/null
+++ b/2321-maximum-score-of-spliced-array.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var maximumsSplicedArray = function(nums1, nums2) {
+  let n = nums1.length;
+  let arr = new Array(n).fill(0);
+  let s1 = 0, s2 = 0;
+  for (let i = 0; i < n; i++) {
+      s1 += nums1[i];
+      s2 += nums2[i];
+  }
+  for (let i = 0; i < n; i++) {
+      arr[i] = nums1[i] - nums2[i];
+  }
+  let sum = 0;
+  let min1 = 0;
+  let max1 = 0;
+  for (let i = 0; i < n; i++) {
+      sum += arr[i];
+      max1 = Math.max(sum - min1, max1);
+      min1 = Math.min(min1, sum);
+  }
+  sum = 0;
+  let min2 = 0;
+  let max2 = 0;
+  for (let i = 0; i < n; i++) {
+      sum += arr[i];
+      min2 = Math.min(sum - max2, min2);
+      max2 = Math.max(max2, sum);
+  }
+  return Math.max(s2 + max1, s1 - min2);
+};

From bb1c838e92fa1b1782cb9fab759891463feab350 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jun 2022 18:10:09 +0800
Subject: [PATCH 2104/3374] Create 2320-count-number-of-ways-to-place-houses.js

---
 2320-count-number-of-ways-to-place-houses.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2320-count-number-of-ways-to-place-houses.js

diff --git a/2320-count-number-of-ways-to-place-houses.js b/2320-count-number-of-ways-to-place-houses.js
new file mode 100644
index 00000000..2b8f6052
--- /dev/null
+++ b/2320-count-number-of-ways-to-place-houses.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countHousePlacements = function(n) {
+  const mod = 1e9 + 7
+  let f0 = 1;
+  let f1 = 1;
+  for (let i = 1; i < n; i++) {
+      let nf0 = (f0 + f1) % mod;
+      let nf1 = f0;
+      f0 = nf0;
+      f1 = nf1;
+  }
+  let m = (f0 + f1) % mod;
+  return BigInt(m) * BigInt(m) % BigInt(mod)
+};

From 261f2d0e3c48cec65f229494c40af4c50b03b7d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jun 2022 18:10:38 +0800
Subject: [PATCH 2105/3374] Create 2319-check-if-matrix-is-x-matrix.js

---
 2319-check-if-matrix-is-x-matrix.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2319-check-if-matrix-is-x-matrix.js

diff --git a/2319-check-if-matrix-is-x-matrix.js b/2319-check-if-matrix-is-x-matrix.js
new file mode 100644
index 00000000..65bbdc79
--- /dev/null
+++ b/2319-check-if-matrix-is-x-matrix.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+var checkXMatrix = function(grid) {
+  const n = grid.length
+  const onDiag = (i, j) => {
+    return i === j || j === n - 1 - i
+  }
+  for(let i = 0; i < n; i++) {
+    for(let j = 0;j < n; j++) {
+      const valid = onDiag(i, j)
+      if(valid) {
+        if(grid[i][j] === 0) return false
+      }else {
+        if(grid[i][j] !== 0) return false
+      }
+    }
+  }
+  
+  return true
+};

From 27385835f2d9c8acb1408f44df623d5894052721 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Jun 2022 18:21:33 +0800
Subject: [PATCH 2106/3374] Create 2227-encrypt-and-decrypt-strings.js

---
 2227-encrypt-and-decrypt-strings.js | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2227-encrypt-and-decrypt-strings.js

diff --git a/2227-encrypt-and-decrypt-strings.js b/2227-encrypt-and-decrypt-strings.js
new file mode 100644
index 00000000..8178208e
--- /dev/null
+++ b/2227-encrypt-and-decrypt-strings.js
@@ -0,0 +1,30 @@
+class Encrypter {
+  constructor(keys, values, dictionary) {
+    this.mapKeyToValue = {};
+    this.mapCount = {};
+    const n = keys.length;
+
+    for (let i = 0; i < n; i++) {
+      const key = keys[i];
+      const value = values[i];
+      this.mapKeyToValue[key] = value;
+    }
+
+    for (const dict of dictionary) {
+      const encrypted = this.encrypt(dict);
+      this.mapCount[encrypted] = (this.mapCount[encrypted] || 0) + 1;
+    }
+  }
+
+  encrypt(word1) {
+    let res = '';
+    for (const char of word1) {
+      res += this.mapKeyToValue[char];
+    }
+    return res;
+  }
+
+  decrypt(word2) {
+    return this.mapCount[word2] || 0;
+  }
+}

From 6fbc803ac54599e73bf4697df59139ef06707190 Mon Sep 17 00:00:00 2001
From: Fayez Baig <59474861+fayez-baig@users.noreply.github.com>
Date: Mon, 27 Jun 2022 00:54:20 +0530
Subject: [PATCH 2107/3374] 1481 Least Number of Unique Integers after K
 Removals

---
 ...ber-of-unique-integers-after k-removals.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1481-least-number-of-unique-integers-after k-removals.js

diff --git a/1481-least-number-of-unique-integers-after k-removals.js b/1481-least-number-of-unique-integers-after k-removals.js
new file mode 100644
index 00000000..3c5796af
--- /dev/null
+++ b/1481-least-number-of-unique-integers-after k-removals.js	
@@ -0,0 +1,41 @@
+// Given an array of integers arr and an integer k. Find the least number of unique integers 
+// after removing exactly k elements.
+
+
+// Example 1:
+
+// Input: arr = [5,5,4], k = 1
+// Output: 1
+// Explanation: Remove the single 4, only 5 is left.
+// Example 2:
+// Input: arr = [4,3,1,1,3,3,2], k = 3
+// Output: 2
+// Explanation: Remove 4, 2 and either one of the two 1s or three 3s. 1 and 3 will be left.
+
+
+// Constraints:
+
+// 1 <= arr.length <= 10^5
+// 1 <= arr[i] <= 10^9
+// 0 <= k <= arr.length
+
+
+const findLeastNumOfUniqueInts = function (arr, k) {
+    const map = {}
+  
+    for (const num of arr) {
+      map[num] = map[num] || 0
+      map[num] += 1
+    }
+    const keys = Object.keys(map).sort((a, b) => map[a] - map[b])
+    for (const key of keys) {
+      while (map[key] > 0 && k > 0) {
+        k--
+        map[key] -= 1
+        if (map[key] === 0) {
+          delete map[key]
+        }
+      }
+    }
+    return Object.keys(map).length
+}
\ No newline at end of file

From df36e50cfa7e23817b0bfb4c358ae7fb0dac8262 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Jun 2022 15:58:18 +0800
Subject: [PATCH 2108/3374] Update 2166-design-bitset.js

---
 2166-design-bitset.js | 83 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/2166-design-bitset.js b/2166-design-bitset.js
index d38a595a..4c177ba6 100644
--- a/2166-design-bitset.js
+++ b/2166-design-bitset.js
@@ -1,3 +1,86 @@
+/**
+ * @param {number} size
+ */
+const Bitset = function (size) {
+  this.arr = Array.from({ length: 2 }, (el, idx) =>
+    Array(size).fill(idx === 0 ? 0 : 1)
+  )
+  this.cur = 0
+  this.cnt = 0
+}
+
+/**
+ * @param {number} idx
+ * @return {void}
+ */
+Bitset.prototype.fix = function (idx) {
+  if(this.arr[this.cur][idx] === 1) return
+  this.arr[this.cur][idx] = 1
+  this.arr[this.cur ^ 1][idx] = 0
+  this.cnt++
+}
+
+/**
+ * @param {number} idx
+ * @return {void}
+ */
+Bitset.prototype.unfix = function (idx) {
+  if(this.arr[this.cur][idx] === 0) return
+  this.arr[this.cur][idx] = 0
+  this.arr[this.cur ^ 1][idx] = 1
+  this.cnt--
+}
+
+/**
+ * @return {void}
+ */
+Bitset.prototype.flip = function () {
+  this.cur ^= 1
+  this.cnt = this.arr[this.cur].length - this.cnt
+}
+
+/**
+ * @return {boolean}
+ */
+Bitset.prototype.all = function () {
+  return this.cnt === this.arr[this.cur].length
+}
+
+/**
+ * @return {boolean}
+ */
+Bitset.prototype.one = function () {
+  return this.cnt > 0
+}
+
+/**
+ * @return {number}
+ */
+Bitset.prototype.count = function () {
+  return this.cnt
+}
+
+/**
+ * @return {string}
+ */
+Bitset.prototype.toString = function () {
+  return this.arr[this.cur].join('')
+}
+
+/**
+ * Your Bitset object will be instantiated and called as such:
+ * var obj = new Bitset(size)
+ * obj.fix(idx)
+ * obj.unfix(idx)
+ * obj.flip()
+ * var param_4 = obj.all()
+ * var param_5 = obj.one()
+ * var param_6 = obj.count()
+ * var param_7 = obj.toString()
+ */
+
+// another
+
 /**
  * @param {number} size
  */

From 53a5323136ea74a260c2ab9ff2b9fdeff8eba8cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Jun 2022 20:42:36 +0800
Subject: [PATCH 2109/3374] Create 1291-sequential-digits.js

---
 1291-sequential-digits.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1291-sequential-digits.js

diff --git a/1291-sequential-digits.js b/1291-sequential-digits.js
new file mode 100644
index 00000000..280eed23
--- /dev/null
+++ b/1291-sequential-digits.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number} low
+ * @param {number} high
+ * @return {number[]}
+ */
+const sequentialDigits = function(low, high) {
+   const set = new Set()
+   let start = 0, end = 0
+   for(let i = 10; i >= 0; i--) {
+     if (low / (10 ** i) >= 1) {
+       start = ~~(low / (10 ** i))
+       break
+     }
+   }
+   for(let i = 10; i >= 0; i--) {
+     if (high / (10 ** i) >= 1) {
+       end = ~~(high / (10 ** i))
+       break
+     }
+   }
+  for(let i = 1; i <= 9; i++) {
+   helper(`${i}`)    
+  }
+
+   const res = Array.from(set)
+  res.sort((a, b) => a- b)
+  return res
+   
+  function helper(s) {
+    // console.log(s)
+    if(+s > high) return
+    if(+s >= low && +s <= high) {
+      set.add(+s)
+    }
+    if(s[s.length - 1] === '9') return
+    helper(`${s}${+s[s.length - 1] + 1}`)
+  }
+};

From 5279809e8e9d317d08151220041b74ba4e6555b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Jun 2022 21:48:26 +0800
Subject: [PATCH 2110/3374] Update 1291-sequential-digits.js

---
 1291-sequential-digits.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1291-sequential-digits.js b/1291-sequential-digits.js
index 280eed23..3cd7049b 100644
--- a/1291-sequential-digits.js
+++ b/1291-sequential-digits.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number} low
+ * @param {number} high
+ * @return {number[]}
+ */
+const sequentialDigits = function(low, high) {
+  const res = []
+  
+  let q = []
+  for(let i = 1; i <= 9; i++) q.push(i)
+  
+  while(q.length) {
+    const tmp = []
+    const size = q.length
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      if(cur >= low && cur <= high) {
+        res.push(cur)
+      }
+      if(cur > high) break
+      const last = cur % 10
+      if(last === 9) continue
+      tmp.push(cur * 10 + last + 1)
+    }
+    
+    q = tmp
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number} low
  * @param {number} high

From 573bf16c9c86e018fa73702ac3859e1311c901f2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Jun 2022 17:20:40 +0800
Subject: [PATCH 2111/3374] Update 2296-design-a-text-editor.js

---
 2296-design-a-text-editor.js | 73 ++++++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)

diff --git a/2296-design-a-text-editor.js b/2296-design-a-text-editor.js
index d7e1b392..7df5b5ae 100644
--- a/2296-design-a-text-editor.js
+++ b/2296-design-a-text-editor.js
@@ -1,3 +1,76 @@
+const TextEditor = function () {
+  this.stk1 = []
+  this.stk2 = []
+}
+
+/**
+ * @param {string} text
+ * @return {void}
+ */
+TextEditor.prototype.addText = function (text) {
+  for(const ch of text) {
+      this.stk1.push(ch)
+  }
+}
+
+/**
+ * @param {number} k
+ * @return {number}
+ */
+TextEditor.prototype.deleteText = function (k) {
+  let res = 0
+  while(this.stk1.length && k) {
+    k--
+    res++
+    this.stk1.pop()
+  }
+  return res
+}
+
+/**
+ * @param {number} k
+ * @return {string}
+ */
+TextEditor.prototype.cursorLeft = function (k) {
+  let res = ''
+  while(this.stk1.length && k) {
+    const tmp = this.stk1.pop()
+    this.stk2.push(tmp)
+    k--
+  }
+
+
+  for(let len = this.stk1.length, size = Math.min(10, this.stk1.length), i = 0; i < size; i++) {
+    res = this.stk1[len - 1 - i] + res
+  }
+
+  
+  return res
+}
+
+/**
+ * @param {number} k
+ * @return {string}
+ */
+TextEditor.prototype.cursorRight = function (k) {
+  let res = ''
+
+  while(this.stk2.length && k) {
+    const tmp = this.stk2.pop()
+    this.stk1.push(tmp)
+    k--
+  }
+
+  for(let len = this.stk1.length, size = Math.min(10, this.stk1.length), i = 0; i < size; i++) {
+    res = this.stk1[len - 1 - i] + res
+  }
+
+  return res
+}
+
+// another
+
+
 class Node {
   constructor(val) {
     this.val = val

From c6cf4af7269be3e9cdc9937e0927fa5b9940b5a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Jun 2022 17:30:44 +0800
Subject: [PATCH 2112/3374] Update 2296-design-a-text-editor.js

---
 2296-design-a-text-editor.js | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/2296-design-a-text-editor.js b/2296-design-a-text-editor.js
index 7df5b5ae..1e953e41 100644
--- a/2296-design-a-text-editor.js
+++ b/2296-design-a-text-editor.js
@@ -8,9 +8,7 @@ const TextEditor = function () {
  * @return {void}
  */
 TextEditor.prototype.addText = function (text) {
-  for(const ch of text) {
-      this.stk1.push(ch)
-  }
+  for (const ch of text) this.stk1.push(ch)
 }
 
 /**
@@ -19,7 +17,7 @@ TextEditor.prototype.addText = function (text) {
  */
 TextEditor.prototype.deleteText = function (k) {
   let res = 0
-  while(this.stk1.length && k) {
+  while (this.stk1.length && k) {
     k--
     res++
     this.stk1.pop()
@@ -33,19 +31,13 @@ TextEditor.prototype.deleteText = function (k) {
  */
 TextEditor.prototype.cursorLeft = function (k) {
   let res = ''
-  while(this.stk1.length && k) {
+  while (this.stk1.length && k) {
     const tmp = this.stk1.pop()
     this.stk2.push(tmp)
     k--
   }
 
-
-  for(let len = this.stk1.length, size = Math.min(10, this.stk1.length), i = 0; i < size; i++) {
-    res = this.stk1[len - 1 - i] + res
-  }
-
-  
-  return res
+  return this.slice()
 }
 
 /**
@@ -55,16 +47,24 @@ TextEditor.prototype.cursorLeft = function (k) {
 TextEditor.prototype.cursorRight = function (k) {
   let res = ''
 
-  while(this.stk2.length && k) {
+  while (this.stk2.length && k) {
     const tmp = this.stk2.pop()
     this.stk1.push(tmp)
     k--
   }
 
-  for(let len = this.stk1.length, size = Math.min(10, this.stk1.length), i = 0; i < size; i++) {
-    res = this.stk1[len - 1 - i] + res
-  }
+  return this.slice()
+}
 
+TextEditor.prototype.slice = function() {
+  let res = ''
+  for (
+    let len = this.stk1.length, size = Math.min(10, this.stk1.length), i = 0;
+    i < size;
+    i++
+  ) {
+    res = this.stk1[len - i - 1] + res
+  }
   return res
 }
 

From 61b3b3acd454624faaf97ce39350d9f805104aaa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Jun 2022 21:45:25 +0800
Subject: [PATCH 2113/3374] Create 979-distribute-coins-in-binary-tree.js

---
 979-distribute-coins-in-binary-tree.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 979-distribute-coins-in-binary-tree.js

diff --git a/979-distribute-coins-in-binary-tree.js b/979-distribute-coins-in-binary-tree.js
new file mode 100644
index 00000000..ba29ee10
--- /dev/null
+++ b/979-distribute-coins-in-binary-tree.js
@@ -0,0 +1,25 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const distributeCoins = function(root) {
+  let res = 0
+  helper(root)
+  return res
+  
+  function helper(node) {
+    if(node == null) return 0
+    const left = helper(node.left)
+    const right = helper(node.right)
+    res += Math.abs(left) + Math.abs(right)
+    return node.val + left + right - 1
+  }
+};

From 769769008e3486059530f356b827400121a00ee9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jun 2022 10:57:56 +0800
Subject: [PATCH 2114/3374] Update 642-design-search-autocomplete-system.js

---
 642-design-search-autocomplete-system.js | 151 +++++++++++++++++++++++
 1 file changed, 151 insertions(+)

diff --git a/642-design-search-autocomplete-system.js b/642-design-search-autocomplete-system.js
index d00efdb3..1f4a5657 100644
--- a/642-design-search-autocomplete-system.js
+++ b/642-design-search-autocomplete-system.js
@@ -105,3 +105,154 @@ Trie.prototype.stringsStartingWith = function (prefix) {
   traverse(curr, prefix)
   return results
 }
+
+// another
+
+class TrieNode {
+  constructor() {
+    this.children = new Map()
+    this.counts = new Map()
+    this.isWord = false
+  }
+}
+
+class Pair {
+  constructor(s, c) {
+    this.str = s
+    this.cnt = c
+  }
+}
+
+/**
+ * @param {string[]} sentences
+ * @param {number[]} times
+ */
+const AutocompleteSystem = function (sentences, times) {
+  this.root = new TrieNode()
+  this.prefix = ''
+  for (let i = 0, n = sentences.length; i < n; i++) {
+    this.add(sentences[i], times[i])
+  }
+}
+
+AutocompleteSystem.prototype.add = function (str, cnt) {
+  let cur = this.root
+  for (const ch of str) {
+    let next = cur.children.get(ch)
+    if (next == null) {
+      next = new TrieNode()
+      cur.children.set(ch, next)
+    }
+    cur = next
+    cur.counts.set(str, (cur.counts.get(str) || 0) + cnt)
+  }
+  cur.isWord = true
+}
+
+/**
+ * @param {character} c
+ * @return {string[]}
+ */
+AutocompleteSystem.prototype.input = function (c) {
+  if (c === '#') {
+    this.add(this.prefix, 1)
+    this.prefix = ''
+    return []
+  }
+  this.prefix += c
+  let cur = this.root
+  for (const ch of this.prefix) {
+    const next = cur.children.get(ch)
+    if (next == null) {
+      return []
+    }
+    cur = next
+  }
+  const pq = new PriorityQueue((a, b) =>
+    a.cnt === b.cnt ? a.str.localeCompare(b.str) < 0 : a.cnt > b.cnt
+  )
+
+  for(const s of cur.counts.keys()) {
+    pq.push(new Pair(s, cur.counts.get(s)))
+  }
+  const res = []
+  for(let i = 0; i < 3 && pq.size(); i++) {
+    res.push(pq.pop().str)
+  }
+
+  return res
+}
+
+/**
+ * Your AutocompleteSystem object will be instantiated and called as such:
+ * var obj = new AutocompleteSystem(sentences, times)
+ * var param_1 = obj.input(c)
+ */
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 869784e80fcdc443d0ad4bfd3735cabf16d33a78 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jun 2022 21:28:34 +0800
Subject: [PATCH 2115/3374] Create
 2178-maximum-split-of-positive-even-integers.js

---
 ...-maximum-split-of-positive-even-integers.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2178-maximum-split-of-positive-even-integers.js

diff --git a/2178-maximum-split-of-positive-even-integers.js b/2178-maximum-split-of-positive-even-integers.js
new file mode 100644
index 00000000..8efc231c
--- /dev/null
+++ b/2178-maximum-split-of-positive-even-integers.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} finalSum
+ * @return {number[]}
+ */
+const maximumEvenSplit = function(finalSum) {
+  if(finalSum % 2 === 1) return []
+  const res = []
+  let i = 2
+  while(i <= finalSum) {
+    res.push(i)
+    finalSum -= i
+    i += 2
+  }
+  
+  const last = res.pop()
+  res.push(finalSum + last)
+  return res
+};

From a9be3c104f58641822c42229ec7cf44d4f9171b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jun 2022 22:02:13 +0800
Subject: [PATCH 2116/3374] Create 1219-path-with-maximum-gold.js

---
 1219-path-with-maximum-gold.js | 40 ++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1219-path-with-maximum-gold.js

diff --git a/1219-path-with-maximum-gold.js b/1219-path-with-maximum-gold.js
new file mode 100644
index 00000000..ae7b9552
--- /dev/null
+++ b/1219-path-with-maximum-gold.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const getMaximumGold = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const arr = []
+  const dirs = [[-1, 0], [1, 0], [0, 1], [0, -1]]
+  const visited = new Set()
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] !== 0) arr.push([i, j])
+    }
+  }
+  let res = 0
+  
+  for(const [i, j] of arr) {
+    visited.clear()
+    visited.add(`${i},${j}`)
+    dfs(i, j, grid[i][j])
+  }
+  
+  return res
+  
+  function dfs(i, j, cur) {
+
+    res = Math.max(res, cur)
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx
+      const ny = j + dy
+      const key = `${nx},${ny}`
+      if(nx >= 0 && nx < m && ny >= 0 && ny < n && !visited.has(key) && grid[nx][ny] !== 0) {
+        visited.add(key)
+        dfs(nx, ny, cur + grid[nx][ny])
+        visited.delete(key)
+      }
+    }
+  }
+  
+};

From 3c33190c669e60ffce546227d7e169503fd76fc3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Jun 2022 22:06:23 +0800
Subject: [PATCH 2117/3374] Update 1219-path-with-maximum-gold.js

---
 1219-path-with-maximum-gold.js | 43 ++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1219-path-with-maximum-gold.js b/1219-path-with-maximum-gold.js
index ae7b9552..150b85e8 100644
--- a/1219-path-with-maximum-gold.js
+++ b/1219-path-with-maximum-gold.js
@@ -38,3 +38,46 @@ const getMaximumGold = function(grid) {
   }
   
 };
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var getMaximumGold = function (grid) {
+  const m = grid.length
+  const n = grid[0].length
+  let max = 0
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] != 0) {
+        const sum = backtrack(grid, i, j, m, n)
+        max = Math.max(sum, max)
+      }
+    }
+  }
+
+  return max
+}
+
+function backtrack(grid, row, col, m, n) {
+  if (outOfBound(row, col, m, n) || grid[row][col] === 0) return 0
+
+  let sum = grid[row][col]
+  grid[row][col] = 0 // mark as being visited already
+
+  const top = backtrack(grid, row - 1, col, m, n)
+  const right = backtrack(grid, row, col + 1, m, n)
+  const bot = backtrack(grid, row + 1, col, m, n)
+  const left = backtrack(grid, row, col - 1, m, n)
+
+  grid[row][col] = sum // backtrack to the original form
+
+  return sum + Math.max(top, right, bot, left)
+}
+
+function outOfBound(row, col, m, n) {
+  return row < 0 || col < 0 || row >= m || col >= n
+}

From 46a8a03839e95f08e39b2117c092c14c86c9774f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 09:46:13 +0800
Subject: [PATCH 2118/3374] Update 1268-search-suggestions-system.js

---
 1268-search-suggestions-system.js | 59 +++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/1268-search-suggestions-system.js b/1268-search-suggestions-system.js
index c2b9ba09..6b5750cc 100644
--- a/1268-search-suggestions-system.js
+++ b/1268-search-suggestions-system.js
@@ -38,3 +38,62 @@ const suggestedProducts = function(products, searchWord) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {string[]} products
+ * @param {string} searchWord
+ * @return {string[][]}
+ */
+ const suggestedProducts = function(products, searchWord) {
+  const root = new Node()
+  for(const str of products) {
+    addProduct(str)
+  }
+
+  const res = []
+
+  let cur = root
+  for(const ch of searchWord) {
+    const tmp = []
+    if(cur == null) {
+        res.push(tmp)
+        continue
+    }
+    const map = cur.children.get(ch)
+    if(map != null) {
+      const arr = [...map.words]
+      arr.sort()
+      tmp.push(...arr.slice(0, 3))
+    }
+
+    res.push(tmp)
+    cur = map
+  }
+
+
+  return res
+  
+  function addProduct(str) {
+    let cur = root
+    for(const ch of str) {
+      let next = cur.children.get(ch)
+      if(next == null) {
+        next = new Node()
+        cur.children.set(ch, next)
+      }
+      next.words.add(str)
+      cur = next
+    }
+    cur.isWord = true
+  }
+};
+
+class Node {
+  constructor() {
+      this.children = new Map()
+      this.words = new Set()
+      this.isWord = false
+  }
+}

From e15f15f5ad62b73e56d6851412d7a2e122e5b9cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 09:57:18 +0800
Subject: [PATCH 2119/3374] Update 1268-search-suggestions-system.js

---
 1268-search-suggestions-system.js | 43 ++++++++++++++++++-------------
 1 file changed, 25 insertions(+), 18 deletions(-)

diff --git a/1268-search-suggestions-system.js b/1268-search-suggestions-system.js
index 6b5750cc..2e8ea666 100644
--- a/1268-search-suggestions-system.js
+++ b/1268-search-suggestions-system.js
@@ -46,40 +46,46 @@ const suggestedProducts = function(products, searchWord) {
  * @param {string} searchWord
  * @return {string[][]}
  */
- const suggestedProducts = function(products, searchWord) {
+ const suggestedProducts = function (products, searchWord) {
+  products.sort()
   const root = new Node()
-  for(const str of products) {
+  for (const str of products) {
     addProduct(str)
   }
 
   const res = []
 
   let cur = root
-  for(const ch of searchWord) {
+  for (const ch of searchWord) {
     const tmp = []
-    if(cur == null) {
-        res.push(tmp)
-        continue
+    if (cur == null) {
+      res.push(tmp)
+      continue
     }
     const map = cur.children.get(ch)
-    if(map != null) {
-      const arr = [...map.words]
-      arr.sort()
-      tmp.push(...arr.slice(0, 3))
+    if (map != null) {
+      addThree(map.words.values(), tmp)
     }
 
     res.push(tmp)
     cur = map
   }
 
-
   return res
-  
+
+  function addThree(it, arr) {
+
+    for(let i = 0; i < 3; i++) {
+      const res = it.next()
+      if(res.value) arr.push(res.value)
+    }
+  }
+
   function addProduct(str) {
     let cur = root
-    for(const ch of str) {
+    for (const ch of str) {
       let next = cur.children.get(ch)
-      if(next == null) {
+      if (next == null) {
         next = new Node()
         cur.children.set(ch, next)
       }
@@ -88,12 +94,13 @@ const suggestedProducts = function(products, searchWord) {
     }
     cur.isWord = true
   }
-};
+}
 
 class Node {
   constructor() {
-      this.children = new Map()
-      this.words = new Set()
-      this.isWord = false
+    this.children = new Map()
+    this.words = new Set()
+    this.isWord = false
   }
 }
+

From 49d50d8dabf003201d4c0e02dc8ad4b50ec9a747 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 14:09:11 +0800
Subject: [PATCH 2120/3374] Create 974-subarray-sums-divisible-by-k.js

---
 974-subarray-sums-divisible-by-k.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 974-subarray-sums-divisible-by-k.js

diff --git a/974-subarray-sums-divisible-by-k.js b/974-subarray-sums-divisible-by-k.js
new file mode 100644
index 00000000..34fc0a41
--- /dev/null
+++ b/974-subarray-sums-divisible-by-k.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarraysDivByK = function (nums, k) {
+  const memo = {0: 1}
+  let sum = 0, res = 0
+  for(const e of nums) {
+    sum += e
+    const remain = ( sum % k + k) % k
+    res += memo[remain] ?? 0
+    memo[remain] = (memo[remain] ?? 0) + 1 
+  }
+  return res
+}

From 987d4d0c5bb3c3676a89946c7a9436ff55efb4fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 21:09:00 +0800
Subject: [PATCH 2121/3374] Create 1302-deepest-leaves-sum.js

---
 1302-deepest-leaves-sum.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1302-deepest-leaves-sum.js

diff --git a/1302-deepest-leaves-sum.js b/1302-deepest-leaves-sum.js
new file mode 100644
index 00000000..0e7d364b
--- /dev/null
+++ b/1302-deepest-leaves-sum.js
@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const deepestLeavesSum = function(root) {
+  let res= 0
+  let q = [root]
+  while(q.length) {
+    const size = q.length
+    const tmp = []
+    res = 0
+    for(let i = 0; i < size; i++) {
+      res += q[i].val
+      if(q[i].left) tmp.push(q[i].left)
+      if(q[i].right) tmp.push(q[i].right)
+    }
+    
+    q = tmp
+  }
+  return res
+};

From ade6f75b6b2efc0600c39689989c728cdad754df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 21:47:54 +0800
Subject: [PATCH 2122/3374] Create
 1151-minimum-swaps-to-group-all-1s-together.js

---
 ...-minimum-swaps-to-group-all-1s-together.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1151-minimum-swaps-to-group-all-1s-together.js

diff --git a/1151-minimum-swaps-to-group-all-1s-together.js b/1151-minimum-swaps-to-group-all-1s-together.js
new file mode 100644
index 00000000..392f6012
--- /dev/null
+++ b/1151-minimum-swaps-to-group-all-1s-together.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} data
+ * @return {number}
+ */
+const minSwaps = function(data) {
+  let num = 0, n = data.length
+  const arr = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    const e = data[i]
+    if(e === 1) {
+      num++
+    }
+    arr[i] = num
+  }
+  if(num === 0) return 0
+  let res = num - arr[num - 1]
+  for(let i = num; i < n; i++) {
+    res = Math.min(res, num - (arr[i] - arr[i - num]))
+  }
+  return res
+};

From be711b975ab4ceccace0d41b66444f6794d2653c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Jul 2022 22:57:13 +0800
Subject: [PATCH 2123/3374] Create 1376-time-needed-to-inform-all-employees.js

---
 1376-time-needed-to-inform-all-employees.js | 35 +++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 1376-time-needed-to-inform-all-employees.js

diff --git a/1376-time-needed-to-inform-all-employees.js b/1376-time-needed-to-inform-all-employees.js
new file mode 100644
index 00000000..c6d50ad2
--- /dev/null
+++ b/1376-time-needed-to-inform-all-employees.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number} headID
+ * @param {number[]} manager
+ * @param {number[]} informTime
+ * @return {number}
+ */
+const numOfMinutes = function(n, headID, manager, informTime) {
+  const hash = {}
+  const len = manager.length
+  for(let i = 0; i < len; i++) {
+    const m = manager[i]
+    if(hash[m] == null) hash[m] = new Set()
+    hash[m].add(i)
+  }
+  let res = 0
+  let q = [[headID, 0]]
+  while(q.length) {
+    const tmp = []
+    let t = 0
+    const size = q.length
+    for(let i = 0; i < size; i++) {
+      const [cur, time] = q[i]
+      if(hash[cur]) {
+        for(const e of hash[cur]) {
+          res = Math.max(res, time + informTime[cur])
+          tmp.push([e, time + informTime[cur]])
+        }
+      }
+    }
+    q = tmp
+    res += t
+  }
+  return res
+};

From d4f50c44513396c6a809c047ceae460a056c1171 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jul 2022 11:46:36 +0800
Subject: [PATCH 2124/3374] Update
 1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js

---
 ...cake-after-horizontal-and-vertical-cuts.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js
index 204580c6..12701fe7 100644
--- a/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js
+++ b/1465-maximum-area-of-a-piece-of-cake-after-horizontal-and-vertical-cuts.js
@@ -18,3 +18,27 @@ function getMax(limit, cuts) {
   }
   return max
 }
+
+// another
+
+/**
+ * @param {number} h
+ * @param {number} w
+ * @param {number[]} horizontalCuts
+ * @param {number[]} verticalCuts
+ * @return {number}
+ */
+const maxArea = function(h, w, horizontalCuts, verticalCuts) {
+  return (BigInt(maxGap(h, horizontalCuts)) * BigInt(maxGap(w, verticalCuts))) % BigInt(1e9 + 7)
+  function maxGap(limit, arr) {
+    let res = 0
+    arr.sort((a, b) => a - b)
+    for(let i = 0, n = arr.length; i < n; i++) {
+      let tmp = i === 0 ? arr[0] : arr[i] - arr[i - 1]
+      res = Math.max(res, tmp)
+    }
+    res = Math.max(res, limit - arr[arr.length - 1])
+    
+    return res
+  }
+};

From 1d02857df1647d6b3ec47e211f0541f7edbeecad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jul 2022 12:55:22 +0800
Subject: [PATCH 2125/3374] Update 1146-snapshot-array.js

---
 1146-snapshot-array.js | 56 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/1146-snapshot-array.js b/1146-snapshot-array.js
index 31164a7e..28e93963 100644
--- a/1146-snapshot-array.js
+++ b/1146-snapshot-array.js
@@ -1,3 +1,59 @@
+/**
+ * @param {number} length
+ */
+const SnapshotArray = function(length) {
+  this.snaps = Array(length)
+  this.snapId = 0
+};
+
+/** 
+ * @param {number} index 
+ * @param {number} val
+ * @return {void}
+ */
+SnapshotArray.prototype.set = function(index, val) {
+  if(this.snaps[index] == null) {
+    this.snaps[index] = {}
+  }
+  this.snaps[index][this.snapId] = val
+};
+
+/**
+ * @return {number}
+ */
+SnapshotArray.prototype.snap = function() {
+  return this.snapId++
+};
+
+/** 
+ * @param {number} index 
+ * @param {number} snap_id
+ * @return {number}
+ */
+SnapshotArray.prototype.get = function(index, snap_id) {
+  let res = 0
+  let id = snap_id
+  while(id >= 0) {
+    if(this.snaps[index] == null || this.snaps[index][id] == null) id--
+    else {
+      res = this.snaps[index][id]
+      break
+    }
+  }
+  
+  return res
+};
+
+/** 
+ * Your SnapshotArray object will be instantiated and called as such:
+ * var obj = new SnapshotArray(length)
+ * obj.set(index,val)
+ * var param_2 = obj.snap()
+ * var param_3 = obj.get(index,snap_id)
+ */
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} target

From a45e6b0764b029c3c8c3ebadb44a96e7152e9c3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Jul 2022 22:46:39 +0800
Subject: [PATCH 2126/3374] Create 1524-number-of-sub-arrays-with-odd-sum.js

---
 1524-number-of-sub-arrays-with-odd-sum.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1524-number-of-sub-arrays-with-odd-sum.js

diff --git a/1524-number-of-sub-arrays-with-odd-sum.js b/1524-number-of-sub-arrays-with-odd-sum.js
new file mode 100644
index 00000000..671df32f
--- /dev/null
+++ b/1524-number-of-sub-arrays-with-odd-sum.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const numOfSubarrays = function(arr) {
+  const n = arr.length, mod = 1e9 + 7
+
+  let oc = 0, ec = 1
+  let sum = 0
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    sum += arr[i]
+    if(sum % 2 === 1) {
+      res += ec
+      oc++
+    } else {
+      res += oc
+      ec++
+    }
+  }
+  
+  return res % mod
+};

From f831fdf0bc22577aa90e4799809b685f4f4cc67d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 13:02:09 +0800
Subject: [PATCH 2127/3374] Create 2325-decode-the-message.js

---
 2325-decode-the-message.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2325-decode-the-message.js

diff --git a/2325-decode-the-message.js b/2325-decode-the-message.js
new file mode 100644
index 00000000..f6673016
--- /dev/null
+++ b/2325-decode-the-message.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} key
+ * @param {string} message
+ * @return {string}
+ */
+var decodeMessage = function(key, message) {
+  const set =  new Set()
+  for(const ch of key) {
+    if(ch !== ' ') set.add(ch)
+    if(set.size === 26) break
+  }
+  const arr = Array.from(set).map((e, i) => [e, i])
+  const hash = {}
+  for(const [e, i] of arr) {
+    hash[e] = i
+  }
+  // console.log(arr)
+  const a = 'a'.charCodeAt(0)
+  let res = ''
+  for(const ch of message) {
+    if(ch === ' ') {
+      res += ' '
+      continue
+    }
+    const idx = hash[ch]
+    const tmp = String.fromCharCode(a + idx)
+    res += tmp
+  }
+  
+  return res
+};

From b9fe4e60333edbb68f421771aa3fbd8dbd29f77d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 13:02:39 +0800
Subject: [PATCH 2128/3374] Create 2326-spiral-matrix-iv.js

---
 2326-spiral-matrix-iv.js | 51 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2326-spiral-matrix-iv.js

diff --git a/2326-spiral-matrix-iv.js b/2326-spiral-matrix-iv.js
new file mode 100644
index 00000000..66ad0233
--- /dev/null
+++ b/2326-spiral-matrix-iv.js
@@ -0,0 +1,51 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {ListNode} head
+ * @return {number[][]}
+ */
+const spiralMatrix = function (m, n, head) {
+  const mat = Array.from({ length: m }, () => Array(n).fill(-1));
+  let cur = head;
+  const dirs = [
+    [0, 1],
+    [1, 0],
+    [0, -1],
+    [-1, 0],
+  ];
+  let i = 0,
+    j = 0,
+    left = 0,
+    right = n - 1,
+    top = 0,
+    bottom = m - 1,
+    idx = 0;
+  while (cur) {
+    mat[i][j] = cur.val;
+    if (idx === 0 && j === right) {
+      idx = (idx + 1) % 4;
+      right--;
+    } else if (idx === 1 && i === bottom) {
+      idx = (idx + 1) % 4;
+      bottom--;
+    } else if (idx === 2 && j === left) {
+      idx = (idx + 1) % 4;
+      left++;
+    } else if (idx === 3 && i === top + 1) {
+      idx = (idx + 1) % 4;
+      top++;
+    }
+    i += dirs[idx][0];
+    j += dirs[idx][1];
+    cur = cur.next;
+  }
+
+  return mat;
+};

From 3d81dc919aee0e2c07d581c506757b2a5d4c2918 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 13:03:05 +0800
Subject: [PATCH 2129/3374] Create 2327-number-of-people-aware-of-a-secret.js

---
 2327-number-of-people-aware-of-a-secret.js | 23 ++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2327-number-of-people-aware-of-a-secret.js

diff --git a/2327-number-of-people-aware-of-a-secret.js b/2327-number-of-people-aware-of-a-secret.js
new file mode 100644
index 00000000..890bc5d9
--- /dev/null
+++ b/2327-number-of-people-aware-of-a-secret.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number} delay
+ * @param {number} forget
+ * @return {number}
+ */
+const peopleAwareOfSecret = function(n, delay, forget) {
+    let cnt = new Array(n+1).fill(0);
+    cnt[1] = 1;
+    let i = 1;
+    let MOD = 1_000_000_007;
+    while (i+delay <= n) {
+        for (let j = i+delay; j <= Math.min(n, i+forget-1); j++) {
+            cnt[j] = (cnt[j]+cnt[i])%MOD;
+        }
+        i++;
+    }
+    let res = 0;
+    for (let j = n; j > n-forget; j--) {
+        res = (res + cnt[j])%MOD;
+    }
+    return res;
+};

From df2bef3337eeb86820daa306ac1344ebc22c83e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 13:03:27 +0800
Subject: [PATCH 2130/3374] Create 2328-number-of-increasing-paths-in-a-grid.js

---
 2328-number-of-increasing-paths-in-a-grid.js | 37 ++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2328-number-of-increasing-paths-in-a-grid.js

diff --git a/2328-number-of-increasing-paths-in-a-grid.js b/2328-number-of-increasing-paths-in-a-grid.js
new file mode 100644
index 00000000..0c3ca851
--- /dev/null
+++ b/2328-number-of-increasing-paths-in-a-grid.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var countPaths = function(grid) {
+      let MOD = 1e9 + 7;
+      let res = 0;
+      let M = grid.length, N = grid[0].length;
+
+  const dp = Array.from({ length: M }, () => Array(N))
+
+      for (let r = 0; r < M; r++) {
+        for (let c = 0; c < N; c++) {
+          res = (res + dfs(grid, r, c, dp)) % MOD;
+        }
+      }
+      return res; 
+
+    function dfs(grid,  r,  c,  dp) {
+      if (dp[r][c] != null) {
+        return dp[r][c];
+      }
+      let MOD = 1e9 + 7;
+      let res = 1;
+      let M = grid.length, N = grid[0].length;
+    
+      for (const dir of [[-1, 0], [0, -1], [1, 0], [0, 1]]) {
+        let nr = r + dir[0], nc = c + dir[1];
+        if (nr < 0 || nr >= M || nc < 0 || nc >= N || grid[nr][nc] <= grid[r][c]) {
+          continue;
+        }
+        res = (res + dfs(grid, nr, nc, dp))%MOD;
+      }
+      dp[r][c] = res;
+      return res;
+    }
+};

From 02e44142fa84b3a79445b93f122425093decf756 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 16:50:40 +0800
Subject: [PATCH 2131/3374] Create
 2098-subsequence-of-size-k-with-the-largest-even-sum.js

---
 ...nce-of-size-k-with-the-largest-even-sum.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2098-subsequence-of-size-k-with-the-largest-even-sum.js

diff --git a/2098-subsequence-of-size-k-with-the-largest-even-sum.js b/2098-subsequence-of-size-k-with-the-largest-even-sum.js
new file mode 100644
index 00000000..e78fd154
--- /dev/null
+++ b/2098-subsequence-of-size-k-with-the-largest-even-sum.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const largestEvenSum = function(nums, k) {
+  nums.sort((a, b) => b - a)
+  let sum = 0
+  for(let i = 0; i < k; i++) sum += nums[i]
+  if(sum % 2 === 0) return sum
+  
+  const INF = 10 ** 6
+  let minOdd = INF, minEven = INF
+  for(let i = 0; i < k; i++) {
+    if(nums[i] % 2 === 0) minEven = Math.min(minEven, nums[i])
+    else minOdd = Math.min(minOdd, nums[i])
+  }
+  
+  const n = nums.length
+  let res = -1
+  for(let i = k; i < n; i++) {
+    if(nums[i] % 2 === 0 && minOdd !== INF) {
+      res = Math.max(res, sum - minOdd + nums[i])
+    }
+    if(nums[i] % 2 === 1 && minEven !== INF) {
+      res = Math.max(res, sum - minEven + nums[i])
+    }
+  }
+  
+  return res
+};

From 3efdede1e1371c534b4d22d5cddef1a13bfa9989 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 19:42:57 +0800
Subject: [PATCH 2132/3374] Create
 2302-count-subarrays-with-score-less-than-k.js

---
 2302-count-subarrays-with-score-less-than-k.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2302-count-subarrays-with-score-less-than-k.js

diff --git a/2302-count-subarrays-with-score-less-than-k.js b/2302-count-subarrays-with-score-less-than-k.js
new file mode 100644
index 00000000..4125da43
--- /dev/null
+++ b/2302-count-subarrays-with-score-less-than-k.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countSubarrays = function(nums, k) {
+  let sum = 0
+  let res = 0
+  for(let i = 0, j = 0, n = nums.length; i < n; i++) {
+    sum += nums[i]
+    while(sum * (i - j + 1) >= k) sum -= nums[j++]
+    res += i - j + 1
+  }
+  
+  return res
+};

From c663f630a4cf324c565d6de6af53b566e8ccc907 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 20:32:30 +0800
Subject: [PATCH 2133/3374] Update 2327-number-of-people-aware-of-a-secret.js

---
 2327-number-of-people-aware-of-a-secret.js | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/2327-number-of-people-aware-of-a-secret.js b/2327-number-of-people-aware-of-a-secret.js
index 890bc5d9..2ef272bd 100644
--- a/2327-number-of-people-aware-of-a-secret.js
+++ b/2327-number-of-people-aware-of-a-secret.js
@@ -21,3 +21,29 @@ const peopleAwareOfSecret = function(n, delay, forget) {
     }
     return res;
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number} delay
+ * @param {number} forget
+ * @return {number}
+ */
+const peopleAwareOfSecret = function(n, delay, forget) {
+  const dp = Array(n + 1).fill(0)
+  dp[1] = 1
+  const mod = 1e9 + 7
+  const { min, max } = Math
+  let share = 0
+  for(let i = 2; i <= n; i++) {
+    share = (share + dp[max(i - delay, 0)] - dp[max(i - forget, 0)] + mod) % mod
+    dp[i] = share
+  }
+  let res = 0
+  for(let i = n - forget + 1; i <= n; i++) {
+    res = (res + dp[i]) % mod
+  }
+ 
+  return res
+};

From 1dc19b598c17c57fbaaa412daef3b2ae815208f5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Jul 2022 21:07:18 +0800
Subject: [PATCH 2134/3374] Update 2328-number-of-increasing-paths-in-a-grid.js

---
 2328-number-of-increasing-paths-in-a-grid.js | 65 ++++++++++++--------
 1 file changed, 38 insertions(+), 27 deletions(-)

diff --git a/2328-number-of-increasing-paths-in-a-grid.js b/2328-number-of-increasing-paths-in-a-grid.js
index 0c3ca851..54212bc0 100644
--- a/2328-number-of-increasing-paths-in-a-grid.js
+++ b/2328-number-of-increasing-paths-in-a-grid.js
@@ -2,36 +2,47 @@
  * @param {number[][]} grid
  * @return {number}
  */
-var countPaths = function(grid) {
-      let MOD = 1e9 + 7;
-      let res = 0;
-      let M = grid.length, N = grid[0].length;
+var countPaths = function (grid) {
+  const MOD = 1e9 + 7
+  let res = 0
+  const M = grid.length,
+    N = grid[0].length
 
   const dp = Array.from({ length: M }, () => Array(N))
 
-      for (let r = 0; r < M; r++) {
-        for (let c = 0; c < N; c++) {
-          res = (res + dfs(grid, r, c, dp)) % MOD;
-        }
-      }
-      return res; 
+  for (let r = 0; r < M; r++) {
+    for (let c = 0; c < N; c++) {
+      res = (res + dfs(r, c)) % MOD
+    }
+  }
+  return res
 
-    function dfs(grid,  r,  c,  dp) {
-      if (dp[r][c] != null) {
-        return dp[r][c];
-      }
-      let MOD = 1e9 + 7;
-      let res = 1;
-      let M = grid.length, N = grid[0].length;
-    
-      for (const dir of [[-1, 0], [0, -1], [1, 0], [0, 1]]) {
-        let nr = r + dir[0], nc = c + dir[1];
-        if (nr < 0 || nr >= M || nc < 0 || nc >= N || grid[nr][nc] <= grid[r][c]) {
-          continue;
-        }
-        res = (res + dfs(grid, nr, nc, dp))%MOD;
+  function dfs(r, c) {
+    if (dp[r][c] != null) {
+      return dp[r][c]
+    }
+    let res = 1
+
+    for (const dir of [
+      [-1, 0],
+      [0, -1],
+      [1, 0],
+      [0, 1],
+    ]) {
+      const nr = r + dir[0],
+        nc = c + dir[1]
+      if (
+        nr < 0 ||
+        nr >= M ||
+        nc < 0 ||
+        nc >= N ||
+        grid[nr][nc] <= grid[r][c]
+      ) {
+        continue
       }
-      dp[r][c] = res;
-      return res;
+      res = (res + dfs(nr, nc)) % MOD
     }
-};
+    dp[r][c] = res
+    return res
+  }
+}

From 26bfa38e7307a8ff370ed3813070ee4afca34e98 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Jul 2022 10:23:37 +0800
Subject: [PATCH 2135/3374] Create 1102-path-with-maximum-minimum-value.js

---
 1102-path-with-maximum-minimum-value.js | 65 +++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 1102-path-with-maximum-minimum-value.js

diff --git a/1102-path-with-maximum-minimum-value.js b/1102-path-with-maximum-minimum-value.js
new file mode 100644
index 00000000..ef6b6ca6
--- /dev/null
+++ b/1102-path-with-maximum-minimum-value.js
@@ -0,0 +1,65 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maximumMinimumPath = function (grid) {
+  const m = grid.length,
+    n = grid[0].length
+  const dirs = [
+    [0, 1],
+    [0, -1],
+    [1, 0],
+    [-1, 0],
+  ]
+
+  const set = new Set()
+
+  let ceil = Math.min(grid[0][0], grid[m - 1][n - 1])
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] <= ceil) {
+        set.add(grid[i][j])
+      }
+    }
+  }
+  const arr = Array.from(set)
+  arr.sort((a, b) => a - b)
+  let l = 0,
+    r = arr.length - 1
+  while (l < r) {
+    const mid = r - ((r - l) >> 1)
+    if (valid(arr[mid])) {
+      l = mid
+    } else {
+      r = mid - 1
+    }
+  }
+
+  return arr[l]
+
+  function valid(v) {
+    const memo = Array.from({ length: m }, () => Array(n).fill(0))
+
+    function dfs(x, y) {
+      if (x === m - 1 && y === n - 1) return true
+      memo[x][y] = 1
+      for (const [dx, dy] of dirs) {
+        const nx = x + dx,
+          ny = y + dy
+        if (
+          nx >= 0 &&
+          nx < m &&
+          ny >= 0 &&
+          ny < n &&
+          memo[nx][ny] === 0 &&
+          grid[nx][ny] >= v &&
+          dfs(nx, ny)
+        )
+          return true
+      }
+      return false
+    }
+
+    return dfs(0, 0)
+  }
+}

From 53a7f4b695a697a80564cd4648486f729066d69c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Jul 2022 21:24:28 +0800
Subject: [PATCH 2136/3374] Update 227-basic-calculator-ii.js

---
 227-basic-calculator-ii.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/227-basic-calculator-ii.js b/227-basic-calculator-ii.js
index 57be3ffd..e0f174ae 100644
--- a/227-basic-calculator-ii.js
+++ b/227-basic-calculator-ii.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  const stk = []
+  let op = '+', num = 0
+  s = s.trim()
+  const isDigit = ch => ch >= '0' && ch <= '9'
+  for(let i = 0, n = s.length; i < n; i++) {
+    const ch = s[i]
+    if(ch === ' ') continue
+    if(isDigit(ch)) {
+      num = (+num) * 10 + (+ch)
+    } 
+    if(!isDigit(ch) || i === n - 1) {
+      if(op === '-') stk.push(-num)
+      else if(op === '+') stk.push(num)
+      else if(op === '*') stk.push(stk.pop() * num)
+      else if(op === '/') stk.push(~~(stk.pop() / num))
+      
+      op = ch
+      num = 0
+    }
+  }
+  let res = 0  
+  for(const e of stk) res += e
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 067879763309aadf5ab55130cce3d730e0b6c35b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Jul 2022 22:43:34 +0800
Subject: [PATCH 2137/3374] Update 224-basic-calculator.js

---
 224-basic-calculator.js | 46 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/224-basic-calculator.js b/224-basic-calculator.js
index 002c0d40..cf886088 100644
--- a/224-basic-calculator.js
+++ b/224-basic-calculator.js
@@ -77,3 +77,49 @@ const calculate = function(s) {
   
   return res + op * num
 };
+
+// another
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const calculate = function(s) {
+  s = s.trim()
+  
+  let res = 0, num = 0, op = 1
+  const isDigit = ch => ch >= '0' && ch <= '9'
+  const stk = []
+  for(let i = 0, n = s.length; i < n; i++) {
+    
+    const e = s[i]
+    if(e === ' ') continue
+    if(isDigit(e)) num = num * 10 + (+e)
+    else {
+      
+      if(e === '(') {
+        stk.push(res)
+        stk.push(op)
+        
+        res = 0
+        num = 0
+        op = 1
+      } else if(e === ')') {
+        res += num * op
+        res *= stk.pop()
+        res += stk.pop()
+        op = 1
+        num = 0
+      } else if(e === '-') {
+        res += num * op
+        op = -1
+        num = 0
+      } else if(e === '+') {
+        res += num * op
+        op = 1
+        num = 0
+      }
+    }
+  }
+  
+  return res + num * op
+};

From 2aa5d711e392f656d6ff1b285096953e969b69d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Jul 2022 11:12:14 +0800
Subject: [PATCH 2138/3374] Update 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 97 ++++++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
index 1e07dfcb..0514873a 100644
--- a/1631-path-with-minimum-effort.js
+++ b/1631-path-with-minimum-effort.js
@@ -1,3 +1,100 @@
+/**
+ * @param {number[][]} heights
+ * @return {number}
+ */
+const minimumEffortPath = function(heights) {
+  const m = heights.length, n = heights[0].length
+  const pq = new PriorityQueue()
+  const dist = Array.from({ length: m }, () => Array(n).fill(Infinity))
+  pq.push([0, 0, 0])
+  dist[0][0] = 0
+  const dirs = [[-1, 0], [1, 0], [0, 1], [0, -1]]
+  while(!pq.isEmpty()) {
+    const [v, i, j] = pq.pop()
+    if(i === m - 1 && j === n - 1) return v
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      if(nx < 0 || nx >= m || ny < 0 || ny >= n) continue
+      const diff = Math.max(v, Math.abs(heights[nx][ny] - heights[i][j]))
+      if(dist[nx][ny] > diff) {
+         dist[nx][ny] = diff
+         pq.push([diff, nx, ny])
+      }
+    }
+  }
+  return -1
+};
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a[0] < b[0]) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} heights
  * @return {number}

From 9959091bbf2af0e4273116f5bb3520c2315d1e4d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Jul 2022 10:31:12 +0800
Subject: [PATCH 2139/3374] Update 53-maximum-subarray.js

---
 53-maximum-subarray.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/53-maximum-subarray.js b/53-maximum-subarray.js
index 8cb65d28..dde9daa9 100755
--- a/53-maximum-subarray.js
+++ b/53-maximum-subarray.js
@@ -1,3 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxSubArray = function (nums) {
+  let res = -1e9, sum = 0
+  for(const e of nums) {
+    sum += e
+    res = Math.max(res, sum)
+    if(sum < 0) sum = 0
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From daf8454dceab708e1d75af6251c10f000bf1ed67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 12:16:42 +0800
Subject: [PATCH 2140/3374] Update 2321-maximum-score-of-spliced-array.js

---
 2321-maximum-score-of-spliced-array.js | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2321-maximum-score-of-spliced-array.js b/2321-maximum-score-of-spliced-array.js
index 7f1fec21..84fbf277 100644
--- a/2321-maximum-score-of-spliced-array.js
+++ b/2321-maximum-score-of-spliced-array.js
@@ -32,3 +32,34 @@ var maximumsSplicedArray = function(nums1, nums2) {
   }
   return Math.max(s2 + max1, s1 - min2);
 };
+
+// another
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maximumsSplicedArray = function (nums1, nums2) {
+  let sum1 = 0,
+    sum2 = 0,
+    max1 = 0,
+    max2 = 0,
+    ac1 = 0,
+    ac2 = 0
+  sum1 = nums1.reduce((ac, e) => ac + e, 0)
+  sum2 = nums2.reduce((ac, e) => ac + e, 0)
+  const { max } = Math
+  let res = max(sum1, sum2)
+  for (let i = 0, n = nums1.length; i < n; i++) {
+    ac1 += nums1[i] - nums2[i]
+    ac2 += nums2[i] - nums1[i] 
+    max1 = max(max1, ac1)
+    max2 = max(max2, ac2)
+    if(ac1 < 0) ac1 = 0
+    if(ac2 < 0) ac2 = 0
+  }
+  res = max(res, sum1 + max2, sum2 + max1)
+
+  return res
+}

From 50991e6c32d1099895e038c4bff4000c5b09f527 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 14:38:23 +0800
Subject: [PATCH 2141/3374] Create
 1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.js

---
 ...n-largest-and-smallest-value-in-three-moves.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.js

diff --git a/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.js b/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.js
new file mode 100644
index 00000000..a932dbba
--- /dev/null
+++ b/1509-minimum-difference-between-largest-and-smallest-value-in-three-moves.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+ const minDifference = function(nums) {
+  let res = Infinity
+  const n = nums.length
+  if(n < 5) return 0
+  nums.sort((a, b) => a - b)
+  for(let i = 0; i < 4; i++) {
+    res = Math.min(res, nums[n - 4 + i] - nums[i])
+  }
+
+  return res
+};

From b823831907712e423ba75e1ed59a3d60f4526862 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 15:13:32 +0800
Subject: [PATCH 2142/3374] Create 1329-sort-the-matrix-diagonally.js

---
 1329-sort-the-matrix-diagonally.js | 39 ++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 1329-sort-the-matrix-diagonally.js

diff --git a/1329-sort-the-matrix-diagonally.js b/1329-sort-the-matrix-diagonally.js
new file mode 100644
index 00000000..dec33cc0
--- /dev/null
+++ b/1329-sort-the-matrix-diagonally.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} mat
+ * @return {number[][]}
+ */
+const diagonalSort = function(mat) {
+  const m = mat.length, n = mat[0].length
+  
+  for(let j = 0; j < n; j++) {
+    let i = 0, jj = j
+    const tmp = []
+    while(jj < n && i < m) {
+      tmp.push(mat[i++][jj++])
+    }
+    tmp.sort((a, b) => a - b)
+    let idx = 0
+    jj = j
+    let ii = 0
+    while(ii < m && jj < n) {
+      mat[ii++][jj++] = tmp[idx++]
+    }
+  }
+    
+  for(let i = 1; i < m; i++) {
+    let j = 0
+    let ii = i
+    const tmp = []
+    while(j < n && ii < m) {
+      tmp.push(mat[ii++][j++])
+    }
+    tmp.sort((a, b) => a - b)
+    let idx = 0
+    ii = i
+    j = 0
+    while(ii < m && j < n) {
+      mat[ii++][j++] = tmp[idx++]
+    }
+  }
+  return mat
+};

From 6114e5011779832772f348a4a968c4f83d371902 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 19:35:48 +0800
Subject: [PATCH 2143/3374] Create 1424-diagonal-traverse-ii.js

---
 1424-diagonal-traverse-ii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1424-diagonal-traverse-ii.js

diff --git a/1424-diagonal-traverse-ii.js b/1424-diagonal-traverse-ii.js
new file mode 100644
index 00000000..62be5634
--- /dev/null
+++ b/1424-diagonal-traverse-ii.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} nums
+ * @return {number[]}
+ */
+const findDiagonalOrder = function(nums) {
+  const m = nums.length
+  const map = new Map()
+  let maxKey = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0, n = nums[i].length; j < n; j++) {
+      if(!map.has(i + j)) map.set(i + j, [])
+      map.get(i + j).push(nums[i][j])
+      maxKey = Math.max(maxKey, i + j)
+    }
+  }
+  // console.log(map)
+  const res = []
+  for(let i = 0; i <= maxKey; i++) {
+    if(map.has(i)) {
+      const tmp = map.get(i)
+      tmp.reverse()
+      res.push(...tmp)
+    }
+  }
+  
+  return res
+};

From 96104460a74b9bebb58fb58624f52c934659e81f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 21:10:46 +0800
Subject: [PATCH 2144/3374] Create 2130-maximum-twin-sum-of-a-linked-list.js

---
 2130-maximum-twin-sum-of-a-linked-list.js | 27 +++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2130-maximum-twin-sum-of-a-linked-list.js

diff --git a/2130-maximum-twin-sum-of-a-linked-list.js b/2130-maximum-twin-sum-of-a-linked-list.js
new file mode 100644
index 00000000..c1520492
--- /dev/null
+++ b/2130-maximum-twin-sum-of-a-linked-list.js
@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {number}
+ */
+const pairSum = function(head) {
+   const arr = []
+   let cur = head
+   
+   while(cur) {
+     arr.push(cur.val)
+     cur = cur.next
+   }
+  
+   let res = 0
+   for(let i = 0, n = arr.length; i < n / 2; i++) {
+     res = Math.max(res, arr[i] + arr[n - 1 - i])
+   }
+   
+   return res
+};

From 674cce079d8021d93949858bad7c2d6b07e07ab8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Jul 2022 22:02:22 +0800
Subject: [PATCH 2145/3374] Update 2130-maximum-twin-sum-of-a-linked-list.js

---
 2130-maximum-twin-sum-of-a-linked-list.js | 38 +++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2130-maximum-twin-sum-of-a-linked-list.js b/2130-maximum-twin-sum-of-a-linked-list.js
index c1520492..b1e45990 100644
--- a/2130-maximum-twin-sum-of-a-linked-list.js
+++ b/2130-maximum-twin-sum-of-a-linked-list.js
@@ -1,3 +1,41 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {number}
+ */
+const pairSum = function(head) {
+  let slow = head, fast = head
+  while(fast && fast.next) {
+    slow = slow.next
+    fast = fast.next.next
+  }
+  // reverse
+  let next = null, pre = null
+  while(slow) {
+    next = slow.next
+    slow.next = pre
+    pre = slow
+    slow = next
+  }
+
+  let res = 0
+  while(pre) {
+    res = Math.max(res, pre.val + head.val)
+    pre = pre.next
+    head = head.next
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val, next) {

From 464add11e19f5d23af066b8ce3363bf458b90a3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Jul 2022 10:02:04 +0800
Subject: [PATCH 2146/3374] Update
 1186-maximum-subarray-sum-with-one-deletion.js

---
 ...-maximum-subarray-sum-with-one-deletion.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1186-maximum-subarray-sum-with-one-deletion.js b/1186-maximum-subarray-sum-with-one-deletion.js
index 553245f0..745a7fea 100644
--- a/1186-maximum-subarray-sum-with-one-deletion.js
+++ b/1186-maximum-subarray-sum-with-one-deletion.js
@@ -14,3 +14,29 @@ const maximumSum = function(arr) {
   }
   return best
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const maximumSum = function (arr) {
+  const n = arr.length
+  let max = arr[0]
+  const maxEndAt = Array(n), maxStartAt = Array(n)
+  maxEndAt[0] = arr[0]
+  for(let i = 1; i < n; i++) {
+    maxEndAt[i] = Math.max(arr[i], maxEndAt[i - 1] + arr[i])
+    max = Math.max(max, maxEndAt[i])
+  }
+  maxStartAt[n - 1] = arr[n - 1]
+  for(let i = n - 2; i >= 0; i--) {
+    maxStartAt[i] = Math.max(arr[i], maxStartAt[i + 1] + arr[i])
+  }
+  let res = Math.max(maxStartAt[0], maxEndAt[n - 1])
+  for(let i = 1; i < n - 1; i++) {
+    res = Math.max(max, res, maxEndAt[i - 1] + maxStartAt[i + 1])
+  }
+  return res
+}

From f238078838f68504c34fa38bb9652eb2f59a1163 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Jul 2022 10:17:08 +0800
Subject: [PATCH 2147/3374] Update
 1186-maximum-subarray-sum-with-one-deletion.js

---
 1186-maximum-subarray-sum-with-one-deletion.js | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/1186-maximum-subarray-sum-with-one-deletion.js b/1186-maximum-subarray-sum-with-one-deletion.js
index 745a7fea..6938f589 100644
--- a/1186-maximum-subarray-sum-with-one-deletion.js
+++ b/1186-maximum-subarray-sum-with-one-deletion.js
@@ -2,17 +2,17 @@
  * @param {number[]} arr
  * @return {number}
  */
-const maximumSum = function(arr) {
+const maximumSum = function (arr) {
   const n = arr.length
-  let d1 = arr[0],
-    d2 = arr[0],
-    best = arr[0]
-  for (let i = 1; i < n; ++i) {
-    d2 = Math.max(d2 + arr[i], Math.max(d1, arr[i]))
-    d1 = Math.max(d1 + arr[i], arr[i])
-    best = Math.max(d2, best)
+  let oneDel = 0, noDel = arr[0], res = arr[0]
+
+  for(let i = 1; i < n; i++) {
+    oneDel = Math.max(noDel, oneDel + arr[i])
+    noDel = Math.max(arr[i], noDel + arr[i])
+    res = Math.max(res, oneDel, noDel)
   }
-  return best
+
+  return res
 }
 
 // another

From fdd9620858cd266df394445c3f60b9265ebb18bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Jul 2022 21:32:43 +0800
Subject: [PATCH 2148/3374] Create 1254-number-of-closed-islands.js

---
 1254-number-of-closed-islands.js | 62 ++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 1254-number-of-closed-islands.js

diff --git a/1254-number-of-closed-islands.js b/1254-number-of-closed-islands.js
new file mode 100644
index 00000000..bece1302
--- /dev/null
+++ b/1254-number-of-closed-islands.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const closedIsland = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const arr = []
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 0) arr.push([i, j])
+    }
+  }
+  const dirs = [[0,1], [0,-1], [1,0], [-1,0]]
+  let num = 2
+  for(const [i, j] of arr) {
+    if(grid[i][j] !== 0) continue
+    else {
+      bfs(i, j, num)
+      num++
+    }
+  }
+  
+  let res = 0
+  const set = new Set()
+  for(let i = 2; i < num; i++) {
+    set.add(i)
+  }
+  
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] > 1 && invalid(i, j)) {
+        set.delete(grid[i][j])
+      }    
+    }
+  }
+  return set.size
+  
+  function invalid(i,j) {
+    if(i === 0 || i === m - 1 || j === 0 || j === n - 1) return true
+    return false
+  }
+  function bfs(i, j, v) {
+    let q = [[i,j]]
+    grid[i][j] = v
+    while(q.length) {
+      const tmp = []
+      const size = q.length
+      
+      for(const [x, y] of q) {
+        for(const [dx, dy] of dirs) {
+          const nx = x + dx, ny = y + dy
+          if(nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] === 0) {
+            grid[nx][ny] = v
+            tmp.push([nx, ny])
+          }
+        }
+      }
+      
+      q = tmp
+    }
+  }
+};

From 44054d052204587218667c8b8f98b79e96834dd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Jul 2022 23:47:03 +0800
Subject: [PATCH 2149/3374] Update 1254-number-of-closed-islands.js

---
 1254-number-of-closed-islands.js | 42 ++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/1254-number-of-closed-islands.js b/1254-number-of-closed-islands.js
index bece1302..acf9f12e 100644
--- a/1254-number-of-closed-islands.js
+++ b/1254-number-of-closed-islands.js
@@ -1,3 +1,45 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const closedIsland = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const dirs = [[0,1], [0,-1], [1,0], [-1,0]]
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if((i=== 0 || i === m - 1 || j === 0 || j === n - 1) && grid[i][j] === 0){
+        fill(i, j)
+      }
+    }
+  }
+
+  
+  let res = 0
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 0) {
+        res++
+        fill(i, j)
+      }    
+    }
+  }
+  
+  return res
+
+  
+  function fill(i, j) {
+    if(i < 0 || i >= m || j < 0 || j >= n || grid[i][j] !== 0) return
+    grid[i][j] = 1
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      fill(nx, ny)
+    }
+  }
+};
+
+// another
+
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 4cecce4a1ad159d79c1ca46c2398d72c5037216d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Jul 2022 21:06:26 +0800
Subject: [PATCH 2150/3374] Update 152-maximum-product-subarray.js

---
 152-maximum-product-subarray.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/152-maximum-product-subarray.js b/152-maximum-product-subarray.js
index fe71634f..8effa588 100644
--- a/152-maximum-product-subarray.js
+++ b/152-maximum-product-subarray.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxProduct = function(nums) {
+  let min = nums[0], max = nums[0], res = nums[0]
+  for(let i = 1, n = nums.length; i < n; i++) {
+    const e = nums[i]
+    if(e < 0) [min, max] = [max, min]
+    min = Math.min(e, min * e)
+    max = Math.max(e, max * e)
+    res = Math.max(res, max)
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 636e57b91fc4e3cfdf0ddbd06956b3717a1b0153 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jul 2022 20:42:30 +0800
Subject: [PATCH 2151/3374] Create 2272-substring-with-largest-variance.js

---
 2272-substring-with-largest-variance.js | 35 +++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2272-substring-with-largest-variance.js

diff --git a/2272-substring-with-largest-variance.js b/2272-substring-with-largest-variance.js
new file mode 100644
index 00000000..5faad2f2
--- /dev/null
+++ b/2272-substring-with-largest-variance.js
@@ -0,0 +1,35 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const largestVariance = function (s) {
+  const se = new Set(s),
+    n = s.length
+  let res = 0
+  for (const x of se) {
+    // max
+    for (const y of se) {
+      // min
+      if (x != y) {
+        let pre = Array(n + 1).fill(0),
+          preX,
+          preY,
+          diff = 0
+        for (let i = 0; i < n; i++) {
+          if (s[i] == x) {
+            preX = i + 1
+            diff++
+          }
+          if (s[i] == y) {
+            preY = i + 1
+            diff--
+          }
+          pre[i + 1] = Math.min(pre[i], diff)
+          if (preX == undefined || preY == undefined) continue
+          res = Math.max(res, diff - pre[Math.min(preX, preY) - 1])
+        }
+      }
+    }
+  }
+  return res
+}

From dcd4c703732e14e203ea6df36241e95968076eb4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jul 2022 21:24:50 +0800
Subject: [PATCH 2152/3374] Update 2272-substring-with-largest-variance.js

---
 2272-substring-with-largest-variance.js | 58 ++++++++++++++-----------
 1 file changed, 33 insertions(+), 25 deletions(-)

diff --git a/2272-substring-with-largest-variance.js b/2272-substring-with-largest-variance.js
index 5faad2f2..3a1d7aa1 100644
--- a/2272-substring-with-largest-variance.js
+++ b/2272-substring-with-largest-variance.js
@@ -3,33 +3,41 @@
  * @return {number}
  */
 const largestVariance = function (s) {
-  const se = new Set(s),
-    n = s.length
-  let res = 0
-  for (const x of se) {
-    // max
-    for (const y of se) {
-      // min
-      if (x != y) {
-        let pre = Array(n + 1).fill(0),
-          preX,
-          preY,
-          diff = 0
-        for (let i = 0; i < n; i++) {
-          if (s[i] == x) {
-            preX = i + 1
-            diff++
-          }
-          if (s[i] == y) {
-            preY = i + 1
-            diff--
-          }
-          pre[i + 1] = Math.min(pre[i], diff)
-          if (preX == undefined || preY == undefined) continue
-          res = Math.max(res, diff - pre[Math.min(preX, preY) - 1])
+  const freq = new Array(26).fill(0)
+  const ac = 'a'.charCodeAt(0)
+  for (let i = 0; i < s.length; i++) freq[s.charCodeAt(i) - ac]++
+
+  // console.log(freq)
+  let maxVariance = 0
+  for (let a = 0; a < 26; a++) {
+    for (let b = 0; b < 26; b++) {
+      let remainingA = freq[a]
+      let remainingB = freq[b]
+      if (a == b || remainingA == 0 || remainingB == 0) continue
+
+      // run kadanes on each possible character pairs (A & B)
+      let currBFreq = 0,
+        currAFreq = 0
+      for (let i = 0; i < s.length; i++) {
+        let c = s.charCodeAt(i) - ac
+
+        if (c == b) currBFreq++
+        if (c == a) {
+          currAFreq++
+          remainingA--
+        }
+        if (currAFreq > 0) {
+          maxVariance = Math.max(maxVariance, currBFreq - currAFreq)          
+        }
+
+
+        if (currBFreq < currAFreq && remainingA >= 1) {
+          currBFreq = 0
+          currAFreq = 0
         }
       }
     }
   }
-  return res
+
+  return maxVariance
 }

From 362cca76738126048a94051cfb50fde06540a06e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jul 2022 21:37:52 +0800
Subject: [PATCH 2153/3374] Create 2335-minimum-amount-of-time-to-fill-cups.js

---
 2335-minimum-amount-of-time-to-fill-cups.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2335-minimum-amount-of-time-to-fill-cups.js

diff --git a/2335-minimum-amount-of-time-to-fill-cups.js b/2335-minimum-amount-of-time-to-fill-cups.js
new file mode 100644
index 00000000..7d0c385b
--- /dev/null
+++ b/2335-minimum-amount-of-time-to-fill-cups.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} amount
+ * @return {number}
+ */
+const fillCups = function(amount) {
+  amount.sort((a, b) => a- b)
+  let res = 0;
+  while (amount[2] !== 0) {
+    res++;
+    amount[2]--;
+    if (amount[1] > 0) {
+        amount[1]--;
+    }
+    amount.sort((a, b) => a- b)
+  }
+  return res;  
+};

From 90396951864a267c9248fdeb10d9cd908f75ff2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Jul 2022 22:21:37 +0800
Subject: [PATCH 2154/3374] Create 2336-smallest-number-in-infinite-set.js

---
 2336-smallest-number-in-infinite-set.js | 33 +++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2336-smallest-number-in-infinite-set.js

diff --git a/2336-smallest-number-in-infinite-set.js b/2336-smallest-number-in-infinite-set.js
new file mode 100644
index 00000000..1d550dfc
--- /dev/null
+++ b/2336-smallest-number-in-infinite-set.js
@@ -0,0 +1,33 @@
+
+const SmallestInfiniteSet = function() {
+  this.nums = new Set(Array.from({ length: 1001 }, (e, i) => i + 1))
+  this.tmp = new Set()
+};
+
+/**
+ * @return {number}
+ */
+SmallestInfiniteSet.prototype.popSmallest = function() {
+  const min = Math.min(...this.nums)
+  this.nums.delete(min)
+  this.tmp.add(min)
+  return min
+};
+
+/** 
+ * @param {number} num
+ * @return {void}
+ */
+SmallestInfiniteSet.prototype.addBack = function(num) {
+  if(this.tmp.has(num)) {
+    this.tmp.delete(num)
+    this.nums.add(num)
+  } 
+};
+
+/** 
+ * Your SmallestInfiniteSet object will be instantiated and called as such:
+ * var obj = new SmallestInfiniteSet()
+ * var param_1 = obj.popSmallest()
+ * obj.addBack(num)
+ */

From a0e36c21a2b3bd340636e66a28f2435f14e1f216 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Jul 2022 10:58:40 +0800
Subject: [PATCH 2155/3374] Update 198-house-robber.js

---
 198-house-robber.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/198-house-robber.js b/198-house-robber.js
index 36203a07..3ce91fff 100644
--- a/198-house-robber.js
+++ b/198-house-robber.js
@@ -13,3 +13,21 @@ function rob(nums) {
     }
     return prev1;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const rob = function(nums) {
+  const n = nums.length
+  const dp = Array(n+1).fill(0)
+  dp[1] = nums[0] 
+    
+  for(let i = 1; i < n; i++) {
+    dp[i + 1] = Math.max(dp[i], dp[i - 1] + nums[i])
+  }
+  
+  return dp[n]
+};

From 4fe584adc6756681c650e8b963fef28c720629c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Jul 2022 22:35:42 +0800
Subject: [PATCH 2156/3374] Create
 1404-number-of-steps-to-reduce-a-number-in-binary-representation-to-one.js

---
 ...-number-in-binary-representation-to-one.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 1404-number-of-steps-to-reduce-a-number-in-binary-representation-to-one.js

diff --git a/1404-number-of-steps-to-reduce-a-number-in-binary-representation-to-one.js b/1404-number-of-steps-to-reduce-a-number-in-binary-representation-to-one.js
new file mode 100644
index 00000000..e6c8bbb2
--- /dev/null
+++ b/1404-number-of-steps-to-reduce-a-number-in-binary-representation-to-one.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numSteps = function(s) {
+  let res = 0
+  let carry = 0
+  for(let i = s.length - 1; i > 0; i--) {
+    res++
+    if(s[i] === '1' && carry === 0) {
+      res++
+      carry = 1
+    }else if(s[i] === '0' && carry === 1) {
+      res++
+      carry = 1
+    }
+  }
+  return res + carry
+};

From 341a30411b670dabb5aea485b23334dea4731e17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Jul 2022 11:41:32 +0800
Subject: [PATCH 2157/3374] Update 2320-count-number-of-ways-to-place-houses.js

---
 2320-count-number-of-ways-to-place-houses.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/2320-count-number-of-ways-to-place-houses.js b/2320-count-number-of-ways-to-place-houses.js
index 2b8f6052..b1d6f302 100644
--- a/2320-count-number-of-ways-to-place-houses.js
+++ b/2320-count-number-of-ways-to-place-houses.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countHousePlacements = function(n) {
+  const mod = BigInt(1e9 + 7)
+  let house = 1n, space = 1n, total = 2n
+  for(let i = 2; i <= n; i++) {
+    house = space
+    space = total
+    total = (house + space) % mod
+  }
+  
+  return total * total % mod
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From c3632e412fc70d63375af1e8940d6e0ae4a555c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Jul 2022 13:00:49 +0800
Subject: [PATCH 2158/3374] Create 2318-number-of-distinct-roll-sequences.js

---
 2318-number-of-distinct-roll-sequences.js | 35 +++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2318-number-of-distinct-roll-sequences.js

diff --git a/2318-number-of-distinct-roll-sequences.js b/2318-number-of-distinct-roll-sequences.js
new file mode 100644
index 00000000..a47063e4
--- /dev/null
+++ b/2318-number-of-distinct-roll-sequences.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const dp = MultidimensionalArray(0, 1e4 + 1, 7, 7)
+const distinctSequences = function (n, p = 0, pp = 0) {
+  const mod = 1e9 + 7
+  if (n === 0) return 1
+  if (dp[n][p][pp] === 0) {
+    for (let d = 1; d < 7; d++) {
+      if (d !== p && d !== pp && (p === 0 || gcd(d, p) === 1)) {
+        dp[n][p][pp] = (dp[n][p][pp] + distinctSequences(n - 1, d, p)) % mod
+      }
+    }
+  }
+
+  return dp[n][p][pp]
+}
+
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b)
+}
+
+function MultidimensionalArray(defaultValue, ...args) {
+  if (args.length === 1) {
+    return Array(args[0]).fill(defaultValue)
+  }
+  const res = []
+
+  for (let i = 0, n = args[0]; i < n; i++) {
+    res.push(MultidimensionalArray(defaultValue, ...args.slice(1)))
+  }
+
+  return res
+}

From a2fa57dad42bf5e8d4ecc722a27de573b18ef9d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Jul 2022 19:53:06 +0800
Subject: [PATCH 2159/3374] Update 2318-number-of-distinct-roll-sequences.js

---
 2318-number-of-distinct-roll-sequences.js | 52 +++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/2318-number-of-distinct-roll-sequences.js b/2318-number-of-distinct-roll-sequences.js
index a47063e4..14e19cee 100644
--- a/2318-number-of-distinct-roll-sequences.js
+++ b/2318-number-of-distinct-roll-sequences.js
@@ -1,3 +1,55 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const distinctSequences = function(n) {
+  const hash = {
+    1: [2,3,4,5,6],
+    2: [1,3,5],
+    3: [1,2,4,5],
+    4: [1,3,5],
+    5: [1,2,3,4,6],
+    6: [1,5],
+  }
+  
+  const memo = kdArr(0, [7,7,n+1])
+  const mod = 1e9 + 7
+  let res = 0
+  for(let i = 1; i <= 6; i++) {
+    res = (res + dfs(i, 0, n - 1)) % mod
+  }
+  
+  
+  return res
+  
+  function dfs(s,i,j) {
+    if(j === 0) return 1
+    if(memo[s][i][j] !== 0) return memo[s][i][j]
+    let res = 0
+    for(let e of hash[s]) {
+      if(e !== i) {
+        res = (res + dfs(e, s, j - 1)) % mod
+      }
+    }
+    memo[s][i][j] = res
+    return res
+  }
+  
+  function kdArr(defaultVal, arr) {
+    if(arr.length === 1) return Array(arr[0]).fill(defaultVal)
+    
+    const res = []
+    for(let i = 0, len = arr[0]; i < len; i++) {
+      res.push(kdArr(defaultVal, arr.slice(1)))
+    }
+    
+    return res
+  }
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From 9dfc6e1a678a0b8ae3998a9baac4114886daa091 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Jul 2022 10:55:24 +0800
Subject: [PATCH 2160/3374] Update 213-house-robber-ii.js

---
 213-house-robber-ii.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/213-house-robber-ii.js b/213-house-robber-ii.js
index f7195425..5c76dac5 100644
--- a/213-house-robber-ii.js
+++ b/213-house-robber-ii.js
@@ -17,3 +17,27 @@ const rob = function(nums) {
     return Math.max(startFromFirst[nums.length - 1], startFromSecond[nums.length])
   
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const rob = function(nums) {
+  const n = nums.length
+  nums = nums.concat(nums)
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    let tmp = nums[i]
+    let pp = 0
+    let p = 0
+    for(let j = i; j < n + i - 1; j++) {
+      tmp = Math.max(tmp, pp + nums[j], p);
+      [pp, p] = [p, tmp]
+    }
+    res = Math.max(res, tmp)
+  }
+  
+  return res
+};

From 09a28deb2dca343751d6569c9b748675a17c2359 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Jul 2022 13:20:38 +0800
Subject: [PATCH 2161/3374] Update 213-house-robber-ii.js

---
 213-house-robber-ii.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/213-house-robber-ii.js b/213-house-robber-ii.js
index 5c76dac5..c4e1037f 100644
--- a/213-house-robber-ii.js
+++ b/213-house-robber-ii.js
@@ -20,6 +20,27 @@ const rob = function(nums) {
 
 // another
 
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const rob = function(nums) {
+  if(nums.length === 1) return nums[0]
+  return Math.max(helper(0, nums.length - 2), helper(1, nums.length - 1))
+
+  function helper(l, r) {
+    let inc = 0, exc = 0
+    for(let i = l; i <= r; i++) {
+      const pi = inc, pe = exc
+      inc = exc + nums[i]
+      exc = Math.max(pi, pe)
+    }
+    return Math.max(inc, exc)
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 1ba426ba917aa86362c65f380b78850865351d67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Jul 2022 12:57:11 +0800
Subject: [PATCH 2162/3374] Update 1388-pizza-with-3n-slices.js

---
 1388-pizza-with-3n-slices.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1388-pizza-with-3n-slices.js b/1388-pizza-with-3n-slices.js
index be6db2f7..5b214871 100644
--- a/1388-pizza-with-3n-slices.js
+++ b/1388-pizza-with-3n-slices.js
@@ -36,3 +36,32 @@ function maxSum(arr, n) {
   }
   return dp[m][n]
 }
+
+
+// another
+
+/**
+ * @param {number[]} slices
+ * @return {number}
+ */
+const maxSizeSlices = function (slices) {
+  const n = slices.length, m = ~~(n / 3)
+  const arr1 = slices.slice(1), arr2 = slices.slice(0, n - 1)
+  return Math.max(helper(arr1, m), helper(arr2, m))
+  function helper(arr, k) {
+    const len = arr.length
+    const dp = Array.from({ length: len + 1 }, () => Array(k + 1).fill(0))
+    for(let i = 1; i <= len; i++) {
+      for(let j = 1; j <= k; j++) {
+        if(i === 1) dp[i][j] = arr[i - 1]
+        else {
+          dp[i][j] = Math.max(
+            dp[i - 1][j],
+            dp[i - 2][j - 1] + arr[i - 1]
+          )
+        }
+      }
+    }
+    return dp[len][k]
+  }
+}

From 8d12d8bf2a8380ed3407755aeaae9cd4a81497b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Jul 2022 23:04:17 +0800
Subject: [PATCH 2163/3374] Create 1885-count-pairs-in-two-arrays.js

---
 1885-count-pairs-in-two-arrays.js | 34 +++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1885-count-pairs-in-two-arrays.js

diff --git a/1885-count-pairs-in-two-arrays.js b/1885-count-pairs-in-two-arrays.js
new file mode 100644
index 00000000..ecc04f11
--- /dev/null
+++ b/1885-count-pairs-in-two-arrays.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const countPairs = function(nums1, nums2) {
+  const n = nums1.length
+  const arr = Array(n)
+  for(let i = 0; i < n; i++) {
+    arr[i] = nums1[i] - nums2[i]
+  }
+  // console.log(arr)
+  arr.sort((a, b) => a - b)
+   // console.log(arr)
+  let res = 0
+  for(let i = 0; i < n - 1; i++) {
+    const e = arr[i]
+    const target = -e + 1
+    let l = i + 1, r = n
+    while(l < r) {
+      const mid = ((l + r) >> 1)
+      if(valid(mid, target)) r = mid
+      else l = mid + 1
+    }
+    // console.log(l)
+    res += n - l
+  }
+  
+  return res
+  
+  function valid(mid, t) {
+    return arr[mid] >= t
+  }
+};

From e3a0330698e0ce2ab85ed61153941a72f4d44554 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Jul 2022 19:15:21 +0800
Subject: [PATCH 2164/3374] Update 2312-selling-pieces-of-wood.js

---
 2312-selling-pieces-of-wood.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2312-selling-pieces-of-wood.js b/2312-selling-pieces-of-wood.js
index 073b0b4f..8cf6f8b5 100644
--- a/2312-selling-pieces-of-wood.js
+++ b/2312-selling-pieces-of-wood.js
@@ -22,3 +22,30 @@ const sellingWood = function(m, n, prices) {
   }
   return dp[m][n];
 };
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} prices
+ * @return {number}
+ */
+const sellingWood = function(m, n, prices) {
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  
+  for(const [h, w, p] of prices) dp[h][w] = p
+  for(let i = 1; i <= m; i++) {
+    for(let j = 1; j <= n; j++) {
+      for(let k = 1; k <= i / 2; k++) {
+        dp[i][j] = Math.max(dp[i][j], dp[k][j] + dp[i - k][j])
+      }
+      
+      for(let k = 1; k <= j / 2; k++) {
+        dp[i][j] = Math.max(dp[i][j], dp[i][k] + dp[i][j - k])
+      }
+    }
+  }
+  
+  return dp[m][n]
+};

From 045c1ba9f58fee9c1d13a8ede8222433cc6beb44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jul 2022 13:13:22 +0800
Subject: [PATCH 2165/3374] Create 2341-maximum-number-of-pairs-in-array.js

---
 2341-maximum-number-of-pairs-in-array.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2341-maximum-number-of-pairs-in-array.js

diff --git a/2341-maximum-number-of-pairs-in-array.js b/2341-maximum-number-of-pairs-in-array.js
new file mode 100644
index 00000000..98771fc3
--- /dev/null
+++ b/2341-maximum-number-of-pairs-in-array.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var numberOfPairs = function(nums) {
+  const n = nums.length
+  let res = 0
+  const hash = {}
+  for(const e of nums) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+    if(hash[e] === 2) {
+      res++
+      hash[e] = 0
+    }
+  }
+  
+  return [res, n - res * 2]
+};

From cef7477f016bba0a69216d8c25d9ca2ce46137f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jul 2022 13:13:58 +0800
Subject: [PATCH 2166/3374] Create
 2342-max-sum-of-a-pair-with-equal-sum-of-digits.js

---
 ...-sum-of-a-pair-with-equal-sum-of-digits.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2342-max-sum-of-a-pair-with-equal-sum-of-digits.js

diff --git a/2342-max-sum-of-a-pair-with-equal-sum-of-digits.js b/2342-max-sum-of-a-pair-with-equal-sum-of-digits.js
new file mode 100644
index 00000000..1c9f1b10
--- /dev/null
+++ b/2342-max-sum-of-a-pair-with-equal-sum-of-digits.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumSum = function(nums) {
+  const map = new Map()
+  for(const e of nums) {
+    const k = dSum(e)
+    add(map, k, e)
+  }
+  // console.log(map)
+  let res = -1
+  for(const [k, v] of map) {
+    if(v.length === 2) {
+      res = Math.max(res, v[0] + v[1])
+    }
+  }
+  
+  return res
+  
+  
+  function add(map, k, v) {
+    if(!map.has(k)) {
+      map.set(k, [v])
+    } else {
+      if(map.get(k).length === 1) {
+        map.get(k).push(v)
+      } else {
+        const arr = map.get(k)
+        arr.push(v)
+        arr.sort((a, b) => b - a)
+        arr.splice(2, 1)
+      }
+    }
+  }
+  
+  function dSum(num) {
+    let res = 0
+    
+    let cur = num
+    while(cur) {
+      res += cur % 10
+      cur = ~~(cur / 10)
+    }
+    
+    return res
+  }
+};

From 46327bfcb1560dc15f21f06b3015713ad27903c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jul 2022 13:14:28 +0800
Subject: [PATCH 2167/3374] Create 2343-query-kth-smallest-trimmed-number.js

---
 2343-query-kth-smallest-trimmed-number.js | 32 +++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2343-query-kth-smallest-trimmed-number.js

diff --git a/2343-query-kth-smallest-trimmed-number.js b/2343-query-kth-smallest-trimmed-number.js
new file mode 100644
index 00000000..5d0b7085
--- /dev/null
+++ b/2343-query-kth-smallest-trimmed-number.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const smallestTrimmedNumbers = function(nums, queries) {
+  const m = nums.length, n = queries.length, len = nums[0].length
+  const res = []
+  
+  for(const [k, trim] of queries) {
+    const tmp = nums.map(e => e.slice(trim>len?0:len - trim))
+    // console.log(trim, tmp)
+    const clone = tmp.slice().map((e,i) => ({v:e,i}))
+    clone.sort((a, b) => {
+      a = BigInt(a.v)
+      b = BigInt(b.v)
+      if(a > b) {
+        return 1;
+      } else if (a < b){
+        return -1;
+      } else {
+        return 0;
+      }
+    })
+    // console.log(clone)
+    const el = clone[k - 1]
+    // const idx = tmp.lastIndexOf(el)
+    res.push(el.i)
+  }
+  
+  return res
+};

From d5da56f7dfada1053f802c5f13286be09fec5135 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jul 2022 13:14:57 +0800
Subject: [PATCH 2168/3374] Create
 2344-minimum-deletions-to-make-array-divisible.js

---
 ...nimum-deletions-to-make-array-divisible.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2344-minimum-deletions-to-make-array-divisible.js

diff --git a/2344-minimum-deletions-to-make-array-divisible.js b/2344-minimum-deletions-to-make-array-divisible.js
new file mode 100644
index 00000000..466d2bd8
--- /dev/null
+++ b/2344-minimum-deletions-to-make-array-divisible.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} numsDivide
+ * @return {number}
+ */
+var minOperations = function(nums, numsDivide) {
+  let div = numsDivide[0], min = Infinity
+  for(let i = 1, n = numsDivide.length; i < n; i++) {
+    div = Math.min(div, gcd(numsDivide[i], div))
+    min = Math.min(min, numsDivide[i])
+  }
+  // console.log(div)
+
+  nums.sort((a, b) => a - b)
+  if(div === 1 && nums[0] !== 1) return -1
+  let res = 0
+  for(const e of nums) {
+    if(e > min) break
+    if(div % e === 0) {
+      return res
+    }
+    if(e % div !== 0) res++
+    else {
+      return res
+    }
+  }
+  
+  return -1
+  
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+};

From d3686016cc72060958980ba3df135a3c49d7d291 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Jul 2022 19:39:13 +0800
Subject: [PATCH 2169/3374] Create 2222-number-of-ways-to-select-buildings.js

---
 2222-number-of-ways-to-select-buildings.js | 27 ++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2222-number-of-ways-to-select-buildings.js

diff --git a/2222-number-of-ways-to-select-buildings.js b/2222-number-of-ways-to-select-buildings.js
new file mode 100644
index 00000000..02572411
--- /dev/null
+++ b/2222-number-of-ways-to-select-buildings.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numberOfWays = function(s) {
+  let one = 0, zero = 0
+  for(const ch of s) {
+    if(ch === '1') one++
+    else zero++
+  }
+  let preOne = 0, preZero = 0
+  let res = 0
+  
+  for(const ch of s) {
+    if(ch === '1') {
+      res += preZero * zero
+      preOne++
+      one--
+    } else {
+      res += preOne * one
+      preZero++
+      zero--
+    }
+  }
+  
+  return res
+};

From 7d4dc20ca63bb691125dac20b74175e9efffbbc4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Jul 2022 20:47:35 +0800
Subject: [PATCH 2170/3374] Update
 2267-check-if-there-is-a-valid-parentheses-string-path.js

---
 ...here-is-a-valid-parentheses-string-path.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/2267-check-if-there-is-a-valid-parentheses-string-path.js b/2267-check-if-there-is-a-valid-parentheses-string-path.js
index 429c229d..bafe3949 100644
--- a/2267-check-if-there-is-a-valid-parentheses-string-path.js
+++ b/2267-check-if-there-is-a-valid-parentheses-string-path.js
@@ -1,3 +1,40 @@
+/**
+ * @param {character[][]} grid
+ * @return {boolean}
+ */
+const hasValidPath = function (grid) {
+  const m = grid.length
+  const n = grid[0].length
+  if (grid[0][0] != '(' || grid[m - 1][n - 1] != ')') return false
+  const dp = kdArr(-1, [m, n, ~~((m + n) / 2) + 1])
+
+
+  function dfs(i, j, left) {
+    if (i >= m || j >= n) return false
+    if (grid[i][j] === '(') left++
+    else left--
+    if (left < 0 || left > Math.floor((m + n) / 2)) return false
+    if (dp[i][j][left] != -1) return dp[i][j][left]
+    if (i == m - 1 && j == n - 1 && left == 0) return (dp[i][j][left] = true)
+    return (dp[i][j][left] = dfs(i, j + 1, left) || dfs(i + 1, j, left))
+  }
+  return dfs(0, 0, 0)
+  
+  function kdArr(defaultVal, arr) {
+    if(arr.length === 1) return Array(arr[0]).fill(defaultVal)
+    
+    const res = []
+    for(let i = 0, len = arr[0]; i < len; i++) {
+      res.push(kdArr(defaultVal, arr.slice(1)))
+    }
+    
+    return res
+  }
+}
+
+
+// another
+
 /**
  * @param {character[][]} grid
  * @return {boolean}

From fd22dfce70d5cccfb008ca7e9f8b6dae3afd09fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jul 2022 09:23:18 +0800
Subject: [PATCH 2171/3374] Update 2327-number-of-people-aware-of-a-secret.js

---
 2327-number-of-people-aware-of-a-secret.js | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/2327-number-of-people-aware-of-a-secret.js b/2327-number-of-people-aware-of-a-secret.js
index 2ef272bd..83cf4e8f 100644
--- a/2327-number-of-people-aware-of-a-secret.js
+++ b/2327-number-of-people-aware-of-a-secret.js
@@ -30,20 +30,19 @@ const peopleAwareOfSecret = function(n, delay, forget) {
  * @param {number} forget
  * @return {number}
  */
-const peopleAwareOfSecret = function(n, delay, forget) {
+ const peopleAwareOfSecret = function(n, delay, forget) {
+  const mod = 1e9 + 7
   const dp = Array(n + 1).fill(0)
+  const { max } = Math
   dp[1] = 1
-  const mod = 1e9 + 7
-  const { min, max } = Math
   let share = 0
   for(let i = 2; i <= n; i++) {
-    share = (share + dp[max(i - delay, 0)] - dp[max(i - forget, 0)] + mod) % mod
+    share = (share + dp[max(0, i - delay)] - dp[max(i - forget, 0)] + mod) % mod
     dp[i] = share
   }
   let res = 0
   for(let i = n - forget + 1; i <= n; i++) {
     res = (res + dp[i]) % mod
   }
- 
   return res
 };

From ceea55de45c5823c899b55247fa5688769be6c30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Jul 2022 20:38:54 +0800
Subject: [PATCH 2172/3374] Create 1573-number-of-ways-to-split-a-string.js

---
 1573-number-of-ways-to-split-a-string.js | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1573-number-of-ways-to-split-a-string.js

diff --git a/1573-number-of-ways-to-split-a-string.js b/1573-number-of-ways-to-split-a-string.js
new file mode 100644
index 00000000..951172e8
--- /dev/null
+++ b/1573-number-of-ways-to-split-a-string.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numWays = function(s) {
+  const n = s.length
+  const cnt = Array(n).fill(0)
+  let num = 0
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '1') num++
+    cnt[i] = num
+  }
+  const mod = 1e9 + 7
+  let i0 = -1, i1 = -1, i2 = -1, i3 = -1
+  for(let i = 0; i < n; i++) {
+    if(cnt[i] === num / 3) {
+      if(i0 === -1) i0 = i1 = i
+      else i1 = i
+    } else if(cnt[i] === 2 * num / 3) {
+      if(i2 === -1) i2 = i3 = i
+      else i3 = i
+    }
+  }
+  if(num === 0) return (n - 1) * (n - 2) / 2 % mod
+  if(i0 === -1 || i1 === -1 || i2 === -1 || i3 === -1) return 0
+
+  return (i1 - i0 + 1) * (i3 - i2 + 1) % mod
+};

From ef9451e7b04a58e68dd109363744bdb1d8c80f56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Jul 2022 19:42:13 +0800
Subject: [PATCH 2173/3374] Create
 2184-number-of-ways-to-build-sturdy-brick-wall.js

---
 ...mber-of-ways-to-build-sturdy-brick-wall.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 2184-number-of-ways-to-build-sturdy-brick-wall.js

diff --git a/2184-number-of-ways-to-build-sturdy-brick-wall.js b/2184-number-of-ways-to-build-sturdy-brick-wall.js
new file mode 100644
index 00000000..1d53cd50
--- /dev/null
+++ b/2184-number-of-ways-to-build-sturdy-brick-wall.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number} height
+ * @param {number} width
+ * @param {number[]} bricks
+ * @return {number}
+ */
+const buildWall = function (height, width, bricks) {
+  const MOD = 1e9 + 7
+  const rowPerms = new Set() // save all possible permutations of a row as a bitmask
+  const memo = []
+  for (let i = 0; i <= height; ++i) {
+    memo[i] = new Array(2 ** 10).fill(0)
+  }
+  findAllPossRowPerms(rowPerms, 0, 0 | 0)
+  return countWaysToBuildSturdyWall(height, 0)
+
+  function countWaysToBuildSturdyWall(currHeight, prevRowPerm) {
+    if (currHeight === 0) return 1
+    if (memo[currHeight][prevRowPerm] != 0) {
+      return memo[currHeight][prevRowPerm]
+    }
+    let totCount = 0
+    for (const rowPerm of rowPerms) {
+      if ((rowPerm & prevRowPerm) === 0) {
+        totCount =
+          (totCount + countWaysToBuildSturdyWall(currHeight - 1, rowPerm)) % MOD
+      }
+    }
+    memo[currHeight][prevRowPerm] = totCount
+    return totCount
+  }
+
+  function findAllPossRowPerms(rowPerms, currWidth, mask) {
+    if (currWidth === width) {
+      rowPerms.add(mask)
+      return
+    }
+    // The reason why we don't want to mark the 0 index is that we are going from right to left
+    // when creating the wall and unlike other points of a row, the all rows will be flushed
+    // against the 0 index.
+    if (currWidth > 0) mask |= 1 << currWidth
+    for (const brick of bricks) {
+      if (currWidth + brick <= width) {
+        findAllPossRowPerms(rowPerms, currWidth + brick, mask)
+      }
+    }
+    return
+  }
+}

From 96ace54866f451a9a30433c08550645483830264 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Jul 2022 08:55:46 +0800
Subject: [PATCH 2174/3374] Update 767-reorganize-string.js

---
 767-reorganize-string.js | 44 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/767-reorganize-string.js b/767-reorganize-string.js
index 8cbc6901..be449e84 100644
--- a/767-reorganize-string.js
+++ b/767-reorganize-string.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const reorganizeString = function (s) {
+  const freq = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0), n = s.length
+  for(const e of s) {
+    freq[e.charCodeAt(0) - a]++
+  }
+  let max = 0, maxIdx = 0
+  for(let i = 0; i < 26; i++) {
+    if(freq[i] > max) {
+      max = freq[i]
+      maxIdx = i
+    }
+  }
+
+  if(max > (n + 1) / 2) return ''
+
+  const res = Array(n)
+
+  let idx = 0
+  while(freq[maxIdx]) {
+    res[idx] = String.fromCharCode(a + maxIdx)
+    idx += 2
+    freq[maxIdx]--
+  }
+
+  for(let i = 0; i < 26; i++) {
+    while(freq[i]) {
+      if(idx >= n) idx = 1
+      res[idx] = String.fromCharCode(i + a)
+      idx += 2
+      freq[i]--
+    }
+  }
+
+  return res.join('')
+}
+
+// another
+
+
 /**
  * @param {string} S
  * @return {string}

From e647bdd6af018adbfb4991e3689c38bd83a6b507 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Jul 2022 22:26:29 +0800
Subject: [PATCH 2175/3374] Create 2338-count-the-number-of-ideal-arrays.js

---
 2338-count-the-number-of-ideal-arrays.js | 50 ++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2338-count-the-number-of-ideal-arrays.js

diff --git a/2338-count-the-number-of-ideal-arrays.js b/2338-count-the-number-of-ideal-arrays.js
new file mode 100644
index 00000000..5c64c355
--- /dev/null
+++ b/2338-count-the-number-of-ideal-arrays.js
@@ -0,0 +1,50 @@
+const ll = BigInt, mod = ll(1e9 + 7), N = 1e4 + 15;
+
+const hcomb = (p, q) => p == 0 && q == 0 ? 1 : comb(p + q - 1, q);
+const comb_init = () => {
+    fact[0] = ifact[0] = inv[1] = 1n; // factorial, inverse factorial
+    for (let i = 2; i < N; i++) inv[i] = (mod - mod / ll(i)) * inv[mod % ll(i)] % mod;
+    for (let i = 1; i < N; i++) {
+        fact[i] = fact[i - 1] * ll(i) % mod;
+        ifact[i] = ifact[i - 1] * inv[i] % mod;
+    }
+};
+
+// combination mod pick k from n
+const comb = (n, k) => {
+    if (n < k || k < 0) return 0;
+    return fact[n] * ifact[k] % mod * ifact[n - k] % mod;
+};
+
+/*
+prerequisite:
+(number of factors)
+https://www.codechef.com/LTIME01/problems/NUMFACT
+my solution: https://www.codechef.com/viewsolution/67461009
+*/
+const number_factor = (n) => {
+    let m = new Map();
+    for (let i = 2; i * i <= n; i++) {
+        while (n % i == 0) {
+            n /= i;
+            m.set(i, m.get(i) + 1 || 1);
+        }
+    }
+    if (n > 1) m.set(n, m.get(n) + 1 || 1);
+    return m;
+};
+
+let fact, ifact, inv;
+const idealArrays = (n, maxValue) => {
+    fact = Array(N).fill(0), ifact = Array(N).fill(0), inv = Array(N).fill(0);
+    comb_init();
+    let res = 0n;
+    for (let x = 1; x <= maxValue; x++) {
+        let perm = 1n, m = number_factor(x);
+        for (const [x, occ] of m) {
+            perm = perm * hcomb(n, occ) % mod;
+        }
+        res += perm;
+    }
+    return res % mod;
+};

From 39472ee7e1c9d1d085f390c1d1544b06577907ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Jul 2022 22:31:03 +0800
Subject: [PATCH 2176/3374] Update 2338-count-the-number-of-ideal-arrays.js

---
 2338-count-the-number-of-ideal-arrays.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/2338-count-the-number-of-ideal-arrays.js b/2338-count-the-number-of-ideal-arrays.js
index 5c64c355..2de50cd1 100644
--- a/2338-count-the-number-of-ideal-arrays.js
+++ b/2338-count-the-number-of-ideal-arrays.js
@@ -20,7 +20,6 @@ const comb = (n, k) => {
 prerequisite:
 (number of factors)
 https://www.codechef.com/LTIME01/problems/NUMFACT
-my solution: https://www.codechef.com/viewsolution/67461009
 */
 const number_factor = (n) => {
     let m = new Map();

From a1d42132f16118d4d557037916798a558b500881 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Jul 2022 20:10:52 +0800
Subject: [PATCH 2177/3374] Update
 1953-maximum-number-of-weeks-for-which-you-can-work.js

---
 ...m-number-of-weeks-for-which-you-can-work.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/1953-maximum-number-of-weeks-for-which-you-can-work.js b/1953-maximum-number-of-weeks-for-which-you-can-work.js
index fc834574..c981ef69 100644
--- a/1953-maximum-number-of-weeks-for-which-you-can-work.js
+++ b/1953-maximum-number-of-weeks-for-which-you-can-work.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[]} milestones
+ * @return {number}
+ */
+const numberOfWeeks = function(milestones) {
+  let max = -Infinity
+  let res = 0, sum = 0
+  for(const e of milestones) {
+    max = Math.max(e, max)
+    sum += e
+  }
+  
+  return Math.min(sum, (sum - max) * 2 + 1)
+};
+
+
+// another
+
 /**
  * @param {number[]} milestones
  * @return {number}

From 21fe03bd1908649f79b4db14b525fdc26d68f8f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jul 2022 14:13:10 +0800
Subject: [PATCH 2178/3374] Create 2351-first-letter-to-appear-twice.js

---
 2351-first-letter-to-appear-twice.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 2351-first-letter-to-appear-twice.js

diff --git a/2351-first-letter-to-appear-twice.js b/2351-first-letter-to-appear-twice.js
new file mode 100644
index 00000000..4304af5f
--- /dev/null
+++ b/2351-first-letter-to-appear-twice.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {character}
+ */
+var repeatedCharacter = function(s) {
+  const set = new Set()
+  
+  for(const e of s) {
+    if(set.has(e)) return e
+    else set.add(e)
+  }
+};

From ab3db4c8ff3071b22f92bda14aefc588a3d81657 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jul 2022 14:13:42 +0800
Subject: [PATCH 2179/3374] Create 2352-equal-row-and-column-pairs.js

---
 2352-equal-row-and-column-pairs.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2352-equal-row-and-column-pairs.js

diff --git a/2352-equal-row-and-column-pairs.js b/2352-equal-row-and-column-pairs.js
new file mode 100644
index 00000000..75c12119
--- /dev/null
+++ b/2352-equal-row-and-column-pairs.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var equalPairs = function(grid) {
+  let res = 0
+  
+  const n = grid.length
+  for(let i = 0; i <n; i++) {
+    for(let j = 0; j < n;j++){
+      let tmp = true
+      for(let k = 0; k < n; k++) {
+        if(grid[i][k] !== grid[k][j]) {
+          tmp = false
+          break
+        }
+      }
+      if(tmp) res++
+    }
+  }
+  
+  return res
+};

From 798c0eb71307ed81d76aa591b3a4b1c7fccb5f63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jul 2022 14:16:40 +0800
Subject: [PATCH 2180/3374] Create 2353-design-a-food-rating-system.js

---
 2353-design-a-food-rating-system.js | 42 +++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2353-design-a-food-rating-system.js

diff --git a/2353-design-a-food-rating-system.js b/2353-design-a-food-rating-system.js
new file mode 100644
index 00000000..3c0b54b1
--- /dev/null
+++ b/2353-design-a-food-rating-system.js
@@ -0,0 +1,42 @@
+/**
+ * @param {string[]} foods
+ * @param {string[]} cuisines
+ * @param {number[]} ratings
+ */
+var FoodRatings = function(foods, cuisines, ratings) {
+    let n = foods.length, cm = new Map(), fm = new Map(); // cm: cuisine map {cuisine: pq}, fm: food map {food: [cuisine, rating]}
+    for (let i = 0; i < n; i++) {
+        fm.set(foods[i], [cuisines[i], ratings[i]]);
+        if (!cm.has(cuisines[i])) {
+            let pq = new MaxPriorityQueue({
+                compare: (x, y) => {
+                    if (x[0] != y[0]) return y[0] - x[0]; // first priority: high rate comes first
+                    return x[1].localeCompare(y[1]); // second priority: lexical smaller comes first
+                }
+            });
+            cm.set(cuisines[i], pq);
+        }
+        cm.get(cuisines[i]).enqueue([ratings[i], foods[i]])
+    }
+    return { changeRating, highestRated }
+    function changeRating(food, newRating) {
+        let cur = fm.get(food), cuisine = cur[0];
+        cur[1] = newRating;
+        fm.set(food, cur);
+        cm.get(cuisine).enqueue([newRating, food]);
+    }
+    function highestRated(cuisine) {
+        let pq = cm.get(cuisine);
+        while (fm.get(pq.front()[1])[1] != pq.front()[0]) pq.dequeue(); // lazy remove
+        return pq.front()[1];
+    }
+};
+
+
+/** 
+ * Your FoodRatings object will be instantiated and called as such:
+ * var obj = new FoodRatings(foods, cuisines, ratings)
+ * obj.changeRating(food,newRating)
+ * var param_2 = obj.highestRated(cuisine)
+ */
+

From a20e690ff11b4ca3211acfa504633fe6617266cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jul 2022 14:35:41 +0800
Subject: [PATCH 2181/3374] Create 2354-number-of-excellent-pairs.js

---
 2354-number-of-excellent-pairs.js | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2354-number-of-excellent-pairs.js

diff --git a/2354-number-of-excellent-pairs.js b/2354-number-of-excellent-pairs.js
new file mode 100644
index 00000000..5f66e7a2
--- /dev/null
+++ b/2354-number-of-excellent-pairs.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countExcellentPairs = function(nums, k) {
+    const map = new Map();
+    const set = new Set();
+    const l = nums.length;
+    let res = 0;
+    for (let num of nums) {
+        let temp = num.toString(2).split("1").length - 1;
+        if (!map.has(temp)) {
+            map.set(temp, new Set([num]));
+        } else {
+            map.get(temp).add(num);
+        }
+    }
+    
+    for (let num of nums) {
+        let temp = num.toString(2).split("1").length - 1;
+        if(!set.has(num)) {
+            let gap = Math.max(0, k - temp)
+            for (let key of map.keys()) {
+                if (key >= gap) {
+                    res += map.get(key).size;
+                }
+            }  
+            set.add(num);
+        }else {
+            continue;
+        }
+    }
+    return res; 
+};

From 40d45ad2a0eb2904b847fac5076516914bd5f57c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Jul 2022 23:09:10 +0800
Subject: [PATCH 2182/3374] Update 2354-number-of-excellent-pairs.js

---
 2354-number-of-excellent-pairs.js | 55 +++++++++++++++++--------------
 1 file changed, 30 insertions(+), 25 deletions(-)

diff --git a/2354-number-of-excellent-pairs.js b/2354-number-of-excellent-pairs.js
index 5f66e7a2..aec51380 100644
--- a/2354-number-of-excellent-pairs.js
+++ b/2354-number-of-excellent-pairs.js
@@ -4,32 +4,37 @@
  * @return {number}
  */
 const countExcellentPairs = function(nums, k) {
-    const map = new Map();
-    const set = new Set();
-    const l = nums.length;
-    let res = 0;
-    for (let num of nums) {
-        let temp = num.toString(2).split("1").length - 1;
-        if (!map.has(temp)) {
-            map.set(temp, new Set([num]));
-        } else {
-            map.get(temp).add(num);
-        }
+  const arr = [], set = new Set(nums)
+  for(const e of set) {
+    arr.push(setBits(e))
+  }
+
+  arr.sort((a, b) => a - b)
+  let res = 0
+  for(let i = 0, n = arr.length; i < n; i++) {
+    const idx = bs(arr, k - arr[i])
+    res += n - idx
+  }
+  return res
+  
+  
+  function bs(arr, target) {
+    let l = 0, r = arr.length
+    
+    while(l < r) {
+      const mid = (l + r) >> 1
+      if(arr[mid] < target) l = mid + 1
+      else r = mid
     }
     
-    for (let num of nums) {
-        let temp = num.toString(2).split("1").length - 1;
-        if(!set.has(num)) {
-            let gap = Math.max(0, k - temp)
-            for (let key of map.keys()) {
-                if (key >= gap) {
-                    res += map.get(key).size;
-                }
-            }  
-            set.add(num);
-        }else {
-            continue;
-        }
+    return l
+  }
+  function setBits(num) {
+    let res = 0
+    while(num) {
+      res += num % 2
+      num = num >> 1
     }
-    return res; 
+    return res
+  }
 };

From 1456888c7f6d0e82ee31dcac58757dc05f5190f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jul 2022 13:41:17 +0800
Subject: [PATCH 2183/3374] Update 1054-distant-barcodes.js

---
 1054-distant-barcodes.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/1054-distant-barcodes.js b/1054-distant-barcodes.js
index f214d14a..c0930553 100644
--- a/1054-distant-barcodes.js
+++ b/1054-distant-barcodes.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} barcodes
+ * @return {number[]}
+ */
+const rearrangeBarcodes = function(barcodes) {
+  const hash = {}
+  let maxFreq = 0, max = 0
+  for(const e of barcodes) {
+    if(hash[e] == null) hash[e] = 0
+    hash[e]++
+    if(hash[e] > maxFreq) {
+        maxFreq = hash[e]
+        max = e
+    }
+  }
+  const n = barcodes.length
+  const entries = Object.entries(hash)
+  const res = Array(n)
+  let idx = 0
+  while(maxFreq) {
+      res[idx] = max
+      idx += 2
+      maxFreq--
+  }
+  for(let [v, f] of entries) {
+     if(+v === max) continue
+     while(f) {
+         if(idx >= n) idx = 1
+         res[idx] = +v
+         idx += 2
+         f--
+     }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} barcodes
  * @return {number[]}

From d41117975416d86803fd064a5f1582feb399b707 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jul 2022 18:29:57 +0800
Subject: [PATCH 2184/3374] Create 2347-best-poker-hand.js

---
 2347-best-poker-hand.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2347-best-poker-hand.js

diff --git a/2347-best-poker-hand.js b/2347-best-poker-hand.js
new file mode 100644
index 00000000..15e5e320
--- /dev/null
+++ b/2347-best-poker-hand.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} ranks
+ * @param {character[]} suits
+ * @return {string}
+ */
+const bestHand = function(ranks, suits) {
+  let isFlush = false
+  const freq = {}
+  for(const e of suits) {
+      if(freq[e] == null) freq[e] = 0
+      freq[e]++
+      if(freq[e] >= 5) return 'Flush'
+  }
+  const rankHash = {}
+  for(const e of ranks) {
+      if(rankHash[e] == null) rankHash[e] = 0
+      rankHash[e]++
+      if(rankHash[e] >= 3) return 'Three of a Kind'
+  }
+  const rankKeys = Object.keys(rankHash)
+  for(const k of rankKeys) {
+      if(rankHash[k] >= 2) return 'Pair'
+  }
+  return 'High Card'
+};

From 9c9d80546f9bd362691bfbb3c21fa827a2978a3e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jul 2022 19:33:28 +0800
Subject: [PATCH 2185/3374] Create 2348-number-of-zero-filled-subarrays.js

---
 2348-number-of-zero-filled-subarrays.js | 34 +++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2348-number-of-zero-filled-subarrays.js

diff --git a/2348-number-of-zero-filled-subarrays.js b/2348-number-of-zero-filled-subarrays.js
new file mode 100644
index 00000000..98d5fc95
--- /dev/null
+++ b/2348-number-of-zero-filled-subarrays.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const zeroFilledSubarray = function(nums) {
+  let res = 0
+  let idx = -1
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    if(e !== 0) {
+      const len = (i - 1) - idx
+      res += helper(len)
+      idx = i
+    } else {
+      continue
+    }
+  }
+  if(idx !== n - 1) {
+    res += helper(n - 1 - idx)
+  }
+  
+  
+  return res
+  
+  function helper(n) {
+    let res = 0
+    for(let i = 1; i <= n; i++) {
+      res += i
+    }
+    
+    return res
+  }
+};

From dc6ee84a43c0f49c0a1545c64a6d2d4598c37faf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jul 2022 20:42:28 +0800
Subject: [PATCH 2186/3374] Create
 1347-minimum-number-of-steps-to-make-two-strings-anagram.js

---
 ...er-of-steps-to-make-two-strings-anagram.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1347-minimum-number-of-steps-to-make-two-strings-anagram.js

diff --git a/1347-minimum-number-of-steps-to-make-two-strings-anagram.js b/1347-minimum-number-of-steps-to-make-two-strings-anagram.js
new file mode 100644
index 00000000..c568b573
--- /dev/null
+++ b/1347-minimum-number-of-steps-to-make-two-strings-anagram.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+const minSteps = function(s, t) {
+  const as = Array(26).fill(0), ts = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for(const e of s){
+    as[e.charCodeAt(0) - a]++
+  }
+  for(const e of t){
+    ts[e.charCodeAt(0) - a]++
+  }
+  
+  let com = 0
+  for(let i = 0; i < 26; i++) {
+    com += Math.min(as[i], ts[i])
+  }
+  return t.length - com
+};

From 55694ef53d389bd50b79b7daf0e58a3309523ff9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Jul 2022 21:05:54 +0800
Subject: [PATCH 2187/3374] Create 958-check-completeness-of-a-binary-tree.js

---
 958-check-completeness-of-a-binary-tree.js | 49 ++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 958-check-completeness-of-a-binary-tree.js

diff --git a/958-check-completeness-of-a-binary-tree.js b/958-check-completeness-of-a-binary-tree.js
new file mode 100644
index 00000000..577628a0
--- /dev/null
+++ b/958-check-completeness-of-a-binary-tree.js
@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const isCompleteTree = function(root) {
+  let cur = [root]
+  let depth = 1
+  while(cur.length) {
+    const nxt = []
+    // console.log(cur)
+    for(let i = 0; i < cur.length; i++) {
+      const e = cur[i]
+      if(e == null) nxt.push(null, null)
+      else if(e) nxt.push(e.left, e.right)
+    }
+    
+    if(!valid(cur) || (cur[cur.length - 1] == null && valid(nxt))) {
+      return false
+    }
+    
+    if(nxt.some(e => e != null)) {
+      cur = nxt
+    } else {
+      cur = []
+    }
+    depth++
+  }
+  
+  return true
+  
+  function valid(arr) {
+    let firstNull = arr.length, lastNonNull = arr.length
+    for(let i = 0; i < arr.length; i++) {
+      const e = arr[i]
+      if(firstNull === arr.length && e == null) firstNull = i
+      if(e != null) lastNonNull = i
+    }
+    // console.log(firstNull, lastNonNull)
+    return firstNull >= lastNonNull
+  }
+};

From 338ba10056009a2f760dafaa07c9b57569069302 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Jul 2022 14:07:40 +0800
Subject: [PATCH 2188/3374] Update 358-rearrange-string-k-distance-apart.js

---
 358-rearrange-string-k-distance-apart.js | 104 +++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/358-rearrange-string-k-distance-apart.js b/358-rearrange-string-k-distance-apart.js
index f0f22313..825883f5 100644
--- a/358-rearrange-string-k-distance-apart.js
+++ b/358-rearrange-string-k-distance-apart.js
@@ -61,3 +61,107 @@ function findValidMax(count, valid, index) {
   return candidatePos
 }
 
+// another
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const rearrangeString = function(s, k) {
+  const freq = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for(const e of s) {
+    freq[e.charCodeAt(0) - a]++
+  }
+  const pq = new PriorityQueue((a, b) => a[1] > b[1])
+  for(let i = 0; i < 26; i++) {
+    if(freq[i]) pq.push([i, freq[i]])
+  }
+  let res = ''
+  
+  // console.log(pq)
+  const q = []
+  while(!pq.isEmpty()) {
+    const cur = pq.pop()
+    cur[1]--
+    res += String.fromCharCode(a + cur[0])
+    q.push(cur)
+    if(q.length >= k) {
+      const p = q.shift()
+      if(p[1] > 0) pq.push(p)
+    }
+  }
+  // console.log(res)
+  return res.length === s.length ? res : ''
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+

From 125b6ce8f4879f295d6a4cfde8a963e96462c662 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Jul 2022 17:17:15 +0800
Subject: [PATCH 2189/3374] Create 826-most-profit-assigning-work.js

---
 826-most-profit-assigning-work.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 826-most-profit-assigning-work.js

diff --git a/826-most-profit-assigning-work.js b/826-most-profit-assigning-work.js
new file mode 100644
index 00000000..a2acbac0
--- /dev/null
+++ b/826-most-profit-assigning-work.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} difficulty
+ * @param {number[]} profit
+ * @param {number[]} worker
+ * @return {number}
+ */
+const maxProfitAssignment = function(difficulty, profit, worker) {
+  let res = 0
+  const n = profit.length
+  const jobs = []
+  for(let i = 0; i < n; i++) {
+      jobs.push([difficulty[i], profit[i]])
+  }
+  jobs.sort((a,b) => a[0] - b[0])
+  worker.sort((a, b) => a - b)
+  let i = 0, tmp = 0
+  for(let w of worker) {
+      while(i < n && w >= jobs[i][0]) {
+          tmp = Math.max(tmp, jobs[i++][1])
+      }
+      res += tmp
+  }
+  
+  return res
+};
+    

From bdefe38deb7e22b4c6b11d437e5676e51f6e8213 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Jul 2022 21:53:24 +0800
Subject: [PATCH 2190/3374] Create
 1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js

---
 ...solute-diff-less-than-or-equal-to-limit.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js

diff --git a/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js b/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js
new file mode 100644
index 00000000..74c87355
--- /dev/null
+++ b/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const longestSubarray = function(nums, limit) {
+    let maxd = [], mind = [];
+    let i = 0, j;
+    for (j = 0; j < nums.length; ++j) {
+        // non-increase
+        while (maxd.length && nums[j] > maxd[maxd.length - 1]) maxd.pop();
+        // non-decrease
+        while (mind.length && nums[j] < mind[mind.length - 1]) mind.pop();
+
+        maxd.push(nums[j]);
+        mind.push(nums[j]);
+
+        if (maxd[0] - mind[0] > limit) {
+            if (maxd[0] == nums[i]) maxd.shift();
+            if (mind[0] == nums[i]) mind.shift();
+            ++i;
+        }
+    }
+    return j - i; 
+};

From 1069629366230aa0a1a56f67c8c6683003551d71 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jul 2022 09:16:27 +0800
Subject: [PATCH 2191/3374] Update 621-task-scheduler.js

---
 621-task-scheduler.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/621-task-scheduler.js b/621-task-scheduler.js
index fc6cefe3..7f24d89e 100755
--- a/621-task-scheduler.js
+++ b/621-task-scheduler.js
@@ -1,3 +1,36 @@
+/**
+ * @param {character[]} tasks
+ * @param {number} n
+ * @return {number}
+ */
+const leastInterval = function(tasks, n) {
+    const counter = new Array(26).fill(0);
+    let max = 0;
+    let maxCount = 0;
+    const A = 'A'.charCodeAt(0)
+    for(let ch of tasks) {
+        const task = ch.charCodeAt(0)
+        counter[task - A]++;
+        if(max == counter[task - A]) {
+            maxCount++;
+        }
+        else if(max < counter[task - A]) {
+            max = counter[task - A];
+            maxCount = 1;
+        }
+    }
+
+    const partCount = max - 1;
+    const partLength = n - (maxCount - 1);
+    const emptySlots = partCount * partLength;
+    const availableTasks = tasks.length - max * maxCount;
+    const idles = Math.max(0, emptySlots - availableTasks);
+
+    return tasks.length + idles;
+};
+
+// another
+
 /**
  * @param {character[]} tasks
  * @param {number} n

From 297ce135a015caa239f6bd4e873730613d7d5b38 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jul 2022 09:57:44 +0800
Subject: [PATCH 2192/3374] Update 621-task-scheduler.js

---
 621-task-scheduler.js | 44 +++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/621-task-scheduler.js b/621-task-scheduler.js
index 7f24d89e..1c07d12c 100755
--- a/621-task-scheduler.js
+++ b/621-task-scheduler.js
@@ -3,31 +3,31 @@
  * @param {number} n
  * @return {number}
  */
-const leastInterval = function(tasks, n) {
-    const counter = new Array(26).fill(0);
-    let max = 0;
-    let maxCount = 0;
-    const A = 'A'.charCodeAt(0)
-    for(let ch of tasks) {
-        const task = ch.charCodeAt(0)
-        counter[task - A]++;
-        if(max == counter[task - A]) {
-            maxCount++;
-        }
-        else if(max < counter[task - A]) {
-            max = counter[task - A];
-            maxCount = 1;
-        }
+const leastInterval = function (tasks, n) {
+  const len = tasks.length
+  const cnt = Array(26).fill(0)
+
+  const A = 'A'.charCodeAt(0)
+  let maxFreq = 0,
+    maxFreqCnt = 0
+  for (const ch of tasks) {
+    const idx = ch.charCodeAt(0) - A
+    cnt[idx]++
+    if (maxFreq === cnt[idx]) {
+      maxFreqCnt++
+    } else if (maxFreq < cnt[idx]) {
+      maxFreqCnt = 1
+      maxFreq = cnt[idx]
     }
+  }
 
-    const partCount = max - 1;
-    const partLength = n - (maxCount - 1);
-    const emptySlots = partCount * partLength;
-    const availableTasks = tasks.length - max * maxCount;
-    const idles = Math.max(0, emptySlots - availableTasks);
+  const slot = maxFreq - 1
+  const numOfPerSlot = n - (maxFreqCnt - 1)
+  const available = len - maxFreq * maxFreqCnt
+  const idles = Math.max(0, slot * numOfPerSlot - available)
+  return len + idles
+}
 
-    return tasks.length + idles;
-};
 
 // another
 

From f2b57b9c68771c9f8dca020ea7ddc0541cdcc42f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jul 2022 16:29:37 +0800
Subject: [PATCH 2193/3374] Create 904-fruit-into-baskets.js

---
 904-fruit-into-baskets.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 904-fruit-into-baskets.js

diff --git a/904-fruit-into-baskets.js b/904-fruit-into-baskets.js
new file mode 100644
index 00000000..4936d3d0
--- /dev/null
+++ b/904-fruit-into-baskets.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} fruits
+ * @return {number}
+ */
+const totalFruit = function (fruits) {
+  let n = fruits.length
+  let i = 0, j = 0
+  const map = new Map()
+  let res = 0
+  for(;j < n; j++) {
+    const e = fruits[j]
+    if(!map.has(e)) map.set(e, 1)
+    else map.set(e, map.get(e) + 1)
+
+    while(map.size > 2 && i < n) {
+      const tmp = fruits[i++]
+      map.set(tmp, map.get(tmp) - 1)
+      if(map.get(tmp) === 0) {
+        map.delete(tmp)
+      }
+    }
+    res = Math.max(res, j - i + 1)
+  }
+
+  return res
+}

From fe425d32f952d7d5c7c81654aedd72f8b724bcea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Jul 2022 20:52:09 +0800
Subject: [PATCH 2194/3374] Create
 1375-number-of-times-binary-string-is-prefix-aligned.js

---
 ...ber-of-times-binary-string-is-prefix-aligned.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1375-number-of-times-binary-string-is-prefix-aligned.js

diff --git a/1375-number-of-times-binary-string-is-prefix-aligned.js b/1375-number-of-times-binary-string-is-prefix-aligned.js
new file mode 100644
index 00000000..b3f90fed
--- /dev/null
+++ b/1375-number-of-times-binary-string-is-prefix-aligned.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} flips
+ * @return {number}
+ */
+const numTimesAllBlue = function(flips) {
+  let res = 0, right = 0, n = flips.length
+  
+  for(let i = 0; i < n; i++) {
+    right = Math.max(right, flips[i])
+    if(right === i + 1) res++
+  }
+  
+  return res
+};

From b858c2abdec1d18582fcb68b962262c0101e22be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Jul 2022 10:15:56 +0800
Subject: [PATCH 2195/3374] Update 984-string-without-aaa-or-bbb.js

---
 984-string-without-aaa-or-bbb.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/984-string-without-aaa-or-bbb.js b/984-string-without-aaa-or-bbb.js
index bd4832b1..4b41b90a 100644
--- a/984-string-without-aaa-or-bbb.js
+++ b/984-string-without-aaa-or-bbb.js
@@ -22,3 +22,26 @@ const strWithout3a3b = function(a, b) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const strWithout3a3b = function (a, b, ac = 'a', bc = 'b') {
+  const delta = a - b
+  let res = ''
+  if (delta < 0) {
+    return strWithout3a3b(b, a, 'b', 'a')
+  } else {
+    while(a-- > 0) {
+      res += ac
+      if(a > b) res += ac, a--
+      if(b-- > 0) res += bc
+    }
+  }
+
+  return res
+}

From 3744bb57a28c1bbd0571bfc021b1052ff228fc43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Jul 2022 10:49:01 +0800
Subject: [PATCH 2196/3374] Update 984-string-without-aaa-or-bbb.js

---
 984-string-without-aaa-or-bbb.js | 40 ++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/984-string-without-aaa-or-bbb.js b/984-string-without-aaa-or-bbb.js
index 4b41b90a..b5996159 100644
--- a/984-string-without-aaa-or-bbb.js
+++ b/984-string-without-aaa-or-bbb.js
@@ -1,3 +1,43 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const strWithout3a3b = function (a, b) {
+  let res = ''
+
+  while(a > 0 || b > 0) {
+    if(endsWith(res, 'aa')) {
+      res += 'b'
+      b--
+    } else if(endsWith(res, 'bb')) {
+      res += 'a'
+      a--
+    } else if(a >= b) {
+      res += 'a'
+      a--
+    } else {
+      res += 'b'
+      b--
+    }
+  }
+
+  return res
+
+  function endsWith(str, sub) {
+    let i = str.length - 1, j = sub.length - 1
+    for(; i >=0 && j >= 0;i--,j--) {
+      if(str[i] !== sub[j]) return false
+    }
+    if(j >= 0) return false
+
+    return true
+  }
+}
+
+// another
+
+
 /**
  * @param {number} a
  * @param {number} b

From e4acf9819314dcb994cd593b2ad633557e7acb18 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Jul 2022 21:07:28 +0800
Subject: [PATCH 2197/3374] Create
 2128-remove-all-ones-with-row-and-column-flips.js

---
 ...move-all-ones-with-row-and-column-flips.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2128-remove-all-ones-with-row-and-column-flips.js

diff --git a/2128-remove-all-ones-with-row-and-column-flips.js b/2128-remove-all-ones-with-row-and-column-flips.js
new file mode 100644
index 00000000..0de7dfbb
--- /dev/null
+++ b/2128-remove-all-ones-with-row-and-column-flips.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+const removeOnes = function(grid) {
+  
+  const m = grid.length
+  const n = grid[0].length
+  const first = grid[0]
+  for(let i = 1; i < m; i++) {
+    if(!equal(first, grid[i]) && !equal(first, flip(grid[i]))) return false
+  }
+  
+  return true
+  
+  function flip(arr) {
+    const res = []
+    for(const e of arr) {
+      res.push(e === 1 ? 0 : 1)
+    }
+    return res
+  }
+  
+  function equal(a, b) {
+    const n = a.length
+    for(let i = 0; i < n; i++) {
+      if(a[i] !== b[i]) return false
+    }
+    
+    return true
+  }
+};

From df4dfad5ba9688545d15c2f771d7e00b971cd0f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Jul 2022 21:21:14 +0800
Subject: [PATCH 2198/3374] Update
 2128-remove-all-ones-with-row-and-column-flips.js

---
 2128-remove-all-ones-with-row-and-column-flips.js | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/2128-remove-all-ones-with-row-and-column-flips.js b/2128-remove-all-ones-with-row-and-column-flips.js
index 0de7dfbb..55b28358 100644
--- a/2128-remove-all-ones-with-row-and-column-flips.js
+++ b/2128-remove-all-ones-with-row-and-column-flips.js
@@ -3,12 +3,11 @@
  * @return {boolean}
  */
 const removeOnes = function(grid) {
-  
   const m = grid.length
   const n = grid[0].length
-  const first = grid[0]
+  const first = grid[0], firstFliped = flip(first)
   for(let i = 1; i < m; i++) {
-    if(!equal(first, grid[i]) && !equal(first, flip(grid[i]))) return false
+    if(!equal(first, grid[i]) && !equal(firstFliped, grid[i])) return false
   }
   
   return true

From ac154cb5576911b0cd91a9898d1b05141a704750 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Jul 2022 22:56:00 +0800
Subject: [PATCH 2199/3374] Update 1405-longest-happy-string.js

---
 1405-longest-happy-string.js | 38 ++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1405-longest-happy-string.js b/1405-longest-happy-string.js
index 9da22977..d86f669f 100644
--- a/1405-longest-happy-string.js
+++ b/1405-longest-happy-string.js
@@ -53,3 +53,41 @@ function generate(a, b, c, ac, bc, cc) {
   );
 }
 
+// another
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {string}
+ */
+const longestDiverseString = function (a, b, c) {
+  const n = a + b + c
+  let res = ''
+  let A = 0, B = 0, C = 0
+  for(let i = 0; i < n; i++) {
+    if((a >= c && a >= b && A !== 2) || (B === 2 && a > 0) || (C === 2 && a > 0)) {
+      A++
+      res += 'a'
+      a--
+      B = 0
+      C = 0
+    } else if((b >= c && b >= a && B !== 2) || (A === 2 && b > 0) || (C === 2 && b)) {
+      B++
+      res += 'b'
+      b--
+      A = 0
+      C = 0
+    } else if((c >= a && c >= b && C !== 2) || (A === 2 && c) || (B === 2 && c)) {
+      C++
+      res += 'c'
+      c--
+      A = 0
+      B = 0
+    }
+  }
+  
+  return res
+};
+
+

From 630297a3944bbd873b13698fd5282477bd1ff700 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Jul 2022 20:06:59 +0800
Subject: [PATCH 2200/3374] Create
 945-minimum-increment-to-make-array-unique.js

---
 945-minimum-increment-to-make-array-unique.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 945-minimum-increment-to-make-array-unique.js

diff --git a/945-minimum-increment-to-make-array-unique.js b/945-minimum-increment-to-make-array-unique.js
new file mode 100644
index 00000000..8133c9d1
--- /dev/null
+++ b/945-minimum-increment-to-make-array-unique.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minIncrementForUnique = function(nums) {
+  const seen = new Set()
+  const queue = []
+  let res = 0
+  for(const e of nums) {
+    if(!seen.has(e)) seen.add(e)
+    else queue.push(e)
+  }
+  queue.sort((a, b) => b - a)
+  for(let i = 0; i <= 1e5 || queue.length; i++) {
+    if(!seen.has(i) && i > last(queue)) {
+      res += i - queue.pop()
+    }
+  }
+  
+  return res
+    
+    
+  function last(arr) {
+    return arr[arr.length - 1]
+  }
+};

From 652a2e08b036f4a800f546335277c86f54e4490a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Jul 2022 20:40:43 +0800
Subject: [PATCH 2201/3374] Update
 945-minimum-increment-to-make-array-unique.js

---
 945-minimum-increment-to-make-array-unique.js | 20 +++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/945-minimum-increment-to-make-array-unique.js b/945-minimum-increment-to-make-array-unique.js
index 8133c9d1..0ce8f909 100644
--- a/945-minimum-increment-to-make-array-unique.js
+++ b/945-minimum-increment-to-make-array-unique.js
@@ -18,9 +18,25 @@ const minIncrementForUnique = function(nums) {
   }
   
   return res
-    
-    
+ 
   function last(arr) {
     return arr[arr.length - 1]
   }
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minIncrementForUnique = function(nums) {
+  let res = 0, nxt = 0
+  nums.sort((a, b) => a - b)
+  for(const e of nums) {
+    res += Math.max(0, nxt - e)
+    nxt = Math.max(nxt, e) + 1
+  }
+  
+  return res
+};

From 17b25141615fccf3924e6e91a1718603abf1f413 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Jul 2022 21:45:57 +0800
Subject: [PATCH 2202/3374] Create
 1239-maximum-length-of-a-concatenated-string-with-unique-characters.js

---
 ...catenated-string-with-unique-characters.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 1239-maximum-length-of-a-concatenated-string-with-unique-characters.js

diff --git a/1239-maximum-length-of-a-concatenated-string-with-unique-characters.js b/1239-maximum-length-of-a-concatenated-string-with-unique-characters.js
new file mode 100644
index 00000000..7572f0d6
--- /dev/null
+++ b/1239-maximum-length-of-a-concatenated-string-with-unique-characters.js
@@ -0,0 +1,41 @@
+/**
+ * @param {string[]} arr
+ * @return {number}
+ */
+const maxLength = function(arr) {
+    let maxLen = 0;
+    arr = arr.filter(isUnique);
+    const mem = {};
+    maxLen = dfs(arr, "", 0, maxLen, mem);
+    
+    return maxLen;
+};
+
+function dfs(arr, path, i, maxLen, mem) {
+    if (mem[path]) return mem[path];
+    let pathIsUnique = isUnique(path);
+    if (pathIsUnique) {
+        maxLen = Math.max(path.length, maxLen);
+    } 
+    if (i === arr.length || !pathIsUnique) {
+        mem[path] = maxLen;
+        return maxLen;
+    }
+    for (let j = i; j < arr.length; j++) {
+        maxLen = dfs(arr, path + arr[j], j + 1, maxLen, mem);
+    }
+
+
+    mem[path] = maxLen;
+    return maxLen;
+}
+
+function isUnique(str) {
+    const map = {}
+    for (let i = 0; i < str.length; i++) {
+        if (map[str[i]]) return false;
+        map[str[i]] = 1;
+    }
+    
+    return true;
+}

From 687debc43621983fd87ae848a109b749dee29804 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 16:28:23 +0800
Subject: [PATCH 2203/3374] Create 2359-find-closest-node-to-given-two-nodes.js

---
 2359-find-closest-node-to-given-two-nodes.js | 62 ++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 2359-find-closest-node-to-given-two-nodes.js

diff --git a/2359-find-closest-node-to-given-two-nodes.js b/2359-find-closest-node-to-given-two-nodes.js
new file mode 100644
index 00000000..8de57cc7
--- /dev/null
+++ b/2359-find-closest-node-to-given-two-nodes.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} edges
+ * @param {number} node1
+ * @param {number} node2
+ * @return {number}
+ */
+const closestMeetingNode = function(edges, node1, node2) {
+  const graph = {}
+  const n = edges.length
+  for(let i = 0; i < n; i++) {
+    const e = edges[i]
+    if(graph[i] == null) graph[i] = new Set()
+    if(e !== -1) graph[i].add(e)
+  }
+  
+  const dis1 = bfs(node1), dis2 = bfs(node2)
+  // console.log(dis1, dis2)
+  let min = Infinity, res= -1
+  
+  for(let i = 0; i < n; i++) {
+    const disa = dis1[i], disb = dis2[i]
+    if(disa !== Infinity && disb !== Infinity) {
+      const tmp = Math.min(min, Math.max(disa, disb))
+      if(tmp < min) {
+        res = i
+        min = tmp
+      }
+    }
+    
+  }
+  
+  return res
+  
+  function bfs(node) {
+      const dis1 = Array(n).fill(Infinity)
+      dis1[node] = 0
+      const visited = new Set()
+      visited.add(node)
+      let q = [node], dis = 0
+
+      while(q.length) {
+        const size = q.length
+        const nxt = []
+        dis++
+        for(let i = 0; i < size; i++) {
+          const cur = q[i]
+          const tmp = graph[cur]
+          if(tmp) {
+            for(const e of tmp) {
+              if(visited.has(e)) continue
+              nxt.push(e)
+              visited.add(e)
+              dis1[e] = dis
+            }
+          }
+        }
+        q = nxt
+      }
+    return dis1
+  }
+  
+};

From 05321eda6215a69a81902de50d5a0dc015427ec6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 16:29:23 +0800
Subject: [PATCH 2204/3374] Create
 2358-maximum-number-of-groups-entering-a-competition.js

---
 ...number-of-groups-entering-a-competition.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2358-maximum-number-of-groups-entering-a-competition.js

diff --git a/2358-maximum-number-of-groups-entering-a-competition.js b/2358-maximum-number-of-groups-entering-a-competition.js
new file mode 100644
index 00000000..3813ab8d
--- /dev/null
+++ b/2358-maximum-number-of-groups-entering-a-competition.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} grades
+ * @return {number}
+ */
+const maximumGroups = function(grades) {
+  grades.sort((a, b) => a - b)
+  let res = 0
+  let pre = 0, preNum = 0, cur = 0, curNum = 0
+  const n = grades.length
+  for(let i = 0; i < n; i++) {
+    cur += grades[i]
+    curNum++
+    if(cur > pre && curNum > preNum) {
+      res++
+      pre = cur
+      preNum = curNum
+      cur = 0
+      curNum = 0
+    }
+  }
+  
+  
+  return res
+};

From 77c0837e74a82f92a28922d01c4423bbc5d23480 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 16:29:58 +0800
Subject: [PATCH 2205/3374] Create
 2357-make-array-zero-by-subtracting-equal-amounts.js

---
 ...array-zero-by-subtracting-equal-amounts.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2357-make-array-zero-by-subtracting-equal-amounts.js

diff --git a/2357-make-array-zero-by-subtracting-equal-amounts.js b/2357-make-array-zero-by-subtracting-equal-amounts.js
new file mode 100644
index 00000000..8a733003
--- /dev/null
+++ b/2357-make-array-zero-by-subtracting-equal-amounts.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumOperations = function(nums) {
+  
+  let res = 0
+  
+  while(!allZero(nums)) {
+    const sub = minNonZero(nums)
+    nums = nums.map(e => e - sub)
+    
+    res++
+  }
+  
+  return res
+  
+  function minNonZero(arr) {
+    let res = 0
+    const f = arr.filter(e => e > 0)
+    
+    
+    return Math.min(...f)
+  }
+  
+  function allZero(arr) {
+    for(const e of arr) {
+      if(e > 0) return false
+    }
+    return true
+  }
+};

From 067823c50db6a0caefe3a834127af342145329b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 16:52:39 +0800
Subject: [PATCH 2206/3374] Create 2360-longest-cycle-in-a-graph.js

---
 2360-longest-cycle-in-a-graph.js | 33 ++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2360-longest-cycle-in-a-graph.js

diff --git a/2360-longest-cycle-in-a-graph.js b/2360-longest-cycle-in-a-graph.js
new file mode 100644
index 00000000..da87392d
--- /dev/null
+++ b/2360-longest-cycle-in-a-graph.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} edges
+ * @return {number}
+ */
+const longestCycle = function(edges) {
+  const n = edges.length, colors = Array(n).fill(0), dis = Array(n).fill(0)
+  let res = -1
+  
+  for(let i = 0; i < n; i++) {
+    if(colors[i] === 0) {
+      res = Math.max(res, dfs(i, 0))
+    }
+  }
+  
+  return res
+  
+  function dfs(u, d) {
+    let ans = -1
+    dis[u] = d
+    colors[u]  = 1
+    
+    if(edges[u] !== -1) {
+      if(colors[edges[u]] == 1) {
+        return dis[u] - dis[edges[u]] + 1
+      } else if(colors[edges[u]] === 0) {
+        ans = Math.max(ans, dfs(edges[u], d + 1))         
+      }
+    }
+    
+    colors[u] = 2
+    return ans
+  }
+};

From a6ac1c14c47a2ab4b811de010fab022bb698baa4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 19:52:49 +0800
Subject: [PATCH 2207/3374] Create 2333-minimum-sum-of-squared-difference.js

---
 2333-minimum-sum-of-squared-difference.js | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2333-minimum-sum-of-squared-difference.js

diff --git a/2333-minimum-sum-of-squared-difference.js b/2333-minimum-sum-of-squared-difference.js
new file mode 100644
index 00000000..fe9a2a9b
--- /dev/null
+++ b/2333-minimum-sum-of-squared-difference.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k1
+ * @param {number} k2
+ * @return {number}
+ */
+const minSumSquareDiff = function (nums1, nums2, k1, k2) {
+  const n = nums1.length
+  const diff = Array(n).fill(0)
+  for (let i = 0; i < n; ++i) {
+    diff[i] = Math.abs(nums1[i] - nums2[i])
+  }
+  const M = Math.max(...diff)
+  const bucket = Array(M + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    bucket[diff[i]]++
+  }
+  let k = k1 + k2
+  for (let i = M; i > 0; i--) {
+    if (bucket[i] > 0) {
+      const minus = Math.min(bucket[i], k)
+      bucket[i] -= minus
+      bucket[i - 1] += minus
+      k -= minus
+    }
+  }
+  let res = 0
+  for (let i = M; i > 0; --i) {
+    res += bucket[i] * i * i
+  }
+  return res
+}

From 282ca9301a5b6752247aebce3110b91b6412ae36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Jul 2022 20:36:39 +0800
Subject: [PATCH 2208/3374] Update 2333-minimum-sum-of-squared-difference.js

---
 2333-minimum-sum-of-squared-difference.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2333-minimum-sum-of-squared-difference.js b/2333-minimum-sum-of-squared-difference.js
index fe9a2a9b..0837f9ac 100644
--- a/2333-minimum-sum-of-squared-difference.js
+++ b/2333-minimum-sum-of-squared-difference.js
@@ -17,7 +17,7 @@ const minSumSquareDiff = function (nums1, nums2, k1, k2) {
     bucket[diff[i]]++
   }
   let k = k1 + k2
-  for (let i = M; i > 0; i--) {
+  for (let i = M; i > 0 && k; i--) {
     if (bucket[i] > 0) {
       const minus = Math.min(bucket[i], k)
       bucket[i] -= minus

From 638f94a7364ecd3627b07db8de1edf28853a0cf3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Aug 2022 21:02:33 +0800
Subject: [PATCH 2209/3374] Create
 2350-shortest-impossible-sequence-of-rolls.js

---
 2350-shortest-impossible-sequence-of-rolls.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2350-shortest-impossible-sequence-of-rolls.js

diff --git a/2350-shortest-impossible-sequence-of-rolls.js b/2350-shortest-impossible-sequence-of-rolls.js
new file mode 100644
index 00000000..d7bcc54d
--- /dev/null
+++ b/2350-shortest-impossible-sequence-of-rolls.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} rolls
+ * @param {number} k
+ * @return {number}
+ */
+const shortestSequence = function (rolls, k) {
+  let res = 1
+  let set = new Set()
+
+  for (let i of rolls) {
+    set.add(i)
+    if (set.size === k) {
+      res++
+      set = new Set()
+    }
+  }
+  return res
+}

From 6c3790b26c0568648b7dc3340f2c6e07a9896b19 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Aug 2022 14:25:04 +0800
Subject: [PATCH 2210/3374] Create 2242-maximum-score-of-a-node-sequence.js

---
 2242-maximum-score-of-a-node-sequence.js | 140 +++++++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 2242-maximum-score-of-a-node-sequence.js

diff --git a/2242-maximum-score-of-a-node-sequence.js b/2242-maximum-score-of-a-node-sequence.js
new file mode 100644
index 00000000..0494ea71
--- /dev/null
+++ b/2242-maximum-score-of-a-node-sequence.js
@@ -0,0 +1,140 @@
+class Heap {
+  constructor(data = []) {
+    this.data = data
+    this.comparator = (a, b) => a[1] - b[1]
+    this.heapify()
+  }
+
+  // O(nlog(n)). In fact, O(n)
+  heapify() {
+    if (this.size() < 2) return
+    for (let i = 1; i < this.size(); i++) {
+      this.bubbleUp(i)
+    }
+  }
+
+  // O(1)
+  peek() {
+    if (this.size() === 0) return null
+    return this.data[0]
+  }
+
+  // O(log(n))
+  offer(value) {
+    this.data.push(value)
+    this.bubbleUp(this.size() - 1)
+  }
+
+  // O(log(n))
+  poll() {
+    if (this.size() === 0) return null
+    const result = this.data[0]
+    const last = this.data.pop()
+    if (this.size() !== 0) {
+      this.data[0] = last
+      this.bubbleDown(0)
+    }
+    return result
+  }
+
+  // O(log(n))
+  bubbleUp(index) {
+    while (index > 0) {
+      const parentIndex = (index - 1) >> 1
+      if (this.comparator(this.data[index], this.data[parentIndex]) < 0) {
+        this.swap(index, parentIndex)
+        index = parentIndex
+      } else {
+        break
+      }
+    }
+  }
+
+  // O(log(n))
+  bubbleDown(index) {
+    const lastIndex = this.size() - 1
+    while (true) {
+      const leftIndex = index * 2 + 1
+      const rightIndex = index * 2 + 2
+      let findIndex = index
+      if (
+        leftIndex <= lastIndex &&
+        this.comparator(this.data[leftIndex], this.data[findIndex]) < 0
+      ) {
+        findIndex = leftIndex
+      }
+      if (
+        rightIndex <= lastIndex &&
+        this.comparator(this.data[rightIndex], this.data[findIndex]) < 0
+      ) {
+        findIndex = rightIndex
+      }
+      if (index !== findIndex) {
+        this.swap(index, findIndex)
+        index = findIndex
+      } else {
+        break
+      }
+    }
+  }
+
+  // O(1)
+  swap(index1, index2) {
+    ;[this.data[index1], this.data[index2]] = [
+      this.data[index2],
+      this.data[index1],
+    ]
+  }
+
+  // O(1)
+  size() {
+    return this.data.length
+  }
+
+  toArray() {
+    return this.data.reverse().map((dt) => dt.index)
+  }
+}
+
+/**
+ * @param {number[]} scores
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const maximumScore = (scores, edges) => {
+  const n = scores.length
+
+  let top3 = new Array(n).fill().map(() => new Heap())
+
+  for (let [u, v] of edges) {
+    top3[u].offer([v, scores[v]])
+    if (top3[u].size() > 3) top3[u].poll()
+    top3[v].offer([u, scores[u]])
+    if (top3[v].size() > 3) top3[v].poll()
+  }
+
+  let top3Array = new Array(n)
+
+  for (let i = 0; i < n; i++) {
+    top3Array[i] = [...top3[i].data]
+  }
+
+  let ans = -1
+  for (let [b, c] of edges) {
+    if (top3[b].size() < 2 || top3[c].size() < 2) {
+      continue
+    }
+
+    let score = scores[b] + scores[c]
+
+    for (let [a, scoreA] of top3Array[b]) {
+      for (let [d, scoreD] of top3Array[c]) {
+        if (a !== b && a !== c && d !== b && d !== c && a !== d) {
+          ans = Math.max(ans, scoreA + score + scoreD)
+        }
+      }
+    }
+  }
+
+  return ans
+}

From 8fc55dc6b6eafcd430f5954d46acc6174a6ada8d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Aug 2022 14:36:03 +0800
Subject: [PATCH 2211/3374] Update 2242-maximum-score-of-a-node-sequence.js

---
 2242-maximum-score-of-a-node-sequence.js | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/2242-maximum-score-of-a-node-sequence.js b/2242-maximum-score-of-a-node-sequence.js
index 0494ea71..983fb9f8 100644
--- a/2242-maximum-score-of-a-node-sequence.js
+++ b/2242-maximum-score-of-a-node-sequence.js
@@ -103,17 +103,16 @@ class Heap {
  */
 const maximumScore = (scores, edges) => {
   const n = scores.length
+  const top3 = new Array(n).fill().map(() => new Heap())
 
-  let top3 = new Array(n).fill().map(() => new Heap())
-
-  for (let [u, v] of edges) {
+  for (const [u, v] of edges) {
     top3[u].offer([v, scores[v]])
     if (top3[u].size() > 3) top3[u].poll()
     top3[v].offer([u, scores[u]])
     if (top3[v].size() > 3) top3[v].poll()
   }
 
-  let top3Array = new Array(n)
+  const top3Array = new Array(n)
 
   for (let i = 0; i < n; i++) {
     top3Array[i] = [...top3[i].data]
@@ -125,7 +124,7 @@ const maximumScore = (scores, edges) => {
       continue
     }
 
-    let score = scores[b] + scores[c]
+    const score = scores[b] + scores[c]
 
     for (let [a, scoreA] of top3Array[b]) {
       for (let [d, scoreD] of top3Array[c]) {

From 8fd1178bf13912df829c6d57359f3286015b6c8f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Aug 2022 12:05:47 +0800
Subject: [PATCH 2212/3374] Create 2332-the-latest-time-to-catch-a-bus.js

---
 2332-the-latest-time-to-catch-a-bus.js | 42 ++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2332-the-latest-time-to-catch-a-bus.js

diff --git a/2332-the-latest-time-to-catch-a-bus.js b/2332-the-latest-time-to-catch-a-bus.js
new file mode 100644
index 00000000..8b99c6bf
--- /dev/null
+++ b/2332-the-latest-time-to-catch-a-bus.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} buses
+ * @param {number[]} passengers
+ * @param {number} capacity
+ * @return {number}
+ */
+const latestTimeCatchTheBus = function(buses, passengers, capacity) {
+  buses.sort((b1, b2) => b1 - b2)
+  passengers.sort((p1, p2) => p1 - p2)
+  
+  const passengersSet = new Set(passengers)
+  
+  let j = 0
+  let lastBus = []
+  for (let i = 0; i < buses.length; i++) {
+    let k = j
+    let currentBus = []
+    while (k - j < capacity && passengers[k] <= buses[i]) {
+      currentBus.push(passengers[k])
+      k++
+    }
+    lastBus = currentBus
+    j = k
+  }
+  
+  let lastArrival
+  if (lastBus.length == capacity) {
+    lastArrival = lastBus[capacity - 1]
+    while (passengersSet.has(lastArrival)) {
+      lastArrival--
+    }
+  } else {
+    lastArrival = buses[buses.length - 1]
+    
+    while (passengersSet.has(lastArrival)) {
+      lastArrival--
+    }
+  }
+  
+  
+  return lastArrival
+};

From e96cf19739bc5d6bb26ea046b55ee15354938934 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Aug 2022 09:44:07 +0800
Subject: [PATCH 2213/3374] Create
 2311-longest-binary-subsequence-less-than-or-equal-to-k.js

---
 ...ary-subsequence-less-than-or-equal-to-k.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2311-longest-binary-subsequence-less-than-or-equal-to-k.js

diff --git a/2311-longest-binary-subsequence-less-than-or-equal-to-k.js b/2311-longest-binary-subsequence-less-than-or-equal-to-k.js
new file mode 100644
index 00000000..8ff9dddd
--- /dev/null
+++ b/2311-longest-binary-subsequence-less-than-or-equal-to-k.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const longestSubsequence = function(s, k) {
+    let val = 0, pow = 1, oneNum = 0
+    for(let i = s.length - 1; i >= 0 && val + pow <= k; i--) {
+        if(s[i] === '1') {
+            oneNum++
+            val += pow
+        }
+        pow <<= 1
+    }
+    return cnt(s, '0') + oneNum
+   function cnt(s, t) {
+     let res = 0
+     for(const e of s) {
+         if(e === '0') res++
+     }
+     return res
+   }
+};

From 7a42bfde133cadb5d8635b1f9712e6c7afd27ee5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Aug 2022 20:48:16 +0800
Subject: [PATCH 2214/3374] Create
 2263-make-array-non-decreasing-or-non-increasing.js

---
 ...-array-non-decreasing-or-non-increasing.js | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 2263-make-array-non-decreasing-or-non-increasing.js

diff --git a/2263-make-array-non-decreasing-or-non-increasing.js b/2263-make-array-non-decreasing-or-non-increasing.js
new file mode 100644
index 00000000..63b4d19b
--- /dev/null
+++ b/2263-make-array-non-decreasing-or-non-increasing.js
@@ -0,0 +1,93 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var convertArray = function (nums) {
+  function helper(nums) {
+    let que = new PriorityQueue((a, b)=>a > b)
+    let res = 0
+    for (let num of nums) {
+      if (!que.isEmpty() && num < que.peek()) {
+        res += que.pop() - num
+        que.push(num)
+      }
+      que.push(num)
+    }
+    return res
+  }
+
+
+  let nums2 = Array(nums.length).fill(0)
+  for (let i = 0; i < nums.length; i++) {
+    nums2[nums.length - 1 - i] = nums[i]
+  }
+  return Math.min(helper(nums), helper(nums2))
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From d309c37e3cefa8083eb2ed120edc1f7c29b57faf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Aug 2022 12:28:15 +0800
Subject: [PATCH 2215/3374] Create 2370-longest-ideal-subsequence.js

---
 2370-longest-ideal-subsequence.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2370-longest-ideal-subsequence.js

diff --git a/2370-longest-ideal-subsequence.js b/2370-longest-ideal-subsequence.js
new file mode 100644
index 00000000..d08cb5b2
--- /dev/null
+++ b/2370-longest-ideal-subsequence.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const longestIdealString = function(s, k) {
+  const n = s.length
+  const arr = [], a = 'a'.charCodeAt(0)
+  for(const ch of s) {
+    arr.push(ch.charCodeAt(0) - a)
+  }
+  const dp = Array(26).fill(0)
+  for(const e of arr) {
+    dp[e] = 1 + Math.max(...dp.slice(Math.max(0, e - k), e + k + 1))
+  }
+  return Math.max(...dp)
+};
+

From cb46b9dcc692188874b3353a8f7b443a516536f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Aug 2022 12:28:48 +0800
Subject: [PATCH 2216/3374] Create
 2369-check-if-there-is-a-valid-partition-for-the-array.js

---
 ...here-is-a-valid-partition-for-the-array.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2369-check-if-there-is-a-valid-partition-for-the-array.js

diff --git a/2369-check-if-there-is-a-valid-partition-for-the-array.js b/2369-check-if-there-is-a-valid-partition-for-the-array.js
new file mode 100644
index 00000000..bd17e045
--- /dev/null
+++ b/2369-check-if-there-is-a-valid-partition-for-the-array.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var validPartition = function(nums) {
+  const n = nums.length
+  const memo = {}
+  function dfs(i, cur) {
+    // console.log(i,cur)
+    if(i === n) {
+      if(chk1(cur) || chk2(cur) || chk3(cur) || cur.length === 0) return true
+      return false
+    }
+    const k = `${i}_${cur.join(',')}`
+    if(memo[k] != null) return memo[k]
+    let res
+    if(cur.length === 0) {
+      cur.push(nums[i])
+      res = dfs(i + 1, cur)
+    } else if(cur.length === 1) {
+      cur.push(nums[i])
+      res = dfs(i + 1, cur)
+    } else if(cur.length === 2) {
+      let r1 = false
+      if(chk1(cur)) {
+        r1 = dfs(i + 1, [nums[i]])
+      }
+      cur.push(nums[i])
+      let r2 = dfs(i + 1, cur)
+      res = r1 || r2
+    } else if(cur.length === 3) {
+      if(chk2(cur) || chk3(cur)) {
+        res = dfs(i + 1, [nums[i]])
+      }else res = false
+    }
+    memo[k] = res
+    return res
+  }
+  
+  return dfs(0, [])
+  
+  function chk1(arr) {
+    return arr.length === 2 && arr[0] === arr[1]
+  }
+  function chk2(arr) {
+    return arr.length === 3 && arr[0] === arr[1] && arr[2] === arr[1]
+  }
+  function chk3(arr) {
+    return arr.length === 3 && arr[1] - arr[0] === 1 && arr[2] - arr[1] === 1
+  }
+};

From 9cd9403e524538ceea4ed8757da1b51ec2102a5a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Aug 2022 12:29:13 +0800
Subject: [PATCH 2217/3374] Create 2368-reachable-nodes-with-restrictions.js

---
 2368-reachable-nodes-with-restrictions.js | 41 +++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 2368-reachable-nodes-with-restrictions.js

diff --git a/2368-reachable-nodes-with-restrictions.js b/2368-reachable-nodes-with-restrictions.js
new file mode 100644
index 00000000..2cdc408f
--- /dev/null
+++ b/2368-reachable-nodes-with-restrictions.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} restricted
+ * @return {number}
+ */
+const reachableNodes = function(n, edges, restricted) {
+  const graph = {}
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = new Set()
+    if(graph[v] == null) graph[v] = new Set()
+    graph[u].add(v)
+    graph[v].add(u)
+  }
+  const forbid = new Set(restricted)
+  const visited = new Set()
+  let res = 0
+  let q  = []
+  if(!forbid.has(0)) q.push(0)
+  visited.add(0)
+  while(q.length) {
+    const size = q.length
+    const tmp = []
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      res++
+      for(const e of (graph[cur] || [])) {
+        if(!forbid.has(e) && !visited.has(e)) {
+          tmp.push(e)
+          visited.add(e)
+        }
+      }
+      
+    }
+    
+    q = tmp
+  }
+  
+  
+  return res
+};

From caa79de56c297f86538af34a2d45f90a5c46d958 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Aug 2022 12:29:45 +0800
Subject: [PATCH 2218/3374] Create 2367-number-of-arithmetic-triplets.js

---
 2367-number-of-arithmetic-triplets.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2367-number-of-arithmetic-triplets.js

diff --git a/2367-number-of-arithmetic-triplets.js b/2367-number-of-arithmetic-triplets.js
new file mode 100644
index 00000000..bbfec1db
--- /dev/null
+++ b/2367-number-of-arithmetic-triplets.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} diff
+ * @return {number}
+ */
+var arithmeticTriplets = function(nums, diff) {
+   let res = 0
+   const n = nums.length
+   for(let i = 0;i < n - 2; i++) {
+     for(let j = i + 1; j < n - 1; j++) {
+       for(let k = j + 1; k < n; k++) {
+         if(nums[j] - nums[i] === diff && nums[k] - nums[j] === diff) {
+           res++
+         }
+       }
+     }
+   }
+  return res
+};

From d97b7a29663db42f586bfb1ca92c8fffb3e16d59 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Aug 2022 21:15:40 +0800
Subject: [PATCH 2219/3374] Update
 2127-maximum-employees-to-be-invited-to-a-meeting.js

---
 ...um-employees-to-be-invited-to-a-meeting.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/2127-maximum-employees-to-be-invited-to-a-meeting.js b/2127-maximum-employees-to-be-invited-to-a-meeting.js
index c0247001..bcaa93f1 100644
--- a/2127-maximum-employees-to-be-invited-to-a-meeting.js
+++ b/2127-maximum-employees-to-be-invited-to-a-meeting.js
@@ -1,3 +1,54 @@
+/**
+ * @param {number[]} favorite
+ * @return {number}
+ */
+const maximumInvitations = function (favorite) {
+  const n = favorite.length
+  const indegree = Array(n).fill(0)
+  for (let i = 0; i < n; i++) indegree[favorite[i]]++
+  const { max } = Math
+  let q = []
+  const visited = Array(n).fill(0)
+  const depth = Array(n).fill(1)
+  for (let i = 0; i < n; i++) {
+    if (indegree[i] === 0) {
+      depth[i] = 1
+      visited[i] = 1
+      q.push(i)
+    }
+  }
+
+  while (q.length) {
+    const cur = q.shift()
+    const nxt = favorite[cur]
+    indegree[nxt]--
+    if (indegree[nxt] == 0) {
+      q.push(nxt)
+      visited[nxt] = 1
+    }
+    depth[nxt] = depth[cur] + 1
+  }
+
+  let max_circle_size = 0
+  let max_link_size = 0
+  for (let i = 0; i < n; i++) {
+    if (visited[i] === 1) continue
+    let j = i
+    let count = 0
+    while (visited[j] == 0) {
+      count++
+      visited[j] = 1
+      j = favorite[j]
+    }
+    if (count > 2) max_circle_size = max(max_circle_size, count)
+    else if (count == 2) max_link_size += depth[i] + depth[favorite[i]]
+  }
+
+  return max(max_circle_size, max_link_size)
+}
+
+// another
+
 /**
  * @param {number[]} favorite
  * @return {number}

From 07b7c48d3901913067a3553700120b8fdeb432b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Aug 2022 18:56:00 +0800
Subject: [PATCH 2220/3374] Update 792-number-of-matching-subsequences.js

---
 792-number-of-matching-subsequences.js | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/792-number-of-matching-subsequences.js b/792-number-of-matching-subsequences.js
index bf440135..0fc3d939 100644
--- a/792-number-of-matching-subsequences.js
+++ b/792-number-of-matching-subsequences.js
@@ -54,3 +54,34 @@ const numMatchingSubseq = function(S, words) {
     return res
   };
 
+// another
+
+/**
+ * @param {string} s
+ * @param {string[]} words
+ * @return {number}
+ */
+const numMatchingSubseq = function(s, words) {
+  const hash = {}
+  for(const w of words) {
+    const ch = w[0], it = w[Symbol.iterator]()
+    if(hash[ch] == null) hash[ch] = []
+    hash[ch].push(it)
+    it.next()
+  }
+  let res = 0
+  for(const e of s) {
+    const arr = hash[e] || []
+    hash[e] = []
+    for(const it of arr) {
+      const { value, done } = it.next()
+      if(done) res++
+      else {
+        if(hash[value] == null) hash[value] = []
+        hash[value].push(it)
+      }
+    }
+  }
+  
+  return res
+};

From 39fa4f477de0d05a4572db1f88c9f153f6877066 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Aug 2022 19:51:46 +0800
Subject: [PATCH 2221/3374] Update 1055-shortest-way-to-form-string,js

---
 1055-shortest-way-to-form-string,js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1055-shortest-way-to-form-string,js b/1055-shortest-way-to-form-string,js
index 1628fb07..886c670c 100644
--- a/1055-shortest-way-to-form-string,js
+++ b/1055-shortest-way-to-form-string,js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} source
+ * @param {string} target
+ * @return {number}
+ */
+const shortestWay = function(source, target) {
+  const a = 'a'.charCodeAt(0), arr = Array(26).fill(0)
+  for(const ch of source) arr[ch.charCodeAt(0) - a] = 1
+  let res = 0, j = 0
+  for(let i = 0, n = source.length; i < n; i++) {
+    if(arr[target[j].charCodeAt(0) - a] === 0) return -1
+    if(source[i] === target[j]) j++
+    if(j === target.length) {
+      res++
+      break
+    }
+    if(i === n - 1) {
+      res++
+      i = -1
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} source
  * @param {string} target

From b3394c8432549f68efbc4504fb5f9fca006a748a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Aug 2022 10:41:33 +0800
Subject: [PATCH 2222/3374] Update
 524-longest-word-in-dictionary-through-deleting.js

---
 ...est-word-in-dictionary-through-deleting.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/524-longest-word-in-dictionary-through-deleting.js b/524-longest-word-in-dictionary-through-deleting.js
index 70141249..bfe2742f 100644
--- a/524-longest-word-in-dictionary-through-deleting.js
+++ b/524-longest-word-in-dictionary-through-deleting.js
@@ -19,6 +19,38 @@
   return res
 };
 
+// another
+
+/**
+ * @param {string} s
+ * @param {string[]} dictionary
+ * @return {string}
+ */
+const findLongestWord = function (s, dictionary) {
+  const n = dictionary.length
+  const idxArr = Array(n).fill(0)
+  let res = ''
+  for (const ch of s) {
+    for (let i = 0; i < n; i++) {
+      const idx = idxArr[i]
+      if (idx >= dictionary[i].length) continue
+      if (ch === dictionary[i][idx]) {
+        idxArr[i]++
+      }
+
+      if (
+        idxArr[i] === dictionary[i].length &&
+        (dictionary[i].length > res.length ||
+          (dictionary[i].length === res.length && dictionary[i] < res))
+      ) {
+        res = dictionary[i]
+      }
+    }
+  }
+  return res
+}
+
+
 // another
 
 /**

From 388dbb57366d8342ece6a4894f165de265343e9a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Aug 2022 12:32:55 +0800
Subject: [PATCH 2223/3374] Create 1804-implement-trie-ii-prefix-tree.js

---
 1804-implement-trie-ii-prefix-tree.js | 75 +++++++++++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 1804-implement-trie-ii-prefix-tree.js

diff --git a/1804-implement-trie-ii-prefix-tree.js b/1804-implement-trie-ii-prefix-tree.js
new file mode 100644
index 00000000..2e2ecc84
--- /dev/null
+++ b/1804-implement-trie-ii-prefix-tree.js
@@ -0,0 +1,75 @@
+class Node {
+  constructor(val) {
+    this.val = val
+    this.cnt = 0
+    this.children = {}
+    this.wordCnt = 0
+  }
+}
+
+const Trie = function () {
+  this.root = new Node(null)
+}
+
+/**
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.insert = function (word) {
+  let cur = this.root
+  for(const ch of word) {
+    if(cur.children[ch] == null) cur.children[ch] = new Node(ch)
+    cur.children[ch].cnt++
+    cur = cur.children[ch]
+  }
+  cur.wordCnt++
+}
+
+/**
+ * @param {string} word
+ * @return {number}
+ */
+Trie.prototype.countWordsEqualTo = function (word) {
+  let cur = this.root
+  for(const ch of word) {
+    if(cur.children[ch] == null) return 0
+    cur = cur.children[ch]
+  }
+  return cur.wordCnt
+}
+
+/**
+ * @param {string} prefix
+ * @return {number}
+ */
+Trie.prototype.countWordsStartingWith = function (prefix) {
+  let cur = this.root
+  for(const ch of prefix) {
+    if(cur.children[ch] == null) return 0
+    cur = cur.children[ch]
+  }
+  return cur.cnt
+}
+
+/**
+ * @param {string} word
+ * @return {void}
+ */
+Trie.prototype.erase = function (word) {
+  let cur = this.root
+  for(const ch of word) {
+    if(cur.children[ch] == null) break
+    cur.children[ch].cnt--
+    cur = cur.children[ch]
+  }
+  cur.wordCnt--
+}
+
+/**
+ * Your Trie object will be instantiated and called as such:
+ * var obj = new Trie()
+ * obj.insert(word)
+ * var param_2 = obj.countWordsEqualTo(word)
+ * var param_3 = obj.countWordsStartingWith(prefix)
+ * obj.erase(word)
+ */

From ce25b5714b58fc2f34540f5d950f5ebcf0f601c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Aug 2022 12:54:53 +0800
Subject: [PATCH 2224/3374] Create 1324-print-words-vertically.js

---
 1324-print-words-vertically.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 1324-print-words-vertically.js

diff --git a/1324-print-words-vertically.js b/1324-print-words-vertically.js
new file mode 100644
index 00000000..9bf30f31
--- /dev/null
+++ b/1324-print-words-vertically.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+const printVertically = function(s) {
+  const arr = s.split(' ').filter(e => e !== '')
+  const m = arr.length
+  let n = 0
+  for(const e of arr) {
+    n = Math.max(n, e.length)
+  }
+    
+  const mat = Array.from({ length: m }, () => Array(n).fill(' '))
+  for(let i = 0; i < arr.length; i++) {
+    const cur = mat[i]
+    for(let j = 0; j < arr[i].length; j++) {
+        mat[i][j] = arr[i][j]
+    }
+  }
+  const res = []
+  for(let j = 0; j < n; j++) {
+      const col = []
+      for(let i = 0; i < m; i++) {
+          col.push(mat[i][j])
+      }
+      res.push(col.join('').trimEnd())
+  }
+  
+  return res
+};

From dc463a1d90d31804198b2bcd4bc69322fb88888a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Aug 2022 21:58:21 +0800
Subject: [PATCH 2225/3374] Update 2055-plates-between-candles.js

---
 2055-plates-between-candles.js | 43 ++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/2055-plates-between-candles.js b/2055-plates-between-candles.js
index a5f6cc3a..be63d3b9 100644
--- a/2055-plates-between-candles.js
+++ b/2055-plates-between-candles.js
@@ -36,3 +36,46 @@ const platesBetweenCandles = function(s, queries) {
 
   return res
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const platesBetweenCandles = function (s, queries) {
+  const n = s.length
+  const leftArr = Array(n).fill(-1),
+    rightArr = Array(n).fill(n),
+    candleCnt = Array(n).fill(0)
+  let candle = -1
+  for (let i = 0; i < n; i++) {
+    if (s[i] === '|') candle = i
+    leftArr[i] = candle
+  }
+  candle = n
+  for (let i = n - 1; i >= 0; i--) {
+    if (s[i] === '|') candle = i
+    rightArr[i] = candle
+  }
+  let cnt = 0
+  for (let i = 0; i < n; i++) {
+    if (s[i] === '|') cnt++
+    candleCnt[i] = cnt
+  }
+  // console.log(leftArr, rightArr)
+  const res = []
+  for (const [s, e] of queries) {
+    const l = rightArr[s]
+    const r = leftArr[e]
+    const diff = r - l
+    if (diff > 1) {
+      const e = r - l + 1 - (candleCnt[r] - candleCnt[l] + 1)
+      res.push(e)
+    } else res.push(0)
+  }
+
+  return res
+}
+

From 417993b847f72496cf8ce057d0e1c99325346898 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Aug 2022 21:58:41 +0800
Subject: [PATCH 2226/3374] Update 2055-plates-between-candles.js

---
 2055-plates-between-candles.js | 49 ++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/2055-plates-between-candles.js b/2055-plates-between-candles.js
index be63d3b9..bca0a066 100644
--- a/2055-plates-between-candles.js
+++ b/2055-plates-between-candles.js
@@ -1,3 +1,52 @@
+/**
+ * @param {string} s
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const platesBetweenCandles = function (s, queries) {
+  const candleIdxArr = []
+  const n = s.length
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '|') candleIdxArr.push(i)
+  }
+  // console.log(candleIdxArr)
+  const res = []
+  for(const [s, e] of queries) {
+    const l = lower(candleIdxArr, s, e)
+    const r = upper(candleIdxArr, s ,e)
+    const tmp = (candleIdxArr[r] - candleIdxArr[l] + 1) - (r - l + 1)
+    res.push(tmp >= 0 ? tmp : 0)
+  }
+
+  return res
+
+
+  function lower(arr,s,e) {
+    let l = 0, r = arr.length - 1
+    while(l < r) {
+      // console.log('lower',l, r)
+      const mid = ~~(l + (r - l)/2)
+      if(arr[mid] < s) l = mid + 1
+      else r = mid
+    }
+    return l
+  }
+
+  function upper(arr,s, e) {
+    let l = 0, r = arr.length - 1
+    while(l < r) {
+
+      const mid = r - ~~((r - l)/2)
+      // console.log('upper', l, r, mid, e)
+      if(arr[mid] > e) r = mid - 1
+      else l = mid
+    }
+    return l
+  }
+}
+
+// another
+
 /**
  * @param {string} s
  * @param {number[][]} queries

From 780ccf02b2c2845228ae4695be24fe6f1731c451 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Aug 2022 15:14:15 +0800
Subject: [PATCH 2227/3374] Update 2370-longest-ideal-subsequence.js

---
 2370-longest-ideal-subsequence.js | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2370-longest-ideal-subsequence.js b/2370-longest-ideal-subsequence.js
index d08cb5b2..b9f66ca6 100644
--- a/2370-longest-ideal-subsequence.js
+++ b/2370-longest-ideal-subsequence.js
@@ -1,3 +1,35 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const longestIdealString = function(s, k) {
+  const n = s.length, a = 'a'.charCodeAt(0)
+  const dp = Array(26).fill(0)
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    const cur = s[i], curCode = cur.charCodeAt(0)
+    const tmp = helper(curCode - a) + 1
+    dp[curCode - a] = tmp
+    res = Math.max(res, tmp)
+  }
+  // console.log(dp)
+  return res
+  
+  function helper(end) {
+    let res = 0
+    for(let i = Math.max(0, end - k), e = Math.min(25, end + k); i <= e; i++) {
+      if(dp[i] > res) res = dp[i]
+    }
+    
+    return res
+  }
+};
+
+
+// another
+
 /**
  * @param {string} s
  * @param {number} k

From eb0d5d24cb9f706a43da858d51205c4ce019bdb0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Aug 2022 21:59:16 +0800
Subject: [PATCH 2228/3374] Create
 1381-design-a-stack-with-increment-operation.js

---
 ...design-a-stack-with-increment-operation.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 1381-design-a-stack-with-increment-operation.js

diff --git a/1381-design-a-stack-with-increment-operation.js b/1381-design-a-stack-with-increment-operation.js
new file mode 100644
index 00000000..e9ee6f60
--- /dev/null
+++ b/1381-design-a-stack-with-increment-operation.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} maxSize
+ */
+const CustomStack = function(maxSize) {
+  this.stk = []
+  this.size = maxSize
+  this.inc = []
+};
+
+/** 
+ * @param {number} x
+ * @return {void}
+ */
+CustomStack.prototype.push = function(x) {
+  if(this.stk.length === this.size) return
+  this.stk.push(x)
+  this.inc.push(0)
+};
+
+/**
+ * @return {number}
+ */
+CustomStack.prototype.pop = function() {
+  if(this.stk.length === 0) return -1
+  const e = this.stk.pop()
+  const inc = this.inc.pop()
+  if(this.inc.length) {
+    this.inc[this.inc.length - 1] += inc
+  }
+  return e + inc
+};
+
+/** 
+ * @param {number} k 
+ * @param {number} val
+ * @return {void}
+ */
+CustomStack.prototype.increment = function(k, val) {
+  const last = Math.min(k, this.inc.length) - 1
+  if(last !== -1) {
+    this.inc[last] += val
+  }
+};
+
+/** 
+ * Your CustomStack object will be instantiated and called as such:
+ * var obj = new CustomStack(maxSize)
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * obj.increment(k,val)
+ */

From 891ded4b6eac04d6b26f8915b3b63db25a662401 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Aug 2022 14:42:52 +0800
Subject: [PATCH 2229/3374] Create 2373-largest-local-values-in-a-matrix.js

---
 2373-largest-local-values-in-a-matrix.js | 29 ++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2373-largest-local-values-in-a-matrix.js

diff --git a/2373-largest-local-values-in-a-matrix.js b/2373-largest-local-values-in-a-matrix.js
new file mode 100644
index 00000000..59874826
--- /dev/null
+++ b/2373-largest-local-values-in-a-matrix.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[][]}
+ */
+var largestLocal = function(grid) {
+  const n = grid.length
+  const res = Array.from({ length: n - 2 }, () => Array(n - 2).fill(0))
+  
+  for(let i = 0; i < n - 2; i++) {
+    for(let j = 0; j < n - 2; j++) {
+      res[i][j] = helper(i, j)
+    }
+  }
+  
+  return res
+  
+  function helper(i, j) {
+    let res = 0
+    for(let ii = i; ii < 3 + i; ii++) {
+      for(let jj = j; jj < 3 + j; jj++) {
+        if(grid[ii][jj] > res) {
+          res = grid[ii][jj]
+        }
+      }
+    }
+      
+    return res
+  }
+};

From c584d9c66113a67990bcc2fda4f52b4ac876e30b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Aug 2022 14:43:28 +0800
Subject: [PATCH 2230/3374] Create 2374-node-with-highest-edge-score.js

---
 2374-node-with-highest-edge-score.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2374-node-with-highest-edge-score.js

diff --git a/2374-node-with-highest-edge-score.js b/2374-node-with-highest-edge-score.js
new file mode 100644
index 00000000..41b5d73a
--- /dev/null
+++ b/2374-node-with-highest-edge-score.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} edges
+ * @return {number}
+ */
+var edgeScore = function(edges) {
+  const n = edges.length
+    const score = Array(n).fill(0)
+    for(let i = 0; i < n; i++) {
+      const from = i, to = edges[i]
+      score[to] += from
+    }
+  const max = Math.max(...score)
+  for(let i = 0; i < n; i++) {
+    const e = score[i]
+    if(e === max) return i
+  }
+};

From f8a0930472750cabeb9e676e8cd0a09307768096 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Aug 2022 14:44:08 +0800
Subject: [PATCH 2231/3374] Create
 2375-construct-smallest-number-from-di-string.js

---
 ...onstruct-smallest-number-from-di-string.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2375-construct-smallest-number-from-di-string.js

diff --git a/2375-construct-smallest-number-from-di-string.js b/2375-construct-smallest-number-from-di-string.js
new file mode 100644
index 00000000..425f2116
--- /dev/null
+++ b/2375-construct-smallest-number-from-di-string.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} pattern
+ * @return {string}
+ */
+var smallestNumber = function(pattern) {
+    const n = pattern.length
+    let res = ''
+    dfs('', new Set())
+  
+    return res
+    
+    function dfs(str, set) {
+      if(str.length === n + 1) {
+        if(valid(str)) {
+          if(res === '') res = str
+          else if(str < res) res = str
+        } 
+        return
+      }
+      
+      for(let i = 1; i <= 9; i++) {
+        if(set.has(i)) continue
+        set.add(i)
+        dfs(str + i, set)
+        set.delete(i)
+      }
+      
+    }
+
+    
+    function valid(str) {
+      for(let i = 0; i < n; i++) {
+        if(pattern[i] === 'I' && str[i] >= str[i + 1]) return false
+        if(pattern[i] === 'D' && str[i] <= str[i + 1]) return false
+      }
+      
+      return true
+    }
+};

From dc07b82a4972dcccb87a14163bd47161760c2411 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Aug 2022 14:44:44 +0800
Subject: [PATCH 2232/3374] Create 2376-count-special-integers.js

---
 2376-count-special-integers.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2376-count-special-integers.js

diff --git a/2376-count-special-integers.js b/2376-count-special-integers.js
new file mode 100644
index 00000000..ac7e3eb6
--- /dev/null
+++ b/2376-count-special-integers.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countSpecialNumbers = function(n) {
+  const L = [];
+  for (let x = n + 1; x > 0; x = Math.floor(x / 10)) L.unshift(x % 10);
+
+  // Count the number with digits < N
+  let res = 0,
+    limit = L.length;
+  for (let i = 1; i < limit; ++i) res += 9 * A(9, i - 1);
+
+  const seen = new Set();
+  for (let i = 0; i < limit; ++i) {
+    for (let j = i > 0 ? 0 : 1; j < L[i]; ++j)
+      if (!seen.has(j)) res += A(9 - i, limit - i - 1);
+    if (seen.has(L[i])) break;
+    seen.add(L[i]);
+  }
+  return res;  
+};
+
+
+function A(m, n) {
+  return n === 0 ? 1 : A(m, n - 1) * (m - n + 1);
+}

From 329147bdab90b31d99f53ad1d5fe61aeb1f61988 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Aug 2022 21:24:41 +0800
Subject: [PATCH 2233/3374] Update 727-minimum-window-subsequence.js

---
 727-minimum-window-subsequence.js | 36 +++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/727-minimum-window-subsequence.js b/727-minimum-window-subsequence.js
index ce26ad1b..635bc00f 100644
--- a/727-minimum-window-subsequence.js
+++ b/727-minimum-window-subsequence.js
@@ -1,3 +1,39 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {string}
+ */
+const minWindow = function (s1, s2) {
+  const S = s1,T=s2
+    let m = T.length, n = S.length;
+    let dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let j = 0; j <= n; j++) {
+        dp[0][j] = j + 1;
+    }
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            if (T.charAt(i - 1) == S.charAt(j - 1)) {
+                dp[i][j] = dp[i - 1][j - 1];
+            } else {
+                dp[i][j] = dp[i][j - 1];
+            }
+        }
+    }
+
+    let start = 0, len = n + 1;
+    for (let j = 1; j <= n; j++) {
+        if (dp[m][j] != 0) {
+            if (j - dp[m][j] + 1 < len) {
+                start = dp[m][j] - 1;
+                len = j - dp[m][j] + 1;
+            }
+        }
+    }
+    return len == n + 1 ? "" : S.substring(start, start + len);
+}
+
+// another
+
 /**
  * @param {string} s1
  * @param {string} s2

From 725d1b1fa30dcdf66c5db726d93b08c58eace8bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Aug 2022 19:53:19 +0800
Subject: [PATCH 2234/3374] Update 357-count-numbers-with-unique-digits.js

---
 357-count-numbers-with-unique-digits.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/357-count-numbers-with-unique-digits.js b/357-count-numbers-with-unique-digits.js
index 3534107e..89c6f50b 100755
--- a/357-count-numbers-with-unique-digits.js
+++ b/357-count-numbers-with-unique-digits.js
@@ -16,3 +16,27 @@ const countNumbersWithUniqueDigits = function(n) {
 
   return res;
 };
+
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countNumbersWithUniqueDigits = function(n) {
+  const limit = 10 ** n
+  let res = 1
+  let m = 1
+  if(n === 0) return 1
+  while(10**m <= limit) {
+    res += 9 * helper(9, m - 1)
+    m++
+  }
+  
+  return res
+  
+  function helper(m, n) {
+    return n === 0 ? 1 : helper(m, n - 1) * (m - n + 1)
+  }
+};

From d413c53794589d4ef7416ebfc46c2c906fa47df0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Aug 2022 20:15:57 +0800
Subject: [PATCH 2235/3374] Update 357-count-numbers-with-unique-digits.js

---
 357-count-numbers-with-unique-digits.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/357-count-numbers-with-unique-digits.js b/357-count-numbers-with-unique-digits.js
index 89c6f50b..9aca0ff3 100755
--- a/357-count-numbers-with-unique-digits.js
+++ b/357-count-numbers-with-unique-digits.js
@@ -40,3 +40,23 @@ const countNumbersWithUniqueDigits = function(n) {
     return n === 0 ? 1 : helper(m, n - 1) * (m - n + 1)
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countNumbersWithUniqueDigits = function(n) {
+  if(n === 0) return 1
+  let res = 10
+  let tmp = 9, digits = 9
+  while(n > 1 && digits > 0) {
+    tmp *= digits 
+    res += tmp
+    n--
+    digits--
+  }
+  
+  return res
+};

From cc45ae037a69d27d62217780190172869d9148d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Aug 2022 21:53:03 +0800
Subject: [PATCH 2236/3374] Create 855-exam-room.js

---
 855-exam-room.js | 35 +++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 855-exam-room.js

diff --git a/855-exam-room.js b/855-exam-room.js
new file mode 100644
index 00000000..e5025e9f
--- /dev/null
+++ b/855-exam-room.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} n
+ */
+const ExamRoom = function(n) {
+    let a = [];
+    return { seat, leave }
+    function seat() {
+        if (a.length == 0) {
+            a.push(0);
+            return 0;
+        }
+        let dis = Math.max(a[0], n - 1 - a[a.length - 1]);
+        for (let i = 1; i < a.length; i++) dis = Math.max(dis, a[i] - a[i - 1] >> 1);
+        if (a[0] == dis) {
+            a.unshift(0);
+            return 0;
+        }
+        for (let i = 1; i < a.length; i++) {
+            if (a[i] - a[i - 1] >> 1 == dis) {
+                a.splice(i, 0, a[i] + a[i - 1] >> 1);
+                return a[i];
+            }
+        }
+        a.push(n - 1);
+        return n - 1;
+    }
+    function leave(p) {
+        for (let i = 0; i < a.length; i++) {
+            if (a[i] == p) {
+                a.splice(i, 1);
+                break;
+            }
+        }
+    }
+};

From 890aeb9523a082f5857b3f2f9b7ddad3d918c7a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Aug 2022 16:36:49 +0800
Subject: [PATCH 2237/3374] Update 2376-count-special-integers.js

---
 2376-count-special-integers.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/2376-count-special-integers.js b/2376-count-special-integers.js
index ac7e3eb6..c2f74b4f 100644
--- a/2376-count-special-integers.js
+++ b/2376-count-special-integers.js
@@ -25,3 +25,36 @@ var countSpecialNumbers = function(n) {
 function A(m, n) {
   return n === 0 ? 1 : A(m, n - 1) * (m - n + 1);
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countSpecialNumbers = function (n) {
+  const s = '' + n
+  const dp = Array.from({ length: 11 }, () =>
+    Array.from({ length: 2 }, () => Array(1024).fill(-1))
+  )
+
+  return helper(0, 1, 0, s)
+  function helper(idx, tight = 1, mask = 0, digits) {
+    if (idx == digits.length) return mask !== 0 ? 1 : 0
+
+    if (dp[idx][tight][mask] != -1) return dp[idx][tight][mask]
+
+    let k = tight ? +digits[idx] : 9
+    let ans = 0
+
+    for (let i = 0; i <= k; i++) {
+      if (mask & (1 << i)) continue
+      let newMask = mask == 0 && i == 0 ? mask : mask | (1 << i)
+
+      let nextTight = tight && i == digits[idx] ? 1 : 0
+      ans += helper(idx + 1, nextTight, newMask, digits)
+    }
+
+    return (dp[idx][tight][mask] = ans)
+  }
+}

From d43e96b05f906d5f92ee14994a22c88c0e50226b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Aug 2022 13:44:57 +0800
Subject: [PATCH 2238/3374] Create 1390-four-divisors.js

---
 1390-four-divisors.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1390-four-divisors.js

diff --git a/1390-four-divisors.js b/1390-four-divisors.js
new file mode 100644
index 00000000..14be97bd
--- /dev/null
+++ b/1390-four-divisors.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var sumFourDivisors = function(nums) {
+  let res = 0
+  
+  for(const e of nums) {
+    const set = helper(e)
+    if(set.size === 4) {
+      for(const i of set) res += i
+    }
+  }
+  
+  return res
+    
+  function helper(num) {
+      const set = new Set()
+      const r = ~~(Math.sqrt(num) + 1)
+      for(let i = 1; i < r; i++) {
+          if(num % i === 0) {
+              set.add(i)
+              set.add(num / i)
+          }
+      }
+      return set
+  }
+};

From 9878d9f520f2c8d048892597daa21cc7e35acafc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Aug 2022 14:35:08 +0800
Subject: [PATCH 2239/3374] Create 2367-count-number-of-bad-pairs.js

---
 2367-count-number-of-bad-pairs.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2367-count-number-of-bad-pairs.js

diff --git a/2367-count-number-of-bad-pairs.js b/2367-count-number-of-bad-pairs.js
new file mode 100644
index 00000000..f7c8997d
--- /dev/null
+++ b/2367-count-number-of-bad-pairs.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countBadPairs = function (nums) {
+  let cnt = 0
+  const n = nums.length
+  const mp = {}
+  for (let i = 0; i < n; i++) {
+    const prev = mp[i - nums[i]] || 0
+    cnt += prev
+    mp[i - nums[i]] = prev + 1
+  }
+  return (n * (n - 1)) / 2 - cnt
+}

From f66ef849fd0d1c7777890bda3d582c39c036ae27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 18:37:09 +0800
Subject: [PATCH 2240/3374] Update 902-numbers-at-most-n-given-digit-set.js

---
 902-numbers-at-most-n-given-digit-set.js | 37 ++++++++++++++----------
 1 file changed, 21 insertions(+), 16 deletions(-)

diff --git a/902-numbers-at-most-n-given-digit-set.js b/902-numbers-at-most-n-given-digit-set.js
index 82d157dd..c45b9fef 100644
--- a/902-numbers-at-most-n-given-digit-set.js
+++ b/902-numbers-at-most-n-given-digit-set.js
@@ -1,21 +1,26 @@
 /**
- * @param {string[]} D
- * @param {number} N
+ * @param {string[]} digits
+ * @param {number} n
  * @return {number}
  */
-const atMostNGivenDigitSet = function (D, N) {
-  const NS = '' + N
-  const digit = NS.length,
-    dsize = D.length
-  let rtn = 0
-  for (let i = 1; i < digit; ++i) rtn += Math.pow(dsize, i)
-  for (let i = 0; i < digit; ++i) {
-    let hasSameNum = false
-    for (let d of D) {
-      if (d < NS[i]) rtn += Math.pow(dsize, digit - i - 1)
-      else if (d == NS[i]) hasSameNum = true
+const atMostNGivenDigitSet = function(digits, n) {
+  const str = '' + n, { pow } = Math
+  const len = str.length, dsize = digits.length
+  let res = 0
+  
+  for(let i = 1; i < len; i++) {
+    res += pow(dsize, i)
+  }
+  
+  for(let i = 0; i < len; i++) {
+    let sameNum = false
+    for(const d of digits) {
+      if(+d < +str[i]) {
+        res += pow(dsize, len - i - 1)
+      } else if(+d === +str[i]) sameNum = true
     }
-    if (!hasSameNum) return rtn
+    if(sameNum === false) return res
   }
-  return rtn + 1
-}
+  
+  return res + 1
+};

From 5d5349bb338f0f5e4874aa674b81b1832d13ed42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:02:19 +0800
Subject: [PATCH 2241/3374] Create
 1265-print-immutable-linked-list-in-reverse.js

---
 ...-print-immutable-linked-list-in-reverse.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 1265-print-immutable-linked-list-in-reverse.js

diff --git a/1265-print-immutable-linked-list-in-reverse.js b/1265-print-immutable-linked-list-in-reverse.js
new file mode 100644
index 00000000..66a405a0
--- /dev/null
+++ b/1265-print-immutable-linked-list-in-reverse.js
@@ -0,0 +1,31 @@
+/**
+ * // This is the ImmutableListNode's API interface.
+ * // You should not implement it, or speculate about its implementation.
+ * function ImmutableListNode() {
+ *    @ return {void}
+ *    this.printValue = function() { // print the value of this node.
+ *       ...
+ *    }; 
+ *
+ *    @return {ImmutableListNode}
+ *    this.getNext = function() { // return the next node.
+ *       ...
+ *    };
+ * };
+ */
+
+/**
+ * @param {ImmutableListNode} head
+ * @return {void}
+ */
+var printLinkedListInReverse = function(head) {
+  dfs(head)  
+  function dfs(node) {
+    if(node.getNext() == null) {
+      node.printValue()
+      return
+    }
+    dfs(node.getNext())
+    node.printValue()
+  }
+};

From 9c1ab07713942c5c111be77dfb93a043c822f5b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:06:29 +0800
Subject: [PATCH 2242/3374] Create
 2084-drop-type-1-orders-for-customers-with-type-0-orders.sql

---
 ...-drop-type-1-orders-for-customers-with-type-0-orders.sql | 6 ++++++
 1 file changed, 6 insertions(+)
 create mode 100644 2084-drop-type-1-orders-for-customers-with-type-0-orders.sql

diff --git a/2084-drop-type-1-orders-for-customers-with-type-0-orders.sql b/2084-drop-type-1-orders-for-customers-with-type-0-orders.sql
new file mode 100644
index 00000000..113dc39f
--- /dev/null
+++ b/2084-drop-type-1-orders-for-customers-with-type-0-orders.sql
@@ -0,0 +1,6 @@
+# Write your MySQL query statement below
+SELECT * FROM Orders
+WHERE (customer_id, order_type) 
+IN (SELECT customer_id, MIN(order_type) 
+    FROM Orders 
+    GROUP BY customer_id);

From d0f5dc58c91edd082e8c466ecd7a33ff06ed8e84 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:17:20 +0800
Subject: [PATCH 2243/3374] Create 1445-apples-oranges.sql

---
 1445-apples-oranges.sql | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 1445-apples-oranges.sql

diff --git a/1445-apples-oranges.sql b/1445-apples-oranges.sql
new file mode 100644
index 00000000..e921ad4e
--- /dev/null
+++ b/1445-apples-oranges.sql
@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+select sale_date, sum(case when fruit='apples' then sold_num else -sold_num end) as diff
+from sales
+group by sale_date;

From 14ca1aad306df02c79b9e5791b645381e8d64fb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:21:42 +0800
Subject: [PATCH 2244/3374] Create 1393-capital-gainloss.sql

---
 1393-capital-gainloss.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 1393-capital-gainloss.sql

diff --git a/1393-capital-gainloss.sql b/1393-capital-gainloss.sql
new file mode 100644
index 00000000..9f81342f
--- /dev/null
+++ b/1393-capital-gainloss.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT stock_name, SUM(
+    CASE
+        WHEN operation = 'Buy' THEN -price
+        ELSE price
+    END
+) AS capital_gain_loss
+FROM Stocks
+GROUP BY stock_name

From e8f53bafd3996bd720bff5b49db5d0371816475d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:37:17 +0800
Subject: [PATCH 2245/3374] Create 1874-minimize-product-sum-of-two-arrays.js

---
 1874-minimize-product-sum-of-two-arrays.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1874-minimize-product-sum-of-two-arrays.js

diff --git a/1874-minimize-product-sum-of-two-arrays.js b/1874-minimize-product-sum-of-two-arrays.js
new file mode 100644
index 00000000..556095cb
--- /dev/null
+++ b/1874-minimize-product-sum-of-two-arrays.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minProductSum = function(nums1, nums2) {
+  nums1.sort((a, b) => a - b) 
+  nums2.sort((a, b) => b - a)
+  
+  const n = nums1.length
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    res += nums1[i] * nums2[i]
+  }
+  
+  return res
+};

From 266aa5bdc728ad0f4b99bbdb7d0bcaa7e73f6257 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:43:23 +0800
Subject: [PATCH 2246/3374] Create
 2372-calculate-the-influence-of-each-salesperson.sql

---
 2372-calculate-the-influence-of-each-salesperson.sql | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 2372-calculate-the-influence-of-each-salesperson.sql

diff --git a/2372-calculate-the-influence-of-each-salesperson.sql b/2372-calculate-the-influence-of-each-salesperson.sql
new file mode 100644
index 00000000..5ff847f0
--- /dev/null
+++ b/2372-calculate-the-influence-of-each-salesperson.sql
@@ -0,0 +1,9 @@
+# Write your MySQL query statement below
+SELECT
+    sp.salesperson_id,
+    name,
+    SUM(IF(price IS NULL, 0, price)) AS total
+FROM Salesperson sp
+LEFT JOIN Customer c ON sp.salesperson_id = c.salesperson_id
+LEFT JOIN Sales s ON c.customer_id = s.customer_id
+GROUP BY sp.salesperson_id, name

From 7a1a18852af0ea95889900481b978cc83647ca58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:51:36 +0800
Subject: [PATCH 2247/3374] Create 1783-grand-slam-titles.sql

---
 1783-grand-slam-titles.sql | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 1783-grand-slam-titles.sql

diff --git a/1783-grand-slam-titles.sql b/1783-grand-slam-titles.sql
new file mode 100644
index 00000000..5107ee09
--- /dev/null
+++ b/1783-grand-slam-titles.sql
@@ -0,0 +1,8 @@
+# Write your MySQL query statement below
+SELECT player_id,player_name,
+SUM(player_id=Wimbledon)+SUM(player_id=Fr_open)+SUM(player_id=US_open)+SUM(player_id=Au_open)
+as grand_slams_count
+FROM Players
+JOIN Championships
+ON player_id=Wimbledon or player_id=Fr_open or player_id=US_open or player_id=Au_open
+GROUP BY player_id;

From c79250e9c673a921f6065c0cc0901d04efd5bf7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 22:57:24 +0800
Subject: [PATCH 2248/3374] Create 2298-tasks-count-in-the-weekend.sql

---
 2298-tasks-count-in-the-weekend.sql | 5 +++++
 1 file changed, 5 insertions(+)
 create mode 100644 2298-tasks-count-in-the-weekend.sql

diff --git a/2298-tasks-count-in-the-weekend.sql b/2298-tasks-count-in-the-weekend.sql
new file mode 100644
index 00000000..9ad50b93
--- /dev/null
+++ b/2298-tasks-count-in-the-weekend.sql
@@ -0,0 +1,5 @@
+# Write your MySQL query statement below
+# Write your MySQL query statement below
+SELECT SUM(WEEKDAY(submit_date)>=5) AS weekend_cnt,
+SUM(WEEKDAY(submit_date)<5) AS working_cnt
+FROM Tasks;

From 049503bb22bd1bb73a0811e8a11de1db169ea480 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Aug 2022 23:31:33 +0800
Subject: [PATCH 2249/3374] Create
 1828-queries-on-number-of-points-inside-a-circle.js

---
 ...ies-on-number-of-points-inside-a-circle.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1828-queries-on-number-of-points-inside-a-circle.js

diff --git a/1828-queries-on-number-of-points-inside-a-circle.js b/1828-queries-on-number-of-points-inside-a-circle.js
new file mode 100644
index 00000000..f4a8176d
--- /dev/null
+++ b/1828-queries-on-number-of-points-inside-a-circle.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} points
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var countPoints = function(points, queries) {
+   const res = []
+   
+   for(const [x, y, r] of queries) {
+     const square = r ** 2
+     const center = [x, y]
+     let cnt = 0
+     for(const d of points) {
+       if(disSquare(d, center) <= square) {
+         cnt++
+       }       
+     }
+     res.push(cnt)
+   }
+   
+   return res
+  
+  function disSquare(a, b) {
+    return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
+  }
+};

From 1818c57bffea10e4bdba358e4e195f95ba3201ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 14:58:06 +0800
Subject: [PATCH 2250/3374] Create
 2383-minimum-hours-of-training-to-win-a-competition.js

---
 ...-hours-of-training-to-win-a-competition.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2383-minimum-hours-of-training-to-win-a-competition.js

diff --git a/2383-minimum-hours-of-training-to-win-a-competition.js b/2383-minimum-hours-of-training-to-win-a-competition.js
new file mode 100644
index 00000000..120f96bd
--- /dev/null
+++ b/2383-minimum-hours-of-training-to-win-a-competition.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} initialEnergy
+ * @param {number} initialExperience
+ * @param {number[]} energy
+ * @param {number[]} experience
+ * @return {number}
+ */
+const minNumberOfHours = function(initialEnergy, initialExperience, energy, experience) {
+	let hours = 0
+
+	for(let i = 0; i < energy.length; i++) {
+		if (initialEnergy > energy[i]) {
+			initialEnergy -= energy[i]
+		} else {
+			hours += energy[i] - initialEnergy + 1
+			initialEnergy = 1
+		}
+
+		if (initialExperience <= experience[i]) {
+			hours += experience[i] - initialExperience + 1
+			initialExperience += experience[i] - initialExperience + 1
+		}
+
+		initialExperience += experience[i]
+	}
+	return hours
+};

From b986450f8aa373ce6ab5ab7056edcd32e68db04e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 14:58:31 +0800
Subject: [PATCH 2251/3374] Create 2384-largest-palindromic-number.js

---
 2384-largest-palindromic-number.js | 36 ++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2384-largest-palindromic-number.js

diff --git a/2384-largest-palindromic-number.js b/2384-largest-palindromic-number.js
new file mode 100644
index 00000000..fcf5da00
--- /dev/null
+++ b/2384-largest-palindromic-number.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} num
+ * @return {string}
+ */
+const largestPalindromic = function(num) {
+       let cnt = new Array(10).fill(0);
+        for (let i = 0; i < num.length; i++) {
+            let c = +num[i];
+            cnt[c]++;
+        }
+
+        let list = [];
+        for (let i = 9; i >= 0; i--) {
+            if (i == 0 && list.length == 0) {
+                break;
+            }
+            while (cnt[i] >= 2) {
+                list.push(i);
+                cnt[i] -= 2;
+            }
+        }
+        let sb = '';
+        for (let n of list) {
+            sb += n;
+        }
+        for (let i = 9; i >= 0; i--) {
+            if (cnt[i] > 0) {
+                sb += i;
+                break;
+            }
+        }
+        for (let i = list.length - 1; i >= 0; i--) {
+            sb += list[i];
+        }
+        return sb;
+};

From 759ead30a30061717b829930033bdc27c2b83d5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 14:58:52 +0800
Subject: [PATCH 2252/3374] Create
 2385-amount-of-time-for-binary-tree-to-be-infected.js

---
 ...-of-time-for-binary-tree-to-be-infected.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 2385-amount-of-time-for-binary-tree-to-be-infected.js

diff --git a/2385-amount-of-time-for-binary-tree-to-be-infected.js b/2385-amount-of-time-for-binary-tree-to-be-infected.js
new file mode 100644
index 00000000..0b8b48a1
--- /dev/null
+++ b/2385-amount-of-time-for-binary-tree-to-be-infected.js
@@ -0,0 +1,58 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} start
+ * @return {number}
+ */
+var amountOfTime = function(root, start) {
+  const graph = new Map()
+  dfs(root)
+  
+  // console.log(graph)
+  const visited = new Set([start])
+  let q = [start]
+  let res = 0
+  while(q.length) {
+    const tmp = []
+    const size = q.length
+    // console.log(q)
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const nxt of (graph.get(cur) || [])) {
+        if(visited.has(nxt)) continue
+        tmp.push(nxt)
+        visited.add(nxt)
+      }
+    }
+    
+    q = tmp
+    res++
+  }
+  
+  return res - 1
+  
+  function dfs(node) {
+    if(node == null) return
+    if(node.left) {
+      if(!graph.has(node.left.val)) graph.set(node.left.val, new Set())
+      if(!graph.has(node.val)) graph.set(node.val, new Set())
+      graph.get(node.val).add(node.left.val)
+      graph.get(node.left.val).add(node.val)
+      dfs(node.left)
+    }
+    if(node.right) {
+      if(!graph.has(node.right.val)) graph.set(node.right.val, new Set())
+      if(!graph.has(node.val)) graph.set(node.val, new Set())
+      graph.get(node.val).add(node.right.val)
+      graph.get(node.right.val).add(node.val)
+      dfs(node.right)
+    }
+  }
+};

From b729bfb31b2d8d22e5247e9a100c0b3d571a9348 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 14:59:15 +0800
Subject: [PATCH 2253/3374] Create 2386-find-the-k-sum-of-an-array.js

---
 2386-find-the-k-sum-of-an-array.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2386-find-the-k-sum-of-an-array.js

diff --git a/2386-find-the-k-sum-of-an-array.js b/2386-find-the-k-sum-of-an-array.js
new file mode 100644
index 00000000..5d7b62bd
--- /dev/null
+++ b/2386-find-the-k-sum-of-an-array.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var kSum = function(nums, k) {
+    let sum = 0, n = nums.length, pq = new MaxPriorityQueue({ compare: (x, y) => y[0] - x[0] });
+    for (let i = 0; i < n; i++) {
+        if (nums[i] < 0) {
+            nums[i] *= -1;
+        } else {
+            sum += nums[i];
+        }
+    }
+    if (k == 1) return sum;
+    nums.sort((x, y) => x - y);
+    pq.enqueue([sum - nums[0], 0]);
+    for (let i = 2; i < k; i++) {
+        let [x, idx] = pq.dequeue();
+        if (idx + 1 < n) {
+            pq.enqueue([x + nums[idx] - nums[idx + 1], idx + 1]);
+            pq.enqueue([x - nums[idx + 1], idx + 1]);
+        }
+    }
+    return pq.front()[0];
+};

From 0182f5b40ac9f96fe2eb1093ad2d8177239c54cf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 20:17:51 +0800
Subject: [PATCH 2254/3374] Update 31-next-permutation.js

---
 31-next-permutation.js | 43 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/31-next-permutation.js b/31-next-permutation.js
index baf10d95..17797b5a 100644
--- a/31-next-permutation.js
+++ b/31-next-permutation.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {void} Do not return anything, modify nums in-place instead.
+ */
+const nextPermutation = function(nums) {
+  const n = nums.length
+  let k
+  for(let i = n - 2; i >= 0; i--) {
+    if(nums[i] < nums[i + 1]) {
+      k = i
+      break
+    }
+  }
+  if(k == null) {
+    reverse(nums, 0, n - 1)
+  } else {
+    let end
+    for(let i = n - 1; i >= 0; i--) {
+      if(nums[i] > nums[k]) {
+        end = i
+        break
+      }
+    }
+    swap(nums, k, end)
+    reverse(nums, k + 1, n - 1)
+  }
+  
+  function reverse(arr, start, end) {
+    while(start < end) {
+      swap(arr, start, end)
+      start++
+      end--
+    }
+  }
+  
+  function swap(arr, i, j) {
+    ;[arr[i], arr[j]] = [arr[j], arr[i]];
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {void} Do not return anything, modify nums in-place instead.

From 5f1de8724769d79104767269a84a4fecedca13a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 21:43:27 +0800
Subject: [PATCH 2255/3374] Create
 1282-group-the-people-given-the-group-size-they-belong-to.js

---
 ...ple-given-the-group-size-they-belong-to.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 1282-group-the-people-given-the-group-size-they-belong-to.js

diff --git a/1282-group-the-people-given-the-group-size-they-belong-to.js b/1282-group-the-people-given-the-group-size-they-belong-to.js
new file mode 100644
index 00000000..0081f3fb
--- /dev/null
+++ b/1282-group-the-people-given-the-group-size-they-belong-to.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} groupSizes
+ * @return {number[][]}
+ */
+const groupThePeople = function(groupSizes) {
+  const hash = {}
+  const n = groupSizes.length
+  
+  for(let i = 0; i < n; i++) {
+    const size = groupSizes[i]
+    if(hash[size] == null) hash[size] = []
+    hash[size].push(i)
+  }
+  
+  const keys = Object.keys(hash)
+  // console.log(hash)
+  const res = []
+  for(let size of keys) {
+    size = +size
+    const arr = hash[size]
+    for(let i = 0; i < arr.length; i += size) {
+      res.push(arr.slice(i, i + size))
+    }
+  }
+  
+  return res
+};

From 76cd794d1cdc45d5990bf4329ef4f114e140d31d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Aug 2022 21:54:44 +0800
Subject: [PATCH 2256/3374] Create
 1315-sum-of-nodes-with-even-valued-grandparent.js

---
 ...m-of-nodes-with-even-valued-grandparent.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1315-sum-of-nodes-with-even-valued-grandparent.js

diff --git a/1315-sum-of-nodes-with-even-valued-grandparent.js b/1315-sum-of-nodes-with-even-valued-grandparent.js
new file mode 100644
index 00000000..6c7de73f
--- /dev/null
+++ b/1315-sum-of-nodes-with-even-valued-grandparent.js
@@ -0,0 +1,28 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const sumEvenGrandparent = function(root) {
+  let res = 0
+  dfs(root, null, null)
+  return res
+  
+  
+  function dfs(node, parent, gp) {
+    if(node == null) return
+    if(parent && gp && gp.val % 2 === 0) {
+      res += node.val
+    }
+    dfs(node.left, node, parent)
+    dfs(node.right, node, parent)
+  }
+  
+};

From 5b6b238e0086b4646eb2441eb637654f81350e2a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Aug 2022 12:11:50 +0800
Subject: [PATCH 2257/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index 9711d3d2..e43e7b06 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getPermutation = function(n, k) {
+  const factorial = Array(n + 1).fill(0)
+  factorial[0] = 1
+  for(let i = 1, pre = 1; i <= n; i++) {
+    factorial[i] = pre * i
+    pre = factorial[i]
+  }
+  const nums = Array.from({length: n}, (_, i) => i + 1)
+  
+  let res = ''
+  k--
+  for(let i = 1; i <= n; i++) {
+     const idx = ~~(k / factorial[n - i])
+     res += nums[idx]
+     nums.splice(idx, 1)
+     k -= idx * factorial[n - i]
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From 815f2444913f904088cedbb1939ced2e252f8b9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Aug 2022 15:59:31 +0800
Subject: [PATCH 2258/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index e43e7b06..f25ea1a4 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -1,3 +1,39 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getPermutation = function(n, k) {
+  const factorial = Array(n + 1).fill(0)
+  factorial[0] = 1
+  for(let i = 1; i <= n; i++) {
+    factorial[i] = factorial[i - 1] * i
+  }
+  let res = ''
+  const visited = Array(n + 1).fill(0)
+  dfs(0)
+  return res
+    
+  function dfs(idx) {
+    if(idx === n) return
+    
+    const cnt = factorial[n - idx - 1]
+    for(let i = 1; i <= n; i++) {
+      if(visited[i]) continue
+      if(cnt < k) {
+          k -= cnt
+          continue
+      }
+      res += i
+      visited[i] = 1
+      dfs(idx + 1)
+      return
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From 8302bdb110f95c782250a702326ee56f6a4a7e9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Aug 2022 20:22:45 +0800
Subject: [PATCH 2259/3374] Create
 2161-partition-array-according-to-given-pivot.js

---
 2161-partition-array-according-to-given-pivot.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2161-partition-array-according-to-given-pivot.js

diff --git a/2161-partition-array-according-to-given-pivot.js b/2161-partition-array-according-to-given-pivot.js
new file mode 100644
index 00000000..e3bf6995
--- /dev/null
+++ b/2161-partition-array-according-to-given-pivot.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} pivot
+ * @return {number[]}
+ */
+var pivotArray = function(nums, pivot) {
+   const less = [], greater = [], mid = []
+   for(const e of nums) {
+     if(e < pivot) less.push(e)
+     else if(e === pivot) mid.push(e)
+     else greater.push(e)
+   }
+  
+  return less.concat(mid, greater)
+};

From 44f7b17abb313f8f71e1cd355c8ff0adfa38a074 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Aug 2022 20:37:37 +0800
Subject: [PATCH 2260/3374] Create 1409-queries-on-a-permutation-with-key.js

---
 1409-queries-on-a-permutation-with-key.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 1409-queries-on-a-permutation-with-key.js

diff --git a/1409-queries-on-a-permutation-with-key.js b/1409-queries-on-a-permutation-with-key.js
new file mode 100644
index 00000000..c8edacfe
--- /dev/null
+++ b/1409-queries-on-a-permutation-with-key.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} queries
+ * @param {number} m
+ * @return {number[]}
+ */
+var processQueries = function(queries, m) {
+  const nums = Array.from({ length: m }, (_, i) => i + 1)
+  const res = []
+  for(const q of queries) {
+    const idx = nums.indexOf(q)
+    nums.splice(idx, 1)
+    nums.unshift(q)
+    res.push(idx)
+  }
+  return res
+};

From 7bd8125957f8fed85a0890a49830afeed60a7ddd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Aug 2022 22:22:15 +0800
Subject: [PATCH 2261/3374] Create
 1551-minimum-operations-to-make-array-equal.js

---
 ...-minimum-operations-to-make-array-equal.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1551-minimum-operations-to-make-array-equal.js

diff --git a/1551-minimum-operations-to-make-array-equal.js b/1551-minimum-operations-to-make-array-equal.js
new file mode 100644
index 00000000..d57d8369
--- /dev/null
+++ b/1551-minimum-operations-to-make-array-equal.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var minOperations = function(n) {
+  let l = 1, r = 2 * (n - 1) + 1
+  
+  // [1, 3]
+  // [1, 3, 5, 7]
+  
+  // [1]
+  // [1, 3, 5]
+  // [1, 3, 5, 7, 9]
+  const target = l + (r - l) / 2
+  let res = 0
+  const num = ~~((n + 1) / 2)
+  for(let i = 1; i <= num; i++) {
+    res += target - (2 * (i -1) + 1)
+  }
+  
+  return res
+};

From 6fd38791b39c7802389389193d53d307258b74a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Aug 2022 16:17:13 +0800
Subject: [PATCH 2262/3374] Create 2277-closest-node-to-path-in-tree.js

---
 2277-closest-node-to-path-in-tree.js | 48 ++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2277-closest-node-to-path-in-tree.js

diff --git a/2277-closest-node-to-path-in-tree.js b/2277-closest-node-to-path-in-tree.js
new file mode 100644
index 00000000..275e550d
--- /dev/null
+++ b/2277-closest-node-to-path-in-tree.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} query
+ * @return {number[]}
+ */
+const closestNode = function (n, edges, query) {
+  const graph = {}
+  for (const [a, b] of edges) {
+    if (graph[a] == null) graph[a] = []
+    if (graph[b] == null) graph[b] = []
+    graph[a].push(b)
+    graph[b].push(a)
+  }
+
+  const dis = Array.from({ length: n }, () => Array(n).fill(Infinity))
+  for (let i = 0; i < n; i++) {
+    let que = [i]
+    dis[i][i] = 0
+    while (que.length) {
+      const tmp = []
+      for (const q of que) {
+        for (const nxt of graph[q] || []) {
+          if (dis[i][nxt] === Infinity) {
+            dis[i][nxt] = dis[i][q] + 1
+            tmp.push(nxt)
+          }
+        }
+      }
+      que = tmp
+    }
+  }
+
+  const arr = []
+
+  for (const [a, b, q] of query) {
+    let tmp = Infinity, res = -1
+    for (let idx = 0; idx < n; idx++) {
+      const d= dis[idx][a] + dis[idx][b] + dis[idx][q]
+      if(d < tmp) {
+          tmp = d
+          res = idx
+      }
+    }
+    arr.push(res)
+  }
+  return arr
+}

From 3487c2f8478383ea20db3eb2bbb1436abb63189a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Aug 2022 12:39:35 +0800
Subject: [PATCH 2263/3374] Update
 2322-minimum-score-after-removals-on-a-tree.js

---
 ...-minimum-score-after-removals-on-a-tree.js | 81 +++++++++++++++++++
 1 file changed, 81 insertions(+)

diff --git a/2322-minimum-score-after-removals-on-a-tree.js b/2322-minimum-score-after-removals-on-a-tree.js
index def6f468..fe2fc586 100644
--- a/2322-minimum-score-after-removals-on-a-tree.js
+++ b/2322-minimum-score-after-removals-on-a-tree.js
@@ -1,3 +1,84 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const minimumScore = function (nums, edges) {
+  const n = nums.length, m = edges.length
+  const graph = {}
+  const children = {}
+  const xor = nums.slice(0)
+  const degree = Array(n).fill(0)
+
+  for(const [p, q] of edges) {
+    if(graph[p] == null) graph[p] = []
+    if(graph[q] == null) graph[q] = []
+    graph[p].push(q)
+    graph[q].push(p)
+    degree[p]++
+    degree[q]++
+  }
+
+  let val = 0
+  const seen = new Set()
+  const queue = []
+  for(let i = 0; i < n; i++) {
+    val ^= nums[i]
+    if(degree[i] === 1) {
+      queue.push(i)
+      seen.add(i)
+    }
+  }
+
+  while(queue.length) {
+    const cur = queue.shift()
+    for(const nxt of (graph[cur] || [])) {
+      if(!seen.has(nxt)) {
+        if(children[nxt] == null) children[nxt] = new Set()
+        children[nxt].add(cur)
+        for(const e of (children[cur] || [])) {
+          children[nxt].add(e)
+        }
+        xor[nxt] ^= xor[cur]
+      }
+      degree[nxt]--
+      if(degree[nxt] === 1) {
+        seen.add(nxt)
+        queue.push(nxt)
+      }
+    }
+  }
+
+  let res = Infinity
+
+  for(let i = 0; i < m - 1; i++) {
+    for(let j = i + 1; j < m; j++) {
+      let [a, b] = edges[i]
+      // Let a, c be the lower break points
+      if(children[a]?.has(b)) {
+        ;[a, b] = [b, a]
+      }
+      let [c, d] = edges[j]
+      if(children[c]?.has(d)) {
+        ;[c, d] = [d, c]
+      } 
+      let cur
+      if(children[a]?.has(c)) {
+        cur = [xor[c], xor[a] ^ xor[c], val ^ xor[a]] 
+      } else if(children[c]?.has(a)) {
+        cur = [xor[a], xor[c] ^ xor[a], val ^ xor[c]]
+      } else {
+        cur = [xor[a], xor[c], val ^ xor[a] ^ xor[c]]
+      }
+      res = Math.min(res, Math.max(...cur) - Math.min(...cur))
+    }
+  }
+
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[][]} edges

From 9a60e06f459607cbd1f432b51d8391ad4015dccb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Aug 2022 21:44:25 +0800
Subject: [PATCH 2264/3374] Create 1877-minimize-maximum-pair-sum-in-array.js

---
 1877-minimize-maximum-pair-sum-in-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1877-minimize-maximum-pair-sum-in-array.js

diff --git a/1877-minimize-maximum-pair-sum-in-array.js b/1877-minimize-maximum-pair-sum-in-array.js
new file mode 100644
index 00000000..1c27a9d4
--- /dev/null
+++ b/1877-minimize-maximum-pair-sum-in-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minPairSum = function(nums) {
+  nums.sort((a, b) => a - b)
+  let res = 0
+  for(let i = 0, limit = nums.length / 2; i < limit; i++) {
+    res = Math.max(res, nums[i] + nums[nums.length - 1 - i])
+  }
+  
+  return res
+};

From 5bf9a19b3e94c961391fae00922aa07f0c48ba3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Aug 2022 22:11:58 +0800
Subject: [PATCH 2265/3374] Create
 1305-all-elements-in-two-binary-search-trees.js

---
 ...all-elements-in-two-binary-search-trees.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 1305-all-elements-in-two-binary-search-trees.js

diff --git a/1305-all-elements-in-two-binary-search-trees.js b/1305-all-elements-in-two-binary-search-trees.js
new file mode 100644
index 00000000..df715040
--- /dev/null
+++ b/1305-all-elements-in-two-binary-search-trees.js
@@ -0,0 +1,60 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root1
+ * @param {TreeNode} root2
+ * @return {number[]}
+ */
+var getAllElements = function(root1, root2) {
+  const set1 = new Set(), set2 = new Set()
+  traverse(root1, set1)
+  traverse(root2, set2)
+  const res = []
+  const it1 = set1[Symbol.iterator]()
+  const it2 = set2[Symbol.iterator]()
+  let { value: value1, done: done1 } = it1.next()
+  let { value: value2, done: done2 } = it2.next()
+  while(done1 === false && done2 === false) {
+    if(value1 < value2) {
+      res.push(value1)
+      const obj = it1.next()
+      value1 = obj.value
+      done1 = obj.done
+    }else {
+      res.push(value2)
+      const obj = it2.next()
+      value2 = obj.value
+      done2 = obj.done
+    }
+  }
+  
+  while(done1 === false) {
+      res.push(value1)
+      const obj = it1.next()
+      value1 = obj.value
+      done1 = obj.done
+  }
+  
+  while(done2 === false) {
+      res.push(value2)
+      const obj = it2.next()
+      value2 = obj.value
+      done2 = obj.done
+  }
+  
+  return res
+  
+  
+  function traverse(node, set) {
+    if(node == null) return
+    traverse(node.left, set)
+    set.add(node.val)
+    traverse(node.right, set)
+  }
+};

From 8574aeef7a001a0010971394808604b617a22747 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Aug 2022 22:17:13 +0800
Subject: [PATCH 2266/3374] Update
 1305-all-elements-in-two-binary-search-trees.js

---
 1305-all-elements-in-two-binary-search-trees.js | 17 ++---------------
 1 file changed, 2 insertions(+), 15 deletions(-)

diff --git a/1305-all-elements-in-two-binary-search-trees.js b/1305-all-elements-in-two-binary-search-trees.js
index df715040..1c4d3929 100644
--- a/1305-all-elements-in-two-binary-search-trees.js
+++ b/1305-all-elements-in-two-binary-search-trees.js
@@ -20,8 +20,8 @@ var getAllElements = function(root1, root2) {
   const it2 = set2[Symbol.iterator]()
   let { value: value1, done: done1 } = it1.next()
   let { value: value2, done: done2 } = it2.next()
-  while(done1 === false && done2 === false) {
-    if(value1 < value2) {
+  while(done1 === false || done2 === false) {
+    if(done2 || value1 < value2) {
       res.push(value1)
       const obj = it1.next()
       value1 = obj.value
@@ -34,19 +34,6 @@ var getAllElements = function(root1, root2) {
     }
   }
   
-  while(done1 === false) {
-      res.push(value1)
-      const obj = it1.next()
-      value1 = obj.value
-      done1 = obj.done
-  }
-  
-  while(done2 === false) {
-      res.push(value2)
-      const obj = it2.next()
-      value2 = obj.value
-      done2 = obj.done
-  }
   
   return res
   

From 9ab9ab2242e779740656082e6d74473205536f32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Aug 2022 13:02:19 +0800
Subject: [PATCH 2267/3374] Create
 2313-minimum-flips-in-binary-tree-to-get-result.js

---
 ...imum-flips-in-binary-tree-to-get-result.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 2313-minimum-flips-in-binary-tree-to-get-result.js

diff --git a/2313-minimum-flips-in-binary-tree-to-get-result.js b/2313-minimum-flips-in-binary-tree-to-get-result.js
new file mode 100644
index 00000000..4354aee3
--- /dev/null
+++ b/2313-minimum-flips-in-binary-tree-to-get-result.js
@@ -0,0 +1,63 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {boolean} result
+ * @return {number}
+ */
+const minimumFlips = function (root, result) {
+  const [FALSE, TRUE, OR, AND, XOR, NOT] = [0, 1, 2, 3, 4, 5]
+  const costs = new Map()
+
+  const getMin = (node, target) => {
+    if (node.val === FALSE || node.val === TRUE)
+      return Math.abs(target - node.val)
+
+    const nodeCosts = costs.get(node) || [-1, -1]
+    if (nodeCosts[target] >= 0) return nodeCosts[target]
+
+    if (node.val === NOT) {
+      nodeCosts[target] = getMin(node.left || node.right, 1 - target)
+    } else if (node.val === OR) {
+      nodeCosts[target] =
+        target === FALSE
+          ? getMin(node.left, 0) + getMin(node.right, 0)
+          : Math.min(
+              getMin(node.left, 0) + getMin(node.right, 1),
+              getMin(node.left, 1) + getMin(node.right, 0),
+              getMin(node.left, 1) + getMin(node.right, 1)
+            )
+    } else if (node.val === AND) {
+      nodeCosts[target] =
+        target === TRUE
+          ? getMin(node.left, 1) + getMin(node.right, 1)
+          : Math.min(
+              getMin(node.left, 0) + getMin(node.right, 1),
+              getMin(node.left, 1) + getMin(node.right, 0),
+              getMin(node.left, 0) + getMin(node.right, 0)
+            )
+    } else {
+      nodeCosts[target] =
+        target === FALSE
+          ? Math.min(
+              getMin(node.left, 0) + getMin(node.right, 0),
+              getMin(node.left, 1) + getMin(node.right, 1)
+            )
+          : Math.min(
+              getMin(node.left, 0) + getMin(node.right, 1),
+              getMin(node.left, 1) + getMin(node.right, 0)
+            )
+    }
+
+    costs.set(node, nodeCosts)
+    return nodeCosts[target]
+  }
+
+  return getMin(root, result ? 1 : 0)
+}

From fd5d1d74fc200d570431335afcee22ab120ded25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 15:25:35 +0800
Subject: [PATCH 2268/3374] Create 2389-longest-subsequence-with-limited-sum.js

---
 2389-longest-subsequence-with-limited-sum.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2389-longest-subsequence-with-limited-sum.js

diff --git a/2389-longest-subsequence-with-limited-sum.js b/2389-longest-subsequence-with-limited-sum.js
new file mode 100644
index 00000000..def2fdd4
--- /dev/null
+++ b/2389-longest-subsequence-with-limited-sum.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+var answerQueries = function(nums, queries) {
+  const n = nums, m = queries.length
+  const arr = Array(n).fill(0)
+  nums.sort((a, b) => a - b)
+  
+  const res = []
+  for(const e of queries) {
+    let sum = 0, i = 0
+    while(sum <= e) {
+      sum += nums[i]
+      i++
+    }
+    res.push(i===0? 0 :i - 1)
+  }
+  
+  return res
+};

From f31510cb10cc31ffd2aed528ac554269b7008685 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 15:26:03 +0800
Subject: [PATCH 2269/3374] Create 2390-removing-stars-from-a-string.js

---
 2390-removing-stars-from-a-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2390-removing-stars-from-a-string.js

diff --git a/2390-removing-stars-from-a-string.js b/2390-removing-stars-from-a-string.js
new file mode 100644
index 00000000..f79f8abf
--- /dev/null
+++ b/2390-removing-stars-from-a-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var removeStars = function(s) {
+    const stk = []
+    for(const e of s) {
+      if(e !== '*') stk.push(e)
+      else {
+        stk.pop()
+      }
+    }
+    return stk.join('')
+};

From 3d25df36fc97f8ed47172b2d4f37f1bff92eba5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 15:26:30 +0800
Subject: [PATCH 2270/3374] Create
 2391-minimum-amount-of-time-to-collect-garbage.js

---
 ...nimum-amount-of-time-to-collect-garbage.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2391-minimum-amount-of-time-to-collect-garbage.js

diff --git a/2391-minimum-amount-of-time-to-collect-garbage.js b/2391-minimum-amount-of-time-to-collect-garbage.js
new file mode 100644
index 00000000..153f1846
--- /dev/null
+++ b/2391-minimum-amount-of-time-to-collect-garbage.js
@@ -0,0 +1,35 @@
+/**
+ * @param {string[]} garbage
+ * @param {number[]} travel
+ * @return {number}
+ */
+const garbageCollection = function(garbage, travel) {
+  let res1 = 0, res2 = 0, res3 = 0
+  const n = garbage.length
+  // P
+  res1 = helper('P')
+    res2 = helper('M')
+    res3 = helper('G')
+  return res1 + res2 + res3
+  
+  function helper(target) {
+      const arr = []
+      for(let i = 0; i < n; i++) {
+        const str = garbage[i]
+        for(const e of str) {
+          if(e === target) arr.push(e)
+        }
+        if(i + 1 < n) arr.push(travel[i])
+      }
+      const idx = arr.indexOf(target)
+      const lastIdx =arr.lastIndexOf(target)
+      let tmp = 0
+      // console.log(arr, idx, lastIdx)
+      for(let i = 0; i >= 0 && i<=lastIdx; i++) {
+        const e = arr[i]
+        if(e === target) tmp += 1
+        else tmp += e
+      }
+    return tmp
+  }
+};

From 473f1d0a18ef8d5665ad32f0e0f70b8e8c44d3c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 15:27:32 +0800
Subject: [PATCH 2271/3374] Create 2392-build-a-matrix-with-conditions.js

---
 2392-build-a-matrix-with-conditions.js | 72 ++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 2392-build-a-matrix-with-conditions.js

diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
new file mode 100644
index 00000000..8245627d
--- /dev/null
+++ b/2392-build-a-matrix-with-conditions.js
@@ -0,0 +1,72 @@
+/**
+ * @param {number} k
+ * @param {number[][]} rowConditions
+ * @param {number[][]} colConditions
+ * @return {number[][]}
+ */
+const initializeGraph = (n) => {
+  let g = []
+  for (let i = 0; i < n; i++) {
+    g.push([])
+  }
+  return g
+}
+const packDGInDegree = (g, edges, indegree) => {
+  for (const [u, v] of edges) {
+    g[u].unshift(v)
+    indegree[v]++
+  }
+}
+const initialize2DArray = (n, m) => {
+  let d = []
+  for (let i = 0; i < n; i++) {
+    let t = Array(m).fill(0)
+    d.push(t)
+  }
+  return d
+}
+
+const buildMatrix = (k, rowConditions, colConditions) => {
+  let gr = make(k, rowConditions),
+    gc = make(k, colConditions),
+    d = initialize2DArray(k, 2),
+    res = initialize2DArray(k, k)
+  if (gr.length == 0 || gc.length == 0) return []
+  for (let i = 0; i < k; i++) {
+    d[gr[i] - 1][0] = i
+    d[gc[i] - 1][1] = i
+  }
+  for (let i = 0; i < k; i++) {
+    let [x, y] = d[i]
+    res[x][y] = i + 1
+  }
+  return res
+}
+
+const make = (n, edges) => {
+  let g = initializeGraph(n + 1),
+    deg = Array(n + 1).fill(0)
+  packDGInDegree(g, edges, deg)
+  return topologicalSort_start_1(g, deg)
+}
+
+const topologicalSort_start_1 = (g, indegree) => {
+  let res = [],
+    q = [],
+    n = g.length - 1
+  for (let i = 1; i <= n; i++) {
+    if (indegree[i] == 0) q.push(i)
+  }
+  while (q.length) {
+    let cur = q.shift()
+    res.push(cur)
+    for (const child of g[cur]) {
+      indegree[child]--
+      if (indegree[child] == 0) q.push(child)
+    }
+  }
+  for (let i = 1; i <= n; i++) {
+    if (indegree[i] > 0) return []
+  }
+  return res
+}

From 095007b2730fe458edce2c621bc02a4ad2caa6e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 16:39:43 +0800
Subject: [PATCH 2272/3374] Update 2392-build-a-matrix-with-conditions.js

---
 2392-build-a-matrix-with-conditions.js | 56 ++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
index 8245627d..1379236c 100644
--- a/2392-build-a-matrix-with-conditions.js
+++ b/2392-build-a-matrix-with-conditions.js
@@ -1,3 +1,59 @@
+/**
+ * @param {number} k
+ * @param {number[][]} rowConditions
+ * @param {number[][]} colConditions
+ * @return {number[][]}
+ */
+var buildMatrix = function(k, rowConditions, colConditions) {
+        const res = Array.from({ length: k }, () => Array(k).fill(0));
+        
+        const row = khansAlgo(rowConditions, k);
+        if(row.length!=k) return [];
+        
+        const col = khansAlgo(colConditions, k);
+        if(col.length!=k) return [];
+        
+        const idx = Array(k+1).fill(0);
+        for(let j=0;j<col.length;j++){
+            idx[col[j]] = j;
+        }
+        for(let i=0;i<k;i++){
+            res[i][idx[row[i]]] = row[i];
+        }
+        return res; 
+  
+  function  khansAlgo(r,  k){
+    const cnt = Array(k + 1).fill(0)
+    const adj = Array.from({ length: k + 1}, () => Array())
+
+        for(let x of r){
+            cnt[x[1]]++;
+            adj[x[0]].push(x[1]);
+        }
+        const row = [];
+        const q = [];
+        for(let i=1;i<=k;i++){
+            if(cnt[i]==0){
+                q.push(i);
+            }
+        }
+        while(q.length){
+            let t = q.pop();
+        
+            row.push(t);
+            for(let x of (adj[t] || [])) {
+                cnt[x]--;
+                if(cnt[x]==0){
+                    q.push(x);
+                }
+            }
+        }
+        return row;
+    }
+};
+
+// another
+
 /**
  * @param {number} k
  * @param {number[][]} rowConditions

From 6e6292d49bea701a96a5e4a3119810489f71af71 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 19:36:25 +0800
Subject: [PATCH 2273/3374] Update 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
index e402f90d..8b5ff85e 100644
--- a/1723-find-minimum-time-to-finish-all-jobs.js
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -1,3 +1,37 @@
+/**
+ * @param {number[]} jobs
+ * @param {number} k
+ * @return {number}
+ */
+const minimumTimeRequired = function(jobs, k) {
+  const workers = Array(k).fill(0)
+  let res = Infinity
+  const n = jobs.length
+
+  dfs(0)
+  
+  return res
+
+  function dfs(idx) {
+    if(idx === n) {
+      res = Math.min(res, Math.max(...workers))
+      return
+    }
+    const visited = new Set()
+    const e = jobs[idx]
+    for(let i = 0; i < k; i++) {
+      if(visited.has(workers[i])) continue
+      if(workers[i] + e >= res) continue
+      visited.add(workers[i])
+      workers[i] += e
+      dfs(idx + 1)
+      workers[i] -= e
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number[]} jobs
  * @param {number} k

From 2e89930652016b7faa9e9131eef4928a6235c171 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Aug 2022 21:55:46 +0800
Subject: [PATCH 2274/3374] Update 2392-build-a-matrix-with-conditions.js

---
 2392-build-a-matrix-with-conditions.js | 90 +++++++++++++-------------
 1 file changed, 46 insertions(+), 44 deletions(-)

diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
index 1379236c..e1f8141e 100644
--- a/2392-build-a-matrix-with-conditions.js
+++ b/2392-build-a-matrix-with-conditions.js
@@ -4,53 +4,55 @@
  * @param {number[][]} colConditions
  * @return {number[][]}
  */
-var buildMatrix = function(k, rowConditions, colConditions) {
-        const res = Array.from({ length: k }, () => Array(k).fill(0));
-        
-        const row = khansAlgo(rowConditions, k);
-        if(row.length!=k) return [];
-        
-        const col = khansAlgo(colConditions, k);
-        if(col.length!=k) return [];
-        
-        const idx = Array(k+1).fill(0);
-        for(let j=0;j<col.length;j++){
-            idx[col[j]] = j;
-        }
-        for(let i=0;i<k;i++){
-            res[i][idx[row[i]]] = row[i];
-        }
-        return res; 
-  
-  function  khansAlgo(r,  k){
-    const cnt = Array(k + 1).fill(0)
-    const adj = Array.from({ length: k + 1}, () => Array())
+var buildMatrix = function (k, rowConditions, colConditions) {
+  const res = Array.from({ length: k }, () => Array(k).fill(0))
 
-        for(let x of r){
-            cnt[x[1]]++;
-            adj[x[0]].push(x[1]);
-        }
-        const row = [];
-        const q = [];
-        for(let i=1;i<=k;i++){
-            if(cnt[i]==0){
-                q.push(i);
-            }
-        }
-        while(q.length){
-            let t = q.pop();
-        
-            row.push(t);
-            for(let x of (adj[t] || [])) {
-                cnt[x]--;
-                if(cnt[x]==0){
-                    q.push(x);
-                }
-            }
+  const row = khansAlgo(rowConditions, k)
+  if (row.length != k) return []
+
+  const col = khansAlgo(colConditions, k)
+  if (col.length != k) return []
+
+  // console.log(row, col)
+  const idx = Array(k + 1).fill(0)
+  for (let j = 0; j < col.length; j++) {
+    idx[col[j]] = j
+  }
+  for (let i = 0; i < k; i++) {
+    res[i][idx[row[i]]] = row[i]
+  }
+  return res
+
+  function khansAlgo(r, k) {
+    const indegree = Array(k + 1).fill(0)
+    const adj = Array.from({ length: k + 1 }, () => Array())
+
+    for (let x of r) {
+      indegree[x[1]]++
+      adj[x[0]].push(x[1])
+    }
+    const row = []
+    const q = []
+    for (let i = 1; i <= k; i++) {
+      if (indegree[i] == 0) {
+        q.push(i)
+      }
+    }
+    while (q.length) {
+      let t = q.pop()
+
+      row.push(t)
+      for (let x of adj[t] || []) {
+        indegree[x]--
+        if (indegree[x] == 0) {
+          q.push(x)
         }
-        return row;
+      }
     }
-};
+    return row
+  }
+}
+
 
 // another
 

From b1884a8989af43a909d501f86614d67e81ad6ae4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Aug 2022 18:21:38 +0800
Subject: [PATCH 2275/3374] Create 2305-fair-distribution-of-cookies.js

---
 2305-fair-distribution-of-cookies.js | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2305-fair-distribution-of-cookies.js

diff --git a/2305-fair-distribution-of-cookies.js b/2305-fair-distribution-of-cookies.js
new file mode 100644
index 00000000..8f7f8936
--- /dev/null
+++ b/2305-fair-distribution-of-cookies.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} cookies
+ * @param {number} k
+ * @return {number}
+ */
+const distributeCookies = function(cookies, k) {
+  const n = cookies.length
+  let res = Infinity
+  const arr = Array(n).fill(0)
+
+  bt(0)
+  return res
+  
+  function bt(idx) {
+    if(idx === n) {
+      res = Math.min(res, Math.max(...arr))
+      return
+    }
+    const cur = cookies[idx]
+    // const visited = new Set()
+    for(let i = 0; i < k; i++) {
+      const e = arr[i]
+      // if(visited.has(i)) continue
+      if(cur + e >= res) continue
+      
+      arr[i] += cur
+      bt(idx + 1)
+      arr[i] -= cur
+      if(arr[i] === 0) break
+    }
+  }
+};

From 6013cbb61d27d742dc508fee9ecce5645e6dfb99 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Aug 2022 18:23:36 +0800
Subject: [PATCH 2276/3374] Update 2305-fair-distribution-of-cookies.js

---
 2305-fair-distribution-of-cookies.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/2305-fair-distribution-of-cookies.js b/2305-fair-distribution-of-cookies.js
index 8f7f8936..38eae083 100644
--- a/2305-fair-distribution-of-cookies.js
+++ b/2305-fair-distribution-of-cookies.js
@@ -17,12 +17,12 @@ const distributeCookies = function(cookies, k) {
       return
     }
     const cur = cookies[idx]
-    // const visited = new Set()
+    const visited = new Set()
     for(let i = 0; i < k; i++) {
       const e = arr[i]
-      // if(visited.has(i)) continue
+      if(visited.has(arr[i])) continue
       if(cur + e >= res) continue
-      
+      visited.add(arr[i])
       arr[i] += cur
       bt(idx + 1)
       arr[i] -= cur

From f49b6434f8bde51d6d02e3401c0856e4dc641559 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Aug 2022 18:25:32 +0800
Subject: [PATCH 2277/3374] Update 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
index 8b5ff85e..40f5824e 100644
--- a/1723-find-minimum-time-to-finish-all-jobs.js
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -26,6 +26,7 @@ const minimumTimeRequired = function(jobs, k) {
       workers[i] += e
       dfs(idx + 1)
       workers[i] -= e
+      if(workers[i] === 0) break
     }
   }
 };

From 4f2102e858a28f8229f9591f8c96eaf7da6c97ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Aug 2022 21:20:48 +0800
Subject: [PATCH 2278/3374] Create 2317-maximum-xor-after-operations.js

---
 2317-maximum-xor-after-operations.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 2317-maximum-xor-after-operations.js

diff --git a/2317-maximum-xor-after-operations.js b/2317-maximum-xor-after-operations.js
new file mode 100644
index 00000000..44a60632
--- /dev/null
+++ b/2317-maximum-xor-after-operations.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumXOR = function(nums) {
+  let res = 0
+  for(const e of nums)  res |= e
+  
+  return res
+};

From d0b28c20211bafc7c547fe6e812edde8fab5128c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Aug 2022 21:33:42 +0800
Subject: [PATCH 2279/3374] Create
 1557-minimum-number-of-vertices-to-reach-all-nodes.js

---
 ...um-number-of-vertices-to-reach-all-nodes.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1557-minimum-number-of-vertices-to-reach-all-nodes.js

diff --git a/1557-minimum-number-of-vertices-to-reach-all-nodes.js b/1557-minimum-number-of-vertices-to-reach-all-nodes.js
new file mode 100644
index 00000000..89430b28
--- /dev/null
+++ b/1557-minimum-number-of-vertices-to-reach-all-nodes.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var findSmallestSetOfVertices = function(n, edges) {
+  const indegree = Array(n).fill(0)
+  for(const [from, to] of edges) {
+    indegree[to]++
+  }
+  let res = []
+  for(let i = 0; i <n; i++) {
+    const e = indegree[i]
+    if(e === 0) res.push(i)
+  }
+  
+  return res
+};

From 0228d63e6ff5278968849bb4a84d9977e8932a34 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Aug 2022 17:00:57 +0800
Subject: [PATCH 2280/3374] Update 329-longest-increasing-path-in-a-matrix.js

---
 329-longest-increasing-path-in-a-matrix.js | 38 ++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/329-longest-increasing-path-in-a-matrix.js b/329-longest-increasing-path-in-a-matrix.js
index c71b8477..6cce9611 100644
--- a/329-longest-increasing-path-in-a-matrix.js
+++ b/329-longest-increasing-path-in-a-matrix.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[][]} matrix
+ * @return {number}
+ */
+const longestIncreasingPath = function(matrix) {
+  const m = matrix.length, n = matrix[0].length
+  let res = 1
+
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  const memo = Array.from({ length: m }, () => Array(n).fill(0))
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      const len = dfs(i, j)
+      res = Math.max(res, len)
+    }
+  }
+  
+  return res
+  
+  function dfs(i, j) {
+    const v = matrix[i][j]
+    if(memo[i][j] !== 0) return memo[i][j]
+    let len = 1
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      if(nx >= 0 && nx < m && ny >= 0 && ny < n && matrix[nx][ny] > v) {
+         const tmp = 1 + dfs(nx, ny)
+         len = Math.max(len, tmp)
+      }
+    }
+      
+    memo[i][j] = len
+    return len
+  }
+};
+
+// another
+
 /**
  * @param {number[][]} matrix
  * @return {number}

From 929978ce83340391a546f402d89068a68541e0d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Aug 2022 21:09:03 +0800
Subject: [PATCH 2281/3374] Create 1829-maximum-xor-for-each-query.js

---
 1829-maximum-xor-for-each-query.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1829-maximum-xor-for-each-query.js

diff --git a/1829-maximum-xor-for-each-query.js b/1829-maximum-xor-for-each-query.js
new file mode 100644
index 00000000..18bb6c49
--- /dev/null
+++ b/1829-maximum-xor-for-each-query.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @param {number} maximumBit
+ * @return {number[]}
+ */
+const getMaximumXor = function(nums, maximumBit) {
+  const n = nums.length
+  let xor = nums.reduce((ac, e) => ac ^ e, 0)
+  let limit = 2 ** maximumBit - 1
+  const res = []
+  for(let i = n - 1; i >= 0; i--) {
+    const tmp = limit ^ xor
+    res.push(tmp)
+    xor ^= nums[i]
+  }
+  
+  return res
+};

From 729aa713eaf8b3a5665915e371c0cfe59b1abd8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Aug 2022 21:19:01 +0800
Subject: [PATCH 2282/3374] Create 2221-find-triangular-sum-of-an-array.js

---
 2221-find-triangular-sum-of-an-array.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2221-find-triangular-sum-of-an-array.js

diff --git a/2221-find-triangular-sum-of-an-array.js b/2221-find-triangular-sum-of-an-array.js
new file mode 100644
index 00000000..561102a5
--- /dev/null
+++ b/2221-find-triangular-sum-of-an-array.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const triangularSum = function(nums) {
+  while(nums.length > 1) {
+    const arr = []
+    for(let i = 0, n = nums.length; i < n - 1; i++) {
+      arr.push((nums[i] + nums[i + 1]) % 10)
+    }
+    nums = arr
+  }
+  return nums[0]
+};

From f51019b65210e2f376851dab5c09450f81ca79a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 Aug 2022 21:50:40 +0800
Subject: [PATCH 2283/3374] Create
 1261-find-elements-in-a-contaminated-binary-tree.js

---
 ...-elements-in-a-contaminated-binary-tree.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 1261-find-elements-in-a-contaminated-binary-tree.js

diff --git a/1261-find-elements-in-a-contaminated-binary-tree.js b/1261-find-elements-in-a-contaminated-binary-tree.js
new file mode 100644
index 00000000..a6b4d4ad
--- /dev/null
+++ b/1261-find-elements-in-a-contaminated-binary-tree.js
@@ -0,0 +1,49 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+const FindElements = function(root) {
+  this.root = root
+  this.set = new Set()
+  if(root) this.set.add(0)
+  
+  dfs(root, 0, this.set)
+
+  // console.log(this.set)
+  function dfs(node, cur, set) {
+    if(node == null) return
+    
+    if(node.left) {
+      const child = cur * 2 + 1
+      set.add(child)
+      dfs(node.left, child, set)
+    }
+    if(node.right) {      
+      const child = cur * 2 + 2
+      set.add(child)
+      dfs(node.right, child, set)
+    }
+  }
+};
+
+/** 
+ * @param {number} target
+ * @return {boolean}
+ */
+FindElements.prototype.find = function(target) {
+    return this.set.has(target)
+};
+
+
+/** 
+ * Your FindElements object will be instantiated and called as such:
+ * var obj = new FindElements(root)
+ * var param_1 = obj.find(target)
+ */

From c2b5e4a367f24f29b718f35cb3179279590626f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Aug 2022 21:09:58 +0800
Subject: [PATCH 2284/3374] Update 2328-number-of-increasing-paths-in-a-grid.js

---
 2328-number-of-increasing-paths-in-a-grid.js | 35 ++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2328-number-of-increasing-paths-in-a-grid.js b/2328-number-of-increasing-paths-in-a-grid.js
index 54212bc0..e6b76dd6 100644
--- a/2328-number-of-increasing-paths-in-a-grid.js
+++ b/2328-number-of-increasing-paths-in-a-grid.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const countPaths = function (grid) {
+  const mod = 1e9 + 7
+  const m = grid.length, n = grid[0].length
+  let res = 0
+  const dirs = [[1,0], [-1,0], [0, 1], [0, -1]]
+  const memo = Array.from({ length: m }, () => Array(n).fill(0))
+  for(let i = 0; i <m ; i++) {
+    for(let j = 0; j < n; j++) {
+      res = (res + dfs(i, j)) % mod
+    }
+  } 
+  return res
+  
+  function dfs(i, j) {
+    let res = 1
+    if(memo[i][j] !== 0) return memo[i][j]
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      if(nx >= 0 && nx < m && ny >= 0 && ny < n && grid[nx][ny] > grid[i][j]) {
+        res = (res + dfs(nx, ny)) % mod
+      }
+    }
+    
+    memo[i][j] = res
+    
+    return res
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From bbc37b184d691cfcd2fe39649edbb132c78c5d96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Sep 2022 11:31:55 +0800
Subject: [PATCH 2285/3374] Update 232-implement-queue-using-stacks.js

---
 232-implement-queue-using-stacks.js | 30 ++++++++++++++---------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/232-implement-queue-using-stacks.js b/232-implement-queue-using-stacks.js
index cd50590d..5477a853 100644
--- a/232-implement-queue-using-stacks.js
+++ b/232-implement-queue-using-stacks.js
@@ -1,46 +1,46 @@
-/**
- * Initialize your data structure here.
- */
-const MyQueue = function() {
-    this.queue = []
+
+var MyQueue = function() {
+  this.input = []
+  this.output = []
 };
 
-/**
- * Push element x to the back of queue. 
+/** 
  * @param {number} x
  * @return {void}
  */
 MyQueue.prototype.push = function(x) {
-    this.queue.push(x)
+  this.input.push(x)
 };
 
 /**
- * Removes the element from in front of queue and returns that element.
  * @return {number}
  */
 MyQueue.prototype.pop = function() {
-    return this.queue.shift()
+  if(this.output.length === 0) {
+      while(this.input.length) {
+          this.output.push(this.input.pop())
+      }
+  }
+  return this.output.pop()
 };
 
 /**
- * Get the front element.
  * @return {number}
  */
 MyQueue.prototype.peek = function() {
-    return this.queue[0]
+  return this.output[this.output.length - 1] || this.input[0]
 };
 
 /**
- * Returns whether the queue is empty.
  * @return {boolean}
  */
 MyQueue.prototype.empty = function() {
-    return this.queue.length === 0
+  return this.input.length === 0 && this.output.length === 0
 };
 
 /** 
  * Your MyQueue object will be instantiated and called as such:
- * var obj = Object.create(MyQueue).createNew()
+ * var obj = new MyQueue()
  * obj.push(x)
  * var param_2 = obj.pop()
  * var param_3 = obj.peek()

From 346632cec07dfb2235d65b8d918574255d477215 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Sep 2022 15:52:01 +0800
Subject: [PATCH 2286/3374] Update 351-android-unlock-patterns.js

---
 351-android-unlock-patterns.js | 40 ++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/351-android-unlock-patterns.js b/351-android-unlock-patterns.js
index 749c4cf6..e8fc35eb 100644
--- a/351-android-unlock-patterns.js
+++ b/351-android-unlock-patterns.js
@@ -38,3 +38,43 @@ function DFS(vis, skip, cur, remain) {
   vis[cur] = false
   return rst
 }
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const numberOfPatterns = function (m, n) {
+  const skip = Array.from({ length: 10 }, () => Array(10).fill(0))
+  let res = 0
+  skip[1][3] = skip[3][1] = 2
+  skip[1][7] = skip[7][1] = 4
+  skip[9][7] = skip[7][9] = 8
+  skip[9][3] = skip[3][9] = 6
+  skip[1][9] = skip[9][1] = skip[2][8] = skip[8][2] = skip[3][7] = skip[7][3] = skip[4][6] = skip[6][4] = 5
+  const visited = new Set()
+  for(let i = m ;i <= n; i++) {
+    res += dfs(1, i - 1) * 4 // 1, 3, 7, 9
+    res += dfs(2, i - 1) * 4 // 2, 4, 6, 8
+    res += dfs(5, i - 1) // 5
+  }
+
+  return res
+
+  function dfs(cur, remain) {
+    if(remain === 0) return 1
+    let res = 0
+    visited.add(cur)
+    for(let i = 1; i <= 9; i++) {
+      if(!visited.has(i) && (skip[cur][i] === 0 || visited.has(skip[cur][i]))) {
+        res += dfs(i, remain - 1)
+      }
+    }
+    visited.delete(cur)
+
+    return res
+  }
+}
+

From 907481d8349ebee222a01d39be3b44d4753cb431 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Sep 2022 19:34:58 +0800
Subject: [PATCH 2287/3374] Create 861-score-after-flipping-matrix.js

---
 861-score-after-flipping-matrix.js | 46 ++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 861-score-after-flipping-matrix.js

diff --git a/861-score-after-flipping-matrix.js b/861-score-after-flipping-matrix.js
new file mode 100644
index 00000000..ef82cbfa
--- /dev/null
+++ b/861-score-after-flipping-matrix.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const matrixScore = function(grid) {
+  const m = grid.length, n = grid[0].length
+  for(let i = 0; i < m; i++) {
+    if(grid[i][0] === 0) flipRow(i)
+  }
+  
+  for(let i = 0; i < n; i++) {
+    if(cntCol(i, 0) > cntCol(i, 1)) flipCol(i)
+  }
+  
+  let res = 0
+  // console.log(grid)
+  for(const row of grid) {
+    res += parseInt(row.join(''), 2)
+  }
+  
+  return res
+  
+  
+  function flipRow(idx) {
+    for(let i = 0; i < n; i++) {
+      if(grid[idx][i] === 0) grid[idx][i] = 1
+      else grid[idx][i] = 0
+    }
+  }
+  
+  function cntCol(idx, target) {
+    let res = 0
+    for(let i = 0; i < m; i++) {
+      if(grid[i][idx] === target) res++
+    }
+    // console.log(res)
+    return res
+  }
+  
+  function flipCol(idx) {
+    for(let i = 0; i < m; i++) {
+      if(grid[i][idx] === 0) grid[i][idx] = 1
+      else grid[i][idx] = 0
+    }
+  }
+};

From 5e2f01145b33e4b9fce18b46704b8e3ab913237f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Sep 2022 22:40:32 +0800
Subject: [PATCH 2288/3374] Update 861-score-after-flipping-matrix.js

---
 861-score-after-flipping-matrix.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/861-score-after-flipping-matrix.js b/861-score-after-flipping-matrix.js
index ef82cbfa..4c57cb6c 100644
--- a/861-score-after-flipping-matrix.js
+++ b/861-score-after-flipping-matrix.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const matrixScore = function(grid) {
+  const m = grid.length, n = grid[0].length
+  let res = 0
+  res += m * (1 << (n - 1))
+  for(let j = 1; j < n; j++) {
+    let same = 0
+    for(let i = 0; i < m; i++) {
+      if(grid[i][0] === grid[i][j]) same++
+    }
+    res += Math.max(same, m - same) * (1 << (n - 1 - j))
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 834c26ed10a4448b9f1631310891cd975281e5fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Sep 2022 13:24:39 +0800
Subject: [PATCH 2289/3374] Update 942-di-string-match.js

---
 942-di-string-match.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/942-di-string-match.js b/942-di-string-match.js
index e8530c2f..8e35e923 100644
--- a/942-di-string-match.js
+++ b/942-di-string-match.js
@@ -19,3 +19,20 @@ const diStringMatch = function(S) {
   res.push(arr.pop())
   return res
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number[]}
+ */
+const diStringMatch = function(s) {
+  const n = s.length
+  let l = 0, r = n
+  const res = []
+  for(let i = 0; i < n; i++) {
+    res.push(s[i] === 'I' ? l++ : r--)
+  }
+  res.push(r)
+  return res
+};

From 673b725917c5c56017a0500d6696c45880c47987 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Sep 2022 13:34:32 +0800
Subject: [PATCH 2290/3374] Update 942-di-string-match.js

---
 942-di-string-match.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/942-di-string-match.js b/942-di-string-match.js
index 8e35e923..7fee2f08 100644
--- a/942-di-string-match.js
+++ b/942-di-string-match.js
@@ -22,6 +22,18 @@ const diStringMatch = function(S) {
 
 // another
 
+/*
+
+it is greedy and one pass !!
+so every time when we meet an I, we need to keep in mind that we may meet another I later,
+so the safest way is use the smallest number available. same idea when we meet D, 
+so in order to keep us safe, we always take largest one available, until we traverse the whole string.
+And since the available numbers are sorted(from 0 to S.length()), 
+so we can set two pointers one starts from the head(smallest number), 
+another from the ends(largest number), then we begin to fill the res array.
+
+*/
+
 /**
  * @param {string} s
  * @return {number[]}

From 707e4a9c81fb065f5e2b9a089ba9b15b2e88876f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 17:33:42 +0800
Subject: [PATCH 2291/3374] Create 2399-check-distances-between-same-letters.js

---
 2399-check-distances-between-same-letters.js | 21 ++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2399-check-distances-between-same-letters.js

diff --git a/2399-check-distances-between-same-letters.js b/2399-check-distances-between-same-letters.js
new file mode 100644
index 00000000..5c877a9b
--- /dev/null
+++ b/2399-check-distances-between-same-letters.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @param {number[]} distance
+ * @return {boolean}
+ */
+var checkDistances = function(s, distance) {
+  const hash = {}
+  const a = 'a'.charCodeAt(0)
+  const n = s.length
+  for(let i = 0; i < n; i++) {
+    if(hash[s[i]] == null) hash[s[i]] = []
+    hash[s[i]].push(i)
+  }
+  const keys = Object.keys(hash)
+  for(let i = 0; i < keys.length; i++) {
+    const k = keys[i]
+    const idx = k.charCodeAt(0) - a
+    if(hash[k][1] - hash[k][0] !== distance[idx] + 1) return false
+  }
+  return true
+};

From 7529ce62926ee0ba63c7766cfac7686c68834622 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 17:36:59 +0800
Subject: [PATCH 2292/3374] Create
 2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js

---
 ...-reach-a-position-after-exactly-k-steps.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js

diff --git a/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js b/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js
new file mode 100644
index 00000000..2a7481e2
--- /dev/null
+++ b/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number} startPos
+ * @param {number} endPos
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfWays = function(startPos, endPos, k) {
+  const ll = BigInt, mod = ll(1e9 + 7), N = 1005;
+
+  let fact, ifact, inv;
+  const comb_init = () => {
+      fact = Array(N).fill(0);
+      ifact = Array(N).fill(0);
+      inv = Array(N).fill(0);
+      fact[0] = ifact[0] = inv[1] = 1n;
+      for (let i = 2; i < N; i++) inv[i] = (mod - mod / ll(i)) * inv[mod % ll(i)] % mod;
+      for (let i = 1; i < N; i++) {
+          fact[i] = fact[i - 1] * ll(i) % mod;
+          ifact[i] = ifact[i - 1] * inv[i] % mod;
+      }
+  };
+
+  const comb = (n, k) => {
+      if (n < k || k < 0) return 0;
+      return fact[n] * ifact[k] % mod * ifact[n - k] % mod;
+  };
+
+  comb_init();
+  let res = 0n;
+  for (let i = 0; i <= k; i++) {
+      let moveRight = i, moveLeft = k - i;
+      if (startPos + moveRight - moveLeft == endPos) res += comb(k, i);
+  }
+  return res;
+  
+};

From 60a48708e2baf8427fecdfe197959fe2a2c01d29 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 17:38:23 +0800
Subject: [PATCH 2293/3374] Create 2401-longest-nice-subarray.js

---
 2401-longest-nice-subarray.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2401-longest-nice-subarray.js

diff --git a/2401-longest-nice-subarray.js b/2401-longest-nice-subarray.js
new file mode 100644
index 00000000..0af71e12
--- /dev/null
+++ b/2401-longest-nice-subarray.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestNiceSubarray = function(nums) {
+    let max = 1;
+    let stack = [];
+    for(let i =0;i<nums.length;i++){
+        if(nums[i]&nums[i+1]) continue;
+        stack.push(nums[i])
+        for(let j =i+1;j<nums.length;j++){
+            let state = true;
+            for(el of stack){
+                if(el&nums[j]){
+                    state=false;
+                    break;
+                }
+            }
+            if(state) {
+                stack.push(nums[j]);
+                max = Math.max(max,stack.length);
+            }
+            else{
+                stack = []
+                break;
+            }
+        }
+    }
+    return max;
+};

From 7e0ca727d7805ff036c2dc587affc78a20252351 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 17:48:23 +0800
Subject: [PATCH 2294/3374] Create 2402-meeting-rooms-iii.js

---
 2402-meeting-rooms-iii.js | 40 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2402-meeting-rooms-iii.js

diff --git a/2402-meeting-rooms-iii.js b/2402-meeting-rooms-iii.js
new file mode 100644
index 00000000..aa3ab2fc
--- /dev/null
+++ b/2402-meeting-rooms-iii.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} n
+ * @param {number[][]} meetings
+ * @return {number}
+ */
+var mostBooked = function(n, meetings) {
+    const count = new Array(n).fill(0);
+    const freeTime = new Array(n).fill(0);
+    meetings.sort((a, b) => a[0] - b[0]);
+    for(let i = 0 ; i < meetings.length ; i++){
+        let minRoom = -1;
+        let minTime = Number.MAX_SAFE_INTEGER;
+        for(let j = 0 ; j < n ; j++){
+            if(freeTime[j] <= meetings[i][0]){
+                count[j]++;
+                freeTime[j] = meetings[i][1];
+                minRoom = -1;
+                break;
+            }
+            if(freeTime[j] < minTime){
+                minTime = freeTime[j];
+                minRoom = j;
+            }
+        }
+        if(minRoom !== -1){
+            count[minRoom]++;
+            freeTime[minRoom] += meetings[i][1] - meetings[i][0]; 
+        }
+    }
+    
+    let ans = 0;
+    let maxCount = count[0];
+    for(let i = 1 ; i < n ; i++){
+        if(count[i] > maxCount){ 
+            ans = i;
+            maxCount = count[i];
+        }
+    }
+    return ans;  
+};

From 921d2d5e583bfcd59e29b8698a5888e5018430fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 20:43:11 +0800
Subject: [PATCH 2295/3374] Update 484-find-permutation.js

---
 484-find-permutation.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/484-find-permutation.js b/484-find-permutation.js
index 024f433f..5ed6cda9 100644
--- a/484-find-permutation.js
+++ b/484-find-permutation.js
@@ -1,3 +1,25 @@
+/**
+ * @param {string} s
+ * @return {number[]}
+ */
+const findPermutation = function(s) {
+    const n = s.length
+    const res = Array(n + 1)
+    res[n]  = n + 1
+    for (let i = 0, len = n; i < len;) {
+        let j = i;
+        while (j < len && s.charAt(j) === 'D') {
+            j++;
+        }
+        for (let k = j - i; k >= 0; k--, j--) {
+            res[i++] = j + 1;
+        }
+    }
+    return res;
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number[]}

From e21aad22d73a06609bc3f71da782e494090b691d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Sep 2022 21:00:10 +0800
Subject: [PATCH 2296/3374] Update 484-find-permutation.js

---
 484-find-permutation.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/484-find-permutation.js b/484-find-permutation.js
index 5ed6cda9..18d3d441 100644
--- a/484-find-permutation.js
+++ b/484-find-permutation.js
@@ -18,6 +18,31 @@ const findPermutation = function(s) {
     return res;
 };
 
+// another
+
+/**
+ * @param {string} s
+ * @return {number[]}
+ */
+const findPermutation = function(s) {
+  const n = s.length
+  const res = Array(n)
+  res[n] = n + 1
+  for(let i = 0; i < n;) {
+    let j = i
+    while(j < n && s[j] === 'D') j++
+    // console.log(j)
+    for(let k = j - i + 1; k > 0; k--) {
+      res[i] = j + 1
+      i++
+      j--
+    }
+  }
+
+  return res
+};
+
+
 // another
 
 /**

From a2d165155860cbee701cc9bee3916a2dfd03755b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Sep 2022 21:50:15 +0800
Subject: [PATCH 2297/3374] Update 903-valid-permutations-for-di-sequence.js

---
 903-valid-permutations-for-di-sequence.js | 41 +++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/903-valid-permutations-for-di-sequence.js b/903-valid-permutations-for-di-sequence.js
index 8e5aaa60..13844712 100644
--- a/903-valid-permutations-for-di-sequence.js
+++ b/903-valid-permutations-for-di-sequence.js
@@ -1,3 +1,44 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numPermsDISequence = function(s) {
+  const mod = 1e9 + 7
+  const n = s.length
+  const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0))
+  s = '#' + s
+  dp[0][0] = 1
+  for(let i = 1; i <= n; i++) {
+    const ch = s[i]
+    for(let j = 0; j <= i; j++) {
+      if(ch === 'I') {
+        for(let k = 0; k < j; k++) {
+          dp[i][j] += dp[i - 1][k]
+          dp[i][j] %= mod
+        }
+      } else {
+        for(let k = j; k < i; k++) {
+          dp[i][j] += dp[i - 1][k]
+          dp[i][j] %= mod
+        }
+      }
+    }
+  }
+  
+  
+  let res = 0
+  
+  for(let i = 0; i <= n; i++) {
+    res = (res + dp[n][i]) % mod
+  }
+  
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 5119e34a00a5d562ba867985857b5cba03fa9e31 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Sep 2022 20:07:53 +0800
Subject: [PATCH 2298/3374] Update 239-sliding-window-maximum.js

---
 239-sliding-window-maximum.js | 32 +++++++++++++++-----------------
 1 file changed, 15 insertions(+), 17 deletions(-)

diff --git a/239-sliding-window-maximum.js b/239-sliding-window-maximum.js
index e34610a7..7f765ee7 100644
--- a/239-sliding-window-maximum.js
+++ b/239-sliding-window-maximum.js
@@ -4,24 +4,22 @@
  * @return {number[]}
  */
 const maxSlidingWindow = function(nums, k) {
-  let n = nums.length
-  if (n === 0) {
-    return nums
-  }
-  let result = []
-
-  let dq = []
-  for (let i = 0; i < n; i++) {
-    if (dq.length && dq[0] < i - k + 1) {
-      dq.shift()
+  const n = nums.length
+  const stk = []
+  const res = []
+  
+  for(let i = 0; i < n; i++) {
+    while(stk.length && stk[0] < i - k + 1) {
+      stk.shift()
     }
-    while (dq.length && nums[i] >= nums[dq[dq.length - 1]]) {
-      dq.pop()
+    while(stk.length && nums[stk[stk.length - 1]] <= nums[i]) {
+      stk.pop()
     }
-    dq.push(i)
-    if (i - k + 1 >= 0) {
-      result[i - k + 1] = nums[dq[0]]
+    stk.push(i)
+    if(i >= k - 1) {
+      res.push(nums[stk[0]])
     }
   }
-  return result
-}
+  
+  return res
+};

From cb5b1dbdd07f483b96446be6e0cd2ee6861fd0aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Sep 2022 20:09:45 +0800
Subject: [PATCH 2299/3374] Update 239-sliding-window-maximum.js

---
 239-sliding-window-maximum.js | 67 +++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/239-sliding-window-maximum.js b/239-sliding-window-maximum.js
index 7f765ee7..3fdf50a4 100644
--- a/239-sliding-window-maximum.js
+++ b/239-sliding-window-maximum.js
@@ -23,3 +23,70 @@ const maxSlidingWindow = function(nums, k) {
   
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+var maxSlidingWindow = function (nums, k) {
+  if (k === 0) return []
+  const deque = new Deque()
+  for (let i = 0; i < k - 1; i++) {
+    while (!deque.isEmpty() && deque.last().val <= nums[i]) deque.pop()
+    deque.enqueue({ val: nums[i], idx: i })
+  }
+  const result = []
+  for (let i = k - 1; i < nums.length; i++) {
+    if (!deque.isEmpty() && deque.first().idx <= i - k) deque.dequeue()
+    while (!deque.isEmpty() && deque.last().val <= nums[i]) deque.pop()
+    deque.enqueue({ val: nums[i], idx: i })
+    result.push(deque.first().val)
+  }
+  return result
+}
+
+class Deque {
+  constructor() {
+    this.head = new Node()
+    this.tail = this.head
+  }
+
+  isEmpty() {
+    return this.head.next === null
+  }
+
+  first() {
+    return this.head.next.value
+  }
+
+  last() {
+    return this.tail.value
+  }
+
+  dequeue() {
+    this.head = this.head.next
+    this.head.prev = null
+  }
+
+  enqueue(value) {
+    this.tail.next = new Node(value)
+    this.tail.next.prev = this.tail
+    this.tail = this.tail.next
+  }
+
+  pop() {
+    this.tail = this.tail.prev
+    this.tail.next = null
+  }
+}
+
+class Node {
+  constructor(value) {
+    this.value = value
+    this.next = null
+    this.prev = null
+  }
+}

From 9827f0394ddbeec07e31d723b45c3692ee069693 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Sep 2022 19:40:46 +0800
Subject: [PATCH 2300/3374] Update 1425-constrained-subsequence-sum.js

---
 1425-constrained-subsequence-sum.js | 77 +++++++++++++++++++++++++++++
 1 file changed, 77 insertions(+)

diff --git a/1425-constrained-subsequence-sum.js b/1425-constrained-subsequence-sum.js
index 1fb3cb59..aad59bcf 100644
--- a/1425-constrained-subsequence-sum.js
+++ b/1425-constrained-subsequence-sum.js
@@ -20,3 +20,80 @@ const constrainedSubsetSum = function(nums, k) {
     }
     return max;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const constrainedSubsetSum = function (nums, k) {
+  const dll = new DLL()
+  dll.push([0, nums[0]])
+  let max = nums[0]
+  for (let i = 1; i < nums.length; i++) {
+    // console.log(dll, dll.peek())
+    let [index, lastKsum] = dll.peek().val
+
+    if (index == i - k) {
+      dll.shift()
+    }
+    const sum = Math.max(lastKsum, 0) + nums[i]
+    max = Math.max(max, sum)
+    while (!dll.isEmpty() && dll.peekLast().val[1] < sum) {
+      dll.pop()
+    }
+    dll.push([i, sum])
+  }
+  return max
+}
+
+class Node {
+  constructor(val) {
+    this.val = val
+    this.prev = null
+    this.next = null
+  }
+}
+class DLL {
+  constructor() {
+    this.head = new Node()
+    this.tail = null
+  }
+  peek() {
+    return this.head.next
+  }
+  peekLast() {
+    return this.tail
+  }
+  isEmpty() {
+    return this.head.next == null
+  }
+  shift() {
+    const h = this.head.next
+    if (h) {
+      this.head.next = h.next
+      if (h.next) {
+        h.next.prev = this.head
+      } else {
+        this.tail = null
+      }
+    }
+  }
+  pop() {
+    if (this.tail == null) return
+    const newTail = this.tail.prev
+    if (newTail) {
+      newTail.next = null
+      this.tail.prev = null
+      this.tail = newTail
+    }
+  }
+  push(val) {
+    const node = new Node(val)
+    node.prev = this.tail ?? this.head
+    node.prev.next = node
+    this.tail = node
+  }
+}

From dccdcd5d63ce947bfd412cfdb5412cb7fd4dd925 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Sep 2022 21:45:49 +0800
Subject: [PATCH 2301/3374] Update 1425-constrained-subsequence-sum.js

---
 1425-constrained-subsequence-sum.js | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/1425-constrained-subsequence-sum.js b/1425-constrained-subsequence-sum.js
index aad59bcf..81ac967e 100644
--- a/1425-constrained-subsequence-sum.js
+++ b/1425-constrained-subsequence-sum.js
@@ -33,13 +33,10 @@ const constrainedSubsetSum = function (nums, k) {
   dll.push([0, nums[0]])
   let max = nums[0]
   for (let i = 1; i < nums.length; i++) {
-    // console.log(dll, dll.peek())
-    let [index, lastKsum] = dll.peek().val
-
-    if (index == i - k) {
+    if (!dll.isEmpty() && i - dll.peek().val[0] > k) {
       dll.shift()
     }
-    const sum = Math.max(lastKsum, 0) + nums[i]
+    const sum = Math.max(dll.peek().val[1], 0) + nums[i]
     max = Math.max(max, sum)
     while (!dll.isEmpty() && dll.peekLast().val[1] < sum) {
       dll.pop()
@@ -60,6 +57,7 @@ class DLL {
   constructor() {
     this.head = new Node()
     this.tail = null
+    this.size = 0
   }
   peek() {
     return this.head.next
@@ -79,6 +77,7 @@ class DLL {
       } else {
         this.tail = null
       }
+      this.size--
     }
   }
   pop() {
@@ -88,12 +87,15 @@ class DLL {
       newTail.next = null
       this.tail.prev = null
       this.tail = newTail
+      this.size--
     }
+
   }
   push(val) {
     const node = new Node(val)
     node.prev = this.tail ?? this.head
     node.prev.next = node
     this.tail = node
+    this.size++
   }
 }

From db31e083629c986d86923e899cda604a613bdf67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Sep 2022 10:41:26 +0800
Subject: [PATCH 2302/3374] Update
 1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js

---
 ...solute-diff-less-than-or-equal-to-limit.js | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)

diff --git a/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js b/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js
index 74c87355..ffc4ed5c 100644
--- a/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js
+++ b/1438-longest-continuous-subarray-with-absolute-diff-less-than-or-equal-to-limit.js
@@ -23,3 +23,78 @@ const longestSubarray = function(nums, limit) {
     }
     return j - i; 
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const longestSubarray = function (nums, limit) {
+  const maxDq = new Deque(), minDq = new Deque(), n = nums.length
+  let l = 0, r = 0
+  let res = 0
+  for(r = 0; r < n; r++) {
+    const cur = nums[r]
+    while(!maxDq.isEmpty() && maxDq.last() < cur) {
+      maxDq.pop()
+    }
+    maxDq.enqueue(cur)
+    while(!minDq.isEmpty() && minDq.last() > cur) {
+      minDq.pop()
+    }
+    minDq.enqueue(cur)
+
+    while(maxDq.first() - minDq.first() > limit) {
+      if(nums[l] === maxDq.first()) maxDq.dequeue()
+      if(nums[l] === minDq.first()) minDq.dequeue()
+      l++
+    }
+    res = Math.max(res, r - l + 1)
+  }
+  return res
+}
+
+class Deque {
+  constructor() {
+    this.head = new Node()
+    this.tail = this.head
+  }
+
+  isEmpty() {
+    return this.head.next === null
+  }
+
+  first() {
+    return this.head.next.value
+  }
+
+  last() {
+    return this.tail.value
+  }
+
+  dequeue() {
+    this.head = this.head.next
+    this.head.prev = null
+  }
+
+  enqueue(value) {
+    this.tail.next = new Node(value)
+    this.tail.next.prev = this.tail
+    this.tail = this.tail.next
+  }
+
+  pop() {
+    this.tail = this.tail.prev
+    this.tail.next = null
+  }
+}
+
+class Node {
+  constructor(value) {
+    this.value = value
+    this.next = null
+    this.prev = null
+  }
+}

From 44aaf6a65155c7eea07108d2951638b6e44acbce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Sep 2022 21:22:46 +0800
Subject: [PATCH 2303/3374] Create 1338-reduce-array-size-to-the-half.js

---
 1338-reduce-array-size-to-the-half.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1338-reduce-array-size-to-the-half.js

diff --git a/1338-reduce-array-size-to-the-half.js b/1338-reduce-array-size-to-the-half.js
new file mode 100644
index 00000000..a9b504af
--- /dev/null
+++ b/1338-reduce-array-size-to-the-half.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var minSetSize = function(arr) {
+   const hash = {}
+   for(const e of arr) {
+     if(hash[e] == null)  hash[e] = 0
+     hash[e]++
+   }
+   const n = arr.length
+   const entries = Object.entries(hash)
+   entries.sort((a, b) => b[1] - a[1])
+  let res= 0
+  let cnt = 0
+  for(const [k, v] of entries) {
+    cnt += v
+    res++
+    if(cnt >= n / 2) break
+  }
+  
+  return res
+};

From 71be2d935fe800d34fbf0ecc304e7d7302813482 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Sep 2022 20:13:40 +0800
Subject: [PATCH 2304/3374] Create 1562-find-latest-group-of-size-m.js

---
 1562-find-latest-group-of-size-m.js | 80 +++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 1562-find-latest-group-of-size-m.js

diff --git a/1562-find-latest-group-of-size-m.js b/1562-find-latest-group-of-size-m.js
new file mode 100644
index 00000000..ca889669
--- /dev/null
+++ b/1562-find-latest-group-of-size-m.js
@@ -0,0 +1,80 @@
+/**
+ * @param {number[]} arr
+ * @param {number} m
+ * @return {number}
+ */
+const findLatestStep = function(arr, m) {
+    const uF = new UnionFind(arr);
+    const mRecords = new Set(); // This contains parents whose rank is m 
+    const visited = new Set();
+    let res = -1;
+
+    for (let i = 0; i < arr.length; i++) {
+        let val = arr[i];
+        visited.add(val);
+        
+        if (visited.has(val - 1)) {
+            let parent1 = uF.find(val);
+            let parent2 = uF.find(val - 1);
+			    // Since merging, the rank for val - 1 & val has changed,
+          // they are no longer m. Hence removed them from set.
+            mRecords.delete(parent1);  
+            mRecords.delete(parent2);
+            uF.union(val, val - 1);
+        }
+        
+        if (visited.has(val + 1)) {
+            let parent1 = uF.find(val);
+            let parent2 = uF.find(val + 1);
+            mRecords.delete(parent1);
+            mRecords.delete(parent2);
+            uF.union(val, val + 1);
+        }
+        
+        let parent = uF.find(val);
+        if (uF.ranks.get(parent) === m) mRecords.add(parent);
+        if (mRecords.size > 0) res = i + 1;  
+    }
+    
+    return res;  
+};
+
+class UnionFind {
+    constructor(arr) {
+        [this.parents, this.ranks] = this.initialise(arr);
+    }
+    
+    initialise(arr) {
+        const parents = new Map();
+        const ranks = new Map();
+        arr.forEach(val => {
+            parents.set(val, val);
+            ranks.set(val, 1);
+        })
+        
+        return [parents, ranks];
+    }
+    
+    find(val) {
+        if (this.parents.get(val) === val) return val;
+        this.parents.set(val, this.find(this.parents.get(val)));
+        return this.parents.get(val);
+    }
+    
+    union(m, n) {
+        const rootM = this.find(m);
+        const rootN = this.find(n);
+        
+        if (rootM === rootN) return;
+        if (rootM > rootN) {
+            this.updateParent(rootN, rootM);
+        } else {
+            this.updateParent(rootM, rootN);
+        }
+    }
+    
+    updateParent(child, parent) {
+        this.ranks.set(parent, this.ranks.get(parent) + this.ranks.get(child));
+        this.parents.set(child, parent);
+    }
+}

From 7fb32164ffc4d124e9196faa194b737e02c5f01a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Sep 2022 16:29:39 +0800
Subject: [PATCH 2305/3374] Create 2404-most-frequent-even-element.js

---
 2404-most-frequent-even-element.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2404-most-frequent-even-element.js

diff --git a/2404-most-frequent-even-element.js b/2404-most-frequent-even-element.js
new file mode 100644
index 00000000..608206cd
--- /dev/null
+++ b/2404-most-frequent-even-element.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var mostFrequentEven = function(nums) {
+  const hash = {}
+  for(const e of nums) {
+    if(e % 2 === 0) {
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+    }
+  }
+  const entries = Object.entries(hash)
+  if(entries.length === 0) return -1
+  entries.sort((a, b) => b[1] - a[1])
+  const v = entries[0][1]
+  const keys = Object.keys(hash).map(e => +e).sort((a, b) => a - b)
+// console.log(hash)
+  for(const k of keys) {
+    if(hash[k] === v) return k
+  }
+  
+  return -1
+};

From a9f28a4a040ebf293bb1b27e023dcf12613118b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Sep 2022 16:30:06 +0800
Subject: [PATCH 2306/3374] Create 2405-optimal-partition-of-string.js

---
 2405-optimal-partition-of-string.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2405-optimal-partition-of-string.js

diff --git a/2405-optimal-partition-of-string.js b/2405-optimal-partition-of-string.js
new file mode 100644
index 00000000..0faa98e7
--- /dev/null
+++ b/2405-optimal-partition-of-string.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var partitionString = function(s) {
+  let res = 0, n = s.length
+  let i = 0, j = 0, num = 0
+  const set = new Set()
+  for(let i = 0; i < n; i++) {
+    const ch = s[i]
+    if(set.has(ch)) {
+      res++
+      num = 1
+      set.clear()
+    } else {
+
+    }
+    set.add(ch)
+  }
+  
+  return res + 1
+};

From 099445768133c24b4190f34836a03eb1fd5c9e1a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Sep 2022 16:31:43 +0800
Subject: [PATCH 2307/3374] Create
 2406.divide-intervals-into-minimum-number-of-groups.js

---
 ...intervals-into-minimum-number-of-groups.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2406.divide-intervals-into-minimum-number-of-groups.js

diff --git a/2406.divide-intervals-into-minimum-number-of-groups.js b/2406.divide-intervals-into-minimum-number-of-groups.js
new file mode 100644
index 00000000..e55dd03d
--- /dev/null
+++ b/2406.divide-intervals-into-minimum-number-of-groups.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+var minGroups = function(intervals) {
+    const hash = {}
+  for(let [s, e] of intervals) {
+    e = e + 1
+    hash[s] = (hash[s] || 0) + 1
+    hash[e] = (hash[e] || 0) - 1
+  }
+  let res = 0, cur = 0
+  const keys = Object.keys(hash).map(e => +e)
+  keys.sort((a, b) => a - b)
+  for(const k of keys) {
+    cur += hash[k]
+    res = Math.max(res, cur)
+  }
+  return res
+};

From 9eea8a21a79f914e61f1d44eb663ada8bacb7936 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Sep 2022 16:34:09 +0800
Subject: [PATCH 2308/3374] Create 2407.longest-increasing-subsequence-ii.js

---
 2407.longest-increasing-subsequence-ii.js | 70 +++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 2407.longest-increasing-subsequence-ii.js

diff --git a/2407.longest-increasing-subsequence-ii.js b/2407.longest-increasing-subsequence-ii.js
new file mode 100644
index 00000000..f84fe50b
--- /dev/null
+++ b/2407.longest-increasing-subsequence-ii.js
@@ -0,0 +1,70 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const lengthOfLIS = (nums, k) => {
+  const a = nums
+    let max = Math.max(...a), st = new SegmentTreeRMQ(max + 3), res = 0;
+    for (const x of a) {
+        let l = Math.max(x-k, 0), r = x;
+        let min = st.minx(l, r), maxL = min == Number.MAX_SAFE_INTEGER ? 0 : -min;
+        maxL++;
+        res = Math.max(res, maxL);
+        st.update(x, -maxL);
+    }
+    return res;
+};
+///////////////////////////////////////////// Template ///////////////////////////////////////////////////////////
+// using array format
+function SegmentTreeRMQ(n) {
+    let h = Math.ceil(Math.log2(n)), len = 2 * 2 ** h, a = Array(len).fill(Number.MAX_SAFE_INTEGER);
+    h = 2 ** h;
+    return { update, minx, indexOf, tree }
+    function update(pos, v) {
+        a[h + pos] = v;
+        for (let i = parent(h + pos); i >= 1; i = parent(i)) propagate(i);
+    }
+    function propagate(i) {
+        a[i] = Math.min(a[left(i)], a[right(i)]);
+    }
+    function minx(l, r) {
+        let min = Number.MAX_SAFE_INTEGER;
+        if (l >= r) return min;
+        l += h;
+        r += h;
+        for (; l < r; l = parent(l), r = parent(r)) {
+            if (l & 1) min = Math.min(min, a[l++]);
+            if (r & 1) min = Math.min(min, a[--r]);
+        }
+        return min;
+    }
+    function indexOf(l, v) {
+        if (l >= h) return -1;
+        let cur = h + l;
+        while (1) {
+            if (a[cur] <= v) {
+                if (cur >= h) return cur - h;
+                cur = left(cur);
+            } else {
+                cur++;
+                if ((cur & cur - 1) == 0) return -1;
+                if (cur % 2 == 0) cur = parent(cur);
+            }
+        }
+    }
+    function parent(i) {
+        return i >> 1;
+    }
+    function left(i) {
+        return 2 * i;
+    }
+    function right(i) {
+        return 2 * i + 1;
+    }
+    function tree() {
+        return a;
+    }
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+

From d0b1f9dbc5af7cf13bf799c82c713fb033763872 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Sep 2022 16:56:05 +0800
Subject: [PATCH 2309/3374] Create
 2398-maximum-number-of-robots-within-budget.js

---
 ...-maximum-number-of-robots-within-budget.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2398-maximum-number-of-robots-within-budget.js

diff --git a/2398-maximum-number-of-robots-within-budget.js b/2398-maximum-number-of-robots-within-budget.js
new file mode 100644
index 00000000..da24351b
--- /dev/null
+++ b/2398-maximum-number-of-robots-within-budget.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} chargeTimes
+ * @param {number[]} runningCosts
+ * @param {number} budget
+ * @return {number}
+ */
+var maximumRobots = function(chargeTimes, runningCosts, budget) {
+  let times = chargeTimes
+  let costs = runningCosts
+  let sum = 0;
+  let i = 0, n = times.length;
+  const d = [];
+  for (let j = 0; j < n; ++j) {
+      sum += costs[j];
+      while (d.length && times[d[d.length - 1]] <= times[j]) d.pop();
+      d.push(j);
+      if (times[d[0]] + (j - i + 1) * sum > budget) {
+          if (d[0] == i) d.shift();
+          sum -= costs[i++];
+      }
+  }
+  return n - i; 
+};
+

From 299963e6dfa102a101c0350ec1d5529384276304 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Sep 2022 17:29:57 +0800
Subject: [PATCH 2310/3374] Update
 2398-maximum-number-of-robots-within-budget.js

---
 ...-maximum-number-of-robots-within-budget.js | 32 ++++++++++---------
 1 file changed, 17 insertions(+), 15 deletions(-)

diff --git a/2398-maximum-number-of-robots-within-budget.js b/2398-maximum-number-of-robots-within-budget.js
index da24351b..9e33245e 100644
--- a/2398-maximum-number-of-robots-within-budget.js
+++ b/2398-maximum-number-of-robots-within-budget.js
@@ -4,21 +4,23 @@
  * @param {number} budget
  * @return {number}
  */
-var maximumRobots = function(chargeTimes, runningCosts, budget) {
-  let times = chargeTimes
-  let costs = runningCosts
-  let sum = 0;
-  let i = 0, n = times.length;
-  const d = [];
-  for (let j = 0; j < n; ++j) {
-      sum += costs[j];
-      while (d.length && times[d[d.length - 1]] <= times[j]) d.pop();
-      d.push(j);
-      if (times[d[0]] + (j - i + 1) * sum > budget) {
-          if (d[0] == i) d.shift();
-          sum -= costs[i++];
-      }
+const maximumRobots = function(chargeTimes, runningCosts, budget) {
+  const times = chargeTimes, costs = runningCosts
+  let sum = 0, res = 0, j = 0
+  const q = [], n = times.length
+  for(let i = 0; i < n; i++) {
+    sum += costs[i]
+    while(q.length && times[q[q.length - 1]] <= times[i]) q.pop()
+    q.push(i)
+    
+    if(q.length && times[q[0]] + (i - j + 1) * sum > budget) {
+      if(q[0] === j) q.shift()
+      sum -= costs[j]
+      j++
+    }
+    res = Math.max(res, i - j + 1)
   }
-  return n - i; 
+  
+  return res
 };
 

From 17d4382dee6cc51ad9521d15a9569c493076cbe4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Sep 2022 21:14:16 +0800
Subject: [PATCH 2311/3374] Create 1104.path-in-zigzag-labelled-binary-tree.js

---
 1104.path-in-zigzag-labelled-binary-tree.js | 37 +++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1104.path-in-zigzag-labelled-binary-tree.js

diff --git a/1104.path-in-zigzag-labelled-binary-tree.js b/1104.path-in-zigzag-labelled-binary-tree.js
new file mode 100644
index 00000000..0b1c7c41
--- /dev/null
+++ b/1104.path-in-zigzag-labelled-binary-tree.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number} label
+ * @return {number[]}
+ */
+const pathInZigZagTree = function(label) {
+  const res = [], { log2, floor, ceil } = Math
+  
+  res.push(label)
+  
+  // check last row
+  const lev = ceil(log2(label + 1))
+  const reverse = lev % 2 === 0 ? true : false
+  // console.log(reverse, lev)
+  if(reverse) {
+    const idx = 2 ** lev - 1 - label
+    label = 2 ** (lev - 1) + idx
+  }
+  // console.log(label)
+  
+  while(label > 1) {
+    const level = floor(log2(label))
+    const parent = floor(label / 2)
+    const parentLevelNum = 2 ** (level - 1)
+    const parentReverse = level % 2 === 0 ? true : false
+    const parentStart = 2 ** (level - 1)
+    const parentEnd = 2 ** level - 1
+    // console.log(parentStart, parentEnd, parent)
+    const idx = parent - parentStart
+    res.push(parentReverse ? parentEnd - idx : parentStart + idx)
+    
+    label = parent
+  }
+  
+
+  res.reverse()
+  return res
+};

From d1eaffa781b26dca9ca90e9bd837a6e3bf9df8ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 Sep 2022 21:56:56 +0800
Subject: [PATCH 2312/3374] Update 1104.path-in-zigzag-labelled-binary-tree.js

---
 1104.path-in-zigzag-labelled-binary-tree.js | 24 +++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1104.path-in-zigzag-labelled-binary-tree.js b/1104.path-in-zigzag-labelled-binary-tree.js
index 0b1c7c41..7f5f3c54 100644
--- a/1104.path-in-zigzag-labelled-binary-tree.js
+++ b/1104.path-in-zigzag-labelled-binary-tree.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} label
+ * @return {number[]}
+ */
+const pathInZigZagTree = function(label) {
+  const res = [], { log2, floor, ceil } = Math
+  const level = floor(log2(label))
+  let compl = 2 ** (level + 1) - 1 + 2 ** level - label
+  
+  while(label) {
+    res.push(label)
+    label = floor(label / 2)
+    compl = floor(compl / 2)
+    ;[label, compl] = [compl, label]
+  }
+  
+  res.reverse()
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number} label
  * @return {number[]}

From f25c5974db17d12b86a03ec8a2ee648933e6277f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 17:13:43 +0800
Subject: [PATCH 2313/3374] Update 862-shortest-subarray-with-sum-at-least-k.js

---
 862-shortest-subarray-with-sum-at-least-k.js | 30 ++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/862-shortest-subarray-with-sum-at-least-k.js b/862-shortest-subarray-with-sum-at-least-k.js
index a45d8c5f..a11a21f6 100644
--- a/862-shortest-subarray-with-sum-at-least-k.js
+++ b/862-shortest-subarray-with-sum-at-least-k.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const shortestSubarray = function(nums, k) {
+  const q = [], n = nums.length
+  let res = Infinity, sum = 0
+  const prefix = []
+  for(let i = 0; i < n; i++) {
+    sum += nums[i]
+    prefix.push(sum)
+    if(sum >= k) res = Math.min(res, i + 1)
+  }
+  // console.log(prefix)
+  for(let i = 0; i < n; i++) {
+
+    while(q.length && prefix[i] - prefix[q[0]] >= k) {
+        res = Math.min(res, i - q[0])
+        q.shift()
+    }
+    while(q.length && prefix[i] <= prefix[q[q.length - 1]]) q.pop()
+    q.push(i)
+  }
+  
+  return res === Infinity ? -1 : res
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} K

From f7ed06b2236a1647420697812da53a3660f87920 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 19:00:18 +0800
Subject: [PATCH 2314/3374] Update 862-shortest-subarray-with-sum-at-least-k.js

---
 862-shortest-subarray-with-sum-at-least-k.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/862-shortest-subarray-with-sum-at-least-k.js b/862-shortest-subarray-with-sum-at-least-k.js
index a11a21f6..e09e2839 100644
--- a/862-shortest-subarray-with-sum-at-least-k.js
+++ b/862-shortest-subarray-with-sum-at-least-k.js
@@ -12,14 +12,14 @@ const shortestSubarray = function(nums, k) {
     prefix.push(sum)
     if(sum >= k) res = Math.min(res, i + 1)
   }
-  // console.log(prefix)
-  for(let i = 0; i < n; i++) {
 
+  for(let i = 0; i < n; i++) {
+    while(q.length && prefix[i] <= prefix[q[q.length - 1]]) q.pop()
     while(q.length && prefix[i] - prefix[q[0]] >= k) {
-        res = Math.min(res, i - q[0])
-        q.shift()
+      res = Math.min(res, i - q[0])
+      q.shift()
     }
-    while(q.length && prefix[i] <= prefix[q[q.length - 1]]) q.pop()
+
     q.push(i)
   }
   

From c8310a61ba04529b743edbadfef8a3e741552008 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 19:34:46 +0800
Subject: [PATCH 2315/3374] Create 1669-merge-in-between-linked-lists.js

---
 1669-merge-in-between-linked-lists.js | 56 +++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 1669-merge-in-between-linked-lists.js

diff --git a/1669-merge-in-between-linked-lists.js b/1669-merge-in-between-linked-lists.js
new file mode 100644
index 00000000..583ff451
--- /dev/null
+++ b/1669-merge-in-between-linked-lists.js
@@ -0,0 +1,56 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} list1
+ * @param {number} a
+ * @param {number} b
+ * @param {ListNode} list2
+ * @return {ListNode}
+ */
+const mergeInBetween = function(list1, a, b, list2) {
+  const dummy = new ListNode()
+  dummy.next = list1
+  let cur = dummy
+  let tail
+  let idx = -1
+  while(cur) {
+    if(cur.next && idx + 1 === a) {
+      tail = cur
+      const tmp = cur.next
+      cur.next = null
+      cur = tmp
+      break
+    }
+    cur = cur.next
+    idx++
+  }
+  let head
+  // console.log(idx)
+  while(cur) {
+    if(idx + 1 === b) {
+      head = cur.next
+      cur.next = null
+      break
+    }
+    cur = cur.next
+    idx++
+  }
+  
+  tail.next = list2
+  cur = list2
+  while(cur) {
+    if(cur.next == null) {
+      cur.next = head
+      break
+    }
+    cur = cur.next
+  }
+  
+  
+  return dummy.next
+};

From dfa5665c6a656fd23a18435c3c2898cb824e4eba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 19:37:25 +0800
Subject: [PATCH 2316/3374] Update 1669-merge-in-between-linked-lists.js

---
 1669-merge-in-between-linked-lists.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/1669-merge-in-between-linked-lists.js b/1669-merge-in-between-linked-lists.js
index 583ff451..1bf4d09f 100644
--- a/1669-merge-in-between-linked-lists.js
+++ b/1669-merge-in-between-linked-lists.js
@@ -24,6 +24,7 @@ const mergeInBetween = function(list1, a, b, list2) {
       const tmp = cur.next
       cur.next = null
       cur = tmp
+      idx++
       break
     }
     cur = cur.next
@@ -32,7 +33,7 @@ const mergeInBetween = function(list1, a, b, list2) {
   let head
   // console.log(idx)
   while(cur) {
-    if(idx + 1 === b) {
+    if(idx === b) {
       head = cur.next
       cur.next = null
       break

From b35cf64d3edbdb7b6e5fca8434d5c1b08c117b4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 20:00:01 +0800
Subject: [PATCH 2317/3374] Create
 1910-remove-all-occurrences-of-a-substring.js

---
 1910-remove-all-occurrences-of-a-substring.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 1910-remove-all-occurrences-of-a-substring.js

diff --git a/1910-remove-all-occurrences-of-a-substring.js b/1910-remove-all-occurrences-of-a-substring.js
new file mode 100644
index 00000000..97b46c74
--- /dev/null
+++ b/1910-remove-all-occurrences-of-a-substring.js
@@ -0,0 +1,13 @@
+/**
+ * @param {string} s
+ * @param {string} part
+ * @return {string}
+ */
+var removeOccurrences = function(s, part) {
+  while(s.indexOf(part) !== -1) {
+    const idx = s.indexOf(part)
+    s = s.slice(0, idx) + s.slice(idx + part.length)
+    // console.log(s)
+  }
+  return s
+};

From 7f9f2f04935c493efac3f0ce0dffbeb7783f31fc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 20:23:11 +0800
Subject: [PATCH 2318/3374] Create
 1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js

---
 ...-depth-of-two-valid-parentheses-strings.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js

diff --git a/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js
new file mode 100644
index 00000000..5027f160
--- /dev/null
+++ b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} seq
+ * @return {number[]}
+ */
+var maxDepthAfterSplit = function(seq) {
+  let A = 0, B = 0, n = seq.length;
+  let res = Array(n).fill(0);
+  for (let i = 0; i < n; ++i) {
+      if (seq.charAt(i) == '(') {
+          if (A < B) {
+              ++A;
+          } else {
+              ++B;
+              res[i] = 1;
+          }
+      } else {
+          if (A > B) {
+              --A;
+          } else {
+              --B;
+              res[i] = 1;
+          }
+      }
+  }
+  return res;
+};

From 425b307899f56df0d61081ee0902380c1256bf95 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Sep 2022 21:44:26 +0800
Subject: [PATCH 2319/3374] Update
 1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js

---
 ...-depth-of-two-valid-parentheses-strings.js | 32 +++++++------------
 1 file changed, 12 insertions(+), 20 deletions(-)

diff --git a/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js
index 5027f160..436fbc27 100644
--- a/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js
+++ b/1111-maximum-nesting-depth-of-two-valid-parentheses-strings.js
@@ -2,25 +2,17 @@
  * @param {string} seq
  * @return {number[]}
  */
-var maxDepthAfterSplit = function(seq) {
-  let A = 0, B = 0, n = seq.length;
-  let res = Array(n).fill(0);
-  for (let i = 0; i < n; ++i) {
-      if (seq.charAt(i) == '(') {
-          if (A < B) {
-              ++A;
-          } else {
-              ++B;
-              res[i] = 1;
-          }
-      } else {
-          if (A > B) {
-              --A;
-          } else {
-              --B;
-              res[i] = 1;
-          }
-      }
+const maxDepthAfterSplit = function(seq) {
+  const n = seq.length
+  const res = Array(n).fill(0)
+  let depth = 0
+  for(let i = 0; i < n; i++) {
+    const ch = seq[i]
+    if(ch === '(') {
+      depth++
+    }
+    res[i] = depth % 2
+    if(ch === ')') depth--
   }
-  return res;
+  return res
 };

From 753265e890e44cf07192bbfa9404295953668a94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Sep 2022 20:27:24 +0800
Subject: [PATCH 2320/3374] Update 1801-number-of-orders-in-the-backlog.js

---
 1801-number-of-orders-in-the-backlog.js | 2 --
 1 file changed, 2 deletions(-)

diff --git a/1801-number-of-orders-in-the-backlog.js b/1801-number-of-orders-in-the-backlog.js
index c5bcd0af..82b7e23d 100644
--- a/1801-number-of-orders-in-the-backlog.js
+++ b/1801-number-of-orders-in-the-backlog.js
@@ -8,8 +8,6 @@ const getNumberOfBacklogOrders = function (orders) {
   const P = 10 ** 9 + 7
   const { min } = Math
 
-  while (!h0.isEmpty()) h0.pop()
-  while (!h1.isEmpty()) h1.pop()
   let i,
     j,
     i1,

From 8d02d2c3daf9af1004311d3659cc980298cdd540 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Sep 2022 20:45:41 +0800
Subject: [PATCH 2321/3374] Update 1801-number-of-orders-in-the-backlog.js

---
 1801-number-of-orders-in-the-backlog.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1801-number-of-orders-in-the-backlog.js b/1801-number-of-orders-in-the-backlog.js
index 82b7e23d..b9678076 100644
--- a/1801-number-of-orders-in-the-backlog.js
+++ b/1801-number-of-orders-in-the-backlog.js
@@ -4,7 +4,7 @@
  */
 const getNumberOfBacklogOrders = function (orders) {
   const h0 = new PriorityQueue((a, b) => a[0] > b[0])
-  const h1 = new PriorityQueue((a, b) => a[0] > b[0])
+  const h1 = new PriorityQueue((a, b) => a[0] < b[0])
   const P = 10 ** 9 + 7
   const { min } = Math
 
@@ -29,9 +29,9 @@ const getNumberOfBacklogOrders = function (orders) {
           break
         }
       }
-      if (j) h1.push([-i, j])
+      if (j) h1.push([i, j])
     } else {
-      while (!h1.isEmpty() && -h1.peek()[0] <= i) {
+      while (!h1.isEmpty() && h1.peek()[0] <= i) {
         i1 = h1.peek()[0]
         j1 = h1.peek()[1]
         h1.pop()

From b5f08f6594a241b113c0df7a7798b2a2551a8fc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Sep 2022 19:49:40 +0800
Subject: [PATCH 2322/3374] Update
 1942-the-number-of-the-smallest-unoccupied-chair.js

---
 ...number-of-the-smallest-unoccupied-chair.js | 108 ++++++++++++++++++
 1 file changed, 108 insertions(+)

diff --git a/1942-the-number-of-the-smallest-unoccupied-chair.js b/1942-the-number-of-the-smallest-unoccupied-chair.js
index 4ad49cf1..65b9cd46 100644
--- a/1942-the-number-of-the-smallest-unoccupied-chair.js
+++ b/1942-the-number-of-the-smallest-unoccupied-chair.js
@@ -1,3 +1,111 @@
+/**
+ * @param {number[][]} times
+ * @param {number} targetFriend
+ * @return {number}
+ */
+const smallestChair = function (times, targetFriend) {
+  const targetArrival = times[targetFriend][0]
+  let seatNum = 0
+  let res = 0
+  const n = times.length
+  
+  times.sort((a, b) => a[0] - b[0])
+  
+  const occupied = new PriorityQueue((a, b) => a[0] < b[0])
+  const available = new PriorityQueue((a, b) => a < b)
+  
+  for(let i = 0; i < n; i++) {
+    const [arrival, leaving] = times[i]
+    while(!occupied.isEmpty() && occupied.peek()[0] <= arrival) {
+      available.push(occupied.pop()[1])      
+    }
+    let seat
+    if(!available.isEmpty()) {
+      seat = available.pop()
+    } else {
+      seat = seatNum
+      seatNum++
+    }
+    occupied.push([leaving, seat])
+    if(arrival === targetArrival) {
+      res = seat
+      break
+    }
+  }
+  
+  return res
+}
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
+
 /**
  * @param {number[][]} times
  * @param {number} targetFriend

From 20734df10bdb0c9b8ec542fbe308ca3e6ea05c1d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 11:49:47 +0800
Subject: [PATCH 2323/3374] Update 1882-process-tasks-using-servers.js

---
 1882-process-tasks-using-servers.js | 119 ++++++++++++++++++++++++++++
 1 file changed, 119 insertions(+)

diff --git a/1882-process-tasks-using-servers.js b/1882-process-tasks-using-servers.js
index 17b515bc..311fafc7 100644
--- a/1882-process-tasks-using-servers.js
+++ b/1882-process-tasks-using-servers.js
@@ -1,3 +1,122 @@
+/**
+ * @param {number[]} servers
+ * @param {number[]} tasks
+ * @return {number[]}
+ */
+const assignTasks = function (servers, tasks) {
+  const available = new PriorityQueue((a, b) =>
+    a[0] === b[0] ? a[1] < b[1] : a[0] < b[0]
+  )
+  const occupied = new PriorityQueue((a, b) =>
+    a[0] === b[0] ? (a[1] === b[1] ? a[2] < b[2] : a[1] < b[1]) : a[0] < b[0]
+  )
+
+  const res = [],
+    m = tasks.length,
+    n = servers.length
+  for (let i = 0; i < n; i++) {
+    const w = servers[i]
+    available.push([w, i])
+  }
+  let now = 0
+  for (let i = 0; i < m; i++) {
+    const t = tasks[i]
+
+    while (!occupied.isEmpty() && occupied.peek()[0] <= now) {
+      const [end, weight, index] = occupied.pop()
+      available.push([weight, index])
+    }
+
+    let idx
+    if (!available.isEmpty()) {
+      const [weight, index] = available.pop()
+      idx = index
+      occupied.push([now + t, weight, index])
+      if(i >= now) now++
+    } else {
+      let [endTime, weight, index] = occupied.pop()
+      idx = index
+      occupied.push([endTime + t, weight, index])
+      now = endTime
+    }
+
+    res.push(idx)
+  }
+
+  return res
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} servers
  * @param {number[]} tasks

From c927930fad21481b103c0e3a2ba06d4e08f1763e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 13:42:10 +0800
Subject: [PATCH 2324/3374] Create 1529-minimum-suffix-flips.js

---
 1529-minimum-suffix-flips.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1529-minimum-suffix-flips.js

diff --git a/1529-minimum-suffix-flips.js b/1529-minimum-suffix-flips.js
new file mode 100644
index 00000000..b50905b8
--- /dev/null
+++ b/1529-minimum-suffix-flips.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} target
+ * @return {number}
+ */
+const minFlips = function (target) {
+  const n = target.length
+  let res = 0, flip = 0
+
+  for(let i = 0; i < n; i++) {
+    if(target[i] === '0' && flip % 2 === 0) continue
+    if(target[i] === '1' && flip % 2 === 1) continue
+    flip++
+    res++
+  }
+
+  return res
+}

From b7b7cb4edc8cacd428c8832ba70abb995140e7fc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 14:00:29 +0800
Subject: [PATCH 2325/3374] Create
 2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.js

---
 ...trings-with-concatenation-equal-to-target.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.js

diff --git a/2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.js b/2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.js
new file mode 100644
index 00000000..89b09319
--- /dev/null
+++ b/2023-number-of-pairs-of-strings-with-concatenation-equal-to-target.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string[]} nums
+ * @param {string} target
+ * @return {number}
+ */
+const numOfPairs = function(nums, target) {
+  let res = 0
+  
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+      for(let j = 0; j < n; j++) {
+          if(i !== j && nums[i] + nums[j] === target) res++
+      }
+  }
+  
+  return res
+};

From 2502ed728dc7e116c566701e7973923595c1e588 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 19:47:48 +0800
Subject: [PATCH 2326/3374] Create 919-complete-binary-tree-inserter.js

---
 919-complete-binary-tree-inserter.js | 53 ++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 919-complete-binary-tree-inserter.js

diff --git a/919-complete-binary-tree-inserter.js b/919-complete-binary-tree-inserter.js
new file mode 100644
index 00000000..2187f8bb
--- /dev/null
+++ b/919-complete-binary-tree-inserter.js
@@ -0,0 +1,53 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ */
+var CBTInserter = function(root) {
+    this.r = root
+};
+
+/** 
+ * @param {number} val
+ * @return {number}
+ */
+CBTInserter.prototype.insert = function(val) {
+   let q = [this.r]
+   
+   while(q.length) {
+     const tmp = []
+     for(let i = 0; i < q.length; i++) {
+       const cur = q[i]
+       if(cur.left == null) {
+         cur.left = new TreeNode(val)
+         return cur.val
+       } else tmp.push(cur.left)
+       if(cur.right == null) {
+         cur.right = new TreeNode(val)
+         return cur.val
+       } else tmp.push(cur.right)
+     }
+     
+     q = tmp
+   }
+};
+
+/**
+ * @return {TreeNode}
+ */
+CBTInserter.prototype.get_root = function() {
+    return this.r
+};
+
+/** 
+ * Your CBTInserter object will be instantiated and called as such:
+ * var obj = new CBTInserter(root)
+ * var param_1 = obj.insert(val)
+ * var param_2 = obj.get_root()
+ */

From 155bb56b81da77b8e4ebcc1be1163f4bbc92fba0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 20:23:16 +0800
Subject: [PATCH 2327/3374] Create
 1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js

---
 ...string-of-all-happy-strings-of-length-n.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js

diff --git a/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
new file mode 100644
index 00000000..98711011
--- /dev/null
+++ b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+var getHappyString = function(n, k) {
+  const res = []
+  dfs()
+  return res.length === k ? res[res.length - 1] : ''
+  function dfs(path = '') {
+    if(res.length === k) return
+    if(path.length === n) {
+      res.push(path)
+      return
+    }
+    for(const e of 'abc') {
+      if(path === '' || e !== path[path.length - 1]) {
+        dfs(path + e)
+      }
+    }
+  }
+};

From cf0ffd74e41377c5c34587768e6dc8722589d487 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Sep 2022 22:09:41 +0800
Subject: [PATCH 2328/3374] Update
 1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js

---
 ...string-of-all-happy-strings-of-length-n.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
index 98711011..03581889 100644
--- a/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
+++ b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getHappyString = function(n, k) {
+  const hash = {a: 'bc', b: 'ac', c: 'ab'}
+  const q = ['a', 'b', 'c']
+  while(q[0].length !== n) {
+    const pre = q.shift()
+    for(const ch of hash[pre[pre.length - 1]]) {
+      q.push(pre + ch)
+    }
+  }
+  
+  return q.length >= k ? q[k - 1] : ''
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From d625124ad6146e4d526ccdce19d1a4b14e4af8bd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 13:03:07 +0800
Subject: [PATCH 2329/3374] Create 2413-smallest-even-multiple.js

---
 2413-smallest-even-multiple.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 2413-smallest-even-multiple.js

diff --git a/2413-smallest-even-multiple.js b/2413-smallest-even-multiple.js
new file mode 100644
index 00000000..fe2f27b0
--- /dev/null
+++ b/2413-smallest-even-multiple.js
@@ -0,0 +1,7 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var smallestEvenMultiple = function(n) {
+    return n % 2 === 0 ? n : 2 * n
+};

From 37ec20d0c4077e3af3e2f73a4600ae0b8817ef94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 13:03:45 +0800
Subject: [PATCH 2330/3374] Create
 2414-length-of-the-longest-alphabetical-continuous-substring.js

---
 ...ngest-alphabetical-continuous-substring.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2414-length-of-the-longest-alphabetical-continuous-substring.js

diff --git a/2414-length-of-the-longest-alphabetical-continuous-substring.js b/2414-length-of-the-longest-alphabetical-continuous-substring.js
new file mode 100644
index 00000000..6abbe1e4
--- /dev/null
+++ b/2414-length-of-the-longest-alphabetical-continuous-substring.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var longestContinuousSubstring = function(s) {
+  let res = 1
+  let tmp = 1
+  const n = s.length
+  let pre = s[0]
+  for(let i = 1;i < n; i++) {
+    const ch = s[i]
+    if(ch.charCodeAt(0) - pre.charCodeAt(0) === 1) {
+      tmp++
+      pre = ch
+      res = Math.max(res, tmp)
+    } else {
+      pre = ch
+      tmp = 1
+    }
+  }
+  
+  return res
+};

From dca594b63a24e4d1ca54dad91b7f978ec60fe5c7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 13:04:32 +0800
Subject: [PATCH 2331/3374] Create 2415-reverse-odd-levels-of-binary-tree.js

---
 2415-reverse-odd-levels-of-binary-tree.js | 40 +++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2415-reverse-odd-levels-of-binary-tree.js

diff --git a/2415-reverse-odd-levels-of-binary-tree.js b/2415-reverse-odd-levels-of-binary-tree.js
new file mode 100644
index 00000000..8a7e57e1
--- /dev/null
+++ b/2415-reverse-odd-levels-of-binary-tree.js
@@ -0,0 +1,40 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+var reverseOddLevels = function(root) {
+  
+  let q = [root]
+  let level = 0
+  
+  while(q.length) {
+    const nxt = []
+    for(let i = 0; i < q.length; i++) {
+      const cur = q[i]
+      if(cur.left) nxt.push(cur.left)
+      if(cur.right) nxt.push(cur.right)
+    }
+    if(level % 2 === 1) {
+      const arr = q.map(e => e.val)
+      arr.reverse()
+      for(let i = 0; i < q.length; i++) {
+        q[i].val = arr[i]
+      }
+    }
+    
+    level++
+    q = nxt
+  }
+  
+  // dfs(root, 0)
+  return root
+
+};

From 6c629e46493ae537230c00f8be81e397860dcbbb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 13:05:12 +0800
Subject: [PATCH 2332/3374] Create 2416-sum-of-prefix-scores-of-strings.js

---
 2416-sum-of-prefix-scores-of-strings.js | 50 +++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2416-sum-of-prefix-scores-of-strings.js

diff --git a/2416-sum-of-prefix-scores-of-strings.js b/2416-sum-of-prefix-scores-of-strings.js
new file mode 100644
index 00000000..11ea9edf
--- /dev/null
+++ b/2416-sum-of-prefix-scores-of-strings.js
@@ -0,0 +1,50 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const sumPrefixScores = function(words) {
+  let trie = new Trie();
+  for (let word of words) {
+    trie.add(word);
+  } 
+
+  let n = words.length, res = Array(n);
+  for (let i = 0; i < words.length; i++) {
+    res[i] = trie.getScore(words[i]);
+  }
+  return res;
+};
+
+class TrieNode {
+  constructor() {
+    this.children = {};
+    this.count = 0; 
+  }
+}
+
+class Trie {
+  constructor() {
+    this.root = new TrieNode();
+  }
+  add(word) {
+    let node = this.root;
+    for (let i = 0; i < word.length; i++) {
+      node = node.children;
+      let char = word[i];
+      if (!node[char]) node[char] = new TrieNode();
+      node = node[char];
+      node.count++;
+    }
+  }
+  getScore(word) {
+    let node = this.root, score = 0;
+    for (let i = 0; i < word.length; i++) {
+      node = node.children;
+      let char = word[i];
+      if (!node[char]) return score;
+      node = node[char];
+      score += node.count;
+    }
+    return score;
+  }
+};

From ea466adf513dcb18121e1b1510f5ac78fdf6cabd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 21:23:28 +0800
Subject: [PATCH 2333/3374] Update 2102-sequentially-ordinal-rank-tracker.js

---
 2102-sequentially-ordinal-rank-tracker.js | 112 ++++++++++++++++++++++
 1 file changed, 112 insertions(+)

diff --git a/2102-sequentially-ordinal-rank-tracker.js b/2102-sequentially-ordinal-rank-tracker.js
index dd976e51..6a33689b 100644
--- a/2102-sequentially-ordinal-rank-tracker.js
+++ b/2102-sequentially-ordinal-rank-tracker.js
@@ -110,3 +110,115 @@ class PriorityQueue {
     }
   }
 }
+
+
+// another
+
+const SORTracker = function() {
+  this.maxCmp = (a, b) => a[1] === b[1] ? a[0] < b[0] : a[1] > b[1]
+  this.minCmp = (a, b) => a[1] === b[1] ? a[0] > b[0] : a[1] < b[1]
+  this.maxQ = new PriorityQueue(this.maxCmp)
+  this.minQ = new PriorityQueue(this.minCmp)
+  this.cnt = 0
+};
+
+/** 
+ * @param {string} name 
+ * @param {number} score
+ * @return {void}
+ */
+SORTracker.prototype.add = function(name, score) {
+  this.maxQ.push([name, score])
+};
+
+/**
+ * @return {string}
+ */
+SORTracker.prototype.get = function() {
+  if(this.cnt) {
+    this.minQ.push(this.maxQ.pop())
+    while(this.minCmp(this.minQ.peek(), this.maxQ.peek())) {
+      const tmp = this.maxQ.pop()
+      this.maxQ.push(this.minQ.pop())
+      this.minQ.push(tmp)
+    }
+  }
+  this.cnt++
+
+  return this.maxQ.peek()[0]
+};
+
+/** 
+ * Your SORTracker object will be instantiated and called as such:
+ * var obj = new SORTracker()
+ * obj.add(name,score)
+ * var param_2 = obj.get()
+ */
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From b22d958e15248f8e9cc2fb18c79d886ae2296640 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Sep 2022 21:29:02 +0800
Subject: [PATCH 2334/3374] Update 2102-sequentially-ordinal-rank-tracker.js

---
 2102-sequentially-ordinal-rank-tracker.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/2102-sequentially-ordinal-rank-tracker.js b/2102-sequentially-ordinal-rank-tracker.js
index 6a33689b..745f2173 100644
--- a/2102-sequentially-ordinal-rank-tracker.js
+++ b/2102-sequentially-ordinal-rank-tracker.js
@@ -137,10 +137,10 @@ SORTracker.prototype.add = function(name, score) {
 SORTracker.prototype.get = function() {
   if(this.cnt) {
     this.minQ.push(this.maxQ.pop())
-    while(this.minCmp(this.minQ.peek(), this.maxQ.peek())) {
-      const tmp = this.maxQ.pop()
-      this.maxQ.push(this.minQ.pop())
-      this.minQ.push(tmp)
+    while(this.maxCmp(this.maxQ.peek(), this.minQ.peek())) {
+      const tmp = this.minQ.pop()
+      this.minQ.push(this.maxQ.pop())
+      this.maxQ.push(tmp)
     }
   }
   this.cnt++

From b2aa6fa301fbe148b6b0574fdab9c6bbbf1410d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Sep 2022 11:25:49 +0800
Subject: [PATCH 2335/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index 5fb05b3a..61a6a0db 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -111,3 +111,30 @@ const minMeetingRooms = function(intervals) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  const n = intervals.length
+  const limit = 1e6 + 1
+  const arr = Array(limit).fill(0)
+  let res = 0
+  
+  for(const [start, end] of intervals) {
+      arr[start]++
+      arr[end]--
+  }
+
+  for(let i = 1; i < limit; i++) {
+      arr[i] += arr[i - 1]
+  }
+  for(let i = 0; i < limit; i++) {
+      res = Math.max(res, arr[i])
+  }
+  
+  return res
+};

From 80740afc7fa7ec272ebee0c001c2a669a64e86ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Sep 2022 21:46:17 +0800
Subject: [PATCH 2336/3374] Create 1884-egg-drop-with-2-eggs-and-n-floors.js

---
 1884-egg-drop-with-2-eggs-and-n-floors.js | 24 +++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1884-egg-drop-with-2-eggs-and-n-floors.js

diff --git a/1884-egg-drop-with-2-eggs-and-n-floors.js b/1884-egg-drop-with-2-eggs-and-n-floors.js
new file mode 100644
index 00000000..09c729a1
--- /dev/null
+++ b/1884-egg-drop-with-2-eggs-and-n-floors.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const twoEggDrop = function (n) {
+  const dp = Array(n + 1).fill(0)
+
+  helper(n)
+// console.log(dp)
+  return dp[n]
+
+  function helper(k) {
+    if(k === 0) return 0
+    if (dp[k] === 0) {
+      for (let i = 1; i <= k; i++) {
+        dp[k] = Math.min(
+          dp[k] === 0 ? k : dp[k],
+          1 + Math.max(i - 1, helper(k - i))
+        )
+      }
+    }
+    return dp[k]
+  }
+}

From c78a5180ee78bff1eb0e9781f7e3c0d6fd1ef160 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Sep 2022 11:18:56 +0800
Subject: [PATCH 2337/3374] Update
 2406.divide-intervals-into-minimum-number-of-groups.js

---
 ...intervals-into-minimum-number-of-groups.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2406.divide-intervals-into-minimum-number-of-groups.js b/2406.divide-intervals-into-minimum-number-of-groups.js
index e55dd03d..aaecb9aa 100644
--- a/2406.divide-intervals-into-minimum-number-of-groups.js
+++ b/2406.divide-intervals-into-minimum-number-of-groups.js
@@ -18,3 +18,31 @@ var minGroups = function(intervals) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minGroups = function(intervals) {
+  const hash = {}
+  for(const [s, e] of intervals) {
+    if(hash[s] == null) hash[s] = 0
+    if(hash[e + 1] == null) hash[e + 1] = 0
+    hash[s]++
+    hash[e + 1]--
+  }
+  const keys = Object.keys(hash)
+  keys.sort((a, b) => a - b)
+  const n = keys.length
+
+  const arr = Array(n).fill(0)
+  arr[0] = hash[keys[0]]
+  let res = arr[0]
+  for(let i = 1; i < n; i++) {
+     arr[i] = hash[keys[i]] + arr[i - 1]
+     res = Math.max(res, arr[i])
+  }
+  return res
+};

From 05bc8c51febd3793a9a2c6e6dcee6156d20a3b2d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Sep 2022 19:52:33 +0800
Subject: [PATCH 2338/3374] Create
 1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js

---
 ...rage-greater-than-or-equal-to-threshold.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js

diff --git a/1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js b/1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js
new file mode 100644
index 00000000..52743a02
--- /dev/null
+++ b/1343-number-of-sub-arrays-of-size-k-and-average-greater-than-or-equal-to-threshold.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @param {number} threshold
+ * @return {number}
+ */
+const numOfSubarrays = function(arr, k, threshold) {
+  const n = arr.length
+  const pre = Array(n).fill(0)
+  pre[0] = arr[0]
+  for(let i = 1; i < n; i++) {
+    pre[i] = pre[i - 1] + arr[i]
+  }
+  
+  let res = 0
+  if(pre[k - 1] / k >= threshold) res++
+  for(let i = k; i < n; i++) {
+    if(pre[i] - pre[i - k] >= k * threshold) res++
+  }
+  return res
+};

From 5d9a5b3a4a804cdfd5a6e2c2cfe2b41aa60c86aa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Sep 2022 20:59:35 +0800
Subject: [PATCH 2339/3374] Create 1387-sort-integers-by-the-power-value.js

---
 1387-sort-integers-by-the-power-value.js | 29 ++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 1387-sort-integers-by-the-power-value.js

diff --git a/1387-sort-integers-by-the-power-value.js b/1387-sort-integers-by-the-power-value.js
new file mode 100644
index 00000000..a756859b
--- /dev/null
+++ b/1387-sort-integers-by-the-power-value.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} lo
+ * @param {number} hi
+ * @param {number} k
+ * @return {number}
+ */
+const getKth = function(lo, hi, k) {
+  const arr = []
+  
+  for(let i = lo; i <= hi; i++) {
+    arr.push([helper(i), i])
+  }
+  
+  arr.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  
+  return arr[k - 1][1]
+  
+  
+  function helper(num) {
+    let res = 0
+    while(num !== 1) {
+      if(num % 2 === 0) num /= 2
+      else num = num * 3 + 1
+      res++
+    }
+    
+    return res
+  }
+};

From fd833f6691e97ef8797900ac1fab7aa7ef2b1ad1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Sep 2022 22:31:31 +0800
Subject: [PATCH 2340/3374] Create
 1836-remove-duplicates-from-an-unsorted-linked-list.js

---
 ...duplicates-from-an-unsorted-linked-list.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 1836-remove-duplicates-from-an-unsorted-linked-list.js

diff --git a/1836-remove-duplicates-from-an-unsorted-linked-list.js b/1836-remove-duplicates-from-an-unsorted-linked-list.js
new file mode 100644
index 00000000..62bb0226
--- /dev/null
+++ b/1836-remove-duplicates-from-an-unsorted-linked-list.js
@@ -0,0 +1,44 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const deleteDuplicatesUnsorted = function(head) {
+  const set = new Set()
+  const del = new Set()
+  let cur = head
+  
+  while(cur) {
+    if(set.has(cur.val)) {
+      del.add(cur.val)
+    } else {
+      set.add(cur.val)
+
+    }
+    cur = cur.next    
+  }
+  
+  const dummy = new ListNode()
+  dummy.next = head
+  cur = dummy
+  
+  while(cur) {
+    if(cur.next) {
+      if(del.has(cur.next.val)) {
+        cur.next = cur.next.next
+      } else {
+        cur = cur.next
+      }
+    } else {
+      cur = cur.next        
+    }
+  }
+  
+  return dummy.next
+};

From 40b4c961a8469e25d6d9880c7c5493d1a84f0c62 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Sep 2022 22:46:37 +0800
Subject: [PATCH 2341/3374] Create 1244-design-a-leaderboard.js

---
 1244-design-a-leaderboard.js | 120 +++++++++++++++++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 1244-design-a-leaderboard.js

diff --git a/1244-design-a-leaderboard.js b/1244-design-a-leaderboard.js
new file mode 100644
index 00000000..769076b8
--- /dev/null
+++ b/1244-design-a-leaderboard.js
@@ -0,0 +1,120 @@
+
+const Leaderboard = function() {
+  this.hash = {}
+};
+
+/** 
+ * @param {number} playerId 
+ * @param {number} score
+ * @return {void}
+ */
+Leaderboard.prototype.addScore = function(playerId, score) {
+  if(this.hash[playerId] == null) this.hash[playerId] = 0
+  this.hash[playerId] += score
+};
+
+/** 
+ * @param {number} K
+ * @return {number}
+ */
+Leaderboard.prototype.top = function(K) {
+  const pq = new PriorityQueue((a, b) => a < b)
+  const values = Object.values(this.hash)
+  // console.log(values)
+  for(const v of values) {
+    pq.push(v)
+    if(pq.size() > K) pq.pop()
+  }
+  // console.log(pq.heap)
+  let sum = 0
+  while(!pq.isEmpty()) {
+    sum += pq.pop()
+    
+  }
+  
+  return sum
+};
+
+/** 
+ * @param {number} playerId
+ * @return {void}
+ */
+Leaderboard.prototype.reset = function(playerId) {
+  delete this.hash[playerId]
+};
+
+/** 
+ * Your Leaderboard object will be instantiated and called as such:
+ * var obj = new Leaderboard()
+ * obj.addScore(playerId,score)
+ * var param_2 = obj.top(K)
+ * obj.reset(playerId)
+ */
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 1ffeb41abc8cb97ccf2dc29fed136a09a55d68ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Sep 2022 11:29:16 +0800
Subject: [PATCH 2342/3374] Update 2386-find-the-k-sum-of-an-array.js

---
 2386-find-the-k-sum-of-an-array.js | 99 ++++++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)

diff --git a/2386-find-the-k-sum-of-an-array.js b/2386-find-the-k-sum-of-an-array.js
index 5d7b62bd..491ad86b 100644
--- a/2386-find-the-k-sum-of-an-array.js
+++ b/2386-find-the-k-sum-of-an-array.js
@@ -24,3 +24,102 @@ var kSum = function(nums, k) {
     }
     return pq.front()[0];
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const kSum = function (nums, k) {
+  let sum = 0,
+    n = nums.length,
+    pq = new PriorityQueue((x, y) => y[0] < x[0])
+  for (let i = 0; i < n; i++) {
+    if (nums[i] < 0) {
+      nums[i] *= -1
+    } else {
+      sum += nums[i]
+    }
+  }
+  if (k == 1) return sum
+  nums.sort((x, y) => x - y)
+  pq.push([sum - nums[0], 0])
+  for (let i = 2; i < k; i++) {
+    let [x, idx] = pq.pop()
+    if (idx + 1 < n) {
+      pq.push([x + nums[idx] - nums[idx + 1], idx + 1])
+      pq.push([x - nums[idx + 1], idx + 1])
+    }
+  }
+  return pq.peek()[0]
+}
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 5912ca5a30bd2f4224e52de4e6d6430fe5f8f8bd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Sep 2022 19:51:58 +0800
Subject: [PATCH 2343/3374] Create
 2083-substrings-that-begin-and-end-with-the-same-letter.js

---
 ...that-begin-and-end-with-the-same-letter.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2083-substrings-that-begin-and-end-with-the-same-letter.js

diff --git a/2083-substrings-that-begin-and-end-with-the-same-letter.js b/2083-substrings-that-begin-and-end-with-the-same-letter.js
new file mode 100644
index 00000000..3e1522a9
--- /dev/null
+++ b/2083-substrings-that-begin-and-end-with-the-same-letter.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const numberOfSubstrings = function(s) {
+  const hash = {}
+  const n = s.length
+  for(let i = 0; i < n; i++) {
+    const ch = s[i]
+    if(hash[ch] == null) hash[ch] = []
+    hash[ch].push(i)
+  }
+  
+  let res = 0
+  const keys = Object.keys(hash)
+  keys.forEach(k => {
+    res += helper(k)
+  })
+  
+  return res
+  
+  
+  function helper(k) {
+    const arr = hash[k]
+    const len = arr.length
+    return len * (len + 1) / 2
+  }
+};

From ff72fce27825940aeefe84ed63e8a8c84a5481e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Sep 2022 21:27:41 +0800
Subject: [PATCH 2344/3374] Create 1247-minimum-swaps-to-make-strings-equal.js

---
 1247-minimum-swaps-to-make-strings-equal.js | 45 +++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 1247-minimum-swaps-to-make-strings-equal.js

diff --git a/1247-minimum-swaps-to-make-strings-equal.js b/1247-minimum-swaps-to-make-strings-equal.js
new file mode 100644
index 00000000..b0619b9d
--- /dev/null
+++ b/1247-minimum-swaps-to-make-strings-equal.js
@@ -0,0 +1,45 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @return {number}
+ */
+const minimumSwap = function (s1, s2) {
+  let x1 = 0 // number of 'x' in s1 (skip equal chars at same index)
+  let y1 = 0 // number of 'y' in s1 (skip equal chars at same index)
+  let x2 = 0 // number of 'x' in s2 (skip equal chars at same index)
+  let y2 = 0 // number of 'y' in s2 (skip equal chars at same index)
+
+  for (let i = 0; i < s1.length; i++) {
+    let c1 = s1.charAt(i)
+    let c2 = s2.charAt(i)
+    if (c1 == c2) {
+      // skip chars that are equal at the same index in s1 and s2
+      continue
+    }
+    if (c1 == 'x') {
+      x1++
+    } else {
+      y1++
+    }
+    if (c2 == 'x') {
+      x2++
+    } else {
+      y2++
+    }
+  } // end for
+
+  // After skip "c1 == c2", check the number of  'x' and 'y' left in s1 and s2.
+  if ((x1 + x2) % 2 != 0 || (y1 + y2) % 2 != 0) {
+    return -1 // if number of 'x' or 'y' is odd, we can not make s1 equals to s2
+  }
+
+  let swaps = Math.floor(x1 / 2) + Math.floor(y1 / 2) + (x1 % 2) * 2
+  // Cases to do 1 swap:
+  // "xx" => x1 / 2 => how many pairs of 'x' we have ?
+  // "yy" => y1 / 2 => how many pairs of 'y' we have ?
+  //
+  // Cases to do 2 swaps:
+  // "xy" or "yx" =>  x1 % 2
+
+  return swaps
+}

From 09ab7f1e5c4fcc382225ea7ccdb5734dc4252b03 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Sep 2022 19:37:10 +0800
Subject: [PATCH 2345/3374] Update 774-minimize-max-distance-to-gas-station.js

---
 774-minimize-max-distance-to-gas-station.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/774-minimize-max-distance-to-gas-station.js b/774-minimize-max-distance-to-gas-station.js
index 32bc695b..9eecda2b 100644
--- a/774-minimize-max-distance-to-gas-station.js
+++ b/774-minimize-max-distance-to-gas-station.js
@@ -24,7 +24,7 @@ const minmaxGasDist = function (stations, K) {
 const possible = (dis, res, K) => {
   let need = 0
   for (let i = 0; i < dis.length; i++) {
-    need += Math.floor(dis[i] / res)
+    need += dis[i] <= res ? 0 : Math.floor(dis[i] / res)
   }
   return need <= K
 }

From 88674e2b3c4b64eaed1add4cff334dd1788a76f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 22 Sep 2022 21:12:15 +0800
Subject: [PATCH 2346/3374] Update 774-minimize-max-distance-to-gas-station.js

---
 774-minimize-max-distance-to-gas-station.js | 102 ++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/774-minimize-max-distance-to-gas-station.js b/774-minimize-max-distance-to-gas-station.js
index 9eecda2b..20ee5131 100644
--- a/774-minimize-max-distance-to-gas-station.js
+++ b/774-minimize-max-distance-to-gas-station.js
@@ -28,3 +28,105 @@ const possible = (dis, res, K) => {
   }
   return need <= K
 }
+
+// another
+
+/**
+ * @param {number[]} stations
+ * @param {number} k
+ * @return {number}
+ */
+const minmaxGasDist = function(stations, k) {
+  const pq = new PriorityQueue((a, b) => a[0] > b[0])
+  for(let i = 1, n = stations.length; i < n; i++) {
+    const delta = stations[i] - stations[i - 1]
+    pq.push([delta, delta, 1])
+  }
+  const limit = (stations[stations.length - 1] - stations[0]) / k
+  // console.log(pq.heap)
+  while(k>0) {
+    let [delta, gap, num] = pq.pop()
+    
+    let v = gap / (num + 1)
+    while(k > 0 && gap / (num + 1) > limit) {
+      k--
+      num++
+    }
+    
+    v = gap / ++num
+    k--
+    
+    pq.push([v, gap, num])
+  }
+  
+  return pq.peek()[0]
+};
+
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From dd72980412fac8650215e03c8ff6a340566ad583 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Sep 2022 10:11:57 +0800
Subject: [PATCH 2347/3374] Update 207-course-schedule.js

---
 207-course-schedule.js | 43 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/207-course-schedule.js b/207-course-schedule.js
index 26831e37..09233baa 100644
--- a/207-course-schedule.js
+++ b/207-course-schedule.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {boolean}
+ */
+const canFinish = function (numCourses, prerequisites) {
+  const set = new Set()
+  const indegree = Array(numCourses).fill(0)
+  const graph = {}
+
+  for (const [s, e] of prerequisites) {
+    indegree[e]++
+    if (graph[s] == null) graph[s] = []
+    graph[s].push(e)
+  }
+
+  let q = []
+  for (let i = 0; i < numCourses; i++) {
+    if (indegree[i] === 0) q.push(i)
+  }
+
+  while (q.length) {
+    const nxt = []
+    for (let i = 0, size = q.length; i < size; i++) {
+      const cur = q[i]
+      set.add(cur)
+      for (const e of graph[cur] || []) {
+        indegree[e]--
+        if (indegree[e] === 0 && !set.has(e)) {
+          nxt.push(e)
+        }
+      }
+    }
+
+    q = nxt
+  }
+
+  return set.size === numCourses
+}
+
+// another
+
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From 91f1fe69146d1e5e9743c318728fb1efb5da67f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Sep 2022 11:10:46 +0800
Subject: [PATCH 2348/3374] Update 210-course-schedule-ii.js

---
 210-course-schedule-ii.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/210-course-schedule-ii.js b/210-course-schedule-ii.js
index f9c01679..350c4d33 100644
--- a/210-course-schedule-ii.js
+++ b/210-course-schedule-ii.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+const findOrder = function(numCourses, prerequisites) {
+  const graph = {}, inDegree = Array(numCourses).fill(0)
+  for(const [s, e] of prerequisites) {
+    inDegree[s]++
+    if(graph[e] == null) graph[e] = []
+    graph[e].push(s)
+  }
+  
+  const res = []
+  let q = []
+  for(let i = 0; i < numCourses; i++) {
+    if(inDegree[i] === 0) q.push(i)
+  }
+  
+  while(q.length) {
+    const nxt = []
+    for(let i = 0; i < q.length; i++) {
+      const cur = q[i]
+      res.push(cur)
+      for(const e of (graph[cur] || [])) {
+        inDegree[e]--
+        if(inDegree[e] === 0) nxt.push(e)
+      }
+    }
+    q = nxt
+  }
+  
+  return res.length === numCourses ? res : []
+}
+
+// another
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From d3d7ba2a2b36efb3dbccb5d892427cdfd194493b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Sep 2022 21:43:50 +0800
Subject: [PATCH 2349/3374] Create 1584-min-cost-to-connect-all-points.js

---
 1584-min-cost-to-connect-all-points.js | 36 ++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 1584-min-cost-to-connect-all-points.js

diff --git a/1584-min-cost-to-connect-all-points.js b/1584-min-cost-to-connect-all-points.js
new file mode 100644
index 00000000..b493e888
--- /dev/null
+++ b/1584-min-cost-to-connect-all-points.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const minCostConnectPoints = function(points) {
+    let minIndex,minDistance=Number.MAX_SAFE_INTEGER,sum=0;
+    let distanceMap={};
+    let prevouslyTakenIndex = 0,taken=1,takenMap={};
+    for(let i=1;i<points.length;i++){
+        distanceMap[i]=Number.MAX_SAFE_INTEGER;
+    }
+    takenMap[prevouslyTakenIndex]=true;
+    while(taken<points.length){
+        minDistance=Number.MAX_SAFE_INTEGER;
+        for(let i=1;i<points.length;i++){
+            if(takenMap[i]!==undefined){
+                continue;
+            }
+            let d = getDistance(prevouslyTakenIndex,i);
+            distanceMap[i]=Math.min(distanceMap[i],d);
+            if(distanceMap[i]<minDistance){
+                minDistance = distanceMap[i];
+                minIndex = i;
+            }
+        }
+        sum+=minDistance;
+        prevouslyTakenIndex = minIndex;
+        takenMap[prevouslyTakenIndex]=true;
+        taken++;
+    }
+    return sum;
+    
+    function getDistance(i,j){
+        return Math.abs(points[i][0]-points[j][0])+Math.abs(points[i][1]-points[j][1])
+    }
+};

From e81869f74202a01dabd62cd1f4a71007d6ee7ef0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Sep 2022 13:44:12 +0800
Subject: [PATCH 2350/3374] Create 2421-number-of-good-paths.js

---
 2421-number-of-good-paths.js | 66 ++++++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 2421-number-of-good-paths.js

diff --git a/2421-number-of-good-paths.js b/2421-number-of-good-paths.js
new file mode 100644
index 00000000..cc0cd7f1
--- /dev/null
+++ b/2421-number-of-good-paths.js
@@ -0,0 +1,66 @@
+
+///////////////////////////////////////////////////// Template ///////////////////////////////////////////////////////////////////////
+const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };
+const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
+
+function DJSet(n) {
+    // parent[i] < 0, -parent[i] is the group size which root is i. example: (i -> parent[i] -> parent[parent[i]] -> parent[parent[parent[i]]] ...)
+    // parent[i] >= 0, i is not the root and parent[i] is i's parent. example: (... parent[parent[parent[i]]] -> parent[parent[i]] -> parent[i] -> i)
+    let parent = Array(n).fill(-1);
+    return { find, union, count, equiv, par }
+    function find(x) {
+        return parent[x] < 0 ? x : parent[x] = find(parent[x]);
+    }
+    function union(x, y) {
+        x = find(x);
+        y = find(y);
+        if (x == y) return false;
+        if (parent[x] < parent[y]) [x, y] = [y, x];
+        parent[x] += parent[y];
+        parent[y] = x;
+        return true;
+    }
+    function count() { // total groups
+        return parent.filter(v => v < 0).length;
+    }
+    function equiv(x, y) { // isConnected
+        return find(x) == find(y);
+    }
+    function par() {
+        return parent;
+    }
+}
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+/**
+ * @param {number[]} vals
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const numberOfGoodPaths = (a, edges) => {
+    let n = a.length, g = initializeGraph(n), f = Array(n).fill(0), ds = new DJSet(n), res = 0;
+    packUG(g, edges);
+    let d = a.map((x, i) => [x, i]);
+    d.sort((x, y) => {
+        if (x[0] != y[0]) return x[0] - y[0];
+        return x[1] - y[1];
+    })
+    for (let r = 0; r < n;) { // l: start node  r: end node
+        let l = r;
+        while (r < n && d[l][0] == d[r][0]) r++; // condition 1
+        for (let i = l; i < r; i++) {
+            let cur = d[i][1];
+            for (const child of g[cur]) {
+                if (a[child] <= d[l][0]) ds.union(child, cur); // condition 2
+            }
+        }
+        for (let i = l; i < r; i++) { // loop the path
+            let cur = d[i][1];
+            res += ++f[ds.find(cur)];
+        }
+        for (let i = l; i < r; i++) {
+            let cur = d[i][1];
+            f[ds.find(cur)]--;
+        }
+    }
+    return res;
+};

From 0780568bc936f331bc6f2cf61a52028bd70f5d60 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Sep 2022 13:44:48 +0800
Subject: [PATCH 2351/3374] Create 2420-find-all-good-indices.js

---
 2420-find-all-good-indices.js | 38 +++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2420-find-all-good-indices.js

diff --git a/2420-find-all-good-indices.js b/2420-find-all-good-indices.js
new file mode 100644
index 00000000..e2e4ded1
--- /dev/null
+++ b/2420-find-all-good-indices.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[]}
+ */
+const goodIndices = function(nums, k) {
+  const n = nums.length
+  const pre = Array(n).fill(1), post = Array(n).fill(1)
+  
+  let preV = nums[0], cnt = 1
+  for(let i = 1; i < n; i++) {
+    if(nums[i] <= preV) cnt++
+    else {
+      cnt = 1
+    }
+    pre[i] = cnt
+    preV = nums[i]
+  }
+
+  preV = nums[n - 1], cnt = 1
+  for(let i = n - 2; i >= 0; i--) {
+    if(nums[i] <= preV) cnt++
+    else {
+      cnt = 1
+    }
+    post[i] = cnt
+    preV = nums[i]
+  }
+  // console.log(pre, post)
+  
+  const res = []
+  
+  for(let i = 1; i < n; i++) {
+    if(pre[i - 1] >= k && post[i + 1] >= k) res.push(i)
+  }
+  
+  return res
+};

From 34b185e8b9ac3d3f796443e3b606c875644a6659 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Sep 2022 13:45:13 +0800
Subject: [PATCH 2352/3374] Create
 2419-longest-subarray-with-maximum-bitwise-and.js

---
 ...ngest-subarray-with-maximum-bitwise-and.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2419-longest-subarray-with-maximum-bitwise-and.js

diff --git a/2419-longest-subarray-with-maximum-bitwise-and.js b/2419-longest-subarray-with-maximum-bitwise-and.js
new file mode 100644
index 00000000..9decbac8
--- /dev/null
+++ b/2419-longest-subarray-with-maximum-bitwise-and.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const longestSubarray = function(nums) {
+  const max = Math.max(...nums)
+  const arr = []
+  for(let i = 0; i < nums.length; i++) {
+    if(nums[i] === max) arr.push(i)
+  }
+  let res = 1, cur = 1
+  for(let i = 1; i < arr.length; i++) {
+    if(arr[i] - arr[i - 1] === 1) cur++
+    else {
+      cur = 1
+    }
+    
+    res = Math.max(res, cur)
+  }
+  
+  return res
+};

From a215ded17416cc8c31dc35a1a9c41f43fa83fd93 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Sep 2022 13:45:38 +0800
Subject: [PATCH 2353/3374] Create 2418-sort-the-people.js

---
 2418-sort-the-people.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2418-sort-the-people.js

diff --git a/2418-sort-the-people.js b/2418-sort-the-people.js
new file mode 100644
index 00000000..5eebafe6
--- /dev/null
+++ b/2418-sort-the-people.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string[]} names
+ * @param {number[]} heights
+ * @return {string[]}
+ */
+var sortPeople = function(names, heights) {
+  const n = names.length
+  const arr = []
+  for(let i = 0; i <n; i++) {
+    arr.push([names[i], heights[i]])
+  }
+  
+  arr.sort((a, b) => a[1] - b[1])
+  arr.reverse()
+  return arr.map(e => e[0])
+};

From 65b3b74a093ab83215edd511e0aa1ee7e6a2fe6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Sep 2022 19:35:54 +0800
Subject: [PATCH 2354/3374] Update 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 58 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index 3d882210..abbcaf55 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -1,3 +1,61 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const checkIfPrerequisite = function (numCourses, prerequisites, queries) {
+  const n = numCourses, m = prerequisites.length
+  const graph = {}, inDegree = Array(n).fill(0)
+  
+  for(const [s, e] of prerequisites) {
+    if(graph[s] == null) graph[s] = []
+    inDegree[e]++
+    graph[s].push(e)
+  }
+  
+  let q = []
+  
+  for(let i = 0; i < n; i++) {
+    if(inDegree[i] === 0) q.push(i)
+  }
+  
+  const hash = {}
+
+  while(q.length) {
+    const size = q.length
+    const nxt = []
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (graph[cur] || [])) {
+        inDegree[e]--
+        if(hash[e] == null) hash[e] = new Set()
+        hash[e].add(cur)
+        for(const dep of (hash[cur] || [])) {
+          hash[e].add(dep)
+        }
+      
+        if(inDegree[e] === 0) {
+          nxt.push(e)
+        }
+      }
+    }
+    
+    q = nxt
+  }
+  
+  const res = []
+  for(const [p, e] of queries) {
+    if(hash[e] && hash[e].has(p)) res.push(true)
+    else res.push(false)
+  }
+  
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From 0243cddaf8000ec497105146531c51792df419c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Sep 2022 14:43:20 +0800
Subject: [PATCH 2355/3374] Update 1136-parallel-courses.js

---
 1136-parallel-courses.js | 47 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1136-parallel-courses.js b/1136-parallel-courses.js
index 4b6b6db5..6f727b6e 100644
--- a/1136-parallel-courses.js
+++ b/1136-parallel-courses.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @return {number}
+ */
+const minimumSemesters = function (n, relations) {
+  const inDegree = Array(n + 1).fill(0)
+  const graph = {}
+  for(const [prev, nxt] of relations) {
+    if(graph[prev] == null) graph[prev] = []
+    graph[prev].push(nxt)
+
+    inDegree[nxt]++
+  }
+
+  let q = []
+  for(let i = 1; i <= n; i++) {
+    if(inDegree[i] === 0) q.push(i)
+  }
+
+// console.log(inDegree)
+  let res = 0, cnt = 0
+  while(q.length) {
+    const size = q.length, nxt = []
+
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (graph[cur] || [])) {
+        inDegree[e]--
+        if(inDegree[e] === 0) {
+          nxt.push(e)
+        }
+      }
+    }
+    res++
+    cnt += size
+    q = nxt
+    // console.log(nxt)
+  }
+// console.log(cnt, res)
+
+  return cnt === n ? res : -1
+}
+
+
+// another
+
 /**
  * @param {number} N
  * @param {number[][]} relations

From 7d37a0616735ecb3229d691cb3d4b9c704ae6b99 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 Sep 2022 20:03:41 +0800
Subject: [PATCH 2356/3374] Update
 105-construct-binary-tree-from-preorder-and-inorder-traversal.js

---
 ...ree-from-preorder-and-inorder-traversal.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/105-construct-binary-tree-from-preorder-and-inorder-traversal.js b/105-construct-binary-tree-from-preorder-and-inorder-traversal.js
index a7c58a06..beebb4af 100644
--- a/105-construct-binary-tree-from-preorder-and-inorder-traversal.js
+++ b/105-construct-binary-tree-from-preorder-and-inorder-traversal.js
@@ -1,3 +1,36 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {number[]} preorder
+ * @param {number[]} inorder
+ * @return {TreeNode}
+ */
+const buildTree = function(preorder, inorder) {
+  if(preorder.length === 0 && inorder.length === 0) return null
+  const val = preorder[0]
+  const node = new TreeNode(val)
+  const inIdx = inorder.indexOf(val)
+  const leftIn = inorder.slice(0, inIdx)
+  const rightIn = inorder.slice(inIdx + 1)
+  
+  const leftPre = preorder.slice(1, leftIn.length + 1)
+  const rightPre = preorder.slice(leftIn.length + 1)
+  
+  // console.log(leftIn, rightIn, leftPre, rightPre)
+  node.left = buildTree(leftPre, leftIn)
+  node.right = buildTree(rightPre, rightIn)
+  return node
+};
+
+
+// another
+
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 2757785b3ce2aaa48d84131572b5cee32c4c8a04 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Sep 2022 10:27:37 +0800
Subject: [PATCH 2357/3374] Update 2050-parallel-courses-iii.js

---
 2050-parallel-courses-iii.js | 45 ++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/2050-parallel-courses-iii.js b/2050-parallel-courses-iii.js
index 97ad7213..1be35f37 100644
--- a/2050-parallel-courses-iii.js
+++ b/2050-parallel-courses-iii.js
@@ -1,3 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+const minimumTime = function (n, relations, time) {
+  const inDegree = Array(n + 1).fill(0)
+  const graph = {}, dist = Array(n + 1).fill(0)
+  
+  for(const [pre, nxt] of relations) {
+    if(graph[pre] == null) graph[pre] = []
+    graph[pre].push(nxt)
+    inDegree[nxt]++
+  }
+
+  let q = []
+  for(let i = 1;i <=n;i++) {
+    if(inDegree[i]===0) {
+      q.push(i)
+      dist[i] = time[i - 1]
+    }
+  }
+  while(q.length) {
+    const size = q.length, nxt = []
+
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (graph[cur] || [])) {
+        dist[e] = Math.max(dist[e], dist[cur] + time[e - 1])
+        inDegree[e]--
+        if(inDegree[e] === 0) {
+          nxt.push(e)
+        }
+      }
+    }
+
+    q = nxt
+  }
+
+  return Math.max(...dist)
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} relations

From c32ea2fd39ca7a86c3cf057f0a9db38d207454ed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Sep 2022 12:33:37 +0800
Subject: [PATCH 2358/3374] Create 2268-minimum-number-of-keypresses.js

---
 2268-minimum-number-of-keypresses.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2268-minimum-number-of-keypresses.js

diff --git a/2268-minimum-number-of-keypresses.js b/2268-minimum-number-of-keypresses.js
new file mode 100644
index 00000000..c2db66f7
--- /dev/null
+++ b/2268-minimum-number-of-keypresses.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minimumKeypresses = function (s) {
+  const freq = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for (const e of s) {
+    freq[e.charCodeAt(0) - a]++
+  }
+  let res = 0
+  freq.sort((a, b) => b - a)
+
+  // console.log(freq)
+  for (let i = 0; i < 26; i++) {
+    if (freq[i] === 0) break
+    const step = 1 + Math.floor(i / 9)
+    const val = step * freq[i]
+    res += val
+  }
+
+  return res
+}

From 9a96c5d2694609d5bb93db8faf61d4885e3798a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Sep 2022 13:32:40 +0800
Subject: [PATCH 2359/3374] Create
 2340-minimum-adjacent-swaps-to-make-a-valid-array.js

---
 ...um-adjacent-swaps-to-make-a-valid-array.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2340-minimum-adjacent-swaps-to-make-a-valid-array.js

diff --git a/2340-minimum-adjacent-swaps-to-make-a-valid-array.js b/2340-minimum-adjacent-swaps-to-make-a-valid-array.js
new file mode 100644
index 00000000..9163ca49
--- /dev/null
+++ b/2340-minimum-adjacent-swaps-to-make-a-valid-array.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumSwaps = function (nums) {
+  const mi = Math.min(...nums)
+  const ma = Math.max(...nums)
+  let minIdx = -1, maxIdx = -1
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    if(nums[i] === mi) {
+      minIdx = i
+      break
+    }
+  }
+  for(let i = n - 1; i >= 0; i--) {
+    if(nums[i] === ma) {
+      maxIdx = i
+      break
+    }
+  }
+
+  const num = minIdx + n - 1 - maxIdx
+  return minIdx > maxIdx ? num - 1 : num
+}

From 46be45ba38c271febe148b3c9a08b6f5911b3b2d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Sep 2022 15:21:14 +0800
Subject: [PATCH 2360/3374] Create
 1061-lexicographically-smallest-equivalent-string.js

---
 ...ographically-smallest-equivalent-string.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 1061-lexicographically-smallest-equivalent-string.js

diff --git a/1061-lexicographically-smallest-equivalent-string.js b/1061-lexicographically-smallest-equivalent-string.js
new file mode 100644
index 00000000..8672746c
--- /dev/null
+++ b/1061-lexicographically-smallest-equivalent-string.js
@@ -0,0 +1,47 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @param {string} baseStr
+ * @return {string}
+ */
+var smallestEquivalentString = function (s1, s2, baseStr) {
+  if (s1.length === 0 || s2.length === 0) return ''
+  const uf = new UnionFind()
+  for (let i = 0; i < s1.length; i++) {
+    uf.union(s1[i], s2[i])
+  }
+  let res = ''
+  for (const ch of baseStr) {
+    res += uf.find(ch) || ch // some letters don't have connected component
+  }
+  return res
+}
+class UnionFind {
+  constructor() {
+    this.parents = new Map()
+  }
+  find(x) {
+    if (this.parents.get(x) === x) return x
+    this.parents.set(x, this.find(this.parents.get(x))) // path compression
+    return this.parents.get(x)
+  }
+  union(u, v) {
+    // init
+    if (!this.parents.has(u)) {
+      this.parents.set(u, u)
+    }
+    if (!this.parents.has(v)) {
+      this.parents.set(v, v)
+    }
+    // find root
+    const rootU = this.find(u)
+    const rootV = this.find(v)
+    if (rootU === rootV) return // connected already
+    // set smallest lex as the root
+    if (rootU > rootV) {
+      this.parents.set(rootU, rootV)
+    } else {
+      this.parents.set(rootV, rootU)
+    }
+  }
+}

From 71678f3ebe2131566349d09b04863bc627504917 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 10:14:47 +0800
Subject: [PATCH 2361/3374] Update 310-minimum-height-trees.js

---
 310-minimum-height-trees.js | 39 +++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/310-minimum-height-trees.js b/310-minimum-height-trees.js
index 2a49c6ff..cb725c28 100644
--- a/310-minimum-height-trees.js
+++ b/310-minimum-height-trees.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const findMinHeightTrees = function (n, edges) {
+  const hash = {}
+
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = new Set()
+    if(graph[v] == null) graph[v] = new Set()
+    graph[u].add(v)
+    graph[v].add(u)
+  }
+
+  let q = []
+  for(let i = 0; i < n; i++) {
+    if(hash[i].size === 1) q.push(i)
+  }
+
+  while(n > 2) {
+    const size = q.length, nxt = []
+    n -= size
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (hash[cur] || [])) {
+        graph[e].delete(cur)
+        if(graph[e].size === 1) nxt.push(e)
+      }
+    }
+
+    q = nxt
+  }
+
+  return q
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 1b7a2d0a8a3e6220020361f12ec21b08d5b75557 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 10:16:59 +0800
Subject: [PATCH 2362/3374] Update 310-minimum-height-trees.js

---
 310-minimum-height-trees.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/310-minimum-height-trees.js b/310-minimum-height-trees.js
index cb725c28..eeaa1111 100644
--- a/310-minimum-height-trees.js
+++ b/310-minimum-height-trees.js
@@ -4,7 +4,7 @@
  * @return {number[]}
  */
 const findMinHeightTrees = function (n, edges) {
-  const hash = {}
+  const graph = {}
 
   for(const [u, v] of edges) {
     if(graph[u] == null) graph[u] = new Set()
@@ -15,7 +15,7 @@ const findMinHeightTrees = function (n, edges) {
 
   let q = []
   for(let i = 0; i < n; i++) {
-    if(hash[i].size === 1) q.push(i)
+    if(graph[i].size === 1) q.push(i)
   }
 
   while(n > 2) {
@@ -23,7 +23,7 @@ const findMinHeightTrees = function (n, edges) {
     n -= size
     for(let i = 0; i < size; i++) {
       const cur = q[i]
-      for(const e of (hash[cur] || [])) {
+      for(const e of (graph[cur] || [])) {
         graph[e].delete(cur)
         if(graph[e].size === 1) nxt.push(e)
       }

From 61068fcae8c3a19293da7dd770ea749bf29ffc7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 10:49:13 +0800
Subject: [PATCH 2363/3374] Add files via upload

---
 images/310.jpeg | Bin 0 -> 41496 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/310.jpeg

diff --git a/images/310.jpeg b/images/310.jpeg
new file mode 100644
index 0000000000000000000000000000000000000000..94f48a59e9c8a1ce4ae7f3b1384e4e09a02b0cb2
GIT binary patch
literal 41496
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
YemSX1c?I@3vGaPAU)B8I1?A)a+59b@tN;K2

literal 0
HcmV?d00001


From 1554d4be8cf1a93e2ccf02af435a877d0b393d42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 13:09:56 +0800
Subject: [PATCH 2364/3374] Create 969-pancake-sorting.js

---
 969-pancake-sorting.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 969-pancake-sorting.js

diff --git a/969-pancake-sorting.js b/969-pancake-sorting.js
new file mode 100644
index 00000000..2404c612
--- /dev/null
+++ b/969-pancake-sorting.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+ const pancakeSort = function (arr) {
+  const res = []
+  let n = arr.length
+  while(n) {
+    const idx = indexOf(0, n - 1, n)
+    if(idx === n - 1) {
+      n--
+    } else {
+      flip(0, idx)
+      flip(0, n - 1)
+      res.push(idx + 1, n)
+      n--
+    }
+  }
+  return res
+
+  function flip(l, r) {
+    while(l < r) {
+      const tmp = arr[l]
+      arr[l] = arr[r]
+      arr[r] = tmp
+      l++
+      r--
+    }
+  }
+
+  function indexOf(start, end, target) {
+    let res = -1
+    for(let i = start; i <= end; i++) {
+      if(arr[i]===target) {
+        res = i
+        break
+      }
+    }
+    return res
+  }
+}

From aa13f37fba7e820d9e55fc0d4a88560a22e7f5ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 14:57:24 +0800
Subject: [PATCH 2365/3374] Create 1257-smallest-common-region.js

---
 1257-smallest-common-region.js | 40 ++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 1257-smallest-common-region.js

diff --git a/1257-smallest-common-region.js b/1257-smallest-common-region.js
new file mode 100644
index 00000000..304e4175
--- /dev/null
+++ b/1257-smallest-common-region.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string[][]} regions
+ * @param {string} region1
+ * @param {string} region2
+ * @return {string}
+ */
+const findSmallestRegion = function (regions, region1, region2) {
+  const hash = {}
+  for(const arr of regions) {
+    const p = arr[0]
+    const size = arr.length
+    for(let i = 1; i < size; i++) {
+      const e = arr[i]
+      if(hash[e] == null) hash[e] = []
+      hash[e].push(p)
+    }
+  }
+
+  const path1 = [region1], path2 = [region2]
+  traverse(region1, path1)
+  traverse(region2, path2)
+
+  let i = path1.length - 1, j = path2.length - 1
+  while(i >= 0 && j >= 0) {
+    if(path1[i] !== path2[j]) break
+    else {
+      i--
+      j--
+    }
+  }
+
+  return path1[i + 1]
+
+  function traverse(node, res) {
+    if(hash[node] == null) return
+    res.push(hash[node][0])
+    traverse(hash[node][0], res)
+  }
+
+}

From c74ef858a3d0c2a8598f9173dc57d90130607c8f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 15:28:29 +0800
Subject: [PATCH 2366/3374] Create 1492-the-kth-factor-of-n.js

---
 1492-the-kth-factor-of-n.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 1492-the-kth-factor-of-n.js

diff --git a/1492-the-kth-factor-of-n.js b/1492-the-kth-factor-of-n.js
new file mode 100644
index 00000000..e6f49916
--- /dev/null
+++ b/1492-the-kth-factor-of-n.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const kthFactor = function (n, k) {
+  let d = 1
+  for (; d * d <= n; ++d) {
+    if (n % d == 0) {
+      if (--k == 0) {
+        return d
+      }
+    }
+  }
+  for (d = d - 1; d >= 1; d--) {
+    if (d * d == n) continue
+    if (n % d == 0) {
+      k--
+      if (k == 0) {
+        return n / d
+      }
+    }
+  }
+  return -1
+}

From 61194de8d42ae8f91c883db258c343a583451ec9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 16:37:00 +0800
Subject: [PATCH 2367/3374] Update 1492-the-kth-factor-of-n.js

---
 1492-the-kth-factor-of-n.js | 21 ++++++++++-----------
 1 file changed, 10 insertions(+), 11 deletions(-)

diff --git a/1492-the-kth-factor-of-n.js b/1492-the-kth-factor-of-n.js
index e6f49916..82dde379 100644
--- a/1492-the-kth-factor-of-n.js
+++ b/1492-the-kth-factor-of-n.js
@@ -5,21 +5,20 @@
  */
 const kthFactor = function (n, k) {
   let d = 1
-  for (; d * d <= n; ++d) {
-    if (n % d == 0) {
-      if (--k == 0) {
-        return d
-      }
+  for (let i = 1; i * i < n; i++) {
+    if (n % i === 0) {
+      k--
+      if (k === 0) return i
     }
   }
-  for (d = d - 1; d >= 1; d--) {
-    if (d * d == n) continue
-    if (n % d == 0) {
+
+  for (let i = ~~Math.sqrt(n); i >= 1; i--) {
+    if (n % ~~(n / i) === 0) {
       k--
-      if (k == 0) {
-        return n / d
-      }
+      // console.log(n, i, n/i, n % (n / i))
+      if (k === 0) return n / i
     }
   }
+
   return -1
 }

From 48ec339114063128f40e1c5de8a9a40eeb2c0ee8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 21:38:03 +0800
Subject: [PATCH 2368/3374] Create 1530-number-of-good-leaf-nodes-pairs.js

---
 1530-number-of-good-leaf-nodes-pairs.js | 34 +++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1530-number-of-good-leaf-nodes-pairs.js

diff --git a/1530-number-of-good-leaf-nodes-pairs.js b/1530-number-of-good-leaf-nodes-pairs.js
new file mode 100644
index 00000000..e46cf854
--- /dev/null
+++ b/1530-number-of-good-leaf-nodes-pairs.js
@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} distance
+ * @return {number}
+ */
+const countPairs = function(root, distance) {
+  let res = 0
+  traverse(root)
+  return res
+  
+  
+  function traverse(node) {
+    if(node == null) return []
+    if(node.left == null && node.right == null) return [0]
+    
+    const left = traverse(node.left)
+    const right = traverse(node.right)
+    for(let i = 0; i < left.length; i++) {
+      for(let j = 0; j < right.length; j++) {
+        if(left[i] + right[j] + 2 <= distance) res++
+      }
+    }
+    
+    return [...left.map(e => e + 1), ...right.map(e => e + 1)]
+  }
+};

From bc735c90b48236fb9cb390088a1a96c4bd39d93f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Sep 2022 22:38:52 +0800
Subject: [PATCH 2369/3374] Create
 1493-longest-subarray-of-1s-after-deleting-one-element.js

---
 ...barray-of-1s-after-deleting-one-element.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 1493-longest-subarray-of-1s-after-deleting-one-element.js

diff --git a/1493-longest-subarray-of-1s-after-deleting-one-element.js b/1493-longest-subarray-of-1s-after-deleting-one-element.js
new file mode 100644
index 00000000..b0395643
--- /dev/null
+++ b/1493-longest-subarray-of-1s-after-deleting-one-element.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const longestSubarray = function(nums) {
+  const n = nums.length
+  let res = 0
+  const pre = Array(n).fill(0)
+  const suf = Array(n).fill(0)
+  
+  let cnt = 0, hasZero = false
+  for(let i = 0; i < n; i++) {
+    if(nums[i] === 1) {
+      cnt++
+      pre[i] = cnt
+      res = Math.max(res, cnt)
+    } else {
+      hasZero = true
+      cnt = 0
+      pre[i] = cnt
+    }
+  }
+  if(!hasZero) res--
+  
+  cnt = 0
+  
+  for(let i = n - 1; i >= 0; i--) {
+    if(nums[i] === 1) {
+      cnt++
+      suf[i] = cnt
+
+    } else {
+      cnt = 0
+      suf[i] = cnt
+
+    }
+  }
+  // console.log(pre,suf)
+  for(let i = 1; i < n - 1; i++) {
+    if(nums[i] === 0) {
+      res = Math.max(res, pre[i - 1] + suf[i + 1])
+    }
+  }
+  
+  
+  return res
+};

From b142dbe6e4f0294bb502d38ddf8dea99bf1ec780 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 10:35:11 +0800
Subject: [PATCH 2370/3374] Update 802-find-eventual-safe-states.js

---
 802-find-eventual-safe-states.js | 33 ++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/802-find-eventual-safe-states.js b/802-find-eventual-safe-states.js
index d55d224e..f1d74624 100644
--- a/802-find-eventual-safe-states.js
+++ b/802-find-eventual-safe-states.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+const eventualSafeNodes = function (graph) {
+  const ing = {},
+    n = graph.length
+  const outDegree = Array(n).fill(0)
+  let q = []
+  for (let i = 0; i < n; i++) {
+    outDegree[i] = graph[i].length
+    if (outDegree[i] === 0) {
+      q.push(i)
+    }
+    for (const e of graph[i]) {
+      if (ing[e] == null) ing[e] = []
+      ing[e].push(i)
+    }
+  }
+
+  for (const term of q) {
+    for (const come of ing[term] || []) {
+      outDegree[come]--
+      if (outDegree[come] === 0) q.push(come)
+    }
+  }
+  q.sort((a, b) => a - b)
+  return q
+}
+
+// another
+
+
 /**
  * @param {number[][]} graph
  * @return {number[]}

From d908f88637e6478e6c7bd71fe894a19128d59b1d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 12:01:33 +0800
Subject: [PATCH 2371/3374] Update 322-coin-change.js

---
 322-coin-change.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/322-coin-change.js b/322-coin-change.js
index 3dadaa50..0c795775 100644
--- a/322-coin-change.js
+++ b/322-coin-change.js
@@ -13,3 +13,29 @@ const coinChange = function(coins, amount) {
   }
   return dp[amount] === amount + 1 ? -1 : dp[amount]
 }
+
+
+// another
+
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+const coinChange = function (coins, amount) {
+  const n = coins.length
+  const dp = Array.from({ length: n }, () =>
+    Array(amount + 1).fill(Infinity)
+  )
+
+  for (let i = 0; i < n; i++) {
+    dp[i][0] = 0
+    for (let j = 1; j <= amount; j++) {
+      if(i > 0) dp[i][j] = dp[i - 1][j]
+      if (j >= coins[i]) {
+        dp[i][j] = Math.min(dp[i][j], dp[i][j - coins[i]] + 1)
+      }
+    }
+  }
+  return dp[n - 1][amount] === Infinity ? -1 : dp[n - 1][amount]
+}

From fcf2f3f17eca7f22550cd2a060c2c7caba7d01ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 13:57:28 +0800
Subject: [PATCH 2372/3374] Create
 1461-check-if-a-string-contains-all-binary-codes-of-size-k.js

---
 ...a-string-contains-all-binary-codes-of-size-k.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 1461-check-if-a-string-contains-all-binary-codes-of-size-k.js

diff --git a/1461-check-if-a-string-contains-all-binary-codes-of-size-k.js b/1461-check-if-a-string-contains-all-binary-codes-of-size-k.js
new file mode 100644
index 00000000..f05d3edf
--- /dev/null
+++ b/1461-check-if-a-string-contains-all-binary-codes-of-size-k.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {boolean}
+ */
+const hasAllCodes = function (s, k) {
+  if (s.length < k) return false
+  const set = new Set()
+  for (let i = 0; i <= s.length - k; i++) {
+    set.add(s.slice(i, i + k))
+  }
+
+  return set.size == Math.pow(2, k)
+}

From 237c48505bbb8e87a2f17b03e5938bf0f1d970ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 14:20:10 +0800
Subject: [PATCH 2373/3374] Create
 967-numbers-with-same-consecutive-differences.js

---
 ...mbers-with-same-consecutive-differences.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 967-numbers-with-same-consecutive-differences.js

diff --git a/967-numbers-with-same-consecutive-differences.js b/967-numbers-with-same-consecutive-differences.js
new file mode 100644
index 00000000..8bd4a423
--- /dev/null
+++ b/967-numbers-with-same-consecutive-differences.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number[]}
+ */
+const numsSameConsecDiff = function (n, k) {
+  const res = []
+  
+  for(let i = 1; i <= 9; i++) {
+    dfs(n - 1, [i])
+  }
+ 
+  return res
+
+  function dfs(num, arr) {
+    if(num === 0) {
+      res.push(+arr.join(''))
+      return 
+    }
+
+    for(let i = 0; i <= 9; i++) {
+      if(Math.abs(i - arr[arr.length - 1]) === k) {
+        arr.push(i)
+        dfs(num - 1, arr)
+        arr.pop()
+      }
+    }
+  }
+}

From 20c00b7b08637d6ee1ef3030a5cd5deb57ea799e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 15:15:17 +0800
Subject: [PATCH 2374/3374] Create 1229-meeting-scheduler.js

---
 1229-meeting-scheduler.js | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 1229-meeting-scheduler.js

diff --git a/1229-meeting-scheduler.js b/1229-meeting-scheduler.js
new file mode 100644
index 00000000..4d86a9aa
--- /dev/null
+++ b/1229-meeting-scheduler.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[][]} slots1
+ * @param {number[][]} slots2
+ * @param {number} duration
+ * @return {number[]}
+ */
+const minAvailableDuration = function (slots1, slots2, duration) {
+  const hash = {}
+  for(const [s, e] of slots1) {
+    if(hash[s] == null) hash[s] = 0
+    if(hash[e] == null) hash[e] = 0
+
+    hash[s]++
+    hash[e]--
+  }
+
+  for(const [s, e] of slots2) {
+    if(hash[s] == null) hash[s] = 0
+    if(hash[e] == null) hash[e] = 0
+
+    hash[s]++
+    hash[e]--
+  }
+
+  const keys = Object.keys(hash).map(e => +e)
+  keys.sort((a, b) => a - b)
+  for(let i = 1; i < keys.length; i++) {
+    hash[keys[i]] += hash[keys[i - 1]]
+  }
+    // console.log(keys, hash)
+  const n = keys.length
+  for(let i = 0; i < keys.length; i++) {
+    const k = keys[i]
+    if(hash[k] === 2 && i + 1 < n && valid(k, i)) {
+      return [k, k + duration]
+    }
+  }
+
+  return []
+  
+  function valid(k, idx) {
+    let l = k, r = k + duration
+    for(let i = idx + 1; i < keys.length && keys[i] < r; i++) {
+      const key = keys[i]
+      if(hash[key] !== 2) return false
+    }
+
+    return true
+  }
+}

From 4038c09d779c014181be1a5bab6ad7b6b9a88e8d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Sep 2022 15:38:53 +0800
Subject: [PATCH 2375/3374] Update 1229-meeting-scheduler.js

---
 1229-meeting-scheduler.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1229-meeting-scheduler.js b/1229-meeting-scheduler.js
index 4d86a9aa..46d4c72e 100644
--- a/1229-meeting-scheduler.js
+++ b/1229-meeting-scheduler.js
@@ -48,3 +48,34 @@ const minAvailableDuration = function (slots1, slots2, duration) {
     return true
   }
 }
+
+// another
+
+/**
+ * @param {number[][]} slots1
+ * @param {number[][]} slots2
+ * @param {number} duration
+ * @return {number[]}
+ */
+const minAvailableDuration = function (slots1, slots2, duration) {
+  slots1.sort((a, b) => a[0] - b[0])
+  slots2.sort((a, b) => a[0] - b[0])
+
+  const m = slots1.length, n = slots2.length
+  let i = 0, j = 0
+
+  while(i < m && j < n) {
+    const start = Math.max(slots1[i][0], slots2[j][0])
+    const end = Math.min(slots1[i][1], slots2[j][1])
+
+    if(end - start >= duration) {
+      return [start, start + duration]
+    }
+
+    if(slots1[i][1] > slots2[j][1]) j++
+    else i++
+
+  }
+
+  return []
+}

From 2981694ea86aeb493a0d111af592f88e7f2a1be9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Sep 2022 22:40:06 +0800
Subject: [PATCH 2376/3374] Update
 2115-find-all-possible-recipes-from-given-supplies.js

---
 ...ll-possible-recipes-from-given-supplies.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/2115-find-all-possible-recipes-from-given-supplies.js b/2115-find-all-possible-recipes-from-given-supplies.js
index 2704f0cd..a0487254 100644
--- a/2115-find-all-possible-recipes-from-given-supplies.js
+++ b/2115-find-all-possible-recipes-from-given-supplies.js
@@ -38,3 +38,59 @@ const findAllRecipes = function(recipes, ingredients, supplies) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {string[]} recipes
+ * @param {string[][]} ingredients
+ * @param {string[]} supplies
+ * @return {string[]}
+ */
+const findAllRecipes = function(recipes, ingredients, supplies) {
+  const graph = {}
+  const n = recipes.length
+
+  const inDegree = {}
+  supplies = new Set(supplies)
+  for(const e of recipes) inDegree[e] = 0
+
+  let q = []
+  for(let i = 0; i < n; i++) {
+    const rec = recipes[i]
+    for(let e of ingredients[i]) {
+      if(!supplies.has(e)) {
+        if(graph[e] == null) graph[e] = []
+        graph[e].push(rec)
+        if(inDegree[e] == null) inDegree[e] = 0
+        inDegree[rec]++
+      }
+    }
+  }
+  // console.log(inDegree)
+  for(let i = 0; i < n; i++) {
+    if(inDegree[recipes[i]] === 0) {
+      q.push(recipes[i])
+    }
+  }
+  
+  // console.log(q)
+  const res = []  
+  while(q.length) {
+    const size = q.length
+    const nxt = []
+    
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      res.push(cur)
+      for(const e of (graph[cur] || [])) {
+        inDegree[e]--
+        if(inDegree[e] === 0) nxt.push(e)
+      }
+    }
+    
+    q = nxt
+  }
+
+  return res
+};

From b20972202aed3bd69c673563e829da92f160aa02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Sep 2022 22:43:18 +0800
Subject: [PATCH 2377/3374] Update
 2115-find-all-possible-recipes-from-given-supplies.js

---
 2115-find-all-possible-recipes-from-given-supplies.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/2115-find-all-possible-recipes-from-given-supplies.js b/2115-find-all-possible-recipes-from-given-supplies.js
index a0487254..856512dd 100644
--- a/2115-find-all-possible-recipes-from-given-supplies.js
+++ b/2115-find-all-possible-recipes-from-given-supplies.js
@@ -62,7 +62,6 @@ const findAllRecipes = function(recipes, ingredients, supplies) {
       if(!supplies.has(e)) {
         if(graph[e] == null) graph[e] = []
         graph[e].push(rec)
-        if(inDegree[e] == null) inDegree[e] = 0
         inDegree[rec]++
       }
     }

From 10ba14cc814c970220cf30a3c6c288f20c0872f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Oct 2022 18:38:37 +0800
Subject: [PATCH 2378/3374] Create
 2204-distance-to-a-cycle-in-undirected-graph.js

---
 ...distance-to-a-cycle-in-undirected-graph.js | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 2204-distance-to-a-cycle-in-undirected-graph.js

diff --git a/2204-distance-to-a-cycle-in-undirected-graph.js b/2204-distance-to-a-cycle-in-undirected-graph.js
new file mode 100644
index 00000000..a9ba46cc
--- /dev/null
+++ b/2204-distance-to-a-cycle-in-undirected-graph.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const distanceToCycle = function(n, edges) {
+  const hash = {}
+  let graph = new Map()
+  for(const [u, v] of edges) {
+    if(graph.get(u) == null) graph.set(u, new Set()) 
+    if(graph.get(v) == null) graph.set(v, new Set())
+    graph.get(u).add(v)
+    graph.get(v).add(u)
+  }
+  
+  const clonedGraph = new Map()
+  for(const [k, v] of graph) {
+    clonedGraph.set(k, new Set(v))
+  }
+  
+  let level = 0
+  let q = []
+  const visited = new Set()
+  for(const [k, v] of graph) {
+    if(graph.get(k).size === 1) {
+      q.push(k)  
+    }    
+  }
+
+  while(q.length) {
+    const size = q.length
+    const nxt = []
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (graph.get(cur) || [])) {
+        graph.get(e).delete(cur)
+        if(graph.get(e).size === 1) {
+          nxt.push(e)
+        }
+      }
+    }
+    q = nxt
+  }
+
+  q = []
+
+  visited.clear()
+  for(const [k, v] of graph) {
+    if(v.size === 2) {
+      q.push(k)
+      visited.add(k)
+    }
+  }
+  const res = Array(n).fill(0)  
+  graph = clonedGraph
+  while(q.length) {
+    level++
+    const size = q.length
+    const nxt = []
+    for(let i = 0; i < size; i++) {
+      const cur = q[i]
+      for(const e of (graph.get(cur) || [])) {
+        if(!visited.has(e)) {
+          nxt.push(e)
+          res[e] = level
+          visited.add(e)
+        }
+      }
+    }
+
+    q = nxt
+  }
+
+  return res
+};

From 79bdbf58e81f0adec89fdcfc36ac4c77ccca8cf8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Oct 2022 12:19:11 +0800
Subject: [PATCH 2379/3374] Create 2430-maximum-deletions-on-a-string.js

---
 2430-maximum-deletions-on-a-string.js | 35 +++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2430-maximum-deletions-on-a-string.js

diff --git a/2430-maximum-deletions-on-a-string.js b/2430-maximum-deletions-on-a-string.js
new file mode 100644
index 00000000..77c6684b
--- /dev/null
+++ b/2430-maximum-deletions-on-a-string.js
@@ -0,0 +1,35 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const deleteString = function (t) {
+  let n = t.length
+  const set = new Set(t.split(''))
+  if (set.size == 1) return n
+
+  let s = t.split('')
+  if (n === 1 || (n === 2 && s[0] !== s[1])) return 1
+  if (n === 2 && s[0] === s[1]) return 2
+  if (n === 3 && s[0] === s[1]) return s[1] === s[2] ? 3 : 2
+  else if (n === 3) return 1
+  const f = new Array(n).fill(null)
+  dfsSearchWithMemory(0)
+  return f[0]
+
+  function dfsSearchWithMemory(i) {
+    if (i >= n) return 0
+    if (f[i] !== null) return f[i]
+    if (i === n - 1) return (f[i] = 1)
+    let max = 0,
+      cur = 0,
+      j = i + 1
+    for (j = i + 1; j <= ~~((n - i) / 2 + i); j++) {
+      if (t.slice(j).startsWith(t.slice(i, j))) {
+        cur = 1 + dfsSearchWithMemory(j)
+        if (cur > max) max = cur
+      }
+    }
+    if (j > (n - i) / 2 + i && max === 0) return (f[i] = 1)
+    return (f[i] = max)
+  }
+}

From ccbc554863509d21ab0e6faf006240b0cbbba59d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Oct 2022 12:19:35 +0800
Subject: [PATCH 2380/3374] Create 2429-minimize-xor.js

---
 2429-minimize-xor.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2429-minimize-xor.js

diff --git a/2429-minimize-xor.js b/2429-minimize-xor.js
new file mode 100644
index 00000000..7677bf01
--- /dev/null
+++ b/2429-minimize-xor.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number} num1
+ * @param {number} num2
+ * @return {number}
+ */
+const minimizeXor = function(num1, num2) {
+  let num = 0
+  let n2 = num2
+  while(n2 > 0) {
+    if(n2 & 1 === 1) num++
+    n2 = n2 >>> 1
+  }
+  
+  let arr1 = num1.toString(2).split('').map(e => +e)
+  // console.log(arr1)
+  let res = Array(arr1.length).fill(0)
+  for(let i = 0; i < arr1.length && num > 0; i++) {
+    if(arr1[i] === 1) {
+      num--
+      res[i] = 1
+    }
+  }
+  
+  for(let i = arr1.length - 1; i >= 0 && num > 0; i--) {
+    if(arr1[i] === 0) {
+      num--
+      res[i] = 1
+    }
+  }
+  
+  while(num) {
+    res.unshift(1)
+    num--
+  }
+  
+  return Number.parseInt(res.join(''), 2)
+};

From 88c1579b5bac2ecdf39b304cbb831043354ee60d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Oct 2022 12:20:01 +0800
Subject: [PATCH 2381/3374] Create 2428-maximum-sum-of-an-hourglass.js

---
 2428-maximum-sum-of-an-hourglass.js | 30 +++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2428-maximum-sum-of-an-hourglass.js

diff --git a/2428-maximum-sum-of-an-hourglass.js b/2428-maximum-sum-of-an-hourglass.js
new file mode 100644
index 00000000..41f63b48
--- /dev/null
+++ b/2428-maximum-sum-of-an-hourglass.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxSum = function(grid) {
+  let res = 0 
+  const m = grid.length, n = grid[0].length
+  
+  for(let i = 0; i < m - 2; i++) {
+    for(let j = 0; j < n - 2; j++) {
+      res = Math.max(res, helper(i, j))
+    }
+  }
+  
+  return res
+  
+  function helper(i, j) {
+    let sum = 0
+    for(let r = i; r < i + 3; r++) {
+      for(let c = j; c < j + 3; c++) {
+        sum += grid[r][c]
+      }
+    }
+    sum -= grid[i + 1][j]
+    sum -= grid[i + 1][j + 2]
+    // console.log(sum)
+    
+    return sum
+  }
+};

From 9ad28ca4a425435ad8d7ae50e1fba0b86f32f7ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Oct 2022 12:20:32 +0800
Subject: [PATCH 2382/3374] Create 2427-number-of-common-factors.js

---
 2427-number-of-common-factors.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2427-number-of-common-factors.js

diff --git a/2427-number-of-common-factors.js b/2427-number-of-common-factors.js
new file mode 100644
index 00000000..162cba4a
--- /dev/null
+++ b/2427-number-of-common-factors.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @return {number}
+ */
+var commonFactors = function(a, b) {
+  let res = 0
+  const r = Math.max(a, b)
+  for(let i = 1; i <= r; i++) {
+    if(a % i === 0 && b % i === 0) res++
+  }
+  
+  return res
+};

From 99cec441c3387ae91444a95cb61ee32d20d10d98 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Oct 2022 19:45:14 +0800
Subject: [PATCH 2383/3374] Update 2392-build-a-matrix-with-conditions.js

---
 2392-build-a-matrix-with-conditions.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
index e1f8141e..8bd4d8ac 100644
--- a/2392-build-a-matrix-with-conditions.js
+++ b/2392-build-a-matrix-with-conditions.js
@@ -4,7 +4,7 @@
  * @param {number[][]} colConditions
  * @return {number[][]}
  */
-var buildMatrix = function (k, rowConditions, colConditions) {
+const buildMatrix = function (k, rowConditions, colConditions) {
   const res = Array.from({ length: k }, () => Array(k).fill(0))
 
   const row = khansAlgo(rowConditions, k)
@@ -13,7 +13,6 @@ var buildMatrix = function (k, rowConditions, colConditions) {
   const col = khansAlgo(colConditions, k)
   if (col.length != k) return []
 
-  // console.log(row, col)
   const idx = Array(k + 1).fill(0)
   for (let j = 0; j < col.length; j++) {
     idx[col[j]] = j
@@ -54,6 +53,7 @@ var buildMatrix = function (k, rowConditions, colConditions) {
 }
 
 
+
 // another
 
 /**

From dfc0ef621d527f24a8223184788b04ac3fab4ed4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Oct 2022 12:12:41 +0800
Subject: [PATCH 2384/3374] Update
 1857-largest-color-value-in-a-directed-graph.js

---
 ...largest-color-value-in-a-directed-graph.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index 3432baae..ed99ed48 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -1,3 +1,50 @@
+/**
+ * @param {string} colors
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const largestPathValue = function (colors, edges) {
+  const graph = {}
+  const n = colors.length,
+    a = 'a'.charCodeAt(0)
+  const indegree = Array(colors.length).fill(0)
+  for (let e of edges) {
+    if (graph[e[0]] == null) graph[e[0]] = []
+    graph[e[0]].push(e[1])
+    indegree[e[1]]++
+  }
+  // cnt[i][j] is the maximum count of j-th color from the ancester nodes to node i.
+  const cnt = Array.from({ length: n }, () => Array(26).fill(0))
+  const q = []
+  for (let i = 0; i < n; i++) {    
+    if (indegree[i] === 0) {
+      q.push(i)
+      cnt[i][colors.charCodeAt(i) - a] = 1
+    }
+  }
+  let res = 0,
+    seen = 0
+  while (q.length) {
+    const u = q[0]
+    q.shift()
+    const val = Math.max(...cnt[u])
+    res = Math.max(res, val)
+    seen++
+    for (let v of (graph[u] || [])) {
+      for (let i = 0; i < 26; i++) {
+        cnt[v][i] = Math.max(
+          cnt[v][i],
+          cnt[u][i] + (i === colors.charCodeAt(v) - a)
+        )
+      }
+      if (--indegree[v] === 0) q.push(v)
+    }
+  }
+  return seen < colors.length ? -1 : res
+}
+
+// another
+
 /**
  * @param {string} colors
  * @param {number[][]} edges

From 162b2d7b278b4817e65a7558b237083b97cd45e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Oct 2022 17:08:33 +0800
Subject: [PATCH 2385/3374] Update
 1203-sort-items-by-groups-respecting-dependencies.js

---
 ...items-by-groups-respecting-dependencies.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/1203-sort-items-by-groups-respecting-dependencies.js b/1203-sort-items-by-groups-respecting-dependencies.js
index e0e9ac0a..cd45660b 100644
--- a/1203-sort-items-by-groups-respecting-dependencies.js
+++ b/1203-sort-items-by-groups-respecting-dependencies.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number[]} group
+ * @param {number[][]} beforeItems
+ * @return {number[]}
+ */
+const sortItems = function (n, m, group, beforeItems) {
+  const graph = Array.from({ length: m + n }, () => [])
+  const indegree = Array(n + m).fill(0)
+  for (let i = 0; i < group.length; i++) {
+    if (group[i] == -1) continue
+    graph[n + group[i]].push(i)
+    indegree[i]++
+  }
+  for (let i = 0; i < beforeItems.length; i++) {
+    for (let e of beforeItems[i]) {
+      let a = group[e] === -1 ? e : n + group[e]
+      let b = group[i] === -1 ? i : n + group[i]
+      if (a === b) {
+        // same group, ingroup order
+        graph[e].push(i)
+        indegree[i]++
+      } else {
+        // outgoup order
+        graph[a].push(b)
+        indegree[b]++
+      }
+    }
+  }
+  const res = []
+  for (let i = 0; i < n + m; i++) {
+    if (indegree[i] === 0) dfs(res, graph, indegree, n, i)
+  }
+  return res.length === n ? res : []
+
+  function dfs(ans, graph, indegree, n, cur) {
+    if (cur < n) ans.push(cur)
+    indegree[cur] = -1 // mark it visited
+    for (let next of graph[cur] || []) {
+      indegree[next]--
+      if (indegree[next] === 0) dfs(ans, graph, indegree, n, next)
+    }
+  }
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number} m

From 8224571e6c2dc1dfce1ed5028228cf6256abab80 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Oct 2022 17:14:41 +0800
Subject: [PATCH 2386/3374] Update
 1203-sort-items-by-groups-respecting-dependencies.js

---
 1203-sort-items-by-groups-respecting-dependencies.js | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/1203-sort-items-by-groups-respecting-dependencies.js b/1203-sort-items-by-groups-respecting-dependencies.js
index cd45660b..0894cd98 100644
--- a/1203-sort-items-by-groups-respecting-dependencies.js
+++ b/1203-sort-items-by-groups-respecting-dependencies.js
@@ -14,9 +14,9 @@ const sortItems = function (n, m, group, beforeItems) {
     indegree[i]++
   }
   for (let i = 0; i < beforeItems.length; i++) {
-    for (let e of beforeItems[i]) {
-      let a = group[e] === -1 ? e : n + group[e]
-      let b = group[i] === -1 ? i : n + group[i]
+    for (const e of beforeItems[i]) {
+      const a = group[e] === -1 ? e : n + group[e]
+      const b = group[i] === -1 ? i : n + group[i]
       if (a === b) {
         // same group, ingroup order
         graph[e].push(i)
@@ -44,6 +44,7 @@ const sortItems = function (n, m, group, beforeItems) {
   }
 }
 
+
 // another
 
 

From cc1f49374495c3b7cc043c9c4a932cd7f46ee976 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Oct 2022 16:52:25 +0800
Subject: [PATCH 2387/3374] Create
 2334-subarray-with-elements-greater-than-varying-threshold.js

---
 ...elements-greater-than-varying-threshold.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2334-subarray-with-elements-greater-than-varying-threshold.js

diff --git a/2334-subarray-with-elements-greater-than-varying-threshold.js b/2334-subarray-with-elements-greater-than-varying-threshold.js
new file mode 100644
index 00000000..81da647a
--- /dev/null
+++ b/2334-subarray-with-elements-greater-than-varying-threshold.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @param {number} threshold
+ * @return {number}
+ */
+const validSubarraySize = function (nums, threshold) {
+  const n = nums.length
+
+  let stk = []
+  // used for storing next and previous smaller elements
+  const nextS = Array(n).fill(-1)
+  const prevS = Array(n).fill(-1)
+
+  // firstly, let's find out the next smaller elements
+  for (let i = 0; i < n; i++) {
+    while (stk.length && nums[i] < nums[back(stk)]) {
+      nextS[back(stk)] = i
+      stk.pop()
+    }
+    stk.push(i)
+  }
+
+  stk = []
+
+  // find out the previous smaller elements for each index
+  for (let i = n - 1; i >= 0; i--) {
+    while (stk.length && nums[i] < nums[back(stk)]) {
+      prevS[back(stk)] = i
+      stk.pop()
+    }
+    stk.push(i)
+  }
+
+  for (let i = 0; i < n; i++) {
+    // left boundary
+    const left = prevS[i]
+    // right boundary
+    const right = nextS[i] == -1 ? n : nextS[i]
+    // length of subarray formed with nums[i] as minimum
+    const len = right - left - 1
+
+    if (nums[i] > threshold / len) return len
+  }
+
+  return -1
+
+  function back(arr) {
+    return arr[arr.length - 1]
+  }
+}

From f94291d056cc32caa2ded282643e8025cd5f9ff6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Oct 2022 20:19:08 +0800
Subject: [PATCH 2388/3374] Update 85-maximal-rectangle.js

---
 85-maximal-rectangle.js | 44 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/85-maximal-rectangle.js b/85-maximal-rectangle.js
index 8192ef62..fd57a2d6 100644
--- a/85-maximal-rectangle.js
+++ b/85-maximal-rectangle.js
@@ -1,3 +1,47 @@
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+const maximalRectangle = function(matrix) {
+  const m = matrix.length, n = matrix[0].length
+  const left = Array(n).fill(0)
+  const right = Array(n).fill(n - 1)
+  const height = Array(n).fill(0)
+  
+  let res = 0
+  
+  for(let i = 0; i < m; i++) {
+    let l = 0, r = n - 1
+    for(let j = 0; j < n; j++) {
+      if(matrix[i][j] === '1') left[j] = Math.max(left[j], l)
+      else {
+        left[j] = 0
+        l = j + 1
+      }
+    }
+    
+    for(let j = n - 1; j >= 0; j--) {
+      if(matrix[i][j] === '1') right[j] = Math.min(right[j], r)
+      else {
+        right[j] = n - 1
+        r = j - 1
+      }
+    }
+
+    for(let j = 0; j < n; j++) {
+      height[j] = matrix[i][j] === '1' ? height[j] + 1 : 0
+      res = Math.max(res, (right[j] - left[j] + 1) * height[j])
+    }
+    
+    // console.log(left, right, height)
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {character[][]} matrix
  * @return {number}

From fb6d0d73872d33fa426f8f1d4c6b21dea52b79b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Oct 2022 20:21:54 +0800
Subject: [PATCH 2389/3374] Create
 2432-the-employee-that-worked-on-the-longest-task.js

---
 ...mployee-that-worked-on-the-longest-task.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2432-the-employee-that-worked-on-the-longest-task.js

diff --git a/2432-the-employee-that-worked-on-the-longest-task.js b/2432-the-employee-that-worked-on-the-longest-task.js
new file mode 100644
index 00000000..fd203058
--- /dev/null
+++ b/2432-the-employee-that-worked-on-the-longest-task.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @param {number[][]} logs
+ * @return {number}
+ */
+var hardestWorker = function(n, logs) {
+  const arr = Array(n).fill(0)
+  const m = logs.length
+  let pre = 0
+  for(let i = 0; i < m; i++) {
+     const [id, leave] = logs[i]
+     arr[id] = Math.max(arr[id], leave - pre)
+     pre = leave
+  }
+  // console.log(arr)
+  const max = Math.max(...arr)
+  
+  return arr.indexOf(max)
+};

From ead41a9770a7e6d1349637163b43a40f7779f9f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Oct 2022 20:22:31 +0800
Subject: [PATCH 2390/3374] Create
 2433-find-the-original-array-of-prefix-xor.js

---
 2433-find-the-original-array-of-prefix-xor.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2433-find-the-original-array-of-prefix-xor.js

diff --git a/2433-find-the-original-array-of-prefix-xor.js b/2433-find-the-original-array-of-prefix-xor.js
new file mode 100644
index 00000000..5d86d3fe
--- /dev/null
+++ b/2433-find-the-original-array-of-prefix-xor.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} pref
+ * @return {number[]}
+ */
+const findArray = function(pref) {
+  const n = pref.length
+  if(n == 0 || n==1) return pref
+  const res = [pref[0]]
+  let xor = pref[0]
+  for(let i = 1; i < n; i++) {
+     const v = pref[i]
+     // v = xor ^ e
+     // v ^ xor = e
+     const tmp = v ^ xor
+     res.push(tmp)
+     xor = xor ^ tmp
+  }
+  
+  return res
+};

From 8dbb2ee933f25dc8104a8f3207573ef8059e17ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Oct 2022 20:23:40 +0800
Subject: [PATCH 2391/3374] Create
 2434-using-a-robot-to-print-the-lexicographically-smallest-string.js

---
 ...t-the-lexicographically-smallest-string.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2434-using-a-robot-to-print-the-lexicographically-smallest-string.js

diff --git a/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js b/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js
new file mode 100644
index 00000000..15535a1b
--- /dev/null
+++ b/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js
@@ -0,0 +1,34 @@
+
+const ord = (c) => c.charCodeAt();
+const char = (ascii) => String.fromCharCode(ascii);
+/**
+ * @param {string} s
+ * @return {string}
+ */
+
+const robotWithString = (s) => {
+    let f = Array(26).fill(0), t = [], res = '';
+    for (const c of s) f[ord(c) - 97]++;
+    for (const c of s) {
+        f[ord(c) - 97]--;
+        t.push(c);
+        while (t.length) {
+            let find = false;
+            for (let i = 0; i < 26; i++) {
+                let curC = char(i + 97);
+                if (curC < t[t.length - 1]) { // check if can find smaller char < t's last char, in the rest of S
+                    if (f[i] > 0) {
+                        find = true;
+                        break;
+                    }
+                }
+            }
+            if (find) { // find means there is lexical smaller one, by moving much more right
+                break;
+            } else { // not find, current is lexical smaller
+                res += t.pop();
+            }
+        }
+    }
+    return res;
+};

From 2db0eacdd3b646cfcbadc2e7b88979e23a127964 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Oct 2022 20:25:29 +0800
Subject: [PATCH 2392/3374] Create
 2435-paths-in-matrix-whose-sum-is-divisible-by-k.js

---
 ...s-in-matrix-whose-sum-is-divisible-by-k.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2435-paths-in-matrix-whose-sum-is-divisible-by-k.js

diff --git a/2435-paths-in-matrix-whose-sum-is-divisible-by-k.js b/2435-paths-in-matrix-whose-sum-is-divisible-by-k.js
new file mode 100644
index 00000000..b3954370
--- /dev/null
+++ b/2435-paths-in-matrix-whose-sum-is-divisible-by-k.js
@@ -0,0 +1,24 @@
+const initialize3DArray = (n, m, p) => { let r = []; for (let i = 0; i < n; i++) { let d = []; for (let j = 0; j < m; j++) { let t = Array(p).fill(0); d.push(t); } r.push(d); } return r; };
+
+const mod = 1e9 + 7;
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfPaths = (grid, k) => {
+    const g = grid, K = k
+    let n = g.length, m = g[0].length, dp = initialize3DArray(n + 1, m + 1, K);
+    dp[0][1][0] = 1;
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < m; j++) {
+            for (let k = 0; k < K; k++) {
+                dp[i + 1][j + 1][(k + g[i][j]) % K] += dp[i][j + 1][k];
+                dp[i + 1][j + 1][(k + g[i][j]) % K] %= mod;
+                dp[i + 1][j + 1][(k + g[i][j]) % K] += dp[i + 1][j][k];
+                dp[i + 1][j + 1][(k + g[i][j]) % K] %= mod;
+            }
+        }
+    }
+    return dp[n][m][0];
+};

From 244b485a7a0a454c6ca69d78af1cc446da4bc7e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Oct 2022 19:47:29 +0800
Subject: [PATCH 2393/3374] Update 1944-number-of-visible-people-in-a-queue.js

---
 1944-number-of-visible-people-in-a-queue.js | 26 +++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1944-number-of-visible-people-in-a-queue.js b/1944-number-of-visible-people-in-a-queue.js
index 6505ef83..d74994b3 100644
--- a/1944-number-of-visible-people-in-a-queue.js
+++ b/1944-number-of-visible-people-in-a-queue.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number[]} heights
+ * @return {number[]}
+ */
+const canSeePersonsCount = function(heights) {
+  const res = []
+  if(heights.length === 0) return res
+  
+  const n = heights.length
+  const stk = []
+  for(let i = n - 1; i >= 0; i--) {
+    let del = 0
+    while(stk.length && heights[i] > heights[stk[stk.length - 1]]) {
+      stk.pop()
+      del++
+    }
+    res.push(del + (stk.length ? 1 : 0))
+    stk.push(i)
+  }
+  
+  return res.reverse()
+};
+
+// another
+
+
 /**
  * @param {number[]} heights
  * @return {number[]}

From a14e99fb07bb6d8a9fbed8e570441435e178e2be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Oct 2022 19:17:54 +0800
Subject: [PATCH 2394/3374] Create
 2282-number-of-people-that-can-be-seen-in-a-grid.js

---
 ...er-of-people-that-can-be-seen-in-a-grid.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2282-number-of-people-that-can-be-seen-in-a-grid.js

diff --git a/2282-number-of-people-that-can-be-seen-in-a-grid.js b/2282-number-of-people-that-can-be-seen-in-a-grid.js
new file mode 100644
index 00000000..90c1fb32
--- /dev/null
+++ b/2282-number-of-people-that-can-be-seen-in-a-grid.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} heights
+ * @return {number[][]}
+ */
+const seePeople = function(heights) {
+  const m = heights.length, n = heights[0].length
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  
+  for(let i = 0; i < m; i++) {
+    const stk = []
+    for(let j = n - 1; j >= 0; j--) {
+      let del = 0
+
+      while(stk.length && heights[i][j] > heights[i][stk[stk.length - 1]]) {
+        del++
+        stk.pop()
+      }
+      res[i][j] = del + (stk.length ? 1 : 0)
+      if(stk.length && heights[i][j] === heights[i][stk[stk.length - 1]]) continue
+      stk.push(j)
+    }
+  }
+  
+  for(let j = 0; j < n; j++) {
+    const stk = []
+    for(let i = m - 1; i >= 0; i--) {
+      let del = 0
+
+      while(stk.length && heights[i][j] > heights[stk[stk.length - 1]][j]) {
+        del++
+        stk.pop()
+      }
+      res[i][j] += del + (stk.length ? 1 : 0)
+      if(stk.length && heights[i][j] === heights[stk[stk.length - 1]][j]) continue
+      stk.push(i)
+    }
+  }
+  
+  return res
+};

From a9765ac01c11099f7f3c129eaf26a6b25c395833 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Oct 2022 19:16:11 +0800
Subject: [PATCH 2395/3374] Create 2197-replace-non-coprime-numbers-in-array.js

---
 2197-replace-non-coprime-numbers-in-array.js | 22 ++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2197-replace-non-coprime-numbers-in-array.js

diff --git a/2197-replace-non-coprime-numbers-in-array.js b/2197-replace-non-coprime-numbers-in-array.js
new file mode 100644
index 00000000..a2551d90
--- /dev/null
+++ b/2197-replace-non-coprime-numbers-in-array.js
@@ -0,0 +1,22 @@
+const gcd = (a, b) => (b == 0 ? a : gcd(b, a % b));
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const replaceNonCoprimes = function (nums) {
+  const stk = [];
+  for (let x of nums) {
+    if (stk.length === 0) {
+      stk.push(x);
+    } else {
+      while (stk.length && gcd(stk[stk.length - 1], x) !== 1) {
+        // check if it can be merged with the value to its left
+        const last = stk.pop(),
+          g = gcd(x, last);
+        x = (x / g) * last; // merge value, update lcm to x
+      }
+      stk.push(x);
+    }
+  }
+  return stk;
+};

From 61ea90211483832982938b2af82a5028b91afbc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Oct 2022 13:31:59 +0800
Subject: [PATCH 2396/3374] Update
 2434-using-a-robot-to-print-the-lexicographically-smallest-string.js

---
 ...t-the-lexicographically-smallest-string.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js b/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js
index 15535a1b..9ffd6f29 100644
--- a/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js
+++ b/2434-using-a-robot-to-print-the-lexicographically-smallest-string.js
@@ -1,3 +1,44 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const robotWithString = function (s) {
+  const stk = []
+  const freq = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for (const ch of s) {
+    freq[ch.charCodeAt(0) - a]++
+  }
+
+  let res = ''
+
+  for (const ch of s) {
+    stk.push(ch)
+    freq[ch.charCodeAt(0) - a]--
+    while (stk.length && stk[stk.length - 1] <= helper(freq)) {
+      const e = stk.pop()
+      res += e
+    }
+  }
+
+  while (stk.length) {
+    res += stk.pop()
+  }
+
+  return res
+
+  function helper(arr) {
+    const a = 'a'.charCodeAt(0)
+    for (let i = 0; i < 26; i++) {
+      if (arr[i] !== 0) return String.fromCharCode(a + i)
+    }
+
+    return ''
+  }
+}
+
+
+// another
 
 const ord = (c) => c.charCodeAt();
 const char = (ascii) => String.fromCharCode(ascii);

From e8d233fd69c8503866c0cffc687acf9d9920b119 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Oct 2022 17:04:56 +0800
Subject: [PATCH 2397/3374] Create 1245-tree-diameter.js

---
 1245-tree-diameter.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 1245-tree-diameter.js

diff --git a/1245-tree-diameter.js b/1245-tree-diameter.js
new file mode 100644
index 00000000..d9b83b62
--- /dev/null
+++ b/1245-tree-diameter.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const treeDiameter = function (edges) {
+  const graph = {}
+  for (const [u, v] of edges) {
+    if (graph[u] == null) graph[u] = new Set()
+    if (graph[v] == null) graph[v] = new Set()
+    graph[u].add(v)
+    graph[v].add(u)
+  }
+
+  let res = 0
+
+  dfs(0, -1)
+
+  return res
+  
+  function dfs(node, parent) {
+    let first = 0, sec = 0
+
+    for(const nxt of (graph[node] || [])) {
+      if(nxt === parent) continue
+      const childNum = dfs(nxt, node)
+      if(childNum > first) {
+        sec = first
+        first = childNum
+      } else if(childNum > sec){
+        sec = childNum
+      }
+    }
+
+    const nodeNum = first + sec + 1
+    res = Math.max(res, nodeNum - 1)
+    return first + 1
+  }
+}

From 39bf4392271df5f3e81bcd8e11b8f1e68b052108 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Oct 2022 19:35:04 +0800
Subject: [PATCH 2398/3374] Create 2355-maximum-number-of-books-you-can-take.js

---
 2355-maximum-number-of-books-you-can-take.js | 49 ++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 2355-maximum-number-of-books-you-can-take.js

diff --git a/2355-maximum-number-of-books-you-can-take.js b/2355-maximum-number-of-books-you-can-take.js
new file mode 100644
index 00000000..585b0b78
--- /dev/null
+++ b/2355-maximum-number-of-books-you-can-take.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} books
+ * @return {number}
+ */
+var maximumBooks = function (books) {
+  const len = books.length
+  const dp = new Array(len).fill(0)
+
+  // dp[i] represents max number of books that can be taken
+  // between shelf 0 and shelf i (both inclusive)
+
+  // use monotonic stack to populate dp array; for every index i,
+  // find the nearest break point j < i such that books[i - j] <
+  // books[i] - i + j
+
+  // this becomes the restraining point for picking books as now
+  // instead of picking (books[i] - i + j) books, we can only pick
+  // books[i - j] books; so we will pick the maximum dp[j] books +
+  // (books[i] + books[i] - 1 + books[i] - 2 + ... + books[i] - (i - j - 1))
+  const stack = []
+  let maxBooks = 0
+
+  for (let i = 0; i < len; i++) {
+    while (stack.length && books[peek(stack)] >= books[i] - i + peek(stack))
+      stack.pop()
+
+    // pick dp[j] books and (books[i] + books[i] - 1 + ... + books[i] -
+    // (i - j - 1)) books, where j is the current stack top; the latter
+    // expression can be rewritten as a difference of two n-summations
+    dp[i] =
+      (stack.length === 0 ? 0 : dp[peek(stack)]) +
+      getSummation(books[i]) -
+      getSummation(books[i] - i + (stack.length === 0 ? -1 : peek(stack)))
+
+    maxBooks = Math.max(maxBooks, dp[i])
+    stack.push(i)
+  }
+
+  return maxBooks
+}
+
+function getSummation(n) {
+  if (n < 0) return 0
+  return (n * (n + 1)) / 2
+}
+
+function peek(arr) {
+  return arr[arr.length - 1]
+}

From 8a82391add15d8e13fc34e00538c47c44a299efc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Oct 2022 19:46:05 +0800
Subject: [PATCH 2399/3374] Update 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 43 ++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
index 0514873a..8202a320 100644
--- a/1631-path-with-minimum-effort.js
+++ b/1631-path-with-minimum-effort.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[][]} heights
+ * @return {number}
+ */
+const minimumEffortPath = function(heights) {
+  const m = heights.length, n = heights[0].length
+  const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+  let l = 0, r = 1e6 - 1
+  
+  while(l < r) {
+    const mid = ~~((l + r) / 2)
+    if(valid(mid)) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  
+  return l
+  
+  function valid(limit) {
+    const visited = Array.from({ length: m }, () => Array(n).fill(false))
+    return dfs(0, 0, limit, visited)
+  }
+  
+  function dfs(i, j, limit, visited) {
+    if(i === m - 1 && j === n - 1) return true
+    visited[i][j] = true
+    for(const [dx, dy] of dirs) {
+      const nx = i + dx, ny = j + dy
+      if(nx < 0 || nx >= m || ny < 0 || ny >= n) continue
+      if(visited[nx][ny]) continue
+      if(Math.abs(heights[i][j] - heights[nx][ny]) <= limit && dfs(nx, ny, limit, visited)) return true
+    }
+    return false
+  }
+
+};
+
+// another
+
+
+
 /**
  * @param {number[][]} heights
  * @return {number}

From 37de20b26c1162bef4f7d649ac7b3f18e9f451e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Oct 2022 19:53:21 +0800
Subject: [PATCH 2400/3374] Update 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
index 8202a320..aa094e96 100644
--- a/1631-path-with-minimum-effort.js
+++ b/1631-path-with-minimum-effort.js
@@ -9,6 +9,7 @@ const minimumEffortPath = function(heights) {
   
   while(l < r) {
     const mid = ~~((l + r) / 2)
+    // console.log(l, r, mid)
     if(valid(mid)) {
       r = mid
     } else {
@@ -30,9 +31,10 @@ const minimumEffortPath = function(heights) {
       const nx = i + dx, ny = j + dy
       if(nx < 0 || nx >= m || ny < 0 || ny >= n) continue
       if(visited[nx][ny]) continue
-      if(Math.abs(heights[i][j] - heights[nx][ny]) <= limit && dfs(nx, ny, limit, visited)) return true
+      if(Math.abs(heights[i][j] - heights[nx][ny]) > limit) continue
+      if(dfs(nx, ny, limit, visited)) return true
     }
-    return false
+    // return false
   }
 
 };

From cb8a622d63aadb4cb2f0db62bb245696135acd75 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Oct 2022 12:15:09 +0800
Subject: [PATCH 2401/3374] Create 2444-count-subarrays-with-fixed-bounds.js

---
 2444-count-subarrays-with-fixed-bounds.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2444-count-subarrays-with-fixed-bounds.js

diff --git a/2444-count-subarrays-with-fixed-bounds.js b/2444-count-subarrays-with-fixed-bounds.js
new file mode 100644
index 00000000..e2d969e1
--- /dev/null
+++ b/2444-count-subarrays-with-fixed-bounds.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} minK
+ * @param {number} maxK
+ * @return {number}
+ */
+var countSubarrays = function(nums, minK, maxK) {
+    let res = 0, j = 0, jmin = -1, jmax = -1, n = nums.length;
+    for (let i = 0; i < n; ++i) {
+        if  (nums[i] < minK || nums[i] > maxK) {
+            jmin = jmax = -1;
+            j = i + 1;
+        }
+        if (nums[i] == minK) jmin = i;
+        if (nums[i] == maxK) jmax = i;
+        res += Math.max(0, Math.min(jmin, jmax) - j + 1);
+    }
+    return res;
+};

From 63ee0de014ed990b5c83367b11cef3e22dab0e94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Oct 2022 12:15:36 +0800
Subject: [PATCH 2402/3374] Create 2443-sum-of-number-and-its-reverse.js

---
 2443-sum-of-number-and-its-reverse.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2443-sum-of-number-and-its-reverse.js

diff --git a/2443-sum-of-number-and-its-reverse.js b/2443-sum-of-number-and-its-reverse.js
new file mode 100644
index 00000000..686d2a4c
--- /dev/null
+++ b/2443-sum-of-number-and-its-reverse.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} num
+ * @return {boolean}
+ */
+var sumOfNumberAndReverse = function(num) {
+  // let l = 0, r = num
+  // while(l < r) {
+  //   const mid = ~~((l + r) / 2)
+  //   if(valid(mid) === 0) return true
+  //   else if(valid(mid) < 0) l = mid + 1
+  //   else r = mid - 1
+  // }
+  for(let i = 0; i <= num; i++) {
+    if(valid(i) === 0) {
+      // console.log(i)
+      return true
+    }
+  }
+  return false
+  
+  function valid(n) {
+    return n + (parseInt( (''+n).split('').reverse().join('') ) ) - num
+  }
+};

From 9725f0bfdfea2fa352cd61b988a67bba974aaad1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Oct 2022 12:15:58 +0800
Subject: [PATCH 2403/3374] Create
 2442-count-number-of-distinct-integers-after-reverse-operations.js

---
 ...-distinct-integers-after-reverse-operations.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2442-count-number-of-distinct-integers-after-reverse-operations.js

diff --git a/2442-count-number-of-distinct-integers-after-reverse-operations.js b/2442-count-number-of-distinct-integers-after-reverse-operations.js
new file mode 100644
index 00000000..884b1c23
--- /dev/null
+++ b/2442-count-number-of-distinct-integers-after-reverse-operations.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var countDistinctIntegers = function(nums) {
+  const set = new Set()
+  
+  for(const e of nums) set.add(e)
+  for(const e of nums) set.add(reverse(e))
+  return set.size
+  
+  function reverse(num) {
+    return parseInt(('' + num).split('').reverse().join(''))
+  }
+};

From df336000d734e2cd7b8438c960205dac90d6ea95 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Oct 2022 12:16:20 +0800
Subject: [PATCH 2404/3374] Create
 2441-largest-positive-integer-that-exists-with-its-negative.js

---
 ...ositive-integer-that-exists-with-its-negative.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2441-largest-positive-integer-that-exists-with-its-negative.js

diff --git a/2441-largest-positive-integer-that-exists-with-its-negative.js b/2441-largest-positive-integer-that-exists-with-its-negative.js
new file mode 100644
index 00000000..47214a1a
--- /dev/null
+++ b/2441-largest-positive-integer-that-exists-with-its-negative.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMaxK = function(nums) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  for(let i = n - 1; i > 0; i--) {
+    const cur = nums[i]
+    if(nums.indexOf(-cur) !== -1) return cur
+  }
+  return -1
+};

From 0d7fcd6b629ff99be16591f02a021c6d82fc76a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Oct 2022 18:26:23 +0800
Subject: [PATCH 2405/3374] Update 1970-last-day-where-you-can-still-cross.js

---
 1970-last-day-where-you-can-still-cross.js | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/1970-last-day-where-you-can-still-cross.js b/1970-last-day-where-you-can-still-cross.js
index ed44df6b..6ae51821 100644
--- a/1970-last-day-where-you-can-still-cross.js
+++ b/1970-last-day-where-you-can-still-cross.js
@@ -9,15 +9,15 @@ const latestDayToCross = function (row, col, cells) {
     n = cells.length,
     r = n
   while (l < r) {
-    const mid = ~~((l + r) / 2)
+    const mid = r - (~~((r - l) / 2))
     if (canWalk(mid)) {
-      l = mid + 1
+      l = mid
     } else {
-      r = mid
+      r = mid - 1
     }
   }
 
-  return l
+  return l + 1
 
   function canWalk(mid) {
     const grid = Array.from({ length: row }, () => Array(col).fill(0))

From 484cba1609d3fd2e5b2f24fe49fa2a0ffb1af3ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Oct 2022 12:44:34 +0800
Subject: [PATCH 2406/3374] Update
 1697-checking-existence-of-edge-length-limited-paths.js

---
 ...-existence-of-edge-length-limited-paths.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/1697-checking-existence-of-edge-length-limited-paths.js b/1697-checking-existence-of-edge-length-limited-paths.js
index cf678002..72ef93c5 100644
--- a/1697-checking-existence-of-edge-length-limited-paths.js
+++ b/1697-checking-existence-of-edge-length-limited-paths.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edgeList
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const distanceLimitedPathsExist = function (n, edgeList, queries) {
+  edgeList.sort((a, b) => a[2] - b[2])
+  const m = queries.length
+  const res = Array(m).fill(false)
+  const order = Array(m).fill(0)
+  for (let i = 0; i < m; ++i) order[i] = i
+  order.sort((i, j) => queries[i][2] - queries[j][2])
+  const uf = new UF(n)
+  let idx = 0
+  for (let i of order) {
+    const limit = queries[i][2]
+    while (idx < edgeList.length && edgeList[idx][2] < limit) {
+      const [u, v] = edgeList[idx]
+      uf.union(u, v)
+      idx++
+    }
+    const [u0, v0] = queries[i]
+    if (uf.find(u0) === uf.find(v0)) res[i] = true
+  }
+  return res
+}
+
+class UF {
+  constructor(n) {
+    this.root = Array(n)
+      .fill(null)
+      .map((_, i) => i)
+  }
+  find(x) {
+    if (this.root[x] !== x) {
+      this.root[x] = this.find(this.root[x])
+    }
+    return this.root[x]
+  }
+  union(x, y) {
+    const xr = this.find(x)
+    const yr = this.find(y)
+    this.root[yr] = xr
+  }
+}
+
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edgeList

From d067b2ae080c3b155a5ef435a59bb15ead6c80c7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Oct 2022 14:23:01 +0800
Subject: [PATCH 2407/3374] Create 1273-delete-tree-nodes.js

---
 1273-delete-tree-nodes.js | 57 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 1273-delete-tree-nodes.js

diff --git a/1273-delete-tree-nodes.js b/1273-delete-tree-nodes.js
new file mode 100644
index 00000000..7ecb9bb1
--- /dev/null
+++ b/1273-delete-tree-nodes.js
@@ -0,0 +1,57 @@
+/**
+ * @param {number} nodes
+ * @param {number[]} parent
+ * @param {number[]} value
+ * @return {number}
+ */
+const deleteTreeNodes = function (nodes, parent, value) {
+  const n = nodes
+  const hash = {}
+  hash[0] = new Node(value[0])
+  for (let i = 1; i < n; i++) {
+    hash[i] = new Node(value[i])
+  }
+
+  for (let i = 1; i < n; i++) {
+    const p = parent[i]
+    hash[p].children[i] = hash[i]
+  }
+
+  const r = hash[0]
+  dfs(r)
+  // console.log(n)
+  return cnt(r)
+
+  function dfs(node) {
+    if (node == null) return 0
+    let res = node.sum
+
+    const keys = Object.keys(node.children)
+    for (const k of keys) {
+      res += dfs(hash[k])
+    }
+
+    node.sum = res
+    return res
+  }
+
+  function cnt(node) {
+    if (node == null) return 0
+    if (node.sum === 0) return 0
+    const keys = Object.keys(node.children)
+    let res = 1
+    for (const k of keys) {
+      res += cnt(hash[k])
+    }
+
+    return res
+  }
+}
+
+class Node {
+  constructor(v) {
+    this.val = v
+    this.sum = v
+    this.children = {}
+  }
+}

From 9752c97e0632151a740653bdd1d6065514025231 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Oct 2022 14:31:20 +0800
Subject: [PATCH 2408/3374] Update 2421-number-of-good-paths.js

---
 2421-number-of-good-paths.js | 117 +++++++++++++++++------------------
 1 file changed, 57 insertions(+), 60 deletions(-)

diff --git a/2421-number-of-good-paths.js b/2421-number-of-good-paths.js
index cc0cd7f1..cffbdb15 100644
--- a/2421-number-of-good-paths.js
+++ b/2421-number-of-good-paths.js
@@ -1,66 +1,63 @@
-
-///////////////////////////////////////////////////// Template ///////////////////////////////////////////////////////////////////////
-const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };
-const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
-
-function DJSet(n) {
-    // parent[i] < 0, -parent[i] is the group size which root is i. example: (i -> parent[i] -> parent[parent[i]] -> parent[parent[parent[i]]] ...)
-    // parent[i] >= 0, i is not the root and parent[i] is i's parent. example: (... parent[parent[parent[i]]] -> parent[parent[i]] -> parent[i] -> i)
-    let parent = Array(n).fill(-1);
-    return { find, union, count, equiv, par }
-    function find(x) {
-        return parent[x] < 0 ? x : parent[x] = find(parent[x]);
-    }
-    function union(x, y) {
-        x = find(x);
-        y = find(y);
-        if (x == y) return false;
-        if (parent[x] < parent[y]) [x, y] = [y, x];
-        parent[x] += parent[y];
-        parent[y] = x;
-        return true;
-    }
-    function count() { // total groups
-        return parent.filter(v => v < 0).length;
-    }
-    function equiv(x, y) { // isConnected
-        return find(x) == find(y);
-    }
-    function par() {
-        return parent;
-    }
-}
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 /**
  * @param {number[]} vals
  * @param {number[][]} edges
  * @return {number}
  */
-const numberOfGoodPaths = (a, edges) => {
-    let n = a.length, g = initializeGraph(n), f = Array(n).fill(0), ds = new DJSet(n), res = 0;
-    packUG(g, edges);
-    let d = a.map((x, i) => [x, i]);
-    d.sort((x, y) => {
-        if (x[0] != y[0]) return x[0] - y[0];
-        return x[1] - y[1];
-    })
-    for (let r = 0; r < n;) { // l: start node  r: end node
-        let l = r;
-        while (r < n && d[l][0] == d[r][0]) r++; // condition 1
-        for (let i = l; i < r; i++) {
-            let cur = d[i][1];
-            for (const child of g[cur]) {
-                if (a[child] <= d[l][0]) ds.union(child, cur); // condition 2
-            }
-        }
-        for (let i = l; i < r; i++) { // loop the path
-            let cur = d[i][1];
-            res += ++f[ds.find(cur)];
-        }
-        for (let i = l; i < r; i++) {
-            let cur = d[i][1];
-            f[ds.find(cur)]--;
-        }
+const numberOfGoodPaths = function (vals, edges) {
+  const n = vals.length
+  let res = 0
+  const adj = Array.from({ length: n }, () => [])
+  const sameValues = new Map()
+  const valWithIdx = vals.map((v, i) => [v, i])
+  valWithIdx.sort((a, b) => a[0] - b[0])
+  for (let i = 0; i < n; i++) {
+    const [val, idx] = valWithIdx[i]
+    if (sameValues.get(val) == null) sameValues.set(val, [])
+    sameValues.get(val).push(idx)
+  }
+  for (const e of edges) {
+    const [u, v] = e
+    if (vals[u] >= vals[v]) {
+      adj[u].push(v)
+    } else if (vals[v] >= vals[u]) {
+      adj[v].push(u)
     }
-    return res;
-};
+  }
+  const uf = new UF(n)
+  for (const [_, allNodes] of sameValues) {
+    for (let u of allNodes) {
+      for (const v of adj[u]) {
+        uf.union(u, v)
+      }
+    }
+    const group = {}
+    for (let u of allNodes) {
+      const uroot = uf.find(u)
+      if (group[uroot] == null) group[uroot] = 0
+      group[uroot]++
+    }
+    res += allNodes.length
+    for (let [_, size] of Object.entries(group)) {
+      res += (size * (size - 1)) / 2
+    }
+  }
+  return res
+}
+class UF {
+  constructor(n) {
+    this.root = Array(n)
+      .fill(null)
+      .map((_, i) => i)
+  }
+  find(x) {
+    if (this.root[x] !== x) {
+      this.root[x] = this.find(this.root[x])
+    }
+    return this.root[x]
+  }
+  union(x, y) {
+    const xr = this.find(x)
+    const yr = this.find(y)
+    this.root[yr] = xr
+  }
+}

From e95fe685d550b761df3fa973318c6dad0c7c23e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Oct 2022 15:31:55 +0800
Subject: [PATCH 2409/3374] Create 910-smallest-range-ii.js

---
 910-smallest-range-ii.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 910-smallest-range-ii.js

diff --git a/910-smallest-range-ii.js b/910-smallest-range-ii.js
new file mode 100644
index 00000000..6980165b
--- /dev/null
+++ b/910-smallest-range-ii.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const smallestRangeII = function (nums, k) {
+  let n = nums.length
+  nums.sort((a, b) => a - b)
+  let res = nums[n - 1] - nums[0]
+
+  let left = nums[0] + k, right = nums[n - 1] - k
+  for(let i = 0; i < n - 1; i++) {
+    const tmax = Math.max(right, nums[i] + k)
+    const tmin = Math.min(left, nums[i + 1] - k)
+    res = Math.min(res, tmax - tmin)
+  }
+
+  return res
+}

From 678025d4a926d688ce10658a70bed01a28e5e817 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Oct 2022 15:36:33 +0800
Subject: [PATCH 2410/3374] Update 910-smallest-range-ii.js

---
 910-smallest-range-ii.js | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/910-smallest-range-ii.js b/910-smallest-range-ii.js
index 6980165b..2c14d07f 100644
--- a/910-smallest-range-ii.js
+++ b/910-smallest-range-ii.js
@@ -6,8 +6,10 @@
 const smallestRangeII = function (nums, k) {
   let n = nums.length
   nums.sort((a, b) => a - b)
+  // all elements plus k or minus k
   let res = nums[n - 1] - nums[0]
 
+  // left side elements plus k, right side elements minus k
   let left = nums[0] + k, right = nums[n - 1] - k
   for(let i = 0; i < n - 1; i++) {
     const tmax = Math.max(right, nums[i] + k)

From df79c74e8e772ffef472a8389da0a85551c84cf2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Oct 2022 12:34:19 +0800
Subject: [PATCH 2411/3374] Update
 952-largest-component-size-by-common-factor.js

---
 ...largest-component-size-by-common-factor.js | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/952-largest-component-size-by-common-factor.js b/952-largest-component-size-by-common-factor.js
index 9d9f2bef..c01f0348 100644
--- a/952-largest-component-size-by-common-factor.js
+++ b/952-largest-component-size-by-common-factor.js
@@ -1,3 +1,72 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const largestComponentSize = function (nums) {
+  const { sqrt } = Math
+  const n = nums.length
+  const uf = new UF(n)
+  const primes = {}
+  for (let i = 0; i < n; i++) {
+    const num = nums[i]
+    const prSet = primesSet(num)
+    for (const e of prSet) {
+      if (primes[e] == null) primes[e] = []
+      primes[e].push(i)
+    }
+  }
+
+  const vals = Object.values(primes)
+  for(const idxArr of vals) {
+    const len = idxArr.length
+    for(let i = 0; i < len - 1; i++) {
+      uf.union(idxArr[i], idxArr[i + 1])
+    }
+  }
+  let res = 0
+  const hash = {}
+  for(let i = 0; i < n; i++) {
+    const root = uf.find(i)
+    if(hash[root] == null) hash[root] = 0
+    hash[root]++
+  }
+  return Math.max(...Object.values(hash))
+
+  function primesSet(n) {
+    const limit = ~~(sqrt(n) + 1)
+    for (let i = 2; i < limit; i++) {
+      if (n % i === 0) {
+        const res = primesSet(n / i)
+        res.add(i)
+        return res
+      }
+    }
+    return new Set([n])
+  }
+}
+
+class UF {
+  constructor(n) {
+    this.root = Array(n)
+      .fill(null)
+      .map((_, i) => i)
+  }
+  find(x) {
+    if (this.root[x] !== x) {
+      this.root[x] = this.find(this.root[x])
+    }
+    return this.root[x]
+  }
+  union(x, y) {
+    const xr = this.find(x)
+    const yr = this.find(y)
+    this.root[yr] = xr
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} A
  * @return {number}

From d2897c749624f6acf848d5afe852c12c0cb0d962 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Oct 2022 14:14:54 +0800
Subject: [PATCH 2412/3374] Create
 971-flip-binary-tree-to-match-preorder-traversal.js

---
 ...binary-tree-to-match-preorder-traversal.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 971-flip-binary-tree-to-match-preorder-traversal.js

diff --git a/971-flip-binary-tree-to-match-preorder-traversal.js b/971-flip-binary-tree-to-match-preorder-traversal.js
new file mode 100644
index 00000000..e21fd117
--- /dev/null
+++ b/971-flip-binary-tree-to-match-preorder-traversal.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number[]} voyage
+ * @return {number[]}
+ */
+const flipMatchVoyage = function (root, voyage) {
+  const n = voyage.length
+  const res = []
+  let idx = 0
+  return dfs(root, 0) ? res : [-1]
+
+  function dfs(node) {
+    if (node == null) return true
+    if (node.val !== voyage[idx]) {
+      return false
+    }
+    idx++
+    if (node.left && node.left.val !== voyage[idx]) {
+      res.push(node.val)
+      return dfs(node.right) && dfs(node.left)
+    }
+    return dfs(node.left) && dfs(node.right)
+  }
+}

From 33c9fd6f0763fd79a1bbe3c1239b14ed6b8ed9c8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Oct 2022 20:29:41 +0800
Subject: [PATCH 2413/3374] Update 1627-graph-connectivity-with-threshold.js

---
 1627-graph-connectivity-with-threshold.js | 50 +++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/1627-graph-connectivity-with-threshold.js b/1627-graph-connectivity-with-threshold.js
index 05eac3ca..cafcb215 100644
--- a/1627-graph-connectivity-with-threshold.js
+++ b/1627-graph-connectivity-with-threshold.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number} n
+ * @param {number} threshold
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+const areConnected = function(n, threshold, queries) {
+  const arr = []
+  const uf = new UF(n)
+  setup(n, threshold, uf)
+  for(let i = 0, len = queries.length; i < len;i++) {
+    arr.push(uf.check(queries[i][0], queries[i][1]))
+  }
+  return arr
+};
+
+function setup(n, t, uf) {
+  for (let i = t + 1; i <= n; i++) {
+    let m = 1;
+    while (i * m <= n) {
+      uf.union(i, i * m);
+      m += 1;
+    }
+  }
+}
+
+
+class UF {
+  constructor(n) {
+    this.root = Array(n).fill(null).map((_, i) => i)
+  }
+  find(x) {
+    if (this.root[x] !== x) {
+      this.root[x] = this.find(this.root[x])
+    }
+    return this.root[x]
+  }
+  union(x, y) {
+    const xr = this.find(x)
+    const yr = this.find(y)
+    this.root[yr] = xr
+  }
+  check(x, y) {
+    return this.find(x) === this.find(y)
+  }
+}
+
+
+// another
+
 /**
  * @param {number} n
  * @param {number} threshold

From 79867186a829d992bd9ff8f878c7533564cce0fc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Oct 2022 14:32:24 +0800
Subject: [PATCH 2414/3374] Add files via upload

---
 images/Sieve_of_Eratosthenes_animation.gif | Bin 0 -> 157448 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/Sieve_of_Eratosthenes_animation.gif

diff --git a/images/Sieve_of_Eratosthenes_animation.gif b/images/Sieve_of_Eratosthenes_animation.gif
new file mode 100644
index 0000000000000000000000000000000000000000..cd385eecd310f0332a98f8679fba81609d5d0f7b
GIT binary patch
literal 157448
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

literal 0
HcmV?d00001


From df355ce7349d84f405ad758dd701e947eefe51e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Oct 2022 14:38:44 +0800
Subject: [PATCH 2415/3374] Update 204-count-primes.js

---
 204-count-primes.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/204-count-primes.js b/204-count-primes.js
index f0ae3e2d..e1a61978 100755
--- a/204-count-primes.js
+++ b/204-count-primes.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countPrimes = function (n) {
+  const memo = Array(n).fill(false)
+  let res = 0
+  for (let i = 2; i < n; i++) {
+    if (memo[i] === false) {
+      res++
+      for (let j = 2; i * j < n; j++) {
+        memo[i * j] = true
+      }
+    }
+  }
+
+  return res
+}
+
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From c8a372b7dff763da2cec9cb23d9915bdd001c708 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Oct 2022 10:41:04 +0800
Subject: [PATCH 2416/3374] Update 2183-count-array-pairs-divisible-by-k.js

---
 2183-count-array-pairs-divisible-by-k.js | 31 ++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2183-count-array-pairs-divisible-by-k.js b/2183-count-array-pairs-divisible-by-k.js
index d7ff02ab..268ad344 100644
--- a/2183-count-array-pairs-divisible-by-k.js
+++ b/2183-count-array-pairs-divisible-by-k.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countPairs = function (nums, k) {
+  const map = new Map()
+
+  let res = 0
+  for(const e of nums) {
+    const tmp = gcd(e, k)
+
+    for(const [key, v] of map) {
+      if(tmp * key % k === 0) {
+        res += v
+      }
+    }
+    if(map.get(tmp) == null) map.set(tmp, 0)
+    map.set(tmp, map.get(tmp) + 1)
+  }
+
+  return res
+
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 5ac507cbf685cf6c251b1d30bfef46baebff4ac3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Oct 2022 15:41:22 +0800
Subject: [PATCH 2417/3374] Create
 1574-shortest-subarray-to-be-removed-to-make-array-sorted.js

---
 ...rray-to-be-removed-to-make-array-sorted.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 1574-shortest-subarray-to-be-removed-to-make-array-sorted.js

diff --git a/1574-shortest-subarray-to-be-removed-to-make-array-sorted.js b/1574-shortest-subarray-to-be-removed-to-make-array-sorted.js
new file mode 100644
index 00000000..7b4c43ef
--- /dev/null
+++ b/1574-shortest-subarray-to-be-removed-to-make-array-sorted.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const findLengthOfShortestSubarray = function (arr) {
+  const n = arr.length
+  let left = 0
+  for(let i = 0; i < n - 1; i++) {
+    if(arr[i] > arr[i+ 1]) {
+      break
+    }
+    left = i + 1
+  }
+
+  let right = n - 1
+  for(let i = n - 1; i > 0; i--) {
+    if(arr[i] < arr[i - 1]) {
+      break
+    }
+    right = i - 1
+  }
+  // console.log(left, right)
+  if(left === n - 1) return 0
+
+  let res = Math.min(n - 1 - left, right)
+  let l = 0, r = right
+  while(l <= left && r < n) {
+    if(arr[l] <= arr[r]) {
+      res = Math.min(res, r - 1 - l)
+      l++
+    } else {
+      r++
+    }
+  }
+
+  return res
+}

From 2c3836f9f8b6a2c27b9be29a80ebaa79823aa391 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 10:44:06 +0800
Subject: [PATCH 2418/3374] Update
 2344-minimum-deletions-to-make-array-divisible.js

---
 ...nimum-deletions-to-make-array-divisible.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2344-minimum-deletions-to-make-array-divisible.js b/2344-minimum-deletions-to-make-array-divisible.js
index 466d2bd8..cf3025b7 100644
--- a/2344-minimum-deletions-to-make-array-divisible.js
+++ b/2344-minimum-deletions-to-make-array-divisible.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} numsDivide
+ * @return {number}
+ */
+const minOperations = function (nums, numsDivide) {
+  nums.sort((a, b) => a - b)
+  let gcdVal = numsDivide[0]
+
+  for(let i = 1, n = numsDivide.length; i < n; i++) {
+    gcdVal = gcd(gcdVal, numsDivide[i])
+  }
+
+  for(let i = 0, n = nums.length; i < n && nums[i] <= gcdVal; i++) {
+    if(gcdVal % nums[i] === 0) return i
+  }
+
+  return -1
+
+
+  function gcd(a,b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[]} numsDivide

From 076df96a8a1cccac34d809b846dbe77c459797e8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 13:25:23 +0800
Subject: [PATCH 2419/3374] Create
 2246-determine-if-two-events-have-conflict.js

---
 2246-determine-if-two-events-have-conflict.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2246-determine-if-two-events-have-conflict.js

diff --git a/2246-determine-if-two-events-have-conflict.js b/2246-determine-if-two-events-have-conflict.js
new file mode 100644
index 00000000..d139a672
--- /dev/null
+++ b/2246-determine-if-two-events-have-conflict.js
@@ -0,0 +1,38 @@
+/**
+ * @param {string[]} event1
+ * @param {string[]} event2
+ * @return {boolean}
+ */
+var haveConflict = function(event1, event2) {
+  const fn = arr => arr.map(e => e.split(':').map(e => +e).reduce((ac,e,i) => i === 0 ? ac + 60 * e : ac + e, 0))
+  const arr1 = fn(event1)
+  const arr2 = fn(event2)
+  const hash = {}
+  
+  if(hash[arr1[0]] == null) hash[arr1[0]] = 0
+  hash[arr1[0]]++
+  
+  if(hash[arr1[1] + 1] == null) hash[arr1[1] + 1] = 0
+  hash[arr1[1] + 1]--
+  
+  if(hash[arr2[0]] == null) hash[arr2[0]] = 0
+  hash[arr2[0]]++
+  
+  if(hash[arr2[1] + 1] == null) hash[arr2[1] + 1] = 0
+  hash[arr2[1] + 1]--
+  
+  const keys = Object.keys(hash).map(e => +e)
+  keys.sort((a, b) => a - b)
+  
+  let num = 0
+  for(let i = 0; i < keys.length; i++) {
+    num += hash[keys[i]]
+    if(num > 1) return true
+  }
+  
+  // const arr = [].concat(arr1, arr2)
+  // arr.sort((a, b) => a - b)
+  // if(arr2[1] >= arr1[0] && arr2[0] <= arr1[1]) return true
+  // if(arr2[1] >= arr1[1] && arr2[0] <= arr1[1]) return true
+  return false
+};

From 98cd5dd70b7235f0d1e75a5ec1eed8ac01b80c68 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 13:55:57 +0800
Subject: [PATCH 2420/3374] Create
 2247-number-of-subarrays-with-gcd-equal-to-k.js

---
 ...number-of-subarrays-with-gcd-equal-to-k.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2247-number-of-subarrays-with-gcd-equal-to-k.js

diff --git a/2247-number-of-subarrays-with-gcd-equal-to-k.js b/2247-number-of-subarrays-with-gcd-equal-to-k.js
new file mode 100644
index 00000000..7611c8ec
--- /dev/null
+++ b/2247-number-of-subarrays-with-gcd-equal-to-k.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarrayGCD = function (nums, k) {
+  let res = 0
+  const n = nums.length
+  for (let i = 0; i < n; i++) {
+    let cur = nums[i]
+    for (let j = i; j < n; j++) {
+      if (nums[j] % k !== 0) break
+      cur = gcd(cur, nums[j])
+      if (cur === k) res++
+    }
+  }
+
+  return res
+
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+}

From acf792a4f7dbfb621a746163bad2fc9aec69e5b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 14:05:00 +0800
Subject: [PATCH 2421/3374] Rename
 2247-number-of-subarrays-with-gcd-equal-to-k.js to
 2447-number-of-subarrays-with-gcd-equal-to-k.js

---
 ...ual-to-k.js => 2447-number-of-subarrays-with-gcd-equal-to-k.js | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename 2247-number-of-subarrays-with-gcd-equal-to-k.js => 2447-number-of-subarrays-with-gcd-equal-to-k.js (100%)

diff --git a/2247-number-of-subarrays-with-gcd-equal-to-k.js b/2447-number-of-subarrays-with-gcd-equal-to-k.js
similarity index 100%
rename from 2247-number-of-subarrays-with-gcd-equal-to-k.js
rename to 2447-number-of-subarrays-with-gcd-equal-to-k.js

From c64f9cd2f066be9f4b4bfc5c6965d1a64aac6885 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 15:01:51 +0800
Subject: [PATCH 2422/3374] Create 2448-minimum-cost-to-make-array-equal.js

---
 2448-minimum-cost-to-make-array-equal.js | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2448-minimum-cost-to-make-array-equal.js

diff --git a/2448-minimum-cost-to-make-array-equal.js b/2448-minimum-cost-to-make-array-equal.js
new file mode 100644
index 00000000..55371cd2
--- /dev/null
+++ b/2448-minimum-cost-to-make-array-equal.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} cost
+ * @return {number}
+ */
+const minCost = function (nums, cost) {
+  const n = nums.length
+  let l = Math.min(...nums)
+  let r = Math.max(...nums)
+
+  let res = calc(l)
+  while(l < r) {
+    const mid = Math.floor((l + r) / 2)
+    const v1 = calc(mid)
+    const v2 = calc(mid + 1)
+    res = Math.min(res, v1, v2)
+    if(v1 < v2) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+
+  return res
+
+  function calc(v) {
+    let res = 0
+    for (let i = 0; i < n; i++) {
+      res += Math.abs(nums[i] - v) * cost[i]
+    }
+    return res
+  }
+}

From 4266524616b2bb5cfa91bbd36d8014de76c64555 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 15:10:41 +0800
Subject: [PATCH 2423/3374] Update 2448-minimum-cost-to-make-array-equal.js

---
 2448-minimum-cost-to-make-array-equal.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/2448-minimum-cost-to-make-array-equal.js b/2448-minimum-cost-to-make-array-equal.js
index 55371cd2..ea777961 100644
--- a/2448-minimum-cost-to-make-array-equal.js
+++ b/2448-minimum-cost-to-make-array-equal.js
@@ -8,12 +8,10 @@ const minCost = function (nums, cost) {
   let l = Math.min(...nums)
   let r = Math.max(...nums)
 
-  let res = calc(l)
   while(l < r) {
     const mid = Math.floor((l + r) / 2)
     const v1 = calc(mid)
     const v2 = calc(mid + 1)
-    res = Math.min(res, v1, v2)
     if(v1 < v2) {
       r = mid
     } else {
@@ -21,7 +19,7 @@ const minCost = function (nums, cost) {
     }
   }
 
-  return res
+  return calc(l)
 
   function calc(v) {
     let res = 0

From 058c3f623f4566e9e49d77bbc2d88e46d7f5764d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Oct 2022 15:58:43 +0800
Subject: [PATCH 2424/3374] Create
 2449-minimum-number-of-operations-to-make-arrays-similar.js

---
 ...er-of-operations-to-make-arrays-similar.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2449-minimum-number-of-operations-to-make-arrays-similar.js

diff --git a/2449-minimum-number-of-operations-to-make-arrays-similar.js b/2449-minimum-number-of-operations-to-make-arrays-similar.js
new file mode 100644
index 00000000..18b5b93f
--- /dev/null
+++ b/2449-minimum-number-of-operations-to-make-arrays-similar.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} target
+ * @return {number}
+ */
+const makeSimilar = function (nums, target) {
+  const odd = [], even = []
+  const todd = [], teven = []
+  for(const e of nums) {
+    if(e % 2 === 0) even.push(e)
+    else odd.push(e)
+  }
+  for(const e of target) {
+    if(e % 2 === 0) teven.push(e)
+    else todd.push(e)
+  }
+  const sfn = (a, b) => a - b
+  odd.sort(sfn)
+  todd.sort(sfn)
+  even.sort(sfn)
+  teven.sort(sfn)
+  let res = 0
+  for(let i = 0, n = odd.length; i < n; i++) {
+    res += Math.abs(odd[i] - todd[i]) / 2
+  }
+  for(let i = 0, n = even.length; i < n; i++) {
+    res += Math.abs(even[i] - teven[i]) / 2
+  }
+  return res / 2
+}

From 6fb1bbca8138143f6c0a2487b0693a247f485ba7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 Oct 2022 10:05:59 +0800
Subject: [PATCH 2425/3374] Update 296-best-meeting-point.js

---
 296-best-meeting-point.js | 42 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/296-best-meeting-point.js b/296-best-meeting-point.js
index a4cdcdd0..deceaa09 100644
--- a/296-best-meeting-point.js
+++ b/296-best-meeting-point.js
@@ -53,3 +53,45 @@ function min(arr) {
   }
   return sum
 }
+
+// another
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minTotalDistance = function (grid) {
+  const homeArr = []
+  const horiArr = [], vertArr = []
+  const m = grid.length,
+    n = grid[0].length
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      if (grid[i][j] === 1) {
+        homeArr.push([i, j])
+        vertArr.push(i)
+        horiArr.push(j)
+      }
+    }
+  }
+
+  vertArr.sort((a, b) => a - b)
+  horiArr.sort((a, b) => a - b)
+
+  let y = vertArr[~~(vertArr.length/2)]
+  let x = horiArr[~~(horiArr.length/2)]
+ 
+  const center = [y, x]
+  
+  let res = 0
+  for(const point of homeArr) {
+    res += dis(center, point)
+  }
+
+  return res
+
+  function dis(a, b) {
+    return Math.abs(a[0] - b[0]) + Math.abs(a[1] - b[1])
+  }
+
+}

From 1443a2dd100e82a93beb76559d33c293df6c2b98 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 Oct 2022 16:58:52 +0800
Subject: [PATCH 2426/3374] Update
 2033-minimum-operations-to-make-a-uni-value-grid.js

---
 ...mum-operations-to-make-a-uni-value-grid.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2033-minimum-operations-to-make-a-uni-value-grid.js b/2033-minimum-operations-to-make-a-uni-value-grid.js
index 4f4698c3..edb3acc4 100644
--- a/2033-minimum-operations-to-make-a-uni-value-grid.js
+++ b/2033-minimum-operations-to-make-a-uni-value-grid.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function (grid, x) {
+  const arr = [],
+    m = grid.length,
+    n = grid[0].length
+  const len = m * n
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      arr.push(grid[i][j])
+    }
+  }
+  arr.sort((a, b) => a - b)
+  const mid = arr[~~(len / 2)], { abs } = Math
+  let res = 0
+  for(const e of arr) {
+    if(abs(mid - e) % x !== 0) return -1
+    res += abs(mid - e) / x
+  }
+
+  return res
+}
+
+// another
+
 /**
  * @param {number[][]} grid
  * @param {number} x

From b396a10786a0d97d396f42773adc0e696144874a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 Oct 2022 21:00:25 +0800
Subject: [PATCH 2427/3374] Create 978-longest-turbulent-subarray.js

---
 978-longest-turbulent-subarray.js | 37 +++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 978-longest-turbulent-subarray.js

diff --git a/978-longest-turbulent-subarray.js b/978-longest-turbulent-subarray.js
new file mode 100644
index 00000000..c44dc883
--- /dev/null
+++ b/978-longest-turbulent-subarray.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const maxTurbulenceSize = function(arr) {
+  const n = arr.length
+  
+  return Math.max(helper(), helper1())
+  // < > <
+  function helper() {
+    const cnt = Array(n).fill(1)
+    
+    for(let i = 0; i < n - 1; i++) {
+      if(i % 2 === 1 && arr[i] > arr[i + 1]) {
+        cnt[i + 1] = cnt[i] + 1
+      } else if(i % 2 === 0 && arr[i] < arr[i + 1]) {
+        cnt[i + 1] = cnt[i] + 1
+      }
+    }
+    
+    return Math.max(...cnt)
+  }
+  
+  function helper1() {
+    const cnt = Array(n).fill(1)
+    
+    for(let i = 0; i < n - 1; i++) {
+      if(i % 2 === 1 &&  arr[i] < arr[i + 1] ) {
+        cnt[i + 1] = cnt[i] + 1
+      } else if(i % 2 === 0 && arr[i] > arr[i + 1] ) {
+        cnt[i + 1] = cnt[i] + 1
+      }
+    }
+    
+    return Math.max(...cnt)
+  }
+};

From 67c15beec0a51679723b68a4a35b931303d813f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Nov 2022 17:05:25 +0800
Subject: [PATCH 2428/3374] Update 1703-maximum-binary-string-after-change.js

---
 1703-maximum-binary-string-after-change.js | 36 ++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1703-maximum-binary-string-after-change.js b/1703-maximum-binary-string-after-change.js
index 2f587761..903e97d4 100644
--- a/1703-maximum-binary-string-after-change.js
+++ b/1703-maximum-binary-string-after-change.js
@@ -1,3 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minMoves = function (nums, k) {
+  const pos = [],
+    pre = []
+  const n = nums.length,
+    { min, floor: fl } = Math
+  for (let i = 0; i < n; i++) {
+    if (nums[i] === 1) pos.push(i)
+  }
+  let res = Infinity
+
+  pre.push(0)
+  for (let i = 0, len = pos.length; i < len; i++) {
+    pre.push(pre[i] + pos[i])
+  }
+
+  for (let i = fl(k / 2), limit = pos.length - fl((k - 1) / 2); i <limit; i++) {
+    const lcnt = fl(k / 2),
+      rcnt = fl((k - 1) / 2)
+    let current =
+      lcnt * pos[i] - (pre[i] - pre[i - lcnt]) - (lcnt * (lcnt + 1)) / 2
+    current +=
+      pre[i + 1 + rcnt] - pre[i + 1] - rcnt * pos[i] - (rcnt * (rcnt + 1)) / 2
+
+    res = min(res, current)
+  }
+  return res
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From eddbba59af10e51331129d2e4630db34b226ec87 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Nov 2022 20:54:10 +0800
Subject: [PATCH 2429/3374] Create 2214-minimum-health-to-beat-game.js

---
 2214-minimum-health-to-beat-game.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 2214-minimum-health-to-beat-game.js

diff --git a/2214-minimum-health-to-beat-game.js b/2214-minimum-health-to-beat-game.js
new file mode 100644
index 00000000..21c1d29e
--- /dev/null
+++ b/2214-minimum-health-to-beat-game.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} damage
+ * @param {number} armor
+ * @return {number}
+ */
+const minimumHealth = function(damage, armor) {
+  const l = Math.max(...damage) 
+  const sum = damage.reduce((ac, e) => ac + e, 0)
+  return sum - (armor >= l ? l : armor) + 1
+};

From bcd06973a23c8cf8735845c83b8dbce3907087a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Nov 2022 19:54:49 +0800
Subject: [PATCH 2430/3374] Create
 2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js

---
 ...s-of-a-node-in-a-directed-acyclic-graph.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js

diff --git a/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js b/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js
new file mode 100644
index 00000000..1c9f83e7
--- /dev/null
+++ b/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[][]}
+ */
+const getAncestors = function(n, edges) {
+  const res = Array.from({ length: n }, () => new Set())
+  const inDegree = Array(n).fill(0)
+  const graph = {}
+  
+  for(const [u, v] of edges) {
+    if(graph[v] == null) graph[v] = []
+    graph[v].push(u)
+    inDegree[v]++
+  }
+  
+  const visited = Array(n).fill(false)
+  for (let i = 0; i < n; i++) {
+    if (!visited[i]) dfs(i);
+  }
+
+  return res.map(set => Array.from(set).sort((a, b) => a - b))
+  
+  function dfs(i) {
+    visited[i] = true
+    for(const p of (graph[i] || [])) {
+      if(visited[p] === false) dfs(p)
+      res[i].add(p)
+      for(const e of res[p]) res[i].add(e)
+    }
+  }
+};

From 16a0f71c37ac6a876dc4c62c29468fc494b4b2d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Nov 2022 21:06:29 +0800
Subject: [PATCH 2431/3374] Update
 2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js

---
 ...s-of-a-node-in-a-directed-acyclic-graph.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js b/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js
index 1c9f83e7..4ae95f82 100644
--- a/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js
+++ b/2192-all-ancestors-of-a-node-in-a-directed-acyclic-graph.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[][]}
+ */
+const getAncestors = function(n, edges) {
+  const res = Array.from({ length: n }, () => [])
+  const graph = {}
+  
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = []
+    graph[u].push(v)
+  }
+  
+  for(let i = 0; i < n; i++) {
+    dfs(i, i)
+  }
+  
+  return res
+  
+  function dfs(p, cur) {
+    for(const nxt of (graph[cur] || [])) {
+      if(res[nxt].length === 0 || res[nxt][res[nxt].length - 1] !== p) {
+        res[nxt].push(p)
+        dfs(p, nxt)
+      }
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 4e2b529944c1b6b1f613b49e94b6001036725200 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 3 Nov 2022 20:14:02 +0800
Subject: [PATCH 2432/3374] Update 315-count-of-smaller-numbers-after-self.js

---
 315-count-of-smaller-numbers-after-self.js | 57 ++++++++++++++++++++++
 1 file changed, 57 insertions(+)

diff --git a/315-count-of-smaller-numbers-after-self.js b/315-count-of-smaller-numbers-after-self.js
index 16df5aa7..8bda9213 100644
--- a/315-count-of-smaller-numbers-after-self.js
+++ b/315-count-of-smaller-numbers-after-self.js
@@ -78,3 +78,60 @@ function insert(num, node, ans, i, preSum) {
   }
   return node
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const countSmaller = function(nums) {
+  
+  const arr = []
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    arr.push([nums[i], i])
+  }
+  
+  const res = Array(n).fill(0)
+  cntSmaller(arr, 0, n - 1, res)
+  
+  return res
+  
+  function cntSmaller(arr, l, r, res) {
+    if(l >= r) return
+    
+    const mid = ~~((l + r) / 2)
+    cntSmaller(arr, l, mid, res)
+    cntSmaller(arr, mid + 1, r, res)
+    let leftPos = l, rightPos = mid + 1, cnt = 0
+    const merged = []
+    while(leftPos < mid + 1 && rightPos <= r) {
+      if(arr[leftPos][0] > arr[rightPos][0]) {
+        cnt++
+        merged.push(arr[rightPos])
+        rightPos++
+      } else {
+        res[arr[leftPos][1]] += cnt
+        merged.push(arr[leftPos])
+        leftPos++
+      }
+    }
+    
+    while(leftPos < mid + 1) {
+      res[arr[leftPos][1]] += cnt
+      merged.push(arr[leftPos])
+      leftPos++
+    }
+    
+    while(rightPos <= r) {
+      merged.push(arr[rightPos])
+      rightPos++
+    }
+    
+    for(let i = l; i <= r; i++) {
+      arr[i] = merged[i - l]
+    }
+    
+  }
+};

From 6825859fb2d689691ecb6282f4b4d7781bc94f83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Nov 2022 15:41:02 +0800
Subject: [PATCH 2433/3374] Update 493-reverse-pairs.js

---
 493-reverse-pairs.js | 49 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/493-reverse-pairs.js b/493-reverse-pairs.js
index bb76e4c8..1ad26aa2 100644
--- a/493-reverse-pairs.js
+++ b/493-reverse-pairs.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const reversePairs = function(nums) {
+    return mergeSort(nums, [], 0, nums.length-1);
+};
+
+function mergeSort(arr, temp, left, right){
+    let mid = Math.floor((left+right)/2), count = 0;
+    if(left<right){
+        count+= mergeSort(arr, temp, left, mid);
+        count+= mergeSort(arr, temp, mid+1, right);
+        count+= merge(arr, temp, left, mid+1, right);
+    }
+    return count;
+}
+
+function merge(a, temp, left, mid, right){
+    let i = left, j = mid, k = left, count=0;
+    for(let y=left; y<mid; y++){
+        while(j<=right && (a[y]>2*a[j])){
+            j++;
+        }
+        count+= (j-(mid));
+    }
+    i=left;
+    j=mid;
+    while(i<=(mid-1) && j<=right){
+        if (a[i]>(a[j])) {
+            temp[k++] = a[j++];
+        } else {
+            temp[k++] = a[i++];
+        }
+    }
+    while(i<=(mid-1)){
+        temp[k++] = a[i++];
+    }
+    while(j<=right){
+        temp[k++] = a[j++];
+    }
+    for(let x=left; x<=right; x++){
+        a[x] = temp[x];
+    }
+    return count;
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 9df567c3076970206779fdebad3fa0bc45f2406b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Nov 2022 12:40:09 +0800
Subject: [PATCH 2434/3374] Create 2463-minimum-total-distance-traveled.js

---
 2463-minimum-total-distance-traveled.js | 26 +++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2463-minimum-total-distance-traveled.js

diff --git a/2463-minimum-total-distance-traveled.js b/2463-minimum-total-distance-traveled.js
new file mode 100644
index 00000000..5eadfe65
--- /dev/null
+++ b/2463-minimum-total-distance-traveled.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} robot
+ * @param {number[][]} factory
+ * @return {number}
+ */
+const minimumTotalDistance = function(robot, factory) {
+  robot.sort((a, b) => a - b)
+  factory.sort((a, b) => a[0] - b[0])
+  const facs = []
+  for(const f of factory) {
+    for(let i = 0; i < f[1]; i++) facs.push(f[0])
+  }
+  const n = facs.length
+  let dp = Array(n + 1).fill(0)
+  for(let i = 0; i < robot.length; i++) {
+    const nxt = Array(n + 1).fill(Infinity)
+    for(let j = 0; j < n; j++) {
+      nxt[j + 1] = Math.min(nxt[j], dp[j] + Math.abs(robot[i] - facs[j]))
+    }
+    dp = nxt
+  }
+  
+  
+  return dp[n]
+};
+

From b2ef4af649feccc6a23d2bcd50b124b8af80bd73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Nov 2022 12:40:53 +0800
Subject: [PATCH 2435/3374] Create 2462-total-cost-to-hire-k-workers.js

---
 2462-total-cost-to-hire-k-workers.js | 138 +++++++++++++++++++++++++++
 1 file changed, 138 insertions(+)
 create mode 100644 2462-total-cost-to-hire-k-workers.js

diff --git a/2462-total-cost-to-hire-k-workers.js b/2462-total-cost-to-hire-k-workers.js
new file mode 100644
index 00000000..017f4c3e
--- /dev/null
+++ b/2462-total-cost-to-hire-k-workers.js
@@ -0,0 +1,138 @@
+/**
+ * @param {number[]} costs
+ * @param {number} k
+ * @param {number} candidates
+ * @return {number}
+ */
+const totalCost = function(costs, k, candidates) {
+  const fn = (a, b) => a[0] === b[0] ? a[1] < b[1] : a[0] < b[0]
+  const n = costs.length
+  let l = 0, r = n - 1
+  const first = new PriorityQueue(fn)
+  const last = new PriorityQueue(fn)
+  
+  for(let i = 0; i < Math.min(candidates, n); i++) {
+    first.push([costs[i], i])
+    l = i
+  }
+  
+  for(let i = n - 1; i > Math.max(0, candidates - 1, n - 1 - candidates); i--) {
+    last.push([costs[i], i])
+    r = i
+  }
+  
+  // console.log(first, last)
+  
+  let res = 0
+  let num = k
+  while(num) {
+    const ft = first.peek()
+    const lt = last.peek()
+    
+    if(ft && lt) {
+      if(ft[0] < lt[0]) {
+        first.pop()
+        res += ft[0]
+        if(r - l > 1) {
+          l++
+          first.push([costs[l], l])
+        }
+      } else if(ft[0] > lt[0]) {
+        last.pop()
+        res += lt[0]
+        if(r - l > 1) {
+          r--
+          last.push([costs[r], r])
+        }
+      } else {
+        first.pop()
+        res += ft[0]
+        if(r - l > 1) {
+          l++
+          first.push([costs[l], l])
+        } 
+      }
+    } else if(ft) {
+      first.pop()
+      res += ft[0]
+    } else if(lt) {
+      last.pop()
+      res += lt[0]
+    }
+    // console.log(res)
+    num--
+  }
+  
+  
+  return res
+  
+};
+
+
+class PriorityQueue {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From c6cff3d26376ee8ea492b841e0e2696a776e6fce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Nov 2022 12:41:17 +0800
Subject: [PATCH 2436/3374] Create
 2461-maximum-sum-of-distinct-subarrays-with-length-k.js

---
 ...sum-of-distinct-subarrays-with-length-k.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2461-maximum-sum-of-distinct-subarrays-with-length-k.js

diff --git a/2461-maximum-sum-of-distinct-subarrays-with-length-k.js b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
new file mode 100644
index 00000000..f2d9bb8e
--- /dev/null
+++ b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumSubarraySum = function(nums, k) {
+  let res = 0
+  const n = nums.length
+  
+  const preSum = Array(n).fill(0)
+  preSum[0] = nums[0]
+  for(let i = 1; i < n; i++) {
+    preSum[i] = preSum[i - 1] + nums[i]
+  }
+  
+  const set = new Set()
+  
+  const lastHash = {}
+  
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    lastHash[cur] = i
+    if(i < k - 1) set.add(cur)
+    else if(i === k - 1) {
+      set.add(cur)
+      if(set.size === k) {
+        res = preSum[i]
+      }
+    } else {
+      if(lastHash[nums[i - k]] == i - k) set.delete(nums[i - k])
+      set.add(nums[i])
+      if(set.size === k) {
+        res = Math.max(res, preSum[i] - preSum[i - k])
+      }
+    }
+  }
+  
+  return res
+};

From 5346a23988ee3d788d694aeafb73857d93e9feb2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Nov 2022 12:41:43 +0800
Subject: [PATCH 2437/3374] Create 2460-apply-operations-to-an-array.js

---
 2460-apply-operations-to-an-array.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2460-apply-operations-to-an-array.js

diff --git a/2460-apply-operations-to-an-array.js b/2460-apply-operations-to-an-array.js
new file mode 100644
index 00000000..01ac392e
--- /dev/null
+++ b/2460-apply-operations-to-an-array.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var applyOperations = function(nums) {
+  const n = nums.length
+  for(let i = 0; i < n - 1; i++) {
+    if(nums[i] === nums[i + 1]) {
+      nums[i] *= 2
+      nums[i + 1] = 0
+    }
+  }
+  const res = nums.filter(e => e !== 0)
+  while(res.length !== n) res.push(0)
+  return res
+};

From 99fdc7b8d033a7b467d8902ae997beeed90371d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Nov 2022 10:27:23 +0800
Subject: [PATCH 2438/3374] Update
 1649-create-sorted-array-through-instructions.js

---
 ...reate-sorted-array-through-instructions.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1649-create-sorted-array-through-instructions.js b/1649-create-sorted-array-through-instructions.js
index 6f30ca3c..d186bcd8 100644
--- a/1649-create-sorted-array-through-instructions.js
+++ b/1649-create-sorted-array-through-instructions.js
@@ -34,3 +34,50 @@ const createSortedArray = function(instructions) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} instructions
+ * @return {number}
+ */
+const createSortedArray = function (instructions) {
+  const ins = instructions, n = ins.length
+  let res = 0
+  const mod = 1e9 + 7, { min } = Math
+  const bit = new BIT(1e5)
+  for(let i = 0; i < n; i++) {
+    const cur = ins[i]
+    res = (res + min(bit.query(cur - 1), i - bit.query(cur))) % mod
+    bit.update(cur, 1)
+  } 
+
+  return res
+}
+
+function lowBit(x) {
+  return x & -x
+}
+class BIT {
+  constructor(n) {
+    this.arr = Array(n + 1).fill(0)
+  }
+
+  update(i, delta) {
+    if(i < 1) return
+    while (i < this.arr.length) {
+      this.arr[i] += delta
+      i += lowBit(i)
+    }
+  }
+
+  query(i) {
+    let res = 0
+    if(i < 1) return res
+    while (i > 0) {
+      res += this.arr[i]
+      i -= lowBit(i)
+    }
+    return res
+  }
+}

From 1f906b533ea1c60cd62e593ee2984489e27114c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Nov 2022 13:39:50 +0800
Subject: [PATCH 2439/3374] Create
 2426-number-of-pairs-satisfying-inequality.js

---
 2426-number-of-pairs-satisfying-inequality.js | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 2426-number-of-pairs-satisfying-inequality.js

diff --git a/2426-number-of-pairs-satisfying-inequality.js b/2426-number-of-pairs-satisfying-inequality.js
new file mode 100644
index 00000000..942eb56b
--- /dev/null
+++ b/2426-number-of-pairs-satisfying-inequality.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} diff
+ * @return {number}
+ */
+const numberOfPairs = function (nums1, nums2, diff) {
+  const n = nums1.length, limit = 6 * 1e4, add = 3 * 1e4
+  const bit = new BIT(limit)
+
+  let res = 0
+  for(let j = 0; j < n; j++) {
+    const d = nums1[j] - nums2[j] + add
+    res += bit.query(d + diff)
+    bit.update(d, 1)
+  }
+
+  return res
+}
+
+function lowBit(x) {
+  return x & -x
+}
+class BIT {
+  constructor(n) {
+    this.arr = Array(n + 1).fill(0)
+  }
+
+  update(i, delta) {
+    if(i < 1) return
+    while (i < this.arr.length) {
+      this.arr[i] += delta
+      i += lowBit(i)
+    }
+  }
+
+  query(i) {
+    let res = 0
+    if(i < 1) return res
+    while (i > 0) {
+      res += this.arr[i]
+      i -= lowBit(i)
+    }
+    return res
+  }
+}

From 60534027406637c3c0d6ab105933fc295eb45079 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Nov 2022 13:01:10 +0800
Subject: [PATCH 2440/3374] Create 2438-range-product-queries-of-powers.js

---
 2438-range-product-queries-of-powers.js | 29 +++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2438-range-product-queries-of-powers.js

diff --git a/2438-range-product-queries-of-powers.js b/2438-range-product-queries-of-powers.js
new file mode 100644
index 00000000..1d4235f4
--- /dev/null
+++ b/2438-range-product-queries-of-powers.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number} n
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const productQueries = function(n, queries) {
+  const mod = 1e9 + 7
+  const powers = []
+  let pow = 1
+  while(n) {
+    const tmp = (n & 1) * pow
+    if(tmp) powers.push(tmp)
+    n = n >> 1
+    pow *= 2
+  }
+
+  // console.log(powers)
+  const res = []
+  
+  for(const [s, e] of queries) {
+     let tmp = 1
+     for(let i = s; i <= e; i++) {
+         tmp = (tmp * powers[i]) % mod
+     }
+     res.push(tmp)
+  }
+  
+  return res
+};

From 628aab41ea0bc9987d4f3499e0b1a09ff556fdd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Nov 2022 17:45:51 +0800
Subject: [PATCH 2441/3374] Create
 1523-count-odd-numbers-in-an-interval-range.js

---
 1523-count-odd-numbers-in-an-interval-range.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 1523-count-odd-numbers-in-an-interval-range.js

diff --git a/1523-count-odd-numbers-in-an-interval-range.js b/1523-count-odd-numbers-in-an-interval-range.js
new file mode 100644
index 00000000..12d862e1
--- /dev/null
+++ b/1523-count-odd-numbers-in-an-interval-range.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const countOdds = function(low, high) {
+  let res = 0
+  
+  const odd = num => num % 2 === 1
+  if(odd(low)) res++
+    
+  const num = Math.floor( (high - low) / 2 )
+  res += num
+  
+  if(high > low + 2 * num && odd(high)) res++
+  
+  return res
+};

From 8ba37037cee4ce483bc5fe0c21448a3340d01a2d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Nov 2022 17:56:14 +0800
Subject: [PATCH 2442/3374] Update
 1523-count-odd-numbers-in-an-interval-range.js

---
 1523-count-odd-numbers-in-an-interval-range.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/1523-count-odd-numbers-in-an-interval-range.js b/1523-count-odd-numbers-in-an-interval-range.js
index 12d862e1..2c47f34f 100644
--- a/1523-count-odd-numbers-in-an-interval-range.js
+++ b/1523-count-odd-numbers-in-an-interval-range.js
@@ -16,3 +16,15 @@ const countOdds = function(low, high) {
   
   return res
 };
+
+
+// another
+
+/**
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const countOdds = function(low, high) {
+  return ~~((high + 1) / 2) - (~~(low / 2))
+};

From d8966d4daa37e9e814270190befa80edcea2bab3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Nov 2022 14:11:28 +0800
Subject: [PATCH 2443/3374] Create 2423-remove-letter-to-equalize-frequency.js

---
 2423-remove-letter-to-equalize-frequency.js | 23 +++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2423-remove-letter-to-equalize-frequency.js

diff --git a/2423-remove-letter-to-equalize-frequency.js b/2423-remove-letter-to-equalize-frequency.js
new file mode 100644
index 00000000..57163f53
--- /dev/null
+++ b/2423-remove-letter-to-equalize-frequency.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} word
+ * @return {boolean}
+ */
+const equalFrequency = function (word) {
+  const cnt = {}
+  for(const ch of word) {
+    if(cnt[ch] == null) cnt[ch] = 0
+    cnt[ch]++
+  }
+
+  for(const ch of word) {
+    cnt[ch]--
+    if(cnt[ch] === 0) delete cnt[ch]
+    const s = new Set([...Object.values(cnt)])
+    if(s.size === 1) return true
+
+    if(cnt[ch] == null) cnt[ch] = 0
+    cnt[ch]++ 
+  }
+
+  return false
+}

From ebb64cb2c033065b51d856a1f843b61a2477b442 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Nov 2022 15:23:26 +0800
Subject: [PATCH 2444/3374] Update 1224-maximum-equal-frequency.js

---
 1224-maximum-equal-frequency.js | 38 +++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1224-maximum-equal-frequency.js b/1224-maximum-equal-frequency.js
index 0f1bb6b1..13eda968 100644
--- a/1224-maximum-equal-frequency.js
+++ b/1224-maximum-equal-frequency.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxEqualFreq = function (nums) {
+  const freqCnt = {}, cnt = {}, { max } = Math
+
+  let res = 0, maxF = 0, i = 0
+  for(const e of nums) {
+    if(cnt[e] == null) cnt[e] = 0
+    cnt[e]++
+
+    const f = cnt[e]
+
+    if(freqCnt[f - 1] == null) freqCnt[f - 1] = 0
+    if(freqCnt[f] == null) freqCnt[f] = 0
+    
+    if(freqCnt[f - 1] > 0) freqCnt[f - 1]--
+    freqCnt[f]++
+
+    maxF = max(maxF, f)
+
+    if(
+      maxF === 1 ||
+      maxF * freqCnt[maxF] === i ||
+      (maxF - 1) * (freqCnt[maxF - 1] + 1) === i
+    ) {
+      res = i + 1
+    }
+
+    i++
+  }
+
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 6b72ba51bd433426c6c7d021be7921067caf65b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Nov 2022 15:26:39 +0800
Subject: [PATCH 2445/3374] Update 1224-maximum-equal-frequency.js

---
 1224-maximum-equal-frequency.js | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/1224-maximum-equal-frequency.js b/1224-maximum-equal-frequency.js
index 13eda968..192cc0e6 100644
--- a/1224-maximum-equal-frequency.js
+++ b/1224-maximum-equal-frequency.js
@@ -20,6 +20,14 @@ const maxEqualFreq = function (nums) {
 
     maxF = max(maxF, f)
 
+    /*
+    cnt records the occurence of each num, freq records the frequence of number of occurences. max_F is the largest frequence.
+    There are three cases which satify the condition:
+
+    all elements appear exact once.
+    all elements appear max_F times, except one appears once.
+    all elements appear max_F-1 times, except one appears max_F.
+    */
     if(
       maxF === 1 ||
       maxF * freqCnt[maxF] === i ||

From c23c35d8b7d98f641156911f249b3d08f4074482 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Nov 2022 14:02:32 +0800
Subject: [PATCH 2446/3374] Create
 2380-time-needed-to-rearrange-a-binary-string.js

---
 2380-time-needed-to-rearrange-a-binary-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2380-time-needed-to-rearrange-a-binary-string.js

diff --git a/2380-time-needed-to-rearrange-a-binary-string.js b/2380-time-needed-to-rearrange-a-binary-string.js
new file mode 100644
index 00000000..62543287
--- /dev/null
+++ b/2380-time-needed-to-rearrange-a-binary-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var secondsToRemoveOccurrences = function(s) {
+  const n = s.length
+    let zeros = 0, seconds = 0;
+    for (let i = 0; i < n; ++i) {
+        zeros += s.charAt(i) == '0' ? 1 : 0;
+        if (s.charAt(i) == '1' && zeros > 0)
+            seconds = Math.max(seconds + 1, zeros);
+    }
+    return seconds; 
+};

From 631ba8ed86aef8bf0de07e3600df28be51b23c2f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Nov 2022 22:48:30 +0800
Subject: [PATCH 2447/3374] Update
 2380-time-needed-to-rearrange-a-binary-string.js

---
 ...ime-needed-to-rearrange-a-binary-string.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/2380-time-needed-to-rearrange-a-binary-string.js b/2380-time-needed-to-rearrange-a-binary-string.js
index 62543287..08f3cfc3 100644
--- a/2380-time-needed-to-rearrange-a-binary-string.js
+++ b/2380-time-needed-to-rearrange-a-binary-string.js
@@ -1,3 +1,24 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const secondsToRemoveOccurrences = function(s) {
+  let zeros = 0
+  const n = s.length, { max } = Math
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '0') zeros++
+    if(s[i] === '1' && zeros > 0) {
+      res = max(res + 1, zeros)
+    }
+  }
+  return res 
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From e838742f608cb0574c19cc51a29b114a14d944eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Nov 2022 21:52:12 +0800
Subject: [PATCH 2448/3374] Create 2337-move-pieces-to-obtain-a-string.js

---
 2337-move-pieces-to-obtain-a-string.js | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2337-move-pieces-to-obtain-a-string.js

diff --git a/2337-move-pieces-to-obtain-a-string.js b/2337-move-pieces-to-obtain-a-string.js
new file mode 100644
index 00000000..51679d87
--- /dev/null
+++ b/2337-move-pieces-to-obtain-a-string.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} start
+ * @param {string} target
+ * @return {boolean}
+ */
+const canChange = function(start, target) {
+    const n=target.length;
+    let i=0,j=0;
+    while(i<=n && j<=n){
+
+        while(i<n && target[i]==='_') i++;
+        while(j<n && start[j]==='_') j++;
+
+        if(i===n || j===n){
+            return i===n && j===n;
+        }
+
+        if(target[i]!==start[j]) return false;
+
+        if(target[i]==='L'){
+            if(j<i) return false;
+        }
+        else{
+            if(i<j) return false;
+        }
+
+        i++;
+        j++;
+    }
+    return true;
+};

From d3acb0fc251ab49917f082c067c410631a1866ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Nov 2022 23:22:00 +0800
Subject: [PATCH 2449/3374] Create 2469-convert-the-temperature.js

---
 2469-convert-the-temperature.js | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 2469-convert-the-temperature.js

diff --git a/2469-convert-the-temperature.js b/2469-convert-the-temperature.js
new file mode 100644
index 00000000..bafc470d
--- /dev/null
+++ b/2469-convert-the-temperature.js
@@ -0,0 +1,7 @@
+/**
+ * @param {number} celsius
+ * @return {number[]}
+ */
+var convertTemperature = function(celsius) {
+  return [celsius + 273.15, celsius * 1.8 + 32]  
+};

From 231b2049b96a4dff48ee54007fe0d12332f23439 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Nov 2022 23:22:25 +0800
Subject: [PATCH 2450/3374] Create
 2470-number-of-subarrays-with-lcm-equal-to-k.js

---
 ...number-of-subarrays-with-lcm-equal-to-k.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2470-number-of-subarrays-with-lcm-equal-to-k.js

diff --git a/2470-number-of-subarrays-with-lcm-equal-to-k.js b/2470-number-of-subarrays-with-lcm-equal-to-k.js
new file mode 100644
index 00000000..ddab1984
--- /dev/null
+++ b/2470-number-of-subarrays-with-lcm-equal-to-k.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var subarrayLCM = function(nums, k) {
+   let res = 0
+   const n = nums.length
+   
+   for(let i = 0; i < n; i++) {
+     let tmp = nums[i]
+     for(let j = i; j < n; j++) {
+       if(k % nums[j] !== 0) break
+       if(lcm(tmp, nums[j]) === k) res++
+       tmp = Math.max(tmp, nums[j])
+     }
+   }
+   
+   return res
+};
+
+
+function lcm(a, b) {
+  return a * b / gcd(a, b);
+}
+
+function gcd(a, b) {
+  return b ? gcd(b, a % b) : a
+}

From 3bee590f22b2bc6bb16d77fcf56f07954786020c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Nov 2022 23:22:52 +0800
Subject: [PATCH 2451/3374] Create
 2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js

---
 ...erations-to-sort-a-binary-tree-by-level.js | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js

diff --git a/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js b/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js
new file mode 100644
index 00000000..146a0099
--- /dev/null
+++ b/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js
@@ -0,0 +1,84 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+var minimumOperations = function(root) {
+  let res = 0
+  let q = []
+  q.push(root)
+  
+  while(q.length) {
+    const nxt = []
+    res += minSwaps(q.map(e =>  e.val), q.length)    
+    const len = q.length
+    
+    for(let i = 0; i < len; i++) {
+      const cur = q[i]
+      if(cur.left) nxt.push(cur.left)
+      if(cur.right) nxt.push(cur.right)
+    }
+
+    q = nxt
+  }
+  
+  
+  return res
+};
+
+function swap(arr, i, j)
+{
+  let temp = arr[i];
+  arr[i] = arr[j];
+  arr[j] = temp;
+}
+ 
+// Return the minimum number
+// of swaps required to sort
+// the array
+function minSwaps(arr,N)
+{
+  let ans = 0;
+  let temp = arr.slice();
+ 
+  // Hashmap which stores the
+  // indexes of the input array
+  let h = new Map();
+ 
+  temp.sort((a, b) => a - b);
+  for (let i = 0; i < N; i++)
+  {
+    h.set(arr[i], i);
+  }
+  for (let i = 0; i < N; i++)
+  {
+   
+    // This is checking whether
+    // the current element is
+    // at the right place or not
+    if (arr[i] != temp[i])
+    {
+      ans++;
+      let init = arr[i];
+ 
+      // If not, swap this element
+      // with the index of the
+      // element which should come here
+      swap(arr, i, h.get(temp[i]));
+ 
+      // Update the indexes in
+      // the hashmap accordingly
+      h.set(init,h.get(temp[i]));
+      h.set(temp[i],i);
+    }
+  }
+  // console.log(arr, ans)
+  return ans;
+}

From c753a4a27b12a4e0a3c241d1fcd654427c3417e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Nov 2022 23:31:08 +0800
Subject: [PATCH 2452/3374] Create
 2472-maximum-number-of-non-overlapping-palindrome-substrings.js

---
 ...f-non-overlapping-palindrome-substrings.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2472-maximum-number-of-non-overlapping-palindrome-substrings.js

diff --git a/2472-maximum-number-of-non-overlapping-palindrome-substrings.js b/2472-maximum-number-of-non-overlapping-palindrome-substrings.js
new file mode 100644
index 00000000..e262fe6a
--- /dev/null
+++ b/2472-maximum-number-of-non-overlapping-palindrome-substrings.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const maxPalindromes = function(s, k) {
+  const len = s.length;
+  // dp[i] 表示s[0 .. i - 1] 中的不重叠回文子字符串的最大数目
+  const dp = new Array(len + 1).fill(0);
+  // 如果s[i]不在回文字符串内，dp[i+1]=dp[i];
+  // 如果s[l..r]是回文字符串且长度不小于k，那么dp[r+1]=max(dp[r+1],dp[l]+1)
+
+  // 中心扩展法
+  // 回文中心：len个单字符和len-1个双字符
+  for (let center = 0; center < 2 * len - 1; center++) {
+    let l = center >> 1,
+      r = l + (center % 2);
+    dp[l + 1] = Math.max(dp[l + 1], dp[l]);
+    while (l >= 0 && r < len && s[l] === s[r]) {
+      if (r - l + 1 >= k) {
+        dp[r + 1] = Math.max(dp[r + 1], dp[l] + 1);
+      }
+      // expand from center
+      l--, r++;
+    }
+  }
+
+  return dp[len];
+};

From 96bf44bb6704f888291488def5e25f3202531951 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Nov 2022 13:13:50 +0800
Subject: [PATCH 2453/3374] Create 2453-destroy-sequential-targets.js

---
 2453-destroy-sequential-targets.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2453-destroy-sequential-targets.js

diff --git a/2453-destroy-sequential-targets.js b/2453-destroy-sequential-targets.js
new file mode 100644
index 00000000..8e0b486e
--- /dev/null
+++ b/2453-destroy-sequential-targets.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} space
+ * @return {number}
+ */
+const destroyTargets = function(nums, space) {
+  let maxCount = -Infinity;
+  const map = {};
+
+  for (const num of nums) {
+    const reminder = num % space;
+    map[reminder] = (map[reminder] || 0) + 1;
+    maxCount = Math.max(maxCount, map[reminder]);
+  }
+
+  let ans = Infinity;
+  for (const num of nums) {
+    if (map[num % space] === maxCount) {
+      ans = Math.min(ans, num);
+    }
+  }
+
+  return ans;
+};

From 88b94e669286aaabe60711ce62261e6a9c428514 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Nov 2022 16:09:54 +0800
Subject: [PATCH 2454/3374] Update 1286-iterator-for-combination.js

---
 1286-iterator-for-combination.js | 51 ++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/1286-iterator-for-combination.js b/1286-iterator-for-combination.js
index 2357732c..f5f904cb 100644
--- a/1286-iterator-for-combination.js
+++ b/1286-iterator-for-combination.js
@@ -41,3 +41,54 @@ function build(max, str, out = [], curr = '') {
 
   return out
 }
+
+// another
+
+/**
+ * @param {string} characters
+ * @param {number} combinationLength
+ */
+const CombinationIterator = function(characters, combinationLength) {
+  const res = [], len = combinationLength, str = characters, n = str.length
+  helper([], 0)
+  this.arr = res
+  this.idx = 0
+  
+  function helper(cur, idx) {
+      if(cur.length === len) {
+          res.push(cur.slice().join(''))
+          return
+      }
+      if(idx >= n) return
+
+      cur.push(str[idx])
+      helper(cur, idx + 1)
+      cur.pop()
+
+      helper(cur, idx + 1)
+  }
+};
+
+/**
+ * @return {string}
+ */
+CombinationIterator.prototype.next = function() {
+  if(this.hasNext()) {
+      return this.arr[this.idx++]
+  }
+};
+
+/**
+ * @return {boolean}
+ */
+CombinationIterator.prototype.hasNext = function() {
+  return this.arr[this.idx] != null
+};
+
+/** 
+ * Your CombinationIterator object will be instantiated and called as such:
+ * var obj = new CombinationIterator(characters, combinationLength)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+

From 2074d6bf6c5d950331ab89576e4e3159e3303cd4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Nov 2022 20:00:10 +0800
Subject: [PATCH 2455/3374] Update 1286-iterator-for-combination.js

---
 1286-iterator-for-combination.js | 54 ++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1286-iterator-for-combination.js b/1286-iterator-for-combination.js
index f5f904cb..314526bf 100644
--- a/1286-iterator-for-combination.js
+++ b/1286-iterator-for-combination.js
@@ -92,3 +92,57 @@ CombinationIterator.prototype.hasNext = function() {
  * var param_2 = obj.hasNext()
  */
 
+// another
+
+/**
+ * @param {string} characters
+ * @param {number} combinationLength
+ */
+const CombinationIterator = function(characters, combinationLength) {
+  const res = [], len = combinationLength, str = characters, n = str.length
+  helper()
+
+  // console.log(res)
+  this.arr = res
+  this.idx = 0
+  
+  function helper() {
+     const limit = 1 << n
+     for(let i = limit - 1; i > 0; i--) {
+       let tmp = i, ts = '', idx = n - 1
+       while(tmp) {
+         if(tmp & 1) {
+           ts = str[idx] + ts
+         }
+         idx--
+         tmp = (tmp >> 1)
+       }
+       if(ts.length === len) res.push(ts)
+     }
+  }
+};
+
+/**
+ * @return {string}
+ */
+CombinationIterator.prototype.next = function() {
+  if(this.hasNext()) {
+      return this.arr[this.idx++]
+  }
+};
+
+/**
+ * @return {boolean}
+ */
+CombinationIterator.prototype.hasNext = function() {
+  return this.arr[this.idx] != null
+};
+
+/** 
+ * Your CombinationIterator object will be instantiated and called as such:
+ * var obj = new CombinationIterator(characters, combinationLength)
+ * var param_1 = obj.next()
+ * var param_2 = obj.hasNext()
+ */
+
+

From 210a65aef81dd1ca78b688c6cef3efc5fef913ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Nov 2022 16:50:06 +0800
Subject: [PATCH 2456/3374] Update
 1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js

---
 ...aving-the-same-number-of-distinct-balls.js | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js b/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js
index 91fd6105..465ec0b8 100644
--- a/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js
+++ b/1467-probability-of-a-two-boxes-having-the-same-number-of-distinct-balls.js
@@ -1,3 +1,71 @@
+/**
+ * @param {number[]} balls
+ * @return {number}
+ */
+const getProbability = function(balls) {
+  const k = balls.length;
+  const halfUsed = balls.reduce((acc, val) => acc + val, 0) / 2;
+  const startArray = new Array(k);
+  startArray.fill(0);
+  const perm = function (b1, b2) {
+    let p1, p2, s1, s2;
+    s1 = b1.reduce((acc, val) => acc + val, 0);
+    s2 = b2.reduce((acc, val) => acc + val, 0);
+    const fact = function (n) {
+      let f = 1;
+      for (let i = 2; i <= n; i++) f *= i;
+      return f;
+    };
+    p1 = fact(s1);
+    p2 = fact(s2);
+    b1.forEach((val) => {
+      if (val > 1) p1 /= fact(val);
+    });
+    b2.forEach((val) => {
+      if (val > 1) p2 /= fact(val);
+    });
+    return p1 * p2;
+  };
+
+  const getValidCombos = function (ballsUsed, colorNum = 0) {
+    let box1Used = ballsUsed.reduce((acc, val) => acc + val, 0);
+    let matches = { good: 0, total: 0 },
+      thisColorMax = halfUsed - box1Used;
+    if (colorNum === k - 1) {
+      if (thisColorMax > balls[colorNum]) return { good: 0, total: 0 };
+      ballsUsed[colorNum] = thisColorMax;
+      let ballsLeft = [];
+      let colorsUsed = [0, 0];
+      for (let i = 0; i < k; i++) {
+        ballsLeft[i] = balls[i] - ballsUsed[i];
+        if (ballsUsed[i] > 0) colorsUsed[0]++;
+        if (ballsLeft[i] > 0) colorsUsed[1]++;
+      }
+      let permutations = perm(ballsUsed, ballsLeft, k);
+      return {
+        good: colorsUsed[1] === colorsUsed[0] ? permutations : 0,
+        total: permutations,
+      };
+    }
+    thisColorMax = Math.min(thisColorMax, balls[colorNum]);
+    for (let i = 0; i <= thisColorMax; i++) {
+      let match = getValidCombos([...ballsUsed], colorNum + 1);
+      matches = {
+        good: matches.good + match.good,
+        total: matches.total + match.total,
+      };
+      ballsUsed[colorNum]++;
+    }
+    return matches;
+  };
+  let res = getValidCombos(startArray);
+  return res.good / res.total;
+};
+
+
+// another
+
+
 /**
  * @param {number[]} balls
  * @return {number}

From 8ccd7196bed9e1b5a72c834da7971504f71802c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Nov 2022 19:54:32 +0800
Subject: [PATCH 2457/3374] Create 2478-number-of-beautiful-partitions.js

---
 2478-number-of-beautiful-partitions.js | 56 ++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2478-number-of-beautiful-partitions.js

diff --git a/2478-number-of-beautiful-partitions.js b/2478-number-of-beautiful-partitions.js
new file mode 100644
index 00000000..6f6ec63b
--- /dev/null
+++ b/2478-number-of-beautiful-partitions.js
@@ -0,0 +1,56 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @param {number} minLength
+ * @return {number}
+ */
+const beautifulPartitions = function (s, k, minLength) {
+  const mod = 1e9 + 7
+  const p = new Set(['2', '3', '5', '7'])
+
+  function isPrime(x) {
+    return p.has(x)
+  }
+
+  let n = s.length
+  const dp = Array.from({ length: k + 1 }, () => Array(n).fill(0))
+
+  for (let j = 0; j < n; ++j) {
+    dp[1][j] = isPrime(s[0]) && !isPrime(s[j])
+  }
+  let previous_row = Array(n).fill(0)
+  for (let i = 0; i + 1 < n; ++i) {
+    if (isPrime(s[i + 1])) previous_row[i] = dp[1][i] // update IFF next_index is prime and capable of starting a substring
+    if (i - 1 >= 0)
+      previous_row[i] = (previous_row[i] + previous_row[i - 1]) % mod
+  }
+  for (let i = 2; i <= k; ++i) {
+    let current_row = Array(n).fill(0)
+    for (let end = i * minLength - 1; end < n; ++end) {
+      if (isPrime(s[end])) continue
+
+      // optimization usage
+      let prefixsum = previous_row[end - minLength]
+      let start = (i - 1) * minLength - 1
+      if (start - 1 >= 0)
+        prefixsum = (prefixsum - previous_row[start - 1] + mod) % mod
+      dp[i][end] = (dp[i][end] + prefixsum) % mod
+
+      // update current_row's column only if the next_index is a prime and capable of starting a substring
+      if (end + 1 < n && isPrime(s[end + 1]))
+        current_row[end] = (current_row[end] + dp[i][end]) % mod
+    }
+    // re-calclate prefix sum of current row dp values for each column
+    for (let c = 1; c <= n - 1; ++c) {
+      current_row[c] = (current_row[c] + current_row[c - 1]) % mod
+    }
+
+    // swap previous_row dp values and current_row dp values. why ?
+    // Because current row will become previous row for next row
+    // swap(previous_row, current_row);
+    let tmp = current_row
+    current_row = previous_row
+    previous_row = tmp
+  }
+  return dp[k][n - 1]
+}

From 925a77b443dd85e12167e42f09be62a9bc06ed88 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Nov 2022 19:55:23 +0800
Subject: [PATCH 2458/3374] Create
 2477-minimum-fuel-cost-to-report-to-the-capital.js

---
 ...imum-fuel-cost-to-report-to-the-capital.js | 57 +++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 2477-minimum-fuel-cost-to-report-to-the-capital.js

diff --git a/2477-minimum-fuel-cost-to-report-to-the-capital.js b/2477-minimum-fuel-cost-to-report-to-the-capital.js
new file mode 100644
index 00000000..04e99f78
--- /dev/null
+++ b/2477-minimum-fuel-cost-to-report-to-the-capital.js
@@ -0,0 +1,57 @@
+/**
+ * @param {number[][]} roads
+ * @param {number} seats
+ * @return {number}
+ */
+const minimumFuelCost = function(roads, seats) {
+  const n = roads.length + 1
+  const graph = {}, inDegree = Array(n).fill(0)
+  const nodes = Array(n).fill(null).map((e, i) => ([i, 1, 0]))
+  for(const [u, v] of roads) {
+    if(graph[u] == null) graph[u] = new Set()
+    if(graph[v] == null) graph[v] = new Set()
+    graph[u].add(nodes[v])
+    graph[v].add(nodes[u])
+    
+    inDegree[u]++
+    inDegree[v]++
+  }
+  const { ceil } = Math
+  let q = []
+  
+  for(let i = 0; i < n; i++) {
+    if(inDegree[i] === 1) q.push([i, 1, 0])
+  }
+  // console.log(q)
+  let res = 0
+  const visited = new Set()
+  
+  while(q.length) {
+    const nxt = []
+    const len = q.length
+    for(let i = 0; i < len; i++) {
+      const [c, num, sum] = q[i]
+      if(c === 0) continue
+      for(const node of (graph[c] || [])) {
+        const [e] = node
+        if(visited.has(e)) continue
+        inDegree[e]--        
+        // console.log(c, e, sum, num, res)
+        if(e === 0) res += ceil(num/ seats) + sum
+        else {
+          node[1] += num
+          node[2] += ceil(num / seats) + sum
+          if(inDegree[e] === 1) nxt.push(node)
+        }
+        // console.log(res)
+      }
+      visited.add(c)
+    }
+
+    q = nxt
+    // console.log(q, visited)
+  }
+  
+
+  return res
+};

From d251e222ce70343880f5c2c820f3f6cd50170a96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Nov 2022 19:55:47 +0800
Subject: [PATCH 2459/3374] Create
 2476-closest-nodes-queries-in-a-binary-search-tree.js

---
 ...t-nodes-queries-in-a-binary-search-tree.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 2476-closest-nodes-queries-in-a-binary-search-tree.js

diff --git a/2476-closest-nodes-queries-in-a-binary-search-tree.js b/2476-closest-nodes-queries-in-a-binary-search-tree.js
new file mode 100644
index 00000000..afa8ba99
--- /dev/null
+++ b/2476-closest-nodes-queries-in-a-binary-search-tree.js
@@ -0,0 +1,63 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number[]} queries
+ * @return {number[][]}
+ */
+var closestNodes = function(root, queries) {
+    const arr = []
+    function dfs(node) {
+      if(node == null) return
+      dfs(node.left)
+      arr.push(node.val)
+      dfs(node.right)
+    }
+    dfs(root)
+    const res = []
+    // console.log(arr)
+    for(const q of queries) {
+      const tmp = []
+      tmp[0] = ceil(arr, q)
+      tmp[1] = floor(arr, q)
+      res.push(tmp)
+    }
+    
+    return res
+    // maxIdx that <= target  
+    function ceil(arr, q) {
+      const n = arr.length
+      let l = 0, r = n - 1
+      while(l < r) {
+        const mid = r - (~~((r - l) / 2))
+        if(arr[mid] <= q) {
+          l = mid
+        } else {
+          r = mid - 1
+        }
+      }
+      
+      return arr[l] <= q ? arr[l] : -1
+    }
+    // minIdx that >= target
+    function floor(arr, q) {
+      const n = arr.length
+      let l = 0, r = n - 1
+      while(l < r) {
+        const mid = ~~((r + l) / 2)
+        if(arr[mid] < q) {
+          l = mid + 1
+        } else {
+          r = mid
+        }
+      }
+      
+      return arr[l] >= q ? arr[l] : -1
+    }
+};

From 2bcd6abc8ac0a1f41c0a688bff83301292dd454a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Nov 2022 19:56:11 +0800
Subject: [PATCH 2460/3374] Create 2475-number-of-unequal-triplets-in-array.js

---
 2475-number-of-unequal-triplets-in-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2475-number-of-unequal-triplets-in-array.js

diff --git a/2475-number-of-unequal-triplets-in-array.js b/2475-number-of-unequal-triplets-in-array.js
new file mode 100644
index 00000000..9bcacaaf
--- /dev/null
+++ b/2475-number-of-unequal-triplets-in-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const unequalTriplets = function(nums) {
+  let res = 0
+  const n = nums.length
+  
+  for(let i = 0; i < n; i++) {
+    for(let j = i + 1; j < n; j++) {
+      for(let k = j + 1; k < n; k++) {
+        if(nums[i] !== nums[j]  && nums[j] !== nums[k] && nums[i] !== nums[k]) res++
+      }
+    }
+  }
+  
+  return res
+};

From ba9a4c30bb47a2bb1ba91796059d35bbb5b0f3b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Nov 2022 11:38:54 +0800
Subject: [PATCH 2461/3374] Update
 2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js

---
 ...-reach-a-position-after-exactly-k-steps.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js b/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js
index 2a7481e2..e11d1929 100644
--- a/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js
+++ b/2400-number-of-ways-to-reach-a-position-after-exactly-k-steps.js
@@ -1,3 +1,27 @@
+const dp = Array.from({ length: 1000 + 1 }, () => Array(1000 + 1).fill(0))
+const mod = 1e9 + 7
+/**
+ * @param {number} startPos
+ * @param {number} endPos
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfWays = function(startPos, endPos, k) {
+    const { abs } = Math
+    if (dp[1][1] == 0) {
+        for (let k = 1; k <= 1000; ++k) {
+            dp[k][k] = 1;
+            for (let i = 0; i < k; ++i) {
+                dp[k][i] = ((i === 0 ? dp[k - 1][1] : dp[k - 1][i - 1]) + dp[k - 1][i + 1]) % mod;                
+            }
+        }        
+    }
+
+    return dp[k][abs(startPos - endPos)];
+};
+
+// another
+
 /**
  * @param {number} startPos
  * @param {number} endPos

From f1c7f95908f27de5cc1d1131a54f3ed78ae1dcc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Nov 2022 11:53:02 +0800
Subject: [PATCH 2462/3374] Update 41-first-missing-positive.js

---
 41-first-missing-positive.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/41-first-missing-positive.js b/41-first-missing-positive.js
index 3bd7ef24..fa054946 100644
--- a/41-first-missing-positive.js
+++ b/41-first-missing-positive.js
@@ -68,3 +68,32 @@ function swap(arr, i, j) {
   arr[i] = arr[j]
   arr[j] = tmp
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const firstMissingPositive = function(nums) {
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+      while(nums[i] > 0 && nums[i] !== nums[nums[i] - 1] && nums[i] <= n) {
+        swap(i, nums[i] - 1)      
+      }
+  }
+
+    // console.log(nums)
+  for(let i = 0; i < n; i++) {
+      if(nums[i] !== i + 1) return i + 1
+  }
+    
+  return n + 1
+  
+  
+  function swap(i, j) {
+      const tmp = nums[j]
+      nums[j] = nums[i]
+      nums[i] = tmp
+  }
+};

From 8363876311b901da529ad729dedf3a38ca569b2d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Nov 2022 18:00:28 +0800
Subject: [PATCH 2463/3374] Update 268-missing-number.js

---
 268-missing-number.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/268-missing-number.js b/268-missing-number.js
index da2b79ad..69960ce7 100755
--- a/268-missing-number.js
+++ b/268-missing-number.js
@@ -23,3 +23,15 @@ const missingNumber = function(nums) {
 function sum(arr) {
   return arr.reduce((ac, el) => ac + el, 0);
 }
+
+// another
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+  const n = nums.length
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  const target = (n + 1) * n / 2
+  return target - sum
+};

From e94fb057d06376d72d2c488a62c9d7847664facc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 26 Nov 2022 22:40:29 +0800
Subject: [PATCH 2464/3374] Update 287-find-the-duplicate-number.js

---
 287-find-the-duplicate-number.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/287-find-the-duplicate-number.js b/287-find-the-duplicate-number.js
index e4a2fa62..d0a9bb2d 100755
--- a/287-find-the-duplicate-number.js
+++ b/287-find-the-duplicate-number.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findDuplicate = function(nums) {
+    const n = nums.length;
+    let ans = 0;
+    let bit_max = 31;
+    while (((n - 1) >> bit_max) == 0) {
+      bit_max -= 1;
+    }
+    for (let bit = 0; bit <= bit_max; ++bit) {
+      let x = 0, y = 0;
+      for (let i = 0; i < n; ++i) {
+        if ((nums[i] & (1 << bit)) != 0) {
+          x += 1;
+        }
+        if (i >= 1 && ((i & (1 << bit)) != 0)) {
+          y += 1;
+        }
+      }
+      if (x > y) {
+        ans |= 1 << bit;
+      }
+    }
+    return ans;
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From a5bbcdbc66a9e78d9aa2d7fc02e3eb2440ed9dfb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Nov 2022 12:37:31 +0800
Subject: [PATCH 2465/3374] Create 2485-find-the-pivot-integer.js

---
 2485-find-the-pivot-integer.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2485-find-the-pivot-integer.js

diff --git a/2485-find-the-pivot-integer.js b/2485-find-the-pivot-integer.js
new file mode 100644
index 00000000..ca073e25
--- /dev/null
+++ b/2485-find-the-pivot-integer.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var pivotInteger = function(n) {
+  const sum = (1 + n) * n / 2
+  let tmp = 0
+  for(let i = 1; i <= n; i++) {
+    tmp += i
+    if(tmp === sum - tmp + i)  return i
+  }
+  
+  return -1
+};

From fc3f7d46eec8cce3f5b0d3fc3c852147b0570c73 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Nov 2022 12:45:53 +0800
Subject: [PATCH 2466/3374] Create
 2486-append-characters-to-string-to-make-subsequence.js

---
 ...haracters-to-string-to-make-subsequence.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2486-append-characters-to-string-to-make-subsequence.js

diff --git a/2486-append-characters-to-string-to-make-subsequence.js b/2486-append-characters-to-string-to-make-subsequence.js
new file mode 100644
index 00000000..a3f588be
--- /dev/null
+++ b/2486-append-characters-to-string-to-make-subsequence.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+var appendCharacters = function(s, t) {
+  let i =  0, j = 0
+  const m = s.length, n = t.length
+  while(i < m && j < n) {
+    if(s[i] === t[j]) {
+      i++
+      j++
+    } else {
+      i++
+    }
+  }
+  
+  return n - 1 - (j - 1)
+};

From de2e3fcf96baee9cc31da3a0ee07a3fdccf5dcf0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Nov 2022 16:32:18 +0800
Subject: [PATCH 2467/3374] Create 2487-remove-nodes-from-linked-list.js

---
 2487-remove-nodes-from-linked-list.js | 34 +++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2487-remove-nodes-from-linked-list.js

diff --git a/2487-remove-nodes-from-linked-list.js b/2487-remove-nodes-from-linked-list.js
new file mode 100644
index 00000000..4945be49
--- /dev/null
+++ b/2487-remove-nodes-from-linked-list.js
@@ -0,0 +1,34 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const removeNodes = function(head) {
+  const arr = []
+  let cur = head
+  while(cur) {
+    arr.push(cur)
+    cur = cur.next
+  }
+  
+  const stk = []
+  for(const e of arr) {
+    while(stk.length && e.val > stk[stk.length - 1].val) {
+      stk.pop()
+    }
+    stk.push(e)
+  }
+  
+  for(let i = 0; i < stk.length - 1; i++) {
+    const cur = stk[i]
+    cur.next = stk[i + 1]
+  }
+  
+  return stk[0]
+};

From 03e5b46d8a138c6ec0dbff91f2abed52a2492525 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Nov 2022 17:33:12 +0800
Subject: [PATCH 2468/3374] Create 2488-count-subarrays-with-median-k.js

---
 2488-count-subarrays-with-median-k.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2488-count-subarrays-with-median-k.js

diff --git a/2488-count-subarrays-with-median-k.js b/2488-count-subarrays-with-median-k.js
new file mode 100644
index 00000000..d1577b75
--- /dev/null
+++ b/2488-count-subarrays-with-median-k.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countSubarrays = (a, k) => permutationArrayWithMedianK(a, k);
+
+const permutationArrayWithMedianK = (a, k) => {
+    let m = new Map([[0, 1]]), find = false, balance = 0, res = 0;
+    for (const x of a) {
+        if (x < k) {
+            balance--;
+        } else if (x > k) {
+            balance++;
+        } else {
+            find = true;
+        }
+        if (find) {
+            // balance - 1, subarray length is even, has one more right
+            res += (m.get(balance) || 0) + (m.get(balance - 1) || 0);
+        } else {
+            m.set(balance, m.get(balance) + 1 || 1);
+        }
+    }
+    return res;
+};

From 8460d5d5ac916a7380da6487a89219e35f212090 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Nov 2022 23:10:38 +0800
Subject: [PATCH 2469/3374] Create 2439-minimize-maximum-of-array.js

---
 2439-minimize-maximum-of-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2439-minimize-maximum-of-array.js

diff --git a/2439-minimize-maximum-of-array.js b/2439-minimize-maximum-of-array.js
new file mode 100644
index 00000000..cc3c1bcf
--- /dev/null
+++ b/2439-minimize-maximum-of-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimizeArrayValue = function(nums) {
+  const n = nums.length
+  let sum = 0, res = 0;
+  for (let i = 0; i < n; ++i) {
+    sum += nums[i];
+    res = Math.max(res, Math.ceil(sum / (i + 1)));
+  }
+  return res;
+};

From 91b449c73d72273e9dbfb12fca622fcdde33bd3e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Nov 2022 13:24:42 +0800
Subject: [PATCH 2470/3374] Update 645-set-mismatch.js

---
 645-set-mismatch.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/645-set-mismatch.js b/645-set-mismatch.js
index b55c998b..98106af4 100644
--- a/645-set-mismatch.js
+++ b/645-set-mismatch.js
@@ -20,3 +20,22 @@ const findErrorNums = function(nums) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findErrorNums = function(nums) {
+    const res = [];
+    for (const i of nums) {
+      if (nums[Math.abs(i) - 1] < 0) res[0] = Math.abs(i);
+	  else nums[Math.abs(i) - 1] *= -1;
+    }
+    for (let i = 0; i < nums.length; i++) {
+      if (nums[i] > 0) res[1] = i + 1;
+    }
+    return res;    
+};
+

From 8eb1b45cfb5c64654364e45a6f0da9c037e98bfa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Nov 2022 19:50:53 +0800
Subject: [PATCH 2471/3374] Create
 2411-smallest-subarrays-with-maximum-bitwise-or.js

---
 ...-smallest-subarrays-with-maximum-bitwise-or.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2411-smallest-subarrays-with-maximum-bitwise-or.js

diff --git a/2411-smallest-subarrays-with-maximum-bitwise-or.js b/2411-smallest-subarrays-with-maximum-bitwise-or.js
new file mode 100644
index 00000000..0c5f82b2
--- /dev/null
+++ b/2411-smallest-subarrays-with-maximum-bitwise-or.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const smallestSubarrays = function(nums) {
+  const n = nums.length, last = Array(30).fill(0), res = [];
+  for (let i = n - 1; i >= 0; --i) {
+    res[i] = 1;
+    for (let j = 0; j < 30; ++j) {
+      if ((nums[i] & (1 << j)) > 0) last[j] = i;
+      res[i] = Math.max(res[i], last[j] - i + 1);
+    }
+  }
+  return res;
+};

From 2d7f9929802bc0d70063ab7840ac221e46eb270f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 30 Nov 2022 19:51:13 +0800
Subject: [PATCH 2472/3374] Update
 2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js

---
 ...erations-to-sort-a-binary-tree-by-level.js | 79 +++++++++----------
 1 file changed, 37 insertions(+), 42 deletions(-)

diff --git a/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js b/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js
index 146a0099..2350da34 100644
--- a/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js
+++ b/2471-minimum-number-of-operations-to-sort-a-binary-tree-by-level.js
@@ -10,75 +10,70 @@
  * @param {TreeNode} root
  * @return {number}
  */
-var minimumOperations = function(root) {
+var minimumOperations = function (root) {
   let res = 0
   let q = []
   q.push(root)
-  
-  while(q.length) {
+
+  while (q.length) {
     const nxt = []
-    res += minSwaps(q.map(e =>  e.val), q.length)    
+    res += minSwaps(
+      q.map((e) => e.val),
+      q.length
+    )
     const len = q.length
-    
-    for(let i = 0; i < len; i++) {
+
+    for (let i = 0; i < len; i++) {
       const cur = q[i]
-      if(cur.left) nxt.push(cur.left)
-      if(cur.right) nxt.push(cur.right)
+      if (cur.left) nxt.push(cur.left)
+      if (cur.right) nxt.push(cur.right)
     }
 
     q = nxt
   }
-  
-  
+
   return res
-};
+}
 
-function swap(arr, i, j)
-{
-  let temp = arr[i];
-  arr[i] = arr[j];
-  arr[j] = temp;
+function swap(arr, i, j) {
+  const temp = arr[i]
+  arr[i] = arr[j]
+  arr[j] = temp
 }
- 
+
 // Return the minimum number
 // of swaps required to sort
 // the array
-function minSwaps(arr,N)
-{
-  let ans = 0;
-  let temp = arr.slice();
- 
+function minSwaps(arr, len) {
+  let ans = 0
+  const temp = arr.slice()
+
   // Hashmap which stores the
   // indexes of the input array
-  let h = new Map();
- 
-  temp.sort((a, b) => a - b);
-  for (let i = 0; i < N; i++)
-  {
-    h.set(arr[i], i);
+  const h = new Map()
+
+  temp.sort((a, b) => a - b)
+  for (let i = 0; i < len; i++) {
+    h.set(arr[i], i)
   }
-  for (let i = 0; i < N; i++)
-  {
-   
+  for (let i = 0; i < len; i++) {
     // This is checking whether
     // the current element is
     // at the right place or not
-    if (arr[i] != temp[i])
-    {
-      ans++;
-      let init = arr[i];
- 
+    if (arr[i] !== temp[i]) {
+      ans++
+      const init = arr[i]
+
       // If not, swap this element
       // with the index of the
       // element which should come here
-      swap(arr, i, h.get(temp[i]));
- 
+      swap(arr, i, h.get(temp[i]))
+
       // Update the indexes in
       // the hashmap accordingly
-      h.set(init,h.get(temp[i]));
-      h.set(temp[i],i);
+      h.set(init, h.get(temp[i]))
+      h.set(temp[i], i)
     }
   }
-  // console.log(arr, ans)
-  return ans;
+  return ans
 }

From 02601a8ee33d431c7be79aea24fb07245280e379 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Dec 2022 12:53:04 +0800
Subject: [PATCH 2473/3374] Update 525-contiguous-array.js

---
 525-contiguous-array.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/525-contiguous-array.js b/525-contiguous-array.js
index fcd03339..9b0da1ea 100644
--- a/525-contiguous-array.js
+++ b/525-contiguous-array.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaxLength = function(nums) {
+  let res = 0, sum = 0
+  const hash = {0: -1}, n = nums.length
+  
+  for(let i = 0; i < n; i++) {
+      const cur = nums[i]
+      sum += cur === 0 ? -1 : 1
+      if(hash[sum] != null) {
+          res = Math.max(res, i - hash[sum])
+      } else {
+          hash[sum] = i
+      }
+      
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From b55818531398aa6afb23824ae968b5a53044bce3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Dec 2022 13:50:40 +0800
Subject: [PATCH 2474/3374] Update 930-binary-subarrays-with-sum.js

---
 930-binary-subarrays-with-sum.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/930-binary-subarrays-with-sum.js b/930-binary-subarrays-with-sum.js
index e94beea5..785bf86c 100644
--- a/930-binary-subarrays-with-sum.js
+++ b/930-binary-subarrays-with-sum.js
@@ -17,3 +17,27 @@ const numSubarraysWithSum = function(A, S) {
     }
     return ans;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} goal
+ * @return {number}
+ */
+const numSubarraysWithSum = function(nums, goal) {
+  const hash = {}
+  const n = nums.length
+  let res = 0, sum = 0
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    sum += cur
+    const pre = sum - goal
+    if(hash[sum] == null) hash[sum] = 0
+    if(hash[pre] != null) res += hash[pre]
+    if(sum === goal) res++
+    hash[sum]++    
+  }
+    
+  return res
+};

From 4362867ed44ad5f3a9be8852513626765545af61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Dec 2022 22:36:43 +0800
Subject: [PATCH 2475/3374] Update 974-subarray-sums-divisible-by-k.js

---
 974-subarray-sums-divisible-by-k.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/974-subarray-sums-divisible-by-k.js b/974-subarray-sums-divisible-by-k.js
index 34fc0a41..26306870 100644
--- a/974-subarray-sums-divisible-by-k.js
+++ b/974-subarray-sums-divisible-by-k.js
@@ -14,3 +14,22 @@ const subarraysDivByK = function (nums, k) {
   }
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarraysDivByK = function(nums, k) {
+  const memo = {0: 1}
+  let sum = 0, res = 0
+  for(const e of nums) {
+    sum += e
+    const remain = (k - (sum % k)) % k
+    res += memo[remain] ?? 0
+    memo[remain] = (memo[remain] ?? 0) + 1 
+  }
+  return res
+};

From 661eb3c91ba41963d5b57c68403fe6caa4b7989f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Dec 2022 19:11:28 +0800
Subject: [PATCH 2476/3374] Create
 1983-widest-pair-of-indices-with-equal-range-sum.js

---
 ...st-pair-of-indices-with-equal-range-sum.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1983-widest-pair-of-indices-with-equal-range-sum.js

diff --git a/1983-widest-pair-of-indices-with-equal-range-sum.js b/1983-widest-pair-of-indices-with-equal-range-sum.js
new file mode 100644
index 00000000..5b0d0233
--- /dev/null
+++ b/1983-widest-pair-of-indices-with-equal-range-sum.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const widestPairOfIndices = function(nums1, nums2) {
+  const n = nums1.length
+  const diff = Array(n).fill(0)
+  let res = 0, sum1 = 0, sum2 = 0
+  
+  for(let i = 0; i < n; i++) {
+    const cur1 = nums1[i], cur2 = nums2[i]
+    sum1 += cur1
+    sum2 += cur2
+    if(sum1 === sum2) res = i + 1
+    diff[i] = sum1 - sum2
+  }
+  const hash = {}
+  for(let i = 0; i < n; i++) {
+    const cur = diff[i]
+    if(hash[cur] == null) hash[cur] = i
+    else {
+      res = Math.max(res, i - hash[cur])
+    }
+  }
+  
+  return res
+};

From 02279f5ce076062f6e15da70f4c79ac1c4766108 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Dec 2022 19:12:12 +0800
Subject: [PATCH 2477/3374] Create 2490-circular-sentence.js

---
 2490-circular-sentence.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2490-circular-sentence.js

diff --git a/2490-circular-sentence.js b/2490-circular-sentence.js
new file mode 100644
index 00000000..b4764941
--- /dev/null
+++ b/2490-circular-sentence.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} sentence
+ * @return {boolean}
+ */
+var isCircularSentence = function(sentence) {
+  const arr = sentence.split(' ')
+  const n = arr.length
+  for(let i = 0; i < n; i++) {
+    if(i === n - 1) {
+      if(arr[i][arr[i].length - 1] !== arr[0][0]) return false
+    } else {
+      if(arr[i][arr[i].length - 1] !== arr[i + 1][0]) return false
+    }
+  }
+  return true
+};

From 95d4b6e2cfa06672db66a0a8f396a2eb6c82099d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Dec 2022 19:12:40 +0800
Subject: [PATCH 2478/3374] Create
 2491-divide-players-into-teams-of-equal-skill.js

---
 ...ivide-players-into-teams-of-equal-skill.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2491-divide-players-into-teams-of-equal-skill.js

diff --git a/2491-divide-players-into-teams-of-equal-skill.js b/2491-divide-players-into-teams-of-equal-skill.js
new file mode 100644
index 00000000..d4ca89ac
--- /dev/null
+++ b/2491-divide-players-into-teams-of-equal-skill.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} skill
+ * @return {number}
+ */
+const dividePlayers = function(skill) {
+  skill.sort((a, b) => a - b)
+  const n = skill.length
+  const sum = skill[0] + skill[skill.length - 1]
+  for(let i = 1; i < n / 2; i++) {
+    const j = n - 1 - i
+    if(skill[i] + skill[j] !== sum) return -1
+  }
+  let res = skill[0] * skill[skill.length - 1]
+  for(let i = 1; i < n / 2; i++) {
+    const j = n - 1 - i
+    res += skill[i] * skill[j]
+  }
+  
+  return res
+};

From 0a9ee039d4779371b17af22a51a273461f94b94c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Dec 2022 19:13:22 +0800
Subject: [PATCH 2479/3374] Create
 2492-minimum-score-of-a-path-between-two-cities.js

---
 ...imum-score-of-a-path-between-two-cities.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2492-minimum-score-of-a-path-between-two-cities.js

diff --git a/2492-minimum-score-of-a-path-between-two-cities.js b/2492-minimum-score-of-a-path-between-two-cities.js
new file mode 100644
index 00000000..de7ed10e
--- /dev/null
+++ b/2492-minimum-score-of-a-path-between-two-cities.js
@@ -0,0 +1,56 @@
+class UnionFind {
+    constructor() {
+      this.sizes = new Map()
+      this.parents = new Map()
+    }
+
+    find(x){
+        if (x !== (this.parents.get(x) ?? x)) {
+            this.parents.set(x, this.find(this.parents.get(x) ?? x));
+        }
+        return this.parents.get(x) ?? x;
+    }
+    size(x) {
+        return (this.sizes.get(this.find(x)) ?? 1);
+    }
+    connected(p, q) {
+        return this.find(p) == this.find(q);
+    }
+    union(a, b) {
+        const fa = this.find(a);
+        const fb = this.find(b);
+        if (fa == fb) {
+            return;
+        }
+        const sa = this.sizes.get(fa) ?? 1;
+        const sb = this.sizes.get(fb) ?? 1;
+
+        if (sa < sb) {
+            this.parents.set(fa, fb);
+            this.sizes.set(fb, sb + sa);
+        } else {
+            this.parents.set(fb, fa);
+            this.sizes.set(fa, sb + sa);
+        }
+    }
+}
+/**
+ * @param {number} n
+ * @param {number[][]} roads
+ * @return {number}
+ */
+var minScore = function(n, roads) {
+    const uf = new UnionFind();
+
+    for (const [a, b] of roads) {
+        uf.union(a, b);
+    }
+    let ans = Infinity;
+
+    for (const [i, j, d] of roads) {
+        if (uf.connected(1, i) && uf.connected(1, j)) {
+            ans = Math.min(ans, d);
+        }
+    }
+    return ans;
+};

From caadda0173007f5c7f9d8386682480021f55061b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Dec 2022 19:14:48 +0800
Subject: [PATCH 2480/3374] Create
 2493-divide-nodes-into-the-maximum-number-of-groups.js

---
 ...nodes-into-the-maximum-number-of-groups.js | 98 +++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 2493-divide-nodes-into-the-maximum-number-of-groups.js

diff --git a/2493-divide-nodes-into-the-maximum-number-of-groups.js b/2493-divide-nodes-into-the-maximum-number-of-groups.js
new file mode 100644
index 00000000..738d09c3
--- /dev/null
+++ b/2493-divide-nodes-into-the-maximum-number-of-groups.js
@@ -0,0 +1,98 @@
+/////////////////////// Template ////////////////////////////////////////
+const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
+const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };
+const initialize2DArray = (n, m) => { let d = []; for (let i = 0; i < n; i++) { let t = Array(m).fill(Number.MAX_SAFE_INTEGER); d.push(t); } return d; };
+
+function DJSet(n) {
+    // parent[i] < 0, -parent[i] is the group size which root is i. example: (i -> parent[i] -> parent[parent[i]] -> parent[parent[parent[i]]] ...)
+    // parent[i] >= 0, i is not the root and parent[i] is i's parent. example: (... parent[parent[parent[i]]] -> parent[parent[i]] -> parent[i] -> i)
+    let parent = Array(n).fill(-1);
+    return { find, union, count, equiv, par }
+    function find(x) {
+        return parent[x] < 0 ? x : parent[x] = find(parent[x]);
+    }
+    function union(x, y) {
+        x = find(x);
+        y = find(y);
+        if (x != y) {
+            if (parent[x] < parent[y]) [x, y] = [y, x];
+            parent[x] += parent[y];
+            parent[y] = x;
+        }
+        return x == y;
+    }
+    function count() { // total groups
+        return parent.filter(v => v < 0).length;
+    }
+    function equiv(x, y) { // isConnected
+        return find(x) == find(y);
+    }
+    function par() {
+        return parent;
+    }
+}
+
+const isBipartite = (g) => {
+    let n = g.length, start = 1, visit = Array(n).fill(false), q = [], color = Array(n).fill(0); // 0: no color, 1: red  -1: blue
+    for (let i = start; i < n; i++) {
+        if (color[i] != 0) continue;
+        q.push(i);
+        color[i] = 1;
+        if (visit[i]) continue;
+        while (q.length) {
+            let cur = q.shift();
+            if (visit[cur]) continue;
+            for (const child of g[cur]) {
+                if (color[child] == color[cur]) return false;
+                if (color[child]) continue;
+                color[child] = -color[cur];
+                q.push(child);
+            }
+        }
+    }
+    return true;
+};
+////////////////////////////////////////////////////////////////////
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const magnificentSets = (n, edges) => {
+    let g = initializeGraph(n + 1), ds = new DJSet(n + 1);
+    packUG(g, edges);
+    if (!isBipartite(g)) return -1;
+    let d = initialize2DArray(n + 1, n + 1), res = Array(n + 1).fill(0);
+    for (let i = 1; i <= n; i++) d[i][i] = 0;
+    for (const [u, v] of edges) {
+        d[u][v] = 1;
+        d[v][u] = 1;
+        ds.union(u, v);
+    }
+    wf(d);
+    for (let i = 1; i <= n; i++) {
+        let max = 0;
+        for (let j = 1; j <= n; j++) {
+            if (d[i][j] >= Number.MAX_SAFE_INTEGER) continue;
+            max = Math.max(max, d[i][j]);
+        }
+        let par = ds.find(i);
+        res[par] = Math.max(res[par], max + 1);
+    }
+    let ans = 0;
+    for (let i = 1; i <= n; i++) ans += res[i];
+    return ans;
+};
+
+const wf = (g) => {
+    let n = g.length;
+    for (let k = 0; k < n; k++) {
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j < n; j++) {
+                if (g[i][j] > g[i][k] + g[k][j]) {
+                    g[i][j] = g[i][k] + g[k][j];
+                }
+            }
+        }
+    }
+};

From 941f878d939f611c92165f89e0104227996f6059 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Dec 2022 18:47:00 +0800
Subject: [PATCH 2481/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 9260de39..943535fa 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -1,3 +1,28 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestSubstring = function(s) {
+  const n = s.length
+  const ch2num = ch => {
+    const idx = 'aeiou'.indexOf(ch)
+    return idx === -1 ? 0 : (1 << idx)
+  }
+  let res = 0
+  let mask = 0
+  const hash = new Map([[0, -1]])
+  for (let i = 0; i < n; i++) {
+    mask ^= ch2num(s[i])
+    const first = hash.has(mask) ? hash.get(mask) : i
+    if (!hash.has(mask)) hash.set(mask, i)
+    res = Math.max(res, i - first)
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From c296d37145e8052e07f058323774277ded0697d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Dec 2022 22:01:10 +0800
Subject: [PATCH 2482/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 943535fa..cd7df758 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestSubstring = function(s) {
+  const n = s.length
+  let res = 0, mask = 0
+  const map = new Map([[0, -1]])
+  
+  for(let i = 0; i < n; i++) {
+    const ch = s[i]
+    const idx = 'aeiou'.indexOf(ch)
+    if(idx !== -1) {
+      mask ^= (1 << idx)
+    }
+    if(map.has(mask)) {
+      res = Math.max(res, i - map.get(mask))
+    } else {
+      map.set(mask, i)
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 039362f154331d1e77eeb7eb56e68e7e42326984 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Dec 2022 22:09:57 +0800
Subject: [PATCH 2483/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index cd7df758..9b9130d8 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -25,6 +25,35 @@ const findTheLongestSubstring = function(s) {
 
 // another
 
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestSubstring = function(s) {
+  const n = s.length
+  let res = 0, mask = 0
+  const map = new Map([[0, -1]])
+  
+  for(let i = 0; i < n; i++) {
+    const ch = s[i]
+    const idx = 'aeiou'.indexOf(ch)
+    if(idx !== -1) {
+      mask ^= (1 << idx)
+      if(map.has(mask)) {
+        res = Math.max(res, i - map.get(mask))
+      } else {
+        map.set(mask, i)
+      }
+    } else {
+      res = Math.max(res, i - map.get(mask))
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From f5e490c8536ee55fd1b5e67599f92305d76ca56a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Dec 2022 23:04:58 +0800
Subject: [PATCH 2484/3374] Update 1524-number-of-sub-arrays-with-odd-sum.js

---
 1524-number-of-sub-arrays-with-odd-sum.js | 26 +++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1524-number-of-sub-arrays-with-odd-sum.js b/1524-number-of-sub-arrays-with-odd-sum.js
index 671df32f..1b3fed50 100644
--- a/1524-number-of-sub-arrays-with-odd-sum.js
+++ b/1524-number-of-sub-arrays-with-odd-sum.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const numOfSubarrays = function(arr) {
+  const n = arr.length, mod = 1e9 + 7
+  let sum = 0, res = 0, oddCnt = 0, evenCnt = 0
+  
+  for(let i = 0; i < n; i++) {
+    const cur = arr[i]
+    sum += cur
+    if(sum % 2 === 1) {
+      res++
+      res += evenCnt
+      oddCnt++
+    } else {
+      res += oddCnt
+      evenCnt++
+    }
+  }
+  
+  return res % mod
+};
+
+// another
+
 /**
  * @param {number[]} arr
  * @return {number}

From be487287c85a2d036e2a1ddf59a4f61325fdbc55 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Dec 2022 23:48:23 +0800
Subject: [PATCH 2485/3374] Create 2100-find-good-days-to-rob-the-bank.js

---
 2100-find-good-days-to-rob-the-bank.js | 39 ++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2100-find-good-days-to-rob-the-bank.js

diff --git a/2100-find-good-days-to-rob-the-bank.js b/2100-find-good-days-to-rob-the-bank.js
new file mode 100644
index 00000000..c90bacd8
--- /dev/null
+++ b/2100-find-good-days-to-rob-the-bank.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} security
+ * @param {number} time
+ * @return {number[]}
+ */
+const goodDaysToRobBank = function(security, time) {
+   const n = security.length, sec = security
+   const pre = Array(n).fill(0), post = Array(n).fill(0)
+   
+   const res = []
+   let num = 0
+   for(let i = 1; i < n; i++) {
+     if(sec[i]  <= sec[i - 1]) {
+       num++
+     } else {
+       num = 0
+     }
+     pre[i] = num
+   }
+  
+   num = 0
+   for(let i = n - 2; i >= 0; i--) {
+     if(sec[i] <= sec[i + 1]) {
+       num++
+     } else {
+       num = 0
+     }
+     post[i] = num
+   }
+  
+    // console.log(pre, post)
+   for(let i = 0; i < n; i++) {
+     if(pre[i] >= time && post[i] >= time) {
+       res.push(i)
+     }
+   }
+   
+   return res
+};

From 627fef5e864c24b13c370352456cc2fbd0a4e5d8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 9 Dec 2022 22:55:21 +0800
Subject: [PATCH 2486/3374] Update 1590-make-sum-divisible-by-p.js

---
 1590-make-sum-divisible-by-p.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
index 61d36c0c..91857ae1 100644
--- a/1590-make-sum-divisible-by-p.js
+++ b/1590-make-sum-divisible-by-p.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+const minSubarray = function(nums, p) {
+  const remain = nums.reduce((ac, e) => ac + e, 0) % p
+  const n = nums.length, hash = {0: -1}
+  let res = n
+  if(remain === 0) return 0
+  for(let i = 0, sum = 0; i < n; i++) {
+    const cur = nums[i]
+    sum += cur
+    const target = (sum % p - remain + p) % p
+    if(hash[target] != null) {
+      res = Math.min(res, i - hash[target])
+    }
+
+    hash[sum % p] = i
+  }
+//   console.log(hash)
+  
+  return res === n ? -1 : res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} p

From ada1e7906e923f5eedbbed422f0ab90e6b9acaa2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Dec 2022 14:19:44 +0800
Subject: [PATCH 2487/3374] Update
 1658-minimum-operations-to-reduce-x-to-zero.js

---
 ...-minimum-operations-to-reduce-x-to-zero.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/1658-minimum-operations-to-reduce-x-to-zero.js b/1658-minimum-operations-to-reduce-x-to-zero.js
index ed2b66ef..15935ef5 100644
--- a/1658-minimum-operations-to-reduce-x-to-zero.js
+++ b/1658-minimum-operations-to-reduce-x-to-zero.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function(nums, x) {
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  const subArrSum = sum - x
+  if(subArrSum === 0) return nums.length
+  const n = nums.length, hash = {0: -1}
+  let ac = 0, res = -1
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    ac += cur
+    if(hash[ac - subArrSum] != null) {
+      res = Math.max(res, i - hash[ac - subArrSum])
+    }
+    hash[ac] = i
+  }
+ 
+  return res === -1 ? -1 : n - res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} x

From da047eed06f87905ab63f6639e8ec03fa73ac3bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Dec 2022 22:01:13 +0800
Subject: [PATCH 2488/3374] Create 2291-maximum-profit-from-trading-stocks.js

---
 2291-maximum-profit-from-trading-stocks.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2291-maximum-profit-from-trading-stocks.js

diff --git a/2291-maximum-profit-from-trading-stocks.js b/2291-maximum-profit-from-trading-stocks.js
new file mode 100644
index 00000000..4a69461f
--- /dev/null
+++ b/2291-maximum-profit-from-trading-stocks.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} present
+ * @param {number[]} future
+ * @param {number} budget
+ * @return {number}
+ */
+const maximumProfit = function(present, future, budget) {
+  const dp = new Array(budget + 1).fill(0);
+  for (let i = 0; i < present.length; i++){
+    for (let j = budget; j >= 0; j--){
+      if (j >= present[i] && present[i] < future[i]){
+        dp[j] = Math.max(dp[j], dp[j - present[i]] + future[i] - present[i]);
+      }
+    }
+  }
+  return dp[budget];
+};

From 18ad49bb95a64894cc95143fb4c241fe2d92fed3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 13 Dec 2022 22:59:55 +0800
Subject: [PATCH 2489/3374] Update 2488-count-subarrays-with-median-k.js

---
 2488-count-subarrays-with-median-k.js | 33 ++++++++++++++-------------
 1 file changed, 17 insertions(+), 16 deletions(-)

diff --git a/2488-count-subarrays-with-median-k.js b/2488-count-subarrays-with-median-k.js
index d1577b75..54a7d129 100644
--- a/2488-count-subarrays-with-median-k.js
+++ b/2488-count-subarrays-with-median-k.js
@@ -6,21 +6,22 @@
 const countSubarrays = (a, k) => permutationArrayWithMedianK(a, k);
 
 const permutationArrayWithMedianK = (a, k) => {
-    let m = new Map([[0, 1]]), find = false, balance = 0, res = 0;
-    for (const x of a) {
-        if (x < k) {
-            balance--;
-        } else if (x > k) {
-            balance++;
-        } else {
-            find = true;
-        }
-        if (find) {
-            // balance - 1, subarray length is even, has one more right
-            res += (m.get(balance) || 0) + (m.get(balance - 1) || 0);
-        } else {
-            m.set(balance, m.get(balance) + 1 || 1);
-        }
+  const m = new Map([[0, 1]])
+  let find = false, balance = 0, res = 0;
+  for (const x of a) {
+    if (x < k) {
+      balance--;
+    } else if (x > k) {
+      balance++;
+    } else {
+      find = true;
     }
-    return res;
+    if (find) {
+      // balance - 1, subarray length is even, has one more right
+      res += (m.get(balance) || 0) + (m.get(balance - 1) || 0);
+    } else {
+      m.set(balance, (m.get(balance) || 0) + 1);
+    }
+  }
+  return res;
 };

From 7755c18b069c5ecc4d3fb6658973d5a05d5e4b70 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Dec 2022 16:50:13 +0800
Subject: [PATCH 2490/3374] Update 743-network-delay-time.js

---
 743-network-delay-time.js | 101 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 101 insertions(+)

diff --git a/743-network-delay-time.js b/743-network-delay-time.js
index a827a9ca..bf562c67 100644
--- a/743-network-delay-time.js
+++ b/743-network-delay-time.js
@@ -1,3 +1,104 @@
+/**
+ * @param {number[][]} times
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const networkDelayTime = function(times, n, k) {
+  const graph = {}
+  for(const [u, v, w] of times) {
+    if(graph[u] == null) graph[u] = []
+    graph[u][v] = w
+  }
+  const visited = new Array(n + 1).fill(false)
+  const pq = new PQ((a, b) => a[0] < b[0])
+  pq.push([0, k])
+  let res = 0
+  while(!pq.isEmpty()) {
+    const [dist, cur] = pq.pop()
+    if(visited[cur]) continue
+    visited[cur] = true
+    n--
+    res = dist
+    if(graph[cur]) {
+      for(const nxt of Object.keys(graph[cur])) {
+        pq.push([res + graph[cur][nxt], nxt])
+      }
+    }
+  }
+  return n === 0 ? res : -1
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} times
  * @param {number} N

From 602afceebcad445537d965e0b49a7c870eade761 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Dec 2022 13:41:40 +0800
Subject: [PATCH 2491/3374] Create
 2503-maximum-number-of-points-from-grid-queries.js

---
 ...imum-number-of-points-from-grid-queries.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 2503-maximum-number-of-points-from-grid-queries.js

diff --git a/2503-maximum-number-of-points-from-grid-queries.js b/2503-maximum-number-of-points-from-grid-queries.js
new file mode 100644
index 00000000..fbc8688f
--- /dev/null
+++ b/2503-maximum-number-of-points-from-grid-queries.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[][]} grid
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const maxPoints = function (grid, queries) {
+  const heap = new MinPriorityQueue({
+    compare: ({ value: valueA }, { value: valueB }) => valueA - valueB,
+  })
+
+  const enqueue = (r, c) => {
+    if (
+      0 <= r &&
+      r < grid.length &&
+      0 <= c &&
+      c < grid[0].length &&
+      grid[r][c] !== null
+    ) {
+      heap.enqueue({ row: r, col: c, value: grid[r][c] })
+      grid[r][c] = null
+    }
+  }
+  enqueue(0, 0)
+  let count = 0
+  const map = {}
+  const sortedQueries = [...queries].sort((x, y) => x - y)
+
+  for (const query of sortedQueries) {
+    while (!heap.isEmpty()) {
+      const { row, col, value } = heap.front()
+      if (query <= value) break
+      heap.dequeue()
+      enqueue(row + 1, col)
+      enqueue(row - 1, col)
+      enqueue(row, col + 1)
+      enqueue(row, col - 1)
+      ++count
+    }
+
+    map[query] = count
+  }
+
+  return queries.map((query) => map[query])
+}

From af301b911a885701e59ebf2561a804e918887730 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Dec 2022 20:47:50 +0800
Subject: [PATCH 2492/3374] Update
 2493-divide-nodes-into-the-maximum-number-of-groups.js

---
 ...nodes-into-the-maximum-number-of-groups.js | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)

diff --git a/2493-divide-nodes-into-the-maximum-number-of-groups.js b/2493-divide-nodes-into-the-maximum-number-of-groups.js
index 738d09c3..371bf321 100644
--- a/2493-divide-nodes-into-the-maximum-number-of-groups.js
+++ b/2493-divide-nodes-into-the-maximum-number-of-groups.js
@@ -1,3 +1,93 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const magnificentSets = function (n, edges) {
+  function getComponents(n) {
+    let visited = Array(n + 1).fill(false);
+    let ans = [];
+    for (let i = 1; i <= n; i++) {
+      if (!visited[i]) {
+        ans.push(visit(i, [], visited));
+      }
+    }
+    return ans;
+  }
+
+  function visit(cur, nodes, visited) {
+    visited[cur] = true;
+    nodes.push(cur);
+    for (let next of map.get(cur)) {
+      // skip if you have already visited this node
+      if (visited[next]) continue;
+      visit(next, nodes, visited);
+    }
+    return nodes;
+  }
+
+  function find(node, n) {
+    let group = Array(n + 1).fill(-1);
+
+    let queue = [];
+    queue.push(node);
+    let groups = 0;
+    while (queue.length > 0) {
+      let k = queue.length;
+      // store nodes in set to avoid duplicates
+      let set = new Set();
+      while (k-- > 0) {
+        let cur = queue.shift();
+        // this case occurs when 2 nodes in the same level are connected
+        // so, return -1
+        if (group[cur] != -1) return -1;
+        group[cur] = groups;
+        for (let next of map.get(cur)) {
+          if (group[next] == -1) {
+            set.add(next);
+          }
+        }
+      }
+      for (let val of set) queue.push(val);
+      groups++;
+    }
+    return groups;
+  }
+
+  let map = new Map(); // Integer -> List<Integer>
+  for (let i = 1; i <= n; i++) {
+    map.set(i, []);
+  }
+  // adjacency list
+  for (let edge of edges) {
+    let u = edge[0],
+      v = edge[1];
+    map.get(u).push(v);
+    map.get(v).push(u);
+  }
+
+  // get all components as Graph can be disconnected
+  let components = getComponents(n);
+
+  let ans = 0;
+  /*
+    - Take each component and get max groups can be formed from that component
+    - return -1 if you can't form groups from any one of the components
+  */
+  for (let component of components) {
+    let groups = -1;
+    for (let node of component) {
+      groups = Math.max(groups, find(node, n));
+    }
+    if (groups == -1) return -1;
+    ans += groups;
+  }
+
+  return ans;
+};
+
+// another
+
 /////////////////////// Template ////////////////////////////////////////
 const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
 const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };

From b52c7886cb1d5ce4ed103d1bccff017e7fce8a8d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Dec 2022 14:56:53 +0800
Subject: [PATCH 2493/3374] Update 2430-maximum-deletions-on-a-string.js

---
 2430-maximum-deletions-on-a-string.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2430-maximum-deletions-on-a-string.js b/2430-maximum-deletions-on-a-string.js
index 77c6684b..957e9712 100644
--- a/2430-maximum-deletions-on-a-string.js
+++ b/2430-maximum-deletions-on-a-string.js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const deleteString = function (s) {
+  const dp = Array(4000).fill(0), lps = Array(4000).fill(0)
+  for (let k = s.length - 1; k >= 0; --k) {
+    dp[k] = 1; 
+    for (let i = 1, j = 0; dp[k] <= s.length - i - k + 1; ++i) {
+      while (j && s[i + k] != s[j + k]) j = Math.max(0, lps[j] - 1);
+      j += s[i + k] == s[j + k];
+      lps[i] = j;
+      if (i % 2) {
+        const len = ~~((i + 1) / 2);
+        if (lps[len * 2 - 1] == len) {
+          dp[k] = Math.max(dp[k], 1 + dp[k + len]);
+        }
+      }
+    }
+  }
+  return dp[0];
+}
+
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 818ca90ed17b2b2024822307d97271ab8f0373c0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Dec 2022 15:44:58 +0800
Subject: [PATCH 2494/3374] Update 2430-maximum-deletions-on-a-string.js

---
 2430-maximum-deletions-on-a-string.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/2430-maximum-deletions-on-a-string.js b/2430-maximum-deletions-on-a-string.js
index 957e9712..4f04ae64 100644
--- a/2430-maximum-deletions-on-a-string.js
+++ b/2430-maximum-deletions-on-a-string.js
@@ -1,3 +1,27 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const deleteString = function (s) {
+  const dp = Array(4000).fill(0)
+  const n = s.length
+  return helper(0)
+  
+  function helper(i) {
+    if(dp[i] === 0) {
+      dp[i] = 1
+      for(let len = 1; dp[i] <= n - i - len; len++) {
+        if(s.slice(i, i + len) === s.slice(i + len, i + 2 * len)) {
+          dp[i] = Math.max(dp[i], 1 + helper(i + len))          
+        }
+      }
+    }
+    return dp[i]
+  }
+}
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 24d2e123a55e630082aac431febeccc2a39990e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Dec 2022 08:58:13 +0800
Subject: [PATCH 2495/3374] Update 2272-substring-with-largest-variance.js

---
 2272-substring-with-largest-variance.js | 61 +++++++++++--------------
 1 file changed, 27 insertions(+), 34 deletions(-)

diff --git a/2272-substring-with-largest-variance.js b/2272-substring-with-largest-variance.js
index 3a1d7aa1..d31fb2bd 100644
--- a/2272-substring-with-largest-variance.js
+++ b/2272-substring-with-largest-variance.js
@@ -2,42 +2,35 @@
  * @param {string} s
  * @return {number}
  */
-const largestVariance = function (s) {
-  const freq = new Array(26).fill(0)
-  const ac = 'a'.charCodeAt(0)
-  for (let i = 0; i < s.length; i++) freq[s.charCodeAt(i) - ac]++
-
-  // console.log(freq)
-  let maxVariance = 0
-  for (let a = 0; a < 26; a++) {
-    for (let b = 0; b < 26; b++) {
-      let remainingA = freq[a]
-      let remainingB = freq[b]
-      if (a == b || remainingA == 0 || remainingB == 0) continue
-
-      // run kadanes on each possible character pairs (A & B)
-      let currBFreq = 0,
-        currAFreq = 0
-      for (let i = 0; i < s.length; i++) {
-        let c = s.charCodeAt(i) - ac
-
-        if (c == b) currBFreq++
-        if (c == a) {
-          currAFreq++
-          remainingA--
-        }
-        if (currAFreq > 0) {
-          maxVariance = Math.max(maxVariance, currBFreq - currAFreq)          
-        }
-
-
-        if (currBFreq < currAFreq && remainingA >= 1) {
-          currBFreq = 0
-          currAFreq = 0
+const largestVariance = (s) => {
+  let se = new Set(s),
+    n = s.length,
+    res = 0
+  for (const x of se) {
+    // max
+    for (const y of se) {
+      // min
+      if (x != y) {
+        let pre = Array(n + 1).fill(0),
+          preX,
+          preY,
+          diff = 0
+        for (let i = 0; i < n; i++) {
+          if (s[i] == x) {
+            preX = i + 1
+            diff++
+          }
+          if (s[i] == y) {
+            preY = i + 1
+            diff--
+          }
+          pre[i + 1] = Math.min(pre[i], diff)
+          if (preX == undefined || preY == undefined) continue
+          res = Math.max(res, diff - pre[Math.min(preX, preY) - 1])
         }
       }
     }
   }
-
-  return maxVariance
+  return res
 }
+

From 94a7a97727719bd56fffe19d5783b8b7dc7e1b6a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Dec 2022 21:17:52 +0800
Subject: [PATCH 2496/3374] Create 2484-count-palindromic-subsequences.js

---
 2484-count-palindromic-subsequences.js | 31 ++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2484-count-palindromic-subsequences.js

diff --git a/2484-count-palindromic-subsequences.js b/2484-count-palindromic-subsequences.js
new file mode 100644
index 00000000..fef523ab
--- /dev/null
+++ b/2484-count-palindromic-subsequences.js
@@ -0,0 +1,31 @@
+const initialize2DArray = (n, m) => {
+  let d = []
+  for (let i = 0; i < n; i++) {
+    let t = Array(m).fill(0)
+    d.push(t)
+  }
+  return d
+}
+
+const mod = 1e9 + 7
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countPalindromes = (s) => {
+  let res = 0,
+    n = s.length,
+    cnt = Array(10).fill(0)
+  for (let i = 0; i < n; i++) {
+    let tot = 0
+    for (let j = n - 1; j > i; j--) {
+      if (s[i] == s[j]) {
+        res += tot * (j - i - 1)
+        res %= mod
+      }
+      tot += cnt[s[j] - "0"]
+    }
+    cnt[s[i] - "0"]++
+  }
+  return res
+}

From 7db705c3245b637cd56c38e69499f2ae35357b14 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Dec 2022 19:50:50 +0800
Subject: [PATCH 2497/3374] Update 494-target-sum.js

---
 494-target-sum.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/494-target-sum.js b/494-target-sum.js
index 8fe84b51..aa4dc673 100755
--- a/494-target-sum.js
+++ b/494-target-sum.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const findTargetSumWays = function(nums, target) {
+    const sum = nums.reduce((a, b) => a+b);
+    
+    if(Math.abs(target) > sum) {
+        return 0;
+    }
+
+    if((target + sum) % 2) {
+        return 0;
+    }
+
+    const halfSum = (target + sum) / 2;
+
+    let dp = new Array(halfSum+1).fill(0);
+    dp[0] = 1;
+
+    for(let i = 0; i < nums.length; i++) {
+        for(let j = halfSum; j >= nums[i]; j--) {
+            dp[j] += dp[j - nums[i]];
+        }
+    }
+
+    return dp[halfSum];
+};
+
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} S

From bade5617922d318a9c3dffd050c281b37225e499 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Dec 2022 20:06:48 +0800
Subject: [PATCH 2498/3374] Update 494-target-sum.js

---
 494-target-sum.js | 15 +++++----------
 1 file changed, 5 insertions(+), 10 deletions(-)

diff --git a/494-target-sum.js b/494-target-sum.js
index aa4dc673..86e36c48 100755
--- a/494-target-sum.js
+++ b/494-target-sum.js
@@ -5,30 +5,25 @@
  */
 const findTargetSumWays = function(nums, target) {
     const sum = nums.reduce((a, b) => a+b);
-    
     if(Math.abs(target) > sum) {
         return 0;
     }
-
     if((target + sum) % 2) {
         return 0;
     }
-
-    const halfSum = (target + sum) / 2;
-
-    let dp = new Array(halfSum+1).fill(0);
+    const newTarget = (target + sum) / 2;
+    let dp = new Array(newTarget+1).fill(0);
     dp[0] = 1;
-
     for(let i = 0; i < nums.length; i++) {
-        for(let j = halfSum; j >= nums[i]; j--) {
+        for(let j = newTarget; j >= nums[i]; j--) {
             dp[j] += dp[j - nums[i]];
         }
     }
-
-    return dp[halfSum];
+    return dp[newTarget];
 };
 
 
+
 // another
 
 /**

From db1c052beec8c0ae3e777a26451b05d2f213aee4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Dec 2022 20:57:17 +0800
Subject: [PATCH 2499/3374] Create 2518-number-of-great-partitions.js

---
 2518-number-of-great-partitions.js | 40 ++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2518-number-of-great-partitions.js

diff --git a/2518-number-of-great-partitions.js b/2518-number-of-great-partitions.js
new file mode 100644
index 00000000..7f2c0e66
--- /dev/null
+++ b/2518-number-of-great-partitions.js
@@ -0,0 +1,40 @@
+const ll = BigInt,
+  mod = 1e9 + 7,
+  bmod = ll(mod)
+const sm = (a) => a.reduce((x, y) => x + y, 0)
+const powmod = (a, b, mod) => {
+  let r = 1n
+  while (b > 0n) {
+    if (b % 2n == 1) r = (r * a) % mod
+    b >>= 1n
+    a = (a * a) % mod
+  }
+  return r
+}
+const minus_mod = (x, y, mod) => (((x - y) % mod) + mod) % mod
+const knapsack_01 = (a, k) => {
+  if (sm(a) < 2 * k) return 0
+  let dp = Array(k).fill(0)
+  dp[0] = 1
+  for (const x of a) {
+    for (let j = k - 1; j > x - 1; j--) {
+      dp[j] += dp[j - x]
+      dp[j] %= mod
+    }
+  }
+  let bad = ll(sm(dp) * 2),
+    tot = powmod(2n, ll(a.length), bmod),
+    good = minus_mod(tot, bad, bmod)
+  return good
+}
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countPartitions = function(nums, k) {
+  return knapsack_01(nums, k)
+};
+
+
+

From 19c71dc3a84b3a8164f6d8b0814d174a0189f4f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Jan 2023 13:22:24 +0800
Subject: [PATCH 2500/3374] Create
 2521-distinct-prime-factors-of-product-of-array.js

---
 ...tinct-prime-factors-of-product-of-array.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2521-distinct-prime-factors-of-product-of-array.js

diff --git a/2521-distinct-prime-factors-of-product-of-array.js b/2521-distinct-prime-factors-of-product-of-array.js
new file mode 100644
index 00000000..cf2c349b
--- /dev/null
+++ b/2521-distinct-prime-factors-of-product-of-array.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var distinctPrimeFactors = function(nums) {
+    const primes = getPrime(1000)
+    const ans = new Set()
+    nums.forEach(it => {
+        let cur = it
+        ans.add(primes[cur])
+        while (primes[cur] != 1) {
+            ans.add(primes[cur])
+            cur /= primes[cur]
+        }
+        ans.add(cur)
+    })
+    ans.delete(1)
+
+    return ans.size
+  
+    function getPrime(k) {
+        const minPrime = new Array(k + 1).fill(1)
+        let p = 2
+        while (p <= k) {
+            let i = p
+            while (p <= k / i) {
+                if (minPrime[i * p] == 1) {
+                    minPrime[i * p] = p
+                }
+                i++
+            }
+            p++
+            while (p <= k) {
+                if (minPrime[p] == 1) break
+                p++
+            }
+        }
+        return minPrime
+    }
+};

From 8139ac0a929d4f47243f9101a224b20aadedf4ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Jan 2023 19:19:52 +0800
Subject: [PATCH 2501/3374] Update 2401-longest-nice-subarray.js

---
 2401-longest-nice-subarray.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/2401-longest-nice-subarray.js b/2401-longest-nice-subarray.js
index 0af71e12..9cd9ef95 100644
--- a/2401-longest-nice-subarray.js
+++ b/2401-longest-nice-subarray.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const longestNiceSubarray = function (nums) {
+  let res = 1, i = 0, j = 0, mask = 0
+  const n = nums.length
+  for(i = 0; i < n; i++) {
+    const cur = nums[i]
+    while((cur & mask) !== 0) {
+      mask ^= nums[j]
+      j++
+    }
+    mask |= cur
+    // console.log(i, j, mask, i - j +1)
+    res = Math.max(res, i - j + 1)
+  }
+  
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 78c9926874381f8e01b018b003edf09e6bbe87fa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Jan 2023 17:20:33 +0800
Subject: [PATCH 2502/3374] Update 2354-number-of-excellent-pairs.js

---
 2354-number-of-excellent-pairs.js | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2354-number-of-excellent-pairs.js b/2354-number-of-excellent-pairs.js
index aec51380..b610661b 100644
--- a/2354-number-of-excellent-pairs.js
+++ b/2354-number-of-excellent-pairs.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countExcellentPairs = function(nums, k) {
+  const cnt = Array(31).fill(0), set = new Set(nums)
+  for(const e of set) {
+    cnt[setBits(e)]++
+  }
+  let res = 0
+  
+  for(let i = 1; i < 31; i++) {
+    for(let j = 1; j < 31; j++) {
+      if(i + j >= k) res += cnt[i] * cnt[j]
+    }
+  }
+
+  return res
+  
+  function setBits(num) {
+    let res = 0
+    while(num) {
+      res += num % 2
+      num = num >> 1
+    }
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From bdcb0f8e9b4d4b59ffc19f5db96cfb6d858124df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Jan 2023 13:47:00 +0800
Subject: [PATCH 2503/3374] Update
 2411-smallest-subarrays-with-maximum-bitwise-or.js

---
 ...llest-subarrays-with-maximum-bitwise-or.js | 20 ++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/2411-smallest-subarrays-with-maximum-bitwise-or.js b/2411-smallest-subarrays-with-maximum-bitwise-or.js
index 0c5f82b2..6f00bf51 100644
--- a/2411-smallest-subarrays-with-maximum-bitwise-or.js
+++ b/2411-smallest-subarrays-with-maximum-bitwise-or.js
@@ -2,14 +2,16 @@
  * @param {number[]} nums
  * @return {number[]}
  */
-const smallestSubarrays = function(nums) {
-  const n = nums.length, last = Array(30).fill(0), res = [];
-  for (let i = n - 1; i >= 0; --i) {
-    res[i] = 1;
-    for (let j = 0; j < 30; ++j) {
-      if ((nums[i] & (1 << j)) > 0) last[j] = i;
-      res[i] = Math.max(res[i], last[j] - i + 1);
+const smallestSubarrays = function (nums) {
+  const n = nums.length,
+    last = Array(30).fill(0),
+    res = []
+  for (let i = n - 1; i >= 0; i--) {
+    res[i] = 1
+    for (let j = 0; j < 30; j++) {
+      if ((nums[i] & (1 << j)) > 0) last[j] = i
+      res[i] = Math.max(res[i], last[j] - i + 1)
     }
   }
-  return res;
-};
+  return res
+}

From 4608d03f70dc7fe07d1ad2061bf6798cc5d20992 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Jan 2023 10:12:53 +0800
Subject: [PATCH 2504/3374] Update
 2461-maximum-sum-of-distinct-subarrays-with-length-k.js

---
 ...sum-of-distinct-subarrays-with-length-k.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2461-maximum-sum-of-distinct-subarrays-with-length-k.js b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
index f2d9bb8e..932c8383 100644
--- a/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
+++ b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumSubarraySum = function (nums, k) {
+  const map = new Map(), n = nums.length
+  let i = 0, res = 0, sum = 0
+
+  while(i < n && i < k) {
+    const cur = nums[i]
+    map.set(cur, (map.get(cur) || 0) + 1 )
+    sum += cur
+    i++
+  }
+  if(map.size === k) res = sum
+
+  for(i = k; i < n; i++) {
+    const cur = nums[i]
+    map.set(cur, (map.get(cur) || 0) + 1)
+    const pre = nums[i - k]
+    map.set(pre, (map.get(pre) || 0) - 1)
+    if(map.get(pre) === 0) map.delete(pre)
+
+    sum += cur
+    sum -= nums[i - k]
+
+    if(map.size === k) res = Math.max(res, sum)
+  }
+
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 2d22a26ee82535552436a749c97c72c2f2428ef2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Jan 2023 21:38:20 +0800
Subject: [PATCH 2505/3374] Create
 2422-merge-operations-to-turn-array-into-a-palindrome.js

---
 ...rations-to-turn-array-into-a-palindrome.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2422-merge-operations-to-turn-array-into-a-palindrome.js

diff --git a/2422-merge-operations-to-turn-array-into-a-palindrome.js b/2422-merge-operations-to-turn-array-into-a-palindrome.js
new file mode 100644
index 00000000..cc6be2d3
--- /dev/null
+++ b/2422-merge-operations-to-turn-array-into-a-palindrome.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumOperations = function(nums) {
+    const n = nums.length
+    let left = nums[0], right = nums[n - 1]
+    let cnt = 0;
+    for (let i = 0, j = n - 1; i < j;) {
+        if (left === right) {
+            i++;
+            j--;
+            left = nums[i];
+            right = nums[j];
+        } else if (left < right) {
+            i++;
+            left += nums[i];
+            cnt++;
+        } else if (left > right) {
+            j--;
+            right += nums[j];
+            cnt++;
+        }
+    }
+    return cnt;
+};

From a3511319a2f880f758386b3e5a4f6a9410e407ba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Jan 2023 19:57:23 +0800
Subject: [PATCH 2506/3374] Create
 2516-take-k-of-each-character-from-left-and-right.js

---
 ...k-of-each-character-from-left-and-right.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2516-take-k-of-each-character-from-left-and-right.js

diff --git a/2516-take-k-of-each-character-from-left-and-right.js b/2516-take-k-of-each-character-from-left-and-right.js
new file mode 100644
index 00000000..f917b2db
--- /dev/null
+++ b/2516-take-k-of-each-character-from-left-and-right.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const takeCharacters = function(s, k) {
+  const cnt = {a: 0, b: 0, c: 0}
+  const n = s.length
+  for(const ch of s) {
+    cnt[ch]++
+  }
+  if(cnt.a < k || cnt.b < k || cnt.c < k) return -1
+  const limits = { a: cnt.a - k, b: cnt.b - k, c: cnt.c - k }
+  let l = 0, r = 0, res = 0
+  const hash = {a: 0, b: 0, c: 0}
+  for(; r < n; r++) {
+    const cur = s[r]
+    hash[cur]++
+    while(hash[cur] > limits[cur]) {
+      hash[s[l]]--
+      l++
+    }
+    
+    res = Math.max(res, r - l + 1)
+  }
+  
+  return n - res
+};

From d602111da571c32d4c5bd3f562c9dc2d2d2921bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Jan 2023 18:28:58 +0800
Subject: [PATCH 2507/3374] Create
 2531-make-number-of-distinct-characters-equal.js

---
 ...ake-number-of-distinct-characters-equal.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 2531-make-number-of-distinct-characters-equal.js

diff --git a/2531-make-number-of-distinct-characters-equal.js b/2531-make-number-of-distinct-characters-equal.js
new file mode 100644
index 00000000..df247fbf
--- /dev/null
+++ b/2531-make-number-of-distinct-characters-equal.js
@@ -0,0 +1,53 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {boolean}
+ */
+const isItPossible = function(word1, word2) {
+    const map1 = new Array(26).fill(0);
+    const map2 = new Array(26).fill(0);
+        
+    const a = 'a'.charCodeAt(0)
+		// store frequency of characters
+    for (const ch of word1) map1[ch.charCodeAt(0)-a]++;
+    for (const ch of word2) map2[ch.charCodeAt(0)-a]++;
+
+    for (let i = 0; i < 26; i++) {
+      if (map1[i] === 0) continue;
+      for (let j = 0; j < 26; j++) {
+        if (map2[j] === 0) continue;
+
+    // increase freq of char2 and decrease freq of char1 in map1
+        map1[j]++;
+        map1[i]--;
+
+    // increase freq of char1 and decrease freq of char2 in map2
+        map2[i]++;
+        map2[j]--;
+
+    // if equal number of unique characters, return true
+        if (same(map1, map2)) return true;
+
+    // revert back changes
+        map1[j]--;
+        map1[i]++;
+        map2[i]--;
+        map2[j]++;
+      }
+    }
+
+    return false;
+  
+  	// check if both maps contain equal number of unique characters
+    function same( map1,  map2) {
+      let count1 = 0;
+      let count2 = 0;
+      for (let i = 0; i < 26; i++) {
+        if (map1[i] > 0) count1++;
+        if (map2[i] > 0) count2++;
+      }
+
+      return count1 === count2;
+    }
+};
+

From 21876f448010a47d2c9fbcc28830912183ba67f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Jan 2023 18:31:18 +0800
Subject: [PATCH 2508/3374] Create
 2530-maximal-score-after-applying-k-operations.js

---
 ...ximal-score-after-applying-k-operations.js | 86 +++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 2530-maximal-score-after-applying-k-operations.js

diff --git a/2530-maximal-score-after-applying-k-operations.js b/2530-maximal-score-after-applying-k-operations.js
new file mode 100644
index 00000000..951db8f0
--- /dev/null
+++ b/2530-maximal-score-after-applying-k-operations.js
@@ -0,0 +1,86 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxKelements = function(nums, k) {
+   const pq = new PQ((a, b) => a > b)
+   for(const e of nums) pq.push(e)
+  let res = 0
+  while(k) {
+    const tmp = pq.pop()
+    res += tmp
+    pq.push(Math.ceil(tmp / 3))
+    k--
+  }
+  
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 2ed330370d4bc52edc5422ea35d236b322d0ec56 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Jan 2023 19:49:09 +0800
Subject: [PATCH 2509/3374] Create
 2529-maximum-count-of-positive-integer-and-negative-integer.js

---
 ...unt-of-positive-integer-and-negative-integer.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2529-maximum-count-of-positive-integer-and-negative-integer.js

diff --git a/2529-maximum-count-of-positive-integer-and-negative-integer.js b/2529-maximum-count-of-positive-integer-and-negative-integer.js
new file mode 100644
index 00000000..d8f6a42f
--- /dev/null
+++ b/2529-maximum-count-of-positive-integer-and-negative-integer.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumCount = function(nums) {
+  let pos = 0, neg = 0
+  
+  for(const e of nums) {
+    if(e > 0) pos++
+    else if(e < 0) neg++
+  }
+  
+  return Math.max(pos, neg)
+};

From 9d9ad5b11e00bcc0d539fdc2685db0bf1cf90f50 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Jan 2023 20:03:32 +0800
Subject: [PATCH 2510/3374] Update
 236-lowest-common-ancestor-of-a-binary-tree.js

---
 ...lowest-common-ancestor-of-a-binary-tree.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/236-lowest-common-ancestor-of-a-binary-tree.js b/236-lowest-common-ancestor-of-a-binary-tree.js
index 002557fa..c0b40692 100644
--- a/236-lowest-common-ancestor-of-a-binary-tree.js
+++ b/236-lowest-common-ancestor-of-a-binary-tree.js
@@ -55,3 +55,26 @@ const lowestCommonAncestor = function(root, p, q) {
     if(left && right) return root;
     return left ? left : right;
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+const lowestCommonAncestor = function(root, p, q) {
+  if(root == null || root === p || root === q) return root
+  const left = lowestCommonAncestor(root.left, p, q)
+  const right = lowestCommonAncestor(root.right, p, q)
+  if(left && right) return root
+  return left || right
+};

From 9dad5df0b0dde568355c6cdcb7ffaadea0b2dd2b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Jan 2023 20:08:47 +0800
Subject: [PATCH 2511/3374] Update
 1644-lowest-common-ancestor-of-a-binary-tree-ii.js

---
 ...est-common-ancestor-of-a-binary-tree-ii.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1644-lowest-common-ancestor-of-a-binary-tree-ii.js b/1644-lowest-common-ancestor-of-a-binary-tree-ii.js
index 32c2a70a..bd9407bb 100644
--- a/1644-lowest-common-ancestor-of-a-binary-tree-ii.js
+++ b/1644-lowest-common-ancestor-of-a-binary-tree-ii.js
@@ -33,3 +33,41 @@ const lowestCommonAncestor = function (root, p, q) {
   dfs(root)
   return cn
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+const lowestCommonAncestor = function (root, p, q) {
+  let hasP = false, hasQ = false
+  const res = LCA(root, p, q)
+  return hasP && hasQ ? res : null
+
+  function LCA(root, p, q) {
+    if(root == null) return root
+    const left = LCA(root.left, p, q)
+    const right = LCA(root.right, p, q)
+    if(root === p) {
+      hasP = true
+      return root
+    }
+    if(root === q) {
+      hasQ = true
+      return root
+    }
+    if(left && right) return root
+    return left || right
+  }
+}
+

From a736e694f5724616a8ff4b4646928c0bdb3fe24d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Jan 2023 21:14:29 +0800
Subject: [PATCH 2512/3374] Update
 865-smallest-subtree-with-all-the-deepest-nodes.js

---
 ...lest-subtree-with-all-the-deepest-nodes.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/865-smallest-subtree-with-all-the-deepest-nodes.js b/865-smallest-subtree-with-all-the-deepest-nodes.js
index ad7fa163..cea0b7a0 100755
--- a/865-smallest-subtree-with-all-the-deepest-nodes.js
+++ b/865-smallest-subtree-with-all-the-deepest-nodes.js
@@ -26,3 +26,37 @@ function result(node, dist) {
   this.node = node;
   this.dist = dist;
 }
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {TreeNode}
+ */
+const subtreeWithAllDeepest = function(root) {
+  let res = null, maxDepth = 0
+  dfs(root, 0)
+  
+  return res
+  
+  function dfs(node, depth) {
+    if(node == null) return depth - 1
+    
+    const left = dfs(node.left, depth + 1)
+    const right = dfs(node.right, depth + 1)
+    maxDepth = Math.max(maxDepth, left, right)
+    
+    if(left === maxDepth && right === maxDepth) {
+      res = node
+    }
+    return Math.max(left, right)
+  }
+};

From 17b9b9162888ff41fe5671149c98e574a5632d7b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Jan 2023 13:57:33 +0800
Subject: [PATCH 2513/3374] Update
 1676-lowest-common-ancestor-of-a-binary-tree-iv.js

---
 ...est-common-ancestor-of-a-binary-tree-iv.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1676-lowest-common-ancestor-of-a-binary-tree-iv.js b/1676-lowest-common-ancestor-of-a-binary-tree-iv.js
index f5cb150b..1057137e 100644
--- a/1676-lowest-common-ancestor-of-a-binary-tree-iv.js
+++ b/1676-lowest-common-ancestor-of-a-binary-tree-iv.js
@@ -20,3 +20,32 @@ const lowestCommonAncestor = function(root, nodes) {
   if(left && right) return root
   return left ? left : right
 };
+
+// another
+
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode[]} nodes
+ * @return {TreeNode}
+ */
+ const lowestCommonAncestor = function(root, nodes) {
+  const set = new Set(nodes)
+  return dfs(root)
+  
+  function dfs(node) {
+    if(node == null) return node
+    const left = dfs(node.left)
+    const right = dfs(node.right)
+
+    if(set.has(node)) return node
+    if(left && right) return node
+    return left || right
+  }
+};

From 581870421d2fa2952bd594d7ce205956cb7a1b07 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Jan 2023 19:03:12 +0800
Subject: [PATCH 2514/3374] Update
 235-lowest-common-ancestor-of-a-binary-search-tree.js

---
 ...common-ancestor-of-a-binary-search-tree.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/235-lowest-common-ancestor-of-a-binary-search-tree.js b/235-lowest-common-ancestor-of-a-binary-search-tree.js
index 482f92e0..205bcf3d 100644
--- a/235-lowest-common-ancestor-of-a-binary-search-tree.js
+++ b/235-lowest-common-ancestor-of-a-binary-search-tree.js
@@ -1,3 +1,27 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+const lowestCommonAncestor = function(root, p, q) {
+  if(root == null || root == p || root == q) return root
+  const left = lowestCommonAncestor(root.left, p, q)
+  const right = lowestCommonAncestor(root.right, p, q)
+  if(left && right) return root
+  return left || right
+};
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 51b313279408cc202ed9ccad89baa5f934cf3725 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Jan 2023 20:14:08 +0800
Subject: [PATCH 2515/3374] Create
 2538-difference-between-maximum-and-minimum-price-sum.js

---
 ...e-between-maximum-and-minimum-price-sum.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2538-difference-between-maximum-and-minimum-price-sum.js

diff --git a/2538-difference-between-maximum-and-minimum-price-sum.js b/2538-difference-between-maximum-and-minimum-price-sum.js
new file mode 100644
index 00000000..ba08e423
--- /dev/null
+++ b/2538-difference-between-maximum-and-minimum-price-sum.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} price
+ * @return {number}
+ */
+const maxOutput = function(n, edges, price) {
+  const tree = [];
+  const memo = [];
+  for (let i = 0; i < n; i++) tree[i] = [];
+  for (const [a, b] of edges) {
+    tree[a].push(b);
+    tree[b].push(a);
+  }
+
+  let result = 0;
+  dfs(0, -1);
+
+  function dfs(node, parent) {
+    const max = [price[node], 0];
+    const nodes = tree[node] ?? [];
+    for (const child of nodes) {
+      if (child === parent) continue;
+      const sub = dfs(child, node);
+      result = Math.max(result, max[0] + sub[1]);
+      result = Math.max(result, max[1] + sub[0]);
+      max[0] = Math.max(max[0], sub[0] + price[node]);
+      max[1] = Math.max(max[1], sub[1] + price[node]);
+    }
+    return max;
+  }
+
+  return result;
+};

From bcf6d90034e24dc9d7ef583f5a616e67b3b26724 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jan 2023 18:33:14 +0800
Subject: [PATCH 2516/3374] Update 1310-xor-queries-of-a-subarray.js

---
 1310-xor-queries-of-a-subarray.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1310-xor-queries-of-a-subarray.js b/1310-xor-queries-of-a-subarray.js
index efad256d..e2b63cb2 100644
--- a/1310-xor-queries-of-a-subarray.js
+++ b/1310-xor-queries-of-a-subarray.js
@@ -17,3 +17,26 @@ const xorQueries = function(arr, queries) {
   })
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const xorQueries = function(arr, queries) {
+  const xorArr = []
+  xorArr[0] = 0
+  const n = arr.length
+  for(let i = 0; i < n; i++) {
+    const cur = arr[i]
+    xorArr.push(cur ^ xorArr[xorArr.length - 1])
+  }
+  const res = []
+  for(const [l, r] of queries) {
+    res.push(xorArr[r + 1] ^ xorArr[l])
+  }
+  
+  return res
+};

From 561f40017c2b3dc0884b397355c96b7da022fa12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Jan 2023 19:34:20 +0800
Subject: [PATCH 2517/3374] Update 1734-decode-xored-permutation.js

---
 1734-decode-xored-permutation.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1734-decode-xored-permutation.js b/1734-decode-xored-permutation.js
index 4b0ecdf9..1ae0f396 100644
--- a/1734-decode-xored-permutation.js
+++ b/1734-decode-xored-permutation.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} encoded
+ * @return {number[]}
+ */
+const decode = function(encoded) {
+  const n = encoded.length + 1
+  let xor = 0
+  for(let i = 1; i <= n; i++) xor ^= i
+  for(let i = 1; i < n - 1; i += 2) xor ^= encoded[i]
+  const res = [xor]
+  let pre = xor
+  for(let i = 0; i < n - 1; i++) {
+    res.push(encoded[i] ^ pre)
+    pre = res[res.length - 1]
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} encoded
  * @return {number[]}

From 77d0c7a8afb6214155a6755f3ca9aab5d3071966 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Feb 2023 19:07:56 +0800
Subject: [PATCH 2518/3374] Update
 1835-find-xor-sum-of-all-pairs-bitwise-and.js

---
 1835-find-xor-sum-of-all-pairs-bitwise-and.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/1835-find-xor-sum-of-all-pairs-bitwise-and.js b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
index 8ada2371..795a8fcf 100644
--- a/1835-find-xor-sum-of-all-pairs-bitwise-and.js
+++ b/1835-find-xor-sum-of-all-pairs-bitwise-and.js
@@ -1,3 +1,19 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @return {number}
+ */
+const getXORSum = function(arr1, arr2) {
+  let a = 0, b = 0
+  for(const e of arr1) a ^= e
+  for(const e of arr2) b ^= e
+  
+  return a & b
+};
+
+
+// another
+
 // On every bit XOR acts as modulo 2 addition and AND acts as modulo 2 multiplication.
 // The set {0,1} with modulo 2 addition and multiplication is the field GF(2) and the distributive property holds in every field.
 

From 06ca5eb13364483cb831e698dacfc193c3a2d581 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Feb 2023 19:08:00 +0800
Subject: [PATCH 2519/3374] Create 2527-find-xor-beauty-of-array.js

---
 2527-find-xor-beauty-of-array.js | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 2527-find-xor-beauty-of-array.js

diff --git a/2527-find-xor-beauty-of-array.js b/2527-find-xor-beauty-of-array.js
new file mode 100644
index 00000000..077ac29b
--- /dev/null
+++ b/2527-find-xor-beauty-of-array.js
@@ -0,0 +1,9 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const xorBeauty = function(nums) {
+  let res = 0
+  for(const e of nums) res ^= e
+  return res
+};

From 8b459b283c219435f0711ed9dccd20f18d2d56da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Feb 2023 12:36:09 +0800
Subject: [PATCH 2520/3374] Create 2558-take-gifts-from-the-richest-pile.js

---
 2558-take-gifts-from-the-richest-pile.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2558-take-gifts-from-the-richest-pile.js

diff --git a/2558-take-gifts-from-the-richest-pile.js b/2558-take-gifts-from-the-richest-pile.js
new file mode 100644
index 00000000..2efda9f0
--- /dev/null
+++ b/2558-take-gifts-from-the-richest-pile.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} gifts
+ * @param {number} k
+ * @return {number}
+ */
+const pickGifts = function(gifts, k) {
+  
+  const n = gifts.length
+  while(k > 0) {
+    
+    const max = Math.max(...gifts)
+    const idx = gifts.indexOf(max)
+    gifts[idx] = ~~(Math.sqrt(max))
+    
+    k--
+  }
+  
+  return gifts.reduce((ac, e) => ac + e, 0)
+};

From 976058ad7b18b2fa65b3333015299a4082d0f6f7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Feb 2023 15:38:20 +0800
Subject: [PATCH 2521/3374] Create 2559-count-vowel-strings-in-ranges.js

---
 2559-count-vowel-strings-in-ranges.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2559-count-vowel-strings-in-ranges.js

diff --git a/2559-count-vowel-strings-in-ranges.js b/2559-count-vowel-strings-in-ranges.js
new file mode 100644
index 00000000..ff31c5be
--- /dev/null
+++ b/2559-count-vowel-strings-in-ranges.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[]} words
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const vowelStrings = function(words, queries) {
+  const n = words.length
+  const pre = Array(n + 1).fill(0)
+  const set = new Set(['a', 'e', 'i', 'o', 'u'])
+  for(let i = 0; i < n; i++) {
+    const cur = words[i]
+    if(set.has(cur[0]) && set.has(cur[cur.length - 1])) pre[i + 1] = 1
+  }
+  
+  const cnt = Array(n + 1).fill(0)
+  for(let i = 1; i <= n; i++) {
+    cnt[i] = cnt[i - 1] + pre[i]
+  }
+  
+  const res = []
+  
+  for(const [l, r] of queries) {
+    res.push(cnt[r + 1] - cnt[l])
+  }
+  
+  return res
+};

From b3563b1612347c63f97d51a773a76ca7539c6284 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Feb 2023 20:03:40 +0800
Subject: [PATCH 2522/3374] Update 502-ipo.js

---
 502-ipo.js | 102 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 102 insertions(+)

diff --git a/502-ipo.js b/502-ipo.js
index e095989d..9938088e 100644
--- a/502-ipo.js
+++ b/502-ipo.js
@@ -111,3 +111,105 @@ const findMaximizedCapital = function(k, W, Profits, Capital) {
   }
   return W;
 };
+
+// another
+
+/**
+ * @param {number} k
+ * @param {number} w
+ * @param {number[]} profits
+ * @param {number[]} capital
+ * @return {number}
+ */
+const findMaximizedCapital = function(k, w, profits, capital) {
+  const capPQ = new PQ((a, b) => a.cap < b.cap)
+  const proPQ = new PQ((a, b) => a.pro > b.pro)
+  const n = profits.length
+  
+  for(let i = 0; i < n; i++) {
+    capPQ.push({ cap: capital[i], pro: profits[i] })
+  }
+  
+  while(k) {
+    
+    while(!capPQ.isEmpty() && capPQ.peek().cap <= w) {
+      proPQ.push(capPQ.pop())
+    }
+    
+    if(proPQ.isEmpty()) break
+    
+    w += proPQ.pop().pro
+    k--
+  }
+  
+  
+  return w
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 9cfa836aa8c562e374ec8fb1ee85a397e407135f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Feb 2023 21:32:34 +0800
Subject: [PATCH 2523/3374] Update 857-minimum-cost-to-hire-k-workers.js

---
 857-minimum-cost-to-hire-k-workers.js | 31 +++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/857-minimum-cost-to-hire-k-workers.js b/857-minimum-cost-to-hire-k-workers.js
index 028bcf65..9c6ae374 100644
--- a/857-minimum-cost-to-hire-k-workers.js
+++ b/857-minimum-cost-to-hire-k-workers.js
@@ -61,3 +61,34 @@ function insert(arr, el) {
   }
   arr.push(el)
 }
+
+// another
+
+/**
+ * @param {number[]} quality
+ * @param {number[]} wage
+ * @param {number} K
+ * @return {number}
+ */
+const mincostToHireWorkers = function(quality, wage, K) {
+  const workers = [], n = wage.length
+  for(let i = 0; i < n; i++) {
+    workers.push([wage[i] / quality[i], quality[i]])
+  }
+  workers.sort((a, b) => a[0] - b[0])
+  const pq = new MaxPriorityQueue({ priority: (w) => w.quality })
+  let res = Infinity, qualitySum = 0
+  for(const worker of workers) {
+    const [ratio, quality] = worker
+    qualitySum += quality
+    pq.enqueue({ quality })
+    
+    if(pq.size() > K) {
+      qualitySum -= pq.dequeue().element.quality
+    }
+    if(pq.size() === K) res = Math.min(res, qualitySum * ratio)
+  }
+  
+  return res
+};
+

From 2869ef71a2115cd4645bb484e8853b0a261816b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Feb 2023 21:36:08 +0800
Subject: [PATCH 2524/3374] Update 857-minimum-cost-to-hire-k-workers.js

---
 857-minimum-cost-to-hire-k-workers.js | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/857-minimum-cost-to-hire-k-workers.js b/857-minimum-cost-to-hire-k-workers.js
index 9c6ae374..76914b01 100644
--- a/857-minimum-cost-to-hire-k-workers.js
+++ b/857-minimum-cost-to-hire-k-workers.js
@@ -75,6 +75,9 @@ const mincostToHireWorkers = function(quality, wage, K) {
   for(let i = 0; i < n; i++) {
     workers.push([wage[i] / quality[i], quality[i]])
   }
+  // wage[i] / wage[j] = quality[i] / quality[j]
+  // wage[i] * quality[j] = wage[j] * quality[i]
+  // wage[i] / quality[i] = wage[j] / quality[j]
   workers.sort((a, b) => a[0] - b[0])
   const pq = new MaxPriorityQueue({ priority: (w) => w.quality })
   let res = Infinity, qualitySum = 0
@@ -92,3 +95,4 @@ const mincostToHireWorkers = function(quality, wage, K) {
   return res
 };
 
+

From e9b9c3c784281a10ac33f17b31636309e3cb01cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Feb 2023 19:25:05 +0800
Subject: [PATCH 2525/3374] Update
 1353-maximum-number-of-events-that-can-be-attended.js

---
 ...m-number-of-events-that-can-be-attended.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/1353-maximum-number-of-events-that-can-be-attended.js b/1353-maximum-number-of-events-that-can-be-attended.js
index 58ec8b08..f0cdc48d 100644
--- a/1353-maximum-number-of-events-that-can-be-attended.js
+++ b/1353-maximum-number-of-events-that-can-be-attended.js
@@ -220,3 +220,29 @@ function maxEvents(events) {
 //     segmentTree.setAt(i, value)
 //     segmentTree.length
 class SegmentTree{constructor(t,e,s){if(this.valueLength=t.length,this.identity=e,this.associate=s,0===t.length)this.tree=[];else{const h=2**Math.ceil(Math.log2(t.length))*2-1,i=[];for(let s=0;s<=h>>1;++s)i[(h>>1)+s]=s<t.length?t[s]:e;for(let t=(h>>1)-1;t>=0;--t)i[t]=s(i[2*t+1],i[2*t+2]);this.tree=i}}get length(){return this.valueLength}getAt(t){return this.tree[t+(this.tree.length>>1)]}queryIn(t,e){let s=this.identity;const h=[[0,0,1+(this.tree.length>>1)]];for(;h.length>0;){const[i,r,n]=h.pop();r>=t&&n<=e?s=this.associate(s,this.tree[i]):r>=e||n<t||i>this.tree.length>>1||h.push([2*i+1,r,r+n>>1],[2*i+2,r+n>>1,n])}return s}setAt(t,e){const s=t+(this.tree.length>>1);this.tree[s]=e;let h=s-1>>1;for(;h>=0;)this.tree[h]=this.associate(this.tree[2*h+1],this.tree[2*h+2]),h=h-1>>1}}
+
+
+// another
+
+/**
+ * @param {number[][]} events
+ * @return {number}
+ */
+function maxEvents(events) {
+  const pq = new MinPriorityQueue ()
+  events.sort((a, b) => a[0] - b[0])
+  let res = 0, i = 0, n = events.length
+  for(let d = 1; d <= 1e5; d++) {
+    while(i < n && events[i][0] === d) {
+      pq.enqueue(events[i++][1])
+    }
+    while(!pq.isEmpty() && pq.front().element < d) {
+      pq.dequeue()
+    }
+    if(!pq.isEmpty()) {
+      res++
+      pq.dequeue()
+    }
+  }
+  return res
+}

From f2e0126ec564d7198290dac4cf5781f6c43ade22 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Feb 2023 19:19:46 +0800
Subject: [PATCH 2526/3374] Create 2542-maximum-subsequence-score.js

---
 2542-maximum-subsequence-score.js | 33 +++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2542-maximum-subsequence-score.js

diff --git a/2542-maximum-subsequence-score.js b/2542-maximum-subsequence-score.js
new file mode 100644
index 00000000..caadb31d
--- /dev/null
+++ b/2542-maximum-subsequence-score.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number}
+ */
+const maxScore = function(nums1, nums2, k) {
+  const pq = new MinPriorityQueue({ priority: e => e })
+  const n = nums1.length
+  const arr = []
+  
+  for(let i = 0; i < n; i++) {
+    arr.push([nums1[i], nums2[i]])
+  }
+  
+  arr.sort((a, b) => b[1] - a[1])
+  let res = 0, left = 0
+  for(let i = 0; i < n; i++) {
+    const cur = arr[i]
+    pq.enqueue(cur[0])
+    left += cur[0]
+    if(pq.size() > k) {
+      const tmp = pq.dequeue().element
+      left -= tmp
+    }
+    
+    if(pq.size() === k) {
+      res = Math.max(res, left * cur[1])
+    }
+  }
+  
+  return res
+};

From 070ca1efa7b8facc504991ac0d275024958bc620 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Feb 2023 16:38:38 +0800
Subject: [PATCH 2527/3374] Create 2563-count-the-number-of-fair-pairs.js

---
 2563-count-the-number-of-fair-pairs.js | 40 ++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2563-count-the-number-of-fair-pairs.js

diff --git a/2563-count-the-number-of-fair-pairs.js b/2563-count-the-number-of-fair-pairs.js
new file mode 100644
index 00000000..3bdf0771
--- /dev/null
+++ b/2563-count-the-number-of-fair-pairs.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+const countFairPairs = function(nums, lower, upper) {
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+  
+  let total = BigInt(n * (n - 1)) / 2n
+  return Number(total - BigInt(large(nums, upper) + low(nums, lower)))
+};
+
+
+function large(arr, target) {
+    let count = 0;
+    for (let lo = 0, hi = arr.length - 1; lo < hi; ) {
+        if (arr[lo] + arr[hi] > target) {
+            count += (hi - lo);
+            hi--;
+        } else  {
+            lo++;
+        }
+    }
+    return count;
+}
+
+function low(arr, target) {
+    let count = 0;
+    for (let lo = 0, hi = arr.length - 1; lo < hi; ) {
+        if (arr[lo] + arr[hi] < target) {
+            count += (hi - lo);
+            lo++;
+        } else  {
+            hi--;
+        }
+    }
+    return count;
+}

From d5baec98df6e2651107aa482d7f7bbaa70630243 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Feb 2023 19:02:11 +0800
Subject: [PATCH 2528/3374] Update 630-course-schedule-iii.js

---
 630-course-schedule-iii.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/630-course-schedule-iii.js b/630-course-schedule-iii.js
index f9558beb..c4366e57 100644
--- a/630-course-schedule-iii.js
+++ b/630-course-schedule-iii.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} courses
+ * @return {number}
+ */
+const scheduleCourse = function (courses) {
+  const compare = (a, b) => a[0] === b[0] ? 0 : (a[0] > b[0] ? -1 : 1)
+  const queue = new PriorityQueue({ compare })
+  courses.sort((a, b) => a[1] - b[1])
+  let time = 0
+  for(let e of courses) {
+    time += e[0]
+    queue.enqueue(e)
+    if(time > e[1]) {
+      const tmp = queue.dequeue()
+      time -= tmp[0]
+    }
+  }
+  return queue.size()
+}
+
+// another
+
+
 /**
  * @param {number[][]} courses
  * @return {number}

From 487713041179bed64279377b992495add11da84b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Feb 2023 20:31:37 +0800
Subject: [PATCH 2529/3374] Create 2523-closest-prime-numbers-in-range.js

---
 2523-closest-prime-numbers-in-range.js | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2523-closest-prime-numbers-in-range.js

diff --git a/2523-closest-prime-numbers-in-range.js b/2523-closest-prime-numbers-in-range.js
new file mode 100644
index 00000000..4b06cc56
--- /dev/null
+++ b/2523-closest-prime-numbers-in-range.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} left
+ * @param {number} right
+ * @return {number[]}
+ */
+var closestPrimes = function(left, right) {
+    let primeArr = [];
+    let res = [-1, -1];
+    let minDiff = Infinity;
+
+    for(let i=left; i<=right; i++){
+        if(isPrime(i)) primeArr.push(i)
+    }
+
+    for(let i=1; i<primeArr.length; i++){
+        let diff = primeArr[i]-primeArr[i-1];
+        if(diff<minDiff){
+            res = [primeArr[i-1], primeArr[i]]
+            minDiff = diff;
+        }
+    }
+    return res
+
+};
+
+function isPrime(n) {
+    if (n === 1) return false;
+    if (n % 2 === 0) return n === 2;
+    let max = Math.floor(Math.sqrt(n)) ;
+    for(let i = 3; i <= max; i += 2) {
+        if (n % i === 0) return false;
+    }
+    return true;
+}

From 7e091a35a3f958ca65ca983a9bd390145fdd9ac4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Feb 2023 20:32:09 +0800
Subject: [PATCH 2530/3374] Update
 2163-minimum-difference-in-sums-after-removal-of-elements.js

---
 ...rence-in-sums-after-removal-of-elements.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/2163-minimum-difference-in-sums-after-removal-of-elements.js b/2163-minimum-difference-in-sums-after-removal-of-elements.js
index 938e51e7..862bbe53 100644
--- a/2163-minimum-difference-in-sums-after-removal-of-elements.js
+++ b/2163-minimum-difference-in-sums-after-removal-of-elements.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumDifference = function(nums) {
+  const n = nums.length, len = n / 3
+  const maxCompare = (p, c) => { return p === c ? 0 : (p > c ? -1 : 1)}
+  const minCompare = (p, c) => { return p === c ? 0 : (p < c ? -1 : 1)}
+  const maxHeap = new PriorityQueue({compare: maxCompare})
+  const minHeap = new PriorityQueue({compare: minCompare})
+  const pre = Array(n).fill(Infinity), suffix = Array(n).fill(-Infinity)
+  for(let i = 0, sum = 0; i < 2 * len; i++) {
+    const cur = nums[i]
+    maxHeap.enqueue(cur)
+    sum += cur
+    if(maxHeap.size() > len) {
+      const tmp = maxHeap.dequeue()
+      sum -= tmp
+    }
+    if(maxHeap.size() === len) {
+      pre[i] = sum 
+    }
+  }
+
+  for(let i = n - 1, sum = 0; i >= len; i--) {
+    const cur = nums[i]
+    minHeap.enqueue(cur)
+    sum += cur
+    if(minHeap.size() > len) {
+      const tmp = minHeap.dequeue()
+      sum -= tmp
+    }
+    if(minHeap.size() === len) {
+      suffix[i] = sum
+    }
+  }
+
+  // console.log(pre, suffix)
+  let res = Infinity
+  for(let i = len - 1; i < n - len; i++) {
+    res = Math.min(res, pre[i] - suffix[i + 1])
+  }
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From ced9e1f552261cdc94e90824438829a61bb0b4ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Feb 2023 21:05:33 +0800
Subject: [PATCH 2531/3374] Update
 1653-minimum-deletions-to-make-string-balanced.js

---
 ...nimum-deletions-to-make-string-balanced.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/1653-minimum-deletions-to-make-string-balanced.js b/1653-minimum-deletions-to-make-string-balanced.js
index ac09dbf2..4cf12446 100644
--- a/1653-minimum-deletions-to-make-string-balanced.js
+++ b/1653-minimum-deletions-to-make-string-balanced.js
@@ -1,3 +1,23 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumDeletions = function(s) {
+  let res = 0, b = 0
+  for(const e of s) {
+    if(e === 'b') b++
+    else if(b > 0) {
+      res++
+      b--
+    }
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @return {number}

From 40d34be01686032d12f29c910d3beecc19dbf42e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Feb 2023 21:29:05 +0800
Subject: [PATCH 2532/3374] Create
 2570-merge-two-2d-arrays-by-summing-values.js

---
 2570-merge-two-2d-arrays-by-summing-values.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2570-merge-two-2d-arrays-by-summing-values.js

diff --git a/2570-merge-two-2d-arrays-by-summing-values.js b/2570-merge-two-2d-arrays-by-summing-values.js
new file mode 100644
index 00000000..5b87f11c
--- /dev/null
+++ b/2570-merge-two-2d-arrays-by-summing-values.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[][]} nums1
+ * @param {number[][]} nums2
+ * @return {number[][]}
+ */
+var mergeArrays = function(nums1, nums2) {
+  const map = new Map()
+  for(const [id, val] of nums1) {
+    if(!map.has(id)) map.set(id, 0)
+    map.set(id, map.get(id) + val)
+  }
+  for(const [id, val] of nums2) {
+    if(!map.has(id)) map.set(id, 0)
+    map.set(id, map.get(id) + val)
+  }
+  const entries = [...map.entries()]
+  entries.sort((a, b) => a[0] - b[0])
+  return entries
+};

From a533c6a053212ab90cc0d65c8626479e6c4ce2b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Feb 2023 21:49:45 +0800
Subject: [PATCH 2533/3374] Create
 2571-minimum-operations-to-reduce-an-integer-to-0.js

---
 ...um-operations-to-reduce-an-integer-to-0.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2571-minimum-operations-to-reduce-an-integer-to-0.js

diff --git a/2571-minimum-operations-to-reduce-an-integer-to-0.js b/2571-minimum-operations-to-reduce-an-integer-to-0.js
new file mode 100644
index 00000000..a395370c
--- /dev/null
+++ b/2571-minimum-operations-to-reduce-an-integer-to-0.js
@@ -0,0 +1,22 @@
+function dec2bin(dec) {
+  return (dec >>> 0).toString(2);
+}
+function bitCnt(s) {
+  let res = 0
+  for(const e of s) {
+    if(e === '1') res++
+  }
+  return res
+}
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var minOperations = function(n) {
+  if(n === 0) return 0  
+  if(bitCnt(dec2bin(n)) === 1) return 1
+  const lowBit = n & -n
+  let low = minOperations(n + lowBit);
+  let high = minOperations(n - lowBit);
+  return Math.min(low, high) + 1;
+};

From 453f076de85fc643fc2e244e7f2ab9df5226bce5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Feb 2023 22:15:54 +0800
Subject: [PATCH 2534/3374] Add files via upload

---
 images/689.png | Bin 0 -> 200579 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 images/689.png

diff --git a/images/689.png b/images/689.png
new file mode 100644
index 0000000000000000000000000000000000000000..3a19a37adcd9686635b875c58301b8ec154643ee
GIT binary patch
literal 200579
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
G;r{_Yj?+T`

literal 0
HcmV?d00001


From 607dc5ee9e079504c34d0ec5248201e975cfb84e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 22 Feb 2023 21:40:10 +0800
Subject: [PATCH 2535/3374] Create 2565-subsequence-with-the-minimum-score.js

---
 2565-subsequence-with-the-minimum-score.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2565-subsequence-with-the-minimum-score.js

diff --git a/2565-subsequence-with-the-minimum-score.js b/2565-subsequence-with-the-minimum-score.js
new file mode 100644
index 00000000..e3dc5adc
--- /dev/null
+++ b/2565-subsequence-with-the-minimum-score.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+var minimumScore = function(s, t) {
+    let sl = s.length, tl = t.length, k = tl - 1;
+    const dp = new Array(tl).fill(-1);
+    for (let i = sl - 1; i >= 0 && k >= 0; --i) {
+      if (s.charAt(i) === t.charAt(k)) dp[k--] = i;
+    }
+    let res = k + 1;
+    for (let i = 0, j = 0; i < sl && j < tl && res > 0; ++i) {
+        if (s.charAt(i) === t.charAt(j)) {
+            while(k < tl && dp[k] <= i) k++
+            j++
+            res = Math.min(res, k - j);
+        }      
+    }
+
+    return res;
+};

From dc0d763995c2826a11e98903ac8f50632e529866 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Feb 2023 21:11:17 +0800
Subject: [PATCH 2536/3374] Create 2555-maximize-win-from-two-segments.js

---
 2555-maximize-win-from-two-segments.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2555-maximize-win-from-two-segments.js

diff --git a/2555-maximize-win-from-two-segments.js b/2555-maximize-win-from-two-segments.js
new file mode 100644
index 00000000..a2d06c88
--- /dev/null
+++ b/2555-maximize-win-from-two-segments.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} prizePositions
+ * @param {number} k
+ * @return {number}
+ */
+const maximizeWin = function(prizePositions, k) {
+  let res = 0, j = 0
+  const n = prizePositions.length, dp = new Array(n + 1).fill(0);
+  for (let i = 0; i < n; ++i) {
+    while (prizePositions[j] < prizePositions[i] - k) ++j;
+    dp[i + 1] = Math.max(dp[i], i - j + 1);
+    res = Math.max(res, i - j + 1 + dp[j]);
+  }
+  return res;
+};

From f92774b95a11f0af4db181b0e1cd5bebf03888e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Feb 2023 20:25:10 +0800
Subject: [PATCH 2537/3374] Update
 1638-count-substrings-that-differ-by-one-character.js

---
 ...substrings-that-differ-by-one-character.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1638-count-substrings-that-differ-by-one-character.js b/1638-count-substrings-that-differ-by-one-character.js
index c95a6d31..e1a9a64f 100644
--- a/1638-count-substrings-that-differ-by-one-character.js
+++ b/1638-count-substrings-that-differ-by-one-character.js
@@ -25,3 +25,30 @@ const countSubstrings = function (s, t) {
   }
   return result
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+const countSubstrings = function(s, t) {
+  let res = 0 ;
+  for (let i = 0; i < s.length; ++i) res += helper(s, t, i, 0);
+  for (let j = 1; j < t.length; ++j) res += helper(s, t, 0, j);
+  return res;
+};
+
+function helper(s,  t,  i,  j) {
+  let res = 0, pre = 0, cur = 0;
+  for (let n = s.length, m = t.length; i < n && j < m; ++i, ++j) {
+    cur++;
+    if (s.charAt(i) !== t.charAt(j)) {
+      pre = cur;
+      cur = 0;
+    }
+    res += pre;
+  }
+  return res;
+}

From e19f6551270ff8ea4a1ae110b673b489849e2531 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Feb 2023 21:12:02 +0800
Subject: [PATCH 2538/3374] Create 2574-left-and-right-sum-differences.js

---
 2574-left-and-right-sum-differences.js | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2574-left-and-right-sum-differences.js

diff --git a/2574-left-and-right-sum-differences.js b/2574-left-and-right-sum-differences.js
new file mode 100644
index 00000000..f3fa4833
--- /dev/null
+++ b/2574-left-and-right-sum-differences.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const leftRigthDifference = function(nums) {
+    const {abs} = Math
+    const n = nums.length
+    
+    const pre = new Array(n + 2).fill(0)
+    const post = new Array(n + 2).fill(0)
+    const res = []
+    for(let i = 1, cur = 0; i <= n; i++) {
+      pre[i] = cur
+      cur += nums[i - 1]
+    }
+  
+    for(let i = n, cur = 0; i >= 1; i--) {
+      post[i] = cur
+      cur += nums[i - 1]
+    }
+  
+    for(let i = 1; i <= n; i++) {
+      res[i - 1] = abs(pre[i] - post[i])
+    }
+    
+    return res
+};

From 1ba52525967cda1693e48d6e804cf694911747c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Feb 2023 21:13:36 +0800
Subject: [PATCH 2539/3374] Create
 2572-find-the-divisibility-array-of-a-string.js

---
 2572-find-the-divisibility-array-of-a-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2572-find-the-divisibility-array-of-a-string.js

diff --git a/2572-find-the-divisibility-array-of-a-string.js b/2572-find-the-divisibility-array-of-a-string.js
new file mode 100644
index 00000000..b9934b8a
--- /dev/null
+++ b/2572-find-the-divisibility-array-of-a-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} word
+ * @param {number} m
+ * @return {number[]}
+ */
+const divisibilityArray = function(word, m) {
+  let ans = [];
+  let cur = 0;
+  for (let i = 0; i < word.length; i++) {
+    cur = (cur * 10 + Number(word[i])) % m;
+    ans.push(cur === 0 ? 1 : 0);
+  }
+  return ans;
+};

From cc7fda34e106f2c7168572d0aae5b22fb562b73f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Feb 2023 21:16:16 +0800
Subject: [PATCH 2540/3374] Create
 2576-find-the-maximum-number-of-marked-indices.js

---
 2576-find-the-maximum-number-of-marked-indices.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 2576-find-the-maximum-number-of-marked-indices.js

diff --git a/2576-find-the-maximum-number-of-marked-indices.js b/2576-find-the-maximum-number-of-marked-indices.js
new file mode 100644
index 00000000..f8520d12
--- /dev/null
+++ b/2576-find-the-maximum-number-of-marked-indices.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxNumOfMarkedIndices = function(nums) {
+    let i = 0, n = nums.length;
+    nums.sort((a, b) => a - b)
+    for (let j = n - (~~(n / 2)); j < n; ++j) {
+        i += 2 * nums[i] <= nums[j] ? 1 : 0;      
+    }
+    return i * 2;
+};

From ef4c9cf4e0c043aa2e9c4b2e6eff4d8efe154f49 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Feb 2023 21:38:36 +0800
Subject: [PATCH 2541/3374] Create
 2577-minimum-time-to-visit-a-cell-in-a-grid.js

---
 ...-minimum-time-to-visit-a-cell-in-a-grid.js | 110 ++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 2577-minimum-time-to-visit-a-cell-in-a-grid.js

diff --git a/2577-minimum-time-to-visit-a-cell-in-a-grid.js b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
new file mode 100644
index 00000000..05a9d259
--- /dev/null
+++ b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
@@ -0,0 +1,110 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minimumTime = function (grid) {
+  const directions = [
+    [-1, 0],
+    [0, 1],
+    [1, 0],
+    [0, -1],
+  ]
+  let m = grid.length,
+    n = grid[0].length
+  if (grid[0][1] > 1 && grid[1][0] > 1) return -1
+  let dist = Array(m)
+    .fill(0)
+    .map(() => Array(n).fill(Infinity))
+  let heap = new Heap((a, b) => a[2] - b[2])
+  heap.add([0, 0, 0])
+  dist[0][0] = 0
+
+  while (!heap.isEmpty()) {
+    let [row, col, time] = heap.remove()
+    if (dist[row][col] < time) continue
+    if (row === m - 1 && col === n - 1) return time
+    for (let [x, y] of directions) {
+      let newRow = row + x,
+        newCol = col + y
+      if (newRow < 0 || newRow >= m || newCol < 0 || newCol >= n) continue
+      let diff = grid[newRow][newCol] - time
+      let moves = diff % 2 === 1 ? diff : diff + 1
+      let weight = grid[newRow][newCol] <= time + 1 ? 1 : moves
+      if (dist[newRow][newCol] > time + weight) {
+        dist[newRow][newCol] = Math.min(dist[newRow][newCol], time + weight)
+        heap.add([newRow, newCol, time + weight])
+      }
+    }
+  }
+}
+
+class Heap {
+  constructor(comparator = (a, b) => a - b) {
+    this.values = []
+    this.comparator = comparator
+    this.size = 0
+  }
+  add(val) {
+    this.size++
+    this.values.push(val)
+    let idx = this.size - 1,
+      parentIdx = Math.floor((idx - 1) / 2)
+    while (
+      parentIdx >= 0 &&
+      this.comparator(this.values[parentIdx], this.values[idx]) > 0
+    ) {
+      ;[this.values[parentIdx], this.values[idx]] = [
+        this.values[idx],
+        this.values[parentIdx],
+      ]
+      idx = parentIdx
+      parentIdx = Math.floor((idx - 1) / 2)
+    }
+  }
+  remove() {
+    if (this.size === 0) return -1
+    this.size--
+    if (this.size === 0) return this.values.pop()
+    let removedVal = this.values[0]
+    this.values[0] = this.values.pop()
+    let idx = 0
+    while (idx < this.size && idx < Math.floor(this.size / 2)) {
+      let leftIdx = idx * 2 + 1,
+        rightIdx = idx * 2 + 2
+      if (rightIdx === this.size) {
+        if (this.comparator(this.values[leftIdx], this.values[idx]) > 0) break
+        ;[this.values[leftIdx], this.values[idx]] = [
+          this.values[idx],
+          this.values[leftIdx],
+        ]
+        idx = leftIdx
+      } else if (
+        this.comparator(this.values[leftIdx], this.values[idx]) < 0 ||
+        this.comparator(this.values[rightIdx], this.values[idx]) < 0
+      ) {
+        if (this.comparator(this.values[leftIdx], this.values[rightIdx]) <= 0) {
+          ;[this.values[leftIdx], this.values[idx]] = [
+            this.values[idx],
+            this.values[leftIdx],
+          ]
+          idx = leftIdx
+        } else {
+          ;[this.values[rightIdx], this.values[idx]] = [
+            this.values[idx],
+            this.values[rightIdx],
+          ]
+          idx = rightIdx
+        }
+      } else {
+        break
+      }
+    }
+    return removedVal
+  }
+  top() {
+    return this.values[0]
+  }
+  isEmpty() {
+    return this.size === 0
+  }
+}

From 3250b66aa359a7c31c991eec0777a8820a5ef46e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Feb 2023 21:43:36 +0800
Subject: [PATCH 2542/3374] Update 334-increasing-triplet-subsequence.js

---
 334-increasing-triplet-subsequence.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/334-increasing-triplet-subsequence.js b/334-increasing-triplet-subsequence.js
index bd231408..d8b22cc0 100644
--- a/334-increasing-triplet-subsequence.js
+++ b/334-increasing-triplet-subsequence.js
@@ -35,3 +35,22 @@ const increasingTriplet = function(nums) {
 
   return false
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const increasingTriplet = function(nums) {
+  let small = Number.MAX_VALUE, big = Number.MAX_VALUE
+  
+  for(const e of nums) {
+    if(e <= small) small = e
+    else if(e <= big) big = e
+    else return true
+  }
+  
+  return false
+};
+

From 8bea775ead10ec6bb31895a679b45d6fe38b8523 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Mar 2023 22:10:21 +0800
Subject: [PATCH 2543/3374] Create 2454-next-greater-element-iv.js

---
 2454-next-greater-element-iv.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2454-next-greater-element-iv.js

diff --git a/2454-next-greater-element-iv.js b/2454-next-greater-element-iv.js
new file mode 100644
index 00000000..b172eaa0
--- /dev/null
+++ b/2454-next-greater-element-iv.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var secondGreaterElement = function(nums) {
+  let n = nums.length,  res = new Array(n).fill(-1);
+  const s1 = [], s2 = [], tmp = [];
+  for (let i = 0; i < n; i++) {
+    while (s2.length && nums[s2.at(-1)] < nums[i]) res[s2.pop()] = nums[i];
+    while (s1.length && nums[s1.at(-1)] < nums[i]) tmp.push(s1.pop());
+    while (tmp.length) s2.push(tmp.pop());
+    s1.push(i);
+  }
+  return res;
+};

From d8b4f84bd223a8f350114107890e85e2a12af1f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Mar 2023 22:31:20 +0800
Subject: [PATCH 2544/3374] Create
 2366-minimum-replacements-to-sort-the-array.js

---
 2366-minimum-replacements-to-sort-the-array.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2366-minimum-replacements-to-sort-the-array.js

diff --git a/2366-minimum-replacements-to-sort-the-array.js b/2366-minimum-replacements-to-sort-the-array.js
new file mode 100644
index 00000000..70d9854d
--- /dev/null
+++ b/2366-minimum-replacements-to-sort-the-array.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumReplacement = function(nums) {
+  const n = nums.length
+  let prev = nums[n - 1];;
+  let ans = 0;
+  for(let i = n - 2; i >= 0; i--){
+      let noOfTime = ~~(nums[i] / prev); 
+      if((nums[i]) % prev != 0){
+        noOfTime++;
+        prev = ~~(nums[i] / noOfTime);
+      }   
+      ans += noOfTime - 1;
+  }
+  return ans;
+};

From 0a9e1589a2e30efe5ed47599befae0d60f53a2bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 4 Mar 2023 21:02:37 +0800
Subject: [PATCH 2545/3374] Create 2365-task-scheduler-ii.js

---
 2365-task-scheduler-ii.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2365-task-scheduler-ii.js

diff --git a/2365-task-scheduler-ii.js b/2365-task-scheduler-ii.js
new file mode 100644
index 00000000..28b9371c
--- /dev/null
+++ b/2365-task-scheduler-ii.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} tasks
+ * @param {number} space
+ * @return {number}
+ */
+const taskSchedulerII = function(tasks, space) {
+  const last = new Map();;
+  let res = 0;
+  for (const a of tasks)
+    if (last.has(a)) {
+      res = Math.max(res, last.get(a) + space) + 1
+      last.set(a, res);
+    } else {
+      res++
+      last.set(a, res);
+    }  
+   return res;
+};

From c7f29b99154f5ff69f4ef94ca3deae7c76633caf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Mar 2023 15:12:30 +0800
Subject: [PATCH 2546/3374] Create 2585-number-of-ways-to-earn-points.js

---
 2585-number-of-ways-to-earn-points.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2585-number-of-ways-to-earn-points.js

diff --git a/2585-number-of-ways-to-earn-points.js b/2585-number-of-ways-to-earn-points.js
new file mode 100644
index 00000000..a2abffef
--- /dev/null
+++ b/2585-number-of-ways-to-earn-points.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number} target
+ * @param {number[][]} types
+ * @return {number}
+ */
+const waysToReachTarget = function(target, types) {
+  const n = types.length
+  const dp = Array.from({ length: n + 1 }, () => Array(target + 1).fill(0))
+  const mod = 1e9 + 7
+  let res = 0
+  dp[0][0] = 1
+  for(let i = 1; i <= n; i++) {
+    const [cnt, mark] = types[i - 1]
+    for(let j = 0, tmp = 0; j <= cnt; j++) {
+      const tmp = mark * j
+      for(let k = tmp; k <= target; k++) {
+        dp[i][k] = (dp[i][k] + dp[i - 1][k - tmp]) % mod 
+      }
+    }
+  }
+  
+  return dp[n][target] % mod
+};

From c0ccaa6551fda31ad9153b6a7a5ccf7bd0837770 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Mar 2023 15:12:57 +0800
Subject: [PATCH 2547/3374] Create 2583-kth-largest-sum-in-a-binary-tree.js

---
 2583-kth-largest-sum-in-a-binary-tree.js | 102 +++++++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 2583-kth-largest-sum-in-a-binary-tree.js

diff --git a/2583-kth-largest-sum-in-a-binary-tree.js b/2583-kth-largest-sum-in-a-binary-tree.js
new file mode 100644
index 00000000..214b31f6
--- /dev/null
+++ b/2583-kth-largest-sum-in-a-binary-tree.js
@@ -0,0 +1,102 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number} k
+ * @return {number}
+ */
+const kthLargestLevelSum = function(root, k) {
+  let row = [root]
+  const pq = new PQ((a, b) => a < b)
+  while(row.length) {
+    let sum = 0
+    const nxt = []
+    const len = row.length
+    for(let i = 0; i < len; i++) {
+      const cur = row[i]
+      sum += cur.val
+      if(cur.left) nxt.push(cur.left)
+      if(cur.right) nxt.push(cur.right)
+    }
+    
+    pq.push(sum)
+    if(pq.size() > k) pq.pop()
+    row = nxt
+  }
+  
+  return pq.size() < k ? -1 : pq.peek()
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 04247f78baddb335c21124bd498deec83bbba1b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Mar 2023 15:13:26 +0800
Subject: [PATCH 2548/3374] Create 2582-pass-the-pillow.js

---
 2582-pass-the-pillow.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 2582-pass-the-pillow.js

diff --git a/2582-pass-the-pillow.js b/2582-pass-the-pillow.js
new file mode 100644
index 00000000..52ad735c
--- /dev/null
+++ b/2582-pass-the-pillow.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @param {number} time
+ * @return {number}
+ */
+const passThePillow = function(n, time) {
+   const k = ~~(time / (n - 1))
+   const r = time % (n - 1)
+   
+   return k % 2 === 1 ? n - r : r + 1 
+};

From 44dde38acacc267c3e3729f92a194392d648eb8a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Mar 2023 15:17:55 +0800
Subject: [PATCH 2549/3374] Create
 2584-split-the-array-to-make-coprime-products.js

---
 ...plit-the-array-to-make-coprime-products.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2584-split-the-array-to-make-coprime-products.js

diff --git a/2584-split-the-array-to-make-coprime-products.js b/2584-split-the-array-to-make-coprime-products.js
new file mode 100644
index 00000000..da1f0171
--- /dev/null
+++ b/2584-split-the-array-to-make-coprime-products.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findValidSplit = function(nums) {
+  let n = nums.length, right = {};
+  for (let i = 0; i < n; i++) {
+    let primeFactorsCount = getPrimeFactors(nums[i]);
+    for (let prime in primeFactorsCount) {
+      let count = primeFactorsCount[prime];
+      right[prime] = (right[prime] || 0) + count;
+    }
+  }
+  let left = {}, common = new Set();
+  for (let i = 0; i <= n - 2; i++) {
+    let primesFactorsCount = getPrimeFactors(nums[i]);
+    for (let prime in primesFactorsCount) {
+      let count = primesFactorsCount[prime];
+      left[prime] = (left[prime] || 0) + count;
+      right[prime] -= count;
+      if (right[prime] > 0) common.add(prime);
+      else if (right[prime] === 0) common.delete(prime);
+    }
+    if (common.size === 0) return i;
+  }
+  return -1;
+};
+
+function getPrimeFactors(n) {
+  let counts = {};
+  for (let x = 2; (x * x) <= n; x++) {
+    while (n % x === 0) {
+      counts[x] = (counts[x] || 0) + 1;
+      n /= x;
+    }
+  }
+  if (n > 1) counts[n] = (counts[n] || 0) + 1;
+  return counts;
+}

From c0aad5e55591df96c4bd756751f25e1715332c0c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Mar 2023 20:30:54 +0800
Subject: [PATCH 2550/3374] Create
 2412-minimum-money-required-before-transactions.js

---
 2412-minimum-money-required-before-transactions.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2412-minimum-money-required-before-transactions.js

diff --git a/2412-minimum-money-required-before-transactions.js b/2412-minimum-money-required-before-transactions.js
new file mode 100644
index 00000000..42fcb831
--- /dev/null
+++ b/2412-minimum-money-required-before-transactions.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[][]} transactions
+ * @return {number}
+ */
+const minimumMoney = function(transactions) {
+  let res = 0;
+  let v = 0;
+  for (const a of transactions) {
+    v = Math.max(v, Math.min(a[0], a[1]));
+    res += Math.max(a[0] - a[1], 0);
+  }
+  return res + v;
+};

From f4ec60bd1a0bbf44b8f9e00890328ac4f1a39dfe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Mar 2023 21:14:51 +0800
Subject: [PATCH 2551/3374] Update 2444-count-subarrays-with-fixed-bounds.js

---
 2444-count-subarrays-with-fixed-bounds.js | 28 +++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2444-count-subarrays-with-fixed-bounds.js b/2444-count-subarrays-with-fixed-bounds.js
index e2d969e1..9ad838c7 100644
--- a/2444-count-subarrays-with-fixed-bounds.js
+++ b/2444-count-subarrays-with-fixed-bounds.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} minK
+ * @param {number} maxK
+ * @return {number}
+ */
+const countSubarrays = function(nums, minK, maxK) {
+  let res = 0, n = nums.length
+  let minIdx = -1, maxIdx = -1
+
+  for(let i = 0, j = 0; i < n; i++) {
+    if(nums[i] < minK || nums[i] > maxK) {
+      minIdx = -1
+      maxIdx = -1
+      j = i + 1
+    }
+    if(nums[i] === minK) minIdx = i
+    if(nums[i] === maxK) maxIdx = i
+    if(minIdx !== -1 && maxIdx !== -1) {
+      res += Math.min(minIdx, maxIdx) - j + 1
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} minK

From 798642b615122523e9cb207c4a95efea7a3c16b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Mar 2023 20:48:43 +0800
Subject: [PATCH 2552/3374] Create
 2457-minimum-addition-to-make-integer-beautiful.js

---
 ...imum-addition-to-make-integer-beautiful.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2457-minimum-addition-to-make-integer-beautiful.js

diff --git a/2457-minimum-addition-to-make-integer-beautiful.js b/2457-minimum-addition-to-make-integer-beautiful.js
new file mode 100644
index 00000000..d1d9189f
--- /dev/null
+++ b/2457-minimum-addition-to-make-integer-beautiful.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number} n
+ * @param {number} target
+ * @return {number}
+ */
+const makeIntegerBeautiful = function(n, target) {
+  let res = 0, carry = 0
+  const arr = []
+  while(n) {
+    if(digitSum(n) <= target) break
+    const remain = (n % 10)
+    if(remain === 0) {
+      arr.push(0)
+      carry = 0
+    } else {
+      arr.push(10 - remain)
+      carry = 1
+    }
+    
+    n = (Math.floor(n / 10)) + carry
+  }
+  if(arr.length === 0) return 0
+  arr.reverse()
+  return +arr.map(e => '' + e).join('')
+  
+  function digitSum(num) {
+    let res = 0
+    while(num > 0) {
+      res += (num % 10)
+      num = Math.floor(num/10)
+    }
+    return res
+  }
+};

From 1a4a4804a3d1c69bbcd47409634ad876b12f4a1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Mar 2023 15:06:39 +0800
Subject: [PATCH 2553/3374] Create 2551-put-marbles-in-bags.js

---
 2551-put-marbles-in-bags.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2551-put-marbles-in-bags.js

diff --git a/2551-put-marbles-in-bags.js b/2551-put-marbles-in-bags.js
new file mode 100644
index 00000000..860094d5
--- /dev/null
+++ b/2551-put-marbles-in-bags.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} weights
+ * @param {number} k
+ * @return {number}
+ */
+const putMarbles = function (weights, k) {
+  if (weights.length === k) return 0
+  let getEdgeWeights = weights.map((n, i, a) =>
+    i < a.length - 1 ? n + a[i + 1] : 0
+  )
+  getEdgeWeights = getEdgeWeights.slice(0, weights.length - 1)
+  getEdgeWeights = getEdgeWeights.sort((a, b) => a - b)
+  let maxScores = getEdgeWeights
+    .slice(getEdgeWeights.length - k + 1)
+    .reduce((a, b) => a + b, 0)
+  let minScores = getEdgeWeights.slice(0, k - 1).reduce((a, b) => a + b, 0)
+  return maxScores - minScores
+}

From f44bd618a1362deab434c2e565a8d2cc219e1c76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Mar 2023 20:00:18 +0800
Subject: [PATCH 2554/3374] Create 2561-rearranging-fruits.js

---
 2561-rearranging-fruits.js | 53 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 2561-rearranging-fruits.js

diff --git a/2561-rearranging-fruits.js b/2561-rearranging-fruits.js
new file mode 100644
index 00000000..1b630ba9
--- /dev/null
+++ b/2561-rearranging-fruits.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number[]} basket1
+ * @param {number[]} basket2
+ * @return {number}
+ */
+const minCost = function (basket1, basket2) {
+  const [map1, map2] = [new Map(), new Map()]
+  let minVal = Number.MAX_SAFE_INTEGER
+
+  for (const val of basket1) {
+    if (!map1.has(val)) map1.set(val, 0)
+    map1.set(val, map1.get(val) + 1)
+    minVal = Math.min(minVal, val)
+  }
+  for (const val of basket2) {
+    if (!map2.has(val)) map2.set(val, 0)
+    map2.set(val, map2.get(val) + 1)
+    minVal = Math.min(minVal, val)
+  }
+
+  const [swapList1, swapList2] = [[], []]
+  for (const [key, c1] of map1.entries()) {
+    const c2 = map2.get(key) || 0
+    if ((c1 + c2) % 2) return -1
+    if (c1 > c2) {
+      let addCnt = (c1 - c2) >> 1
+      while (addCnt--) {
+        swapList1.push(key)
+      }
+    }
+  }
+  for (const [key, c2] of map2.entries()) {
+    const c1 = map1.get(key) || 0
+    if ((c1 + c2) % 2) return -1
+    if (c2 > c1) {
+      let addCnt = (c2 - c1) >> 1
+      while (addCnt--) {
+        swapList2.push(key)
+      }
+    }
+  }
+
+  swapList1.sort((a, b) => a - b)
+  swapList2.sort((a, b) => b - a)
+  const n = swapList1.length
+
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    res += Math.min(2 * minVal, swapList1[i], swapList2[i])
+  }
+
+  return res
+}

From d9490e9554c32f7a7e63b4e2e8b616873b361809 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Mar 2023 19:09:47 +0800
Subject: [PATCH 2555/3374] Create
 2567-minimum-score-by-changing-two-elements.js

---
 2567-minimum-score-by-changing-two-elements.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 2567-minimum-score-by-changing-two-elements.js

diff --git a/2567-minimum-score-by-changing-two-elements.js b/2567-minimum-score-by-changing-two-elements.js
new file mode 100644
index 00000000..6a4b3abc
--- /dev/null
+++ b/2567-minimum-score-by-changing-two-elements.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimizeSum = function(nums) {
+  nums.sort((a, b) => a - b)
+  const { max, min, abs } = Math
+  const res1 = nums.at(-1) - nums[2]
+  const res2 = nums.at(-2) - nums[1]
+  const res3 = nums.at(-3) - nums[0]
+  return min(res1, res2, res3)
+};

From 5e90694cd3331448cf830494cc825e1b01770681 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Mar 2023 19:31:05 +0800
Subject: [PATCH 2556/3374] Update
 2567-minimum-score-by-changing-two-elements.js

---
 ...-minimum-score-by-changing-two-elements.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/2567-minimum-score-by-changing-two-elements.js b/2567-minimum-score-by-changing-two-elements.js
index 6a4b3abc..cf2a5321 100644
--- a/2567-minimum-score-by-changing-two-elements.js
+++ b/2567-minimum-score-by-changing-two-elements.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimizeSum = function(nums) {
+  let s1 = Infinity, s2 = Infinity, s3 = Infinity
+  let l1 = -1, l2 = -1, l3 = -1
+  const { max, min } = Math
+  // s1, s2, s3, ..., l3, l2, l1
+  for(const e of nums) {
+    if(s1 > e) {
+      s3 = s2;
+      s2 = s1;
+      s1 = e;
+    } else if(s2 > e) {
+      s3 = s2
+      s2 = e
+    } else if(s3 > e) {
+      s3 = e
+    }
+    
+    if(e > l1) {
+      l3 = l2
+      l2 = l1
+      l1 = e
+    } else if(e > l2) {
+      l3 = l2
+      l2 = e
+    } else if(e > l3) {
+      l3 = e
+    }
+  }
+  
+  return min(l1 - s3,  l2 - s2, l3 - s1)
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From d108548242f4cda4c498abbd362e500e964f0908 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Mar 2023 19:41:00 +0800
Subject: [PATCH 2557/3374] Create 2568-minimum-impossible-or.js

---
 2568-minimum-impossible-or.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 2568-minimum-impossible-or.js

diff --git a/2568-minimum-impossible-or.js b/2568-minimum-impossible-or.js
new file mode 100644
index 00000000..a5609aab
--- /dev/null
+++ b/2568-minimum-impossible-or.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minImpossibleOR = function(nums) {
+  const s = new Set();
+  for (const e of nums) s.add(e);
+  let res = 1;
+  while (s.has(res)) res <<= 1;
+  return res;
+};

From be5dd9294dbbc5783780a9cb442ca1fd95c2e040 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Mar 2023 20:49:12 +0800
Subject: [PATCH 2558/3374] Update
 2571-minimum-operations-to-reduce-an-integer-to-0.js

---
 ...um-operations-to-reduce-an-integer-to-0.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2571-minimum-operations-to-reduce-an-integer-to-0.js b/2571-minimum-operations-to-reduce-an-integer-to-0.js
index a395370c..70758216 100644
--- a/2571-minimum-operations-to-reduce-an-integer-to-0.js
+++ b/2571-minimum-operations-to-reduce-an-integer-to-0.js
@@ -1,3 +1,35 @@
+function dec2bin(dec) {
+  return (dec >>> 0).toString(2);
+}
+function bitCnt(s) {
+  let res = 0
+  for(const e of s) {
+    if(e === '1') res++
+  }
+  return res
+}
+function cnt(num) {
+  return bitCnt(dec2bin(num))
+}
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const minOperations = function(n) {
+  let res = 0
+  for(let i = 0; i < 14; i++) {
+    if(cnt(n + (1 << i)) < cnt(n)) {
+      res++
+      n += (1 << i)
+    }
+  }
+  
+  return res + cnt(n)
+};
+
+// another
+
+
 function dec2bin(dec) {
   return (dec >>> 0).toString(2);
 }

From 5b202316af16080603ea09f7e89788bcb9b79593 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 18 Mar 2023 18:59:46 +0800
Subject: [PATCH 2559/3374] Create 2573-find-the-string-with-lcp.js

---
 2573-find-the-string-with-lcp.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2573-find-the-string-with-lcp.js

diff --git a/2573-find-the-string-with-lcp.js b/2573-find-the-string-with-lcp.js
new file mode 100644
index 00000000..83ab6c20
--- /dev/null
+++ b/2573-find-the-string-with-lcp.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[][]} lcp
+ * @return {string}
+ */
+const findTheString = function (lcp) {
+  const n = lcp.length
+  let c = 0
+  const arr = new Array(n).fill(0)
+  for (let i = 0; i < n; ++i) {
+    if (arr[i] > 0) continue
+    if (++c > 26) return ''
+    for (let j = i; j < n; ++j) {
+      if (lcp[i][j] > 0) arr[j] = c
+    }
+  }
+  for (let i = 0; i < n; ++i) {
+    for (let j = 0; j < n; ++j) {
+      let v = i + 1 < n && j + 1 < n ? lcp[i + 1][j + 1] : 0
+      v = arr[i] === arr[j] ? v + 1 : 0
+      if (lcp[i][j] != v) return ''
+    }
+  }
+  const res = []
+  const ac = 'a'.charCodeAt(0)
+  for (let a of arr) res.push(String.fromCharCode(ac + a - 1))
+  return res.join('')
+}

From 120dc0a5abd751da622192471cf006d2b5969423 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Mar 2023 21:54:50 +0800
Subject: [PATCH 2560/3374] Update
 2576-find-the-maximum-number-of-marked-indices.js

---
 ...nd-the-maximum-number-of-marked-indices.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/2576-find-the-maximum-number-of-marked-indices.js b/2576-find-the-maximum-number-of-marked-indices.js
index f8520d12..de2fe1c7 100644
--- a/2576-find-the-maximum-number-of-marked-indices.js
+++ b/2576-find-the-maximum-number-of-marked-indices.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxNumOfMarkedIndices = function(nums) {
+  let res = 0
+  const n =  nums.length
+  nums.sort((a, b) => a - b)
+  for(let i = 0, j = n - Math.floor(n / 2); j < n; j++) {
+    if(nums[i] * 2 <= nums[j]) {
+      res += 2
+      i++
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 093323a64e9a98f775494a21bf2896291895ecc4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Mar 2023 19:05:21 +0800
Subject: [PATCH 2561/3374] Update 307-range-sum-query-mutable.js

---
 307-range-sum-query-mutable.js | 65 ++++++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/307-range-sum-query-mutable.js b/307-range-sum-query-mutable.js
index 8c64848f..faff27c5 100644
--- a/307-range-sum-query-mutable.js
+++ b/307-range-sum-query-mutable.js
@@ -1,3 +1,68 @@
+const lowBit = (x) => x & -x
+class FenwickTree {
+  constructor(n) {
+    if (n < 1) return
+    this.sum = Array(n + 1).fill(0)
+  }
+  update(i, delta) {
+    if (i < 1) return
+    while (i < this.sum.length) {
+      this.sum[i] += delta
+      i += lowBit(i)
+    }
+  }
+  query(i) {
+    if (i < 1) return 0
+    let sum = 0
+    while (i > 0) {
+      sum += this.sum[i]
+      i -= lowBit(i)
+    }
+    return sum
+  }
+}
+
+/**
+ * @param {number[]} nums
+ */
+var NumArray = function(nums) {
+  this.nums = nums
+  const n = nums.length
+  this.bit = new FenwickTree(n)
+  for(let i = 1; i <= n; i++) {
+    this.bit.update(i, nums[i - 1])
+  }
+};
+
+/** 
+ * @param {number} index 
+ * @param {number} val
+ * @return {void}
+ */
+NumArray.prototype.update = function(index, val) {
+    const delta = val - this.nums[index]
+    this.nums[index] = val
+    this.bit.update(index + 1, delta)
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right
+ * @return {number}
+ */
+NumArray.prototype.sumRange = function(left, right) {
+    return this.bit.query(right + 1) - this.bit.query(left)
+};
+
+/** 
+ * Your NumArray object will be instantiated and called as such:
+ * var obj = new NumArray(nums)
+ * obj.update(index,val)
+ * var param_2 = obj.sumRange(left,right)
+ */
+
+// another
+
 /**
  * @param {number[]} nums
  */

From aea984e125f0b5138514d1065448d392325a1e71 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Mar 2023 09:43:28 +0800
Subject: [PATCH 2562/3374] Update
 1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js

---
 ...ements-on-subarrays-to-form-a-target-array.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js b/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js
index 10d9f567..8464391c 100644
--- a/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js
+++ b/1526-minimum-number-of-increments-on-subarrays-to-form-a-target-array.js
@@ -1,3 +1,19 @@
+/**
+ * @param {number[]} target
+ * @return {number}
+ */
+const minNumberOperations = function(target) {
+  let res = target[0]
+  
+  for(let i = 1; i < target.length; i++) {
+    res += Math.max(0, target[i] - target[i - 1])
+  }
+  
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} target
  * @return {number}

From 130ee4ce3268441b1cbb85982495c6a0b9c0f385 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Mar 2023 21:01:55 +0800
Subject: [PATCH 2563/3374] Update 1157-online-majority-element-in-subarray.js

---
 1157-online-majority-element-in-subarray.js | 138 ++++++++++++++++++++
 1 file changed, 138 insertions(+)

diff --git a/1157-online-majority-element-in-subarray.js b/1157-online-majority-element-in-subarray.js
index 72a30cfb..54f72984 100644
--- a/1157-online-majority-element-in-subarray.js
+++ b/1157-online-majority-element-in-subarray.js
@@ -1,3 +1,141 @@
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = (lo + hi) >> 1
+      x < a[mid] ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = (lo + hi) >> 1
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+
+function SegmentTreeRQ(m, A, n) {
+  let bisect = new Bisect()
+  let h = Math.ceil(Math.log2(n))
+  const MAX = 2 * 2 ** h - 1
+  let tree = Array(MAX).fill(-1)
+  let a = [...A]
+  build(1, 0, n - 1)
+  return {
+    query,
+  }
+
+  function build(vi, tl, tr) {
+    if (tl == tr) {
+      tree[vi] = a[tl]
+      return
+    }
+    let mid = getMid(tl, tr)
+    build(vi * 2, tl, mid)
+    build(vi * 2 + 1, mid + 1, tr)
+    if (
+      tree[vi * 2] != -1 &&
+      get_occurrence(tree[vi * 2], tl, tr) * 2 > tr - tl + 1
+    ) {
+      tree[vi] = tree[vi * 2]
+    } else if (
+      tree[vi * 2 + 1] != -1 &&
+      get_occurrence(tree[vi * 2 + 1], tl, tr) * 2 > tr - tl + 1
+    ) {
+      tree[vi] = tree[vi * 2 + 1]
+    }
+  }
+
+  function query(vi, l, r, tl, tr) {
+    if (l > tr || r < tl) {
+      return {
+        first: -1,
+        second: -1,
+      }
+    }
+    if (tl <= l && r <= tr) {
+      if (tree[vi] == -1)
+        return {
+          first: -1,
+          second: -1,
+        }
+      let occ = get_occurrence(tree[vi], tl, tr)
+      if (occ * 2 > tr - tl + 1) {
+        return {
+          first: tree[vi],
+          second: occ,
+        }
+      } else {
+        return {
+          first: -1,
+          second: -1,
+        }
+      }
+    }
+    let mid = getMid(l, r)
+    let resL = query(vi * 2, l, mid, tl, tr)
+    if (resL.first > -1) return resL
+    let resR = query(vi * 2 + 1, mid + 1, r, tl, tr)
+    if (resR.first > -1) return resR
+    return {
+      first: -1,
+      second: -1,
+    }
+  }
+
+  function get_occurrence(num, l, r) {
+    // only difference
+    if (!m.has(num)) return 0
+    let a = m.get(num)
+    let lbv = bisect.bisect_left(a, l) //lower_bound
+    if (lbv == a.length) return 0
+    let ubv = bisect.bisect_right(a, r) // upper_bound
+    return ubv - lbv
+  }
+
+  function getMid(low, high) {
+    return low + ((high - low) >> 1)
+  }
+}
+
+function MajorityChecker(a) {
+  let m = new Map()
+  let n = a.length
+  for (let i = 0; i < n; i++) {
+    if (!m.has(a[i])) m.set(a[i], [])
+    m.get(a[i]).push(i)
+  }
+  let st = new SegmentTreeRQ(m, a, n)
+  return {
+    query,
+  }
+
+  function query(left, right, threshold) {
+    let res = st.query(1, 0, n - 1, left, right)
+    if (res.second >= threshold) {
+      return res.first
+    }
+    return -1
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} arr
  */

From 2baf0887ce7baaf845766f2e52053d734adf475b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Mar 2023 10:00:44 +0800
Subject: [PATCH 2564/3374] Update 2-add-two-numbers.js

---
 2-add-two-numbers.js | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2-add-two-numbers.js b/2-add-two-numbers.js
index eeaa3925..06f99a30 100755
--- a/2-add-two-numbers.js
+++ b/2-add-two-numbers.js
@@ -117,4 +117,45 @@ const addTwoNumbers = function(l1, l2) {
   return dummy.next
 };
 
+// another
+
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} l1
+ * @param {ListNode} l2
+ * @return {ListNode}
+ */
+const addTwoNumbers = function(l1, l2) {
+  const dummy = new ListNode(null)
+  let cur = dummy, carry = 0
+  
+  while(l1 || l2) {
+    let v = 0
+    if(l1 && l2) {
+      v = l1.val + l2.val + carry
+      l1 = l1.next
+      l2 = l2.next
+    } else {
+      const node = l1 || l2
+      v = node.val + carry
+      if(l1) l1 = l1.next
+      if(l2) l2 = l2.next
+    }
+    
+    cur.next = new ListNode(v % 10)
+    cur = cur.next
+    if(v >= 10) carry = 1
+    else carry = 0
+  }
+  
+  if(carry) cur.next = new ListNode(1)
+  
+  return dummy.next
+};
 

From b875116529435b9f1ecfc542adf818d3ec124510 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Mar 2023 15:25:10 +0800
Subject: [PATCH 2565/3374] Update 691-stickers-to-spell-word.js

---
 691-stickers-to-spell-word.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/691-stickers-to-spell-word.js b/691-stickers-to-spell-word.js
index ac5b4f16..8c0574c5 100644
--- a/691-stickers-to-spell-word.js
+++ b/691-stickers-to-spell-word.js
@@ -1,3 +1,37 @@
+/**
+ * @param {string[]} stickers
+ * @param {string} target
+ * @return {number}
+ */
+const minStickers = function (stickers, target) {
+  const n = stickers.length
+  const m = target.length
+  const limit = 1 << m
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  for (let i = 0; i < limit; i++) {
+    if (dp[i] === Infinity) continue
+    for (const sticker of stickers) {
+      let stat = i
+      for (const ch of sticker) {
+        for (let j = 0; j < m; j++) {
+          if (target[j] === ch && ((stat >> j) & 1) === 0) {
+            stat |= (1 << j)
+            break
+          }
+        }
+      }
+      dp[stat] = Math.min(dp[stat], dp[i] + 1)
+    }
+  }
+
+  return dp[limit - 1] === Infinity ? -1 : dp[limit - 1]
+}
+
+
+// another
+
+
 /**
  * @param {string[]} stickers
  * @param {string} target

From 621ac9fa08232d76ac3e205fca4d98249e1d8e1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Mar 2023 10:44:01 +0800
Subject: [PATCH 2566/3374] Update 1125-smallest-sufficient-team.js

---
 1125-smallest-sufficient-team.js | 42 ++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/1125-smallest-sufficient-team.js b/1125-smallest-sufficient-team.js
index 561385d6..4b890c98 100644
--- a/1125-smallest-sufficient-team.js
+++ b/1125-smallest-sufficient-team.js
@@ -1,3 +1,45 @@
+/**
+ * @param {string[]} req_skills
+ * @param {string[][]} people
+ * @return {number[]}
+ */
+const smallestSufficientTeam = function (req_skills, people) {
+  const m = req_skills.length,
+    n = people.length,
+    limit = 1 << m
+  const skillIdxMap = {}
+  for(let i = 0; i < m; i++) {
+    skillIdxMap[req_skills[i]] = i
+  }
+  const dp = Array(limit)
+
+  dp[0] = []
+  
+  for(let i = 0; i < n; i++) {
+    let skillMask = 0
+    for(let j = 0; j < people[i].length; j++) {
+      skillMask |= (1 << skillIdxMap[people[i][j]])
+    }
+
+    for(let j = 0; j < dp.length; j++) {
+      if(dp[j] == null) continue
+      const prev = j
+      const comb = prev | skillMask
+
+      if(dp[comb] == null || dp[comb].length > dp[prev].length + 1) {
+
+        dp[comb] = dp[prev].slice()
+        dp[comb].push(i)
+      }
+    }
+  }
+
+  return dp[limit - 1]
+}
+
+// another
+
+
 /**
  * @param {string[]} req_skills
  * @param {string[][]} people

From 74d435044da92e994d571c2ba38247103aea93ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Apr 2023 21:07:32 +0800
Subject: [PATCH 2567/3374] Update 1349-maximum-students-taking-exam.js

---
 1349-maximum-students-taking-exam.js | 56 ++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/1349-maximum-students-taking-exam.js b/1349-maximum-students-taking-exam.js
index 03153525..0a45d165 100644
--- a/1349-maximum-students-taking-exam.js
+++ b/1349-maximum-students-taking-exam.js
@@ -1,3 +1,59 @@
+/**
+ * @param {character[][]} seats
+ * @return {number}
+ */
+const maxStudents = function(seats) {
+  const m = seats.length, n = seats[0].length, limit = 1 << n
+  const dp = Array.from({ length: m + 1}, () => Array(limit).fill(0))
+  
+  let res = 0
+  for(let i = 1; i <= m; i++) {
+    for(let mask = 0; mask < limit; mask++) {
+      let valid = true
+      for(let j = 0; j < n; j++) {
+        if(seats[i - 1][j] === '#' && ((mask >> j) & 1) ) {
+          valid = false
+          break
+        }
+        if(j < n - 1 && ((mask >> j) & 1) && ((mask >> (j + 1)) & 1) ) {
+          valid = false
+          break
+        }
+      }
+      
+      if(!valid) {
+        dp[i][mask] = -1
+        continue
+      }
+      
+      for(let pre = 0; pre < limit; pre++) {
+        if(dp[i - 1][pre] === -1) continue
+        if( (pre & (mask >> 1)) !== 0 || (pre & (mask << 1)) !== 0 ) continue
+        dp[i][mask] = Math.max(dp[i][mask], dp[i - 1][pre])
+      }
+      
+      dp[i][mask] += bitCnt(mask)
+      
+      res = Math.max(res, dp[i][mask])
+    }
+  }
+  
+  return res
+  
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      if(num & 1) res++
+      num = num >> 1
+    }
+    
+    return res
+  }
+};
+
+// another
+
+
 /**
  * @param {character[][]} seats
  * @return {number}

From c49aa74d0d85fcb8c9dda0fc5eef0e7da89c2a9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 15:07:00 +0800
Subject: [PATCH 2568/3374] Create
 2609-find-the-longest-balanced-substring-of-a-binary-string.js

---
 ...t-balanced-substring-of-a-binary-string.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2609-find-the-longest-balanced-substring-of-a-binary-string.js

diff --git a/2609-find-the-longest-balanced-substring-of-a-binary-string.js b/2609-find-the-longest-balanced-substring-of-a-binary-string.js
new file mode 100644
index 00000000..1f3ad65e
--- /dev/null
+++ b/2609-find-the-longest-balanced-substring-of-a-binary-string.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestBalancedSubstring = function(s) {
+   let res = 0
+   
+   const n = s.length
+   for(let i = 0; i < n - 1; i++) {
+     for(let j = i + 1; j < n; j++) {
+       const str = s.slice(i, j + 1)
+       if(valid(str)) {
+         res = Math.max(res, str.length)
+       }
+     }
+   }
+   
+   return res
+  
+  function valid(str) {
+    let res = true
+    const len = str.length
+    if(len % 2 === 1) return false
+    const lastZeroIdx = str.lastIndexOf('0')
+    const firstOneIdx = str.indexOf('1')
+    
+    return firstOneIdx - lastZeroIdx === 1 && len / 2 === firstOneIdx
+  }
+};

From b64ad8bcd8b48dade8765266f079efa38a1657ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 15:14:40 +0800
Subject: [PATCH 2569/3374] Update 1411-number-of-ways-to-paint-n-3-grid.js

---
 1411-number-of-ways-to-paint-n-3-grid.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/1411-number-of-ways-to-paint-n-3-grid.js b/1411-number-of-ways-to-paint-n-3-grid.js
index c644c37b..199a4a5b 100644
--- a/1411-number-of-ways-to-paint-n-3-grid.js
+++ b/1411-number-of-ways-to-paint-n-3-grid.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const numOfWays = function(n) {
+  const mod = 1e9 + 7
+  let colors3 = 6, colors2 = 6
+  
+  for(let i = 1; i < n; i++) {
+    const colors3Tmp = colors3
+    colors3 = (2 * colors3 + 2 * colors2) % mod
+    colors2 = (2 * colors3Tmp + 3 * colors2) % mod
+  }
+  
+  
+  return (colors2 + colors3) % mod
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From 0cc1ab703cfd65764f6524dd0e6d39d9b7bac9b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 20:07:27 +0800
Subject: [PATCH 2570/3374] Create
 2610-convert-an-array-into-a-2d-array-with-conditions.js

---
 ...n-array-into-a-2d-array-with-conditions.js | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 2610-convert-an-array-into-a-2d-array-with-conditions.js

diff --git a/2610-convert-an-array-into-a-2d-array-with-conditions.js b/2610-convert-an-array-into-a-2d-array-with-conditions.js
new file mode 100644
index 00000000..9ab60648
--- /dev/null
+++ b/2610-convert-an-array-into-a-2d-array-with-conditions.js
@@ -0,0 +1,114 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const findMatrix = function(nums) {
+  const p1 = new PQ((a, b) => a.cnt > b.cnt)
+  const p2 = new PQ((a, b) => a.cnt > b.cnt)
+  
+  const hash = new Map()
+  for(const e of nums) {
+    if(!hash.has(e)) hash.set(e, 0)
+    hash.set(e, hash.get(e) + 1)
+  }
+  
+  for(const [k, v] of hash) {
+    p1.push({val: k, cnt: v})
+  }
+  
+  
+  const res = []
+  while(p1.size() || p2.size()) {
+    const tmp = []
+    
+    if(p1.size()) {
+      while(p1.size()) {
+        const e = p1.pop()
+        let {val, cnt} = e
+        tmp.push(val)
+        if(--cnt > 0) p2.push({val, cnt})        
+      }
+
+    } else {
+      while(p2.size()) {
+        const e = p2.pop()
+        let {val, cnt} = e
+        tmp.push(val)
+        if(--cnt > 0) p1.push({val, cnt})        
+      }
+
+    }
+    
+    res.push(tmp)
+  }
+  
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 1fa73a65d1e635e63898429082d5e9da354867c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 20:15:05 +0800
Subject: [PATCH 2571/3374] Update
 2610-convert-an-array-into-a-2d-array-with-conditions.js

---
 ...n-array-into-a-2d-array-with-conditions.js | 102 ++----------------
 1 file changed, 9 insertions(+), 93 deletions(-)

diff --git a/2610-convert-an-array-into-a-2d-array-with-conditions.js b/2610-convert-an-array-into-a-2d-array-with-conditions.js
index 9ab60648..040edf6c 100644
--- a/2610-convert-an-array-into-a-2d-array-with-conditions.js
+++ b/2610-convert-an-array-into-a-2d-array-with-conditions.js
@@ -3,112 +3,28 @@
  * @return {number[][]}
  */
 const findMatrix = function(nums) {
-  const p1 = new PQ((a, b) => a.cnt > b.cnt)
-  const p2 = new PQ((a, b) => a.cnt > b.cnt)
-  
+
   const hash = new Map()
   for(const e of nums) {
     if(!hash.has(e)) hash.set(e, 0)
     hash.set(e, hash.get(e) + 1)
   }
   
+  const arr = []
   for(const [k, v] of hash) {
-    p1.push({val: k, cnt: v})
+    arr.push([v, k])
   }
   
+  arr.sort((a, b) => b[0] - a[0])
   
   const res = []
-  while(p1.size() || p2.size()) {
-    const tmp = []
-    
-    if(p1.size()) {
-      while(p1.size()) {
-        const e = p1.pop()
-        let {val, cnt} = e
-        tmp.push(val)
-        if(--cnt > 0) p2.push({val, cnt})        
-      }
-
-    } else {
-      while(p2.size()) {
-        const e = p2.pop()
-        let {val, cnt} = e
-        tmp.push(val)
-        if(--cnt > 0) p1.push({val, cnt})        
-      }
-
+  for(let i = 0, len = arr.length; i < len; i++) {
+    const [freq, val] = arr[i]
+    for(let j = 0; j < freq; j++) {
+      if(res[j] == null) res[j] = []
+      res[j].push(val)
     }
-    
-    res.push(tmp)
   }
   
   return res
 };
-
-class PQ {
-  constructor(comparator = (a, b) => a > b) {
-    this.heap = []
-    this.top = 0
-    this.comparator = comparator
-  }
-  size() {
-    return this.heap.length
-  }
-  isEmpty() {
-    return this.size() === 0
-  }
-  peek() {
-    return this.heap[this.top]
-  }
-  push(...values) {
-    values.forEach((value) => {
-      this.heap.push(value)
-      this.siftUp()
-    })
-    return this.size()
-  }
-  pop() {
-    const poppedValue = this.peek()
-    const bottom = this.size() - 1
-    if (bottom > this.top) {
-      this.swap(this.top, bottom)
-    }
-    this.heap.pop()
-    this.siftDown()
-    return poppedValue
-  }
-  replace(value) {
-    const replacedValue = this.peek()
-    this.heap[this.top] = value
-    this.siftDown()
-    return replacedValue
-  }
-
-  parent = (i) => ((i + 1) >>> 1) - 1
-  left = (i) => (i << 1) + 1
-  right = (i) => (i + 1) << 1
-  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
-  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
-  siftUp = () => {
-    let node = this.size() - 1
-    while (node > this.top && this.greater(node, this.parent(node))) {
-      this.swap(node, this.parent(node))
-      node = this.parent(node)
-    }
-  }
-  siftDown = () => {
-    let node = this.top
-    while (
-      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
-      (this.right(node) < this.size() && this.greater(this.right(node), node))
-    ) {
-      let maxChild =
-        this.right(node) < this.size() &&
-        this.greater(this.right(node), this.left(node))
-          ? this.right(node)
-          : this.left(node)
-      this.swap(node, maxChild)
-      node = maxChild
-    }
-  }
-}

From a2be85f8aeffb79bf0872791c1cb1c7f0be27386 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 20:35:40 +0800
Subject: [PATCH 2572/3374] Create 2611-mice-and-cheese.js

---
 2611-mice-and-cheese.js | 100 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 100 insertions(+)
 create mode 100644 2611-mice-and-cheese.js

diff --git a/2611-mice-and-cheese.js b/2611-mice-and-cheese.js
new file mode 100644
index 00000000..f8ddd497
--- /dev/null
+++ b/2611-mice-and-cheese.js
@@ -0,0 +1,100 @@
+/**
+ * @param {number[]} reward1
+ * @param {number[]} reward2
+ * @param {number} k
+ * @return {number}
+ */
+const miceAndCheese = function(reward1, reward2, k) {
+  const pq = new PQ((a, b) => a[2] > b[2])
+  
+  const n = reward1.length
+  
+  for(let i = 0; i < n; i++) {
+    const tmp = [reward1[i], reward2[i], reward1[i] - reward2[i]]
+    pq.push(tmp)
+  }
+  
+  let res = 0
+  while(k) {
+    const [v1, v2, delta] = pq.pop()
+    res += v1
+    
+    k--
+  }
+  
+  while(!pq.isEmpty()) {
+    const [v1, v2] = pq.pop()
+    res += v2
+  }
+  
+  
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 5160bb70684c1142cdc031b24f4e7a3b2a6a8d8c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 21:04:28 +0800
Subject: [PATCH 2573/3374] Update 496-next-greater-element-I.js

---
 496-next-greater-element-I.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/496-next-greater-element-I.js b/496-next-greater-element-I.js
index 663ef13e..e3b281bb 100755
--- a/496-next-greater-element-I.js
+++ b/496-next-greater-element-I.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number[]}
+ */
+const nextGreaterElement = function(nums1, nums2) {
+  const map = new Map()
+  const stk = []
+  
+  for(let i = 0, n = nums2.length; i < n; i++) {
+    const e = nums2[i]
+    while(stk.length && stk.at(-1) < e) {
+      const tmp = stk.pop()
+      map.set(tmp, e)
+    }
+    stk.push(e)
+  }
+  
+  const res = []
+  for(const e of nums1) {
+    if(map.has(e)) {
+      res.push(map.get(e))
+    } else {
+      res.push(-1)
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} findNums
  * @param {number[]} nums

From 296904d087e85612c1ec9e464e680a1bd9833f5f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Apr 2023 21:30:46 +0800
Subject: [PATCH 2574/3374] Update 503-next-greater-element-II.js

---
 503-next-greater-element-II.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/503-next-greater-element-II.js b/503-next-greater-element-II.js
index fc284214..37a4898e 100755
--- a/503-next-greater-element-II.js
+++ b/503-next-greater-element-II.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const nextGreaterElements = function(nums) {
+  const arr = []
+  const n = nums.length
+  const res = Array(n).fill(-1)
+  nums.push(...nums)
+  const stk = []
+  for(let i = 0; i < 2 * n; i++) {
+    const e = nums[i]
+    while(stk.length && nums[stk.at(-1)] < e) {
+      const idx = stk.pop()
+      res[idx] = e
+    }
+    if(i < n) stk.push(i)
+  }
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number[]}

From b0e6b74f7c658bd3de34c7a77182662972cd2e02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Apr 2023 10:00:07 +0800
Subject: [PATCH 2575/3374] Update 15-3sum.js

---
 15-3sum.js | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/15-3sum.js b/15-3sum.js
index c6f4a983..498fc859 100755
--- a/15-3sum.js
+++ b/15-3sum.js
@@ -1,3 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const threeSum = function(nums) {
+  const res = [], n = nums.length
+  nums.sort((a, b) => a - b)
+  
+  for(let i = 0; i < n; i++) {
+    const target = -nums[i]
+    let l = i + 1, r = n - 1
+    while(l < r) {
+      const sum = nums[l] + nums[r]
+      if(sum > target) r--
+      else if(sum < target) l++
+      else {
+        const e = [nums[i], nums[l], nums[r]]
+        res.push(e)
+        while(l + 1 < r && nums[l + 1] === nums[l]) l++
+        while(r - 1 > l && nums[r - 1] === nums[r]) r--
+        l++
+        r--
+      }
+    }
+    while(i + 1 < n && nums[i] === nums[i + 1]) i++
+  }
+  
+  
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number[][]}

From 4fedf133b1f1a240c67262c33995bfdee0c4f1c8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Apr 2023 14:17:45 +0800
Subject: [PATCH 2576/3374] Update
 1434-number-of-ways-to-wear-different-hats-to-each-other.js

---
 ...ys-to-wear-different-hats-to-each-other.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1434-number-of-ways-to-wear-different-hats-to-each-other.js b/1434-number-of-ways-to-wear-different-hats-to-each-other.js
index 6704ff78..4656736b 100644
--- a/1434-number-of-ways-to-wear-different-hats-to-each-other.js
+++ b/1434-number-of-ways-to-wear-different-hats-to-each-other.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[][]} hats
+ * @return {number}
+ */
+const numberWays = function(hats) {
+  const map = new Map()
+  const n = hats.length
+  for(let i = 0; i < n; i++) {
+    for(const h of hats[i]) {
+      if(!map.has(h)) map.set(h, [])
+      map.get(h).push(i)
+    }
+  }
+  const mod = 1e9 + 7
+  const allMask = (1 << n) - 1
+  const dp = Array.from({ length: 41 }, () => Array(1024))
+  
+  return dfs(1, 0)
+  
+  function dfs(hat, mask) {
+    if(mask === allMask) return 1
+    if(hat > 40) return 0
+    if(dp[hat][mask] != null) return dp[hat][mask]
+    
+    let res = 0
+    
+    // not using this `hat`
+    res += dfs(hat + 1, mask)
+    for(const p of (map.get(hat) || [])) {
+      if(((mask >> p) & 1) === 0) {
+        res += dfs(hat + 1, mask | (1 << p))
+        res = res % mod
+      }
+    }
+    dp[hat][mask] = res
+    return res
+  }
+  
+};
+
+// another
+
+
 /**
  * @param {number[][]} hats
  * @return {number}

From fd314ca2b6ff20cb7d46e27ab9398870add26e26 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Apr 2023 15:02:50 +0800
Subject: [PATCH 2577/3374] Update 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 50 +++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
index ece2391f..679d1fc2 100644
--- a/1655-distribute-repeating-integers.js
+++ b/1655-distribute-repeating-integers.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} quantity
+ * @return {boolean}
+ */
+const canDistribute = function(nums, quantity) {
+  const freq = new Map()
+  for(const e of nums) {
+    freq.set(e, (freq.get(e) || 0) + 1)
+  }
+  const cntArr = [...freq.values()]
+  const dp = Array.from({ length: 51 }, () => Array(1024).fill(false))
+  const n = cntArr.length, m = quantity.length
+  for(let i = 0; i < n; i++) {
+    dp[i][0] = true
+  }
+  cntArr.unshift(0)
+  const allMask = (1 << m) - 1
+  
+  for(let i = 1; i <= n; i++) {
+    for(let mask = 1; mask <= allMask; mask++) {
+      if(dp[i - 1][mask]) {
+        dp[i][mask] = true
+        continue
+      }
+      for(let subset = mask; subset > 0; subset = (subset - 1) & mask) {
+        if(dp[i - 1][mask - subset] === false) continue
+        if(canSatisfySubset(cntArr[i], subset)) {
+          dp[i][mask] = true
+          break
+        }
+      }
+    }
+  }
+  
+  return dp[n][allMask]
+  
+  function canSatisfySubset(cnt, subset) {
+    let sum = 0
+    for (let i = 0; i < 10; i++) {
+      if(subset & (1 << i)) {
+        sum += quantity[i]
+      }
+    }
+    return cnt >= sum
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[]} quantity

From 89ea11344b6ab6baafde8f975abf673ad40e065d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Apr 2023 20:47:14 +0800
Subject: [PATCH 2578/3374] Update 1681-minimum-incompatibility.js

---
 1681-minimum-incompatibility.js | 46 +++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/1681-minimum-incompatibility.js b/1681-minimum-incompatibility.js
index eb5a21a8..255ef859 100644
--- a/1681-minimum-incompatibility.js
+++ b/1681-minimum-incompatibility.js
@@ -1,3 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minimumIncompatibility = function(nums, k) {
+  const n = nums.length
+  const size = n / k
+  const mod = 1e9 + 7
+  if(size === 1) return 0
+  const limit = 1 << n
+  const dp = Array.from({ length: limit }, () => Array(16).fill(Infinity))
+  for(let i = 0; i < n; i++) dp[1 << i][i] = 0
+  
+  for(let mask = 0; mask < limit; mask++) {
+    for(let i = 0; i < n; i++) {
+      if((mask & (1 << i)) === 0) continue
+      for(let j = 0; j < n; j++) {
+        if((mask & (1 << j))) continue
+        const newMask = mask | (1 << j)
+        if(bitCnt(mask) % size === 0) {
+          dp[newMask][j] = Math.min(dp[newMask][j], dp[mask][i])
+        } else if(nums[j] > nums[i]) {
+          dp[newMask][j] = Math.min(dp[newMask][j], dp[mask][i] + nums[j] - nums[i])
+        }
+      }
+    }
+  }
+
+  const candidate = Math.min(...dp.at(-1))
+  
+  return candidate === Infinity ? -1 : candidate
+    
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      if(num & 1) res++
+      num = num >> 1
+    }
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 406a75452ea5670e6fc28260f18ea83b2c487f68 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Apr 2023 20:39:42 +0800
Subject: [PATCH 2579/3374] Update 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
index 40f5824e..4dd000c4 100644
--- a/1723-find-minimum-time-to-finish-all-jobs.js
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -17,12 +17,9 @@ const minimumTimeRequired = function(jobs, k) {
       res = Math.min(res, Math.max(...workers))
       return
     }
-    const visited = new Set()
     const e = jobs[idx]
     for(let i = 0; i < k; i++) {
-      if(visited.has(workers[i])) continue
       if(workers[i] + e >= res) continue
-      visited.add(workers[i])
       workers[i] += e
       dfs(idx + 1)
       workers[i] -= e

From fde3f164ee74805dbc089c89031c96d703991f92 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Apr 2023 22:19:46 +0800
Subject: [PATCH 2580/3374] Update 1723-find-minimum-time-to-finish-all-jobs.js

---
 1723-find-minimum-time-to-finish-all-jobs.js | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/1723-find-minimum-time-to-finish-all-jobs.js b/1723-find-minimum-time-to-finish-all-jobs.js
index 4dd000c4..94a8c01b 100644
--- a/1723-find-minimum-time-to-finish-all-jobs.js
+++ b/1723-find-minimum-time-to-finish-all-jobs.js
@@ -1,3 +1,37 @@
+/**
+ * @param {number[]} jobs
+ * @param {number} k
+ * @return {number}
+ */
+const minimumTimeRequired = function(jobs, k) {
+  const n = jobs.length
+  const limit = 1 << n
+  const sum = Array(limit).fill(0)
+  const { min, max } = Math
+  
+  for(let mask = 0; mask < limit; mask++) {
+    for(let i = 0; i < n; i++) {
+      if((mask & (1 << i))) sum[mask] += jobs[i]
+    }
+  }
+  
+  const dp = Array.from({ length: k + 1 }, () => Array(limit).fill(0))
+  for(let i = 0; i < limit; i++) dp[1][i] = sum[i]
+  
+  for(let i = 2; i <= k; i++) {
+    for(let mask = 0; mask < limit; mask++) {
+      dp[i][mask] = dp[i - 1][mask]
+      for(let sub = mask; sub; sub = (sub - 1) & mask) {
+        dp[i][mask] = min(dp[i][mask], max(dp[i - 1][mask - sub], sum[sub]))
+      }
+    }
+  }
+  
+  return dp[k][limit - 1]
+};
+
+// another
+
 /**
  * @param {number[]} jobs
  * @param {number} k

From fb16d686cd20a475568530c14c7b62ee7cca9c35 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Apr 2023 17:06:51 +0800
Subject: [PATCH 2581/3374] Create 2614-prime-in-diagonal.js

---
 2614-prime-in-diagonal.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2614-prime-in-diagonal.js

diff --git a/2614-prime-in-diagonal.js b/2614-prime-in-diagonal.js
new file mode 100644
index 00000000..d214e379
--- /dev/null
+++ b/2614-prime-in-diagonal.js
@@ -0,0 +1,30 @@
+const isPrime = num => {
+    for(let i = 2, s = Math.sqrt(num); i <= s; i++) {
+        if(num % i === 0) return false;
+    }
+    return num > 1;
+}
+/**
+ * @param {number[][]} nums
+ * @return {number}
+ */
+var diagonalPrime = function(nums) {
+  const n = nums.length
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    if(isPrime(nums[i][i])) {
+      res = Math.max(res, nums[i][i])
+    }
+  }
+  
+  for(let i = 0; i < n; i++) {
+    if(isPrime(nums[i][n - 1 - i])) {
+      res = Math.max(res, nums[i][n - 1 - i])
+    }
+  }
+  
+  
+  return res
+    
+
+};

From 9b8bd8153c70cc8edd7179575ebcdcc284141334 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Apr 2023 12:21:28 +0800
Subject: [PATCH 2582/3374] Update
 1931-painting-a-grid-with-three-different-colors.js

---
 ...ting-a-grid-with-three-different-colors.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1931-painting-a-grid-with-three-different-colors.js b/1931-painting-a-grid-with-three-different-colors.js
index 1433b0e4..2e3cec5a 100644
--- a/1931-painting-a-grid-with-three-different-colors.js
+++ b/1931-painting-a-grid-with-three-different-colors.js
@@ -100,3 +100,50 @@ const colorTheGrid = function(m, n) {
 
   return dp(0, 0)
 };
+
+// another
+
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+const colorTheGrid = function(m, n) {
+  const mod = 1e9 + 7
+  const limit = 1 << (2 * m)
+  const memo = Array.from({ length: n }, () => Array(limit))
+  
+  return dp(0, 0)
+  
+  function dp(col, preColMask) {
+    if(col === n) return 1
+    let res = 0
+    
+    if(memo[col][preColMask] != null) return memo[col][preColMask]
+    const curColMasks = []
+    dfs(preColMask, 0, 0, curColMasks)
+    for(const colMask of curColMasks) {
+      res = (res + dp(col + 1, colMask)) % mod
+    }
+    return memo[col][preColMask] = res
+  }
+  
+  function dfs(preColMask, curColMask, row, res) {
+    if(row === m) {
+      res.push(curColMask)
+      return
+    }
+    for(let i = 1; i <= 3; i++) {
+      if(getColor(preColMask, row) !== i && (row === 0 || getColor(curColMask, row - 1) !== i)) {
+        dfs(preColMask, setColor(curColMask, row, i) ,row + 1, res)
+      }
+    }
+  }
+    
+  function getColor(mask, row) {
+    return (mask >> (2 * row)) & 3 
+  }
+  function setColor(mask, row, val) {
+    return mask | (val << (2 * row)) 
+  }
+};

From a6015ede1db6619c90cccd278493f82ec68416ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Apr 2023 19:47:43 +0800
Subject: [PATCH 2583/3374] Create 2615-sum-of-distances.js

---
 2615-sum-of-distances.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2615-sum-of-distances.js

diff --git a/2615-sum-of-distances.js b/2615-sum-of-distances.js
new file mode 100644
index 00000000..533c3806
--- /dev/null
+++ b/2615-sum-of-distances.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const distance = function(nums) {
+  const n = nums.length
+  const res = Array(n).fill(0)
+  const hash = {}
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    if(hash[e] == null) hash[e] = []
+    hash[e].push(i)
+  }
+  
+  const keys = Object.keys(hash)
+  for(const k of keys) {
+    const arr = hash[k]
+    const totalSum = arr.reduce((ac, e) => ac + e, 0)
+    let preSum = 0
+    if(arr.length < 2) continue
+    for(let i = 0, len =  arr.length; i < len; i++) {
+      const idx = arr[i]
+      const postSum =  totalSum - (preSum + idx)
+      
+      res[idx] += idx * i
+      res[idx] -= preSum
+      res[idx] -= idx * (len - 1 - i)
+      res[idx] += postSum
+      
+      preSum += idx
+    }
+  }
+  
+  
+  return res
+};

From 2ff0661b1e4a792e2736520ce153f94b64d98825 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Apr 2023 10:53:59 +0800
Subject: [PATCH 2584/3374] Update
 2184-number-of-ways-to-build-sturdy-brick-wall.js

---
 ...mber-of-ways-to-build-sturdy-brick-wall.js | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/2184-number-of-ways-to-build-sturdy-brick-wall.js b/2184-number-of-ways-to-build-sturdy-brick-wall.js
index 1d53cd50..99624b12 100644
--- a/2184-number-of-ways-to-build-sturdy-brick-wall.js
+++ b/2184-number-of-ways-to-build-sturdy-brick-wall.js
@@ -1,3 +1,57 @@
+/**
+ * @param {number} height
+ * @param {number} width
+ * @param {number[]} bricks
+ * @return {number}
+ */
+const buildWall = function (height, width, bricks) {
+  const mod = 1e9 + 7
+  const avail = []
+  const bset = new Set(bricks)
+  const m = width - 1, limit = 1 << m
+  for(let mask = 0; mask < limit; mask++) {
+    const idxArr = [-1]
+    for(let j = 0; j < m; j++) {
+      if((mask >> j) & 1) idxArr.push(j)
+    }
+    idxArr.push(m)
+    let flag = true
+    for(let j = 1, len = idxArr.length; j < len; j++) {
+      if(!bset.has(idxArr[j] - idxArr[j - 1])) {
+        flag = false
+        break
+      }
+    }
+    if(flag) avail.push(mask)
+  }
+  
+  let res = 0
+  if(height === 1) return avail.length
+  const dp = Array.from({ length: height }, () => Array(limit).fill(0))
+  for(const mask of avail) {
+    dp[0][mask] = 1
+  }
+  
+  for(let i = 1; i < height; i++) {
+    for(let j = 0, len = avail.length; j < len; j++) {
+      const cur = avail[j]
+      for(let k = 0; k < len; k++) {
+        const pre = avail[k]
+        if((cur & pre) === 0) {
+          dp[i][cur] = (dp[i][cur] + dp[i - 1][pre]) % mod
+        }
+      }
+      if(i === height - 1) {
+        res = (res + dp[i][cur]) % mod
+      }
+    }
+  }
+  
+  return res
+}
+
+// another
+
 /**
  * @param {number} height
  * @param {number} width

From 22d618f36bc711d21932114951226c1af61e9398 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Apr 2023 19:25:01 +0800
Subject: [PATCH 2585/3374] Create
 2616-minimize-the-maximum-difference-of-pairs.js

---
 ...inimize-the-maximum-difference-of-pairs.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2616-minimize-the-maximum-difference-of-pairs.js

diff --git a/2616-minimize-the-maximum-difference-of-pairs.js b/2616-minimize-the-maximum-difference-of-pairs.js
new file mode 100644
index 00000000..c96d82b0
--- /dev/null
+++ b/2616-minimize-the-maximum-difference-of-pairs.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+const minimizeMax = function(nums, p) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  let l = 0, r = nums.at(-1) - nums[0]
+  
+  while(l < r) {
+    const mid = Math.floor(l + (r - l) / 2)
+    let k = 0
+    for(let i = 1; i < n;) {
+      if(nums[i] - nums[i - 1] <= mid) {
+        k++
+        i += 2
+      } else {
+        i++
+      }
+    }
+    
+    if(k >= p) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  
+  return l
+};

From f106183a718e75a9d867a541133d84787c7e1c4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Apr 2023 06:41:53 +0800
Subject: [PATCH 2586/3374] Update 206-reverse-linked-list.js

---
 206-reverse-linked-list.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/206-reverse-linked-list.js b/206-reverse-linked-list.js
index 94c78a97..82ccda9a 100755
--- a/206-reverse-linked-list.js
+++ b/206-reverse-linked-list.js
@@ -14,7 +14,7 @@ const reverseList = function(head) {
   const pre = new ListNode(null, head)
   let cur = head
   while(cur.next) {
-    let tmp = pre.next
+    const tmp = pre.next
     pre.next = cur.next
     cur.next = cur.next.next
     pre.next.next = tmp

From 24572632c52eadba03a8e229534aed644a1cd2dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Apr 2023 11:04:38 +0800
Subject: [PATCH 2587/3374] Update
 2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js

---
 ...-length-of-two-palindromic-subsequences.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
index ad4a1b79..f6126c88 100644
--- a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
+++ b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
@@ -27,3 +27,47 @@ function palindromic( i, s) {
   }
   return len;
 }
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxProduct = function(s) {
+  const s1 = [], s2 = [], n = s.length
+  let res = 0
+  dfs(0)
+  return res
+  
+  function dfs(idx) {
+    if(idx === n) {
+      if(isPalindromic(s1) && isPalindromic(s2)) {
+        res = Math.max(res, s1.length * s2.length)
+      }
+      return
+    }
+    const ch = s[idx]
+    s1.push(ch)
+    dfs(idx + 1)
+    s1.pop()
+    
+    s2.push(ch)
+    dfs(idx + 1)
+    s2.pop()
+    
+    dfs(idx + 1)
+  }
+  function isPalindromic(arr) {
+    let l = 0, r = arr.length - 1
+    while(l < r) {
+      if(arr[l] === arr[r]) {
+        l++
+        r--
+      } else {
+        return false
+      }
+    }
+    return true
+  }
+};

From a95af4a7e3a802247cf123d6828aa3a5d1a6fbad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Apr 2023 11:46:37 +0800
Subject: [PATCH 2588/3374] Create
 2572-count-the-number-of-square-free-subsets.js

---
 ...count-the-number-of-square-free-subsets.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2572-count-the-number-of-square-free-subsets.js

diff --git a/2572-count-the-number-of-square-free-subsets.js b/2572-count-the-number-of-square-free-subsets.js
new file mode 100644
index 00000000..2100de59
--- /dev/null
+++ b/2572-count-the-number-of-square-free-subsets.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const squareFreeSubsets = function(nums) {
+  const primes = [2,3,5,7,11,13,17,19,23,29]
+  const n = nums.length
+  const limit = 1 << primes.length, mod = 1e9 + 7
+  const dp = Array.from({ length: n + 1 }, () => Array(limit).fill(0))
+  dp[0][0] = 1
+  const arr = [0, ...nums]
+  let res = 0
+  for(let i = 1; i <= n; i++) {
+    const cur = arr[i]
+    for(let mask = 0; mask < limit; mask++) {
+      if(cur === 1) {
+        dp[i][mask] = (dp[i - 1][mask] * 2) % mod
+      } else {
+        dp[i][mask] = dp[i - 1][mask]
+        const sub = helper(cur)
+        if(sub !== -1 && (mask & sub) === sub) {
+          dp[i][mask] = (dp[i][mask] + dp[i - 1][mask - sub]) % mod
+        }
+      }
+      if(i === n) {
+        res = (res + dp[i][mask]) % mod
+      }
+    }
+  }
+  
+  return (res + mod - 1) % mod
+  
+  function helper(x) {
+    let res = 0
+    for(let i = 0; i < primes.length; i++) {
+      let cnt = 0
+      while(x && (x % primes[i] === 0)) {
+        cnt++
+        x = x / primes[i]
+      }
+      if(cnt > 1) return -1
+      else if(cnt === 1) {
+        res = res | (1 << i)
+      }
+    }
+    return res
+  }
+};

From 1a42bc432ce576618bb379b5aad3ed1f9fd30060 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Apr 2023 12:28:48 +0800
Subject: [PATCH 2589/3374] Create 2403-minimum-time-to-kill-all-monsters.js

---
 2403-minimum-time-to-kill-all-monsters.js | 30 +++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2403-minimum-time-to-kill-all-monsters.js

diff --git a/2403-minimum-time-to-kill-all-monsters.js b/2403-minimum-time-to-kill-all-monsters.js
new file mode 100644
index 00000000..b91a3541
--- /dev/null
+++ b/2403-minimum-time-to-kill-all-monsters.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} power
+ * @return {number}
+ */
+const minimumTime = function(power) {
+  const n = power.length
+  const limit = 1 << n
+  const dp = new Array(limit).fill(Infinity)
+  dp[0] = 0
+  for(let mask = 1; mask < limit; mask++) {
+    const k = cnt(mask)
+    for(let i = 0; i < n; i++) {
+      if((mask >> i) & 1) {
+        dp[mask] = Math.min(dp[mask], dp[mask - (1 << i)] + Math.ceil(power[i] / k) )
+      }
+    }
+  }
+  // console.log(dp)
+  return dp[limit - 1]
+  
+  function cnt(num) {
+    let res = 0
+    while(num) {
+      if(num & 1) res++
+      num = num >> 1
+    }
+    
+    return res
+  }
+};

From a678a67f0dc6e115d537d400a793f18d3630553a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Apr 2023 19:30:16 +0800
Subject: [PATCH 2590/3374] Update 1494-parallel-courses-ii.js

---
 1494-parallel-courses-ii.js | 47 +++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1494-parallel-courses-ii.js b/1494-parallel-courses-ii.js
index af6c6a1d..e693d4b5 100644
--- a/1494-parallel-courses-ii.js
+++ b/1494-parallel-courses-ii.js
@@ -48,3 +48,50 @@ function bitCount(n) {
   n = (n & 0x33333333) + ((n >> 2) & 0x33333333)
   return (((n + (n >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24
 }
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} dependencies
+ * @param {number} k
+ * @return {number}
+ */
+const minNumberOfSemesters = function (n, dependencies, k) {
+  const pre = Array(n).fill(0)
+  const limit = 1 << n
+  for(const [p, v] of dependencies) {
+    pre[v - 1] |= (1 << (p - 1))
+  }
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  
+  for(let learned = 0; learned < limit; learned++) {
+    let wait = 0
+    for(let i = 0; i < n; i++) {
+      if( (learned & pre[i]) === pre[i]) {
+        wait |= (1 << i)
+      }
+    }
+    wait = wait & (~learned)
+    for(let sub = wait; sub; sub = (sub - 1) & wait) {
+      if(bitCnt(sub) > k) continue
+      const mask = learned | sub
+      dp[mask] = Math.min(dp[mask], dp[learned] + 1)
+    }
+  }
+  
+  return dp[limit - 1]
+}
+
+function bitCnt(num) {
+  let res = 0
+  while(num) {
+    if(num & 1) res++
+    num = num >> 1
+  }
+  
+  return res
+}
+
+

From 91b528dc297b355ca9d5901bc80d8922e83254ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Apr 2023 19:38:29 +0800
Subject: [PATCH 2591/3374] Update 1494-parallel-courses-ii.js

---
 1494-parallel-courses-ii.js | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/1494-parallel-courses-ii.js b/1494-parallel-courses-ii.js
index e693d4b5..0882499f 100644
--- a/1494-parallel-courses-ii.js
+++ b/1494-parallel-courses-ii.js
@@ -87,11 +87,12 @@ const minNumberOfSemesters = function (n, dependencies, k) {
 function bitCnt(num) {
   let res = 0
   while(num) {
-    if(num & 1) res++
-    num = num >> 1
+    num &= (num - 1)
+    res++
   }
   
   return res
 }
 
 
+

From c24a66cf875cfa38549479cf232536282d602b76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Apr 2023 12:16:54 +0800
Subject: [PATCH 2592/3374] Create 2643-row-with-maximum-ones.js

---
 2643-row-with-maximum-ones.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2643-row-with-maximum-ones.js

diff --git a/2643-row-with-maximum-ones.js b/2643-row-with-maximum-ones.js
new file mode 100644
index 00000000..b7ebf790
--- /dev/null
+++ b/2643-row-with-maximum-ones.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[][]} mat
+ * @return {number[]}
+ */
+var rowAndMaximumOnes = function(mat) {
+  const arr= []
+  const m = mat.length, n = mat[0].length
+  let ma = 0
+  for(let i = 0; i < m; i++) {
+    let cnt = 0
+    for(let j = 0; j < n; j++) {
+      if(mat[i][j] === 1) cnt++
+    }
+    arr[i] = cnt
+    ma = Math.max(ma, cnt)
+  }
+  
+  for(let i = 0; i < m; i++) {
+    if(arr[i] === ma) return [i, ma]
+  }
+};

From 2668e5e810a61928f4483a532160598a126deeaf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Apr 2023 12:17:24 +0800
Subject: [PATCH 2593/3374] Create 2644-find-the-maximum-divisibility-score.js

---
 2644-find-the-maximum-divisibility-score.js | 24 +++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2644-find-the-maximum-divisibility-score.js

diff --git a/2644-find-the-maximum-divisibility-score.js b/2644-find-the-maximum-divisibility-score.js
new file mode 100644
index 00000000..78832000
--- /dev/null
+++ b/2644-find-the-maximum-divisibility-score.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} divisors
+ * @return {number}
+ */
+var maxDivScore = function(nums, divisors) {
+    divisors.sort((a, b) => a - b)
+  nums.sort((a, b) => a - b)
+  
+  let arr = [], ma = 0
+  for(let i = 0; i < divisors.length; i++) {
+    const div = divisors[i]
+    let cnt = 0
+    for(let j = 0; j < nums.length; j++) {
+      if(nums[j] % div === 0) cnt++
+    }
+    arr[i] = cnt
+    ma = Math.max(ma, cnt)
+  }
+  
+  for(let i = 0; i < divisors.length; i++) {
+    if(arr[i] === ma) return divisors[i]
+  }
+};

From fc170d70cb665a4f00e0f2de63b9968f6688345f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Apr 2023 12:17:55 +0800
Subject: [PATCH 2594/3374] Create
 2645-minimum-additions-to-make-valid-string.js

---
 ...-minimum-additions-to-make-valid-string.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2645-minimum-additions-to-make-valid-string.js

diff --git a/2645-minimum-additions-to-make-valid-string.js b/2645-minimum-additions-to-make-valid-string.js
new file mode 100644
index 00000000..7e767f07
--- /dev/null
+++ b/2645-minimum-additions-to-make-valid-string.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+var addMinimum = function(word) {
+	let pattern = "abc"
+	let p1 = 0, p2 = 0
+	let cnt = 0
+	while( p1 < word.length) {
+		while( p1 < word.length && word[p1] != pattern[p2]) {
+			p2 = (p2 + 1) % 3
+			cnt++
+		}
+		p1++
+		p2 = (p2 + 1) % 3
+	}
+	if (p2 == 1) {
+		cnt += 2
+	} else if (p2 == 2) {
+		cnt += 1
+	}
+	return cnt
+};

From 272207dea2457f0bf28eb3ebc08f0b723a46effd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Apr 2023 12:18:35 +0800
Subject: [PATCH 2595/3374] Create
 2646-minimize-the-total-price-of-the-trips.js

---
 2646-minimize-the-total-price-of-the-trips.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2646-minimize-the-total-price-of-the-trips.js

diff --git a/2646-minimize-the-total-price-of-the-trips.js b/2646-minimize-the-total-price-of-the-trips.js
new file mode 100644
index 00000000..52600ad8
--- /dev/null
+++ b/2646-minimize-the-total-price-of-the-trips.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} price
+ * @param {number[][]} trips
+ * @return {number}
+ */
+var minimumTotalPrice = function (n, edges, price, trips) {
+  const graph = []
+  const { min, max } = Math
+  for (const [u, v] of edges) {
+    if (graph[u] == null) graph[u] = []
+    if (graph[v] == null) graph[v] = []
+    graph[u].push(v)
+    graph[v].push(u)
+  }
+
+  const cnt = Array(n).fill(0)
+
+  function dfs(p, i, e) {
+    if (i == e) {
+      ++cnt[i]
+      return true
+    }
+    for (const j of graph[i] || []) {
+      if (j != p && dfs(i, j, e)) {
+        ++cnt[i]
+        return true
+      }
+    }
+    return false
+  }
+
+  for (const t of trips) dfs(-1, t[0], t[1])
+
+  const dp = Array.from({ length: n }, () => Array(2).fill(Infinity))
+
+  function minCost(pre, i, status) {
+    if (dp[i][status] == Infinity) {
+      dp[i][status] = (price[i] >> status) * cnt[i]
+      for (const j of graph[i] || []) {
+        if (j == pre) continue
+        if (status == 1) dp[i][status] += minCost(i, j, 0)
+        else dp[i][status] += min(minCost(i, j, 0), minCost(i, j, 1))
+      }
+    }
+    return dp[i][status]
+  }
+
+  return min(minCost(-1, 0, 0), minCost(-1, 0, 1))
+}

From fb7504d55e12276b50a218f29fa350da9e4092bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Apr 2023 20:37:39 +0800
Subject: [PATCH 2596/3374] Update 1655-distribute-repeating-integers.js

---
 1655-distribute-repeating-integers.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/1655-distribute-repeating-integers.js b/1655-distribute-repeating-integers.js
index 679d1fc2..201a7fad 100644
--- a/1655-distribute-repeating-integers.js
+++ b/1655-distribute-repeating-integers.js
@@ -1,3 +1,4 @@
+
 /**
  * @param {number[]} nums
  * @param {number[]} quantity
@@ -9,13 +10,13 @@ const canDistribute = function(nums, quantity) {
     freq.set(e, (freq.get(e) || 0) + 1)
   }
   const cntArr = [...freq.values()]
-  const dp = Array.from({ length: 51 }, () => Array(1024).fill(false))
-  const n = cntArr.length, m = quantity.length
+  const n = cntArr.length, m = quantity.length, limit = 1 << m
+  const dp = Array.from({ length: n + 1 }, () => Array(limit).fill(false))
   for(let i = 0; i < n; i++) {
     dp[i][0] = true
   }
   cntArr.unshift(0)
-  const allMask = (1 << m) - 1
+  const allMask = limit - 1
   
   for(let i = 1; i <= n; i++) {
     for(let mask = 1; mask <= allMask; mask++) {
@@ -37,7 +38,7 @@ const canDistribute = function(nums, quantity) {
   
   function canSatisfySubset(cnt, subset) {
     let sum = 0
-    for (let i = 0; i < 10; i++) {
+    for (let i = 0; i < m; i++) {
       if(subset & (1 << i)) {
         sum += quantity[i]
       }

From 245f37713471aebc67b50e92c26c5e4c635aa176 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Apr 2023 15:34:48 +0800
Subject: [PATCH 2597/3374] Update
 1986-minimum-number-of-work-sessions-to-finish-the-tasks.js

---
 ...er-of-work-sessions-to-finish-the-tasks.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
index 2b5b5758..a3237bb6 100644
--- a/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
+++ b/1986-minimum-number-of-work-sessions-to-finish-the-tasks.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number[]} tasks
+ * @param {number} sessionTime
+ * @return {number}
+ */
+const minSessions = function(tasks, sessionTime) {
+  const n = tasks.length
+  const limit = 1 << n
+  
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  for(let mask = 1; mask < limit; mask++) {
+    for(let sub = mask; sub; sub = (sub - 1) & mask) {
+      if(valid(sub)) {
+        dp[mask] = Math.min(dp[mask], dp[mask - sub] + 1)        
+      }
+    }
+  }
+  
+  return dp[limit - 1]
+  
+  function valid(sub) {
+    let sum = 0
+    for(let i = 0; i < 14; i++) {
+      if((sub >> i) & 1) sum += tasks[i]
+    }
+    
+    return sum <= sessionTime
+  }
+};
+
+// another
+
 /**
  * @param {number[]} tasks
  * @param {number} sessionTime

From 0f93d9fe54fff71902d49c1f6b89e669dfd9584c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Apr 2023 11:43:07 +0800
Subject: [PATCH 2598/3374] Update
 2152-minimum-number-of-lines-to-cover-points.js

---
 ...minimum-number-of-lines-to-cover-points.js | 80 +++++++++----------
 1 file changed, 36 insertions(+), 44 deletions(-)

diff --git a/2152-minimum-number-of-lines-to-cover-points.js b/2152-minimum-number-of-lines-to-cover-points.js
index 8c0878b4..78453f54 100644
--- a/2152-minimum-number-of-lines-to-cover-points.js
+++ b/2152-minimum-number-of-lines-to-cover-points.js
@@ -3,56 +3,48 @@
  * @return {number}
  */
 const minimumLines = function(points) {
-  const n = points.length;
-  const connects = Array.from({ length: n }, () => Array(n).fill(0));
-  for(let i = 0; i < n; ++i) {
-      for(let j = i + 1; j < n; ++j) {
-          connects[i][j] = (1 << i) | (1 << j);
-          let dx = points[j][0] - points[i][0];
-          let dy = points[j][1] - points[i][1];
-          for(let k = j + 1; k < n; ++k) { // check if k will be on the line connecting i and j.
-              let dx2 = points[k][0] - points[i][0];
-              let dy2 = points[k][1] - points[i][1];
-              if (dx * dy2 == dy * dx2) {
-                  connects[i][j] |= (1 << k);
-              }
-          }
+  const n = points.length
+  const limit = 1 << n
+  const dp = Array(limit).fill(n)
+  dp[0] = 0
+  for(let mask = 1; mask < limit; mask++) {
+    for(let sub = mask; sub; sub = (sub - 1) & mask) {
+      if(valid(sub)) {
+        dp[mask] = Math.min(dp[mask], dp[mask - sub] + 1)
       }
+    }
   }
-  const dp = new Array(1<<n).fill(Infinity);
-  return helper(n, 0, dp, connects);
-};
-
-function helper(n, mask, dp, connects) {
-  if (dp[mask] == Infinity) {
-      let has = numOfOne(mask);
-      if (has == n) { // if all the points have been connected
-          dp[mask] = 0;
-      } else if (has >= n - 2) { // if only 2 points left
-          dp[mask] = 1;
-      } else { // if there are more than 2 points, try a line connecting first to second, third, ...
-          let i = 0;
-          for(let x = (1 << i); i < n; ++i, x <<= 1) {
-              if ((mask & x) == 0) {
-                  break;
-              }
-          }
-          for(let j = i + 1, x = (1 << j); j < n; ++j, x <<= 1) {
-              if ((mask & x) == 0) {
-                  let mask2 = mask | connects[i][j];
-                  dp[mask] = Math.min(dp[mask], 1 + helper(n, mask2, dp, connects));
-              }
-          }
+  return dp[limit - 1]
+  
+  function valid(sub) {
+    let res = true
+    const arr = []
+    let idx = 0
+    while(sub) {
+      if(sub & 1) arr.push(idx)
+      sub = sub >> 1
+      idx++
+    }
+    if(arr.length <= 2) return res
+    for(let i = 2; i < arr.length; i++) {
+      if(!isSameLine(points[arr[0]], points[arr[1]], points[arr[i]])) {
+        return false
       }
+    }
+    return res
   }
-  return dp[mask];
-}
+};
+
 
-function numOfOne(num) {
-  const str = (num >>> 0).toString(2)
+function bitCnt(num) {
   let res = 0
-  for(let ch of str) {
-    if(ch === '1') res++
+  while(num) {
+    if(num & 1) res++
+    num = num >> 1
   }
   return res
 }
+function isSameLine(p1, p2, p3) {
+  const delta = (p3[1] - p2[1]) * (p2[0] - p1[0]) - (p2[1] - p1[1]) * (p3[0] - p2[0])
+  return delta === 0
+}

From 4cf0026f066a8970dd43acf7789a2d971f7f9f72 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Apr 2023 11:25:36 +0800
Subject: [PATCH 2599/3374] Update 1879-minimum-xor-sum-of-two-arrays.js

---
 1879-minimum-xor-sum-of-two-arrays.js | 36 +++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/1879-minimum-xor-sum-of-two-arrays.js b/1879-minimum-xor-sum-of-two-arrays.js
index 0225d947..31c752c9 100644
--- a/1879-minimum-xor-sum-of-two-arrays.js
+++ b/1879-minimum-xor-sum-of-two-arrays.js
@@ -1,3 +1,39 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const minimumXORSum = function (nums1, nums2) {
+  const n = nums1.length
+  const limit = 1 << n
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  for (let mask = 1; mask < limit; ++mask) {
+    for (let i = 0; i < n; ++i) {
+      if ((mask >> i) & 1) {
+        dp[mask] = Math.min(
+          dp[mask],
+          dp[mask ^ (1 << i)] + (nums1[bitCnt(mask) - 1] ^ nums2[i])
+        )
+      }
+    }
+  }
+  return dp[limit - 1]
+}
+
+function bitCnt(num) {
+  let res = 0
+  while (num) {
+    res++
+    num = num & (num - 1)
+  }
+
+  return res
+}
+
+
+// another
+
 /**
  * @param {number[]} nums1
  * @param {number[]} nums2

From e0f3a8e56388caf5c621c032296315c77ad73f40 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Apr 2023 10:03:21 +0800
Subject: [PATCH 2600/3374] Update 1947-maximum-compatibility-score-sum.js

---
 1947-maximum-compatibility-score-sum.js | 47 +++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1947-maximum-compatibility-score-sum.js b/1947-maximum-compatibility-score-sum.js
index e6148d33..7debdc44 100644
--- a/1947-maximum-compatibility-score-sum.js
+++ b/1947-maximum-compatibility-score-sum.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number[][]} students
+ * @param {number[][]} mentors
+ * @return {number}
+ */
+const maxCompatibilitySum = function(students, mentors) {
+  const m = students.length, n = students[0].length
+  const limit = 1 << m
+  const dp = Array(limit).fill(0)
+  for(let mask = 1; mask < limit; mask++) {
+    for(let i = 0; i < m; i++) {
+      if(mask & (1 << i)) {
+        dp[mask] = Math.max(
+          dp[mask],
+          dp[mask ^ (1 << i)] + calc(bitCnt(mask) - 1, i)
+        )
+      }
+    }
+  }
+  
+  
+  return dp[limit - 1]
+    
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      num = num & (num - 1)
+      res++
+    }
+    
+    return res
+  }
+  // student, mentor
+  function calc(i, j) {
+    let res = 0
+    for(let k = 0; k < n; k++) {
+      if(students[i][k] === mentors[j][k]) {
+        res++
+      }
+    }
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[][]} students
  * @param {number[][]} mentors

From a6fdb0a9bff9e1c4c743c5e5cb6a9b1946dea2c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Apr 2023 11:42:30 +0800
Subject: [PATCH 2601/3374] Update 1066-campus-bikes-ii.js

---
 1066-campus-bikes-ii.js | 48 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1066-campus-bikes-ii.js b/1066-campus-bikes-ii.js
index ddf46b3d..8b536b6d 100644
--- a/1066-campus-bikes-ii.js
+++ b/1066-campus-bikes-ii.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number[][]} workers
+ * @param {number[][]} bikes
+ * @return {number}
+ */
+const assignBikes = function(workers, bikes) {
+  const { abs, min } = Math
+  const n = workers.length, m = bikes.length
+  
+  const limit = 1 << m
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  let res = Infinity
+  for(let mask = 1; mask < limit; mask++) {
+    if(bitCnt(mask) > n) continue
+    for(let i = 0; i < m; i++) {
+      if((mask >> i) & 1) {
+        dp[mask] = min(
+          dp[mask],
+          dp[mask ^ (1 << i)] + distance(bitCnt(mask) - 1, i)
+        )        
+      }
+    }
+    if(bitCnt(mask) === n) {
+      res = min(res, dp[mask])
+    }
+  }
+  
+  return res
+  
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      num = num & (num - 1)
+      res++
+    }
+    
+    return res
+  }
+  
+  // worker, bike
+  function distance(i, j) {
+    return abs(workers[i][0] - bikes[j][0]) + abs(workers[i][1] - bikes[j][1])
+  }
+};
+
+// another
+
 /**
  * @param {number[][]} workers
  * @param {number[][]} bikes

From 83a3c3efea80f4ab8a946d2221722bd84b325901 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Apr 2023 16:16:09 +0800
Subject: [PATCH 2602/3374] Create 875-koko-eating-bananas.js

---
 875-koko-eating-bananas.js | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 875-koko-eating-bananas.js

diff --git a/875-koko-eating-bananas.js b/875-koko-eating-bananas.js
new file mode 100644
index 00000000..6bb679cd
--- /dev/null
+++ b/875-koko-eating-bananas.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} piles
+ * @param {number} h
+ * @return {number}
+ */
+const minEatingSpeed = function(piles, h) {
+  let ma = -1
+  for(const e of piles) {
+    if(e > ma) ma = e
+  }
+  
+  let l = 1, r = ma
+  
+  while(l < r) {
+    const mid = Math.floor((l + r) / 2)
+    if(valid(mid)) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  
+  return l
+  
+  function valid(val) {
+    let res = 0
+    for(const e of piles) {
+      res += Math.ceil(e / val)
+    }
+    
+    return res <= h
+  }
+};

From e021d32d4780d2416cd94c120accc4c8ffbb6ee1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Apr 2023 18:28:20 +0800
Subject: [PATCH 2603/3374] Update
 2127-maximum-employees-to-be-invited-to-a-meeting.js

---
 ...um-employees-to-be-invited-to-a-meeting.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/2127-maximum-employees-to-be-invited-to-a-meeting.js b/2127-maximum-employees-to-be-invited-to-a-meeting.js
index bcaa93f1..356bf2f2 100644
--- a/2127-maximum-employees-to-be-invited-to-a-meeting.js
+++ b/2127-maximum-employees-to-be-invited-to-a-meeting.js
@@ -1,3 +1,61 @@
+/**
+ * @param {number[]} favorite
+ * @return {number}
+ */
+const maximumInvitations = function(favorite) {
+  const n = favorite.length
+  const inDegree = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    inDegree[favorite[i]]++
+  }
+  
+  let q = []
+  const visited = Array(n).fill(0)
+  const depth = Array(n).fill(1)
+  for(let i = 0; i < n; i++) {
+    if(inDegree[i] === 0) {
+      q.push(i)
+      visited[i] = 1
+    }
+  }
+  
+  while(q.length) {
+    const cur = q.shift()
+    const nxt = favorite[cur]
+    inDegree[nxt]--
+    if(inDegree[nxt] === 0) {
+      q.push(nxt)
+      visited[nxt] = 1
+    }
+    depth[nxt] = depth[cur] + 1
+  }
+  
+  let maxLoopSize = 0
+  let twoNodesSize = 0
+  const { max } = Math
+  for(let i = 0; i < n; i++) {
+    if(visited[i] === 1) continue
+    let j = i
+    let cnt = 0
+    while(visited[j] === 0) {
+      cnt++
+      visited[j] = 1
+      j = favorite[j]
+    }
+    
+    if(cnt > 2) {
+      maxLoopSize = max(maxLoopSize, cnt)
+    } else if(cnt === 2) {
+      twoNodesSize += depth[i] + depth[favorite[i]]
+    }
+  }
+  
+  
+  return max(maxLoopSize, twoNodesSize)
+};
+
+// another
+
 /**
  * @param {number[]} favorite
  * @return {number}

From 88a2af5122db7dad5fe119560eb57c39565ac64d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Apr 2023 19:01:29 +0800
Subject: [PATCH 2604/3374] Update
 2127-maximum-employees-to-be-invited-to-a-meeting.js

---
 2127-maximum-employees-to-be-invited-to-a-meeting.js | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/2127-maximum-employees-to-be-invited-to-a-meeting.js b/2127-maximum-employees-to-be-invited-to-a-meeting.js
index 356bf2f2..8a8efe69 100644
--- a/2127-maximum-employees-to-be-invited-to-a-meeting.js
+++ b/2127-maximum-employees-to-be-invited-to-a-meeting.js
@@ -5,6 +5,7 @@
 const maximumInvitations = function(favorite) {
   const n = favorite.length
   const inDegree = Array(n).fill(0)
+  const { max } = Math
   for(let i = 0; i < n; i++) {
     inDegree[favorite[i]]++
   }
@@ -16,23 +17,24 @@ const maximumInvitations = function(favorite) {
     if(inDegree[i] === 0) {
       q.push(i)
       visited[i] = 1
+      depth[i] = 1
     }
   }
   
   while(q.length) {
-    const cur = q.shift()
+    const cur = q.pop()
     const nxt = favorite[cur]
     inDegree[nxt]--
     if(inDegree[nxt] === 0) {
       q.push(nxt)
       visited[nxt] = 1
     }
-    depth[nxt] = depth[cur] + 1
+    depth[nxt] = max(depth[nxt], depth[cur] + 1)
   }
-  
+
   let maxLoopSize = 0
   let twoNodesSize = 0
-  const { max } = Math
+
   for(let i = 0; i < n; i++) {
     if(visited[i] === 1) continue
     let j = i
@@ -50,7 +52,6 @@ const maximumInvitations = function(favorite) {
     }
   }
   
-  
   return max(maxLoopSize, twoNodesSize)
 };
 

From aa2cb91856b1ff2634e50c0ff797f013ac4132bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 12:32:43 +0800
Subject: [PATCH 2605/3374] Create 2653-sliding-subarray-beauty.js

---
 2653-sliding-subarray-beauty.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2653-sliding-subarray-beauty.js

diff --git a/2653-sliding-subarray-beauty.js b/2653-sliding-subarray-beauty.js
new file mode 100644
index 00000000..89080175
--- /dev/null
+++ b/2653-sliding-subarray-beauty.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} x
+ * @return {number[]}
+ */
+const getSubarrayBeauty = function(nums, k, x) {
+  let counter = Array(50).fill(0), ans = new Array(nums.length - k + 1).fill(0);
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] < 0) counter[nums[i] + 50]++;
+    if (i - k >= 0 && nums[i - k] < 0) counter[nums[i - k] + 50]--;
+    if (i - k + 1 < 0) continue;
+    let count = 0;
+    for (let j = 0; j < 50; j++) {
+      count += counter[j];
+      if (count >= x) {
+        ans[i - k + 1] = j - 50;
+        break;
+      }
+    }
+  }
+  return ans;
+};

From 1bb16b89858e8299226657c1529242f77744cf5d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 12:36:43 +0800
Subject: [PATCH 2606/3374] Create
 2654-minimum-number-of-operations-to-make-all-array-elements-equal-to-1.js

---
 ...s-to-make-all-array-elements-equal-to-1.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2654-minimum-number-of-operations-to-make-all-array-elements-equal-to-1.js

diff --git a/2654-minimum-number-of-operations-to-make-all-array-elements-equal-to-1.js b/2654-minimum-number-of-operations-to-make-all-array-elements-equal-to-1.js
new file mode 100644
index 00000000..498f4da2
--- /dev/null
+++ b/2654-minimum-number-of-operations-to-make-all-array-elements-equal-to-1.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minOperations = function(nums) {
+  let n = nums.length;
+
+  let ones = cntOnes();
+  if (ones) return n - ones;
+
+  for (let r = 2; r <= n; r++) {
+    for (let i = 0; i + r <= n; i++) {
+      let g = 0;
+      for (let j = i; j < i + r; j++) g = gcd(g, nums[j]);
+      if (g == 1) return r - 1 + n - 1;
+    }
+  }
+
+  return -1;
+  
+  function cntOnes() {
+    let res = 0
+    for(const e of nums) {
+      if(e === 1) res++
+    }
+    return res
+  }
+  function gcd(a, b) {
+    return b ? gcd(b, a % b) : a
+  }
+};

From 94719d496e51d1c13214ca434b83f36111a43bad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 12:42:05 +0800
Subject: [PATCH 2607/3374] Create 2652-sum-multiples.js

---
 2652-sum-multiples.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2652-sum-multiples.js

diff --git a/2652-sum-multiples.js b/2652-sum-multiples.js
new file mode 100644
index 00000000..e135636d
--- /dev/null
+++ b/2652-sum-multiples.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const sumOfMultiples = function(n) {
+  let res = 0
+  const set = new Set()
+  for(let i = 3; i <= n; i += 3) {
+    set.add(i)
+  }
+  
+  for(let i = 5; i <= n; i += 5) {
+    set.add(i)
+  }
+  
+  for(let i = 7; i <= n; i += 7) {
+    set.add(i)
+  }
+  
+  for(const e of set) {
+    res += e
+  }
+  
+  return res
+};

From e98dc390addbdc90aada4bb1613d26bbbaddc44c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 12:42:42 +0800
Subject: [PATCH 2608/3374] Create 2651-calculate-delayed-arrival-time.js

---
 2651-calculate-delayed-arrival-time.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 2651-calculate-delayed-arrival-time.js

diff --git a/2651-calculate-delayed-arrival-time.js b/2651-calculate-delayed-arrival-time.js
new file mode 100644
index 00000000..e30c44e6
--- /dev/null
+++ b/2651-calculate-delayed-arrival-time.js
@@ -0,0 +1,8 @@
+/**
+ * @param {number} arrivalTime
+ * @param {number} delayedTime
+ * @return {number}
+ */
+var findDelayedArrivalTime = function(arrivalTime, delayedTime) {
+  return (arrivalTime + delayedTime) % 24
+};

From 85f8a4dd8bf97d765802c228cdae27216340444a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 13:54:01 +0800
Subject: [PATCH 2609/3374] Create 2172-maximum-and-sum-of-array.js

---
 2172-maximum-and-sum-of-array.js | 42 ++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2172-maximum-and-sum-of-array.js

diff --git a/2172-maximum-and-sum-of-array.js b/2172-maximum-and-sum-of-array.js
new file mode 100644
index 00000000..02ca3260
--- /dev/null
+++ b/2172-maximum-and-sum-of-array.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @param {number} numSlots
+ * @return {number}
+ */
+const maximumANDSum = function (nums, numSlots) {
+  const n = nums.length
+  nums.unshift(0)
+  const m = Math.pow(3, numSlots)
+
+  const dp = Array.from({ length: n + 1 }, () => Array(m).fill(-Infinity))
+  dp[0][0] = 0
+
+  let ret = 0
+
+  for (let state = 1; state < m; state++) {
+    let i = 0
+    let temp = state
+    while (temp > 0) {
+      i += temp % 3
+      temp = Math.floor(temp / 3)
+    }
+    if (i > n) continue
+
+    for (let j = 0; j < numSlots; j++) {
+      if (filled(state, j) >= 1) {
+        dp[i][state] = Math.max(
+          dp[i][state],
+          dp[i - 1][state - Math.pow(3, j)] + (nums[i] & (j + 1))
+        )
+      }
+    }
+    if (i === n) ret = Math.max(ret, dp[i][state])
+  }
+
+  return ret
+}
+
+function filled(state, k) {
+  for (let i = 0; i < k; i++) state = Math.floor(state / 3)
+  return state % 3
+}

From 9be65f0be80b79e177394ad8947472b5c345b48e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Apr 2023 14:20:10 +0800
Subject: [PATCH 2610/3374] Create 2619-array-prototype-last.js

---
 2619-array-prototype-last.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 2619-array-prototype-last.js

diff --git a/2619-array-prototype-last.js b/2619-array-prototype-last.js
new file mode 100644
index 00000000..acd8a636
--- /dev/null
+++ b/2619-array-prototype-last.js
@@ -0,0 +1,8 @@
+Array.prototype.last = function() {
+    return this.at(-1) ?? -1
+};
+
+/**
+ * const arr = [1, 2, 3];
+ * arr.last(); // 3
+ */

From 98fe4174fbfc3f33b1bd13c700bb414910e3b391 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Apr 2023 09:55:30 +0800
Subject: [PATCH 2611/3374] Update
 1595-minimum-cost-to-connect-two-groups-of-points.js

---
 ...um-cost-to-connect-two-groups-of-points.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1595-minimum-cost-to-connect-two-groups-of-points.js b/1595-minimum-cost-to-connect-two-groups-of-points.js
index 900ec1dc..48f9f7f0 100644
--- a/1595-minimum-cost-to-connect-two-groups-of-points.js
+++ b/1595-minimum-cost-to-connect-two-groups-of-points.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number[][]} cost
+ * @return {number}
+ */
+const connectTwoGroups = function(cost) {
+  const m = cost.length, n = cost[0].length, { min } = Math
+  const limit = 1 << n
+  const dp = Array.from({ length: m + 1 }, () => Array(limit).fill(Infinity))
+  const minCost = Array.from({ length: m + 1 }, () => Array(limit).fill(Infinity))
+  
+  for(let i = 0; i < m; i++) {
+    for(let mask = 0; mask < limit; mask++) {
+      let sum = 0
+      for(let j = 0; j < n; j++) {
+        if((mask >> j) & 1) {
+          sum += cost[i][j]
+        }
+      }
+      
+      minCost[i][mask] = sum
+    }
+  }
+  
+  dp[0][0] = 0
+  for(let i = 1; i <= m; i++) {
+    for(let mask = 0; mask < limit; mask++) {
+      for(let sub = mask; sub; sub = (sub - 1) & mask) {
+        dp[i][mask] = min(
+          dp[i][mask],
+          dp[i - 1][mask - sub] + minCost[i - 1][sub]
+        )
+      }
+      let tmp = Infinity
+      for(let j = 0; j < n; j++) {
+        tmp = min(tmp, cost[i - 1][j])
+      }
+      
+      dp[i][mask] = min(dp[i][mask], dp[i - 1][mask] + tmp)
+    }
+  }
+  // console.log(dp)
+  return dp[m][limit - 1]
+};
+
+// another
+
+
 /**
  * @param {number[][]} cost
  * @return {number}

From 8bf7d93421e7fca6cb2edaebc629be90b3b2620d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 24 Apr 2023 10:04:40 +0800
Subject: [PATCH 2612/3374] Update
 1595-minimum-cost-to-connect-two-groups-of-points.js

---
 1595-minimum-cost-to-connect-two-groups-of-points.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/1595-minimum-cost-to-connect-two-groups-of-points.js b/1595-minimum-cost-to-connect-two-groups-of-points.js
index 48f9f7f0..43e3d060 100644
--- a/1595-minimum-cost-to-connect-two-groups-of-points.js
+++ b/1595-minimum-cost-to-connect-two-groups-of-points.js
@@ -6,7 +6,7 @@ const connectTwoGroups = function(cost) {
   const m = cost.length, n = cost[0].length, { min } = Math
   const limit = 1 << n
   const dp = Array.from({ length: m + 1 }, () => Array(limit).fill(Infinity))
-  const minCost = Array.from({ length: m + 1 }, () => Array(limit).fill(Infinity))
+  const subCost = Array.from({ length: m + 1 }, () => Array(limit).fill(Infinity))
   
   for(let i = 0; i < m; i++) {
     for(let mask = 0; mask < limit; mask++) {
@@ -17,7 +17,7 @@ const connectTwoGroups = function(cost) {
         }
       }
       
-      minCost[i][mask] = sum
+      subCost[i][mask] = sum
     }
   }
   
@@ -27,7 +27,7 @@ const connectTwoGroups = function(cost) {
       for(let sub = mask; sub; sub = (sub - 1) & mask) {
         dp[i][mask] = min(
           dp[i][mask],
-          dp[i - 1][mask - sub] + minCost[i - 1][sub]
+          dp[i - 1][mask - sub] + subCost[i - 1][sub]
         )
       }
       let tmp = Infinity

From e43fd5d75636dce6135d4f5c3bfad6d6f9487f45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Apr 2023 12:33:06 +0800
Subject: [PATCH 2613/3374] Create 2397-maximum-rows-covered-by-columns.js

---
 2397-maximum-rows-covered-by-columns.js | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 2397-maximum-rows-covered-by-columns.js

diff --git a/2397-maximum-rows-covered-by-columns.js b/2397-maximum-rows-covered-by-columns.js
new file mode 100644
index 00000000..2bf39ffe
--- /dev/null
+++ b/2397-maximum-rows-covered-by-columns.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[][]} matrix
+ * @param {number} numSelect
+ * @return {number}
+ */
+const maximumRows = function(matrix, numSelect) {
+  const m = matrix.length, n = matrix[0].length
+  const limit = 1 << n
+  
+  let res = 0
+  
+  for(let mask = 1; mask < limit; mask++) {
+    if(bitCnt(mask) > numSelect) continue
+    const set = new Set()
+    for(let i = 0; i < n; i++) {
+      if(mask & (1 << i)) {
+        set.add(n - 1 - i)
+      }
+    }
+    let num = 0
+    for(let i = 0; i < m; i++) {
+      let mark = true
+      for(let j = 0; j < n; j++) {
+        if(matrix[i][j] === 1 && !set.has(j)) {
+          mark = false
+          break
+        }
+      }
+      if(mark) num++
+    }
+    res = Math.max(res, num)
+  }
+  
+  return res
+  
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      num = num & (num - 1)
+      res++
+    }
+    return res
+  }
+};

From 06c7bc2affe2d0f951de05a92949f3d2b0e67f30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Apr 2023 12:48:22 +0800
Subject: [PATCH 2614/3374] Update 2397-maximum-rows-covered-by-columns.js

---
 2397-maximum-rows-covered-by-columns.js | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/2397-maximum-rows-covered-by-columns.js b/2397-maximum-rows-covered-by-columns.js
index 2bf39ffe..8d2e4f5d 100644
--- a/2397-maximum-rows-covered-by-columns.js
+++ b/2397-maximum-rows-covered-by-columns.js
@@ -11,17 +11,11 @@ const maximumRows = function(matrix, numSelect) {
   
   for(let mask = 1; mask < limit; mask++) {
     if(bitCnt(mask) > numSelect) continue
-    const set = new Set()
-    for(let i = 0; i < n; i++) {
-      if(mask & (1 << i)) {
-        set.add(n - 1 - i)
-      }
-    }
     let num = 0
     for(let i = 0; i < m; i++) {
       let mark = true
-      for(let j = 0; j < n; j++) {
-        if(matrix[i][j] === 1 && !set.has(j)) {
+      for(let j = n - 1; j >= 0; j--) {
+        if(matrix[i][j] === 1 && (mask & (1 << j)) === 0) {
           mark = false
           break
         }

From a8e2a5047a8b1c8e273752eb3a66c821d76389e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Apr 2023 10:59:42 +0800
Subject: [PATCH 2615/3374] Update 320-generalized-abbreviation.js

---
 320-generalized-abbreviation.js | 34 +++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/320-generalized-abbreviation.js b/320-generalized-abbreviation.js
index 016c0045..b8fc1b48 100644
--- a/320-generalized-abbreviation.js
+++ b/320-generalized-abbreviation.js
@@ -11,6 +11,40 @@ Output:
 
 */
 
+/**
+ * @param {string} word
+ * @return {string[]}
+ */
+const generateAbbreviations = function(word) {
+  const n = word.length
+  const limit = 1 << n
+  const res = []
+  
+  for(let mask = 0; mask < limit; mask++) {
+    res.push(helper(word, mask))
+  }
+  
+  return res
+  
+  function helper(word, mask) {
+    let res = '', zero = 0, idx = 0
+    for(let i = 0; i < n; i++) {
+      if(mask & (1 << i)) {
+        if(zero) res += zero
+        res += word[i]
+        zero = 0
+      } else {
+        zero++
+      }
+      if(i === n - 1 && zero) res += zero
+    }
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {string} word
  * @return {string[]}

From 4a0a99bf4ea367c8dba3ea7c1f7edb3a505644c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Apr 2023 16:04:46 +0800
Subject: [PATCH 2616/3374] Create 2626-array-reduce-transformation.js

---
 2626-array-reduce-transformation.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2626-array-reduce-transformation.js

diff --git a/2626-array-reduce-transformation.js b/2626-array-reduce-transformation.js
new file mode 100644
index 00000000..cfc6ea20
--- /dev/null
+++ b/2626-array-reduce-transformation.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {Function} fn
+ * @param {number} init
+ * @return {number}
+ */
+const reduce = function(nums, fn, init) {
+  let res = init
+  
+  for(let i = 0; i < nums.length; i++) {
+    res = fn(res, nums[i])
+  }
+  
+  return res
+};

From b7b9bae155d0957bf7dfb996a81cb9039bcd9a33 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Apr 2023 16:08:24 +0800
Subject: [PATCH 2617/3374] Create 2627-debounce.js

---
 2627-debounce.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2627-debounce.js

diff --git a/2627-debounce.js b/2627-debounce.js
new file mode 100644
index 00000000..15d16dfb
--- /dev/null
+++ b/2627-debounce.js
@@ -0,0 +1,21 @@
+/**
+ * @param {Function} fn
+ * @param {number} t milliseconds
+ * @return {Function}
+ */
+const debounce = function(fn, t) {
+  let timer = null
+    return function(...args) {
+        clearTimeout(timer)
+      timer = setTimeout(() => {
+        fn(...args)
+      }, t)
+    }
+};
+
+/**
+ * const log = debounce(console.log, 100);
+ * log('Hello'); // cancelled
+ * log('Hello'); // cancelled
+ * log('Hello'); // Logged at t=100ms
+ */

From e3539482ef4509f68bf94357e6c28d94d8e21f52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Apr 2023 16:11:48 +0800
Subject: [PATCH 2618/3374] Create 2632-curry.js

---
 2632-curry.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2632-curry.js

diff --git a/2632-curry.js b/2632-curry.js
new file mode 100644
index 00000000..10272274
--- /dev/null
+++ b/2632-curry.js
@@ -0,0 +1,16 @@
+/**
+ * @param {Function} fn
+ * @return {Function}
+ */
+const curry = function(fn) {
+  return function curried(...args) {
+    if(args.length >= fn.length) return fn(...args)
+    return (...params) => curried(...args, ...params)
+  };
+};
+
+/**
+ * function sum(a, b) { return a + b; }
+ * const csum = curry(sum);
+ * csum(1)(2) // 3
+ */

From 9b39c5709dcf699e4772576b9246ee999b0c3e4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Apr 2023 12:03:53 +0800
Subject: [PATCH 2619/3374] Create 2381-shifting-letters-ii.js

---
 2381-shifting-letters-ii.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2381-shifting-letters-ii.js

diff --git a/2381-shifting-letters-ii.js b/2381-shifting-letters-ii.js
new file mode 100644
index 00000000..630d5b58
--- /dev/null
+++ b/2381-shifting-letters-ii.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {number[][]} shifts
+ * @return {string}
+ */
+const shiftingLetters = function(s, shifts) {
+  const n = s.length
+  const arr = Array(n + 1).fill(0)
+  const a = 'a'.charCodeAt(0)
+  const chToCode = ch => ch.charCodeAt(0)
+  const codeToCh = code => String.fromCharCode(code)
+  for(const [s, e, d] of shifts) {
+    const delta = d === 1 ? 1 : -1
+    arr[s] += delta
+    arr[e + 1] -= delta
+  }
+  for(let i = 1; i < n + 1; i++) {
+    arr[i] = arr[i - 1] + arr[i]
+  }
+  const codes = s.split('').map(e => chToCode(e))
+  for(let i = 0; i < n; i++) {
+    codes[i] += arr[i]
+    codes[i] = a + (codes[i] - a + 26 * n) % 26
+  }
+  return codes.map(c => codeToCh(c)).join('')
+};

From de82905c3c7f63f297b40935ce30402973603f76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Apr 2023 13:55:27 +0800
Subject: [PATCH 2620/3374] Create 2636-promise-pool.js

---
 2636-promise-pool.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2636-promise-pool.js

diff --git a/2636-promise-pool.js b/2636-promise-pool.js
new file mode 100644
index 00000000..0c86a9cb
--- /dev/null
+++ b/2636-promise-pool.js
@@ -0,0 +1,29 @@
+/**
+ * @param {Function[]} functions
+ * @param {number} n
+ * @return {Function}
+ */
+const promisePool = async function(functions, n) {
+  const it = functions[Symbol.iterator]()
+  
+  const add = async () => {
+    const { value, done } = it.next()
+    if(value) {
+      await value()
+      await add()
+    }
+  }
+  
+  const arr = []
+  for(let i = 0; i < n; i++) {
+    arr.push(add())
+  }
+  
+  return Promise.all(arr)
+};
+
+/**
+ * const sleep = (t) => new Promise(res => setTimeout(res, t));
+ * promisePool([() => sleep(500), () => sleep(400)], 1)
+ *   .then(console.log) // After 900ms
+ */

From 5fe28f890405db45c51eab0da7b1319418d54bfa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Apr 2023 14:29:18 +0800
Subject: [PATCH 2621/3374] Create 2630-memoize-ii.js

---
 2630-memoize-ii.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2630-memoize-ii.js

diff --git a/2630-memoize-ii.js b/2630-memoize-ii.js
new file mode 100644
index 00000000..2ddb7868
--- /dev/null
+++ b/2630-memoize-ii.js
@@ -0,0 +1,36 @@
+const RES = Symbol("result");
+/**
+ * @param {Function} fn
+ */
+function memoize(fn) {
+    const globalCache = new Map();
+
+    return (...params) => {
+        let currentCache = globalCache;
+        for(const param of params) {
+            if (!currentCache.has(param)) {
+                currentCache.set(param, new Map());
+            }
+            currentCache = currentCache.get(param);
+        }
+
+        if (currentCache.has(RES)) return currentCache.get(RES);
+
+        const result = fn(...params);
+
+        currentCache.set(RES, result);
+        return result;
+    }
+}
+
+
+/** 
+ * let callCount = 0;
+ * const memoizedFn = memoize(function (a, b) {
+ *	 callCount += 1;
+ *   return a + b;
+ * })
+ * memoizedFn(2, 3) // 5
+ * memoizedFn(2, 3) // 5
+ * console.log(callCount) // 1 
+ */

From 51b6a4dda0858c8ef772c2f855b4f245dddcbfe1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Apr 2023 14:35:06 +0800
Subject: [PATCH 2622/3374] Update 2630-memoize-ii.js

---
 2630-memoize-ii.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2630-memoize-ii.js b/2630-memoize-ii.js
index 2ddb7868..93519d2b 100644
--- a/2630-memoize-ii.js
+++ b/2630-memoize-ii.js
@@ -1,4 +1,4 @@
-const RES = Symbol("result");
+const RES = Symbol("res");
 /**
  * @param {Function} fn
  */

From e2561e49aa6d958f4d3779631c7914c7e2c1b568 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 Apr 2023 11:09:07 +0800
Subject: [PATCH 2623/3374] Update
 2584-split-the-array-to-make-coprime-products.js

---
 ...split-the-array-to-make-coprime-products.js | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/2584-split-the-array-to-make-coprime-products.js b/2584-split-the-array-to-make-coprime-products.js
index da1f0171..2e438d82 100644
--- a/2584-split-the-array-to-make-coprime-products.js
+++ b/2584-split-the-array-to-make-coprime-products.js
@@ -2,20 +2,20 @@
  * @param {number[]} nums
  * @return {number}
  */
-var findValidSplit = function(nums) {
-  let n = nums.length, right = {};
+const findValidSplit = function(nums) {
+  const n = nums.length, right = {};
   for (let i = 0; i < n; i++) {
-    let primeFactorsCount = getPrimeFactors(nums[i]);
+    const primeFactorsCount = getPrimeFactors(nums[i]);
     for (let prime in primeFactorsCount) {
-      let count = primeFactorsCount[prime];
+      const count = primeFactorsCount[prime];
       right[prime] = (right[prime] || 0) + count;
     }
   }
-  let left = {}, common = new Set();
+  const left = {}, common = new Set();
   for (let i = 0; i <= n - 2; i++) {
-    let primesFactorsCount = getPrimeFactors(nums[i]);
-    for (let prime in primesFactorsCount) {
-      let count = primesFactorsCount[prime];
+    const primesFactorsCount = getPrimeFactors(nums[i]);
+    for (const prime in primesFactorsCount) {
+      const count = primesFactorsCount[prime];
       left[prime] = (left[prime] || 0) + count;
       right[prime] -= count;
       if (right[prime] > 0) common.add(prime);
@@ -27,7 +27,7 @@ var findValidSplit = function(nums) {
 };
 
 function getPrimeFactors(n) {
-  let counts = {};
+  const counts = {};
   for (let x = 2; (x * x) <= n; x++) {
     while (n % x === 0) {
       counts[x] = (counts[x] || 0) + 1;

From 0fcff71e8ab3fa830cdfba921d0fbe1df9f16927 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 28 Apr 2023 13:54:06 +0800
Subject: [PATCH 2624/3374] Update
 2584-split-the-array-to-make-coprime-products.js

---
 ...plit-the-array-to-make-coprime-products.js | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)

diff --git a/2584-split-the-array-to-make-coprime-products.js b/2584-split-the-array-to-make-coprime-products.js
index 2e438d82..3d148bc2 100644
--- a/2584-split-the-array-to-make-coprime-products.js
+++ b/2584-split-the-array-to-make-coprime-products.js
@@ -37,3 +37,72 @@ function getPrimeFactors(n) {
   if (n > 1) counts[n] = (counts[n] || 0) + 1;
   return counts;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findValidSplit = function (nums) {
+  const map = new Map()
+  const n = nums.length
+  const max = Math.max(...nums)
+  const primes = Eratosthenes(max)
+
+  for (let i = 0; i < n; i++) {
+    let x = nums[i]
+    for (const p of primes) {
+      if (p * p > x && x > 1) {
+        if (!map.has(x)) {
+          map.set(x, [i, i])
+        }
+        map.get(x)[1] = i
+        break
+      }
+
+      if (x % p === 0) {
+        if (!map.has(p)) {
+          map.set(p, [i, i])
+        }
+        const a = map.get(p)
+        a[1] = i
+      }
+      while (x % p === 0) x = x / p
+    }
+  }
+
+  const diff = Array(n + 1).fill(0)
+  for (const [k, v] of map) {
+    const [s, e] = v
+    // if(s === e) continue
+    diff[s] += 1
+    diff[e] -= 1
+  }
+  // console.log(diff)
+  let sum = 0
+  for (let i = 0; i < n - 1; i++) {
+    sum += diff[i]
+    if (sum === 0) return i
+  }
+
+  return -1
+}
+
+function Eratosthenes(n) {
+  const q = Array(n + 1).fill(0)
+  const primes = []
+  for (let i = 2; i <= Math.sqrt(n); i++) {
+    if (q[i] == 1) continue
+    let j = i * 2
+    while (j <= n) {
+      q[j] = 1
+      j += i
+    }
+  }
+  for (let i = 2; i <= n; i++) {
+    if (q[i] == 0) primes.push(i)
+  }
+  return primes
+}
+

From 541ab0a408d5f09606057d337a2915e717e0d340 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 29 Apr 2023 20:48:44 +0800
Subject: [PATCH 2625/3374] Update 2327-number-of-people-aware-of-a-secret.js

---
 2327-number-of-people-aware-of-a-secret.js | 29 ++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/2327-number-of-people-aware-of-a-secret.js b/2327-number-of-people-aware-of-a-secret.js
index 83cf4e8f..8339fb12 100644
--- a/2327-number-of-people-aware-of-a-secret.js
+++ b/2327-number-of-people-aware-of-a-secret.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number} n
+ * @param {number} delay
+ * @param {number} forget
+ * @return {number}
+ */
+const peopleAwareOfSecret = function(n, delay, forget) {
+  const dp = Array(n + 1).fill(0)
+  const mod = 1e9 + 7
+  
+  dp[1] = 1
+  for(let i = 1; i <= n; i++) {
+    for(let j = i + delay; j < i + forget; j++) {
+      if(j > n) break
+      dp[j] += dp[i]
+      dp[j] %= mod
+    }
+  }
+
+  let res = 0
+  for(let i = n - forget + 1; i <= n; i++) {
+    res = (dp[i] + res) % mod
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} delay

From c85b328a56558a172a5b6aa6e26890d8e9bec661 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Apr 2023 12:55:05 +0800
Subject: [PATCH 2626/3374] Create
 2660-determine-the-winner-of-a-bowling-game.js

---
 ...-determine-the-winner-of-a-bowling-game.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2660-determine-the-winner-of-a-bowling-game.js

diff --git a/2660-determine-the-winner-of-a-bowling-game.js b/2660-determine-the-winner-of-a-bowling-game.js
new file mode 100644
index 00000000..c51e7e18
--- /dev/null
+++ b/2660-determine-the-winner-of-a-bowling-game.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} player1
+ * @param {number[]} player2
+ * @return {number}
+ */
+var isWinner = function(player1, player2) {
+   const n =  player1.length
+   let sum1 = 0, sum2 = 0
+   // 1
+   for(let i = 0; i < n; i++) {
+     const cur = player1[i]
+     sum1 += cur
+     if( (i >= 1 && player1[i - 1] === 10) || (i >= 2 && player1[i - 2] === 10) ) {
+       sum1 += cur
+     }
+   }
+   
+   
+   // 2
+  for(let i = 0; i < n; i++) {
+     const cur = player2[i]
+     sum2 += cur
+     if( (i >= 1 && player2[i - 1] === 10) || (i >= 2 && player2[i - 2] === 10) ) {
+       sum2 += cur
+     }
+   }
+  
+   return sum1 === sum2 ? 0 : (sum1 > sum2 ? 1 : 2)
+};

From 1ab5d0e6b447662b91bfa3189e8ce5bc43e397d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Apr 2023 12:55:32 +0800
Subject: [PATCH 2627/3374] Create
 2661-first-completely-painted-row-or-column.js

---
 ...-first-completely-painted-row-or-column.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2661-first-completely-painted-row-or-column.js

diff --git a/2661-first-completely-painted-row-or-column.js b/2661-first-completely-painted-row-or-column.js
new file mode 100644
index 00000000..373ccd52
--- /dev/null
+++ b/2661-first-completely-painted-row-or-column.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} arr
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const firstCompleteIndex = function(arr, mat) {
+  const map = new Map()
+  const m = mat.length, n = mat[0].length
+  
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      map.set(mat[i][j], [i, j])
+    }
+  }
+  
+  const rows = Array(m).fill(0)
+  const cols = Array(n).fill(0)
+  
+  for(let i = 0; i < m * n; i++) {
+    const e = arr[i]
+    const [r, c] = map.get(e)
+    rows[r]++
+    cols[c]++
+    // console.log(r, c, rows, cols, m, n)
+    if(rows[r] === n) return i
+    if(cols[c] === m) return i
+  }
+  
+};

From 1f67111e9fd8c26719e281da61b81d9c85113d3b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Apr 2023 21:31:25 +0800
Subject: [PATCH 2628/3374] Update 253-meeting-rooms-ii.js

---
 253-meeting-rooms-ii.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/253-meeting-rooms-ii.js b/253-meeting-rooms-ii.js
index 61a6a0db..fb5d5915 100644
--- a/253-meeting-rooms-ii.js
+++ b/253-meeting-rooms-ii.js
@@ -15,6 +15,27 @@ Output: 1
  
  */
 
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const minMeetingRooms = function(intervals) {
+  const arr = Array(1e6 + 2).fill(0)
+  for(const [s, e] of intervals) {
+    arr[s]++
+    arr[e]--
+  }
+  let res = arr[0]
+  for(let i = 1; i < arr.length; i++) {
+    arr[i] += arr[i - 1]
+    res = Math.max(res, arr[i])
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} intervals
  * @return {number}

From 447cf7165648ff1147401e3b664e5ff73bf873b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Apr 2023 21:52:12 +0800
Subject: [PATCH 2629/3374] Create
 2662-minimum-cost-of-a-path-with-special-roads.js

---
 ...nimum-cost-of-a-path-with-special-roads.js | 127 ++++++++++++++++++
 1 file changed, 127 insertions(+)
 create mode 100644 2662-minimum-cost-of-a-path-with-special-roads.js

diff --git a/2662-minimum-cost-of-a-path-with-special-roads.js b/2662-minimum-cost-of-a-path-with-special-roads.js
new file mode 100644
index 00000000..b1e7bb8c
--- /dev/null
+++ b/2662-minimum-cost-of-a-path-with-special-roads.js
@@ -0,0 +1,127 @@
+/**
+ * @param {number[]} start
+ * @param {number[]} target
+ * @param {number[][]} specialRoads
+ * @return {number}
+ */
+var minimumCost = function (start, target, specialRoads) {
+  const INF = 1e9 + 10
+  let n = specialRoads.length
+  const { abs, min, max } = Math
+
+  // Initialize the distance of each special road to infinity
+  const d = Array(n).fill(INF)
+
+  // Create a priority queue and push the distance from start to each special road
+  const pq = new PQ((a, b) => a[0] < b[0])
+  for (let i = 0; i < n; i++) {
+    d[i] =
+      abs(start[0] - specialRoads[i][0]) +
+      abs(start[1] - specialRoads[i][1]) +
+      specialRoads[i][4]
+    pq.push([d[i], i])
+  }
+
+  // Initialize the answer with the manhattan distance between start and target
+  let ans = abs(start[0] - target[0]) + abs(start[1] - target[1])
+
+  // Continue to search for the shortest path until the priority queue is empty
+  while (pq.size()) {
+    // Pop the pair with smallest distance
+    let [d_c, c] = pq.pop()
+
+    // If the distance stored in d is not equal to the current distance d_c, skip this node
+    if (d_c != d[c]) continue
+
+    // Update the answer by finding the distance from the current special road to the target
+    ans = min(
+      ans,
+      d_c +
+        abs(target[0] - specialRoads[c][2]) +
+        abs(target[1] - specialRoads[c][3])
+    )
+
+    // For each special road that can be reached from the current special road, update its distance
+    for (let nxt = 0; nxt < n; nxt++) {
+      let w =
+        abs(specialRoads[c][2] - specialRoads[nxt][0]) +
+        abs(specialRoads[c][3] - specialRoads[nxt][1]) +
+        specialRoads[nxt][4]
+      if (d_c + w < d[nxt]) {
+        d[nxt] = d_c + w
+        pq.push([d[nxt], nxt])
+      }
+    }
+  }
+
+  // Return the minimum cost of reaching the target
+  return ans
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From c98b4ac4e51265322747826c9bb8a0f24e49a447 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 May 2023 13:11:09 +0800
Subject: [PATCH 2630/3374] Update 630-course-schedule-iii.js

---
 630-course-schedule-iii.js | 93 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/630-course-schedule-iii.js b/630-course-schedule-iii.js
index c4366e57..b2f0f289 100644
--- a/630-course-schedule-iii.js
+++ b/630-course-schedule-iii.js
@@ -20,6 +20,99 @@ const scheduleCourse = function (courses) {
 
 // another
 
+/**
+ * @param {number[][]} courses
+ * @return {number}
+ */
+const scheduleCourse = function(courses) {
+  const pq = new PQ((a, b) => a[0] === b[0] ? a[1] < b[1] : a[0] > b[0])
+  const n = courses.length
+  courses.sort((a, b) => a[1] === b[1] ? a[0] - b[0] : a[1] - b[1])
+  
+  let time = 0
+  for(const e of courses) {
+    const [dur, end] = e
+    time += dur
+    pq.push(e)
+    if(time > end) {
+      const tmp = pq.pop()
+      time -= tmp[0]
+    }
+  }
+  
+  return pq.size()
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 
 /**
  * @param {number[][]} courses

From a5869f3447b937a1b42549d8763b91d8071bb134 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 May 2023 13:00:27 +0800
Subject: [PATCH 2631/3374] Update 299-bulls-and-cows.js

---
 299-bulls-and-cows.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/299-bulls-and-cows.js b/299-bulls-and-cows.js
index 6acc441a..dd67443e 100644
--- a/299-bulls-and-cows.js
+++ b/299-bulls-and-cows.js
@@ -1,3 +1,28 @@
+/**
+ * @param {string} secret
+ * @param {string} guess
+ * @return {string}
+ */
+const getHint = function(secret, guess) {
+  let x = 0, y = 0
+  const arr = Array(10).fill(0)
+  for(let i = 0; i < guess.length; i++) {
+    const ch = guess[i], e = secret[i]
+    if(secret[i] === ch) {
+      x++
+    } else {
+      if(arr[+ch] < 0) y++
+      if(arr[+e] > 0) y++
+      arr[+ch]++
+      arr[+e]--      
+    }
+  }
+
+  return `${x}A${y}B`
+};
+
+// another
+
 /**
  * @param {string} secret
  * @param {string} guess

From 715d482244929ac93ef7fc28fbbcf7186de28cf1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 May 2023 13:24:08 +0800
Subject: [PATCH 2632/3374] Create 2599-make-the-prefix-sum-non-negative.js

---
 2599-make-the-prefix-sum-non-negative.js | 88 ++++++++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 2599-make-the-prefix-sum-non-negative.js

diff --git a/2599-make-the-prefix-sum-non-negative.js b/2599-make-the-prefix-sum-non-negative.js
new file mode 100644
index 00000000..5025c1ac
--- /dev/null
+++ b/2599-make-the-prefix-sum-non-negative.js
@@ -0,0 +1,88 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const makePrefSumNonNegative = function(nums) {
+  const pq = new PQ((a, b) => a < b)
+  let sum = 0, res = 0
+  for(const e of nums) {
+    sum += e
+    if(e < 0) {
+      pq.push(e)
+      if(sum < 0) {
+        sum -= pq.pop()
+        res++
+      }
+    }
+  }
+  
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From e12aee2764c0ab888847105462fdc435c328f210 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 May 2023 12:47:17 +0800
Subject: [PATCH 2633/3374] Update 1801-number-of-orders-in-the-backlog.js

---
 1801-number-of-orders-in-the-backlog.js | 109 +++++++++++++-----------
 1 file changed, 60 insertions(+), 49 deletions(-)

diff --git a/1801-number-of-orders-in-the-backlog.js b/1801-number-of-orders-in-the-backlog.js
index b9678076..8e95f7ce 100644
--- a/1801-number-of-orders-in-the-backlog.js
+++ b/1801-number-of-orders-in-the-backlog.js
@@ -2,64 +2,75 @@
  * @param {number[][]} orders
  * @return {number}
  */
-const getNumberOfBacklogOrders = function (orders) {
-  const h0 = new PriorityQueue((a, b) => a[0] > b[0])
-  const h1 = new PriorityQueue((a, b) => a[0] < b[0])
-  const P = 10 ** 9 + 7
-  const { min } = Math
-
-  let i,
-    j,
-    i1,
-    j1,
-    ans = 0
-  for (let c of orders) {
-    i = c[0]
-    j = c[1]
-    if (c[2]) {
-      while (!h0.isEmpty() && h0.peek()[0] >= i) {
-        i1 = h0.peek()[0]
-        j1 = h0.peek()[1]
-        h0.pop()
-        if (j > j1) j -= j1
-        else {
-          j1 -= j
-          j = 0
-          if (j1) h0.push([i1, j1])
-          break
+const getNumberOfBacklogOrders = function(orders) {
+  const buyPQ = new PQ((a, b) => a[0] > b[0])
+  const sellPQ = new PQ((a, b) => a[0] < b[0])
+  const mod = 1e9 + 7
+  
+  for(const e of orders) {
+    const [p, a, o] = e
+    if(o === 0) {
+      // buy order
+      if(sellPQ.isEmpty() || sellPQ.peek()[0] > p) {
+        buyPQ.push(e)
+        continue
+      }
+      while(!sellPQ.isEmpty() && sellPQ.peek()[0] <= p && e[1]) {
+        const tmp = sellPQ.peek()
+        if(e[1] <= tmp[1]) {
+          tmp[1] -= e[1]
+          e[1] = 0
+          if(tmp[1] === 0) {
+            sellPQ.pop()
+          }
+        } else {
+          // e[1] > tmp[1]
+          sellPQ.pop()
+          e[1] -= tmp[1]
         }
       }
-      if (j) h1.push([i, j])
-    } else {
-      while (!h1.isEmpty() && h1.peek()[0] <= i) {
-        i1 = h1.peek()[0]
-        j1 = h1.peek()[1]
-        h1.pop()
-        if (j > j1) j -= j1
-        else {
-          j1 -= j
-          j = 0
-          if (j1) h1.push([i1, j1])
-          break
+      if(e[1]) {
+        buyPQ.push(e)
+      }
+    } else if(o === 1) {
+      // sell order
+      if(buyPQ.isEmpty() || buyPQ.peek()[0] < p) {
+        sellPQ.push(e)
+        continue
+      }
+      while(!buyPQ.isEmpty() && buyPQ.peek()[0] >= p && e[1]) {
+        const tmp = buyPQ.peek()
+        if(e[1] <= tmp[1]) {
+          tmp[1] -= e[1]
+          e[1] = 0
+          if(tmp[1] === 0) {
+            buyPQ.pop()
+          }
+        } else {
+          // e[1] > tmp[1]
+          buyPQ.pop()
+          e[1] -= tmp[1]
         }
       }
-      if (j) h0.push([i, j])
+      if(e[1]) {
+        sellPQ.push(e)
+      }
     }
   }
-  while (!h0.isEmpty()) {
-    ans += h0.peek()[1]
-    h0.pop()
-    if (ans >= P) ans -= P
+  
+  let res = 0
+  
+  while(!buyPQ.isEmpty()) {
+    res = (res + buyPQ.pop()[1]) % mod
   }
-  while (!h1.isEmpty()) {
-    ans += h1.peek()[1]
-    h1.pop()
-    if (ans >= P) ans -= P
+  while(!sellPQ.isEmpty()) {
+    res = (res + sellPQ.pop()[1]) % mod
   }
-  return ans
-}
+  
+  return res % mod
+};
 
-class PriorityQueue {
+class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []
     this.top = 0

From 933d48e5503a2ad4b2c8e52d1f7146896e1d1545 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 May 2023 12:01:08 +0800
Subject: [PATCH 2634/3374] Create 2670-find-the-distinct-difference-array.js

---
 2670-find-the-distinct-difference-array.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2670-find-the-distinct-difference-array.js

diff --git a/2670-find-the-distinct-difference-array.js b/2670-find-the-distinct-difference-array.js
new file mode 100644
index 00000000..4148bf6c
--- /dev/null
+++ b/2670-find-the-distinct-difference-array.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const distinctDifferenceArray = function(nums) {
+  const res = []
+  
+  for(let i = 0, n = nums.length; i < n; i++) {
+    const pre = nums.slice(0, i + 1), suf = nums.slice(i + 1)
+    res[i] = new Set(pre).size - new Set(suf).size
+  }
+  
+  return res
+};

From c4d1d7fb92a17057131b1df12d067160dc5099f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 May 2023 12:01:35 +0800
Subject: [PATCH 2635/3374] Create 2671-frequency-tracker.js

---
 2671-frequency-tracker.js | 51 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2671-frequency-tracker.js

diff --git a/2671-frequency-tracker.js b/2671-frequency-tracker.js
new file mode 100644
index 00000000..74362ddb
--- /dev/null
+++ b/2671-frequency-tracker.js
@@ -0,0 +1,51 @@
+let cnt = {}, freq = {} 
+var FrequencyTracker = function() {
+    cnt = {}
+    freq = {}
+};
+
+/** 
+ * @param {number} number
+ * @return {void}
+ */
+FrequencyTracker.prototype.add = function(number) {
+    const c = cnt[number] ?? 0
+    if(cnt[number] == null) cnt[number] = 0
+    if(freq[c] == null) freq[c] = 0
+    --freq[cnt[number]];
+    if(cnt[number] == null)  cnt[number] = 0
+    ++cnt[number];
+    if(freq[cnt[number]] == null) freq[cnt[number]] = 0
+    ++freq[cnt[number]];
+};
+
+/** 
+ * @param {number} number
+ * @return {void}
+ */
+FrequencyTracker.prototype.deleteOne = function(number) {
+        if(cnt[number] == null) cnt[number] = 0
+        if (cnt[number] > 0) {
+            if(freq[cnt[number]] == null) freq[cnt[number]] = 0
+            --freq[cnt[number]];
+            --cnt[number];
+            if(freq[cnt[number]] == null) freq[cnt[number]] = 0
+            ++freq[cnt[number]];
+        }
+};
+
+/** 
+ * @param {number} frequency
+ * @return {boolean}
+ */
+FrequencyTracker.prototype.hasFrequency = function(frequency) {
+   return freq[frequency] > 0;
+};
+
+/** 
+ * Your FrequencyTracker object will be instantiated and called as such:
+ * var obj = new FrequencyTracker()
+ * obj.add(number)
+ * obj.deleteOne(number)
+ * var param_3 = obj.hasFrequency(frequency)
+ */

From 24436279ee7df7dd0f8b304150f87388a8364d02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 May 2023 12:02:03 +0800
Subject: [PATCH 2636/3374] Create
 2672-number-of-adjacent-elements-with-the-same-color.js

---
 ...f-adjacent-elements-with-the-same-color.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2672-number-of-adjacent-elements-with-the-same-color.js

diff --git a/2672-number-of-adjacent-elements-with-the-same-color.js b/2672-number-of-adjacent-elements-with-the-same-color.js
new file mode 100644
index 00000000..241889da
--- /dev/null
+++ b/2672-number-of-adjacent-elements-with-the-same-color.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} n
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var colorTheArray = function(n, queries) {
+    let color = {};
+    let ans = [];
+    let cnt = 0;
+    for (const q of queries) {
+        if (get(color, q[0])!=q[1]) {
+            if (get(color, q[0])!=0){
+                if (get(color, q[0]-1) == get(color, q[0])) --cnt;
+                if (get(color, q[0]+1) == get(color, q[0])) --cnt;
+            }
+            color[q[0]]=q[1];
+            if (get(color, q[0]-1) == color[q[0]]) ++cnt;
+            if (get(color, q[0]+1) == color[q[0]]) ++cnt;
+        }
+        ans.push(cnt);
+    }
+    return ans;
+
+   function get(hash, key) {
+     return hash[key] == null ? 0 : hash[key]
+   }
+};

From b99135e4efbb99dbc871ca3f6c91a53eec468c51 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 May 2023 12:02:36 +0800
Subject: [PATCH 2637/3374] Create
 2673-make-costs-of-paths-equal-in-a-binary-tree.js

---
 ...-make-costs-of-paths-equal-in-a-binary-tree.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2673-make-costs-of-paths-equal-in-a-binary-tree.js

diff --git a/2673-make-costs-of-paths-equal-in-a-binary-tree.js b/2673-make-costs-of-paths-equal-in-a-binary-tree.js
new file mode 100644
index 00000000..fecb6c46
--- /dev/null
+++ b/2673-make-costs-of-paths-equal-in-a-binary-tree.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} n
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minIncrements = function(n, cost) {
+  let ans = 0;
+  const {abs, max} = Math
+  for (let i = n >> 1; i > 0; ) {
+      let r = i<<1, l = r-1;
+      ans += abs(cost[l]-cost[r]);
+      cost[--i] += max(cost[l], cost[r]);
+  }
+  return ans;
+};

From cb1d152097d32098a7784079e306393951d259b7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 May 2023 12:01:15 +0800
Subject: [PATCH 2638/3374] Update 1882-process-tasks-using-servers.js

---
 1882-process-tasks-using-servers.js | 109 ++++++++++++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/1882-process-tasks-using-servers.js b/1882-process-tasks-using-servers.js
index 311fafc7..db62a07e 100644
--- a/1882-process-tasks-using-servers.js
+++ b/1882-process-tasks-using-servers.js
@@ -1,3 +1,112 @@
+/**
+ * @param {number[]} servers
+ * @param {number[]} tasks
+ * @return {number[]}
+ */
+const assignTasks = function(servers, tasks) {
+  const avail = new PQ((a, b) => a[0] === b[0] ? a[1] < b[1] : a[0] < b[0])
+  const busy = new PQ((a, b) => a[2] < b[2])
+  const res = []
+  const { max } = Math
+  // init
+  for(let i = 0, len = servers.length; i < len; i++) {
+    avail.push([servers[i], i, 0])
+  }
+  
+  for(let i = 0, len = tasks.length; i < len; i++) {
+    while(!busy.isEmpty() && busy.peek()[2] <= i) {
+      const s = busy.pop()
+      s[2] = i
+      avail.push(s)
+    }
+    if(!avail.isEmpty()) {
+      const s = avail.pop()
+      res.push(s[1])
+      busy.push([s[0], s[1], max(i, s[2]) + tasks[i]])
+    } else {
+      const tmp = busy.peek()
+      while(!busy.isEmpty() && busy.peek()[2] === tmp[2]) {
+        avail.push(busy.pop())
+      }
+      const s = avail.pop()
+      res.push(s[1])
+      busy.push([s[0], s[1], max(i, s[2]) + tasks[i]])
+    }
+  }
+  
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[]} servers
  * @param {number[]} tasks

From 3d88f03aa7cbcab9e75fe12c37cdffd16c27a035 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 May 2023 13:29:42 +0800
Subject: [PATCH 2639/3374] Update
 1942-the-number-of-the-smallest-unoccupied-chair.js

---
 ...number-of-the-smallest-unoccupied-chair.js | 105 ++++++++++++++++++
 1 file changed, 105 insertions(+)

diff --git a/1942-the-number-of-the-smallest-unoccupied-chair.js b/1942-the-number-of-the-smallest-unoccupied-chair.js
index 65b9cd46..aeeafb99 100644
--- a/1942-the-number-of-the-smallest-unoccupied-chair.js
+++ b/1942-the-number-of-the-smallest-unoccupied-chair.js
@@ -1,3 +1,108 @@
+/**
+ * @param {number[][]} times
+ * @param {number} targetFriend
+ * @return {number}
+ */
+const smallestChair = function(times, targetFriend) {
+  const avail = new PQ((a, b) => a[0] < b[0])
+  const occupied = new PQ((a, b) => a[1] < b[1])
+  const n = times.length
+  for(let i = 0; i < n; i++) {
+    avail.push([i, 0])
+  }
+  times.forEach((e, i) => e.push(i))
+  times.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  
+  for(let i = 0; i < n; i++) {
+    let res = -1
+    const [s, e, idx] = times[i]
+    while(!occupied.isEmpty() && occupied.peek()[1] <= s) {
+      const tmp = occupied.pop()
+      tmp[1] = s
+      avail.push(tmp)
+    }
+    
+    const c = avail.pop()
+    res = c[0]
+    c[1] = e
+    occupied.push(c)
+    
+    if(idx === targetFriend) {
+      return res
+    }
+  }
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} times
  * @param {number} targetFriend

From 301e17004693118b6a67cd207202077c9fe0d721 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 May 2023 13:48:59 +0800
Subject: [PATCH 2640/3374] Update
 1942-the-number-of-the-smallest-unoccupied-chair.js

---
 1942-the-number-of-the-smallest-unoccupied-chair.js | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/1942-the-number-of-the-smallest-unoccupied-chair.js b/1942-the-number-of-the-smallest-unoccupied-chair.js
index aeeafb99..0876ec69 100644
--- a/1942-the-number-of-the-smallest-unoccupied-chair.js
+++ b/1942-the-number-of-the-smallest-unoccupied-chair.js
@@ -17,9 +17,7 @@ const smallestChair = function(times, targetFriend) {
     let res = -1
     const [s, e, idx] = times[i]
     while(!occupied.isEmpty() && occupied.peek()[1] <= s) {
-      const tmp = occupied.pop()
-      tmp[1] = s
-      avail.push(tmp)
+      avail.push(occupied.pop())
     }
     
     const c = avail.pop()

From e823c8115287b7bc76e979d52064b5278f751d0f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 May 2023 11:53:30 +0800
Subject: [PATCH 2641/3374] Update 2402-meeting-rooms-iii.js

---
 2402-meeting-rooms-iii.js | 113 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 113 insertions(+)

diff --git a/2402-meeting-rooms-iii.js b/2402-meeting-rooms-iii.js
index aa3ab2fc..22d0bf36 100644
--- a/2402-meeting-rooms-iii.js
+++ b/2402-meeting-rooms-iii.js
@@ -1,3 +1,116 @@
+/**
+ * @param {number} n
+ * @param {number[][]} meetings
+ * @return {number}
+ */
+const mostBooked = function(n, meetings) {
+  const rooms = Array(n).fill(0)
+  const busy = new PQ((a, b) => a[1] === b[1] ? a[0] < b[0] : a[1] < b[1])
+  const avail = new PQ((a, b) => a[0] < b[0])
+  for(let i = 0; i < n; i++) {
+    avail.push([i, 0])
+  }
+  meetings.sort((a, b) => a[0] - b[0])
+  
+  for(let i = 0, len = meetings.length; i < len; i++) {
+    const [s, e] = meetings[i]
+    while(!busy.isEmpty() && busy.peek()[1] <= s) {
+      avail.push(busy.pop())
+    }
+    if(!avail.isEmpty()) {
+      const r = avail.pop()
+      r[1] = e
+      rooms[r[0]]++
+      busy.push(r)
+    } else {
+      const r = busy.pop()
+      r[1] += e - s
+      rooms[r[0]]++
+      busy.push(r)
+    }
+  }
+  let res = 0
+  // console.log(meetings.length, rooms)
+  const maxNum = Math.max(...rooms)
+  for(let i = 0; i < n; i++) {
+    if(rooms[i] === maxNum) {
+      res = i
+      break
+    }
+  }
+  return res
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} meetings

From e33f458e2701689448d037786d98c0ef7bde9e9e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 May 2023 12:08:16 +0800
Subject: [PATCH 2642/3374] Update 2102-sequentially-ordinal-rank-tracker.js

---
 2102-sequentially-ordinal-rank-tracker.js | 110 ++++++++++++++++++++++
 1 file changed, 110 insertions(+)

diff --git a/2102-sequentially-ordinal-rank-tracker.js b/2102-sequentially-ordinal-rank-tracker.js
index 745f2173..3e2f8c83 100644
--- a/2102-sequentially-ordinal-rank-tracker.js
+++ b/2102-sequentially-ordinal-rank-tracker.js
@@ -1,3 +1,113 @@
+const maxFn = (a, b) => a.score === b.score ? a.name < b.name : a.score > b.score
+const minFn = (a, b) => a.score === b.score ? a.name > b.name : a.score < b.score
+const SORTracker = function() {
+  this.maxPQ = new PQ(maxFn)
+  this.minPQ = new PQ(minFn)
+  this.idx = 0
+};
+
+/** 
+ * @param {string} name 
+ * @param {number} score
+ * @return {void}
+ */
+SORTracker.prototype.add = function(name, score) {
+  this.maxPQ.push({name, score})
+};
+
+/**
+ * @return {string}
+ */
+SORTracker.prototype.get = function() {
+  if(this.idx) {
+    this.minPQ.push(this.maxPQ.pop())
+    while(maxFn(this.maxPQ.peek(), this.minPQ.peek())) {
+      const tmp = this.minPQ.pop()
+      this.minPQ.push(this.maxPQ.pop())
+      this.maxPQ.push(tmp)
+    }
+  }
+  this.idx++
+  return this.maxPQ.peek().name
+};
+
+/** 
+ * Your SORTracker object will be instantiated and called as such:
+ * var obj = new SORTracker()
+ * obj.add(name,score)
+ * var param_2 = obj.get()
+ */
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 const maxComp = (a, b) => {
   return a[1] === b[1] ? b[0].localeCompare(a[0]) > 0 : a[1] > b[1]
 }

From 7f25f44e3348339677d7e9ca3226b1ba7f2b24fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 May 2023 11:40:36 +0800
Subject: [PATCH 2643/3374] Update 2653-sliding-subarray-beauty.js

---
 2653-sliding-subarray-beauty.js | 42 +++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2653-sliding-subarray-beauty.js b/2653-sliding-subarray-beauty.js
index 89080175..0450dda7 100644
--- a/2653-sliding-subarray-beauty.js
+++ b/2653-sliding-subarray-beauty.js
@@ -1,3 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} x
+ * @return {number[]}
+ */
+const getSubarrayBeauty = function(nums, k, x) {
+  const arr = Array(101).fill(0)
+  const res = [], n = nums.length, delta = 50
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    const idx = cur + delta
+    arr[idx]++
+    if(i < k - 1) continue
+    else if(i === k - 1) res.push(helper())
+    else {
+      const prev = nums[i - k]
+      arr[prev + delta]--
+      res.push(helper())
+    }
+  }
+  
+  return res
+  
+  function helper() {
+    let res = 0, neg = 0
+    // -50 ---> 0
+    // -1  ---> 49
+    for(let i = 0, len = arr.length; i < len; i++) {
+      if(i < delta && arr[i] > 0) neg += arr[i]
+      if(neg >= x) {
+        res = i - delta
+        break
+      }
+    }
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From cfdd85244fe5337d4c9acdd51921da406297a6ff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 May 2023 11:28:07 +0800
Subject: [PATCH 2644/3374] Update 715-range-module.js

---
 715-range-module.js | 96 +++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)

diff --git a/715-range-module.js b/715-range-module.js
index abeb83e4..4c193227 100644
--- a/715-range-module.js
+++ b/715-range-module.js
@@ -1,3 +1,99 @@
+
+const RangeModule = function() {
+  this.st = new SegmentTree();
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.addRange = function(left, right) {
+  this.st.add(left, right);
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right
+ * @return {boolean}
+ */
+RangeModule.prototype.queryRange = function(left, right) {
+  return this.st.query(left, right);
+};
+
+/** 
+ * @param {number} left 
+ * @param {number} right
+ * @return {void}
+ */
+RangeModule.prototype.removeRange = function(left, right) {
+  this.st.remove(left, right);
+};
+
+/** 
+ * Your RangeModule object will be instantiated and called as such:
+ * var obj = new RangeModule()
+ * obj.addRange(left,right)
+ * var param_2 = obj.queryRange(left,right)
+ * obj.removeRange(left,right)
+ */
+class SegNode {
+  constructor(l, r, state) {
+    this.l = l;
+    this.r = r;
+    this.state = state;
+    this.left = null;
+    this.right = null; 
+  }
+}
+
+function SegmentTree() {
+    let root = new SegNode(0, 1e9, false);
+    return { update, query, add, remove }
+    function update(node, l, r, state) {
+        if (l <= node.l && r >= node.r) {
+            node.state = state;
+            node.left = null;
+            node.right = null;
+            return node.state;
+        }
+        if (l >= node.r || r <= node.l) return node.state;
+        let mid = node.l + parseInt((node.r - node.l) / 2);
+        if (node.left == null) {
+            node.left = new SegNode(node.l, mid, node.state);
+            node.right = new SegNode(mid, node.r, node.state);
+        }
+        let left = update(node.left, l, r, state);
+        let right = update(node.right, l, r, state);
+        node.state = left && right;
+        return node.state;
+    }
+    function query(l, r) {
+        return dfs(root, l, r);
+    }
+    function dfs(node, l, r) {
+        if (l >= node.r || r <= node.l) return true;
+        if ((l <= node.l && r >= node.r) || (node.left == null)) return node.state;
+        let mid = node.l + parseInt((node.r - node.l) / 2);
+        if (r <= mid) {
+            return dfs(node.left, l, r);
+        } else if (l >= mid) {
+            return dfs(node.right, l, r);
+        } else {
+            return dfs(node.left, l, r) && dfs(node.right, l, r);
+        }
+    }
+    function add(l, r) {
+        update(root, l, r, true);
+    }
+    function remove(l, r) {
+        update(root, l, r, false);
+    }
+}
+
+
+// another
+
 const RangeModule = function() {
   this.range = []
 }

From a423ecec46229903ae1280d5c937f488f3ac005e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 May 2023 11:17:42 +0800
Subject: [PATCH 2645/3374] Create 2382-maximum-segment-sum-after-removals.js

---
 2382-maximum-segment-sum-after-removals.js | 29 ++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2382-maximum-segment-sum-after-removals.js

diff --git a/2382-maximum-segment-sum-after-removals.js b/2382-maximum-segment-sum-after-removals.js
new file mode 100644
index 00000000..83269863
--- /dev/null
+++ b/2382-maximum-segment-sum-after-removals.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} removeQueries
+ * @return {number[]}
+ */
+const maximumSegmentSum = function(nums, removeQueries) {
+  const INF = Infinity, n = nums.length
+  const res = Array(n).fill(0) 
+  const ds = Array(n).fill(INF);
+  for (let i = n - 1; i > 0; --i) {
+    const j = removeQueries[i];
+    ds[j] = -nums[j];
+    if (j > 0 && ds[j - 1] !== INF) merge(j, j - 1, ds);
+    if (j < n - 1 && ds[j + 1] !== INF) merge(j, j + 1, ds);
+    res[i - 1] = Math.max(res[i], -ds[find(j, ds)]);
+  }
+  return res;
+};
+
+function find(i, ds) {
+  return ds[i] < 0 ? i : ds[i] = find(ds[i], ds);
+}
+
+function merge(s1, s2, ds) {
+  const p1 = find(s1, ds);
+  const p2 = find(s2, ds);
+  ds[p2] += ds[p1];
+  ds[p1] = p2;
+}

From daa82ab353215a3ee24daa11de740004cde1f690 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 May 2023 14:15:05 +0800
Subject: [PATCH 2646/3374] Update 2382-maximum-segment-sum-after-removals.js

---
 2382-maximum-segment-sum-after-removals.js | 41 +++++++++++-----------
 1 file changed, 21 insertions(+), 20 deletions(-)

diff --git a/2382-maximum-segment-sum-after-removals.js b/2382-maximum-segment-sum-after-removals.js
index 83269863..6ce1bf3e 100644
--- a/2382-maximum-segment-sum-after-removals.js
+++ b/2382-maximum-segment-sum-after-removals.js
@@ -4,26 +4,27 @@
  * @return {number[]}
  */
 const maximumSegmentSum = function(nums, removeQueries) {
-  const INF = Infinity, n = nums.length
-  const res = Array(n).fill(0) 
-  const ds = Array(n).fill(INF);
-  for (let i = n - 1; i > 0; --i) {
-    const j = removeQueries[i];
-    ds[j] = -nums[j];
-    if (j > 0 && ds[j - 1] !== INF) merge(j, j - 1, ds);
-    if (j < n - 1 && ds[j + 1] !== INF) merge(j, j + 1, ds);
-    res[i - 1] = Math.max(res[i], -ds[find(j, ds)]);
+  removeQueries.reverse()
+  const rev = removeQueries
+  const hash = {}
+  const res = []
+  let cur = 0
+  for(const idx of rev) {
+    hash[idx] = [nums[idx], 1]
+    const [lv, ll] = (hash[idx - 1] || [0, 0])
+    const [rv, rl] = (hash[idx + 1] || [0, 0])
+    
+    const val = nums[idx] + lv + rv
+    hash[idx + rl] = [val, ll + rl + 1]
+    hash[idx - ll] = [val, ll + rl + 1]
+    
+    cur = Math.max(cur, val)
+    res.push(cur)
   }
-  return res;
+  res.pop()
+  res.reverse()
+  res.push(0)
+  
+  return res
 };
 
-function find(i, ds) {
-  return ds[i] < 0 ? i : ds[i] = find(ds[i], ds);
-}
-
-function merge(s1, s2, ds) {
-  const p1 = find(s1, ds);
-  const p2 = find(s2, ds);
-  ds[p2] += ds[p1];
-  ds[p1] = p2;
-}

From d03136af0df4d51ffd3bc0075bf2975435bda01c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 May 2023 12:15:07 +0800
Subject: [PATCH 2647/3374] Create
 2556-disconnect-path-in-a-binary-matrix-by-at-most-one-flip.js

---
 ...-in-a-binary-matrix-by-at-most-one-flip.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2556-disconnect-path-in-a-binary-matrix-by-at-most-one-flip.js

diff --git a/2556-disconnect-path-in-a-binary-matrix-by-at-most-one-flip.js b/2556-disconnect-path-in-a-binary-matrix-by-at-most-one-flip.js
new file mode 100644
index 00000000..ddec85ef
--- /dev/null
+++ b/2556-disconnect-path-in-a-binary-matrix-by-at-most-one-flip.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+const isPossibleToCutPath = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const pre = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0))
+  const suf = Array.from({ length: m + 2 }, () => Array(n + 2).fill(0))
+  
+  for(let i = 1; i <= m; i++) {
+    for(let j = 1; j <= n; j++) {
+      if(i === 1 && j === 1) pre[i][j] = 1
+      else if(grid[i - 1][j - 1] === 1) {
+        pre[i][j] = pre[i - 1][j] + pre[i][j - 1]
+      }
+    }
+  }
+  
+  for(let i = m; i > 0; i--) {
+    for(let j = n; j > 0; j--) {
+      if(i === m && j === n) suf[i][j] = 1
+      else if(grid[i - 1][j - 1] === 1) {
+        suf[i][j] = suf[i + 1][j] + suf[i][j + 1]
+      }
+    }
+  }
+  // console.log(pre, suf)
+  
+  const target = pre[m][n]
+  
+  for(let i = 1; i <= m; i++) {
+    for(let j = 1; j <= n; j++) {
+      if(i === 1 && j === 1) continue
+      if(i === m && j === n) continue
+      if(pre[i][j] * suf[i][j] === target) {
+        return true
+      }
+    }
+  }
+  
+  return false
+};

From 33e2d1b3cc62282db158ade7be61212f4b4329b6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 May 2023 12:16:19 +0800
Subject: [PATCH 2648/3374] Create 2682-find-the-losers-of-the-circular-game.js

---
 2682-find-the-losers-of-the-circular-game.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2682-find-the-losers-of-the-circular-game.js

diff --git a/2682-find-the-losers-of-the-circular-game.js b/2682-find-the-losers-of-the-circular-game.js
new file mode 100644
index 00000000..27eab644
--- /dev/null
+++ b/2682-find-the-losers-of-the-circular-game.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number[]}
+ */
+var circularGameLosers = function(n, k) {
+  const set = new Set()
+  let i = 0, turn = 1
+  while(!set.has(i + 1)) {
+    set.add(i + 1)
+    i = (i + turn * k) % n
+    turn++
+  }
+  const res = []
+  for(let j = 1; j<=n;j++) {
+    if(!set.has(j)) res.push(j)
+  }
+  return res
+};

From 285a836108ff4e78ef86cb2eb6654ccc5f388862 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 May 2023 12:16:55 +0800
Subject: [PATCH 2649/3374] Create 2683-neighboring-bitwise-xor.js

---
 2683-neighboring-bitwise-xor.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2683-neighboring-bitwise-xor.js

diff --git a/2683-neighboring-bitwise-xor.js b/2683-neighboring-bitwise-xor.js
new file mode 100644
index 00000000..bf83e34c
--- /dev/null
+++ b/2683-neighboring-bitwise-xor.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} derived
+ * @return {boolean}
+ */
+var doesValidArrayExist = function(derived) {
+	let n = derived.length
+	let r1 = Array(n).fill(0)
+	for (let i = 0; i < n-1; i++) {
+		r1[i+1] = derived[i] ^ r1[i]
+	}
+	if (r1[n-1]^r1[0] == derived[n-1]) {
+		return true
+	}
+	r1[0] = 1
+	for (let i = 0; i < n-1; i++) {
+		r1[i+1] = derived[i] ^ r1[i]
+	}
+	if (r1[n-1]^r1[0] == derived[n-1]) {
+		return true
+	}
+	return false
+};

From 36518bf185db421081624ddbb69aa78cbc1860d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 May 2023 12:17:26 +0800
Subject: [PATCH 2650/3374] Create 2684-maximum-number-of-moves-in-a-grid.js

---
 2684-maximum-number-of-moves-in-a-grid.js | 39 +++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2684-maximum-number-of-moves-in-a-grid.js

diff --git a/2684-maximum-number-of-moves-in-a-grid.js b/2684-maximum-number-of-moves-in-a-grid.js
new file mode 100644
index 00000000..b3760368
--- /dev/null
+++ b/2684-maximum-number-of-moves-in-a-grid.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxMoves = function(g) {
+	let dirs = [
+		[-1, 1],
+		[0, 1],
+		[1, 1],
+	]
+  let grid = g
+	let m = grid.length, n = grid[0].length
+	let cachev1 = Array.from({ length: m }, () => Array(n).fill(null))
+  const cache = {}
+  // const m = g.length; const n = g[0].length
+  const dx = [0, -1, 1]; const dy = [1, 1, 1]
+
+  let ans = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      ans = Math.max(ans, dfs(i, j))
+    }
+  }
+  return ans
+
+  function dfs (i, j) {
+    if (cache[`${i}_${j}`]) return cache[`${i}_${j}`]
+    if (j === 0) return cache[`${i}_${j}`] = 0
+    let s = -1
+    for (let k = 0; k < 3; k++) {
+      const x = i - dx[k]; const y = j - dy[k]
+      if (x >= 0 && x < m && y >= 0 && y < n && g[i][j] > g[x][y]) {
+        s = Math.max(s, dfs(x, y))
+      }
+    }
+    if (s === -1) return cache[`${i}_${j}`] = -1
+    return cache[`${i}_${j}`] = s + 1
+  }
+};

From 935e4ed7d328aec3fa736d62244f90ad333e7180 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 May 2023 12:18:03 +0800
Subject: [PATCH 2651/3374] Create
 2685-count-the-number-of-complete-components.js

---
 ...count-the-number-of-complete-components.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2685-count-the-number-of-complete-components.js

diff --git a/2685-count-the-number-of-complete-components.js b/2685-count-the-number-of-complete-components.js
new file mode 100644
index 00000000..f13b6657
--- /dev/null
+++ b/2685-count-the-number-of-complete-components.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var countCompleteComponents = function(n, edges) {
+  const ma = Array(n).fill(0).map((_, idx) => idx)
+  const e = {}
+  for (const [x, y] of edges) {
+    e[x] ??= new Set()
+    e[x].add(y)
+    e[y] ??= new Set()
+    e[y].add(x)
+    merge(x, y)
+  }
+  const f = []; const fs = {}
+  for (let i = 0; i < n; i++) {
+    s = get(i)
+    f.push(s)
+    fs[s] ??= []
+    fs[s].push(i)
+  }
+
+  let ans = 0
+  for (const [_, t] of Object.entries(fs)) {
+    let ok = true
+    for (let i = 0; i < t.length; i++) {
+      if (!ok) break
+      for (let j = i + 1; j < t.length; j++) {
+        if (!e[t[i]].has(t[j])) {
+          ok = false
+          break
+        }
+      }
+    }
+    ans += ok
+  }
+  return ans
+  
+  function get(x) {
+    if (ma[x] === x) return x
+    return ma[x] = get(ma[x])
+  }
+  function merge (x, y) {
+    const fx = get(x); const fy = get(y)
+    ma[fx] = fy
+  }
+};

From b7205ed8084157dde67fe41f2f5dfff00bd901e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 May 2023 20:02:58 +0800
Subject: [PATCH 2652/3374] Create
 2508-add-edges-to-make-degrees-of-all-nodes-even.js

---
 ...edges-to-make-degrees-of-all-nodes-even.js | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 2508-add-edges-to-make-degrees-of-all-nodes-even.js

diff --git a/2508-add-edges-to-make-degrees-of-all-nodes-even.js b/2508-add-edges-to-make-degrees-of-all-nodes-even.js
new file mode 100644
index 00000000..f360018a
--- /dev/null
+++ b/2508-add-edges-to-make-degrees-of-all-nodes-even.js
@@ -0,0 +1,55 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean}
+ */
+const isPossible = (n, edges) => {
+  const g = initializeGraphSet(n)
+  packUG_Set(g, edges)
+  return canAddAtMost2EdgesMakeALLNodesDegreeEven(g)
+}
+
+function initializeGraphSet(n) {
+  const g = []
+  for (let i = 0; i < n; i++) {
+    g.push(new Set())
+  }
+  return g
+}
+function packUG_Set(g, edges) {
+  for (const [u, v] of edges) {
+    g[u - 1].add(v - 1)
+    g[v - 1].add(u - 1)
+  }
+}
+
+function canAddAtMost2EdgesMakeALLNodesDegreeEven(g) {
+  const oddNodes = []
+  for (let i = 0; i < g.length; i++) {
+    let deg = g[i].size
+    if (deg % 2 == 1) {
+      oddNodes.push(i)
+    }
+  }
+  if (oddNodes.length == 0) {
+    // add no edge
+    return true
+  } else if (oddNodes.length == 2) {
+    // add one edge
+    let [a, b] = oddNodes
+    for (let k = 0; k < g.length; k++) {
+      // a <-> k  b <-> k (k as transition node)
+      if (!g[a].has(k) && !g[b].has(k)) return true
+    }
+    return false
+  } else if (oddNodes.length == 4) {
+    // add two edges
+    let [a, b, c, d] = oddNodes // find two matched pairs valid
+    if (!g[a].has(b) && !g[c].has(d)) return true
+    if (!g[a].has(c) && !g[b].has(d)) return true
+    if (!g[a].has(d) && !g[c].has(b)) return true
+    return false
+  } else {
+    return false
+  }
+}

From 0a7f9c7c3ea00b0fc7d14ae1db1239975bdf1b58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 May 2023 20:25:16 +0800
Subject: [PATCH 2653/3374] Create
 2640-find-the-score-of-all-prefixes-of-an-array.js

---
 2640-find-the-score-of-all-prefixes-of-an-array.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2640-find-the-score-of-all-prefixes-of-an-array.js

diff --git a/2640-find-the-score-of-all-prefixes-of-an-array.js b/2640-find-the-score-of-all-prefixes-of-an-array.js
new file mode 100644
index 00000000..2c7a88c7
--- /dev/null
+++ b/2640-find-the-score-of-all-prefixes-of-an-array.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const findPrefixScore = function(nums) {
+  let pre = [];
+  let m = 0, s = 0;
+  for(let x of nums) {
+      m = Math.max(m, x);
+      s += x + m;
+      pre.push(s);
+  }
+  return pre;
+};

From b23360fd98594bffaffb5cda5f5e9a37ecacbc86 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 May 2023 20:28:11 +0800
Subject: [PATCH 2654/3374] Update
 2640-find-the-score-of-all-prefixes-of-an-array.js

---
 ...find-the-score-of-all-prefixes-of-an-array.js | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/2640-find-the-score-of-all-prefixes-of-an-array.js b/2640-find-the-score-of-all-prefixes-of-an-array.js
index 2c7a88c7..e07e4517 100644
--- a/2640-find-the-score-of-all-prefixes-of-an-array.js
+++ b/2640-find-the-score-of-all-prefixes-of-an-array.js
@@ -3,12 +3,14 @@
  * @return {number[]}
  */
 const findPrefixScore = function(nums) {
-  let pre = [];
-  let m = 0, s = 0;
-  for(let x of nums) {
-      m = Math.max(m, x);
-      s += x + m;
-      pre.push(s);
+  const { max } = Math
+  const res = []
+  let ma = 0, sum = 0
+  for(const e of nums) {
+    ma = max(e, ma)
+    sum += ma + e
+    res.push(sum)
   }
-  return pre;
+  
+  return res
 };

From dce73881f63bf02f20e5c5d0af0aceec19a4e1c7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 May 2023 19:33:44 +0800
Subject: [PATCH 2655/3374] Create
 2642-design-graph-with-shortest-path-calculator.js

---
 ...ign-graph-with-shortest-path-calculator.js | 79 +++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 2642-design-graph-with-shortest-path-calculator.js

diff --git a/2642-design-graph-with-shortest-path-calculator.js b/2642-design-graph-with-shortest-path-calculator.js
new file mode 100644
index 00000000..2d1a48d4
--- /dev/null
+++ b/2642-design-graph-with-shortest-path-calculator.js
@@ -0,0 +1,79 @@
+/**
+ * Your Graph object will be instantiated and called as such:
+ * var obj = new Graph(n, edges)
+ * obj.addEdge(edge)
+ * var param_2 = obj.shortestPath(node1,node2)
+ */
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ */
+const Graph = function (n, edges) {
+  this.map = new Map()
+  const map = this.map
+  for (let i = 0; i < edges.length; i++) {
+    let edge = edges[i]
+    let from = edge[0]
+    let to = edge[1]
+    let cost = edge[2]
+    if (!map.has(from)) {
+      map.set(from, new Set())
+    }
+
+    map.get(from).add({ to, cost })
+  }
+}
+
+/**
+ * @param {number[]} edge
+ * @return {void}
+ */
+Graph.prototype.addEdge = function (edge) {
+  let map = this.map
+  let from = edge[0]
+  let to = edge[1]
+  let cost = edge[2]
+  if (!map.has(from)) {
+    map.set(from, new Set())
+  }
+
+  map.get(from).add({ to, cost })
+}
+
+/**
+ * @param {number} node1
+ * @param {number} node2
+ * @return {number}
+ */
+Graph.prototype.shortestPath = function (node1, node2) {
+  const heap = new MinPriorityQueue()
+  heap.enqueue({ node: node1, cost: 0 }, 0)
+  let visited = new Set()
+
+  while (heap.size() > 0) {
+    const top = heap.dequeue().element
+
+    if (visited.has(top.node)) {
+      continue
+    }
+    visited.add(top.node)
+    if (top.node === node2) {
+      return top.cost
+    }
+    let next = this.map.get(top.node)
+    if (next) {
+      for (let n of next) {
+        heap.enqueue({ node: n.to, cost: top.cost + n.cost }, top.cost + n.cost)
+      }
+    }
+  }
+
+  return -1
+}
+
+/**
+ * Your Graph object will be instantiated and called as such:
+ * var obj = new Graph(n, edges)
+ * obj.addEdge(edge)
+ * var param_2 = obj.shortestPath(node1,node2)
+ */

From 4f373f6c215a94c2da518b46d37b20c29fd47bd3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 May 2023 12:08:56 +0800
Subject: [PATCH 2656/3374] Create 2608-shortest-cycle-in-a-graph.js

---
 2608-shortest-cycle-in-a-graph.js | 40 +++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2608-shortest-cycle-in-a-graph.js

diff --git a/2608-shortest-cycle-in-a-graph.js b/2608-shortest-cycle-in-a-graph.js
new file mode 100644
index 00000000..77057b20
--- /dev/null
+++ b/2608-shortest-cycle-in-a-graph.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const findShortestCycle = function(n, edges) {
+  let res = Infinity
+  const graph = new Map()
+  for(const [u, v] of edges) {
+    if(graph.get(u) == null) graph.set(u, [])
+    if(graph.get(v) == null) graph.set(v, [])
+    graph.get(u).push(v)
+    graph.get(v).push(u)
+  }
+  for(let i = 0; i < n; i++) {
+    bfs(i)
+  }
+  
+  if(res === Infinity) return -1
+  return res
+  
+  function bfs(src) {
+    const parent = Array(n), dis = Array(n).fill(Infinity)
+    let q = []
+    dis[src] = 0
+    q.push(src)
+    while(q.length) {
+      const node = q.shift()
+      for(const nxt of (graph.get(node) || [])) {
+        if(dis[nxt] === Infinity) {
+          dis[nxt] = dis[node] + 1
+          parent[nxt] = node
+          q.push(nxt)
+        } else if(parent[node] !== nxt && parent[nxt] !== node) {
+          res = Math.min(res, dis[nxt] + dis[node] + 1)          
+        }
+      }
+    }
+  }
+};

From 8b0eeba2b7b47f788cdfd57090cc275f58386ca8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 May 2023 13:57:38 +0800
Subject: [PATCH 2657/3374] Update 386-lexicographical-numbers.js

---
 386-lexicographical-numbers.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/386-lexicographical-numbers.js b/386-lexicographical-numbers.js
index cd11275b..d593eb57 100644
--- a/386-lexicographical-numbers.js
+++ b/386-lexicographical-numbers.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number[]}
+ */
+const lexicalOrder = function(n) {
+  const res = []
+  for(let i = 1; i < 10; i++) {
+    dfs(i)
+  }
+  
+  return res
+  
+  function dfs(num) {
+    if(num > n) return
+    res.push(num)
+    for(let i = 0; i < 10; i++) {
+      const tmp = num * 10 + i
+      if(tmp > n) return
+      dfs(tmp)
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number[]}

From a2fe75adf7d8bc1dddf6c47f1e2d1446c68b16d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 May 2023 21:02:07 +0800
Subject: [PATCH 2658/3374] Update 400-nth-digit.js

---
 400-nth-digit.js | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/400-nth-digit.js b/400-nth-digit.js
index 59e4a928..53f0f393 100644
--- a/400-nth-digit.js
+++ b/400-nth-digit.js
@@ -3,16 +3,16 @@
  * @return {number}
  */
 const findNthDigit = function(n) {
-    let start = 1
-    let len = 1
-    let base = 9
-    while(n > len * base) {
-      n = n - len * base
-      len++
-      start *= 10
-      base *= 10
-    }
-    let target = start + (n - 1) / len
-    let reminder = (n - 1) % len
-    return (''+target).charAt(reminder)
+  let start = 1
+  let len = 1
+  let base = 9
+  while(n > len * base) {
+    n = n - len * base
+    len++
+    start *= 10
+    base *= 10
+  }
+  let target = start + Math.floor((n - 1) / len)
+  let reminder = (n - 1) % len
+  return (''+target).charAt(reminder)
 };

From 09b9a7978cd294ffc97f4973f8bd06392975d5ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 May 2023 15:27:11 +0800
Subject: [PATCH 2659/3374] Update
 440-k-th-smallest-in-lexicographical-order.js

---
 440-k-th-smallest-in-lexicographical-order.js | 23 +++++++++----------
 1 file changed, 11 insertions(+), 12 deletions(-)

diff --git a/440-k-th-smallest-in-lexicographical-order.js b/440-k-th-smallest-in-lexicographical-order.js
index 0750acf5..5e6f7319 100644
--- a/440-k-th-smallest-in-lexicographical-order.js
+++ b/440-k-th-smallest-in-lexicographical-order.js
@@ -3,29 +3,28 @@
  * @param {number} k
  * @return {number}
  */
-const findKthNumber = function(n, k) {
+const findKthNumber = function (n, k) {
   let curr = 1
   k = k - 1
   while (k > 0) {
     let steps = calSteps(n, curr, curr + 1)
     if (steps <= k) {
-      curr++
+      curr += 1
       k -= steps
     } else {
       curr *= 10
-      k--
+      k -= 1
     }
   }
   return curr
-}
 
-//use long in case of overflow
-function calSteps(n, n1, n2) {
-  let steps = 0
-  while (n1 <= n) {
-    steps += Math.min(n + 1, n2) - n1
-    n1 *= 10
-    n2 *= 10
+  function calSteps(n, n1, n2) {
+    let steps = 0
+    while (n1 <= n) {
+      steps += Math.min(n + 1, n2) - n1
+      n1 *= 10
+      n2 *= 10
+    }
+    return steps
   }
-  return steps
 }

From 22b3aabc2ef02893db51b66ef05f0b6ff48a787e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 May 2023 19:51:53 +0800
Subject: [PATCH 2660/3374] Update
 440-k-th-smallest-in-lexicographical-order.js

---
 440-k-th-smallest-in-lexicographical-order.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/440-k-th-smallest-in-lexicographical-order.js b/440-k-th-smallest-in-lexicographical-order.js
index 5e6f7319..00bb38fb 100644
--- a/440-k-th-smallest-in-lexicographical-order.js
+++ b/440-k-th-smallest-in-lexicographical-order.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const findKthNumber = function (n, k) {
+  let cur = 1
+  k = k - 1
+  while(k > 0) {
+    const num = calc(cur)
+    if(num <= k) {
+      cur++
+      k -= num
+    } else {
+      k--
+      cur *= 10
+    }
+  }
+  return cur
+  
+  function calc(cur) {
+    let total = 0
+    let nxt = cur + 1
+    while(cur <= n) {
+      total += Math.min(n - cur + 1, nxt - cur)
+      nxt *= 10
+      cur *= 10
+    }
+    
+    return total
+  }
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From 15d22cd7f6d4e30181475f8506a1931de2471b4d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 May 2023 11:58:06 +0800
Subject: [PATCH 2661/3374] Update
 1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js

---
 ...string-of-all-happy-strings-of-length-n.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
index 03581889..e5568823 100644
--- a/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
+++ b/1415-the-k-th-lexicographical-string-of-all-happy-strings-of-length-n.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getHappyString = function(n, k) {
+  const hash = {a: 'bc', b: 'ac', c: 'ab'}
+  const q = ['a', 'b', 'c']
+  while(q[0].length !== n) {
+    const e = q.shift()
+    const last = e.charAt(e.length - 1)
+    for(const ch of hash[last]) {
+      q.push(e + ch)
+    }
+  }
+  if(q.length >= k && q[k - 1].length === n) {
+     return q[k - 1]
+  }
+     
+  return ''
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From fa45d419f21ddfe033772e88355a0cc124204ce4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 May 2023 17:02:51 +0800
Subject: [PATCH 2662/3374] Update 120-triangle.js

---
 120-triangle.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/120-triangle.js b/120-triangle.js
index 483942e8..6f809c2a 100644
--- a/120-triangle.js
+++ b/120-triangle.js
@@ -17,3 +17,26 @@ const minimumTotal = function(triangle) {
 
   return triangle[0][0];
 };
+
+// another
+
+/**
+ * @param {number[][]} triangle
+ * @return {number}
+ */
+const minimumTotal = function(triangle) {
+  const m = triangle.length, n = triangle.at(-1).length
+  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(Infinity))
+  dp[1][1] = triangle[0][0]
+  for(let i = 2; i <= m; i++) {
+    for(let j = 1; j <= triangle[i - 1].length; j++) {
+      if(j === 1) dp[i][j] = dp[i - 1][j] + triangle[i - 1][j - 1]
+      else dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle[i - 1][j - 1] 
+    }
+  }
+  let res = Infinity
+  for (let j = 0; j <= n; j++) {
+    res = Math.min(res, dp[m][j])
+  }
+  return res
+};

From f249742ad852e9045e32ac33e06c70b42a741a30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 May 2023 17:40:45 +0800
Subject: [PATCH 2663/3374] Create 2710-remove-trailing-zeros-from-a-string.js

---
 2710-remove-trailing-zeros-from-a-string.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2710-remove-trailing-zeros-from-a-string.js

diff --git a/2710-remove-trailing-zeros-from-a-string.js b/2710-remove-trailing-zeros-from-a-string.js
new file mode 100644
index 00000000..960926be
--- /dev/null
+++ b/2710-remove-trailing-zeros-from-a-string.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} num
+ * @return {string}
+ */
+var removeTrailingZeros = function(num) {
+    const n = num.length
+    let idx = n
+    for(let i = n - 1; i >= 0; i--) {
+      if(num[i] === '0') idx = i
+      else break
+    }
+    
+    return num.slice(0, idx)
+};

From f094dab40014d66efcb8fa5953877573f23176b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 May 2023 17:42:04 +0800
Subject: [PATCH 2664/3374] Create
 2711-difference-of-number-of-distinct-values-on-diagonals.js

---
 ...-number-of-distinct-values-on-diagonals.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 2711-difference-of-number-of-distinct-values-on-diagonals.js

diff --git a/2711-difference-of-number-of-distinct-values-on-diagonals.js b/2711-difference-of-number-of-distinct-values-on-diagonals.js
new file mode 100644
index 00000000..03cabb3d
--- /dev/null
+++ b/2711-difference-of-number-of-distinct-values-on-diagonals.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[][]}
+ */
+const differenceOfDistinctValues = function (grid) {
+  const m = grid.length,
+    n = grid[0].length,
+    { abs } = Math
+  const res = Array.from({ length: m }, () => Array(n).fill(0))
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      const bottomRight = new Set()
+      const topLeft = new Set()
+      let x = i + 1
+      let y = j + 1
+      while (x >= 0 && x < m && y >= 0 && y < n) {
+        bottomRight.add(grid[x][y])
+        x++
+        y++
+      }
+      x = i - 1
+      y = j - 1
+      while (x >= 0 && x < m && y >= 0 && y < n) {
+        topLeft.add(grid[x][y])
+        x--
+        y--
+      }
+
+      res[i][j] = abs(bottomRight.size - topLeft.size)
+    }
+  }
+  return res
+}

From 326b489866e1ffbf21dde10b6e8ba413e41146b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 May 2023 17:42:46 +0800
Subject: [PATCH 2665/3374] Create
 2712-minimum-cost-to-make-all-characters-equal.js

---
 ...nimum-cost-to-make-all-characters-equal.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2712-minimum-cost-to-make-all-characters-equal.js

diff --git a/2712-minimum-cost-to-make-all-characters-equal.js b/2712-minimum-cost-to-make-all-characters-equal.js
new file mode 100644
index 00000000..934c66bb
--- /dev/null
+++ b/2712-minimum-cost-to-make-all-characters-equal.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const minimumCost = function (s) {
+  const n = s.length,
+    { min } = Math
+  let res = Infinity
+  const dp = Array.from({ length: n + 1 }, () => Array(2).fill(0))
+  const dp1 = Array.from({ length: n + 1 }, () => Array(2).fill(0))
+  for (let i = 0; i < n; i++) {
+    if (s[i] === '0') {
+      dp[i + 1][0] = dp[i][0]
+      dp[i + 1][1] = dp[i][0] + (i + 1)
+    } else {
+      dp[i + 1][0] = dp[i][1] + (i + 1)
+      dp[i + 1][1] = dp[i][1]
+    }
+  }
+
+  for (let i = n - 1; i >= 0; i--) {
+    if (s[i] === '0') {
+      dp1[i][0] = dp1[i + 1][0]
+      dp1[i][1] = dp1[i + 1][0] + (n - i)
+    } else {
+      dp1[i][0] = dp1[i + 1][1] + (n - i)
+      dp1[i][1] = dp1[i + 1][1]
+    }
+  }
+  for (let i = 0; i <= n; i++) {
+    res = min(res, dp[i][0] + dp1[i][0], dp[i][1] + dp1[i][1])
+  }
+  return res
+}

From 4457d96e58d1e3ad12333f27d02ac90a41928afb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 May 2023 17:43:19 +0800
Subject: [PATCH 2666/3374] Create
 2713-maximum-strictly-increasing-cells-in-a-matrix.js

---
 ...m-strictly-increasing-cells-in-a-matrix.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2713-maximum-strictly-increasing-cells-in-a-matrix.js

diff --git a/2713-maximum-strictly-increasing-cells-in-a-matrix.js b/2713-maximum-strictly-increasing-cells-in-a-matrix.js
new file mode 100644
index 00000000..e033e1f7
--- /dev/null
+++ b/2713-maximum-strictly-increasing-cells-in-a-matrix.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const maxIncreasingCells = function (mat) {
+  let m = mat.length
+  let n = mat[0].length
+
+  const p = Array.from({ length: m * n }, () => Array(2).fill(0))
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      p[i * n + j][0] = i
+      p[i * n + j][1] = j
+    }
+  }
+  p.sort((a, b) => mat[a[0]][a[1]] - mat[b[0]][b[1]])
+
+  let rmax = new Array(m).fill(0)
+
+  let cmax = new Array(n).fill(0)
+  let ans = 0
+  let start = 0,
+    end = 0
+  for (; start < m * n; start = end) {
+    let sv = mat[p[start][0]][p[start][1]]
+
+    for (end = start + 1; end < m * n; end++) {
+      if (sv != mat[p[end][0]][p[end][1]]) {
+        break
+      }
+    }
+
+    let list = []
+    for (let t = start; t < end; t++) {
+      let i = p[t][0],
+        j = p[t][1]
+      let max = Math.max(rmax[i], cmax[j]) + 1
+      list.push([i, j, max])
+      ans = Math.max(ans, max)
+    }
+    for (let ints of list) {
+      let i = ints[0],
+        j = ints[1],
+        max = ints[2]
+      rmax[i] = Math.max(rmax[i], max)
+      cmax[j] = Math.max(cmax[j], max)
+    }
+  }
+  return ans
+}

From d7a71e146f1755e8b28d36a230812ee505f56b54 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 May 2023 22:45:13 +0800
Subject: [PATCH 2667/3374] Update 31-next-permutation.js

---
 31-next-permutation.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/31-next-permutation.js b/31-next-permutation.js
index 17797b5a..28de12d6 100644
--- a/31-next-permutation.js
+++ b/31-next-permutation.js
@@ -4,7 +4,7 @@
  */
 const nextPermutation = function(nums) {
   const n = nums.length
-  let k
+  let k = null
   for(let i = n - 2; i >= 0; i--) {
     if(nums[i] < nums[i + 1]) {
       k = i

From e0f66a71d6ea6501b09ee13fd5a710e0f412bdde Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 May 2023 17:41:17 +0800
Subject: [PATCH 2668/3374] Create
 2663-lexicographically-smallest-beautiful-string.js

---
 ...cographically-smallest-beautiful-string.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2663-lexicographically-smallest-beautiful-string.js

diff --git a/2663-lexicographically-smallest-beautiful-string.js b/2663-lexicographically-smallest-beautiful-string.js
new file mode 100644
index 00000000..b37a5814
--- /dev/null
+++ b/2663-lexicographically-smallest-beautiful-string.js
@@ -0,0 +1,42 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const smallestBeautifulString = function(s, k) {
+const chars = s.split('')
+
+for (let i = chars.length - 1; i >= 0; i--) {
+  chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1)
+  while (containsPalindrome(chars, i)) {
+    chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1)
+  }
+  if (chars[i] < String.fromCharCode('a'.charCodeAt(0) + k)) {
+    // If s[i] is among the first k letters, then change the letters after
+    // s[i] to the smallest ones that don't form any palindrome substring.
+    return changeSuffix(chars, i + 1)
+  }
+}
+
+return ''
+
+// Returns true if chars[0..i] contains palindrome.
+function containsPalindrome(chars, i) {
+  return (
+    (i > 0 && chars[i] == chars[i - 1]) || (i > 1 && chars[i] == chars[i - 2])
+  )
+}
+
+// Returns string where chars[i..] replaced with the smallest letters that
+// don't form any palindrome substring.
+function changeSuffix(chars, i) {
+  for (let j = i; j < chars.length; j++) {
+    chars[j] = 'a'
+    while (containsPalindrome(chars, j)) {
+      chars[j] = String.fromCharCode(chars[j].charCodeAt(0) + 1)
+    }
+  }
+  return chars.join('')
+}
+
+};

From 1bcc5fc48c77edf297bc9e1b3afc72bcabb6a735 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 May 2023 17:42:00 +0800
Subject: [PATCH 2669/3374] Update
 2663-lexicographically-smallest-beautiful-string.js

---
 ...cographically-smallest-beautiful-string.js | 55 +++++++++----------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/2663-lexicographically-smallest-beautiful-string.js b/2663-lexicographically-smallest-beautiful-string.js
index b37a5814..e1b63472 100644
--- a/2663-lexicographically-smallest-beautiful-string.js
+++ b/2663-lexicographically-smallest-beautiful-string.js
@@ -3,40 +3,39 @@
  * @param {number} k
  * @return {string}
  */
-const smallestBeautifulString = function(s, k) {
-const chars = s.split('')
+const smallestBeautifulString = function (s, k) {
+  const chars = s.split('')
 
-for (let i = chars.length - 1; i >= 0; i--) {
-  chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1)
-  while (containsPalindrome(chars, i)) {
+  for (let i = chars.length - 1; i >= 0; i--) {
     chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1)
+    while (containsPalindrome(chars, i)) {
+      chars[i] = String.fromCharCode(chars[i].charCodeAt(0) + 1)
+    }
+    if (chars[i] < String.fromCharCode('a'.charCodeAt(0) + k)) {
+      // If s[i] is among the first k letters, then change the letters after
+      // s[i] to the smallest ones that don't form any palindrome substring.
+      return changeSuffix(chars, i + 1)
+    }
   }
-  if (chars[i] < String.fromCharCode('a'.charCodeAt(0) + k)) {
-    // If s[i] is among the first k letters, then change the letters after
-    // s[i] to the smallest ones that don't form any palindrome substring.
-    return changeSuffix(chars, i + 1)
-  }
-}
 
-return ''
+  return ''
 
-// Returns true if chars[0..i] contains palindrome.
-function containsPalindrome(chars, i) {
-  return (
-    (i > 0 && chars[i] == chars[i - 1]) || (i > 1 && chars[i] == chars[i - 2])
-  )
-}
+  // Returns true if chars[0..i] contains palindrome.
+  function containsPalindrome(chars, i) {
+    return (
+      (i > 0 && chars[i] == chars[i - 1]) || (i > 1 && chars[i] == chars[i - 2])
+    )
+  }
 
-// Returns string where chars[i..] replaced with the smallest letters that
-// don't form any palindrome substring.
-function changeSuffix(chars, i) {
-  for (let j = i; j < chars.length; j++) {
-    chars[j] = 'a'
-    while (containsPalindrome(chars, j)) {
-      chars[j] = String.fromCharCode(chars[j].charCodeAt(0) + 1)
+  // Returns string where chars[i..] replaced with the smallest letters that
+  // don't form any palindrome substring.
+  function changeSuffix(chars, i) {
+    for (let j = i; j < chars.length; j++) {
+      chars[j] = 'a'
+      while (containsPalindrome(chars, j)) {
+        chars[j] = String.fromCharCode(chars[j].charCodeAt(0) + 1)
+      }
     }
+    return chars.join('')
   }
-  return chars.join('')
 }
-
-};

From bd93128a0bdeab7ab852f765eb3fe18caeaeae6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 30 May 2023 22:20:09 +0800
Subject: [PATCH 2670/3374] Update
 2663-lexicographically-smallest-beautiful-string.js

---
 ...cographically-smallest-beautiful-string.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/2663-lexicographically-smallest-beautiful-string.js b/2663-lexicographically-smallest-beautiful-string.js
index e1b63472..9c6d0067 100644
--- a/2663-lexicographically-smallest-beautiful-string.js
+++ b/2663-lexicographically-smallest-beautiful-string.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const smallestBeautifulString = function(s, k) {
+  const n = s.length
+  const original = s
+  const chars = s.split(''), a = 'a'.charCodeAt(0), z = 'z'.charCodeAt(0)
+  const codeToCh = code => String.fromCharCode(code)
+  let flag = false
+  for(let i = n - 1; i >= 0; i--) {
+    const code = chars[i].charCodeAt(0)
+    for(let j = code + 1; j < a + k && j <= z; j++) {
+      if(!valid(i, codeToCh(j))) continue
+      chars[i] = codeToCh(j)
+      for(let nxt = i + 1; nxt < n; nxt++) {
+        for(let c = a; c < a + k; c++) {
+          if(valid(nxt, codeToCh(c))) {
+            chars[nxt] = codeToCh(c)
+            break
+          }
+        }
+      }
+      flag = true
+      break
+    }
+    if(flag) break
+  }
+  
+  const res = chars.join('')
+  if(res === original) return ''
+  return res
+  
+  function valid(idx, ch) {
+    if(idx >= 1 && ch === chars[idx - 1]) return false
+    if(idx >= 2 && ch === chars[idx - 2]) return false
+    return true
+  }
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @param {number} k

From 4ee0653402e814e389c1ae894b8f2a3112c0177d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 May 2023 20:00:01 +0800
Subject: [PATCH 2671/3374] Update
 1625-lexicographically-smallest-string-after-applying-operations.js

---
 ...allest-string-after-applying-operations.js | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
index 6c603c5d..f624d743 100644
--- a/1625-lexicographically-smallest-string-after-applying-operations.js
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -1,3 +1,62 @@
+/**
+ * @param {string} s
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */ 
+const findLexSmallestString = function(s, a, b) {
+  let res = s
+  const visited = new Set()
+  dfs(s)
+  return res
+  
+  function dfs(str) {
+    if(isVisited(str)) return
+    visit(str)
+    dfs(add(str))
+    dfs(rotate(str))
+  }
+  
+  function isVisited(str) {
+    return visited.has(str)
+  }
+  
+  function visit(str) {
+    if(str < res) res = str
+    visited.add(str)
+  }
+  
+  function add(str) {
+    const arr = str.split('').map(e => +e)
+    for(let i = 1; i < str.length; i += 2) {
+      arr[i] = (arr[i] + a) % 10
+    }
+    return arr.join('')
+  }
+  
+  function rotate(str) {
+    const arr = str.split('')
+    arr.reverse()
+    let l = 0, r = b - 1
+    while(l < r) {
+      swap(arr, l++, r--)
+    }
+    l = b
+    r = s.length - 1
+    while(l < r) {
+      swap(arr, l++, r--)
+    }
+    return arr.join('')
+  }
+  
+  function swap(arr, i, j) {
+    ;[arr[i], arr[j]] = [arr[j], arr[i]]
+  }
+};
+
+// another
+
+
 /**
  * @param {string} s
  * @param {number} a

From 1619cab4cc78ef1834aa981c13149c0c32bd34c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 1 Jun 2023 13:04:03 +0800
Subject: [PATCH 2672/3374] Create
 2702-minimum-operations-to-make-numbers-non-positive.js

---
 ...operations-to-make-numbers-non-positive.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2702-minimum-operations-to-make-numbers-non-positive.js

diff --git a/2702-minimum-operations-to-make-numbers-non-positive.js b/2702-minimum-operations-to-make-numbers-non-positive.js
new file mode 100644
index 00000000..1330b34b
--- /dev/null
+++ b/2702-minimum-operations-to-make-numbers-non-positive.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @param {number} y
+ * @return {number}
+ */
+const minOperations = function (nums, x, y) {
+  const { max, floor } = Math
+  let right = nums[0]
+  for (const v of nums) {
+    right = Math.max(v, right)
+  }
+  let left = 1
+  right = floor(right / y) + 1
+  x -= y
+  while (left <= right) {
+    let mid = (left + right) >> 1,
+      s = mid
+    for (let v of nums) {
+      let t = floor((v + y - 1) / y)
+      if (mid >= t) {
+        continue
+      }
+      s -= floor((v - mid * y + x - 1) / x)
+      if (s < 0) {
+        break
+      }
+    }
+    if (s >= 0) {
+      right = mid - 1
+    } else {
+      left = mid + 1
+    }
+  }
+  return right + 1
+}

From 429405e29f2d871e4c29db0e83c1ce8cba80e594 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Jun 2023 00:05:06 +0800
Subject: [PATCH 2673/3374] Create
 2557-maximum-number-of-integers-to-choose-from-a-range-ii.js

---
 ...r-of-integers-to-choose-from-a-range-ii.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2557-maximum-number-of-integers-to-choose-from-a-range-ii.js

diff --git a/2557-maximum-number-of-integers-to-choose-from-a-range-ii.js b/2557-maximum-number-of-integers-to-choose-from-a-range-ii.js
new file mode 100644
index 00000000..376d4586
--- /dev/null
+++ b/2557-maximum-number-of-integers-to-choose-from-a-range-ii.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} banned
+ * @param {number} n
+ * @param {number} maxSum
+ * @return {number}
+ */
+var maxCount = function(banned, n, maxSum) {
+  const set = new Set(banned);
+
+  let low = 0;
+  let high = n;
+  let possibleVal = 0;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    let totalSum = (mid * (mid + 1)) / 2;
+    for (const val of set) {
+      if (val <= mid) totalSum -= val;
+    }
+
+    if (totalSum <= maxSum) {
+      possibleVal = mid;
+      low = mid + 1;
+    } else {
+      high = mid - 1;
+    }
+  }
+
+  let ans = possibleVal;
+  for (const val of set) {
+    if (val <= possibleVal) ans--;
+  }
+
+  return ans;
+};

From f2c1e29b746adca6ee50bedd22e4c6c4c25a790d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Jun 2023 11:34:51 +0800
Subject: [PATCH 2674/3374] Create 2560-house-robber-iv.js

---
 2560-house-robber-iv.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2560-house-robber-iv.js

diff --git a/2560-house-robber-iv.js b/2560-house-robber-iv.js
new file mode 100644
index 00000000..d0fe4251
--- /dev/null
+++ b/2560-house-robber-iv.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minCapability = function(nums, k) {
+  let left = 1, right = 1e9, n = nums.length
+  while (left < right) {
+    let mid = Math.floor((left + right) / 2), take = 0
+    for (let i = 0; i < n; ++i) {
+      if (nums[i] <= mid) {
+        take += 1
+        i++
+      } 
+    }
+    if (take >= k) right = mid
+    else left = mid + 1
+  }
+  return left
+};

From 59ec24a9d5b7295703f5a300a44d9ece1b0715bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 Jun 2023 13:27:15 +0800
Subject: [PATCH 2675/3374] Update 2560-house-robber-iv.js

---
 2560-house-robber-iv.js | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/2560-house-robber-iv.js b/2560-house-robber-iv.js
index d0fe4251..3a297193 100644
--- a/2560-house-robber-iv.js
+++ b/2560-house-robber-iv.js
@@ -4,17 +4,19 @@
  * @return {number}
  */
 const minCapability = function(nums, k) {
-  let left = 1, right = 1e9, n = nums.length
-  while (left < right) {
-    let mid = Math.floor((left + right) / 2), take = 0
-    for (let i = 0; i < n; ++i) {
-      if (nums[i] <= mid) {
-        take += 1
+  const n = nums.length
+  let l = 1, r = 1e9
+  while(l < r) {
+    const mid = Math.floor((l + r) / 2)
+    let cnt = 0
+    for(let i = 0; i < n; i++) {
+      if(nums[i] <= mid) {
+        cnt++
         i++
-      } 
+      }
     }
-    if (take >= k) right = mid
-    else left = mid + 1
+    if(cnt >= k) r = mid
+    else l = mid + 1
   }
-  return left
+  return l
 };

From 85b740c453cc86e82945d73bea5e1467474ff72f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 Jun 2023 22:53:01 +0800
Subject: [PATCH 2676/3374] Create 2604-minimum-time-to-eat-all-grains.js

---
 2604-minimum-time-to-eat-all-grains.js | 32 ++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2604-minimum-time-to-eat-all-grains.js

diff --git a/2604-minimum-time-to-eat-all-grains.js b/2604-minimum-time-to-eat-all-grains.js
new file mode 100644
index 00000000..33762836
--- /dev/null
+++ b/2604-minimum-time-to-eat-all-grains.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} hens
+ * @param {number[]} grains
+ * @return {number}
+ */
+var minimumTime = function (hens, grains) {
+  hens.sort((a, b) => a - b)
+  grains.sort((a, b) => a - b)
+  let lo = 0,
+    hi = 1e9
+  while (lo < hi) {
+    let mid = Math.floor(lo + (hi - lo) / 2),
+      i = 0
+    for (let h of hens) {
+      for (
+        let ii = i;
+        i < grains.length &&
+        ((grains[i] <= h && h - grains[i] <= mid) ||
+          (h <= grains[ii] && grains[i] - h <= mid) ||
+          (grains[ii] <= h &&
+            h <= grains[i] &&
+            grains[i] - grains[ii] + Math.min(grains[i] - h, h - grains[ii]) <=
+              mid));
+        ++i
+      );
+    }
+
+    if (i == grains.length) hi = mid
+    else lo = mid + 1
+  }
+  return lo
+}

From a854e29bd952de93328c302f0af8c285004c8320 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Jun 2023 14:34:40 +0800
Subject: [PATCH 2677/3374] Create
 2031-count-subarrays-with-more-ones-than-zeros.js

---
 ...unt-subarrays-with-more-ones-than-zeros.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 2031-count-subarrays-with-more-ones-than-zeros.js

diff --git a/2031-count-subarrays-with-more-ones-than-zeros.js b/2031-count-subarrays-with-more-ones-than-zeros.js
new file mode 100644
index 00000000..c87d67a3
--- /dev/null
+++ b/2031-count-subarrays-with-more-ones-than-zeros.js
@@ -0,0 +1,41 @@
+const lowBit = (x) => x & -x
+class FenwickTree {
+  constructor(n) {
+    if (n < 1) return
+    this.sum = Array(n + 1).fill(0)
+  }
+  update(i, delta) {
+    if (i < 1) return
+    while (i < this.sum.length) {
+      this.sum[i] += delta
+      i += lowBit(i)
+    }
+  }
+  query(i) {
+    if (i < 1) return 0
+    let sum = 0
+    while (i > 0) {
+      sum += this.sum[i]
+      i -= lowBit(i)
+    }
+    return sum
+  }
+}
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const subarraysWithMoreZerosThanOnes = function(nums) {
+  const n = nums.length, mod = 1e9 + 7
+  const bit = new FenwickTree(2 * n + 1)
+  bit.update(n, 1)
+  let balance = 0, res = 0
+  for(const e of nums) {
+    balance += (e === 1 ? 1 : -1)
+    bit.update(balance + n, 1)
+    res = (res + bit.query(balance + n - 1)) % mod 
+  }
+  
+  return res
+};

From b4441842d6abe3aa28a22f605baec0663ab9fbf6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Jun 2023 14:40:12 +0800
Subject: [PATCH 2678/3374] Update
 2031-count-subarrays-with-more-ones-than-zeros.js

---
 2031-count-subarrays-with-more-ones-than-zeros.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/2031-count-subarrays-with-more-ones-than-zeros.js b/2031-count-subarrays-with-more-ones-than-zeros.js
index c87d67a3..324c77f6 100644
--- a/2031-count-subarrays-with-more-ones-than-zeros.js
+++ b/2031-count-subarrays-with-more-ones-than-zeros.js
@@ -29,12 +29,12 @@ class FenwickTree {
 const subarraysWithMoreZerosThanOnes = function(nums) {
   const n = nums.length, mod = 1e9 + 7
   const bit = new FenwickTree(2 * n + 1)
-  bit.update(n, 1)
+  bit.update(n + 1, 1)
   let balance = 0, res = 0
   for(const e of nums) {
     balance += (e === 1 ? 1 : -1)
-    bit.update(balance + n, 1)
-    res = (res + bit.query(balance + n - 1)) % mod 
+    bit.update(balance + n + 1, 1)
+    res = (res + bit.query(balance + n)) % mod 
   }
   
   return res

From 8cbe5cbe7fac6ddd69706a0bd22ceef04086d61f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 20 Jun 2023 12:46:31 +0800
Subject: [PATCH 2679/3374] Update
 1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js

---
 ...ubsequences-that-satisfy-the-given-sum-condition.js | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js b/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js
index 8803f183..e7de9469 100644
--- a/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js
+++ b/1498-number-of-subsequences-that-satisfy-the-given-sum-condition.js
@@ -4,17 +4,17 @@
  * @return {number}
  */
 const numSubseq = function(nums, target) {
-  const n = nums.length, pow = Array(n), mod = 1e9 + 7
-  pow[0] = 1
+  const n = nums.length, mod = 1e9 + 7
+  const pows = Array(n).fill(1)
   for(let i = 1; i < n; i++) {
-    pow[i] = (pow[i - 1] * 2) % mod
+    pows[i] = pows[i - 1] * 2 % mod
   }
+  let res = 0, l = 0, r = n - 1
   nums.sort((a, b) => a - b)
-  let l = 0, r = n - 1, res = 0
   while(l <= r) {
     if(nums[l] + nums[r] > target) r--
     else {
-      res = (res + pow[r - l]) % mod
+      res = (res + pows[r - l]) % mod
       l++
     }
   }

From c5ce8a5b87ef10ba719990a76fa2d9ccd63aecb8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 Jun 2023 15:32:03 +0800
Subject: [PATCH 2680/3374] Create 2681-power-of-heroes.js

---
 2681-power-of-heroes.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2681-power-of-heroes.js

diff --git a/2681-power-of-heroes.js b/2681-power-of-heroes.js
new file mode 100644
index 00000000..e76bf3da
--- /dev/null
+++ b/2681-power-of-heroes.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfPower = function(nums) {
+  const n = nums.length, mod = BigInt(1e9 + 7)
+  let res = 0n, sum = 0n
+  nums.sort((a, b) => a - b)
+  
+  for(let i = 0; i < n; i++) {
+    const e = BigInt(nums[i])
+    const square = (e * e) % mod
+    
+    res = (res + sum * square + e * square) % mod
+    sum = (sum * 2n + e) % mod  
+  }
+  
+  return res
+};

From 2277886292b9d639d0a7b7fe85d90b6a94b652b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 24 Jun 2023 17:14:57 +0800
Subject: [PATCH 2681/3374] Update
 2492-minimum-score-of-a-path-between-two-cities.js

---
 ...imum-score-of-a-path-between-two-cities.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/2492-minimum-score-of-a-path-between-two-cities.js b/2492-minimum-score-of-a-path-between-two-cities.js
index de7ed10e..43c7f362 100644
--- a/2492-minimum-score-of-a-path-between-two-cities.js
+++ b/2492-minimum-score-of-a-path-between-two-cities.js
@@ -1,3 +1,36 @@
+/**
+ * @param {number} n
+ * @param {number[][]} roads
+ * @return {number}
+ */
+const minScore = function(n, roads) {
+  const g = {}, visited = Array(n + 1).fill(0)
+  let res = Infinity
+  for(const [u, v, d] of roads) {
+    if(g[u] == null) g[u] = []
+    if(g[v] == null) g[v] = []
+    
+    g[u].push([v, d])
+    g[v].push([u, d])
+  }
+  
+  dfs(1)
+  
+  return res
+  
+  function dfs(node) {
+    visited[node] = 1
+    for(const [nxt, dis] of (g[node] || [])) {
+      res = Math.min(res, dis)
+      if(visited[nxt] === 0) {
+        dfs(nxt)
+      }
+    }
+  }
+};
+
+// another
+
 class UnionFind {
     constructor() {
       this.sizes = new Map()

From fc5a4bc64e5e7299aaa7c3d7af87857f03d1eba0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Jun 2023 22:26:24 +0800
Subject: [PATCH 2682/3374] Create 2658-maximum-number-of-fish-in-a-grid.js

---
 2658-maximum-number-of-fish-in-a-grid.js | 62 ++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 2658-maximum-number-of-fish-in-a-grid.js

diff --git a/2658-maximum-number-of-fish-in-a-grid.js b/2658-maximum-number-of-fish-in-a-grid.js
new file mode 100644
index 00000000..a46ab84b
--- /dev/null
+++ b/2658-maximum-number-of-fish-in-a-grid.js
@@ -0,0 +1,62 @@
+const deepCopy2DArray = (g) => {
+  let d = []
+  for (const a of g) d.push([...a])
+  return d
+}
+
+const dx = [1, -1, 0, 0],
+  dy = [0, 0, 1, -1]
+const getAllAreasCoordinates = (g) => {
+  const forbid = 0,
+    floodFillMakeConnected = '*' // forbid is land cell
+  let n = g.length,
+    m = g[0].length,
+    res = []
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (g[i][j] != forbid) {
+        let q = [[i, j]],
+          area = []
+        while (q.length) {
+          let [x, y] = q.shift()
+          for (let k = 0; k < 4; k++) {
+            let nx = x + dx[k],
+              ny = y + dy[k]
+            if (
+              nx < 0 ||
+              nx >= n ||
+              ny < 0 ||
+              ny >= m ||
+              g[nx][ny] == forbid ||
+              g[nx][ny] == floodFillMakeConnected
+            )
+              continue
+            g[nx][ny] = floodFillMakeConnected
+            area.push([nx, ny])
+            q.push([nx, ny])
+          }
+        }
+        if (area.length == 0 && g[i][j] != floodFillMakeConnected)
+          area.push([i, j])
+        res.push(area)
+      }
+    }
+  }
+  return res
+}
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const findMaxFish = (g) => {
+  let areas = getAllAreasCoordinates(deepCopy2DArray(g)),
+    res = 0
+  for (const area of areas) {
+    let sum = 0
+    for (const [x, y] of area) sum += g[x][y]
+    res = Math.max(res, sum)
+  }
+  return res
+}
+

From 95aa94fc8f4bda4fffd589431199887f85c02275 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Jun 2023 13:38:56 +0800
Subject: [PATCH 2683/3374] Update 459-repeated-substring-pattern.js

---
 459-repeated-substring-pattern.js | 32 +++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/459-repeated-substring-pattern.js b/459-repeated-substring-pattern.js
index 2ed1fcce..9debc498 100644
--- a/459-repeated-substring-pattern.js
+++ b/459-repeated-substring-pattern.js
@@ -1,3 +1,35 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+const repeatedSubstringPattern = function(s) {
+  
+  const len = s.length
+  const table = build(s)
+  return table[len] && (table[len] % (len - table[len]) === 0)
+  
+  function build(str) {
+    const n = str.length
+    const table = Array(n + 1).fill(0)
+    let i = 1, j = 0
+    table[0] = -1
+    while(i < n) {
+      if(str[i] === str[j]) {
+        i++
+        j++
+        table[i] = j
+      } else {
+        if(j > 0) j = table[j]
+        else i++
+      }
+    }
+    
+    return table
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {boolean}

From 6924e8bd4d22fc3eaa3098da5a23539bf62da278 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Jun 2023 16:20:00 +0800
Subject: [PATCH 2684/3374] Update 1998-gcd-sort-of-an-array.js

---
 1998-gcd-sort-of-an-array.js | 95 ++++++++++++++++++++++++++++++------
 1 file changed, 81 insertions(+), 14 deletions(-)

diff --git a/1998-gcd-sort-of-an-array.js b/1998-gcd-sort-of-an-array.js
index 55c9526d..68ecd546 100644
--- a/1998-gcd-sort-of-an-array.js
+++ b/1998-gcd-sort-of-an-array.js
@@ -3,25 +3,92 @@
  * @return {boolean}
  */
 const gcdSort = function(nums) {
-  const spf = Array(nums.length).fill(0)
-         let maxNum = Math.max(...nums);
-        sieve(maxNum);
+  const n = nums.length
+  const maxNum = Math.max(...nums);
+  const spf = sieve(maxNum);
+
+  const uf = new UnionFind(maxNum + 1)
+  for(const e of nums) {
+    for(const f of getFactors(e)) uf.union(e, f)
+  }
+  const clone = nums.slice()
+  clone.sort((a, b) => a - b)
 
-        const uf = new UnionFind(maxNum+1);
-        for (let x of nums) {
-            for (let f of getFactors(x)) uf.union(f, x);          
+  for(let i = 0; i < n; i++) {
+    if(uf.find(nums[i]) !== uf.find(clone[i])) return false
+  }
+  
+  return true
+
+  function sieve(n) { // O(Nlog(logN)) ~ O(N)
+    const res = [0, 0]
+    for (let i = 2; i <= n; ++i) res[i] = i;
+    for (let i = 2; i * i <= n; i++) {
+      if (res[i] != i) continue; // skip if `i` is not a prime number
+      for (let j = i * i; j <= n; j += i) {
+        if (res[j] == j) { // marking spf[j] if it is not previously marked
+          res[j] = i;
         }
+      }
+    }
+    return res
+  }
+  
+  function getFactors(n) { // O(logN)
+    const factors = [];
+    while (n > 1) {
+      factors.push(spf[n]);
+      n = ~~(n /spf[n]);
+    }
+    return factors;
+  }
+};
 
+function gcd( x,  y) {
+    return y == 0 ? x : gcd(y, x % y);
+}
 
-        const sortedArr = nums.slice();
-        sortedArr.sort((a, b) => a - b)
+class UnionFind {
+    constructor(n) {
+        this.parent = [];
+        for (let i = 0; i < n; i++) this.parent[i] = i;
+    }
+    find(x) {
+        if (x == this.parent[x]) return x;
+        return this.parent[x] = this.find(this.parent[x]); // Path compression
+    }
+    union(u,  v) {
+        let pu = this.find(u), pv = this.find(v);
+        if (pu != pv) this.parent[pu] = pv;
+    }
+};
 
-        for (let i = 0; i < nums.length; ++i) {
-            let pu = uf.find(sortedArr[i]);
-            let pv = uf.find(nums[i]);
-            if (pu != pv) return false; // can't swap nums[i] with sortedArr[i]
-        }
-        return true;
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const gcdSort = function(nums) {
+  const spf = Array(nums.length).fill(0)
+   let maxNum = Math.max(...nums);
+  sieve(maxNum);
+
+  const uf = new UnionFind(maxNum+1);
+  for (let x of nums) {
+      for (let f of getFactors(x)) uf.union(f, x);          
+  }
+
+
+  const sortedArr = nums.slice();
+  sortedArr.sort((a, b) => a - b)
+
+  for (let i = 0; i < nums.length; ++i) {
+      let pu = uf.find(sortedArr[i]);
+      let pv = uf.find(nums[i]);
+      if (pu != pv) return false; // can't swap nums[i] with sortedArr[i]
+  }
+  return true;
   
   function sieve( n) { // O(Nlog(logN)) ~ O(N)
     for (let i = 2; i <= n; ++i) spf[i] = i;

From 9add58e096d93a41a5694b2535d9cb2f7bf2251e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 30 Jun 2023 16:39:03 +0800
Subject: [PATCH 2685/3374] Create 2709-greatest-common-divisor-traversal.js

---
 2709-greatest-common-divisor-traversal.js | 47 +++++++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 2709-greatest-common-divisor-traversal.js

diff --git a/2709-greatest-common-divisor-traversal.js b/2709-greatest-common-divisor-traversal.js
new file mode 100644
index 00000000..581401c6
--- /dev/null
+++ b/2709-greatest-common-divisor-traversal.js
@@ -0,0 +1,47 @@
+// max number in `nums` is 10^5. Only need primes up to sqrt(10^5) = 316
+const primes = [
+  2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
+  73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151,
+  157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
+  239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,
+]
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canTraverseAllPairs = function(nums) {
+  const n = nums.length
+  const uf = new Array(n).fill(-1)
+  const primeIdxs = {}
+
+  const find = (i) => (uf[i] < 0 ? i : find(uf[i]))
+
+  nums.forEach((num, i) => {
+    // find all prime factors of num
+    let primeFactors = []
+    for (let p of primes) {
+      if (num % p === 0) {
+        primeFactors.push(p)
+        while (num % p === 0) num = Math.floor(num / p)
+      }
+    }
+
+    if (num !== 1) primeFactors.push(num)
+
+    for (let factor of primeFactors) {
+      if (factor in primeIdxs) {
+        let pi = find(i)
+        let pj = find(primeIdxs[factor])
+        // union if not already merged
+        if (pi !== pj) {
+          if (uf[pi] > uf[pj]) [pi, pj] = [pj, pi]
+          uf[pi] += uf[pj]
+          uf[pj] = pi
+        }
+      } else primeIdxs[factor] = i
+    }
+  })
+
+  return Math.abs(Math.min(...uf)) === n
+};

From faae9739592ef82abe8768c6f53f9fea5966bc6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Jul 2023 15:43:42 +0800
Subject: [PATCH 2686/3374] Update 204-count-primes.js

---
 204-count-primes.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/204-count-primes.js b/204-count-primes.js
index e1a61978..6882fda6 100755
--- a/204-count-primes.js
+++ b/204-count-primes.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countPrimes = function(n) {
+  const arr = Array(n).fill(0)
+  
+  for(let i = 2; i * i < n; i++) {
+    if(arr[i] !== 0) continue
+    let j = i * i
+    while(j < n) {
+      arr[j] = 1
+      j += i
+    }
+  }
+  
+  let res = 0
+  for(let i = 2; i < n; i++) {
+    if(arr[i] === 0) res++
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 4db9500bd965fe81b3db54b3764f3747e5eddb84 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jul 2023 13:10:52 +0800
Subject: [PATCH 2687/3374] Update
 2280-minimum-lines-to-represent-a-line-chart.js

---
 ...minimum-lines-to-represent-a-line-chart.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/2280-minimum-lines-to-represent-a-line-chart.js b/2280-minimum-lines-to-represent-a-line-chart.js
index 96ae3aa4..a8d50bf9 100644
--- a/2280-minimum-lines-to-represent-a-line-chart.js
+++ b/2280-minimum-lines-to-represent-a-line-chart.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[][]} stockPrices
+ * @return {number}
+ */
+const minimumLines = function(stockPrices) {
+  let res = 1
+  const n = stockPrices.length
+  if(n === 1) return 0
+  stockPrices.sort((a, b) => a[0] - b[0])
+  for(let i = 2; i < n; i++) {
+    const cur = stockPrices[i], p = stockPrices[i - 1], pp = stockPrices[i - 2]
+    if(chk(pp, p, cur)) continue
+    else res++
+  }
+  
+  
+  return res
+};
+
+function chk(p1, p2, p3) {
+  const bi = BigInt
+  // (y3 - y1) / (x3 - x1) == (y2 - y1) / (x2 - x1)
+  const [x1, y1] =  p1, [x2, y2] = p2, [x3, y3] = p3
+  return (bi(y3) - bi(y1)) * (bi(x2) - bi(x1)) === (bi(y2) - bi(y1)) * (bi(x3) - bi(x1))
+}
+
+
+
+// another
+
 /**
  * @param {number[][]} stockPrices
  * @return {number}

From e20a1970c9b7b13b69bb6c8ae60ec37053fd2d5d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jul 2023 19:29:50 +0800
Subject: [PATCH 2688/3374] Create
 2763-sum-of-imbalance-numbers-of-all-subarrays.js

---
 ...m-of-imbalance-numbers-of-all-subarrays.js | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 2763-sum-of-imbalance-numbers-of-all-subarrays.js

diff --git a/2763-sum-of-imbalance-numbers-of-all-subarrays.js b/2763-sum-of-imbalance-numbers-of-all-subarrays.js
new file mode 100644
index 00000000..6bc83cc3
--- /dev/null
+++ b/2763-sum-of-imbalance-numbers-of-all-subarrays.js
@@ -0,0 +1,72 @@
+class MultiSet {
+  constructor() {
+    this.countMap = new Map()
+    this.valueList = []
+  }
+  remove(value) {
+    if(!this.countMap.has(value)) return false
+    let index = binarySearch(this.valueList, value)
+    if (this.countMap.get(value) === 1) {
+      this.valueList.splice(index, 1)
+      this.countMap.delete(value)
+    } else {
+      this.countMap.set(value, (this.countMap.get(value) || 0) - 1)
+    }
+    return true
+  }
+  add(value) {
+    let index = binarySearch(this.valueList, value)
+    if (index < 0) {
+      this.valueList.splice(-index - 1, 0, value)
+      this.countMap.set(value, 1)
+    } else {
+      this.countMap.set(value, this.countMap.get(value) + 1)
+    }
+  }
+  has(value) {
+    return this.countMap.has(value)
+  }
+  get max() {
+    return this.valueList[this.valueList.length - 1]
+  }
+  get min() {
+    return this.valueList[0]
+  }
+}
+
+function binarySearch(arr, val) {
+  let l = 0, r = arr.length
+  while( l < r ) {
+    const mid = Math.floor((l + r) / 2)
+    if(arr[mid] < val) {
+       l = mid + 1
+    } else {
+      r = mid
+    }
+  }
+  if(arr[l] !== val) return -(l + 1)
+  
+  return l
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumImbalanceNumbers = function (nums) {
+  let n = nums.length, res = 0;
+  for (let i = 0; i < n; i++) {
+      let tree = new MultiSet(), cnt = 0;
+      tree.add(nums[i]);
+      for (let j = i + 1; j < n; j++) {
+          let x = nums[j];
+          if (!tree.has(x)) {
+              tree.add(x);
+              cnt++;
+              if (tree.has(x - 1)) cnt--;
+              if (tree.has(x + 1)) cnt--;
+          }
+          res += cnt;
+      }
+  }
+  return res;
+}

From 420ebae9503e3612896537e070e54ae13af84620 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jul 2023 19:30:44 +0800
Subject: [PATCH 2689/3374] Create 2762-continuous-subarrays.js

---
 2762-continuous-subarrays.js | 68 ++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 2762-continuous-subarrays.js

diff --git a/2762-continuous-subarrays.js b/2762-continuous-subarrays.js
new file mode 100644
index 00000000..54ab362a
--- /dev/null
+++ b/2762-continuous-subarrays.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const continuousSubarrays = function(nums) {
+  let res = 0
+  let l = 0
+  let r = 0
+  const mset = new MultiSet()
+  for(let r = 0; r < nums.length; r++) {
+    mset.add(nums[r])
+    while (mset.max - mset.min > 2) {
+      mset.remove(nums[l])
+      l++
+    }
+
+    res += r - l + 1
+  }
+  return res
+};
+
+class MultiSet {
+  constructor() {
+    this.countMap = new Map()
+    this.valueList = []
+  }
+  remove(value) {
+    if(!this.countMap.has(value)) return false
+    let index = binarySearch(this.valueList, value)
+    if (this.countMap.get(value) === 1) {
+      this.valueList.splice(index, 1)
+      this.countMap.delete(value)
+    } else {
+      this.countMap.set(value, (this.countMap.get(value) || 0) - 1)
+    }
+    return true
+  }
+  add(value) {
+    let index = binarySearch(this.valueList, value)
+    if (index < 0) {
+      this.valueList.splice(-index - 1, 0, value)
+      this.countMap.set(value, 1)
+    } else {
+      this.countMap.set(value, this.countMap.get(value) + 1)
+    }
+  }
+  get max() {
+    return this.valueList[this.valueList.length - 1]
+  }
+  get min() {
+    return this.valueList[0]
+  }
+}
+
+function binarySearch(arr, val) {
+  let l = 0, r = arr.length
+  while( l < r ) {
+    const mid = Math.floor((l + r) / 2)
+    if(arr[mid] < val) {
+       l = mid + 1
+    } else {
+      r = mid
+    }
+  }
+  if(arr[l] !== val) return -(l + 1)
+  
+  return l
+}

From 57136bcd549e77256ed1cf8d7e6ada7cd6d2ea4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jul 2023 19:31:25 +0800
Subject: [PATCH 2690/3374] Create 2761-prime-pairs-with-target-sum.js

---
 2761-prime-pairs-with-target-sum.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 2761-prime-pairs-with-target-sum.js

diff --git a/2761-prime-pairs-with-target-sum.js b/2761-prime-pairs-with-target-sum.js
new file mode 100644
index 00000000..ef9a6bba
--- /dev/null
+++ b/2761-prime-pairs-with-target-sum.js
@@ -0,0 +1,28 @@
+
+/**
+ * @param {number} n
+ * @return {number[][]}
+ */
+const findPrimePairs = function(n) {
+  const res = primes(n + 1, n)
+  return res
+};
+
+function primes(n, target) {
+  const arr = Array(n).fill(0)
+
+  for(let i = 2; i * i < n; i++) {
+    if(arr[i] !== 0) continue
+    let j = i * i
+    while(j < n) {
+      arr[j] = 1
+      j += i
+    }
+  }
+
+  let res = []
+  for(let i = 2; i < n; i++) {
+    if(arr[i] === 0 && target - i > 1 && target - i >= i && arr[target - i] === 0) res.push([i, target - i])
+  }
+  return res
+};

From f8b189203376952e74a0295612b30e10caaa31c9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jul 2023 19:32:04 +0800
Subject: [PATCH 2691/3374] Create
 2760-longest-even-odd-subarray-with-threshold.js

---
 ...ongest-even-odd-subarray-with-threshold.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2760-longest-even-odd-subarray-with-threshold.js

diff --git a/2760-longest-even-odd-subarray-with-threshold.js b/2760-longest-even-odd-subarray-with-threshold.js
new file mode 100644
index 00000000..690ff7f6
--- /dev/null
+++ b/2760-longest-even-odd-subarray-with-threshold.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} threshold
+ * @return {number}
+ */
+var longestAlternatingSubarray = function(nums, threshold) {
+  let res = 0
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    let j = i, s = i
+    if(e % 2 === 0 && e <= threshold) {
+      j++
+      while(true) {
+        if(j >= n) break
+        if(nums[j] > threshold) break
+        if( (nums[j] % 2) === (nums[j - 1] % 2) ) break
+        j++
+      }
+    }
+    res = Math.max(res, j - i)
+  }
+  
+  return res
+};

From a7b2fbb581982371e40bd1bab61e6263ce28bfff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Jul 2023 13:56:51 +0800
Subject: [PATCH 2692/3374] Create 2514-count-anagrams.js

---
 2514-count-anagrams.js | 60 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 2514-count-anagrams.js

diff --git a/2514-count-anagrams.js b/2514-count-anagrams.js
new file mode 100644
index 00000000..a8b4e197
--- /dev/null
+++ b/2514-count-anagrams.js
@@ -0,0 +1,60 @@
+const mod = 1e9 + 7
+const fact = Array(1e5 + 2)
+getfact()
+// console.log(fact)
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const countAnagrams = function (s) {
+  let ans = 1
+  const arr = s.trim().split(' ')
+  for (const word of arr) {
+    ans = modmul(ans, ways(word))
+  }
+
+  return ans
+}
+
+function modmul(a, b) {
+  const big = BigInt
+  return Number(((big(a) % big(mod)) * (big(b) % big(mod))) % big(mod))
+}
+
+function binExpo(a, b) {
+  if (b === 0) return 1
+  let res = binExpo(a, Math.floor(b / 2))
+  if (b & 1) {
+    return modmul(a, modmul(res, res))
+  } else {
+    return modmul(res, res)
+  }
+}
+
+function modmulinv(a) {
+  return binExpo(a, mod - 2)
+}
+
+function getfact() {
+  fact[0] = 1
+  for (let i = 1; i <= 100001; i++) {
+    fact[i] = modmul(fact[i - 1], i)
+  }
+}
+
+function ways(str) {
+  const freq = Array(26).fill(0)
+  const a = 'a'.charCodeAt(0)
+  for (let i = 0; i < str.length; i++) {
+    freq[str.charCodeAt(i) - a]++
+  }
+
+  let totalWays = fact[str.length]
+
+  let factR = 1
+  for (let i = 0; i < 26; i++) {
+    factR = modmul(factR, fact[freq[i]])
+  }
+  // console.log(freq, totalWays, factR)
+  return modmul(totalWays, modmulinv(factR))
+}

From 865c6111d3c1f754f8349490c5769cb9cceffbbd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Jul 2023 19:26:07 +0800
Subject: [PATCH 2693/3374] Update
 1830-minimum-number-of-operations-to-make-string-sorted.js

---
 ...ber-of-operations-to-make-string-sorted.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)

diff --git a/1830-minimum-number-of-operations-to-make-string-sorted.js b/1830-minimum-number-of-operations-to-make-string-sorted.js
index e7808cbd..702e0c27 100644
--- a/1830-minimum-number-of-operations-to-make-string-sorted.js
+++ b/1830-minimum-number-of-operations-to-make-string-sorted.js
@@ -1,3 +1,66 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const makeStringSorted = function (s) {
+  const mod = 1e9 + 7,
+    n = s.length
+  const a = 'a'.charCodeAt(0)
+  let res = 0
+  const freq = Array(26).fill(0)
+  for (let c of s) {
+    freq[c.charCodeAt(0) - a]++
+  }
+  const fact = Array(n + 1).fill(1)
+  getfact()
+  let l = n
+  for (let c of s) {
+    l--
+    let t = 0,
+      rev = 1
+    for (let i = 0; i < 26; i++) {
+      if (i < c.charCodeAt(0) - a) t += freq[i]
+      rev = modmul(rev, fact[freq[i]])
+    }
+    res += modmul(modmul(t, fact[l]), binExpo(rev, mod - 2))
+    res %= mod
+    freq[c.charCodeAt(0) - a]--
+  }
+  return res
+
+  function modmul(a, b) {
+    const big = BigInt
+    return Number(((big(a) % big(mod)) * (big(b) % big(mod))) % big(mod))
+  }
+
+  function binExpo(a, b) {
+    if (b === 0) return 1
+    let res = binExpo(a, Math.floor(b / 2))
+    if (b & 1) {
+      return modmul(a, modmul(res, res))
+    } else {
+      return modmul(res, res)
+    }
+  }
+
+  function modmulinv(a) {
+    return binExpo(a, mod - 2)
+  }
+
+  function getfact() {
+    fact[0] = 1
+    for (let i = 1; i <= 3000; i++) {
+      fact[i] = modmul(fact[i - 1], i)
+    }
+  }
+  
+}
+
+
+// another
+
+
+
 /**
  * @param {string} s
  * @return {number}

From 86552ba3428a9b1a14aad0bae5c35f101fead4e5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Jul 2023 12:38:15 +0800
Subject: [PATCH 2694/3374] Create 2543-check-if-point-is-reachable.js

---
 2543-check-if-point-is-reachable.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2543-check-if-point-is-reachable.js

diff --git a/2543-check-if-point-is-reachable.js b/2543-check-if-point-is-reachable.js
new file mode 100644
index 00000000..c10a2f9f
--- /dev/null
+++ b/2543-check-if-point-is-reachable.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number} targetX
+ * @param {number} targetY
+ * @return {boolean}
+ */
+const isReachable = function(targetX, targetY) {
+  const g = gcd(targetX, targetY)
+  return (g & (g - 1)) === 0
+  
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+};

From 3bbdcb87770a52172cca1801220350fed2f79c38 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Jul 2023 13:23:53 +0800
Subject: [PATCH 2695/3374] Create 2607-make-k-subarray-sums-equal.js

---
 2607-make-k-subarray-sums-equal.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2607-make-k-subarray-sums-equal.js

diff --git a/2607-make-k-subarray-sums-equal.js b/2607-make-k-subarray-sums-equal.js
new file mode 100644
index 00000000..a208b2f7
--- /dev/null
+++ b/2607-make-k-subarray-sums-equal.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} arr
+ * @param {number} k
+ * @return {number}
+ */
+const makeSubKSumEqual = function(arr, k) {
+  let res = 0
+  const n =  arr.length
+  for(let i = 0; i < n; i++) {
+    const tmp = []
+    for(let j = i; arr[j] !== 0; j = (j + k) % n) {
+      tmp.push(arr[j])
+      arr[j] = 0
+    }
+    tmp.sort((a, b) => a - b)
+    const mid = tmp[~~(tmp.length / 2)]
+    for(const e of tmp) {
+      res += Math.abs(e - mid)
+    }
+  }
+  
+  
+  return res
+};

From c9410785d88d05f70f4f7b69a3d83e5d340bc245 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Jul 2023 20:37:36 +0800
Subject: [PATCH 2696/3374] Update 357-count-numbers-with-unique-digits.js

---
 357-count-numbers-with-unique-digits.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/357-count-numbers-with-unique-digits.js b/357-count-numbers-with-unique-digits.js
index 9aca0ff3..03018011 100755
--- a/357-count-numbers-with-unique-digits.js
+++ b/357-count-numbers-with-unique-digits.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countNumbersWithUniqueDigits = function(n) {
+  if(n === 0) return 1
+  let res = 10
+  let uniqueDigits = 9, avail = 9
+  while(n > 1 && avail) {
+    uniqueDigits = uniqueDigits * avail
+    res += uniqueDigits
+    avail--
+    n--
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 845a84ae3c099abf7eb08e0bfe3ab913a0ab377c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 17:59:14 +0800
Subject: [PATCH 2697/3374] Update 233-number-of-digit-one.js

---
 233-number-of-digit-one.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/233-number-of-digit-one.js b/233-number-of-digit-one.js
index 938403e6..e672d63f 100644
--- a/233-number-of-digit-one.js
+++ b/233-number-of-digit-one.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countDigitOne = function(n) {
+    return countNum(1, n + 1)
+};
+
+// Counts the number of `digit` in the range [0, limit)
+function countNum( digit,  limit) {
+  let count = 0;
+  let factor = 1;
+  let tail = 0;
+  while (limit >= 10) {
+    let d = limit % 10;
+    limit = ~~(limit / 10);
+    count += limit * factor;
+    count += d > digit ? factor : d == digit ? tail : 0;
+    tail += d * factor;
+    factor *= 10;
+  }
+  return count + (limit > digit ? factor : limit == digit ? tail : 0);
+}
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From 89ab6857950032d1aecc1134d6d757fa85e5413c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 18:06:09 +0800
Subject: [PATCH 2698/3374] Create 2769-find-the-maximum-achievable-number.js

---
 2769-find-the-maximum-achievable-number.js | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 2769-find-the-maximum-achievable-number.js

diff --git a/2769-find-the-maximum-achievable-number.js b/2769-find-the-maximum-achievable-number.js
new file mode 100644
index 00000000..db0ac464
--- /dev/null
+++ b/2769-find-the-maximum-achievable-number.js
@@ -0,0 +1,8 @@
+/**
+ * @param {number} num
+ * @param {number} t
+ * @return {number}
+ */
+const theMaximumAchievableX = function(num, t) {
+    return 2 * t + num
+};

From b86709430cb25947554bfdf534b3ccebe1e4c385 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 18:06:40 +0800
Subject: [PATCH 2699/3374] Create
 2770-maximum-number-of-jumps-to-reach-the-last-index.js

---
 ...number-of-jumps-to-reach-the-last-index.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2770-maximum-number-of-jumps-to-reach-the-last-index.js

diff --git a/2770-maximum-number-of-jumps-to-reach-the-last-index.js b/2770-maximum-number-of-jumps-to-reach-the-last-index.js
new file mode 100644
index 00000000..e1c26db5
--- /dev/null
+++ b/2770-maximum-number-of-jumps-to-reach-the-last-index.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var maximumJumps = function(nums, target) {
+  const n = nums.length
+  const dp = Array(n).fill(-1)
+  dp[0] = 0
+  for(let i = 0; i < n; i++) {
+    if(dp[i] === -1) continue
+    for(let j = i + 1; j < n; j++) {
+      if (nums[j] - nums[i] <= target && nums[j] - nums[i] >= -target) {
+        dp[j] = Math.max(dp[j], dp[i] + 1)
+      }
+    }
+  }
+  
+  return dp.at(-1)
+};
+

From aa333ddd8f330f45b180732c43ac5cdd442a392e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 18:07:12 +0800
Subject: [PATCH 2700/3374] Create
 2771-longest-non-decreasing-subarray-from-two-arrays.js

---
 ...non-decreasing-subarray-from-two-arrays.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2771-longest-non-decreasing-subarray-from-two-arrays.js

diff --git a/2771-longest-non-decreasing-subarray-from-two-arrays.js b/2771-longest-non-decreasing-subarray-from-two-arrays.js
new file mode 100644
index 00000000..5435776a
--- /dev/null
+++ b/2771-longest-non-decreasing-subarray-from-two-arrays.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var maxNonDecreasingLength = function(nums1, nums2) {
+    const n = nums1.length
+    let dp = Array(3).fill(1)
+    let ans = 1
+    const { max } = Math
+    for(let i = 1; i < n; i++) {
+      const nextDp = Array(3).fill(1)
+      if (nums1[i] >= nums1[i - 1]) {
+          nextDp[1] = max(nextDp[1], dp[1] + 1)
+      }
+      if (nums1[i] >= nums2[i - 1]) {
+          nextDp[1] = max(nextDp[1], dp[2] + 1)
+      }
+      if (nums2[i] >= nums1[i - 1]) {
+          nextDp[2] = max(nextDp[2], dp[1] + 1)
+      }
+      if (nums2[i] >= nums2[i - 1]) {
+          nextDp[2] = max(nextDp[2], dp[2] + 1)
+      }
+      dp = nextDp
+      // console.log(dp, nextDp)
+      ans = max(ans, max(...dp))
+    }
+    return ans
+};
+

From 83622e7d7188e90832083293f72a877466d673a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 18:07:46 +0800
Subject: [PATCH 2701/3374] Create
 2772-apply-operations-to-make-all-array-elements-equal-to-zero.js

---
 ...o-make-all-array-elements-equal-to-zero.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2772-apply-operations-to-make-all-array-elements-equal-to-zero.js

diff --git a/2772-apply-operations-to-make-all-array-elements-equal-to-zero.js b/2772-apply-operations-to-make-all-array-elements-equal-to-zero.js
new file mode 100644
index 00000000..bbc33d1e
--- /dev/null
+++ b/2772-apply-operations-to-make-all-array-elements-equal-to-zero.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+var checkArray = function(nums, k) {
+  let cur = 0
+  let diff = Array(nums.length).fill(0)
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    if (nums[i] != cur) {
+      diff[i] += nums[i] - cur
+      if( (i + k - 1) >= n ) return false
+      diff[i + k - 1] -= nums[i] - cur
+    }
+    if (nums[i] < cur) return false
+    cur += diff[i]
+  }
+  return true  
+};

From 20b791bf8b9d2925d3745d7f4f629d7390f62eff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Jul 2023 23:06:31 +0800
Subject: [PATCH 2702/3374] Update 233-number-of-digit-one.js

---
 233-number-of-digit-one.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/233-number-of-digit-one.js b/233-number-of-digit-one.js
index e672d63f..82678200 100644
--- a/233-number-of-digit-one.js
+++ b/233-number-of-digit-one.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countDigitOne = function(n) {
+  let res = 0
+  const str = `${n}`
+  const len = str.length, { pow } = Math
+  
+  for(let i = 1; i <= len; i++) {
+    const pre = ~~(n / pow(10, i))
+    const remain = n % (pow(10, i - 1))
+    const post = pow(10, i - 1)
+    res += pre * post
+    const e = +(str[len - i])
+    if(e > 1) {
+      res += pow(10, i - 1)
+    } else if(e === 1) {
+      res += remain + 1
+    }
+  }
+  
+  return res
+};
+
+
+// another
+
 /**
  * @param {number} n
  * @return {number}

From e06f56018cffb04f9e0e872d136d59387bf208fc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Jul 2023 17:24:27 +0800
Subject: [PATCH 2703/3374] Update 1067-digit-count-in-range.js

---
 1067-digit-count-in-range.js | 47 ++++++++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1067-digit-count-in-range.js b/1067-digit-count-in-range.js
index 55a147f6..7b75d18d 100644
--- a/1067-digit-count-in-range.js
+++ b/1067-digit-count-in-range.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number} d
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const digitsCount = function(d, low, high) {
+  return countDigit(high, d) - countDigit(low - 1, d)
+};
+function countDigit(limit, d) {
+  let res = 0
+  const str = `${limit}`
+  const len = str.length
+  const { pow } = Math
+  if(d === 0) {
+    for(let i = 1; i < len; i++) {
+      const pre = ~~(limit / pow(10, i))
+      const post = pow(10, i - 1)
+      res += (pre - 1) * post
+      const e = +str[len - i]
+      if(e > d) {
+        res += post
+      } else if(e === d) {
+        res += (limit % post) + 1
+      }
+    }    
+  } else {
+    for(let i = 1; i <= len; i++) {
+      const pre = ~~(limit / pow(10, i))
+      const post = pow(10, i - 1)
+      res += pre * post
+      const e = +str[len - i]
+      if(e > d) {
+        res += post
+      } else if(e === d) {
+        res += (limit % post) + 1
+      }
+    }  
+  }
+  
+  
+  return res
+}
+
+
+// another
+
 /**
  * @param {number} d
  * @param {number} low

From 95401de9a0c69abff59a395393f4e025828191c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Jul 2023 15:02:30 +0800
Subject: [PATCH 2704/3374] Update 902-numbers-at-most-n-given-digit-set.js

---
 902-numbers-at-most-n-given-digit-set.js | 35 ++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/902-numbers-at-most-n-given-digit-set.js b/902-numbers-at-most-n-given-digit-set.js
index c45b9fef..8793d275 100644
--- a/902-numbers-at-most-n-given-digit-set.js
+++ b/902-numbers-at-most-n-given-digit-set.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string[]} digits
+ * @param {number} n
+ * @return {number}
+ */
+const atMostNGivenDigitSet = function(digits, n) {
+  let res = 0
+  const str = `${n}`, len = str.length
+  const { pow } = Math, base = digits.length
+  for(let i = 1; i < len; i++) {
+    res += pow(base, i)
+  }
+  
+  dfs(0)
+  
+  return res
+  
+  function dfs(pos) {
+    if(pos === len) {
+      res++
+      return
+    }
+    for(const ch of digits) {
+      if(str[pos] > ch) {
+        res += pow(base, len - 1 - pos)
+      } else if(str[pos] === ch) {
+        dfs(pos + 1)
+      }
+    }
+  }
+};
+
+// another
+
+
 /**
  * @param {string[]} digits
  * @param {number} n

From cda02c04c769741d5defebbb239f269b77b0d375 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Jul 2023 15:08:26 +0800
Subject: [PATCH 2705/3374] Update 902-numbers-at-most-n-given-digit-set.js

---
 902-numbers-at-most-n-given-digit-set.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/902-numbers-at-most-n-given-digit-set.js b/902-numbers-at-most-n-given-digit-set.js
index 8793d275..2e5da545 100644
--- a/902-numbers-at-most-n-given-digit-set.js
+++ b/902-numbers-at-most-n-given-digit-set.js
@@ -25,7 +25,7 @@ const atMostNGivenDigitSet = function(digits, n) {
         res += pow(base, len - 1 - pos)
       } else if(str[pos] === ch) {
         dfs(pos + 1)
-      }
+      } else break
     }
   }
 };

From 50f8904322d06dc17b0dc04282c58f6defe48123 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 13 Jul 2023 14:41:24 +0800
Subject: [PATCH 2706/3374] Update 60-permutation-sequence.js

---
 60-permutation-sequence.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/60-permutation-sequence.js b/60-permutation-sequence.js
index f25ea1a4..ea812807 100644
--- a/60-permutation-sequence.js
+++ b/60-permutation-sequence.js
@@ -62,6 +62,36 @@ const getPermutation = function(n, k) {
 
 // another
 
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {string}
+ */
+const getPermutation = function(n, k) {
+  const fact = []
+  const nums = []
+  for(let i = 1; i <= n; i++) {
+    nums.push(i)
+  }
+  fact[0] = 1
+  for(let i = 1, tmp = 1; i <= n; i++) {
+    tmp *= i
+    fact[i] = tmp
+  }
+  let res = ''
+  k--
+  for(let i = 1; i <= n; i++) {
+    const idx = ~~(k / fact[n - i])
+    res += nums[idx]
+    nums.splice(idx, 1)
+    k -= idx * fact[n - i]
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} k

From dec9c086dba3897e978509e62b64550814ce9103 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Jul 2023 13:50:13 +0800
Subject: [PATCH 2707/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 29 ++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index ed497d7b..f597e751 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarraysWithKDistinct = function(nums, k) {
+  return mostK(k) - mostK(k - 1)
+  function mostK(limit) {
+    const map = new Map()
+    let i = 0, j = 0, res = 0
+    const n = nums.length
+    for(; j< n; j++) {
+      const e = nums[j]
+      map.set(e, (map.get(e) || 0) + 1)
+      while(map.size > limit) {
+        const tmp = nums[i]
+        map.set(tmp, (map.get(tmp) || 0) - 1)
+        if(map.get(tmp) === 0) map.delete(tmp)
+        i++
+      }
+      res += j - i + 1
+    }
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} K

From 8f38541dcd8cdc3ce3697628ffbd994d582bc01b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jul 2023 18:19:06 +0800
Subject: [PATCH 2708/3374] Create
 2781-length-of-the-longest-valid-substring.js

---
 2781-length-of-the-longest-valid-substring.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2781-length-of-the-longest-valid-substring.js

diff --git a/2781-length-of-the-longest-valid-substring.js b/2781-length-of-the-longest-valid-substring.js
new file mode 100644
index 00000000..d938a9be
--- /dev/null
+++ b/2781-length-of-the-longest-valid-substring.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} word
+ * @param {string[]} forbidden
+ * @return {number}
+ */
+var longestValidSubstring = function(word, forbidden) {
+  let setF = new Set(forbidden)
+  let res = 0, left = 0
+  for(let i = 0; i < word.length; i++) {
+    for(let j = Math.max(left, i - 10); j < i + 1; j++) {
+      if(setF.has(word.slice(j, i + 1))) {
+        left = j + 1
+      }
+    }
+    res = Math.max(res, i - left + 1)
+  }
+  return res
+};

From bd93f3f26f775ca6f0d57c8d36142bfe45acebe8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jul 2023 18:19:45 +0800
Subject: [PATCH 2709/3374] Create 2780-minimum-index-of-a-valid-split.js

---
 2780-minimum-index-of-a-valid-split.js | 30 ++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2780-minimum-index-of-a-valid-split.js

diff --git a/2780-minimum-index-of-a-valid-split.js b/2780-minimum-index-of-a-valid-split.js
new file mode 100644
index 00000000..99b54191
--- /dev/null
+++ b/2780-minimum-index-of-a-valid-split.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumIndex = function(nums) {
+	let n = nums.length
+	if (n == 1) {
+		return -1
+	}
+	let mp = {}
+	let mx = 0
+	for (const num of nums) {
+    if(mp[num] == null) mp[num] = 0
+		mp[num]++
+		if (mp[num] > n/2) {
+			mx = num
+		}
+	}
+	let c = 0
+	for (let i = 0; i < n-1; i++) {
+		let num = nums[i]
+		if (num == mx) {
+			c++
+		}
+		if (c > (i+1)/2 && mp[mx]-c > (n-i-1)/2) {
+			return i
+		}
+	}
+	return -1
+};

From a82062f019fc7ddf70f47cb3488c7f47e4bc35f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jul 2023 18:20:45 +0800
Subject: [PATCH 2710/3374] Create
 2779-maximum-beauty-of-an-array-after-applying-operation.js

---
 ...ty-of-an-array-after-applying-operation.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2779-maximum-beauty-of-an-array-after-applying-operation.js

diff --git a/2779-maximum-beauty-of-an-array-after-applying-operation.js b/2779-maximum-beauty-of-an-array-after-applying-operation.js
new file mode 100644
index 00000000..cd45bff2
--- /dev/null
+++ b/2779-maximum-beauty-of-an-array-after-applying-operation.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumBeauty = function(nums, k) {
+	nums.sort((a, b)  => a - b)
+	let n = nums.length
+	let res = 0
+	let l = 0, r = 0
+	while( r < n) {
+		if (nums[l]+k >= nums[r]-k) {
+			if (r-l+1 > res) {
+				res = r - l + 1
+			}
+			r++
+		} else {
+			l++
+		}
+	}
+	if (r-l > res) {
+		res = r - l
+	}
+	return res
+};

From 9a5e8712704c49780fb0658073ddfff4fb8cd3fa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jul 2023 18:21:15 +0800
Subject: [PATCH 2711/3374] Create 2778-sum-of-squares-of-special-elements.js

---
 2778-sum-of-squares-of-special-elements.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2778-sum-of-squares-of-special-elements.js

diff --git a/2778-sum-of-squares-of-special-elements.js b/2778-sum-of-squares-of-special-elements.js
new file mode 100644
index 00000000..621da5ef
--- /dev/null
+++ b/2778-sum-of-squares-of-special-elements.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var sumOfSquares = function(nums) {
+  const n  = nums.length
+  let res = 0
+  
+  for(let i = 1; i <= n; i++) {
+    if(n % i === 0) res += nums[i - 1] ** 2
+  }
+  
+  return res
+};

From cf014f9a2265eb52b87d2c9de6154e41d70d80c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Jul 2023 11:30:16 +0800
Subject: [PATCH 2712/3374] Create 2537-count-the-number-of-good-subarrays.js

---
 2537-count-the-number-of-good-subarrays.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2537-count-the-number-of-good-subarrays.js

diff --git a/2537-count-the-number-of-good-subarrays.js b/2537-count-the-number-of-good-subarrays.js
new file mode 100644
index 00000000..31b95aae
--- /dev/null
+++ b/2537-count-the-number-of-good-subarrays.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countGood = function(nums, k) {
+  let res = 0;
+  const count = new Map()
+  for(let i = 0, j = 0; j < nums.length; ++j){
+    k -= count.get(nums[j]) || 0;
+    count.set(nums[j], (count.get(nums[j]) || 0) + 1);
+    while(k <= 0) {
+      count.set(nums[i],count.get(nums[i]) - 1);
+      k += count.get(nums[i]);
+      i++
+    }
+    res += i;
+  }
+  return res;
+};

From ca489ca0a5c9118afe99ee0f051aba55873f266b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Jul 2023 12:13:53 +0800
Subject: [PATCH 2713/3374] Update 2537-count-the-number-of-good-subarrays.js

---
 2537-count-the-number-of-good-subarrays.js | 39 ++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/2537-count-the-number-of-good-subarrays.js b/2537-count-the-number-of-good-subarrays.js
index 31b95aae..58df8f51 100644
--- a/2537-count-the-number-of-good-subarrays.js
+++ b/2537-count-the-number-of-good-subarrays.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countGood = function(nums, k) {
+  let res = 0, total = 0
+  const cnt = {}, n = nums.length
+
+  for(let i = 0, j = 0; i < n; i++) {
+    
+    while(j < n && total < k) {
+      total += diff(nums[j], 1)
+      cnt[nums[j]] = (cnt[nums[j]] || 0) + 1
+      j++
+    }
+    
+    if(total >= k) {
+      res += n - j + 1
+    }
+    total += diff(nums[i], -1)
+    cnt[nums[i]]--
+  }
+  
+  return res
+  
+  function diff(num, delta) {
+    const pre = cnt[num] || 0
+    const old = pre * (pre - 1) / 2
+    const post = pre + delta
+    const cur = post * (post - 1) / 2
+    
+    return cur - old
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From c186fb1f55cad54e0eaeacc965d6eaffcfcec58f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Jul 2023 12:33:29 +0800
Subject: [PATCH 2714/3374] Create 2564-substring-xor-queries.js

---
 2564-substring-xor-queries.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 2564-substring-xor-queries.js

diff --git a/2564-substring-xor-queries.js b/2564-substring-xor-queries.js
new file mode 100644
index 00000000..f689aefb
--- /dev/null
+++ b/2564-substring-xor-queries.js
@@ -0,0 +1,30 @@
+/**
+ * @param {string} s
+ * @param {number[][]} queries
+ * @return {number[][]}
+ */
+const substringXorQueries = function(s, queries) {
+  const n = s.length, q = queries.length
+  const res = []
+  const map = {}, { max, min } = Math, int = parseInt, big = BigInt
+  
+  for(let i = 0; i < n; i++) {
+    if(s[i] === '0') {
+      if(map[0] == null) map[0] = [i, i]
+      continue
+    }
+    let num = 0n
+    for(let j = i; j <= min(i + 32, n - 1); j++) {
+      num = (num << 1n) + big(int(s[j]))
+      if(map[num] == null) map[num] = [i, j]
+    }
+  }
+  for(let i = 0; i < q; i++) {
+    const [fir, sec] = queries[i]
+    const num = fir ^ sec
+    if(map[num] != null) res.push([...map[num]])
+    else res.push([-1, -1])
+  }
+  
+  return res
+};

From a512dae8ef3f377884b99bd029ea14034340de7c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Jul 2023 17:27:01 +0800
Subject: [PATCH 2715/3374] Create
 2730-find-the-longest-semi-repetitive-substring.js

---
 ...d-the-longest-semi-repetitive-substring.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2730-find-the-longest-semi-repetitive-substring.js

diff --git a/2730-find-the-longest-semi-repetitive-substring.js b/2730-find-the-longest-semi-repetitive-substring.js
new file mode 100644
index 00000000..cfb15f6b
--- /dev/null
+++ b/2730-find-the-longest-semi-repetitive-substring.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestSemiRepetitiveSubstring = function(s) {
+  let res = 1
+  let i = 0, j = 1, last = 0
+  while(j <  s.length) {
+    if(s[j] === s[j - 1]) {
+      if(last) i = last
+      last = j
+    }
+    
+    res = Math.max(res, j - i + 1)
+    j++
+  }
+  
+  return res
+};

From badd49c2eb1d1d81ba7d05b806a23d963c9e6a6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 20 Jul 2023 21:25:44 +0800
Subject: [PATCH 2716/3374] Update 2762-continuous-subarrays.js

---
 2762-continuous-subarrays.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2762-continuous-subarrays.js b/2762-continuous-subarrays.js
index 54ab362a..d812a6f4 100644
--- a/2762-continuous-subarrays.js
+++ b/2762-continuous-subarrays.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const continuousSubarrays = function(nums) {
+  let res = 0
+  let l = 0
+  let r = 0
+  const mq1 = [], mq2 = []
+  for(let r = 0; r < nums.length; r++) {
+    const e = nums[r]
+    while(mq1.length && nums[mq1.at(-1)] < e) mq1.pop()
+    mq1.push(r)
+    while(mq2.length && nums[mq2.at(-1)] > e) mq2.pop()
+    mq2.push(r)
+    
+    while(mq1.length && mq2.length && Math.abs(nums[mq1[0]] - nums[mq2[0]]) > 2) {
+      if(mq1.length && mq1[0] <= l) mq1.shift()
+      if(mq2.length && mq2[0] <= l) mq2.shift()
+      l++
+    }
+    
+    res += r - l + 1
+  }
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From 992c6c7df4fa8a8228e08be70e9b59533a554703 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Jul 2023 19:49:28 +0800
Subject: [PATCH 2717/3374] Create 2747-count-zero-request-servers.js

---
 2747-count-zero-request-servers.js | 56 ++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2747-count-zero-request-servers.js

diff --git a/2747-count-zero-request-servers.js b/2747-count-zero-request-servers.js
new file mode 100644
index 00000000..58b6a4f9
--- /dev/null
+++ b/2747-count-zero-request-servers.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number} n
+ * @param {number[][]} logs
+ * @param {number} x
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const countServers = function(n, logs, x, queries) {
+let queryArr = [],
+  ans = []
+for (let i = 0; i < queries.length; i++) {
+  queryArr.push([i, queries[i]])
+}
+queryArr.sort(function (a, b) {
+  return a[1] - b[1]
+})
+logs.sort(function (a, b) {
+  return a[1] - b[1]
+})
+
+let sumOfServersInCurrentTimeWindow = 0,
+  serverFrequenceyInCurrentTimeWindow = []
+for (let i = 0, left = 0, right = 0; i < queryArr.length; i++) {
+  let queryIndex = queryArr[i][0]
+  let startTime = queryArr[i][1] - x //Start time for the current query
+  let endTime = queryArr[i][1] //End time for the current query
+  while (right < logs.length && logs[right][1] <= endTime) {
+    //Include all the servers till endTime
+    let s = logs[right][0]
+    if (
+      serverFrequenceyInCurrentTimeWindow[s] === undefined ||
+      serverFrequenceyInCurrentTimeWindow[s] === 0
+    ) {
+      serverFrequenceyInCurrentTimeWindow[s] = 1
+      sumOfServersInCurrentTimeWindow++
+    } else {
+      serverFrequenceyInCurrentTimeWindow[s] += 1
+    }
+    right++
+  }
+  while (left < logs.length && logs[left][1] < startTime) {
+    //Exclude all the servers older than startTime
+    let s = logs[left][0]
+    if (serverFrequenceyInCurrentTimeWindow[s] === 1) {
+      serverFrequenceyInCurrentTimeWindow[s] = 0
+      sumOfServersInCurrentTimeWindow--
+    } else {
+      serverFrequenceyInCurrentTimeWindow[s] -= 1
+    }
+    left++
+  }
+  ans[queryIndex] = n - sumOfServersInCurrentTimeWindow
+}
+return ans
+
+};

From d2add3e8c91c217a94d71ceb4671934d8114064f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 22 Jul 2023 19:46:28 +0800
Subject: [PATCH 2718/3374] Create
 1503-last-moment-before-all-ants-fall-out-of-a-plank.js

---
 ...oment-before-all-ants-fall-out-of-a-plank.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1503-last-moment-before-all-ants-fall-out-of-a-plank.js

diff --git a/1503-last-moment-before-all-ants-fall-out-of-a-plank.js b/1503-last-moment-before-all-ants-fall-out-of-a-plank.js
new file mode 100644
index 00000000..af5ef123
--- /dev/null
+++ b/1503-last-moment-before-all-ants-fall-out-of-a-plank.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number[]} left
+ * @param {number[]} right
+ * @return {number}
+ */
+var getLastMoment = function(n, left, right) {
+    left.sort(function(a,b){return a-b});
+    right.sort(function(a,b){return a-b});
+    if(left.length == 0){
+        return n-right[0];
+    }
+    if(right.length == 0){
+        return left[left.length-1];
+    }
+    return Math.max(left[left.length-1], n-right[0])
+};

From 9ace2333e420ce94fb3d4b10ba3ee29430f6b586 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Jul 2023 12:06:26 +0800
Subject: [PATCH 2719/3374] Update 735-asteroid-collision.js

---
 735-asteroid-collision.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/735-asteroid-collision.js b/735-asteroid-collision.js
index 35b768f7..f48a26b0 100644
--- a/735-asteroid-collision.js
+++ b/735-asteroid-collision.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[]} asteroids
+ * @return {number[]}
+ */
+const asteroidCollision = function(asteroids) {
+  const stk = [], n = asteroids.length, {abs} = Math
+  for(const e of asteroids) {
+    while(stk.length && stk.at(-1) > 0 && e < 0 && -e > stk.at(-1)) {
+      stk.pop()
+    }
+    if(stk.length && stk.at(-1) > 0 && e < 0 && -e === stk.at(-1)) {
+      stk.pop()
+    }else if(stk.length && stk.at(-1) > 0 && e < 0 && -e < stk.at(-1)) {
+      
+    }else stk.push(e)
+  }
+  return stk
+};
+
+// another
+
+
 /**
  * @param {number[]} asteroids
  * @return {number[]}

From a852473795b903606852a57e7934f4c24effde58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Jul 2023 13:16:37 +0800
Subject: [PATCH 2720/3374] Create 2751-robot-collisions.js

---
 2751-robot-collisions.js | 45 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 2751-robot-collisions.js

diff --git a/2751-robot-collisions.js b/2751-robot-collisions.js
new file mode 100644
index 00000000..c45f2602
--- /dev/null
+++ b/2751-robot-collisions.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} positions
+ * @param {number[]} healths
+ * @param {string} directions
+ * @return {number[]}
+ */
+const survivedRobotsHealths = function (positions, healths, directions) {
+  const p = positions,
+    h = healths,
+    d = directions
+  let m = {},
+    res = Array(p.length).fill(0)
+  p.map((x, i) => (m[x] = d[i] == 'R' ? [h[i], i] : [-h[i], i]))
+  let a = []
+  for (const k in m) a.push(m[k])
+  let v = asteroidCollision(a)
+  for (const [x, i] of v) res[i] = Math.abs(x)
+  return res.filter((x) => x != 0)
+}
+
+function asteroidCollision(a) {
+  let st = []
+  for (const [x, i] of a) {
+    st.push([x, i])
+    let l, li, sl, sli
+    if (st.length >= 1) [l, li] = st[st.length - 1]
+    if (st.length >= 2) [sl, sli] = st[st.length - 2]
+    while (st.length >= 2 && l < 0 && sl > 0) {
+      st.pop()
+      st.pop()
+      let add, idx
+      if (-l > sl) {
+        add = -(-l - 1)
+        idx = li
+      } else if (-l < sl) {
+        add = sl - 1
+        idx = sli
+      }
+      if (add) st.push([add, idx])
+      if (st.length >= 1) [l, li] = st[st.length - 1]
+      if (st.length >= 2) [sl, sli] = st[st.length - 2]
+    }
+  }
+  return st
+}

From f01cfcacb5a1c81b94123c5729100d2c02751bf6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jul 2023 19:30:06 +0800
Subject: [PATCH 2721/3374] Create 2799-count-complete-subarrays-in-an-array.js

---
 2799-count-complete-subarrays-in-an-array.js | 23 ++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2799-count-complete-subarrays-in-an-array.js

diff --git a/2799-count-complete-subarrays-in-an-array.js b/2799-count-complete-subarrays-in-an-array.js
new file mode 100644
index 00000000..7218b364
--- /dev/null
+++ b/2799-count-complete-subarrays-in-an-array.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countCompleteSubarrays = function(nums) {
+  const set = new Set(nums)
+  const size = set.size
+
+  let res = 0
+  const n = nums.length
+
+  for(let i = 0; i < n; i++) {
+    const s = new Set()
+    s.add(nums[i])
+    for(let j = i; j < n; j++) {
+      s.add(nums[j])
+      if(s.size === size) res++
+    }
+  }
+  
+  return res
+  
+};

From 62fa7a8c07fcd1170ae19f0661ff9778ef8b048d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jul 2023 19:30:52 +0800
Subject: [PATCH 2722/3374] Create
 2798-number-of-employees-who-met-the-target.js

---
 2798-number-of-employees-who-met-the-target.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2798-number-of-employees-who-met-the-target.js

diff --git a/2798-number-of-employees-who-met-the-target.js b/2798-number-of-employees-who-met-the-target.js
new file mode 100644
index 00000000..09b41092
--- /dev/null
+++ b/2798-number-of-employees-who-met-the-target.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} hours
+ * @param {number} target
+ * @return {number}
+ */
+var numberOfEmployeesWhoMetTarget = function(hours, target) {
+  let res = 0
+  for(const e of hours) {
+    if(e >= target) res++
+  }
+  
+  return res
+};

From b7654700b0157abdec5429121ba22d255d66ed64 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jul 2023 19:33:12 +0800
Subject: [PATCH 2723/3374] Create 2801-count-stepping-numbers-in-range.js

---
 2801-count-stepping-numbers-in-range.js | 35 +++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2801-count-stepping-numbers-in-range.js

diff --git a/2801-count-stepping-numbers-in-range.js b/2801-count-stepping-numbers-in-range.js
new file mode 100644
index 00000000..8fbb85c9
--- /dev/null
+++ b/2801-count-stepping-numbers-in-range.js
@@ -0,0 +1,35 @@
+const minus_mod = (x, y, mod) => ((x - y) % mod + mod) % mod;
+const mod = 1e9 + 7, ll = BigInt;
+let memo;
+const go = (s) => {
+    memo = new Map();
+    return dfs(0, 0, true, false, s);
+};
+
+const dfs = (i, mask, isLimit, isNum, s) => {
+    let ke = i + " " + mask + " " + isLimit + " " + isNum;
+    if (memo.has(ke)) return memo.get(ke);
+    if (i == s.length) return isNum - '0';
+    let res = 0;
+    if (!isNum) res = dfs(i + 1, mask, false, false, s);
+    let leading = isNum ? 0 : 1;
+    let up = isLimit ? s[i] - '0' : 9;
+    for (let digit = leading; digit <= up; digit++) {
+        if (!isNum || Math.abs(digit - mask) == 1) {
+            res += dfs(i + 1, digit, isLimit && digit == up, true, s);
+        }
+    }
+    res %= mod;
+    memo.set(ke, res);
+    return res;
+};
+/**
+ * @param {string} low
+ * @param {string} high
+ * @return {number}
+ */
+const countSteppingNumbers = (low, high) => {
+    let x = go(high), y = go((ll(low) - 1n).toString());
+    return minus_mod(x, y, mod);
+};
+

From 6c71a45493d44974e24b62a83adb87c3fd13f1a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jul 2023 19:35:08 +0800
Subject: [PATCH 2724/3374] Create
 2800-shortest-string-that-contains-three-strings.js

---
 ...test-string-that-contains-three-strings.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2800-shortest-string-that-contains-three-strings.js

diff --git a/2800-shortest-string-that-contains-three-strings.js b/2800-shortest-string-that-contains-three-strings.js
new file mode 100644
index 00000000..dd53a0b4
--- /dev/null
+++ b/2800-shortest-string-that-contains-three-strings.js
@@ -0,0 +1,23 @@
+const lexical_smallest_comp = (x, y) => x < y ? -1 : x > y ? 1 : 0;
+const merge = (s, t) => {
+    if (s.indexOf(t) != -1) return s;
+    // concat based on suffix
+    for (let l = Math.min(s.length, t.length); l > 0; l--) {
+        if (s.slice(-l) == t.slice(0, l)) return s.slice(0, -l) + t;
+    }
+    return s + t;
+};
+/**
+ * @param {string} a
+ * @param {string} b
+ * @param {string} c
+ * @return {string}
+ */
+const minimumString = (a, b, c) => {
+    let d = [merge(merge(a, b), c), merge(merge(a, c), b), merge(merge(b, a), c), merge(merge(b, c), a), merge(merge(c, a), b), merge(merge(c, b), a)];
+    d.sort((x, y) => {
+        if (x.length != y.length) return x.length - y.length;
+        return lexical_smallest_comp(x, y);
+    })
+    return d[0];
+};

From a7e66369aa4e8fd4b95d67119c86e0878b5a44e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jul 2023 20:10:56 +0800
Subject: [PATCH 2725/3374] Update 2799-count-complete-subarrays-in-an-array.js

---
 2799-count-complete-subarrays-in-an-array.js | 30 ++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/2799-count-complete-subarrays-in-an-array.js b/2799-count-complete-subarrays-in-an-array.js
index 7218b364..dd6d4307 100644
--- a/2799-count-complete-subarrays-in-an-array.js
+++ b/2799-count-complete-subarrays-in-an-array.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countCompleteSubarrays = function(nums) {
+  const set = new Set(nums)
+  const size = set.size
+  const hash = new Map()
+
+  let res = 0, i = 0, j = 0
+  const n = nums.length
+
+  while(i < n) {
+    const e = nums[i]
+    hash.set(e, (hash.get(e) || 0) + 1)
+    while(j <= i && size === hash.size) {
+      const pre = nums[j]
+      hash.set(pre, hash.get(pre) - 1)
+      if(hash.get(pre) === 0) hash.delete(pre)
+      res += n - i
+      j++
+    }
+    i++
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 505f7647aca05246005aaba39690cd25977a4b6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 Jul 2023 19:10:38 +0800
Subject: [PATCH 2726/3374] Create 2547-minimum-cost-to-split-an-array.js

---
 2547-minimum-cost-to-split-an-array.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2547-minimum-cost-to-split-an-array.js

diff --git a/2547-minimum-cost-to-split-an-array.js b/2547-minimum-cost-to-split-an-array.js
new file mode 100644
index 00000000..a04c2441
--- /dev/null
+++ b/2547-minimum-cost-to-split-an-array.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minCost = function (nums, k) {
+  const n = nums.length,
+    max = Math.max(...nums),
+    dp = Array(n + 1).fill(Number.MAX_SAFE_INTEGER)
+  dp[0] = 0
+  for (let i = 0; i < n; i++) {
+    let f = Array(max + 1).fill(0),
+      cost = 0
+    for (let j = i; j < n; j++) {
+      f[nums[j]]++
+      if (f[nums[j]] == 2) {
+        cost += 2
+      } else if (f[nums[j]] > 2) {
+        cost++
+      }
+      dp[j + 1] = Math.min(dp[i] + cost + k, dp[j + 1])
+    }
+  }
+  return dp[n]
+}

From 0feb7800bd11d00d5a531c6c63ae4af54fa98363 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 31 Jul 2023 19:28:41 +0800
Subject: [PATCH 2727/3374] Update 2547-minimum-cost-to-split-an-array.js

---
 2547-minimum-cost-to-split-an-array.js | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2547-minimum-cost-to-split-an-array.js b/2547-minimum-cost-to-split-an-array.js
index a04c2441..8ff46ae8 100644
--- a/2547-minimum-cost-to-split-an-array.js
+++ b/2547-minimum-cost-to-split-an-array.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minCost = function (nums, k) {
+  const n = nums.length
+  const dp = Array(n + 1).fill(Infinity)
+  for(let i = 0; i < n; i++) {
+    let score = 0, hash = {}
+    for(let j = i; j >= 0; j--) {
+      const e = nums[j]
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+      if(hash[e] === 2) score += 2
+      else if(hash[e] > 2) score++
+      
+      if(j > 0) dp[i] = Math.min(dp[i], dp[j - 1] + score + k)
+      else dp[i] = Math.min(dp[i], score + k)
+    }
+  }
+  
+  return dp[n - 1]
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From b6173e71cf3be95597865dcf5a338801efb5c486 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Aug 2023 18:58:34 +0800
Subject: [PATCH 2728/3374] Create 2552-count-increasing-quadruplets.js

---
 2552-count-increasing-quadruplets.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2552-count-increasing-quadruplets.js

diff --git a/2552-count-increasing-quadruplets.js b/2552-count-increasing-quadruplets.js
new file mode 100644
index 00000000..b7f08c53
--- /dev/null
+++ b/2552-count-increasing-quadruplets.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countQuadruplets = function(nums) {
+  const B = new Array(nums.length + 1).fill(0);
+  let quadruplets = 0;
+
+  for (let i = 0; i < nums.length; i += 1) {
+    let countSmaller = 0;
+
+    for (let j = 0; j < i; j += 1) {
+      if (nums[j] < nums[i]) {
+        countSmaller += 1;
+        quadruplets += B[nums[j]];
+      } else {
+	    // countSmaller is all the As nums[j] is the B, nums[i] is C
+		  // so nums[j] is apart of countSmaller A-B-C relationships with nums[i]
+        B[nums[j]] += countSmaller;
+      }
+    }
+  }
+
+  return quadruplets
+};

From 94f0a4d749a528d006f9409cd975c71e812dcd42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 1 Aug 2023 19:56:20 +0800
Subject: [PATCH 2729/3374] Update 2552-count-increasing-quadruplets.js

---
 2552-count-increasing-quadruplets.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2552-count-increasing-quadruplets.js b/2552-count-increasing-quadruplets.js
index b7f08c53..89e05c6e 100644
--- a/2552-count-increasing-quadruplets.js
+++ b/2552-count-increasing-quadruplets.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countQuadruplets = function(nums) {
+  let res = 0, n = nums.length
+  const cnt = Array(n).fill(0)
+  
+  for(let j = 0; j < n; j++) {
+    let preSmall = 0
+    for(let i = 0; i < j; i++) {
+      if(nums[i] < nums[j]) {
+        preSmall++
+        res += cnt[i]
+      } else if(nums[j] < nums[i]) {
+        cnt[i] += preSmall
+      }
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 200f06f228cdf0f0f0e6feaafdef92dee199762f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 2 Aug 2023 11:54:36 +0800
Subject: [PATCH 2730/3374] Create
 2522-partition-string-into-substrings-with-values-at-most-k.js

---
 ...g-into-substrings-with-values-at-most-k.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2522-partition-string-into-substrings-with-values-at-most-k.js

diff --git a/2522-partition-string-into-substrings-with-values-at-most-k.js b/2522-partition-string-into-substrings-with-values-at-most-k.js
new file mode 100644
index 00000000..706d07c7
--- /dev/null
+++ b/2522-partition-string-into-substrings-with-values-at-most-k.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const minimumPartition = function(s, k) {
+  const n = s.length, m = `${k}`.length
+  const dp = Array(n + 1).fill(0)
+  for(let i = 0; i < n; i++) {
+    if(m === 1 && +s[i] > k) return -1
+  }
+  s = '#' + s
+  for(let i = 1; i <= n; i++) {
+    if(i - m + 1 > 0 && s.slice(i - m + 1, i + 1) <= k) {
+      dp[i] = dp[i - m] + 1
+    } else {
+      dp[i] = dp[Math.max(0, i - m + 1)] + 1
+    }
+  }
+  
+  return dp[n]
+};

From 4f2aed85b8351cb88c9c5da2564f2d2f55c49682 Mon Sep 17 00:00:00 2001
From: tunakite <113432700+Tunakite03@users.noreply.github.com>
Date: Fri, 4 Aug 2023 22:32:24 +0700
Subject: [PATCH 2731/3374] Update 7-reverse-integer.js

add another
---
 7-reverse-integer.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/7-reverse-integer.js b/7-reverse-integer.js
index 4a2fef60..1048c8cf 100755
--- a/7-reverse-integer.js
+++ b/7-reverse-integer.js
@@ -40,3 +40,22 @@ const reverse = function(num) {
   if (negative) return result * -1;
   return result;
 };
+
+// another 
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const reverse = (n) => {
+    if (typeof n !== 'number') {
+        throw new Error('n must be a number');
+    }
+    let sign = Math.sign(n);
+    n = Math.abs(n);
+    if (n < 0) {
+        return -reverse(-n);
+    }
+    let reversed = Number([...n.toString()].reverse().join(''));
+    return sign * reversed;
+}

From 5ef3e4b21022a93c7c9a0e8fc129a73224995d08 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 5 Aug 2023 01:06:36 +0800
Subject: [PATCH 2732/3374] Create 2597-the-number-of-beautiful-subsets.js

---
 2597-the-number-of-beautiful-subsets.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2597-the-number-of-beautiful-subsets.js

diff --git a/2597-the-number-of-beautiful-subsets.js b/2597-the-number-of-beautiful-subsets.js
new file mode 100644
index 00000000..308352a3
--- /dev/null
+++ b/2597-the-number-of-beautiful-subsets.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var beautifulSubsets = function (nums, k) {
+  let output = 0
+  const pick = function (nums, k) {
+    if (nums.length > 0) {
+      for (let i = 0; i < nums.length; i++) {
+        output++
+        let arr = nums.slice(i + 1)
+        arr = arr.filter((e) => Math.abs(e - nums[i]) != k)
+        pick(arr, k)
+      }
+    }
+  }
+  pick(nums, k)
+  return output
+}

From 13f90316025a4cb8e12470a67fc4f49a18c7aa8f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Aug 2023 09:19:47 +0800
Subject: [PATCH 2733/3374] Create 2638-count-the-number-of-k-free-subsets.js

---
 2638-count-the-number-of-k-free-subsets.js | 36 ++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2638-count-the-number-of-k-free-subsets.js

diff --git a/2638-count-the-number-of-k-free-subsets.js b/2638-count-the-number-of-k-free-subsets.js
new file mode 100644
index 00000000..5005da89
--- /dev/null
+++ b/2638-count-the-number-of-k-free-subsets.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countTheNumOfKFreeSubsets = function (nums, k) {
+  let res = 1
+  const marr = Array.from({ length: k }, () => Array())
+  for (const e of nums) {
+    marr[e % k].push(e)
+  }
+
+  for (let i = 0; i < k; i++) {
+    res *= helper(marr[i])
+  }
+
+  return res
+
+  function helper(arr) {
+    arr.sort((a, b) => a - b)
+    let take = 0,
+      no_take = 1
+    for (let i = 0; i < arr.length; i++) {
+      let take_temp = take,
+        no_take_temp = no_take
+      if (i >= 1 && arr[i] == arr[i - 1] + k) {
+        take = no_take_temp
+        no_take = take_temp + no_take_temp
+      } else {
+        take = take_temp + no_take_temp
+        no_take = take_temp + no_take_temp
+      }
+    }
+    return take + no_take
+  }
+}

From ba8ffa4529ad9866801f5723ca999d08afadc20a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Aug 2023 19:39:37 +0800
Subject: [PATCH 2734/3374] Create 2810-faulty-keyboard.js

---
 2810-faulty-keyboard.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2810-faulty-keyboard.js

diff --git a/2810-faulty-keyboard.js b/2810-faulty-keyboard.js
new file mode 100644
index 00000000..1eb78b4f
--- /dev/null
+++ b/2810-faulty-keyboard.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+const finalString = function(s) {
+  const arr = []
+  for(const ch of s) {
+    if(ch === 'i') {
+      arr.reverse()
+    } else {
+      arr.push(ch)
+    }
+  }
+  
+  return arr.join('')
+};

From 95601a4c4e6c5d1c390ff14a84514853ceea62d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Aug 2023 19:40:04 +0800
Subject: [PATCH 2735/3374] Create
 2811-check-if-it-is-possible-to-split-array.js

---
 2811-check-if-it-is-possible-to-split-array.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2811-check-if-it-is-possible-to-split-array.js

diff --git a/2811-check-if-it-is-possible-to-split-array.js b/2811-check-if-it-is-possible-to-split-array.js
new file mode 100644
index 00000000..bb135222
--- /dev/null
+++ b/2811-check-if-it-is-possible-to-split-array.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @param {number} m
+ * @return {boolean}
+ */
+const canSplitArray = function(nums, m) {
+  const n = nums.length
+  if(n <= 2) return true
+  for(let i = 1; i < n; i++) {
+    if(nums[i] + nums[i - 1] >= m) return true
+  }
+  return false
+};

From bc4c51a226726eaf9bafa3601161561f3d6a85b4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Aug 2023 19:40:43 +0800
Subject: [PATCH 2736/3374] Create 2812-find-the-safest-path-in-a-grid.js

---
 2812-find-the-safest-path-in-a-grid.js | 126 +++++++++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 2812-find-the-safest-path-in-a-grid.js

diff --git a/2812-find-the-safest-path-in-a-grid.js b/2812-find-the-safest-path-in-a-grid.js
new file mode 100644
index 00000000..a30e3a47
--- /dev/null
+++ b/2812-find-the-safest-path-in-a-grid.js
@@ -0,0 +1,126 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const maximumSafenessFactor = function (grid) {
+  let n = grid.length,
+    m = grid[0].length,
+    ans = Infinity
+  const { min, abs } = Math
+  let t = []
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (grid[i][j] == 1) {
+        t.push([i, j]) // keeping track of each thief
+      }
+    }
+  }
+
+  const vis = Array.from({ length: n }, () => Array(m).fill(0))
+
+  const pq = new PQ((a, b) => a[0] > b[0])
+  let m_dist = Infinity
+  for (const thieve of t) {
+    m_dist = Math.min(m_dist, thieve[0] + thieve[1]) // Calculating Manhattan distance between current cell and all thieves
+  }
+  let dr = [0, -1, 0, 1],
+    dc = [-1, 0, 1, 0]
+  pq.push([m_dist, [0, 0]])
+  vis[0][0] = 1
+  // int mn_dist = 0;
+  while (!pq.isEmpty()) {
+    let temp = pq.pop()
+
+    let dist = temp[0],
+      r = temp[1][0],
+      c = temp[1][1]
+    // mn_dist = min(dist,mn_dist);
+    if (r == n - 1 && c == m - 1) {
+      return dist // return path safety when end is reached
+    }
+    for (let i = 0; i < 4; i++) {
+      let nr = r + dr[i]
+      let nc = c + dc[i]
+      if (nr >= 0 && nc >= 0 && nr < n && nc < m && !vis[nr][nc]) {
+        //for every adjacent cell calculate the minimum mahattan distance betwwen cell and thieves.
+        vis[nr][nc] = 1
+        let m_dist = Infinity
+        for (let thieve of t) {
+          m_dist = min(m_dist, abs(thieve[0] - nr) + abs(thieve[1] - nc))
+        }
+
+        // push the minimum of current distance and the minimum distance of the path till now
+        pq.push([min(m_dist, dist), [nr, nc]])
+      }
+    }
+  }
+  return ans
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 5fa58203daa39c53944726917f6c350607f461a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Aug 2023 19:41:20 +0800
Subject: [PATCH 2737/3374] Create
 2813-maximum-elegance-of-a-k-length-subsequence.js

---
 ...imum-elegance-of-a-k-length-subsequence.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2813-maximum-elegance-of-a-k-length-subsequence.js

diff --git a/2813-maximum-elegance-of-a-k-length-subsequence.js b/2813-maximum-elegance-of-a-k-length-subsequence.js
new file mode 100644
index 00000000..844e63f9
--- /dev/null
+++ b/2813-maximum-elegance-of-a-k-length-subsequence.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} items
+ * @param {number} k
+ * @return {number}
+ */
+const findMaximumElegance = function (items, k) {
+  let v = items
+  let n = v.length
+  const { max } = Math
+  v.sort((a, b) => b[0] - a[0]) //sort according to profit
+  let ans = 0
+  let m = {}
+  for (let i = 0; i < k; i++) {
+    ans += v[i][0]
+    if (m[v[i][1]] == null) m[v[i][1]] = 0
+    m[v[i][1]]++
+  }
+  let sz = Object.keys(m).length
+  ans += sz * sz
+  let res = ans
+  let j = k - 1
+  for (let i = k; i < n; i++) {
+    if (m[v[i][1]] == 0 || m[v[i][1]] == null) {
+      //try to increase unique elements
+      while (j >= 0 && m[v[j][1]] < 2) j-- //finding smallest number in 0 to k-1 whose frequency is more than 1, and removing it to increasing uniquenes of the subsequence
+      if (j < 0) break //no number found that has frequency more than two
+      m[v[j][1]]--
+      m[v[i][1]]++
+      res -= v[j][0]
+      res += v[i][0]
+      res -= sz * sz
+      sz++
+      res += sz * sz
+      j--
+      ans = max(ans, res) //keep taking max
+    }
+  }
+  return max(ans, res)
+}

From 12e56cc5182226fdc5e5d846e8b932d8a479eb63 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Aug 2023 15:57:52 +0800
Subject: [PATCH 2738/3374] Update 956-tallest-billboard.js

---
 956-tallest-billboard.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/956-tallest-billboard.js b/956-tallest-billboard.js
index 3b2cc2f8..2d322d8e 100644
--- a/956-tallest-billboard.js
+++ b/956-tallest-billboard.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} rods
+ * @return {number}
+ */
+const tallestBillboard = function(rods) {
+  const sum = rods.reduce((ac, e) => ac + e, 0)
+  const dp = Array(sum + 1).fill(-1), { abs, max, min } = Math
+  dp[0] = 0
+  for(const e of rods) {
+    const bak = dp.slice()
+    for(let delta = 0; delta <= sum; delta++) {
+      if(bak[delta] < 0) continue
+      if(delta + e <= sum) dp[delta + e] = max(dp[delta + e], bak[delta])
+      dp[abs(delta - e)] = max(dp[abs(delta - e)], bak[delta] + min(e, delta))
+    }
+  }
+  
+  
+  return dp[0]
+};
+
+
+// another
+
+
 /**
  * @param {number[]} rods
  * @return {number}

From dab2ec364a7c92b0abb066fad7664fa7f94e7feb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Aug 2023 17:25:17 +0800
Subject: [PATCH 2739/3374] Create 2742-painting-the-walls.js

---
 2742-painting-the-walls.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2742-painting-the-walls.js

diff --git a/2742-painting-the-walls.js b/2742-painting-the-walls.js
new file mode 100644
index 00000000..3bd19770
--- /dev/null
+++ b/2742-painting-the-walls.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} cost
+ * @param {number[]} time
+ * @return {number}
+ */
+const paintWalls = function(cost, time) {
+  const n = cost.length
+  const cache = {}
+  
+  return dfs(n - 1, 0)
+
+  function dfs(i, j) {
+    if(j > i) return 0
+    if(i < 0) return Number.MAX_SAFE_INTEGER
+    const k = `${i},${j}`
+    if(cache[k] != null) return cache[k]
+
+    const res = Math.min(dfs(i - 1, j + time[i]) + cost[i], dfs(i - 1, j - 1))
+    cache[k] = res
+    return res
+  }
+};

From 98ca324b1a74df8ffaf1803ec40e3296e5ea67ed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 9 Aug 2023 11:23:17 +0800
Subject: [PATCH 2740/3374] Create
 2786-visit-array-positions-to-maximize-score.js

---
 ...visit-array-positions-to-maximize-score.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2786-visit-array-positions-to-maximize-score.js

diff --git a/2786-visit-array-positions-to-maximize-score.js b/2786-visit-array-positions-to-maximize-score.js
new file mode 100644
index 00000000..33007b95
--- /dev/null
+++ b/2786-visit-array-positions-to-maximize-score.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+const maxScore = function(nums, x) {
+  let even = nums[0] + (nums[0] % 2 ? -x : 0)
+  let odd = nums[0] + (nums[0] % 2 ? 0 : -x)
+  
+  const n = nums.length, { max } = Math
+  for(let i = 1; i < n; i++) {
+    const e = nums[i]
+    if(e % 2 === 1) {
+      odd = max(even - x, odd) + e
+    } else {
+      even = max(even, odd - x) + e
+    }
+  }
+  
+  return max(even, odd)
+};

From d0205e07716b3203c90cdfdb37b800697afc5f02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Aug 2023 12:37:23 +0800
Subject: [PATCH 2741/3374] Create
 2787-ways-to-express-an-integer-as-sum-of-powers.js

---
 ...-to-express-an-integer-as-sum-of-powers.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2787-ways-to-express-an-integer-as-sum-of-powers.js

diff --git a/2787-ways-to-express-an-integer-as-sum-of-powers.js b/2787-ways-to-express-an-integer-as-sum-of-powers.js
new file mode 100644
index 00000000..4a4161a8
--- /dev/null
+++ b/2787-ways-to-express-an-integer-as-sum-of-powers.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number} n
+ * @param {number} x
+ * @return {number}
+ */
+const numberOfWays = function(n, x) {
+  const dp = Array.from({ length: n + 1 }, () => Array(n + 1).fill(0))
+  dp[0][0] = 1
+  const mod = 1e9 + 7
+  for(let i = 0; i <= n; i++) {
+    for(let j = 1; j <= n; j++) {
+      dp[i][j] = (dp[i][j] + dp[i][j - 1]) % mod
+      const tmp = Math.pow(j, x)
+      if(i >= tmp) {
+        dp[i][j] = (dp[i][j] + dp[i - tmp][j - 1]) % mod
+      }
+    }
+  }
+  
+  return dp[n][n]
+};

From ea6950e788a140f26624270de48c0fff9686798f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 10 Aug 2023 13:08:04 +0800
Subject: [PATCH 2742/3374] Update
 2787-ways-to-express-an-integer-as-sum-of-powers.js

---
 ...-to-express-an-integer-as-sum-of-powers.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/2787-ways-to-express-an-integer-as-sum-of-powers.js b/2787-ways-to-express-an-integer-as-sum-of-powers.js
index 4a4161a8..a6311cad 100644
--- a/2787-ways-to-express-an-integer-as-sum-of-powers.js
+++ b/2787-ways-to-express-an-integer-as-sum-of-powers.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number} n
+ * @param {number} x
+ * @return {number}
+ */
+const numberOfWays = function(n, x) {
+  const dp = Array(n + 1).fill(0)
+  dp[0] = 1
+  const mod = 1e9 + 7
+  for(let i = 1; i <= n; i++) {
+    const tmp = Math.pow(i, x)
+    for(let j = n; j >= tmp; j--) {
+
+      dp[j] = (dp[j] + dp[j - tmp]) % mod
+      
+    }
+  }
+  
+  return dp[n]
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number} x

From c593f24579e3dc634576e40cf4f73ee0b7d479a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Aug 2023 12:58:39 +0800
Subject: [PATCH 2743/3374] Create
 2809-minimum-time-to-make-array-sum-at-most-x.js

---
 ...inimum-time-to-make-array-sum-at-most-x.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2809-minimum-time-to-make-array-sum-at-most-x.js

diff --git a/2809-minimum-time-to-make-array-sum-at-most-x.js b/2809-minimum-time-to-make-array-sum-at-most-x.js
new file mode 100644
index 00000000..f858ea98
--- /dev/null
+++ b/2809-minimum-time-to-make-array-sum-at-most-x.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} x
+ * @return {number}
+ */
+const minimumTime = function (nums1, nums2, x) {
+  let n = nums1.length,
+    s1 = 0,
+    s2 = 0
+
+  let ids = Array(n)
+  for (let i = 0; i < n; i++) {
+    ids[i] = i
+    s1 += nums1[i]
+    s2 += nums2[i]
+  }
+
+  ids.sort((i, j) => nums2[i] - nums2[j])
+
+  let f = new Array(n + 1).fill(0)
+  for (let i of ids) {
+    for (let j = n; j > 0; j--) {
+      f[j] = Math.max(f[j], f[j - 1] + nums1[i] + nums2[i] * j)
+    }
+  }
+
+  for (let t = 0; t <= n; t++) {
+    if (s1 + s2 * t - f[t] <= x) {
+      return t
+    }
+  }
+  return -1
+}

From acd86bbb61c21ec9683addc35dc194956f9c245b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Aug 2023 21:42:12 +0800
Subject: [PATCH 2744/3374] Create
 2807-insert-greatest-common-divisors-in-linked-list.js

---
 ...greatest-common-divisors-in-linked-list.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2807-insert-greatest-common-divisors-in-linked-list.js

diff --git a/2807-insert-greatest-common-divisors-in-linked-list.js b/2807-insert-greatest-common-divisors-in-linked-list.js
new file mode 100644
index 00000000..9607c762
--- /dev/null
+++ b/2807-insert-greatest-common-divisors-in-linked-list.js
@@ -0,0 +1,32 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+const insertGreatestCommonDivisors = function(head) {
+  const dummy = new ListNode()
+  
+  dummy.next = head
+  let cur = head
+  while(cur.next) {
+    const val = gcd(cur.val, cur.next.val)
+    const tmp = new ListNode(val)
+    const nxt = cur.next
+    cur.next = tmp
+    tmp.next = nxt
+    
+    cur = nxt
+  }
+  
+  return dummy.next
+  
+  function gcd(a, b) {
+    return b === 0 ? a : gcd(b, a % b)
+  }
+};

From c8c16d7cd0bf23bcfbaeff867c7f55478d9e13bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Aug 2023 13:04:29 +0800
Subject: [PATCH 2745/3374] Update 1631-path-with-minimum-effort.js

---
 1631-path-with-minimum-effort.js | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1631-path-with-minimum-effort.js b/1631-path-with-minimum-effort.js
index aa094e96..76e5611d 100644
--- a/1631-path-with-minimum-effort.js
+++ b/1631-path-with-minimum-effort.js
@@ -1,3 +1,47 @@
+/**
+ * @param {number[][]} heights
+ * @return {number}
+ */
+const minimumEffortPath = function(heights) {
+  const m = heights.length, n = heights[0].length
+  const { abs, floor } = Math
+  let l = 0, r= 1e6
+  
+  while(l <  r) {
+    const mid = l + floor((r- l) /2)
+    if(valid(mid)) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  
+  return l
+  
+  function valid(effort) {
+    const visited = Array.from({length:m}, () => Array(n).fill(0))
+    const dirs = [[1,0],[-1,0],[0,1],[0,-1]]
+    let q = []
+    q.push([0, 0])
+    visited[0][0] = 1
+    while(q.length) {
+      const [x, y] = q.shift()
+      for(const [dx, dy] of dirs) {
+        const nx = x + dx, ny = y + dy
+        if(nx<0 || nx>=m || ny < 0 || ny >= n) continue
+        if(visited[nx][ny]) continue
+        if(abs(heights[nx][ny] - heights[x][y]) > effort) continue
+        q.push([nx,ny])
+        visited[nx][ny] = 1
+      }
+    }
+    
+    return visited[m - 1][n - 1] === 1
+  }
+};
+
+// another
+
 /**
  * @param {number[][]} heights
  * @return {number}

From 5880c4d56a81bcde355c26f089e5454fc058fa3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Aug 2023 19:58:05 +0800
Subject: [PATCH 2746/3374] Create 2818-apply-operations-to-maximize-score.js

---
 2818-apply-operations-to-maximize-score.js | 105 +++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 2818-apply-operations-to-maximize-score.js

diff --git a/2818-apply-operations-to-maximize-score.js b/2818-apply-operations-to-maximize-score.js
new file mode 100644
index 00000000..e48f7311
--- /dev/null
+++ b/2818-apply-operations-to-maximize-score.js
@@ -0,0 +1,105 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumScore = function (nums, k) {
+  const n = nums.length
+  const factors = Array(n).fill(0) // To store prime factors count for each number
+  const count = Array(n).fill(0) // To store the count of reachable elements for each element
+
+  // Calculate prime factors count for each number
+  for (let i = 0; i < n; i++) {
+    factors[i] = primeFactors(nums[i])
+  }
+
+  const stack = [-1] // Monotonic stack to keep track of elements in decreasing order of factors
+  let curr = 0
+
+  // Calculate the count of reachable elements for each element
+  for (let i = 0; i < n; i++) {
+    while (
+      stack[stack.length - 1] !== -1 &&
+      factors[stack[stack.length - 1]] < factors[i]
+    ) {
+      curr = stack.pop()
+      count[curr] = (curr - stack[stack.length - 1]) * (i - curr)
+    }
+    stack.push(i)
+  }
+
+  // Process any remaining elements in the stack
+  while (stack[stack.length - 1] !== -1) {
+    curr = stack.pop()
+    count[curr] = (curr - stack[stack.length - 1]) * (n - curr)
+  }
+
+  // Create an array of pairs containing elements and their corresponding reachable count
+  const pairs = Array(n)
+  for (let i = 0; i < n; i++) {
+    pairs[i] = [nums[i], count[i]]
+  }
+
+  // Sort the pairs in descending order of elements
+  pairs.sort((a, b) => b[0] - a[0])
+
+  let res = BigInt(1)
+  const mod = BigInt(1e9 + 7)
+
+  // Calculate the maximum score using modPow and available moves
+  for (let i = 0; i < pairs.length && k > 0; i++) {
+    const curr = Math.min(pairs[i][1], k)
+    res = (res * modPow(BigInt(pairs[i][0]), BigInt(curr), mod)) % mod
+    k -= curr
+  }
+
+  return Number(res) // Convert the result to a regular number before returning
+}
+
+/**
+ * Function to calculate modular exponentiation.
+ * @param {bigint} x - Base.
+ * @param {bigint} y - Exponent.
+ * @param {bigint} m - Modulus.
+ * @return {bigint} - Result of modular exponentiation.
+ */
+function modPow(x, y, m) {
+  if (y === 0n) {
+    return 1n
+  }
+  let p = modPow(x, y / 2n, m) % m
+  p = (p * p) % m
+  if (y % 2n === 0n) {
+    return p
+  }
+  return (p * x) % m
+}
+
+/**
+ * Function to calculate the count of prime factors for a number.
+ * @param {number} num - Input number.
+ * @return {number} - Count of prime factors for the input number.
+ */
+function primeFactors(num) {
+  let count = 0
+  let factor = 2
+  const end = Math.sqrt(num)
+
+  while (num > 1 && factor <= end) {
+    let inc = false
+    while (num % factor === 0) {
+      if (!inc) {
+        count++
+        inc = true
+      }
+      num /= factor
+    }
+    factor++
+  }
+
+  if (num > 1) {
+    count++
+  }
+
+  return count
+}

From 5ea26e68488ec4efe2e90ec7558260d9f6007e59 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Aug 2023 19:58:47 +0800
Subject: [PATCH 2747/3374] Create
 2817-minimum-absolute-difference-between-elements-with-constraint.js

---
 ...erence-between-elements-with-constraint.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2817-minimum-absolute-difference-between-elements-with-constraint.js

diff --git a/2817-minimum-absolute-difference-between-elements-with-constraint.js b/2817-minimum-absolute-difference-between-elements-with-constraint.js
new file mode 100644
index 00000000..68f63926
--- /dev/null
+++ b/2817-minimum-absolute-difference-between-elements-with-constraint.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+var minAbsoluteDifference = function(nums, x) {
+  const {abs, min, max, floor} = Math
+  
+          let res = Infinity
+        let n = nums.length
+        for(let i = 0; i < n; i++) {
+            if( i + x <= n - 1) {
+                let j = n - 1 - i - x
+                // abs_var.push()
+              res = min(res, abs(nums[i] - nums[i + x]))
+                let g = 1  
+                while (j > 0) {
+                    // abs_var.push()
+                  res = min(res, abs(nums[i] - nums[i + x + g]))
+                    g += 1 
+                    j -= 1
+                }
+            }
+
+        }
+        return res
+};

From 9a201a6df58aa5c9a00104f718b66bc81fa8377c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Aug 2023 19:59:25 +0800
Subject: [PATCH 2748/3374] Create
 2816-double-a-number-represented-as-a-linked-list.js

---
 ...e-a-number-represented-as-a-linked-list.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2816-double-a-number-represented-as-a-linked-list.js

diff --git a/2816-double-a-number-represented-as-a-linked-list.js b/2816-double-a-number-represented-as-a-linked-list.js
new file mode 100644
index 00000000..62407097
--- /dev/null
+++ b/2816-double-a-number-represented-as-a-linked-list.js
@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var doubleIt = function(head) {
+  const res = dfs(head)
+  if(res.val > 9) {
+    const dummy = new ListNode(1)
+    dummy.next = res
+    res.val = res.val % 10
+    return dummy
+  } else return res
+  
+  function dfs(node) {
+    if(node == null) return
+    const nxt = dfs(node.next)
+    let val = node.val * 2
+    if(nxt && nxt.val > 9) {
+      val++
+      nxt.val = nxt.val % 10
+      node.val = val
+      return node
+    } else {
+      node.val = val
+      return node
+    }
+    
+  }
+  
+  
+};

From d1b9ab871061897e96fb6164d5ec25a52e5221c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 13 Aug 2023 19:59:53 +0800
Subject: [PATCH 2749/3374] Create 2815-max-pair-sum-in-an-array.js

---
 2815-max-pair-sum-in-an-array.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2815-max-pair-sum-in-an-array.js

diff --git a/2815-max-pair-sum-in-an-array.js b/2815-max-pair-sum-in-an-array.js
new file mode 100644
index 00000000..703a8456
--- /dev/null
+++ b/2815-max-pair-sum-in-an-array.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSum = function(nums) {
+   let res = -1
+   const n = nums.length
+   
+   for(let i = 0; i < n - 1; i++) {
+     const arr = `${nums[i]}`.split('')
+     arr.sort((a, b) => b - a)
+     for(let j = 1; j < n; j++) {
+          if(i === j) continue
+          const ar = `${nums[j]}`.split('')
+           ar.sort((a, b) => b - a)
+       if(arr[0] === ar[0]) {
+         res = Math.max(res, nums[i] + nums[j])
+       }
+     }
+   }
+   
+   return res
+};

From 102d709becee0e843b0bb8dc92cce2d61bc5e9fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Aug 2023 21:12:04 +0800
Subject: [PATCH 2750/3374] Update 2812-find-the-safest-path-in-a-grid.js

---
 2812-find-the-safest-path-in-a-grid.js | 152 +++++++------------------
 1 file changed, 44 insertions(+), 108 deletions(-)

diff --git a/2812-find-the-safest-path-in-a-grid.js b/2812-find-the-safest-path-in-a-grid.js
index a30e3a47..73b62e49 100644
--- a/2812-find-the-safest-path-in-a-grid.js
+++ b/2812-find-the-safest-path-in-a-grid.js
@@ -3,124 +3,60 @@
  * @return {number}
  */
 const maximumSafenessFactor = function (grid) {
-  let n = grid.length,
-    m = grid[0].length,
-    ans = Infinity
-  const { min, abs } = Math
-  let t = []
-  for (let i = 0; i < n; i++) {
-    for (let j = 0; j < m; j++) {
-      if (grid[i][j] == 1) {
-        t.push([i, j]) // keeping track of each thief
+  const n = grid.length;
+  const isInBound = (r, c) => r >= 0 && r < n && c >= 0 && c < n;
+  const dist = new Array(n).fill(0).map(() => new Array(n).fill(Infinity));
+  const queue = [];
+
+  for (let r = 0; r < n; r++) {
+    for (let c = 0; c < n; c++) {
+      if (grid[r][c] === 1) {
+        dist[r][c] = 0;
+        queue.push([r, c]);
       }
     }
   }
 
-  const vis = Array.from({ length: n }, () => Array(m).fill(0))
-
-  const pq = new PQ((a, b) => a[0] > b[0])
-  let m_dist = Infinity
-  for (const thieve of t) {
-    m_dist = Math.min(m_dist, thieve[0] + thieve[1]) // Calculating Manhattan distance between current cell and all thieves
-  }
-  let dr = [0, -1, 0, 1],
-    dc = [-1, 0, 1, 0]
-  pq.push([m_dist, [0, 0]])
-  vis[0][0] = 1
-  // int mn_dist = 0;
-  while (!pq.isEmpty()) {
-    let temp = pq.pop()
-
-    let dist = temp[0],
-      r = temp[1][0],
-      c = temp[1][1]
-    // mn_dist = min(dist,mn_dist);
-    if (r == n - 1 && c == m - 1) {
-      return dist // return path safety when end is reached
-    }
-    for (let i = 0; i < 4; i++) {
-      let nr = r + dr[i]
-      let nc = c + dc[i]
-      if (nr >= 0 && nc >= 0 && nr < n && nc < m && !vis[nr][nc]) {
-        //for every adjacent cell calculate the minimum mahattan distance betwwen cell and thieves.
-        vis[nr][nc] = 1
-        let m_dist = Infinity
-        for (let thieve of t) {
-          m_dist = min(m_dist, abs(thieve[0] - nr) + abs(thieve[1] - nc))
-        }
+  while (queue.length) {
+    const [r, c] = queue.shift();
+    const neighbors = [
+      [r + 1, c],
+      [r - 1, c],
+      [r, c + 1],
+      [r, c - 1],
+    ];
 
-        // push the minimum of current distance and the minimum distance of the path till now
-        pq.push([min(m_dist, dist), [nr, nc]])
+    for (const [nr, nc] of neighbors) {
+      if (isInBound(nr, nc) && dist[nr][nc] === Infinity) {
+        dist[nr][nc] = dist[r][c] + 1;
+        queue.push([nr, nc]);
       }
     }
   }
-  return ans
-}
 
-class PQ {
-  constructor(comparator = (a, b) => a > b) {
-    this.heap = []
-    this.top = 0
-    this.comparator = comparator
-  }
-  size() {
-    return this.heap.length
-  }
-  isEmpty() {
-    return this.size() === 0
-  }
-  peek() {
-    return this.heap[this.top]
-  }
-  push(...values) {
-    values.forEach((value) => {
-      this.heap.push(value)
-      this.siftUp()
-    })
-    return this.size()
-  }
-  pop() {
-    const poppedValue = this.peek()
-    const bottom = this.size() - 1
-    if (bottom > this.top) {
-      this.swap(this.top, bottom)
-    }
-    this.heap.pop()
-    this.siftDown()
-    return poppedValue
-  }
-  replace(value) {
-    const replacedValue = this.peek()
-    this.heap[this.top] = value
-    this.siftDown()
-    return replacedValue
-  }
+  const maxDistance = new Array(n).fill(0).map(() => new Array(n).fill(0));
+  maxDistance[0][0] = dist[0][0];
+  queue.push([0, 0]);
 
-  parent = (i) => ((i + 1) >>> 1) - 1
-  left = (i) => (i << 1) + 1
-  right = (i) => (i + 1) << 1
-  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
-  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
-  siftUp = () => {
-    let node = this.size() - 1
-    while (node > this.top && this.greater(node, this.parent(node))) {
-      this.swap(node, this.parent(node))
-      node = this.parent(node)
-    }
-  }
-  siftDown = () => {
-    let node = this.top
-    while (
-      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
-      (this.right(node) < this.size() && this.greater(this.right(node), node))
-    ) {
-      let maxChild =
-        this.right(node) < this.size() &&
-        this.greater(this.right(node), this.left(node))
-          ? this.right(node)
-          : this.left(node)
-      this.swap(node, maxChild)
-      node = maxChild
+  while (queue.length) {
+    const [r, c] = queue.shift();
+    const neighbors = [
+      [r + 1, c],
+      [r - 1, c],
+      [r, c + 1],
+      [r, c - 1],
+    ];
+
+    for (const [nr, nc] of neighbors) {
+      if (isInBound(nr, nc)) {
+        const newDistance = Math.min(maxDistance[r][c], dist[nr][nc]);
+        if (newDistance > maxDistance[nr][nc]) {
+          maxDistance[nr][nc] = newDistance;
+          queue.push([nr, nc]);
+        }
+      }
     }
   }
+
+  return maxDistance[n - 1][n - 1];    
 }

From a5353e90237335056fd526fa6ec05f46a9b44b32 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Aug 2023 14:01:32 +0800
Subject: [PATCH 2751/3374] Update 778-swim-in-rising-water.js

---
 778-swim-in-rising-water.js | 43 +++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/778-swim-in-rising-water.js b/778-swim-in-rising-water.js
index 43f52c67..c39e9372 100644
--- a/778-swim-in-rising-water.js
+++ b/778-swim-in-rising-water.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const swimInWater = function(grid) {
+   const n = grid.length
+   const limit = n * n, { floor } = Math
+   let l = 0, r = limit - 1
+   
+   while(l < r) {
+     const mid = l + floor((r - l) / 2)
+     if(valid(mid)) r = mid
+     else l = mid + 1
+   }
+   
+    return l
+   
+  
+   function valid(h) {
+     const visited = Array.from({ length: n }, () => Array(n).fill(0))
+     if(grid[0][0] > h) return false
+     return dfs(h, 0, 0, visited)
+   }
+  
+   function dfs(h, i, j, visited) {
+     if(i === n - 1 && j === n - 1) return true
+     const dirs = [[1, 0], [-1, 0], [0, 1], [0, -1]]
+     visited[i][j] = 1
+     for(const [dx, dy] of dirs) {
+       const nx = i + dx, ny = j + dy
+       if(nx >= 0 && nx < n && ny >= 0 && ny < n && visited[nx][ny] === 0 && grid[nx][ny] <= h) {
+         if(dfs(h, nx, ny, visited)) return true
+       }
+  
+     }
+     
+     return false
+   }
+};
+
+// another
+
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 7d24af747e4d291685c94f1de5117d26755b6c0c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Aug 2023 16:23:03 +0800
Subject: [PATCH 2752/3374] Create 2667-create-hello-world-function.js

---
 2667-create-hello-world-function.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2667-create-hello-world-function.js

diff --git a/2667-create-hello-world-function.js b/2667-create-hello-world-function.js
new file mode 100644
index 00000000..d4dcdbfa
--- /dev/null
+++ b/2667-create-hello-world-function.js
@@ -0,0 +1,13 @@
+/**
+ * @return {Function}
+ */
+var createHelloWorld = function() {
+    return function(...args) {
+        return 'Hello World'
+    }
+};
+
+/**
+ * const f = createHelloWorld();
+ * f(); // "Hello World"
+ */

From 3fbd239425b2908a44422f02901abfb2aa9d2f16 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Aug 2023 16:53:47 +0800
Subject: [PATCH 2753/3374] Create
 1491-average-salary-excluding-the-minimum-and-maximum-salary.js

---
 ...salary-excluding-the-minimum-and-maximum-salary.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 1491-average-salary-excluding-the-minimum-and-maximum-salary.js

diff --git a/1491-average-salary-excluding-the-minimum-and-maximum-salary.js b/1491-average-salary-excluding-the-minimum-and-maximum-salary.js
new file mode 100644
index 00000000..e65eff5d
--- /dev/null
+++ b/1491-average-salary-excluding-the-minimum-and-maximum-salary.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} salary
+ * @return {number}
+ */
+const average = function(salary) {
+  const sum = salary.reduce((ac, e) => ac + e, 0)
+  const min = Math.min(...salary), max = Math.max(...salary)
+  const n = salary.length
+  
+  return (sum - min - max) / (n - 2)
+};

From badd57ba978ef464024d00ff2a4b14dfc27a77a6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Aug 2023 16:55:22 +0800
Subject: [PATCH 2754/3374] Create 851-loud-and-rich.js

---
 851-loud-and-rich.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 851-loud-and-rich.js

diff --git a/851-loud-and-rich.js b/851-loud-and-rich.js
new file mode 100644
index 00000000..a413c424
--- /dev/null
+++ b/851-loud-and-rich.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[][]} richer
+ * @param {number[]} quiet
+ * @return {number[]}
+ */
+const loudAndRich = function(richer, quiet) {
+  const hash = {}
+  for(const [a, b] of richer) {
+    if(hash[b] == null) hash[b] = []
+    hash[b].push(a)
+  }
+  const n = quiet.length
+  
+  const res = []
+  for(let i = 0; i < n; i++) {
+    dfs(i)
+  }
+  
+  return res
+  
+  function dfs(i) {
+    if(res[i] != null) return res[i]
+    res[i] = i
+    
+    const nxt = hash[i] || []
+    for(const e of nxt) {
+      if(quiet[dfs(e)] < quiet[res[i]]) res[i] = res[e]
+      
+    }
+    return res[i]
+  }
+};

From 6d7b1381413dccb1f94b7da3b0df2d09e5cc4fce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Aug 2023 20:53:36 +0800
Subject: [PATCH 2755/3374] Create 2440-create-components-with-same-value.js

---
 2440-create-components-with-same-value.js | 50 +++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2440-create-components-with-same-value.js

diff --git a/2440-create-components-with-same-value.js b/2440-create-components-with-same-value.js
new file mode 100644
index 00000000..fc6e910c
--- /dev/null
+++ b/2440-create-components-with-same-value.js
@@ -0,0 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const componentValue = function(nums, edges) {
+   const n = nums.length, sum = nums.reduce((ac, e) => ac + e, 0)
+   const graph = {}, degree = Array(n).fill(0)
+   const { min } = Math, mi = min(...nums)
+   for(const [u, v] of edges) {
+     if(graph[u] == null) graph[u] = []
+     if(graph[v] == null) graph[v] = []
+     graph[u].push(v)
+     graph[v].push(u)
+     degree[u]++
+     degree[v]++
+   }
+  
+
+   for(let t = mi; t < sum; t++) {
+     if((sum % t === 0) && bfs(t)) return sum / t - 1
+   }
+   
+  return 0
+   
+   
+   function bfs(target) {
+     const vertices = nums.slice(0), deg = degree.slice(0), q = []
+     for(let i = 0; i < n; i++) {
+       if(deg[i] === 1) {
+         q.push(i)
+       }
+     }
+
+     while(q.length) {
+       const cur = q.shift()
+       deg[cur] = 0
+       const nxt = graph[cur] || []
+       for(const e of nxt) {
+         if(vertices[cur] !== target) vertices[e] += vertices[cur]
+         deg[e]--
+         
+         if(deg[e] === 0) return vertices[e] === target
+         else if(deg[e] === 1) q.push(e)
+       }
+     }
+     return false
+   }
+};
+

From b2f4f91e1d0b993b3ae9330241bd5a3bf6e796c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 18 Aug 2023 16:05:31 +0800
Subject: [PATCH 2756/3374] Create 2603-collect-coins-in-a-tree.js

---
 2603-collect-coins-in-a-tree.js | 35 +++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2603-collect-coins-in-a-tree.js

diff --git a/2603-collect-coins-in-a-tree.js b/2603-collect-coins-in-a-tree.js
new file mode 100644
index 00000000..211e4335
--- /dev/null
+++ b/2603-collect-coins-in-a-tree.js
@@ -0,0 +1,35 @@
+let a, cum, res, v, sum, g;
+const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
+const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };
+const sm = (a) => a.reduce(((x, y) => x + y), 0);
+const tree_dp = (cur, par) => {
+    v[cur] = a[cur];
+    for (const child of g[cur]) {
+        if (child != par) {
+            v[cur] += tree_dp(child, cur);
+        }
+    }
+    if (cur != par) {
+        let x = v[cur] + cum[par] - a[cur];
+        let y = (sum - v[cur]) + cum[cur] - a[par];
+        if (x != sum && y != sum) res += 2;
+    }
+    return v[cur];
+};
+/**
+ * @param {number[]} coins
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const collectTheCoins = function(coins, edges) {
+    let n = coins.length;
+    g = initializeGraph(n), a = coins, res = 0, cum = Array(n), v = Array(n), sum = sm(a);
+    packUG(g, edges);
+    for (let i = 0; i < n; i++) {
+        cum[i] = a[i];
+        for (const child of g[i]) cum[i] += a[child];
+    }
+    tree_dp(0, 0);
+    return res;
+    
+};

From a76c48a73acd980ce0b088472c2b8de564bfcd36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Aug 2023 20:29:44 +0800
Subject: [PATCH 2757/3374] Create 2768-number-of-black-blocks.js

---
 2768-number-of-black-blocks.js | 48 ++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2768-number-of-black-blocks.js

diff --git a/2768-number-of-black-blocks.js b/2768-number-of-black-blocks.js
new file mode 100644
index 00000000..d43a8070
--- /dev/null
+++ b/2768-number-of-black-blocks.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} coordinates
+ * @return {number[]}
+ */
+const countBlackBlocks = function (m, n, coordinates) {
+  let arr = new Array(5).fill(0)
+  arr[0] = (m - 1) * (n - 1)
+  let mat = {}
+  for (let [r, c] of coordinates) {
+    mat[r] ||= []
+    mat[r][c] = true
+  }
+  for (let [r, c] of coordinates) {
+    for (let i = -1; i < 1; i++) {
+      for (let j = -1; j < 1; j++) {
+        let nextR = r + i
+        let nextC = c + j
+        if (nextR < 0 || nextC < 0 || (nextR >= m - 1) | (nextC >= n - 1))
+          continue
+        let res = getRes(nextR, nextC, mat)
+        arr[res]++
+      }
+    }
+  }
+  for (let i = 1; i < 5; i++) {
+    arr[i] = ~~(arr[i] / i)
+  }
+  let used = 0
+  for (let i = 1; i < 5; i++) {
+    used += arr[i]
+  }
+  arr[0] -= used
+  return arr
+}
+
+const getRes = (r, c, mat) => {
+  let res = 0
+  for (let i = 0; i < 2; i++) {
+    for (let j = 0; j < 2; j++) {
+      let nextR = r + i
+      let nextC = c + j
+      if (mat[nextR]?.[nextC] === true) res++
+    }
+  }
+  return res
+}

From 8365b8fdd11a286dca2c54b1951c1cf13e0f3027 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 19 Aug 2023 20:53:23 +0800
Subject: [PATCH 2758/3374] Update 2768-number-of-black-blocks.js

---
 2768-number-of-black-blocks.js | 50 ++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/2768-number-of-black-blocks.js b/2768-number-of-black-blocks.js
index d43a8070..48067a99 100644
--- a/2768-number-of-black-blocks.js
+++ b/2768-number-of-black-blocks.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} coordinates
+ * @return {number[]}
+ */
+const countBlackBlocks = function(m, n, coordinates) {
+   const block = {}
+   
+   for(const [i, j] of coordinates) {
+     helper(i, j)
+   }
+
+   const arr = Array(5).fill(0)
+   for(const k in block) {
+    if(block.hasOwnProperty(k)) {
+      arr[block[k]]++
+    }
+   }
+   arr[0] = (m - 1) * (n - 1) - arr.reduce((ac, e) => ac + e, 0) 
+   return arr
+
+   function helper(i, j) {
+
+     if(i < m - 1 && j < n - 1) {
+       update(i, j)
+       if(i > 0) update(i - 1, j)
+       if(j > 0) update(i, j - 1)
+       if(i > 0 && j > 0) update(i - 1, j - 1)         
+     } else if(i === m - 1 && j === n - 1) {
+       update(i - 1, j - 1)
+     } else if(i === m - 1) {
+       update(i - 1, j)
+       if(j > 0) update(i - 1, j - 1)
+     } else if(j === n - 1) {
+       update(i, j - 1)
+       if(i > 0) update(i - 1, j - 1)
+     }    
+     
+   }
+  
+   function update(i, j, delta = 1) {
+     const key = `${i},${j}`
+     if(block[key] == null) block[key] = 0
+     block[key]++
+   }
+};
+
+// another
+
 /**
  * @param {number} m
  * @param {number} n

From 15633d72bea5a35bae353c43818e03970c65e0ad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Aug 2023 18:31:34 +0800
Subject: [PATCH 2759/3374] Update
 1685-sum-of-absolute-differences-in-a-sorted-array.js

---
 ...of-absolute-differences-in-a-sorted-array.js | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/1685-sum-of-absolute-differences-in-a-sorted-array.js b/1685-sum-of-absolute-differences-in-a-sorted-array.js
index c9893c3f..a4273d0e 100644
--- a/1685-sum-of-absolute-differences-in-a-sorted-array.js
+++ b/1685-sum-of-absolute-differences-in-a-sorted-array.js
@@ -3,15 +3,18 @@
  * @return {number[]}
  */
 const getSumAbsoluteDifferences = function(nums) {
-  const res = [], n = nums.length
-  let sum = 0
-  for(let first = nums[0], i = 1; i < n; i++) {
-    sum += nums[i] - first
+  const n = nums.length, { abs } = Math
+  const res = []
+  let e0 = 0
+  for(let i = 1; i < n; i++) {
+    e0 += abs(nums[i] - nums[0])
   }
-  res[0] = sum
+  res[0] = e0
   for(let i = 1; i < n; i++) {
-    res[i] = res[i - 1] - (nums[i] - nums[i - 1]) * (n - i - 1) + (nums[i] - nums[i - 1]) * (i - 1)
+    const pre = res[i - 1], diff = nums[i] - nums[i - 1]
+    let cur = pre + diff * (i - 1) - diff * (n - 1 - i)
+    res.push(cur)
   }
-
+  
   return res
 };

From 77171102d705fe40110b3209658f856f251d0faa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Aug 2023 21:28:09 +0800
Subject: [PATCH 2760/3374] Create
 2828-check-if-a-string-is-an-acronym-of-words.js

---
 2828-check-if-a-string-is-an-acronym-of-words.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 2828-check-if-a-string-is-an-acronym-of-words.js

diff --git a/2828-check-if-a-string-is-an-acronym-of-words.js b/2828-check-if-a-string-is-an-acronym-of-words.js
new file mode 100644
index 00000000..5951071d
--- /dev/null
+++ b/2828-check-if-a-string-is-an-acronym-of-words.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string[]} words
+ * @param {string} s
+ * @return {boolean}
+ */
+const isAcronym = function(words, s) {
+  let str = ''
+  for(const e of words) str = str + e[0]
+  return s === str
+};

From 91640a0b47fe3fe547c522f6828300ca4561de27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Aug 2023 21:29:07 +0800
Subject: [PATCH 2761/3374] Create
 2829-determine-the-minimum-sum-of-a-k-avoiding-array.js

---
 ...ine-the-minimum-sum-of-a-k-avoiding-array.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2829-determine-the-minimum-sum-of-a-k-avoiding-array.js

diff --git a/2829-determine-the-minimum-sum-of-a-k-avoiding-array.js b/2829-determine-the-minimum-sum-of-a-k-avoiding-array.js
new file mode 100644
index 00000000..8bf5b7c1
--- /dev/null
+++ b/2829-determine-the-minimum-sum-of-a-k-avoiding-array.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const minimumSum = function(n, k) {
+  let res = 0
+  const set = new Set()
+  for(let i = 1; set.size < n; i++) {
+    if(!set.has(k - i)) {
+      set.add(i)
+      res += i
+    }
+  }
+  
+  return res
+};

From 11a3f528df99a7bc78bcdc88572aa6396bb738c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Aug 2023 21:29:42 +0800
Subject: [PATCH 2762/3374] Create 2830-maximize-the-profit-as-the-salesman.js

---
 2830-maximize-the-profit-as-the-salesman.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2830-maximize-the-profit-as-the-salesman.js

diff --git a/2830-maximize-the-profit-as-the-salesman.js b/2830-maximize-the-profit-as-the-salesman.js
new file mode 100644
index 00000000..d54b6eeb
--- /dev/null
+++ b/2830-maximize-the-profit-as-the-salesman.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number} n
+ * @param {number[][]} offers
+ * @return {number}
+ */
+const maximizeTheProfit = function(n, offers) {
+  const dp = Array(n + 1).fill(0);
+  const m = [];
+  for (const a of offers) {
+    if(m[a[1]] == null) m[a[1]] = []  
+    m[a[1]].push(a);
+  }
+  for (let e = 1; e <= n; e++) {
+      dp[e] = dp[e - 1];
+      for (let a of (m[e - 1] || []) ) {
+          dp[e] = Math.max(dp[e], dp[a[0]] + a[2]);
+      }
+  }
+  return dp[n];
+};

From 6556704c0366134315b55268127854c64ec85c44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 20 Aug 2023 21:30:16 +0800
Subject: [PATCH 2763/3374] Create 2831-find-the-longest-equal-subarray.js

---
 2831-find-the-longest-equal-subarray.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2831-find-the-longest-equal-subarray.js

diff --git a/2831-find-the-longest-equal-subarray.js b/2831-find-the-longest-equal-subarray.js
new file mode 100644
index 00000000..a2fdf369
--- /dev/null
+++ b/2831-find-the-longest-equal-subarray.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const longestEqualSubarray = function(nums, k) {
+  let maxf = 0, i = 0, n = nums.length;
+  let count = {};
+  for (let j = 0; j < n; j++) {
+      if(count[nums[j]] == null) count[nums[j]] = 0
+      maxf = Math.max(maxf, ++count[nums[j]]);
+      if (j - i + 1 - maxf > k) {
+          if(count[nums[i]] == null) count[nums[i]] = 0
+          --count[nums[i++]];
+      }
+        
+  }
+  return maxf;
+};

From ce6aa564d3322025a938579d77b38ca8649d5aaf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Aug 2023 18:11:06 +0800
Subject: [PATCH 2764/3374] Update 2121-intervals-between-identical-elements.js

---
 2121-intervals-between-identical-elements.js | 38 ++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2121-intervals-between-identical-elements.js b/2121-intervals-between-identical-elements.js
index 2c99b424..3507ba0e 100644
--- a/2121-intervals-between-identical-elements.js
+++ b/2121-intervals-between-identical-elements.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} arr
+ * @return {number[]}
+ */
+const getDistances = function(arr) {
+  const hash = {}
+  const n = arr.length
+  for(let i = 0; i < n; i++) {
+    const e = arr[i]
+    if(hash[e] == null) hash[e] = []
+    hash[e].push(i)
+  }
+  const res = []
+  for(const [k, v] of Object.entries(hash)) {
+    helper(v)
+  }
+  return res
+  
+  function helper(idxArr) {
+    let sum = 0
+    const len = idxArr.length
+    for(let i = 1; i < len; i++) {
+      sum += idxArr[i] - idxArr[0]
+    }
+    const first = idxArr[0]
+    res[first] = sum
+    for(let i = 1; i < len; i++) {
+      const pre = res[idxArr[i - 1]]
+      const delta = idxArr[i] - idxArr[i - 1]
+      const tmp = pre + i * delta - (len - i) * delta
+      res[idxArr[i]] = tmp
+    }
+  }
+};
+
+// another
+
+
 /**
  * @param {number[]} arr
  * @return {number[]}

From ca16016e025063995f41c936a645f280392e6af4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Aug 2023 19:01:31 +0800
Subject: [PATCH 2765/3374] Update 2615-sum-of-distances.js

---
 2615-sum-of-distances.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2615-sum-of-distances.js b/2615-sum-of-distances.js
index 533c3806..6ac7000e 100644
--- a/2615-sum-of-distances.js
+++ b/2615-sum-of-distances.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const distance = function(nums) {
+   const res = []
+   const hash = {}, n = nums.length
+   for(let i = 0; i < n; i++) {
+     const e = nums[i]
+     if(hash[e] == null) hash[e] = []
+     hash[e].push(i)
+   }
+  
+   for(const [_, arr] of Object.entries(hash)) {
+     helper(arr)
+   }
+   
+   return res
+
+  function helper(arr) {
+    let sum = 0
+    const len = arr.length
+    for(let i = 1; i < len; i++) {
+      sum += arr[i] - arr[0]
+    }
+    const first = arr[0]
+    res[first] = sum
+    for(let i = 1; i < len; i++) {
+      const preIdx = arr[i - 1]
+      const pre = res[preIdx], diff = arr[i] - arr[i - 1]
+      const val = pre + i * diff - diff * (len - i)
+      res[arr[i]] = val
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number[]}

From 5661b6012eb25187dbbbd43be03ed729a0b6c560 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 23 Aug 2023 19:23:08 +0800
Subject: [PATCH 2766/3374] Create 2591-distribute-money-to-maximum-children.js

---
 2591-distribute-money-to-maximum-children.js | 27 ++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2591-distribute-money-to-maximum-children.js

diff --git a/2591-distribute-money-to-maximum-children.js b/2591-distribute-money-to-maximum-children.js
new file mode 100644
index 00000000..52d9a5a6
--- /dev/null
+++ b/2591-distribute-money-to-maximum-children.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} money
+ * @param {number} children
+ * @return {number}
+ */
+const distMoney = function(money, children) {
+  let m = money, n = children
+  if(m < n) return -1
+  let res = 0
+  for(let num = 1; num <= n && num * 8 <= m; num++) {
+    if(valid(num)) res = num
+  }
+  
+  return res
+  
+  function valid(num) {
+    if(m < num * 8) return false
+    let remain = m - num * 8
+    let slots = n - num
+    if(slots === 0 && remain) return false
+    if(slots > remain) return false
+    remain = remain - slots
+    if(remain === 3 && slots === 1) return false
+    return true
+  }
+  
+};

From 8eaac9216cf181ff5a454781e2419a6cf5815009 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Aug 2023 18:53:14 +0800
Subject: [PATCH 2767/3374] Update
 2672-number-of-adjacent-elements-with-the-same-color.js

---
 ...f-adjacent-elements-with-the-same-color.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/2672-number-of-adjacent-elements-with-the-same-color.js b/2672-number-of-adjacent-elements-with-the-same-color.js
index 241889da..1ca04f3c 100644
--- a/2672-number-of-adjacent-elements-with-the-same-color.js
+++ b/2672-number-of-adjacent-elements-with-the-same-color.js
@@ -1,3 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const colorTheArray = function(n, queries) {
+   let res = []
+   const arr = Array(n).fill(0)
+   const [idx, val] = queries[0]
+   arr[idx] = val
+   res.push(0)
+  const len = queries.length
+  for(let i = 1; i < len; i++) {
+    helper(queries[i])
+  }
+  
+  return res
+  
+  function helper([idx, val]) {
+    const pre = res[res.length - 1]
+    let cur = pre
+    if(arr[idx] !== val) {
+      if(arr[idx] !== 0) {
+        if(idx > 0 && arr[idx - 1] === val) cur++
+        if(idx + 1 < n && arr[idx + 1] === val) cur++
+        if(idx > 0 && arr[idx - 1] === arr[idx]) {
+          cur--
+        }
+        if(idx + 1 < n && arr[idx + 1] === arr[idx]) {
+          cur--
+        }
+      } else {
+        // not set
+        if(idx > 0 && arr[idx - 1] === val) cur++
+        if(idx + 1 < n && arr[idx + 1] === val) cur++
+      }
+    }
+    arr[idx] = val
+    
+    res.push(cur)
+  }
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} queries

From 7ff215bda29686e080e9e1dfcb63609cf380dab3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Aug 2023 22:03:13 +0800
Subject: [PATCH 2768/3374] Create 2833-furthest-point-from-origin.js

---
 2833-furthest-point-from-origin.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 2833-furthest-point-from-origin.js

diff --git a/2833-furthest-point-from-origin.js b/2833-furthest-point-from-origin.js
new file mode 100644
index 00000000..b7a34e64
--- /dev/null
+++ b/2833-furthest-point-from-origin.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} moves
+ * @return {number}
+ */
+var furthestDistanceFromOrigin = function(moves) {
+  let u = 0
+  let val = 0
+  for(const e of moves) {
+    if(e === '_') u++
+    else if(e === 'L') val--
+    else if(e === 'R') val++
+  }
+  return Math.abs(val) + u
+};

From 825998f7769559ccae05ba4f3f9c6706c1c6b8ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Sep 2023 21:02:56 +0800
Subject: [PATCH 2769/3374] Create 2745-construct-the-longest-new-string.js

---
 2745-construct-the-longest-new-string.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 2745-construct-the-longest-new-string.js

diff --git a/2745-construct-the-longest-new-string.js b/2745-construct-the-longest-new-string.js
new file mode 100644
index 00000000..271bc658
--- /dev/null
+++ b/2745-construct-the-longest-new-string.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+var longestString = function(x, y, z) {
+    if (x === y)
+        return (4 * x + 2 * z);
+    var mini = Math.min(x, y);
+    return (2 * mini + 2 * (mini + 1) + 2 * z); 
+};

From 6e3b028a6fdb61f9c3e052dbd4461339f467789c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Sep 2023 21:24:06 +0800
Subject: [PATCH 2770/3374] Update 2745-construct-the-longest-new-string.js

---
 2745-construct-the-longest-new-string.js | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/2745-construct-the-longest-new-string.js b/2745-construct-the-longest-new-string.js
index 271bc658..523bcf91 100644
--- a/2745-construct-the-longest-new-string.js
+++ b/2745-construct-the-longest-new-string.js
@@ -4,9 +4,12 @@
  * @param {number} z
  * @return {number}
  */
-var longestString = function(x, y, z) {
-    if (x === y)
-        return (4 * x + 2 * z);
-    var mini = Math.min(x, y);
-    return (2 * mini + 2 * (mini + 1) + 2 * z); 
+const longestString = function(x, y, z) {
+   const base = Math.min(x, y)
+   let extra = 0
+   if(x !== y) {
+     extra = 1
+   }
+  
+   return (base * 2 + z + extra) * 2
 };

From 39745e816f366c361b6323566e27c41fa0d6e7b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Sep 2023 17:52:40 +0800
Subject: [PATCH 2771/3374] Create
 2749-minimum-operations-to-make-the-integer-zero.js

---
 ...mum-operations-to-make-the-integer-zero.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 2749-minimum-operations-to-make-the-integer-zero.js

diff --git a/2749-minimum-operations-to-make-the-integer-zero.js b/2749-minimum-operations-to-make-the-integer-zero.js
new file mode 100644
index 00000000..884190c2
--- /dev/null
+++ b/2749-minimum-operations-to-make-the-integer-zero.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} num1
+ * @param {number} num2
+ * @return {number}
+ */
+const makeTheIntegerZero = (x, y) => {
+    for (let cnt = 0; cnt < 40; cnt++) {
+        let sum = x - cnt * y;
+        if (sum < 0) break;
+        let f = SumOfPower2Factorization(sum), min = f.size, max = sum; // max factorization is all 1's (2 ^ 0)
+        if (min <= cnt && cnt <= max) return cnt;
+    }
+    return -1;
+};
+
+// min factorization (smallest total cnt)
+const SumOfPower2Factorization = (x) => {
+    let i = 0, bit = 2 ** i, v = [], res = new Set(), cur = x;
+    while (bit <= x) {
+        v.push(bit);
+        i++;
+        bit = 2 ** i;
+    }
+    while (cur != 0) {
+        let idx = v.findIndex((element) => element > cur);
+        if (idx === -1) {
+            idx = v.length - 1;
+        } else {
+            idx--;
+        }
+        res.add(idx);
+        cur -= v[idx];
+    }
+    return res;
+};

From 824dbae17e9e48e4ee688fc09081fe17a518dc8a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Sep 2023 20:31:09 +0800
Subject: [PATCH 2772/3374] Update
 2673-make-costs-of-paths-equal-in-a-binary-tree.js

---
 ...e-costs-of-paths-equal-in-a-binary-tree.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/2673-make-costs-of-paths-equal-in-a-binary-tree.js b/2673-make-costs-of-paths-equal-in-a-binary-tree.js
index fecb6c46..b429fb98 100644
--- a/2673-make-costs-of-paths-equal-in-a-binary-tree.js
+++ b/2673-make-costs-of-paths-equal-in-a-binary-tree.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number} n
+ * @param {number[]} cost
+ * @return {number}
+ */
+const minIncrements = function(n, cost) {
+  let res = 0
+  dfs(1)
+  return res
+  
+  function dfs(node) {
+    if(node > n) return 0
+    const l = dfs(2 * node)
+    const r = dfs(2 * node + 1)
+    res += Math.abs(l - r)
+    return Math.max(l, r) + cost[node - 1]
+  }
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[]} cost

From 9e2b3b34612fd25902f185a7dab8fe054591e9a6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Sep 2023 21:23:32 +0800
Subject: [PATCH 2773/3374] Create
 2580-count-ways-to-group-overlapping-ranges.js

---
 2580-count-ways-to-group-overlapping-ranges.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2580-count-ways-to-group-overlapping-ranges.js

diff --git a/2580-count-ways-to-group-overlapping-ranges.js b/2580-count-ways-to-group-overlapping-ranges.js
new file mode 100644
index 00000000..11817f76
--- /dev/null
+++ b/2580-count-ways-to-group-overlapping-ranges.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[][]} ranges
+ * @return {number}
+ */
+const countWays = function(ranges) {
+  const mod = 1e9 + 7
+  const n = ranges.length
+  ranges.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  let last = -1, res = 1
+  for (const r of ranges) {   
+      if (last < r[0]) res = res * 2 % mod;
+      last = Math.max(last, r[1]);
+  }
+  return res
+};

From cddca02a38b7ee7c264871c2928250902d4847d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Sep 2023 21:17:15 +0800
Subject: [PATCH 2774/3374] Create 2589-minimum-time-to-complete-all-tasks.js

---
 2589-minimum-time-to-complete-all-tasks.js | 31 ++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2589-minimum-time-to-complete-all-tasks.js

diff --git a/2589-minimum-time-to-complete-all-tasks.js b/2589-minimum-time-to-complete-all-tasks.js
new file mode 100644
index 00000000..6999599c
--- /dev/null
+++ b/2589-minimum-time-to-complete-all-tasks.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number}
+ */
+const findMinimumTime = function(tasks) {
+  let maxEnd = -Infinity
+  for(const [s,e,d] of tasks) {
+    maxEnd = Math.max(maxEnd, e)
+  }
+  // console.log(maxEnd)
+  const endSlots = Array(maxEnd + 1).fill(0)
+  tasks.sort((a, b) => a[1] - b[1])
+  const n = tasks.length
+  for(let i = 0; i < n; i++) {
+    const cur = tasks[i]
+    let [s, e, d] = cur
+    for(let j = s; j <= e; j++) {
+      if(endSlots[j]) d--
+    }
+    let t = e
+    while(d > 0) {
+      if(endSlots[t] === 0) {
+        endSlots[t] = 1
+        d--
+      }
+      t--
+    }
+  }
+  
+  return endSlots.reduce((ac, e) => ac + e, 0)
+};

From e5371965aa02fa2699ffe3f9adf6dae27a7613a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Sep 2023 20:53:29 +0800
Subject: [PATCH 2775/3374] Create
 2598-smallest-missing-non-negative-integer-after-operations.js

---
 ...g-non-negative-integer-after-operations.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2598-smallest-missing-non-negative-integer-after-operations.js

diff --git a/2598-smallest-missing-non-negative-integer-after-operations.js b/2598-smallest-missing-non-negative-integer-after-operations.js
new file mode 100644
index 00000000..a0cbc404
--- /dev/null
+++ b/2598-smallest-missing-non-negative-integer-after-operations.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @param {number} value
+ * @return {number}
+ */
+const findSmallestInteger = function(nums, value) {
+  const hash = {}, n = nums.length
+  for(const e of nums) {
+    let remain = e % value
+    if(remain < 0)  remain = value + remain
+    if(hash[remain] == null) hash[remain] = 0
+    hash[remain]++
+  }
+  for(let i = 0; i < n; i++) {
+    const re = i % value
+    if(hash[re] == null) return i
+    hash[re]--
+    if(hash[re] === 0) delete hash[re]
+  }
+  return n
+};

From c03f93232821cdeb56942a32e88d645004548784 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Sep 2023 17:38:41 +0800
Subject: [PATCH 2776/3374] Create
 2835-minimum-operations-to-form-subsequence-with-target-sum.js

---
 ...ons-to-form-subsequence-with-target-sum.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2835-minimum-operations-to-form-subsequence-with-target-sum.js

diff --git a/2835-minimum-operations-to-form-subsequence-with-target-sum.js b/2835-minimum-operations-to-form-subsequence-with-target-sum.js
new file mode 100644
index 00000000..399aefd2
--- /dev/null
+++ b/2835-minimum-operations-to-form-subsequence-with-target-sum.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var minOperations = function(nums, target) {
+    const n = nums.length, arr = Array(31).fill(0);
+    let sum = 0;
+
+    for(const x of nums) ++arr[Math.log2(x)], sum += x;
+    if(sum < target) return -1;
+
+    let i=0, res = 0;
+    while(i < 31) {
+        if(1<<i & target) {
+            if(arr[i]) --arr[i];
+            else {
+                while(i < 30 && !arr[i]) ++i, ++res;
+                --arr[i];
+                continue;
+            }
+        }
+        arr[++i] += Math.floor(arr[i-1] / 2);
+    }
+
+    return res;    
+};

From 57bf73cf2685c4c490b1911ed160c0ea8a9c6739 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Sep 2023 20:28:36 +0800
Subject: [PATCH 2777/3374] Create
 2836-maximize-value-of-function-in-a-ball-passing-game.js

---
 ...alue-of-function-in-a-ball-passing-game.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 2836-maximize-value-of-function-in-a-ball-passing-game.js

diff --git a/2836-maximize-value-of-function-in-a-ball-passing-game.js b/2836-maximize-value-of-function-in-a-ball-passing-game.js
new file mode 100644
index 00000000..ac238a8f
--- /dev/null
+++ b/2836-maximize-value-of-function-in-a-ball-passing-game.js
@@ -0,0 +1,60 @@
+const N = 34
+const checkIthBit64 = (x, i) => {
+  let s = x.toString(2),
+    n = s.length
+  for (let j = 0; j < n; j++) {
+    if (n - j - 1 == i && s[j] == '1') return 1
+  }
+  return 0
+}
+
+/**
+ * @param {number[]} receiver
+ * @param {number} k
+ * @return {number}
+ */
+var getMaxFunctionValue = function(receiver, k) {
+  const a = receiver
+  let n = a.length,
+    ia = [],
+    res = [],
+    iaP = [...a],
+    resP = [...a]
+  for (let i = 0; i < n; i++) {
+    ia.push(i)
+    res.push(i)
+  }
+  for (let i = 0; i < N; i++) {
+    if (checkIthBit64(k, i)) {
+      ;[res, ia] = update(res, resP, ia, iaP)
+    }
+    resP = updateResP(res, resP, iaP)
+    iaP = updateIaP(iaP)
+  }
+  return Math.max(...res) 
+};
+
+const update = (cur, curP, ia, iaP) => {
+  let n = cur.length,
+    nextRes = [],
+    nextPos = []
+  for (let i = 0; i < n; i++) {
+    nextRes.push(cur[i] + curP[ia[i]])
+    nextPos.push(ia[iaP[i]])
+  }
+  return [nextRes, nextPos]
+}
+
+const updateResP = (cur, curP, iaP) => {
+  let n = cur.length,
+    next = []
+  for (let i = 0; i < n; i++) next.push(curP[i] + curP[iaP[i]])
+  return next
+}
+
+const updateIaP = (iaP) => {
+  let n = iaP.length,
+    next = []
+  for (let i = 0; i < n; i++) next.push(iaP[iaP[i]])
+  return next
+}

From df1e053129470de7f756ef518997ee9235f83ac8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Sep 2023 21:39:39 +0800
Subject: [PATCH 2778/3374] Create
 2846-minimum-edge-weight-equilibrium-queries-in-a-tree.js

---
 ...ge-weight-equilibrium-queries-in-a-tree.js | 120 ++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 2846-minimum-edge-weight-equilibrium-queries-in-a-tree.js

diff --git a/2846-minimum-edge-weight-equilibrium-queries-in-a-tree.js b/2846-minimum-edge-weight-equilibrium-queries-in-a-tree.js
new file mode 100644
index 00000000..113349f5
--- /dev/null
+++ b/2846-minimum-edge-weight-equilibrium-queries-in-a-tree.js
@@ -0,0 +1,120 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const minOperationsQueries = function (n, edges, queries) {
+  let [directParents, counts, depths] = getParentsAndPrefixCounts(n, edges)
+  let lcaModule = new LCA(n, directParents, depths)
+  let ans = []
+  for (let [a, b] of queries) {
+    let lca = lcaModule.getLCA(a, b)
+    let countsA = diffCounts(counts[a], counts[lca]),
+      countsB = diffCounts(counts[b], counts[lca])
+    let totalCounts = addCounts(countsA, countsB)
+    let edgesInPath = depths[a] - depths[lca] + depths[b] - depths[lca]
+    let maxCount = 0
+    for (let i = 1; i <= 26; i++) {
+      maxCount = Math.max(maxCount, totalCounts[i])
+    }
+    ans.push(edgesInPath - maxCount) // turn all other non-majority weights into the weight with the most occurances
+  }
+  return ans
+}
+
+function addCounts(countsA, countsB) {
+  let total = Array(27)
+  for (let i = 1; i <= 26; i++) {
+    total[i] = countsA[i] + countsB[i]
+  }
+  return total
+}
+
+function diffCounts(countsA, countsLCA) {
+  let diff = Array(27)
+  for (let i = 1; i <= 26; i++) {
+    diff[i] = countsA[i] - countsLCA[i]
+  }
+  return diff
+}
+
+function getParentsAndPrefixCounts(n, edges) {
+  let directParents = Array(n).fill(-1)
+  let graph = Array(n)
+    .fill(0)
+    .map(() => [])
+  let prefixCounts = Array(n)
+  for (let [u, v, w] of edges) {
+    graph[u].push([v, w])
+    graph[v].push([u, w])
+  }
+  let seen = Array(n).fill(false)
+  seen[0] = true
+  let queue = [[0, Array(27).fill(0), 0]]
+  let depths = Array(n)
+  while (queue.length) {
+    let [node, count, depth] = queue.shift()
+    prefixCounts[node] = count
+    depths[node] = depth
+
+    for (let [nei, weight] of graph[node]) {
+      if (seen[nei]) continue
+      let newCount = [...count]
+      newCount[weight]++
+      seen[nei] = true
+      queue.push([nei, newCount, depth + 1])
+      directParents[nei] = node
+    }
+  }
+  return [directParents, prefixCounts, depths]
+}
+
+class LCA {
+  constructor(n, directParents, depths) {
+    this.maxDepth = Math.ceil(Math.log2(n))
+    this.p = Array(this.maxDepth + 1)
+      .fill(0)
+      .map(() => Array(n).fill(-1))
+    this.depths = depths
+
+    // precomputation for binary lifting
+    for (let node = 0; node < n; node++) {
+      this.p[0][node] = directParents[node]
+    }
+    for (let pow2 = 1; pow2 <= this.maxDepth; pow2++) {
+      for (let node = 0; node < n; node++) {
+        let halfParent = this.p[pow2 - 1][node]
+        this.p[pow2][node] =
+          halfParent === -1 ? -1 : this.p[pow2 - 1][halfParent]
+      }
+    }
+  }
+  getLCA(a, b) {
+    if (this.depths[a] > this.depths[b]) {
+      let temp = a
+      a = b
+      b = temp
+    }
+
+    // bring both nodes up to the same depth
+    let depthDiff = this.depths[b] - this.depths[a]
+    for (let i = 0; i <= this.maxDepth; i++) {
+      if ((depthDiff >> i) & 1) {
+        b = this.p[i][b] // move b up to the 2^ith parent
+      }
+    }
+    if (a === b) return a
+
+    // move both nodes up by 2^ith levels if the 2^ith parents are not equal
+    for (let i = this.maxDepth; i >= 0; i--) {
+      // this decrements so that we can jump the nodes up incrementally
+      if (this.p[i][a] !== this.p[i][b]) {
+        // if 2^ith parents of both nodes are not equal, we can safely both move up
+        a = this.p[i][a]
+        b = this.p[i][b]
+      }
+    }
+    return this.p[0][a]
+  }
+}

From ead9b6ee11c91866edd22d8ee4754c6d9fd7f25b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Sep 2023 20:24:13 +0800
Subject: [PATCH 2779/3374] Create 2581-count-number-of-possible-root-nodes.js

---
 2581-count-number-of-possible-root-nodes.js | 45 +++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 2581-count-number-of-possible-root-nodes.js

diff --git a/2581-count-number-of-possible-root-nodes.js b/2581-count-number-of-possible-root-nodes.js
new file mode 100644
index 00000000..49c2615c
--- /dev/null
+++ b/2581-count-number-of-possible-root-nodes.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[][]} guesses
+ * @param {number} k
+ * @return {number}
+ */
+const rootCount = function (edges, guesses, k) {
+  const lookup = new Set(guesses.map(([a, b]) => a * 1_000_000 + b))
+  const adjList = edges.reduce(
+    (adjList, [a, b]) => {
+      adjList[a].push(b)
+      adjList[b].push(a)
+      return adjList
+    },
+    new Array(edges.length + 1).fill(0).map(() => []),
+  )
+
+  const guessed = (a, b) => (lookup.has(a * 1_000_000 + b) ? 1 : 0)
+
+  const getCorrect = (node, parent) =>
+    adjList[node].reduce(
+      (total, child) =>
+        child === parent
+          ? total
+          : total + guessed(node, child) + getCorrect(child, node),
+      0,
+    )
+
+  const getTotal = (node, parent, correct) =>
+    (correct >= k ? 1 : 0) +
+    adjList[node].reduce(
+      (total, child) =>
+        child === parent
+          ? total
+          : total +
+            getTotal(
+              child,
+              node,
+              correct - guessed(node, child) + guessed(child, node),
+            ),
+      0,
+    )
+
+  return getTotal(0, -1, getCorrect(0, -1))
+}

From dab908ae7835cca692969420c91a0633b4e02dad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Sep 2023 22:05:16 +0800
Subject: [PATCH 2780/3374] Create
 2764-is-array-a-preorder-of-some-binary-tree.js

---
 ...is-array-a-preorder-of-some-binary-tree.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2764-is-array-a-preorder-of-some-binary-tree.js

diff --git a/2764-is-array-a-preorder-of-some-binary-tree.js b/2764-is-array-a-preorder-of-some-binary-tree.js
new file mode 100644
index 00000000..5054f1c8
--- /dev/null
+++ b/2764-is-array-a-preorder-of-some-binary-tree.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[][]} nodes
+ * @return {boolean}
+ */
+var isPreorder = function(nodes) {
+  const stack = [];
+
+  for (const [curr, parent] of nodes) {
+    while (stack.length && stack[stack.length - 1] !== parent) {
+      stack.pop();
+    }
+    if (!stack.length && parent !== -1) {
+      return false;
+    }
+    stack.push(curr);
+  }
+
+  return true;
+};

From ad1eed49fcd782d4c9dbf4886a927f29d88562da Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Sep 2023 01:37:29 -0500
Subject: [PATCH 2781/3374] Create
 2458-height-of-binary-tree-after-subtree-removal-queries.js

---
 ...nary-tree-after-subtree-removal-queries.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 2458-height-of-binary-tree-after-subtree-removal-queries.js

diff --git a/2458-height-of-binary-tree-after-subtree-removal-queries.js b/2458-height-of-binary-tree-after-subtree-removal-queries.js
new file mode 100644
index 00000000..e3869df4
--- /dev/null
+++ b/2458-height-of-binary-tree-after-subtree-removal-queries.js
@@ -0,0 +1,50 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const treeQueries = function(root, queries) {
+  const height = [], depth = [], { max } = Math
+  dfs(root, 0)
+  
+  function dfs(node, dep) {
+    if(node == null) return 0
+    depth[node.val] = dep
+    const h = max(dfs(node.left, dep + 1), dfs(node.right, dep + 1))
+    height[node.val] = h
+    return h + 1
+  }
+  // console.log(height, depth)
+  
+  const neighbors = []
+  for(let i = 1; i < height.length; i++) {
+     if(height[i] == null) continue
+     const d = depth[i]
+     if(neighbors[d] == null) neighbors[d] = []
+     neighbors[d].push([height[i], i])
+     neighbors[d].sort((a, b) => b[0] - a[0])
+     if(neighbors[d].length > 2) neighbors[d].pop()
+  }
+  // console.log(neighbors)
+  const res = []
+  for(const q of queries) {
+     const d = depth[q]
+     if(neighbors[d].length === 1) res.push(d - 1)
+     else if(q === neighbors[d][0][1]) {
+        // console.log('in', d)
+       res.push(d + neighbors[d][1][0])
+     } else {
+       res.push(d + neighbors[d][0][0])
+     }
+  }
+  
+  return res
+};

From 008496e57964e3300a672c9ff3b89e844de79999 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Sep 2023 03:33:26 -0500
Subject: [PATCH 2782/3374] Create 2467-most-profitable-path-in-a-tree.js

---
 2467-most-profitable-path-in-a-tree.js | 48 ++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2467-most-profitable-path-in-a-tree.js

diff --git a/2467-most-profitable-path-in-a-tree.js b/2467-most-profitable-path-in-a-tree.js
new file mode 100644
index 00000000..9f0b827c
--- /dev/null
+++ b/2467-most-profitable-path-in-a-tree.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number[][]} edges
+ * @param {number} bob
+ * @param {number[]} amount
+ * @return {number}
+ */
+const mostProfitablePath = function(edges, bob, amount) {
+  const graph = [], depth = [], parent = []
+  for(const [u, v] of edges) {
+    if(graph[u] == null) graph[u] = []
+    if(graph[v] == null) graph[v] = []
+    graph[u].push(v)
+    graph[v].push(u)
+  }
+  dfs(0)
+  let cur = bob, bobh = 0
+  while(cur) {
+    if(depth[cur] > bobh) amount[cur] = 0
+    else if(depth[cur] === bobh) amount[cur] /= 2
+
+    bobh++
+    cur = parent[cur]
+  }
+  
+  // console.log(depth, parent, amount)
+
+  return dfs2(0)
+
+  function dfs(node, p = 0, d = 0) {
+    parent[node] = p
+    depth[node] = d
+    for(const e of graph[node]) {
+        if(e === p) continue
+        dfs(e, node, d + 1)
+    }
+  }
+
+  function dfs2(node, p = 0) {
+    let res = amount[node]
+    let ma = -Infinity
+    for(const e of graph[node]) {
+        if(e === p) continue
+        ma = Math.max(ma, dfs2(e, node))
+    }
+    if(ma === -Infinity) return res
+    return res + ma
+  }
+};

From 6adb4b11cc78df7a274d30ed41d3659cf81d4dc9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Sep 2023 20:58:54 -0500
Subject: [PATCH 2783/3374] Update
 2322-minimum-score-after-removals-on-a-tree.js

---
 ...-minimum-score-after-removals-on-a-tree.js | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/2322-minimum-score-after-removals-on-a-tree.js b/2322-minimum-score-after-removals-on-a-tree.js
index fe2fc586..5adcde91 100644
--- a/2322-minimum-score-after-removals-on-a-tree.js
+++ b/2322-minimum-score-after-removals-on-a-tree.js
@@ -139,3 +139,96 @@ var minimumScore = function (nums, edges) {
     return (child_xor[i] = ans)
   }
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const minimumScore = function (nums, edges) {
+  const n = nums.length,
+    m = edges.length
+  const graph = {},
+    degree = Array(n).fill(0)
+  const children = [],
+    vArr = nums.slice()
+  for (let i = 0; i < n; i++) children[i] = new Set()
+  for (const [u, v] of edges) {
+    if (graph[u] == null) graph[u] = []
+    if (graph[v] == null) graph[v] = []
+    graph[u].push(v)
+    graph[v].push(u)
+    degree[u]++
+    degree[v]++
+  }
+  let v = 0,
+    q = []
+  const seen = new Set()
+  for (let i = 0; i < n; i++) {
+    v ^= nums[i]
+    if (degree[i] === 1) {
+      q.push(i)
+      seen.add(i)
+    }
+  }
+
+  while (q.length) {
+    const tmp = []
+    const size = q.length
+    for (let i = 0; i < size; i++) {
+      const cur = q[i]
+      for (const nxt of graph[cur]) {
+        // chidlren
+        // vArr
+        if (!seen.has(nxt)) {
+          children[nxt].add(cur)
+          children[nxt] = mergeSet(children[nxt], children[cur])
+          vArr[nxt] ^= vArr[cur]
+        }
+        degree[nxt]--
+        if (degree[nxt] === 1) {
+          tmp.push(nxt)
+          seen.add(nxt)
+        }
+      }
+    }
+
+    q = tmp
+  }
+
+  let res = Infinity
+  for (let i = 0; i < m - 1; i++) {
+    for (let j = i + 1; j < m; j++) {
+      let [a, b] = edges[i]
+      if (children[a].has(b)) {
+        ;[a, b] = [b, a]
+      }
+      let [c, d] = edges[j]
+      if (children[c].has(d)) {
+        ;[c, d] = [d, c]
+      }
+      if (children[c].has(a)) {
+        const tmp = [vArr[a], vArr[c] ^ vArr[a], v ^ vArr[c]]
+        res = Math.min(res, Math.max(...tmp) - Math.min(...tmp))
+      } else if (children[a].has(c)) {
+        const tmp = [vArr[c], vArr[a] ^ vArr[c], v ^ vArr[a]]
+        res = Math.min(res, Math.max(...tmp) - Math.min(...tmp))
+      } else {
+        const tmp = [vArr[a], vArr[c], v ^ vArr[a] ^ vArr[c]]
+        res = Math.min(res, Math.max(...tmp) - Math.min(...tmp))
+      }
+    }
+  }
+
+  return res
+}
+
+function mergeSet(s, t) {
+  for (const e of t) {
+    s.add(e)
+  }
+  return s
+}
+

From a096f7e0d67deab5d863ee26f55f3c1b66999015 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Sep 2023 19:58:30 +0800
Subject: [PATCH 2784/3374] Create
 2858-minimum-edge-reversals-so-every-node-is-reachable.js

---
 ...ge-reversals-so-every-node-is-reachable.js | 71 +++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 2858-minimum-edge-reversals-so-every-node-is-reachable.js

diff --git a/2858-minimum-edge-reversals-so-every-node-is-reachable.js b/2858-minimum-edge-reversals-so-every-node-is-reachable.js
new file mode 100644
index 00000000..839d6212
--- /dev/null
+++ b/2858-minimum-edge-reversals-so-every-node-is-reachable.js
@@ -0,0 +1,71 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+const minEdgeReversals = function (n, edges) {
+  let edgesMap = {}
+  for (let i = 0; i < edges.length; i++) {
+    let a = edges[i][0]
+    let b = edges[i][1]
+    if (edgesMap[a] === undefined) {
+      edgesMap[a] = []
+    }
+    //its a forward edge
+    edgesMap[a].push([b, 'f'])
+    if (edgesMap[b] === undefined) {
+      edgesMap[b] = []
+    }
+    //its a revers edge
+    edgesMap[b].push([a, 'r'])
+  }
+
+  //We can cosnider any node as root node, Here I choose node 0
+  let res = bfs(0)
+  let ans = []
+  ans[0] = res[0]
+  let dist = res[1]
+  for (let i = 1; i < n; i++) {
+    //Ans for rest of the node will be, distance from node to root + answer of root
+    ans[i] = dist[i][0] - dist[i][1] + ans[0]
+  }
+
+  return ans
+  function bfs(root) {
+    let distance = [],
+      visited = [],
+      totalReversal = 0
+    let queue = []
+    queue.push([root, 0, 0])
+    distance[root] = [0, 0]
+    visited[root] = true
+    while (queue.length > 0) {
+      let nextLevelQueue = []
+      for (let i = 0; i < queue.length; i++) {
+        let node = queue[i][0]
+        let weightF = queue[i][1]
+        let weightR = queue[i][2]
+        for (let j = 0; j < edgesMap[node].length; j++) {
+          let neighbour = edgesMap[node][j][0]
+          if (visited[neighbour] !== undefined) {
+            continue
+          }
+          let type = edgesMap[node][j][1]
+          let f = weightF,
+            r = weightR
+          if (type === 'r') {
+            totalReversal += 1
+            r++
+          } else {
+            f++
+          }
+          visited[neighbour] = true
+          distance[neighbour] = [f, r]
+          nextLevelQueue.push([neighbour, f, r])
+        }
+      }
+      queue = nextLevelQueue
+    }
+    return [totalReversal, distance]
+  }
+}

From 83370d88f05325b6c10011ca09082facaec8f91c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Sep 2023 00:13:24 -0500
Subject: [PATCH 2785/3374] Update
 2003-smallest-missing-genetic-value-in-each-subtree.js

---
 ...t-missing-genetic-value-in-each-subtree.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/2003-smallest-missing-genetic-value-in-each-subtree.js b/2003-smallest-missing-genetic-value-in-each-subtree.js
index fccbd9db..0089f20a 100644
--- a/2003-smallest-missing-genetic-value-in-each-subtree.js
+++ b/2003-smallest-missing-genetic-value-in-each-subtree.js
@@ -1,3 +1,61 @@
+/**
+ * @param {number[]} parents
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+function smallestMissingValueSubtree(parent, nums) {
+  const graph = {},
+    n = parent.length
+  const res = Array(n).fill(1)
+  const visited = new Set()
+  let miss = 1
+  for (let i = 0; i < n; i++) {
+    if (graph[parent[i]] == null) graph[parent[i]] = []
+    graph[parent[i]].push(i)
+  }
+  let idx = -1
+  for (let i = 0; i < n; i++) {
+    if (nums[i] === 1) {
+      idx = i
+      break
+    }
+  }
+
+  if (idx === -1) return res
+  let cur = idx,
+    pre = -1
+  while (cur !== -1) {
+    const chidlren = graph[cur]
+    if (chidlren) {
+      for (const child of chidlren) {
+        if (child === pre) continue
+        dfs(child)
+      }
+    }
+    visited.add(nums[cur])
+    while (visited.has(miss)) {
+      miss++
+    }
+    // console.log(cur, miss, visited)
+    res[cur] = miss
+    pre = cur
+    cur = parent[cur]
+  }
+
+  return res
+
+  function dfs(node) {
+    visited.add(nums[node])
+    const chidlren = graph[node]
+    if (chidlren) {
+      for (const child of chidlren) dfs(child)
+    }
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} parents
  * @param {number[]} nums

From c7138bc80a9cd8b474cabb9fde8ac3541ee0b68e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Sep 2023 19:37:09 +0800
Subject: [PATCH 2786/3374] Create 1504-count-submatrices-with-all-ones.js

---
 1504-count-submatrices-with-all-ones.js | 34 +++++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 1504-count-submatrices-with-all-ones.js

diff --git a/1504-count-submatrices-with-all-ones.js b/1504-count-submatrices-with-all-ones.js
new file mode 100644
index 00000000..14cad762
--- /dev/null
+++ b/1504-count-submatrices-with-all-ones.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+const numSubmat = function(mat) {
+  let m = mat.length
+  let n = mat[0].length
+  let res = 0
+  let height = Array(n).fill(0)
+  for (let i = 0; i < m; i++) {
+    let st = []
+    for (let j = 0; j < n; j++) {
+      if (mat[i][j] == 1) {
+        height[j]++
+      } else {
+        height[j] = 0
+      }
+      let sum = 0
+      while (st.length != 0) {
+        if (height[st[st.length - 1][0]] < height[j]) break
+        st.pop()
+      }
+      if (st.length != 0) {
+        sum += height[j] * (j - st[st.length - 1][0]) + st[st.length - 1][1]
+      } else {
+        sum += height[j] * (j + 1)
+      }
+      st.push([j, sum])
+      res += sum
+    }
+  }
+  return res
+
+};

From 942de7057b09165072f915cd619dfa885b72b275 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 14:57:19 +0800
Subject: [PATCH 2787/3374] Create
 2873-maximum-value-of-an-ordered-triplet-i.js

---
 2873-maximum-value-of-an-ordered-triplet-i.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 2873-maximum-value-of-an-ordered-triplet-i.js

diff --git a/2873-maximum-value-of-an-ordered-triplet-i.js b/2873-maximum-value-of-an-ordered-triplet-i.js
new file mode 100644
index 00000000..06fc592a
--- /dev/null
+++ b/2873-maximum-value-of-an-ordered-triplet-i.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumTripletValue = function(nums) {
+  const n = nums.length
+  let res = 0
+  for(let i = 0; i < n - 2; i++) {
+    for(let j = i + 1; j < n - 1; j++) {
+      for(let k = j + 1; k < n ; k++) {
+        if(nums[i] < 0 && nums[j] < 0 && nums[k] < 0) continue
+        res = Math.max(res, (nums[i] - nums[j]) * nums[k])
+      }
+    }
+  }
+  return res
+};

From 0941361a30d2c230b8fc5422adc7d5b1faf07f65 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 14:57:47 +0800
Subject: [PATCH 2788/3374] Create
 2874-maximum-value-of-an-ordered-triplet-ii.js

---
 ...-maximum-value-of-an-ordered-triplet-ii.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2874-maximum-value-of-an-ordered-triplet-ii.js

diff --git a/2874-maximum-value-of-an-ordered-triplet-ii.js b/2874-maximum-value-of-an-ordered-triplet-ii.js
new file mode 100644
index 00000000..2b996426
--- /dev/null
+++ b/2874-maximum-value-of-an-ordered-triplet-ii.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumTripletValue = function(nums) {
+  const n = nums.length, {max} = Math
+  const left = Array(n).fill(0), right = Array(n).fill(0)
+  for(let i = 0, ma = 0; i < n; i++) {
+    ma = max(ma, nums[i])
+    left[i] = ma
+  }
+  for(let i = n - 1, ma = 0; i >= 0; i--) {
+    ma = max(ma, nums[i])
+    right[i] = ma
+  }
+  let res = 0
+  
+  for(let i = 1; i < n - 1; i++) {
+    res = max(res, (left[i - 1] - nums[i]) * right[i + 1] )
+  }
+  
+  return res
+};

From da45b267456eb91e23d7384400ee3c4479dac4dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 14:58:18 +0800
Subject: [PATCH 2789/3374] Create
 2875-minimum-size-subarray-in-infinite-array.js

---
 ...minimum-size-subarray-in-infinite-array.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2875-minimum-size-subarray-in-infinite-array.js

diff --git a/2875-minimum-size-subarray-in-infinite-array.js b/2875-minimum-size-subarray-in-infinite-array.js
new file mode 100644
index 00000000..94c6b1b3
--- /dev/null
+++ b/2875-minimum-size-subarray-in-infinite-array.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+var minSizeSubarray = function(nums, target) {
+    let sum = 0, su = 0;
+    for (const a of nums) sum += a;
+    let n = nums.length, k = Math.floor(target / sum), res = n;
+    target %= sum;
+    if (target === 0) {
+        return k * n;
+    }
+
+    let dp = new Map();
+    dp.set(0, -1);
+
+    for (let i = 0; i < 2 * n; ++i) {
+        su += nums[i % n];
+        if (dp.has(su - target)) {
+            res = Math.min(res, i - dp.get(su - target));
+        }
+        dp.set(su, i);
+    }
+
+    return res < n ? res + k * n : -1;
+};

From 6c005b5c0361cd429850d088109af763f9be6a23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 14:58:50 +0800
Subject: [PATCH 2790/3374] Create
 2876-count-visited-nodes-in-a-directed-graph.js

---
 ...count-visited-nodes-in-a-directed-graph.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2876-count-visited-nodes-in-a-directed-graph.js

diff --git a/2876-count-visited-nodes-in-a-directed-graph.js b/2876-count-visited-nodes-in-a-directed-graph.js
new file mode 100644
index 00000000..df153750
--- /dev/null
+++ b/2876-count-visited-nodes-in-a-directed-graph.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} edges
+ * @return {number[]}
+ */
+var countVisitedNodes = function(edges) {
+    let n = edges.length, res = new Array(n).fill(0), j = 0;
+    for (let i = 0; i < n; j = ++i) {
+        let seen = new Set();
+        let s = [];
+        while (!seen.has(j) && res[j] == 0) {
+            seen.add(j);
+            s.push(j);
+            j = edges[j];
+        }
+        if (seen.has(j)) { // hit the cycle
+            let k = s.length - s.indexOf(j);
+            for (j = 0; j < k; ++j) {
+                res[s.pop()] = k;
+            }
+        }
+        while (s.length) {
+            j = s.pop();
+            res[j] = res[edges[j]] + 1;
+        }
+    }
+    return res;  
+};

From 6a76469d6655becb763754e9f5604c79eb145722 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 15:28:21 +0800
Subject: [PATCH 2791/3374] Update
 2876-count-visited-nodes-in-a-directed-graph.js

---
 2876-count-visited-nodes-in-a-directed-graph.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/2876-count-visited-nodes-in-a-directed-graph.js b/2876-count-visited-nodes-in-a-directed-graph.js
index df153750..0def283d 100644
--- a/2876-count-visited-nodes-in-a-directed-graph.js
+++ b/2876-count-visited-nodes-in-a-directed-graph.js
@@ -4,7 +4,8 @@
  */
 var countVisitedNodes = function(edges) {
     let n = edges.length, res = new Array(n).fill(0), j = 0;
-    for (let i = 0; i < n; j = ++i) {
+    for (let i = 0; i < n; i++) {
+        let j = i
         let seen = new Set();
         let s = [];
         while (!seen.has(j) && res[j] == 0) {

From 7d504b4ad41dc04c9255e5b245d668f9ebb1f54b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Oct 2023 20:29:50 +0800
Subject: [PATCH 2792/3374] Create 2866-beautiful-towers-ii.js

---
 2866-beautiful-towers-ii.js | 37 +++++++++++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 2866-beautiful-towers-ii.js

diff --git a/2866-beautiful-towers-ii.js b/2866-beautiful-towers-ii.js
new file mode 100644
index 00000000..8cbf4e55
--- /dev/null
+++ b/2866-beautiful-towers-ii.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} maxHeights
+ * @return {number}
+ */
+const maximumSumOfHeights = function (maxHeights) {
+  let n = maxHeights.length
+
+  let left = Array(n).fill(0)
+  let stack = []
+  stack.push(-1)
+  let res = 0,
+    cur = 0
+  for (let i = 0; i < n; i++) {
+    while (stack.length > 1 && maxHeights[stack.at(-1)] > maxHeights[i]) {
+      let j = stack.pop()
+      cur -= (j - stack.at(-1)) * maxHeights[j]
+    }
+    cur += 1 * (i - stack.at(-1)) * maxHeights[i]
+    stack.push(i)
+    left[i] = cur
+  }
+
+  stack = []
+  stack.push(n)
+  cur = 0
+  for (let i = n - 1; i >= 0; i--) {
+    while (stack.length > 1 && maxHeights[stack.at(-1)] > maxHeights[i]) {
+      let j = stack.pop()
+      cur -= 1 * -(j - stack.at(-1)) * maxHeights[j]
+    }
+    cur += 1 * -(i - stack.at(-1)) * maxHeights[i]
+    stack.push(i)
+    res = Math.max(res, left[i] + cur - maxHeights[i])
+  }
+
+  return res
+}

From fbcf8cd0f8117cc003c3ac5c9321fc638b531fdd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Oct 2023 21:43:56 +0800
Subject: [PATCH 2793/3374] Update 1944-number-of-visible-people-in-a-queue.js

---
 1944-number-of-visible-people-in-a-queue.js | 24 +++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/1944-number-of-visible-people-in-a-queue.js b/1944-number-of-visible-people-in-a-queue.js
index d74994b3..b2864dfc 100644
--- a/1944-number-of-visible-people-in-a-queue.js
+++ b/1944-number-of-visible-people-in-a-queue.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} heights
+ * @return {number[]}
+ */
+const canSeePersonsCount = function(heights) {
+  const n = heights.length
+  const res = Array(n).fill(0)
+  const stk = []
+  for(let i = n - 1; i >= 0; i--) {
+    const cur = heights[i]
+    let del = 0
+    while(stk.length && cur > heights[stk.at(-1)]) {
+      del++
+      stk.pop()
+    }
+    res[i] = del + (stk.length ? 1 : 0)
+    stk.push(i)
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} heights
  * @return {number[]}

From 657ff1275d032786a30fde033865b3a9cf88d563 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Oct 2023 23:10:58 +0800
Subject: [PATCH 2794/3374] Create 962-maximum-width-ramp.js

---
 962-maximum-width-ramp.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 962-maximum-width-ramp.js

diff --git a/962-maximum-width-ramp.js b/962-maximum-width-ramp.js
new file mode 100644
index 00000000..8cd14c1e
--- /dev/null
+++ b/962-maximum-width-ramp.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxWidthRamp = function(nums) {
+  const s = [];
+  let res = 0, n = nums.length;
+  for (let i = 0; i < n; ++i) {
+    if (s.length === 0 || nums[s.at(-1)] > nums[i]) s.push(i);      
+  }
+
+  for (let i = n - 1; i > res; --i) {
+    while (s.length && nums[s.at(-1)] <= nums[i])  res = Math.max(res, i - s.pop());      
+  }
+
+  return res;
+};

From 04320658dd57959b1b1d02b7be56ddda04d00e36 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Oct 2023 23:48:49 -0500
Subject: [PATCH 2795/3374] Create
 2897-apply-operations-on-array-to-maximize-sum-of-squares.js

---
 ...ons-on-array-to-maximize-sum-of-squares.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2897-apply-operations-on-array-to-maximize-sum-of-squares.js

diff --git a/2897-apply-operations-on-array-to-maximize-sum-of-squares.js b/2897-apply-operations-on-array-to-maximize-sum-of-squares.js
new file mode 100644
index 00000000..64c54537
--- /dev/null
+++ b/2897-apply-operations-on-array-to-maximize-sum-of-squares.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxSum = function(nums, k) {
+  const n = nums.length, mod = BigInt(1e9 + 7)
+  let res = 0n
+  const stk = Array(n).fill(0), idx = Array(32).fill(0)
+  for(const e of nums) {
+      for(let i = 0; i < 32; i++) {
+          if((e >> i) & 1) {
+              stk[idx[i]] += (1 << i)
+              idx[i]++
+          }
+      }
+  }
+
+  for(let i = 0; i < k; i++) {
+      res += BigInt(stk[i]) * BigInt(stk[i]) 
+      res %= mod 
+  }
+  
+  return Number(res)
+};

From abf9481f56f13e51c932afea3538f5a11787856e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Oct 2023 23:57:36 -0500
Subject: [PATCH 2796/3374] Create
 2896-apply-operations-to-make-two-strings-equal.js

---
 ...ly-operations-to-make-two-strings-equal.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2896-apply-operations-to-make-two-strings-equal.js

diff --git a/2896-apply-operations-to-make-two-strings-equal.js b/2896-apply-operations-to-make-two-strings-equal.js
new file mode 100644
index 00000000..839fa09e
--- /dev/null
+++ b/2896-apply-operations-to-make-two-strings-equal.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function(s1, s2, x) {
+    const diffs = [];
+    for (let i = 0; i < s1.length; i++) {
+        if (s1[i] !== s2[i]) {
+            diffs.push(i);
+        }
+    }
+
+    if (diffs.length % 2 === 1) {
+        return -1;
+    }
+
+    const cache = new Map();
+    function bestCostUpTo(i) {
+        if (i === 0) {
+            return x / 2;
+        }
+        if (i === -1) {
+            return 0;
+        }
+        if (cache.has(i)) {
+            return cache.get(i);
+        }
+        const cost = Math.min(
+            bestCostUpTo(i - 1) + x / 2,
+            bestCostUpTo(i - 2) + diffs[i] - diffs[i - 1]
+        );
+        cache.set(i, cost);
+        return cost;
+    }
+
+    return Math.floor(bestCostUpTo(diffs.length - 1));
+};

From 06c587c18da8a040edebe8aacdcfbd02b1a1d6ee Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Oct 2023 23:58:15 -0500
Subject: [PATCH 2797/3374] Create 2895-minimum-processing-time.js

---
 2895-minimum-processing-time.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2895-minimum-processing-time.js

diff --git a/2895-minimum-processing-time.js b/2895-minimum-processing-time.js
new file mode 100644
index 00000000..02747490
--- /dev/null
+++ b/2895-minimum-processing-time.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} processorTime
+ * @param {number[]} tasks
+ * @return {number}
+ */
+const minProcessingTime = function (processorTime, tasks) {
+    const n = processorTime.length
+    processorTime.sort((a, b) => a - b)
+    tasks.sort((a, b) => b - a)
+    let res = 0
+    for(let i = 0, j = 0; i < n; i++, j += 4) {
+        res = Math.max(res, processorTime[i] + tasks[j])
+    }
+    return res
+}

From 887d465429ac7db6ad0d8d09410661b4ef9e0bcd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 7 Oct 2023 23:58:43 -0500
Subject: [PATCH 2798/3374] Create
 2894-divisible-and-non-divisible-sums-difference.js

---
 2894-divisible-and-non-divisible-sums-difference.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2894-divisible-and-non-divisible-sums-difference.js

diff --git a/2894-divisible-and-non-divisible-sums-difference.js b/2894-divisible-and-non-divisible-sums-difference.js
new file mode 100644
index 00000000..d7a5db30
--- /dev/null
+++ b/2894-divisible-and-non-divisible-sums-difference.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+const differenceOfSums = function(n, m) {
+    let num1 = 0, num2 = 0
+    for(let i = 1; i <= n; i++) {
+        if(i % m !== 0) num1 += i
+        if(i % m === 0) num2 += i
+    }
+    return num1 - num2
+};

From bdfd497c9dc871c01979f61490567e0b95e9f7ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Oct 2023 00:25:30 -0500
Subject: [PATCH 2799/3374] Create
 1297-maximum-number-of-occurrences-of-a-substring.js

---
 ...um-number-of-occurrences-of-a-substring.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 1297-maximum-number-of-occurrences-of-a-substring.js

diff --git a/1297-maximum-number-of-occurrences-of-a-substring.js b/1297-maximum-number-of-occurrences-of-a-substring.js
new file mode 100644
index 00000000..7d63bbac
--- /dev/null
+++ b/1297-maximum-number-of-occurrences-of-a-substring.js
@@ -0,0 +1,24 @@
+/**
+ * @param {string} s
+ * @param {number} maxLetters
+ * @param {number} minSize
+ * @param {number} maxSize
+ * @return {number}
+ */
+function maxFreq(s, maxLetters, k, maxSize) {
+    let count = new Map();
+    for (let i = 0; i <= s.length - k; i++) {
+        let substring = s.slice(i, i + k);
+        if (!count.has(substring)) {
+            count.set(substring, 0);
+        }
+        count.set(substring, count.get(substring) + 1);
+    }
+    let maxFreq = 0;
+    for (let [substring, freq] of count) {
+        if (new Set(substring).size <= maxLetters) {
+            maxFreq = Math.max(maxFreq, freq);
+        }
+    }
+    return maxFreq;
+}

From efa671fbb0c391bb249feda6c8057c949cec45d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Oct 2023 01:49:00 -0500
Subject: [PATCH 2800/3374] Update
 2896-apply-operations-to-make-two-strings-equal.js

---
 ...ly-operations-to-make-two-strings-equal.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2896-apply-operations-to-make-two-strings-equal.js b/2896-apply-operations-to-make-two-strings-equal.js
index 839fa09e..7e7492ca 100644
--- a/2896-apply-operations-to-make-two-strings-equal.js
+++ b/2896-apply-operations-to-make-two-strings-equal.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @param {number} x
+ * @return {number}
+ */
+var minOperations = function(s1, s2, x) {
+    const n = s1.length;
+    const idxs = [];
+    for (let i = 0; i < n; i++) {
+        if (s1[i] !== s2[i]) {
+            idxs.push(i);
+        }
+    }
+    const k = idxs.length;
+    if (k % 2) {
+        return -1;
+    }
+    const dp = new Array(k + 1).fill(Infinity);
+    dp[0] = 0;
+    for (let i = 0; i < k; i++) {
+        if (i % 2 === 0) {
+            dp[i + 1] = dp[i];
+        } else {
+            dp[i + 1] = dp[i] + x;
+        }
+        if (i) {
+            dp[i + 1] = Math.min(dp[i + 1], dp[i - 1] + idxs[i] - idxs[i - 1]);
+        }
+    }
+    return dp[k];
+};
+
+// another
+
 /**
  * @param {string} s1
  * @param {string} s2

From bb70f9195df728585b4fbedab14c98c92806ab75 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Oct 2023 01:50:26 -0500
Subject: [PATCH 2801/3374] Update
 2896-apply-operations-to-make-two-strings-equal.js

---
 2896-apply-operations-to-make-two-strings-equal.js | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/2896-apply-operations-to-make-two-strings-equal.js b/2896-apply-operations-to-make-two-strings-equal.js
index 7e7492ca..71acb213 100644
--- a/2896-apply-operations-to-make-two-strings-equal.js
+++ b/2896-apply-operations-to-make-two-strings-equal.js
@@ -19,11 +19,22 @@ var minOperations = function(s1, s2, x) {
     const dp = new Array(k + 1).fill(Infinity);
     dp[0] = 0;
     for (let i = 0; i < k; i++) {
+        /*
+            # 这里没有删除指的是没有用第二种操作
+            # 如果目前考虑的元素个数为奇数，如果最后一个位置没有被删除，则前面位置都被删除了，那么当前的成本是 dp[i]
+        */
         if (i % 2 === 0) {
             dp[i + 1] = dp[i];
         } else {
+        /*
+            # 如果目前考虑的元素个数为偶数，如果最后一个位置没有被删除，则需要与前面的某项进行配对删除（第一种操作），
+            # 那么当前的成本是 dp[i] + x，即前面有位置没被删除的成本 + 这次删除的成本，因为要删去最后两项
+        */
             dp[i + 1] = dp[i] + x;
         }
+        /*
+            # 考虑使用第二种操作
+        */
         if (i) {
             dp[i + 1] = Math.min(dp[i + 1], dp[i - 1] + idxs[i] - idxs[i - 1]);
         }

From 4320bf9382ba7ac041478bf5586476903b23b6e0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Oct 2023 02:35:48 -0500
Subject: [PATCH 2802/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 9b9130d8..0c65e37a 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -124,3 +124,41 @@ const findTheLongestSubstring = function(s) {
 
   return res
 };
+
+// another
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const findTheLongestSubstring = function (s) {
+  let mask = 0
+  const n = s.length,
+    { max } = Math,
+    map = new Map(),
+    a = 'a'.charCodeAt(0),
+    set = new Set(['a', 'e', 'i', 'o', 'u'])
+  map.set(0, -1)
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    const ch = s[i]
+    if (set.has(ch)) {
+      const idx = ch.charCodeAt(0) - a
+      mask ^= 1 << idx
+      if (mask === 0) res = max(res, i + 1)
+      else if (map.has(mask)) {
+        res = max(res, i - map.get(mask))
+      } else {
+        map.set(mask, i)
+      }
+    } else {
+        if(map.has(mask)) {
+            // console.log(i, map.get(mask))
+            res = max(res, i - map.get(mask))
+        }
+    }
+  }
+
+  return res
+}
+

From 66fee86854f5c8d4fd690d83c300ccdf053ccaf2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Oct 2023 21:30:12 -0500
Subject: [PATCH 2803/3374] Update 1542-find-longest-awesome-substring.js

---
 1542-find-longest-awesome-substring.js | 34 ++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/1542-find-longest-awesome-substring.js b/1542-find-longest-awesome-substring.js
index aaa37653..7426ad8f 100644
--- a/1542-find-longest-awesome-substring.js
+++ b/1542-find-longest-awesome-substring.js
@@ -1,3 +1,37 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const longestAwesome = function(s) {
+  const n = s.length, map = new Map(), {max} = Math
+  let res = 0, mask = 0
+  
+  map.set(0, -1)
+  for(let i = 0; i < n; i++) {
+    const d = +s[i]
+    mask ^= (1 << d)
+    if(map.has(mask)) {
+        res = max(res, i - map.get(mask))
+    }
+
+    for(let j = 0; j < 10; j++) {
+        const tmp = mask ^ (1 << j)
+        if(map.has(tmp)) {
+            // console.log(i, map.get(tmp), tmp)
+            res = max(res, i - map.get(tmp))
+        }
+    }
+
+    if(!map.has(mask)) {
+        map.set(mask, i)
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From bcdfe81ac805ba8b5a28db4ace663e5031abedc7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Oct 2023 22:04:17 +0800
Subject: [PATCH 2804/3374] Update 169-majority-element.js

---
 169-majority-element.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/169-majority-element.js b/169-majority-element.js
index 91f38a94..34d524d4 100755
--- a/169-majority-element.js
+++ b/169-majority-element.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const majorityElement = function(nums) {
+   let res = 0, cnt = 0
+   
+   for(const e of nums) {
+     if(cnt === 0) {
+       res = e
+     }
+     if(res === e) cnt++
+     else cnt--
+   }
+   
+   return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 97f5d05cacdcfa03e328dd2453a9b0e49edb829a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Oct 2023 22:17:35 +0800
Subject: [PATCH 2805/3374] Update 229-majority-element-ii.js

---
 229-majority-element-ii.js | 39 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/229-majority-element-ii.js b/229-majority-element-ii.js
index 96d6c824..2f1b5be7 100644
--- a/229-majority-element-ii.js
+++ b/229-majority-element-ii.js
@@ -1,3 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const majorityElement = function(nums) {
+  let candidate1 = 0, candidate2 = 0, cnt1 = 0, cnt2 = 0
+  for(const e of nums) {
+    if(e === candidate1) {
+      cnt1++
+    } else if(e === candidate2) {
+      cnt2++
+    } else if(cnt1 === 0) {
+      candidate1 = e
+      cnt1++
+    } else if(cnt2 === 0) {
+      candidate2 = e
+      cnt2++
+    } else {
+      cnt1--
+      cnt2--
+    }
+  }
+  
+  const n = nums.length
+  let c1 = 0, c2 = 0
+  for(const e of nums) {
+    if(e === candidate1) c1++
+    if(e === candidate2) c2++
+  }
+  const k = Math.floor(n / 3)
+  const res = []
+  if(c1 > k) res.push(candidate1)
+  if(c2 > k) res.push(candidate2)
+  if(res[0] === res[1]) res.pop()
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number[]}

From eb3cab9433cf9b3ab03a3c5b8b92a9413cc7ade6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Oct 2023 22:41:06 -0500
Subject: [PATCH 2806/3374] Update 1590-make-sum-divisible-by-p.js

---
 1590-make-sum-divisible-by-p.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
index 91857ae1..182ae5a0 100644
--- a/1590-make-sum-divisible-by-p.js
+++ b/1590-make-sum-divisible-by-p.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+const minSubarray = function(nums, p) {
+  const sum = nums.reduce((ac, e) => ac+ e,0)
+  const target = sum % p, n = nums.length, {min} = Math
+  if(target === 0) return 0
+  const map = new Map()
+  map.set(0, -1)
+  let res = n
+  for(let i = 0, s = 0; i < n; i++) {
+      s += nums[i]
+      const r = s % p
+
+      if(r >= target) {
+          if(map.has(r - target)) res = min(res, i - map.get(r-target))
+      }else {
+          if(map.has(p + r - target)) res = min(res, i - map.get(p + r - target))
+      }
+      map.set(r, i)
+  }
+  
+  return res === n ? -1 : res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} p

From c09d159d9f5eac813170538beace00e58b7a2e69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Oct 2023 00:43:54 -0500
Subject: [PATCH 2807/3374] Create 2483-minimum-penalty-for-a-shop.js

---
 2483-minimum-penalty-for-a-shop.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2483-minimum-penalty-for-a-shop.js

diff --git a/2483-minimum-penalty-for-a-shop.js b/2483-minimum-penalty-for-a-shop.js
new file mode 100644
index 00000000..ed7948fa
--- /dev/null
+++ b/2483-minimum-penalty-for-a-shop.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} customers
+ * @return {number}
+ */
+const bestClosingTime = function (customers) {
+    const n = customers.length, {min} = Math
+    let penalty = n, idx = -1, ma = 0
+    for(let i = 0, save = 0; i < n; i++) {
+        const ch = customers[i]
+        if(ch === 'Y') save++
+        else save--
+
+        if(save > ma) {
+            idx = i
+            ma = save
+        }
+    }
+
+    return idx + 1
+}

From eef0ac565474624f9de6f2d3ffa0d9f65a1a0b22 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Oct 2023 20:25:02 +0800
Subject: [PATCH 2808/3374] Update
 1658-minimum-operations-to-reduce-x-to-zero.js

---
 ...-minimum-operations-to-reduce-x-to-zero.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1658-minimum-operations-to-reduce-x-to-zero.js b/1658-minimum-operations-to-reduce-x-to-zero.js
index 15935ef5..1e9fd1d6 100644
--- a/1658-minimum-operations-to-reduce-x-to-zero.js
+++ b/1658-minimum-operations-to-reduce-x-to-zero.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function(nums, x) {
+  const n = nums.length
+  const sum  = nums.reduce((ac, e) => ac + e, 0)
+  const target = sum - x
+  if(target < 0) return -1
+  if(target === 0) return n
+  const map = new Map()
+  map.set(0, -1)
+  let res = 0
+  for(let i = 0, cur = 0; i < n; i++) {
+    cur += nums[i]
+    if(map.has(cur - target)) {
+      res = Math.max(res, i - map.get(cur - target))
+    }
+    
+    if(!map.has(cur)) map.set(cur, i)
+  }
+  
+  return res === 0 ? -1 : n - res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} x

From 80dd26077ce5ad4d2490209a20fea88f8ab79706 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Oct 2023 22:45:14 -0500
Subject: [PATCH 2809/3374] Update 1915-number-of-wonderful-substrings.js

---
 1915-number-of-wonderful-substrings.js | 27 ++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1915-number-of-wonderful-substrings.js b/1915-number-of-wonderful-substrings.js
index 8402c87d..99f3a690 100644
--- a/1915-number-of-wonderful-substrings.js
+++ b/1915-number-of-wonderful-substrings.js
@@ -1,3 +1,30 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const wonderfulSubstrings = function (word) {
+  const n = word.length,
+    a = 'a'.charCodeAt(0)
+  const map = new Map()
+  map.set(0, 1)
+  let res = 0
+  for (let i = 0, mask = 0; i < n; i++) {
+    const idx = word[i].charCodeAt(0) - a
+    mask ^= 1 << idx
+    res += (map.get(mask) || 0) 
+    for (let j = 0; j < 10; j++) {
+      const tmp = mask ^ (1 << j)
+      res += map.get(tmp) || 0
+    }
+
+    map.set(mask, (map.get(mask) || 0) + 1)
+  }
+  return res
+}
+
+// another
+
+
 /**
  * @param {string} word
  * @return {number}

From ff7748a76af212753cfe54a18bdff4f3306270cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Oct 2023 13:39:25 +0800
Subject: [PATCH 2810/3374] Create
 2903-find-indices-with-index-and-value-difference-i.js

---
 ...dices-with-index-and-value-difference-i.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2903-find-indices-with-index-and-value-difference-i.js

diff --git a/2903-find-indices-with-index-and-value-difference-i.js b/2903-find-indices-with-index-and-value-difference-i.js
new file mode 100644
index 00000000..46a565c9
--- /dev/null
+++ b/2903-find-indices-with-index-and-value-difference-i.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number} indexDifference
+ * @param {number} valueDifference
+ * @return {number[]}
+ */
+var findIndices = function(nums, indexDifference, valueDifference) {
+  let res = [-1, -1]
+  const {abs} = Math, n = nums.length
+  for(let i = 0; i < n; i++) {
+    for(let j = i; j < n; j++) {
+      if(abs(i - j) >= indexDifference && abs(nums[i] - nums[j]) >= valueDifference) {
+        res = [i, j]
+      }
+    }
+  }
+  
+  
+  return res
+};

From 7ab055b0ab4e499d277a50216a4de2633b6b5b0f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Oct 2023 13:39:52 +0800
Subject: [PATCH 2811/3374] Create
 2904-shortest-and-lexicographically-smallest-beautiful-string.js

---
 ...cographically-smallest-beautiful-string.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 2904-shortest-and-lexicographically-smallest-beautiful-string.js

diff --git a/2904-shortest-and-lexicographically-smallest-beautiful-string.js b/2904-shortest-and-lexicographically-smallest-beautiful-string.js
new file mode 100644
index 00000000..b138eec2
--- /dev/null
+++ b/2904-shortest-and-lexicographically-smallest-beautiful-string.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const shortestBeautifulSubstring = function (s, k) {
+    let n = s.length;
+    let left = 0;
+    let right = 0;
+    let count = 0;
+    let min_length = Infinity;
+    let res = "";
+    while (right < n) {
+        count = updateCount(s[right], count);
+        while (count === k) {
+            [min_length, res] = updateRes(s, left, right, min_length, res);
+            count = updateCount(s[left], count, false);
+            left++;
+        }
+        right++;
+    }
+    return res;
+    
+    
+    function updateCount(c, count, increment = true) {
+        if (c === '1') {
+            return increment ? count + 1 : count - 1;
+        }
+        return count;
+    }
+    
+    function updateRes(s, left, right, min_length, res) {
+        if (right - left + 1 < min_length) {
+            min_length = right - left + 1;
+            res = s.substring(left, left + min_length);
+        } else if (right - left + 1 === min_length) {
+            // res = Math.min(res, s.substring(left, left + min_length));
+           if(s.substring(left, left + min_length) < res) res = s.substring(left, left + min_length)
+        }
+        return [min_length, res];
+    }
+
+}

From 2f89661d1a2eb0d2168666db34073390ccba7741 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Oct 2023 13:40:20 +0800
Subject: [PATCH 2812/3374] Create
 2905-find-indices-with-index-and-value-difference-ii.js

---
 ...ices-with-index-and-value-difference-ii.js | 156 ++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 2905-find-indices-with-index-and-value-difference-ii.js

diff --git a/2905-find-indices-with-index-and-value-difference-ii.js b/2905-find-indices-with-index-and-value-difference-ii.js
new file mode 100644
index 00000000..a8d47bb8
--- /dev/null
+++ b/2905-find-indices-with-index-and-value-difference-ii.js
@@ -0,0 +1,156 @@
+/**
+ * @param {number[]} nums
+ * @param {number} indexDifference
+ * @param {number} valueDifference
+ * @return {number[]}
+ */
+class SegmentTree {
+  constructor(start = 0, end = 0, value = null, lazy = null, merge) {
+    this.start = start
+    this.end = end
+    this.value = value
+    this.lazy = lazy
+    this.merge = merge
+    this.left = null
+    this.right = null
+  }
+
+  get mid() {
+    return this.start + Math.floor((this.end - this.start) / 2)
+  }
+
+  build(arr) {
+    return this.buildHelper(0, arr.length - 1, arr)
+  }
+
+  buildHelper(left, right, arr) {
+    if (left > right) return null
+    const root = new SegmentTree(left, right, arr[left], null, this.merge)
+    if (left === right) return root
+    const mid = Math.floor((left + right) / 2)
+    root.left = this.buildHelper(left, mid, arr)
+    root.right = this.buildHelper(mid + 1, right, arr)
+    root.value = this.safeMerge(root.left?.value, root.right?.value)
+    return root
+  }
+
+  build(left, right, defaultValue) {
+    if (left > right) return null
+    return new SegmentTree(left, right, defaultValue, null, this.merge)
+  }
+
+  update(root, l, r, v) {
+    if (l <= root.start && r >= root.end) {
+      root.value = v
+      root.lazy = this.safeMerge(root.lazy, v)
+      return
+    }
+    if (root.left === null || root.right === null) {
+      const mid = root.mid
+      if (root.left === null)
+        root.left = this.build(root.start, mid, root.value)
+      if (root.right === null)
+        root.right = this.build(mid + 1, root.end, root.value)
+    }
+    this.pushDown(root)
+    const mid = root.mid
+    if (l <= mid) {
+      this.update(root.left, l, r, v)
+    }
+    if (r > mid) {
+      this.update(root.right, l, r, v)
+    }
+    root.value = this.merge(root.left.value, root.right.value)
+  }
+
+  pushDown(root) {
+    if (root.lazy === null) return
+    root.left.lazy = this.safeMerge(root.left.lazy, root.lazy)
+    root.right.lazy = this.safeMerge(root.right.lazy, root.lazy)
+    root.left.value = this.safeMerge(root.left.value, root.lazy)
+    root.right.value = this.safeMerge(root.right.value, root.lazy)
+    root.lazy = null
+  }
+
+  update(root, index, value) {
+    if (root.start === index && root.end === index) {
+      root.value = value
+      return
+    }
+    if (root.left === null || root.right === null) {
+      const mid = root.mid
+      if (root.left === null)
+        root.left = this.build(root.start, mid, root.value)
+      if (root.right === null)
+        root.right = this.build(mid + 1, root.end, root.value)
+    }
+    const mid = root.mid
+    if (index <= mid) {
+      this.update(root.left, index, value)
+      root.value = this.safeMerge(root.left.value, root.right.value)
+    } else {
+      this.update(root.right, index, value)
+      root.value = this.safeMerge(root.left.value, root.right.value)
+    }
+  }
+
+  query(root, left, right) {
+    if (left <= root.start && right >= root.end) {
+      return root.value
+    }
+    if (root.left === null || root.right === null) {
+      const mid = root.mid
+      if (root.left === null)
+        root.left = this.build(root.start, mid, root.value)
+      if (root.right === null)
+        root.right = this.build(mid + 1, root.end, root.value)
+    }
+    this.pushDown(root)
+    const mid = root.mid
+    let ans = null
+    if (mid >= left) {
+      ans = this.safeMerge(ans, this.query(root.left, left, right))
+    }
+    if (mid + 1 <= right) {
+      ans = this.safeMerge(ans, this.query(root.right, left, right))
+    }
+    return ans
+  }
+
+  safeMerge(a, b) {
+    if (a === null) return b
+    if (b === null) return a
+    return this.merge(a, b)
+  }
+
+  lazyMerge(a, b) {
+    return b
+  }
+}
+
+function findIndices(nums, indexDifference, valueDifference) {
+  const root = new SegmentTree(0, 100005, [0, 0], null, (a, b) =>
+    a[0] >= b[0] ? a : b,
+  )
+  for (let i = 0; i < nums.length; i++) {
+    root.update(root, i, [nums[i], i])
+  }
+
+  for (let i = 0; i < nums.length; i++) {
+    const left = i - indexDifference
+    if (left >= 0) {
+      const max = root.query(root, 0, left)
+      if (max[0] - nums[i] >= valueDifference) {
+        return [max[1], i]
+      }
+    }
+    const right = i + indexDifference
+    if (right < nums.length) {
+      const max = root.query(root, right, nums.length - 1)
+      if (max[0] - nums[i] >= valueDifference) {
+        return [i, max[1]]
+      }
+    }
+  }
+  return [-1, -1]
+}

From a5bd49d7392d0d2381462c044a323937bbd69e51 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 15 Oct 2023 13:40:45 +0800
Subject: [PATCH 2813/3374] Create 2906-construct-product-matrix.js

---
 2906-construct-product-matrix.js | 68 ++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 2906-construct-product-matrix.js

diff --git a/2906-construct-product-matrix.js b/2906-construct-product-matrix.js
new file mode 100644
index 00000000..5396d36c
--- /dev/null
+++ b/2906-construct-product-matrix.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[][]}
+ */
+var constructProductMatrix = function(grid) {
+    const mod = 12345;
+    const n = grid.length;
+    const m = grid[0].length;
+
+    const row = new Array(n).fill(1);
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < m; j++) {
+            row[i] = (row[i] * grid[i][j]) % mod;
+        }
+    }
+
+    const rowLeft = new Array(n).fill(1);
+    const rowRight = new Array(n).fill(1);
+    for (let i = 0; i < n; i++) {
+        rowLeft[i] = (i === 0) ? row[i] : rowLeft[i - 1] * row[i];
+        rowLeft[i] = rowLeft[i] % mod;
+    }
+    for (let i = n - 1; i >= 0; i--) {
+        rowRight[i] = (i === n - 1) ? row[i] : rowRight[i + 1] * row[i];
+        rowRight[i] = rowRight[i] % mod;
+    }
+
+    const colLeft = new Array(n);
+    const colRight = new Array(n);
+    for (let i = 0; i < n; i++) {
+        colLeft[i] = new Array(m);
+        colRight[i] = new Array(m);
+        for (let j = 0; j < m; j++) {
+            colLeft[i][j] = (j === 0) ? grid[i][j] : colLeft[i][j - 1] * grid[i][j];
+            colLeft[i][j] = colLeft[i][j] % mod;
+        }
+        for (let j = m - 1; j >= 0; j--) {
+            colRight[i][j] = (j === m - 1) ? grid[i][j] : colRight[i][j + 1] * grid[i][j];
+            colRight[i][j] = colRight[i][j] % mod;
+        }
+    }
+
+    const ans = new Array(n);
+    for (let i = 0; i < n; i++) {
+        ans[i] = new Array(m);
+        for (let j = 0; j < m; j++) {
+            let tmp = 1;
+            if (i - 1 >= 0) {
+                tmp *= rowLeft[i - 1];
+                tmp %= mod;
+            }
+            if (i + 1 < n) {
+                tmp *= rowRight[i + 1];
+                tmp %= mod;
+            }
+            if (j - 1 >= 0) {
+                tmp *= colLeft[i][j - 1];
+                tmp %= mod;
+            }
+            if (j + 1 < m) {
+                tmp *= colRight[i][j + 1];
+                tmp %= mod;
+            }
+            ans[i][j] = tmp;
+        }
+    }
+    return ans;
+};

From b359e53909434b39df431f83e8da2adf3b16d303 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Oct 2023 01:52:51 -0500
Subject: [PATCH 2814/3374] Create
 2588-count-the-number-of-beautiful-subarrays.js

---
 ...count-the-number-of-beautiful-subarrays.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2588-count-the-number-of-beautiful-subarrays.js

diff --git a/2588-count-the-number-of-beautiful-subarrays.js b/2588-count-the-number-of-beautiful-subarrays.js
new file mode 100644
index 00000000..62786c7b
--- /dev/null
+++ b/2588-count-the-number-of-beautiful-subarrays.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const beautifulSubarrays = function (nums) {
+  const map = new Map()
+  map.set(0, 1)
+  let res = 0
+  const n = nums.length
+  for(let i = 0, mask = 0; i < n; i++) {
+    const cur = nums[i]
+    mask ^= cur
+    if(map.has(mask)) {
+      res += map.get(mask)
+    }
+    map.set(mask, (map.get(mask) || 0) + 1)
+  }
+
+  return res
+}

From 3a68a2f65921d16bb66329fd3b7f7a8e27c06a1d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Oct 2023 21:37:43 -0500
Subject: [PATCH 2815/3374] Create 2845-count-of-interesting-subarrays.js

---
 2845-count-of-interesting-subarrays.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2845-count-of-interesting-subarrays.js

diff --git a/2845-count-of-interesting-subarrays.js b/2845-count-of-interesting-subarrays.js
new file mode 100644
index 00000000..6acf17c8
--- /dev/null
+++ b/2845-count-of-interesting-subarrays.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} modulo
+ * @param {number} k
+ * @return {number}
+ */
+const countInterestingSubarrays = function (nums, modulo, k) {
+  const n = nums.length
+  const map = new Map()
+  let res = 0
+  map.set(0, 1)
+  for (let i = 0, cnt = 0; i < n; i++) {
+    const cur = nums[i]
+    if (cur % modulo === k) {
+      cnt++
+    }
+    const key = cnt % modulo
+    if(key >= k) res += map.get(key - k) || 0
+    else res += map.get(modulo - (k - key)) || 0
+
+    map.set(key, (map.get(key) || 0) + 1)
+  }
+
+  return res
+}

From 9e7dca4b46596692450e3dc01253e136a895c403 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 16 Oct 2023 21:43:10 -0500
Subject: [PATCH 2816/3374] Update 2845-count-of-interesting-subarrays.js

---
 2845-count-of-interesting-subarrays.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/2845-count-of-interesting-subarrays.js b/2845-count-of-interesting-subarrays.js
index 6acf17c8..e1cac0b4 100644
--- a/2845-count-of-interesting-subarrays.js
+++ b/2845-count-of-interesting-subarrays.js
@@ -15,8 +15,11 @@ const countInterestingSubarrays = function (nums, modulo, k) {
       cnt++
     }
     const key = cnt % modulo
+    /*
     if(key >= k) res += map.get(key - k) || 0
     else res += map.get(modulo - (k - key)) || 0
+    */
+    res += map.get((modulo + key - k) % modulo) || 0
 
     map.set(key, (map.get(key) || 0) + 1)
   }

From 9cf4604195c638d0eada49ce82098ac525952c0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Oct 2023 00:53:56 -0500
Subject: [PATCH 2817/3374] Update
 2875-minimum-size-subarray-in-infinite-array.js

---
 ...minimum-size-subarray-in-infinite-array.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2875-minimum-size-subarray-in-infinite-array.js b/2875-minimum-size-subarray-in-infinite-array.js
index 94c6b1b3..9746278e 100644
--- a/2875-minimum-size-subarray-in-infinite-array.js
+++ b/2875-minimum-size-subarray-in-infinite-array.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const minSizeSubarray = function (nums, target) {
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  const remain = target % sum
+  if(remain === 0) return target / sum * nums.length
+  const arr = [...nums, ...nums]
+  const map = new Map()
+  const n = arr.length
+  let r = Infinity
+  for(let i = 0, cur = 0; i < n; i++) {
+    const e = arr[i]
+    cur += e
+    // const tmp = cur % target
+    if(map.has(cur - remain)) r = Math.min(r, i - map.get(cur-remain))
+    map.set(cur, i)
+  }
+  if(r === Infinity) return -1
+  return r + Math.floor(target / sum) * nums.length
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} target

From dfd3206b6194bf008ed0559925d32a29034150e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 19 Oct 2023 20:30:27 +0800
Subject: [PATCH 2818/3374] Update 322-coin-change.js

---
 322-coin-change.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/322-coin-change.js b/322-coin-change.js
index 0c795775..4e16731e 100644
--- a/322-coin-change.js
+++ b/322-coin-change.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} coins
+ * @param {number} amount
+ * @return {number}
+ */
+const coinChange = function(coins, amount) {
+  const n = coins.length
+  const dp = Array(amount + 1).fill(Infinity)
+  dp[0] = 0
+  for(const e of coins) dp[e] = 1
+  for(let i = 1; i <= amount; i++) {
+    for(const e of coins) {
+      if(i > e) dp[i] = Math.min(dp[i], dp[i - e] + 1)
+    }
+  }
+  // console.log(dp)
+  return dp[amount] !== Infinity ? dp[amount] : -1
+};
+
+// another
+
 /**
  * @param {number[]} coins
  * @param {number} amount

From 595339634014cc6db321993b47623092d508003d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Oct 2023 02:38:15 -0500
Subject: [PATCH 2819/3374] Update 518-coin-change-2.js

---
 518-coin-change-2.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/518-coin-change-2.js b/518-coin-change-2.js
index 54db7941..92577234 100644
--- a/518-coin-change-2.js
+++ b/518-coin-change-2.js
@@ -1,3 +1,29 @@
+/**
+ * @param {number} amount
+ * @param {number[]} coins
+ * @return {number}
+ */
+const change = function(amount, coins) {
+  const n = coins.length
+  const dp = Array.from({length: n + 1}, () => Array(amount + 1).fill(0))
+  for(let i = 0; i <= n; i++) {
+      dp[i][0] = 1
+  }
+
+  for(let j = 1; j <= amount; j++) {
+      for(let i = 1; i <= n; i++) {
+          const e = coins[i - 1]
+          dp[i][j] = dp[i - 1][j] + (j >= e ? dp[i][j - e]: 0)
+      }
+  }
+  // console.log(dp)
+  return dp[n][amount]
+};
+
+// another
+
+
+
 /**
  * @param {number} amount
  * @param {number[]} coins

From 04f3bedeba73d2a0fa98eace74b6929293d0e716 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Oct 2023 21:56:07 +0800
Subject: [PATCH 2820/3374] Update 494-target-sum.js

---
 494-target-sum.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/494-target-sum.js b/494-target-sum.js
index 86e36c48..2a414a41 100755
--- a/494-target-sum.js
+++ b/494-target-sum.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const findTargetSumWays = function(nums, target) {
+  const n = nums.length
+  let res = 0
+  for(let i = 0, limit = Math.pow(2, n); i < limit; i++) {
+    if(helper(i)) res++
+  }
+  
+  return res
+  
+  function helper(mask) {
+    let sum = 0
+    for(let i = 0; i < nums.length; i++) {
+      if(mask & (1 << i)) {
+        sum += nums[i]
+      } else sum -= nums[i]
+    }
+    
+    return sum === target
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} target

From b8c49670e6b80f9bf155465716f10df72ba37237 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Oct 2023 19:05:18 +0800
Subject: [PATCH 2821/3374] Create 2908-minimum-sum-of-mountain-triplets-i.js

---
 2908-minimum-sum-of-mountain-triplets-i.js | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2908-minimum-sum-of-mountain-triplets-i.js

diff --git a/2908-minimum-sum-of-mountain-triplets-i.js b/2908-minimum-sum-of-mountain-triplets-i.js
new file mode 100644
index 00000000..d5fc9135
--- /dev/null
+++ b/2908-minimum-sum-of-mountain-triplets-i.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumSum = function(nums) {
+  let pre = [],pmin = [], suf = [], smin = []
+  let i = 0
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    while(pre.length && cur <= nums[pre.at(-1)]) {
+      pre.pop()
+    }
+    if(pre.length) pmin[i] = nums[pre[0]]
+    pre.push(i)
+  }
+  for(let i = n - 1; i >= 0; i--) {
+    const cur = nums[i]
+    while(suf.length && cur <= nums[suf.at(-1)]) {
+      suf.pop()
+    }
+    if(suf.length) smin[i] = nums[suf[0]]
+    suf.push(i)
+  }
+  let res = Infinity
+  
+  for(let i = 1; i < n - 1;i++) {
+    if(pmin[i] != null && smin[i] != null) {
+      res = Math.min(res, nums[i] + pmin[i] + smin[i])
+    }
+  }
+  
+  return res === Infinity ? -1 : res
+};

From 2ff445f588c8fe3ea1f9d626563186130d4c84e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Oct 2023 19:05:56 +0800
Subject: [PATCH 2822/3374] Create 2909-minimum-sum-of-mountain-triplets-ii.js

---
 2909-minimum-sum-of-mountain-triplets-ii.js | 34 +++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2909-minimum-sum-of-mountain-triplets-ii.js

diff --git a/2909-minimum-sum-of-mountain-triplets-ii.js b/2909-minimum-sum-of-mountain-triplets-ii.js
new file mode 100644
index 00000000..d5fc9135
--- /dev/null
+++ b/2909-minimum-sum-of-mountain-triplets-ii.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumSum = function(nums) {
+  let pre = [],pmin = [], suf = [], smin = []
+  let i = 0
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    const cur = nums[i]
+    while(pre.length && cur <= nums[pre.at(-1)]) {
+      pre.pop()
+    }
+    if(pre.length) pmin[i] = nums[pre[0]]
+    pre.push(i)
+  }
+  for(let i = n - 1; i >= 0; i--) {
+    const cur = nums[i]
+    while(suf.length && cur <= nums[suf.at(-1)]) {
+      suf.pop()
+    }
+    if(suf.length) smin[i] = nums[suf[0]]
+    suf.push(i)
+  }
+  let res = Infinity
+  
+  for(let i = 1; i < n - 1;i++) {
+    if(pmin[i] != null && smin[i] != null) {
+      res = Math.min(res, nums[i] + pmin[i] + smin[i])
+    }
+  }
+  
+  return res === Infinity ? -1 : res
+};

From 54e9cda5c51ae85f49e172d174b7e875de40d098 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Oct 2023 19:06:32 +0800
Subject: [PATCH 2823/3374] Create
 2910-minimum-number-of-groups-to-create-a-valid-assignment.js

---
 ...-of-groups-to-create-a-valid-assignment.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 2910-minimum-number-of-groups-to-create-a-valid-assignment.js

diff --git a/2910-minimum-number-of-groups-to-create-a-valid-assignment.js b/2910-minimum-number-of-groups-to-create-a-valid-assignment.js
new file mode 100644
index 00000000..37496cc8
--- /dev/null
+++ b/2910-minimum-number-of-groups-to-create-a-valid-assignment.js
@@ -0,0 +1,61 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minGroupsForValidAssignment = function(nums) {
+        let mp = new Map();
+        for (let i = 0; i < nums.length; i++) {
+            if (mp.has(nums[i])) {
+                mp.set(nums[i], mp.get(nums[i]) + 1);
+            } else {
+                mp.set(nums[i], 1);
+            }
+        }
+        
+        let maxi = 0;
+        let n = nums.length;
+        
+        let u = new Map();
+        for (let i of nums) {
+            if (u.has(i)) {
+                u.set(i, u.get(i) + 1);
+            } else {
+                u.set(i, 1);
+            }
+            maxi = Math.max(maxi, u.get(i));
+        }
+        
+        for (let i = maxi; i >= 1; i--) {
+            if (posi(i, u)) {
+                let res = 0;
+                for (let [curr, c] of u) {
+                    let left = c % i;
+                    res += Math.floor(c / i);
+                    if (left > 0) {
+                        res++;
+                    }
+                }
+                return res;
+            }
+        }
+        return -1;
+    }
+    
+    function posi(x, u) {
+        for (let [curr, cnt] of u) {
+            let left = cnt % x;
+            let tt = Math.floor(cnt / x);
+            
+            if (left < x - 1) {
+                let req = (x - 1) - left;
+                if (tt >= req) {
+                    left = x - 1;
+                }
+            }
+            
+            if (left > 0 && left < x - 1) {
+                return false;
+            }
+        }
+        return true;
+    }

From 36d332dd52667b4d30b8af6abbfa6d89e3db5705 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Oct 2023 19:07:10 +0800
Subject: [PATCH 2824/3374] Create
 2911-minimum-changes-to-make-k-semi-palindromes.js

---
 ...imum-changes-to-make-k-semi-palindromes.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 2911-minimum-changes-to-make-k-semi-palindromes.js

diff --git a/2911-minimum-changes-to-make-k-semi-palindromes.js b/2911-minimum-changes-to-make-k-semi-palindromes.js
new file mode 100644
index 00000000..7e758952
--- /dev/null
+++ b/2911-minimum-changes-to-make-k-semi-palindromes.js
@@ -0,0 +1,62 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var minimumChanges = function(s, k) {
+  const ins =  new Solution()
+  return ins.minimumChanges(s,k)
+};
+
+class Solution {
+    constructor() {
+        this.fac = new Array(210).fill(0).map(() => []); // A vector of vectors to store factors of string lengths.
+    }
+
+    num(st) {
+        const n = st.length;
+        let ans = 1e9;
+        for (const it of this.fac[st.length]) {
+            const nu = Math.floor(n / it);
+            let cur = 0;
+            for (let i = 0; i < Math.floor(nu / 2); i++) {
+                const i2 = nu - i - 1;
+                for (let j = 0; j < it; j++) {
+                    if (st[i * it + j] !== st[i2 * it + j]) {
+                        cur++;
+                    }
+                }
+            }
+            ans = Math.min(ans, cur);
+        }
+        return ans;
+    }
+
+    minimumChanges(st, k) {
+        const n = st.length;
+
+        for (let i = 2; i <= n; i++) {
+            this.fac[i] = [];
+            for (let j = 1; j < i; j++) {
+                if (i % j === 0) {
+                    this.fac[i].push(j);
+                }
+            }
+        }
+
+        const dp = new Array(n + 1).fill(0).map(() => new Array(k + 1).fill(1e9));
+        dp[0][0] = 0;
+
+        for (let i = 0; i < n; i++) {
+            for (let j = 0; j <= i; j++) {
+                const cur = st.slice(j, i + 1);
+                const add = this.num(cur);
+                for (let l = 0; l < k; l++) {
+                    dp[i + 1][l + 1] = Math.min(dp[i + 1][l + 1], dp[j][l] + add);
+                }
+            }
+        }
+
+        return dp[n][k];
+    }
+}

From 7561738d871bee3a90740b91f72118383008577a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Oct 2023 19:36:37 +0800
Subject: [PATCH 2825/3374] Update 416-partition-equal-subset-sum.js

---
 416-partition-equal-subset-sum.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/416-partition-equal-subset-sum.js b/416-partition-equal-subset-sum.js
index c118c8e6..7c79d633 100644
--- a/416-partition-equal-subset-sum.js
+++ b/416-partition-equal-subset-sum.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canPartition = function(nums) {
+  const n = nums.length
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  if(sum % 2 === 1) return false
+  const target = sum / 2
+  const dp = Array.from({length: n + 1}, () => Array(target + 101).fill(0))
+  dp[0][0] = 1
+  
+  for(let i = 1; i <= n ; i++) {
+    const e = nums[i - 1]
+    for(let s = 0; s < target + 101; s++) {
+      dp[i][s] = dp[i - 1][s]
+      if(s >= e) dp[i][s] += dp[i - 1][s - e]
+    }
+  }
+  return dp[n][target] > 0
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {boolean}

From 86a1cdccbeb63d7f1869e156a13139635c52d9be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Oct 2023 01:54:31 -0500
Subject: [PATCH 2826/3374] Update 2518-number-of-great-partitions.js

---
 2518-number-of-great-partitions.js | 31 ++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2518-number-of-great-partitions.js b/2518-number-of-great-partitions.js
index 7f2c0e66..a416e323 100644
--- a/2518-number-of-great-partitions.js
+++ b/2518-number-of-great-partitions.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+function countPartitions(nums, k) {
+  const mod = 1e9 + 7
+  let total = 0
+  let res = 1
+  const dp = new Array(k).fill(0)
+  dp[0] = 1
+
+  for (let a of nums) {
+    for (let i = k - 1 - a; i >= 0; i--) {
+      dp[i + a] = (dp[i + a] + dp[i]) % mod
+    }
+    res = (res * 2) % mod
+    total += a
+  }
+
+  for (let i = 0; i < k; i++) {
+    res -= total - i < k ? dp[i] : dp[i] * 2
+  }
+
+  return ((res % mod) + mod) % mod
+}
+
+// another
+
+
+
 const ll = BigInt,
   mod = 1e9 + 7,
   bmod = ll(mod)

From 3f1290a94b50a5fb6593a3ca79e0b5aa79ae68d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Oct 2023 02:29:33 -0500
Subject: [PATCH 2827/3374] Update 2518-number-of-great-partitions.js

---
 2518-number-of-great-partitions.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2518-number-of-great-partitions.js b/2518-number-of-great-partitions.js
index a416e323..6823b1af 100644
--- a/2518-number-of-great-partitions.js
+++ b/2518-number-of-great-partitions.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+function countPartitions(nums, k) {
+  const bi = BigInt
+  const mod = bi(1e9 + 7)
+  const n = nums.length, total = bi(2 ** n)
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  if(sum < 2 * k) return 0
+  const dp = Array.from({ length: n + 1}, () => Array(k).fill(0n))
+  for(let i = 0; i <= n; i++) dp[i][0] = 1n
+
+  for(let i = 1; i <= n; i++) {
+    const e = nums[i - 1]
+    for(let j = 1; j < k; j++) {
+        dp[i][j] = dp[i - 1][j]
+        if(j >= e) dp[i][j] = bi(dp[i][j] + dp[i - 1][j - e]) % mod
+    }
+  }
+  const tmp = dp[n].reduce((ac, e) => ac + bi(e), 0n)
+  return (total - tmp * 2n) % mod
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 0eb33099934d224a674e524e1f5f0c2154aaff74 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Oct 2023 02:28:11 -0500
Subject: [PATCH 2828/3374] Update 879-profitable-schemes.js

---
 879-profitable-schemes.js | 53 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/879-profitable-schemes.js b/879-profitable-schemes.js
index ccccac9a..9a1a366c 100644
--- a/879-profitable-schemes.js
+++ b/879-profitable-schemes.js
@@ -1,3 +1,56 @@
+/**
+ * @param {number} n
+ * @param {number} minProfit
+ * @param {number[]} group
+ * @param {number[]} profit
+ * @return {number}
+ */
+const profitableSchemes = function (n, minProfit, group, profit) {
+  const m = group.length
+  const dp = buildMatrix([m + 1, n + 1, minProfit + 1], 0)
+  const mod = 1e9 + 7
+  group.unshift(0)
+  profit.unshift(0)
+  dp[0][0][0] = 1
+  console.log(group, profit)
+  for (let i = 0; i < m; i++) {
+    const g = group[i + 1],
+      p = profit[i + 1]
+    for (let j = 0; j <= n; j++) {
+      for (let k = 0; k <= minProfit; k++) {
+        dp[i + 1][j][k] += dp[i][j][k]
+        dp[i + 1][j][k] = dp[i + 1][j][k] % mod
+        if (j + g <= n) {
+          const pp = Math.min(minProfit, k + p)
+          dp[i + 1][j + g][pp] += dp[i][j][k]
+          dp[i + 1][j + g][pp] = dp[i + 1][j + g][pp] % mod
+        }
+      }
+    }
+  }
+  let res = 0
+  for (let j = 0; j <= n; j++) {
+    res = (res + dp[m][j][minProfit]) % mod
+  }
+
+  return res
+}
+
+function buildMatrix(dimensions, defaultVal) {
+  if (dimensions.length === 1) return Array(dimensions[0]).fill(defaultVal)
+  const res = []
+  const [len, ...rest] = dimensions
+
+  for (let i = 0; i < len; i++) {
+    res.push(buildMatrix(rest, defaultVal))
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} G
  * @param {number} P

From 6f3c4cd28b5b3c7f414f13a6d9677ad9ca595e0a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Oct 2023 01:18:08 -0500
Subject: [PATCH 2829/3374] Update
 1449-form-largest-integer-with-digits-that-add-up-to-target.js

---
 ...teger-with-digits-that-add-up-to-target.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1449-form-largest-integer-with-digits-that-add-up-to-target.js b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
index 8ceae82d..04f0c568 100644
--- a/1449-form-largest-integer-with-digits-that-add-up-to-target.js
+++ b/1449-form-largest-integer-with-digits-that-add-up-to-target.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[]} cost
+ * @param {number} target
+ * @return {string}
+ */
+const largestNumber = function (cost, target) {
+  const dp = Array(target + 1).fill('#')
+  cost.unshift(0)
+  dp[0] = ''
+  for (let sum = 0; sum <= target; sum++) {
+    for (let i = 1; i <= 9; i++) {
+      const e = cost[i]
+      if (sum < e) continue
+      if (dp[sum - e] === '#') continue
+      const str = dp[sum - e] + `${i}`
+      // console.log(str)
+      if (
+        str.length > dp[sum].length ||
+        (str.length === dp[sum].length && str > dp[sum])
+      ) {
+        dp[sum] = str
+      }
+    }
+  }
+// console.log(dp)
+  if (dp[target] === '#') return '0'
+  return dp[target]
+}
+
+// another
+
 /**
  * @param {number[]} cost
  * @param {number} target

From a5d37aa8410db40b3ecb726f859d8b851d3e1742 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Oct 2023 21:38:10 -0500
Subject: [PATCH 2830/3374] Update 2291-maximum-profit-from-trading-stocks.js

---
 2291-maximum-profit-from-trading-stocks.js | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/2291-maximum-profit-from-trading-stocks.js b/2291-maximum-profit-from-trading-stocks.js
index 4a69461f..27aba95e 100644
--- a/2291-maximum-profit-from-trading-stocks.js
+++ b/2291-maximum-profit-from-trading-stocks.js
@@ -15,3 +15,29 @@ const maximumProfit = function(present, future, budget) {
   }
   return dp[budget];
 };
+
+// another
+
+/**
+ * @param {number[]} present
+ * @param {number[]} future
+ * @param {number} budget
+ * @return {number}
+ */
+const maximumProfit = function(present, future, budget) {
+    const n = present.length
+    const dp = Array.from({ length: n + 1 }, () => Array(budget + 1).fill(0))
+
+    for(let b = 0; b <= budget; b++) {
+        for(let i = 1; i <= n; i++) {
+            const cost = present[i - 1]
+            const diff = future[i - 1] - cost
+            dp[i][b] = dp[i - 1][b]
+            if(b >= cost) {
+                dp[i][b] = Math.max(dp[i][b], dp[i - 1][b - cost] + diff)
+            }
+        }
+    }
+
+    return dp[n][budget]
+  };

From 9990ab56a1461feca5fada6a4015c337d9aa0b9b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Oct 2023 22:54:46 +0800
Subject: [PATCH 2831/3374] Create
 2902-count-of-sub-multisets-with-bounded-sum.js

---
 ...count-of-sub-multisets-with-bounded-sum.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2902-count-of-sub-multisets-with-bounded-sum.js

diff --git a/2902-count-of-sub-multisets-with-bounded-sum.js b/2902-count-of-sub-multisets-with-bounded-sum.js
new file mode 100644
index 00000000..7fbd2d1b
--- /dev/null
+++ b/2902-count-of-sub-multisets-with-bounded-sum.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var countSubMultisets = function (nums, l, r) {
+  const a = nums
+  const counter = (a_or_s) => {
+    let m = new Map()
+    for (const x of a_or_s) m.set(x, m.get(x) + 1 || 1)
+    return m
+  }
+
+  const mod = 1e9 + 7
+  let f = Array(r + 1).fill(0),
+    m = counter(a),
+    res = 0
+  f[0] = 1
+  for (const [x, occ] of m) {
+    if (x == 0) {
+      f = f.map((e) => e * (occ + 1))
+    } else {
+      for (let i = x; i <= r; i++) {
+        f[i] += f[i - x]
+        f[i] %= mod
+      }
+      for (let i = r; i >= (occ + 1) * x; i--) {
+        f[i] -= f[i - (occ + 1) * x]
+        f[i] %= mod
+      }
+    }
+  }
+  for (let i = l; i <= r; i++) {
+    res += f[i]
+    res %= mod
+  }
+  return (res + mod) % mod
+}

From 36c0289d5838f28f8ec88a5202a8337e12de0ae3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Oct 2023 02:40:52 -0500
Subject: [PATCH 2832/3374] Create 2826-sorting-three-groups.js

---
 2826-sorting-three-groups.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2826-sorting-three-groups.js

diff --git a/2826-sorting-three-groups.js b/2826-sorting-three-groups.js
new file mode 100644
index 00000000..bab1b9b1
--- /dev/null
+++ b/2826-sorting-three-groups.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumOperations = function(nums) {
+  const n = nums.length, { min } = Math
+  const dp = Array.from({ length: n + 1 }, () => Array(3 + 1).fill(0))
+
+  for(let i = 1; i <= n; i++) {
+    const e = nums[i - 1]
+    dp[i][1] = dp[i - 1][1] + (e === 1 ? 0 : 1)
+    dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + (e === 2 ? 0 : 1)
+    dp[i][3] = min(dp[i - 1][1], dp[i - 1][2], dp[i - 1][3]) + (e === 3 ? 0 : 1)
+  }
+  return min(dp[n][1], dp[n][2], dp[n][3])
+};

From 90e7b13acb64b6e51d20ad65faa41d9cb8e19e50 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Oct 2023 00:04:33 -0500
Subject: [PATCH 2833/3374] Create 2851-string-transformation.js

---
 2851-string-transformation.js | 203 ++++++++++++++++++++++++++++++++++
 1 file changed, 203 insertions(+)
 create mode 100644 2851-string-transformation.js

diff --git a/2851-string-transformation.js b/2851-string-transformation.js
new file mode 100644
index 00000000..7becb586
--- /dev/null
+++ b/2851-string-transformation.js
@@ -0,0 +1,203 @@
+class Modulo {
+  /**
+   * @param {number} modulo
+   */
+  constructor(modulo) {
+    /** @type {number} @readonly */
+    this.modulo = modulo;
+
+    /** @private @type {undefined | number} */
+    this._phi = undefined;
+  }
+
+  /**
+   * @returns {number}
+   */
+  getPhi() {
+    if (this._phi !== undefined) return this._phi;
+
+    let result = this.modulo;
+    let temp = this.modulo;
+    for (let i = 2; i <= Math.sqrt(temp); i++) {
+      if (temp % i === 0) {
+        result /= i;
+        result *= i - 1;
+      }
+      while (temp % i === 0) temp /= i;
+    }
+    if (temp > 1) {
+      result /= temp;
+      result *= temp - 1;
+    }
+
+    this._phi = result;
+    return result;
+  }
+
+  /**
+   * @param {number} a
+   * @returns {number}
+   */
+  getInverse(a) {
+    return this.pow(a, this.getPhi() - 1);
+  }
+
+  /**
+   * @param  {...number} numbers
+   */
+  add(...numbers) {
+    let result = 0;
+    for (let number of numbers) {
+      result = (result + (number % this.modulo)) % this.modulo;
+    }
+
+    if (result < 0) result += this.modulo;
+    return result;
+  }
+
+  /**
+   * @private
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  _quickMul(a, b) {
+    a = ((a % this.modulo) + this.modulo) % this.modulo;
+    b = ((b % this.modulo) + this.modulo) % this.modulo;
+    if (a === 0 || b === 0) return 0;
+
+    let result = 0;
+    while (b) {
+      while (b % 2 === 0) {
+        a = (a * 2) % this.modulo;
+        b /= 2;
+      }
+
+      if (b % 2 !== 0) {
+        result = (result + a) % this.modulo;
+        b--;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * @param  {...number} numbers
+   */
+  mul(...numbers) {
+    let result = 1;
+    for (let number of numbers) {
+      if (number > 0 && number < 1)
+        number = this.getInverse(Math.round(1 / number));
+      result = this._quickMul(result, number);
+      if (result === 0) return 0;
+    }
+
+    if (result < 0) result += this.modulo;
+    return result;
+  }
+
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  div(a, b) {
+    return this._quickMul(a, this.getInverse(b));
+  }
+
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  pow(a, b) {
+    a = ((a % this.modulo) + this.modulo) % this.modulo;
+    if (a === 0) return 0;
+
+    let result = 1;
+    while (b) {
+      while (b % 2 === 0) {
+        a = this._quickMul(a, a);
+        b /= 2;
+      }
+
+      if (b % 2 !== 0) {
+        result = this._quickMul(result, a);
+        b--;
+      }
+    }
+
+    return result;
+  }
+}
+
+const mod = new Modulo(1000000007);
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfWays = function (s, t, k) {
+  s += s;
+  const BASE = 26;
+
+  const basePows = [1];
+  function getBasePow(n) {
+    while (n >= basePows.length) {
+      basePows.push(mod.mul(basePows[basePows.length - 1], BASE));
+    }
+    return basePows[n];
+  }
+
+  /** @param {string} s */
+  function calcHashWord(s, pre = 0) {
+    let result = pre;
+    for (let i = 0; i < s.length; i++) {
+      result = mod.add(
+        mod.mul(result, BASE),
+        mod.mul(1 + s.charCodeAt(i), s.charCodeAt(i))
+      );
+    }
+    return result;
+  }
+
+  const prefixHash = [];
+  prefixHash[-1] = 0;
+
+  for (let i = 0; i < s.length; i++) {
+    prefixHash.push(calcHashWord(s[i], prefixHash[prefixHash.length - 1]));
+  }
+
+  function getHash(l, r) {
+    return mod.add(
+      prefixHash[r],
+      -mod.mul(prefixHash[l - 1], getBasePow(r - l + 1))
+    );
+  }
+
+  const hashedT = calcHashWord(t, 0);
+  let cntOcc = 0;
+  let flagFirstMatch = 0;
+  if (getHash(0, t.length - 1) === hashedT) {
+    cntOcc++;
+    flagFirstMatch = 1;
+  }
+
+  for (let i = 1; i < t.length; i++) {
+    if (getHash(i, i + t.length - 1) === hashedT) cntOcc++;
+  }
+
+  if (k == 1) return cntOcc - flagFirstMatch;
+  let res = mod.mul(cntOcc, mod.pow(t.length - 1, k));
+  res = mod.add(
+    res,
+    mod.mul(flagFirstMatch * t.length - cntOcc, k % 2 ? -1 : 1)
+  );
+  res = mod.div(res, t.length);
+
+  return res;
+};

From 9f09ae2a61e965d89f2b5c1880fd4830e8bb857d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 1 Nov 2023 02:54:30 -0500
Subject: [PATCH 2834/3374] Update
 2896-apply-operations-to-make-two-strings-equal.js

---
 ...ly-operations-to-make-two-strings-equal.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/2896-apply-operations-to-make-two-strings-equal.js b/2896-apply-operations-to-make-two-strings-equal.js
index 71acb213..2f43e165 100644
--- a/2896-apply-operations-to-make-two-strings-equal.js
+++ b/2896-apply-operations-to-make-two-strings-equal.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @param {number} x
+ * @return {number}
+ */
+const minOperations = function (s1, s2, x) {
+   const n = s1.length, arr = []
+   for(let i = 0; i < n; i++) {
+     if(s1[i] !== s2[i]) arr.push(i)
+   }
+   const len = arr.length
+   if(len % 2) return -1
+   const cache = new Map()
+   return dfs(len - 1)
+
+   function dfs(i) {
+     if(i < 0) return 0
+     if(i === 0) return x / 2
+     if(cache.has(i)) return cache.get(i)
+     const res = Math.min(dfs(i - 2) + arr[i] - arr[i - 1], dfs(i - 1) + x/2)
+     cache.set(i, res)
+     return res
+   }
+}
+
+// another
+
+
 /**
  * @param {string} s1
  * @param {string} s2

From ac0c775e546796e90f071ccb1603e13a58b78d69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Nov 2023 01:06:11 -0500
Subject: [PATCH 2835/3374] Create
 2900-longest-unequal-adjacent-groups-subsequence-i.js

---
 ...ngest-unequal-adjacent-groups-subsequence-i.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2900-longest-unequal-adjacent-groups-subsequence-i.js

diff --git a/2900-longest-unequal-adjacent-groups-subsequence-i.js b/2900-longest-unequal-adjacent-groups-subsequence-i.js
new file mode 100644
index 00000000..ba50d1fb
--- /dev/null
+++ b/2900-longest-unequal-adjacent-groups-subsequence-i.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number} n
+ * @param {string[]} words
+ * @param {number[]} groups
+ * @return {string[]}
+ */
+const getWordsInLongestSubsequence = function (n, words, groups) {
+    let res = []
+    res.push(words[0])
+
+    for(let i = 1; i < n; i++) {
+        if(groups[i] !== groups[i - 1]) res.push(words[i])
+    }
+    return res
+}

From cb5f316056574a50b3f469c2aaa81e28667e86e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Nov 2023 13:06:47 +0800
Subject: [PATCH 2836/3374] Create
 2901-longest-unequal-adjacent-groups-subsequence-ii.js

---
 ...-unequal-adjacent-groups-subsequence-ii.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 2901-longest-unequal-adjacent-groups-subsequence-ii.js

diff --git a/2901-longest-unequal-adjacent-groups-subsequence-ii.js b/2901-longest-unequal-adjacent-groups-subsequence-ii.js
new file mode 100644
index 00000000..00f99e6d
--- /dev/null
+++ b/2901-longest-unequal-adjacent-groups-subsequence-ii.js
@@ -0,0 +1,48 @@
+/**
+ * @param {number} n
+ * @param {string[]} words
+ * @param {number[]} groups
+ * @return {string[]}
+ */
+const getWordsInLongestSubsequence = function(n, words, groups) {
+  let res = []
+  let len = new Array(1001).fill(1)
+  let next = new Array(1001).fill(-1)
+  let startNodeWithMaxLen = -1
+  let maxLen = 0
+  for (let i = n - 1; i >= 0; i--) {
+    for (let t = i + 1; t < n; t++) {
+      if (len[i] < len[t] + 1 && check(words, groups, i, t)) {
+        len[i] = len[t] + 1
+        next[i] = t
+      }
+    }
+    if (maxLen < len[i]) {
+      maxLen = len[i]
+      startNodeWithMaxLen = i
+    }
+  }
+  let p = startNodeWithMaxLen
+  while (p !== -1) {
+    res.push(words[p])
+    p = next[p]
+  }
+  return res
+
+  function check(words, groups, i, lastInd) {
+    if (
+      groups[i] === groups[lastInd] ||
+      words[i].length !== words[lastInd].length
+    ) {
+      return false
+    }
+    let diff = 0
+    for (let j = 0; j < words[i].length; j++) {
+      if (words[i][j] !== words[lastInd][j]) {
+        diff++
+      }
+    }
+    return diff === 1
+  }
+
+};

From fce45515e93d94bc482083e306938eccff14bc96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 Nov 2023 22:38:53 +0800
Subject: [PATCH 2837/3374] Create
 2919-minimum-increment-operations-to-make-array-beautiful.js

---
 ...ment-operations-to-make-array-beautiful.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2919-minimum-increment-operations-to-make-array-beautiful.js

diff --git a/2919-minimum-increment-operations-to-make-array-beautiful.js b/2919-minimum-increment-operations-to-make-array-beautiful.js
new file mode 100644
index 00000000..b0d83880
--- /dev/null
+++ b/2919-minimum-increment-operations-to-make-array-beautiful.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minIncrementOperations = function(nums, k) {
+    const dp = new Array(nums.length).fill(-1)
+    
+    const traverse = (index) => {
+        if (index >= nums.length - 2) return 0
+
+        if (dp[index] !== -1) return dp[index]
+        
+        let res = Infinity;
+        for (let i = index; i <= index + 2; i++) {
+            const val = Math.max(k - nums[i], 0)
+            const next = traverse(i + 1)
+            res = Math.min(val + next, res)
+        }
+        
+        dp[index] = res
+        return res
+    }
+
+    
+    return traverse(0)   
+};

From 95ed042e95950db8205489dc90347361317c2eae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Nov 2023 14:48:47 +0800
Subject: [PATCH 2838/3374] Create 2741-special-permutations.js

---
 2741-special-permutations.js | 54 ++++++++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 2741-special-permutations.js

diff --git a/2741-special-permutations.js b/2741-special-permutations.js
new file mode 100644
index 00000000..5264811d
--- /dev/null
+++ b/2741-special-permutations.js
@@ -0,0 +1,54 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const specialPerm = function (nums) {
+  const s = new Solution()
+  return s.specialPerm(nums)
+}
+
+class Solution {
+  constructor() {
+    this.dp = []
+  }
+  solve(nums, previdx, chosenIndices) {
+    if (chosenIndices.length === nums.length) {
+      return 1
+    }
+
+    let mask = 0
+    for (let index of chosenIndices) {
+      mask |= 1 << index
+    }
+
+    if (this.dp[previdx + 1][mask] !== -1) {
+      return this.dp[previdx + 1][mask]
+    }
+
+    let tot = 0
+    for (let j = 0; j < nums.length; j++) {
+      if (chosenIndices.includes(j)) {
+        continue
+      }
+      if (
+        previdx === -1 ||
+        nums[previdx] % nums[j] === 0 ||
+        nums[j] % nums[previdx] === 0
+      ) {
+        chosenIndices.push(j)
+        tot += this.solve(nums, j, chosenIndices)
+        tot %= 1000000007
+        chosenIndices.pop()
+      }
+    }
+    return (this.dp[previdx + 1][mask] = tot)
+  }
+
+  specialPerm(nums) {
+    this.dp = new Array(20)
+      .fill(-1)
+      .map(() => new Array((1 << nums.length) + 5).fill(-1))
+    let chosenIndices = []
+    return this.solve(nums, -1, chosenIndices)
+  }
+}

From 25b83c65a64d6197aa36d97832444af2188b55c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Nov 2023 22:05:29 +0800
Subject: [PATCH 2839/3374] Create
 2842-count-k-subsequences-of-a-string-with-maximum-beauty.js

---
 ...quences-of-a-string-with-maximum-beauty.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2842-count-k-subsequences-of-a-string-with-maximum-beauty.js

diff --git a/2842-count-k-subsequences-of-a-string-with-maximum-beauty.js b/2842-count-k-subsequences-of-a-string-with-maximum-beauty.js
new file mode 100644
index 00000000..06ec3d6f
--- /dev/null
+++ b/2842-count-k-subsequences-of-a-string-with-maximum-beauty.js
@@ -0,0 +1,51 @@
+////////////////////////////// combination Template //////////////////////////////////
+const ll = BigInt,
+  mod = ll(1e9 + 7)
+let N
+
+let fact, ifact, inv
+const comb_init = () => {
+  ;(fact = Array(N)), (ifact = Array(N)), (inv = Array(N))
+  fact[0] = ifact[0] = inv[1] = 1n
+  for (let i = 2; i < N; i++)
+    inv[i] = ((mod - mod / ll(i)) * inv[mod % ll(i)]) % mod
+  for (let i = 1; i < N; i++) {
+    fact[i] = (fact[i - 1] * ll(i)) % mod
+    ifact[i] = (ifact[i - 1] * inv[i]) % mod
+  }
+}
+
+const comb = (n, k) => {
+  if (n < k || k < 0) return 0n
+  return (((fact[n] * ifact[k]) % mod) * ifact[n - k]) % mod
+}
+//////////////////////////////////////////////////////////////////////
+
+const ord = (c) => c.charCodeAt()
+
+const M = 1e9 + 7
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const countKSubsequencesWithMaxBeauty = (s, k) => {
+  N = s.length + 1
+  comb_init()
+  let f = Array(26).fill(0),
+    res = 1,
+    pick = 0
+  for (const c of s) f[ord(c) - 97]++
+  f = f.sort((x, y) => y - x).filter((x) => x > 0)
+  for (let i = 0; i < k; i++) {
+    if (f[i] >= f[k - 1]) {
+      // ways of first k-1 elements
+      res *= f[i]
+      res %= M
+    }
+    if (f[i] == f[k - 1]) pick++ // count last element needed
+  }
+  let lastPick = comb(f.filter((x) => x == f[k - 1]).length, pick) // ways of last element pick up
+  res = (ll(res) * lastPick) % mod
+  return res
+}

From d9d821f7c1b46b0058497d043f3dbc458d14a85e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Nov 2023 21:46:52 +0800
Subject: [PATCH 2840/3374] Create
 2850-minimum-moves-to-spread-stones-over-grid.js

---
 ...inimum-moves-to-spread-stones-over-grid.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2850-minimum-moves-to-spread-stones-over-grid.js

diff --git a/2850-minimum-moves-to-spread-stones-over-grid.js b/2850-minimum-moves-to-spread-stones-over-grid.js
new file mode 100644
index 00000000..8e6a6086
--- /dev/null
+++ b/2850-minimum-moves-to-spread-stones-over-grid.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumMoves = function (grid) {
+  let zeros = []
+  let extras = []
+  let ans = 0
+  for (let r = 0; r < 3; ++r) {
+    for (let c = 0; c < 3; ++c) {
+      if (grid[r][c] > 1) {
+        extras.push([r, c, grid[r][c]])
+      } else if (grid[r][c] == 0) {
+        zeros.push([r, c])
+      }
+    }
+  }
+  function solve(index) {
+    if (index >= zeros.length) {
+      return 0
+    }
+    let min = Number.MAX_SAFE_INTEGER
+    let [r, c] = zeros[index]
+    for (let j = 0; j < extras.length; ++j) {
+      if (extras[j][2] > 1) {
+        extras[j][2] -= 1
+        min = Math.min(
+          min,
+          Math.abs(extras[j][0] - r) +
+            Math.abs(extras[j][1] - c) +
+            solve(index + 1),
+        )
+        extras[j][2] += 1
+      }
+    }
+    return min
+  }
+  return solve(0)
+}

From 1db7b9969120ca74a3ea56d39c6863cc951f914e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Nov 2023 12:54:59 +0800
Subject: [PATCH 2841/3374] Create 2935-maximum-strong-pair-xor-ii.js

---
 2935-maximum-strong-pair-xor-ii.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2935-maximum-strong-pair-xor-ii.js

diff --git a/2935-maximum-strong-pair-xor-ii.js b/2935-maximum-strong-pair-xor-ii.js
new file mode 100644
index 00000000..42ae29a5
--- /dev/null
+++ b/2935-maximum-strong-pair-xor-ii.js
@@ -0,0 +1,26 @@
+const maximumStrongPairXor= (nums) => {
+  const A = nums
+  let res = 0;
+  for (let i = 20; i >= 0; --i) {
+    res <<= 1;
+    let pref = new Map();
+    let pref2 = new Map();
+    for (let a of A) {
+      let p = a >> i;
+      if (!pref.has(p)) {
+        pref.set(p, a);
+        pref2.set(p, a);
+      }
+      pref.set(p, Math.min(pref.get(p), a));
+      pref2.set(p, Math.max(pref2.get(p), a));
+    }
+    for (let [x, val] of pref) {
+      let y = res ^ 1 ^ x;
+      if (x >= y && pref.has(y) && pref.get(x) <= pref2.get(y) * 2) {
+        res |= 1;
+        break;
+      }
+    }
+  }
+  return res;
+}

From a70f84932896f2a9d6b74832665fc0e32ec12e23 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Nov 2023 12:55:54 +0800
Subject: [PATCH 2842/3374] Create
 2934-minimum-operations-to-maximize-last-elements-in-arrays.js

---
 ...ons-to-maximize-last-elements-in-arrays.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2934-minimum-operations-to-maximize-last-elements-in-arrays.js

diff --git a/2934-minimum-operations-to-maximize-last-elements-in-arrays.js b/2934-minimum-operations-to-maximize-last-elements-in-arrays.js
new file mode 100644
index 00000000..6ee08455
--- /dev/null
+++ b/2934-minimum-operations-to-maximize-last-elements-in-arrays.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var minOperations = function (nums1, nums2) {
+  const n = nums1.length
+  let a = nums1[n - 1]
+  let b = nums2[n - 1]
+
+  let tmp0 = 0
+  for (let i = 0; i < n - 1; i++) {
+    const x = nums1[i]
+    const y = nums2[i]
+
+    if (Math.min(x, y) > Math.min(a, b)) return -1
+    if (Math.max(x, y) > Math.max(a, b)) return -1
+
+    if (y <= a && x <= b && (x > a || y > b)) {
+      tmp0++
+    }
+  }
+
+  a = nums2[n - 1]
+  b = nums1[n - 1]
+  let tmp1 = 0
+  for (let i = 0; i < n - 1; i++) {
+    const x = nums1[i]
+    const y = nums2[i]
+
+    if (Math.min(x, y) > Math.min(a, b)) return -1
+    if (Math.max(x, y) > Math.max(a, b)) return -1
+
+    if (y <= a && x <= b && (x > a || y > b)) {
+      tmp1++
+    }
+  }
+
+  return Math.min(tmp0, tmp1 + 1)
+}

From 934c049b4f00b493de11c034e86cf8d769fe02ea Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Nov 2023 12:56:32 +0800
Subject: [PATCH 2843/3374] Create 2933-high-access-employees.js

---
 2933-high-access-employees.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2933-high-access-employees.js

diff --git a/2933-high-access-employees.js b/2933-high-access-employees.js
new file mode 100644
index 00000000..4660b7f4
--- /dev/null
+++ b/2933-high-access-employees.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string[][]} access_times
+ * @return {string[]}
+ */
+var findHighAccessEmployees = function(access_times) {
+    const map = new Map();
+    access_times.sort((a, b) => a[1] - b[1]).forEach((item) => {
+      const key = item[0];
+      const value = parseInt(item[1]);
+      map.set(key, map.get(key) || []);
+      map.get(key).push(value);
+    });
+    const ans = [];
+    map.forEach((value, key) => {
+      for (let i = 2; i < value.length; i++) {
+        if (value[i] - value[i - 2] < 100) {
+          ans.push(key);
+          break;
+        }
+      }
+    });
+    return ans;
+};

From 62282d08db74c6047d8f18504efaed976a3b5723 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Nov 2023 12:57:15 +0800
Subject: [PATCH 2844/3374] Create 2932-maximum-strong-pair-xor-i.js

---
 2932-maximum-strong-pair-xor-i.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2932-maximum-strong-pair-xor-i.js

diff --git a/2932-maximum-strong-pair-xor-i.js b/2932-maximum-strong-pair-xor-i.js
new file mode 100644
index 00000000..41a92ef3
--- /dev/null
+++ b/2932-maximum-strong-pair-xor-i.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumStrongPairXor = function(nums) {
+    const n = nums.length
+    let res = -Infinity
+    for(let i = 0; i < n; i++) {
+      const x = nums[i]
+      for(let j = i; j < n; j++) {
+        const y = nums[j]
+        if(Math.abs(x - y) <= Math.min(x, y) && (x ^ y) > res) {
+          res = x ^ y
+        }
+      }
+    }
+    return res
+};

From 220cc1bce3f3ca79f0235462efb1c7884881822d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 Nov 2023 14:14:00 +0800
Subject: [PATCH 2845/3374] Update 2935-maximum-strong-pair-xor-ii.js

---
 2935-maximum-strong-pair-xor-ii.js | 93 ++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/2935-maximum-strong-pair-xor-ii.js b/2935-maximum-strong-pair-xor-ii.js
index 42ae29a5..6246500b 100644
--- a/2935-maximum-strong-pair-xor-ii.js
+++ b/2935-maximum-strong-pair-xor-ii.js
@@ -1,3 +1,96 @@
+class Node {
+  constructor() {
+    this.links = [null, null]
+    this.frequency = 0
+  }
+
+  containsKey(bit) {
+    return this.links[bit] !== null
+  }
+
+  get(bit) {
+    return this.links[bit]
+  }
+
+  put(bit, node) {
+    this.links[bit] = node
+  }
+}
+
+class Trie {
+  constructor() {
+    this.root = new Node()
+  }
+
+  insert(num) {
+    let node = this.root
+    for (let i = 31; i >= 0; i--) {
+      const bit = (num >> i) & 1
+      if (!node.containsKey(bit)) {
+        node.put(bit, new Node())
+      }
+      node = node.get(bit)
+      node.frequency++
+    }
+  }
+
+  getMax(num) {
+    let node = this.root
+    let res = 0
+    for (let i = 31; i >= 0; i--) {
+      const bit = (num >> i) & 1
+      if (node.containsKey(1 - bit) && node.get(1 - bit).frequency > 0) {
+        res = res | (1 << i)
+        node = node.get(1 - bit)
+      } else {
+        if (node.containsKey(bit) && node.get(bit).frequency > 0) {
+          node = node.get(bit)
+        } else {
+          return 0
+        }
+      }
+    }
+    return res
+  }
+
+  deleteKey(num) {
+    let node = this.root
+    for (let i = 31; i >= 0; i--) {
+      const bit = (num >> i) & 1
+      if (node.containsKey(bit)) {
+        node = node.get(bit)
+        node.frequency--
+      } else {
+        break
+      }
+    }
+  }
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+function maximumStrongPairXor(nums) {
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+  let maxi = 0
+  let j = 0
+  const t = new Trie()
+  t.insert(nums[0])
+  for (let i = 1; i < n; i++) {
+    while (j < i && nums[i] - nums[j] > Math.min(nums[i], nums[j])) {
+      t.deleteKey(nums[j])
+      j++
+    }
+    maxi = Math.max(maxi, t.getMax(nums[i]))
+    t.insert(nums[i])
+  }
+  return maxi
+}
+
+// another
+
+
 const maximumStrongPairXor= (nums) => {
   const A = nums
   let res = 0;

From 06283d6218a2733cc7bf8d4d479b75319b58da81 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Nov 2023 15:16:11 +0800
Subject: [PATCH 2846/3374] Update
 2313-minimum-flips-in-binary-tree-to-get-result.js

---
 ...imum-flips-in-binary-tree-to-get-result.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/2313-minimum-flips-in-binary-tree-to-get-result.js b/2313-minimum-flips-in-binary-tree-to-get-result.js
index 4354aee3..f11fa541 100644
--- a/2313-minimum-flips-in-binary-tree-to-get-result.js
+++ b/2313-minimum-flips-in-binary-tree-to-get-result.js
@@ -1,3 +1,65 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {boolean} result
+ * @return {number}
+ */
+const minimumFlips = function(root, result) {
+  const dp = new Map()
+  return dfs(root, result)
+  
+  function dfs(node, expected) {
+    if(node.val === 0 || node.val === 1) {
+      return (!!node.val) === !!expected ? 0 : 1
+    }
+    if(dp.has(node) && dp.get(node).has(expected)) {
+      return dp.get(node).get(expected)
+    }
+    let res = Infinity
+    
+    if(node.val === 2) {
+      if(expected) {
+        res = Math.min(dfs(node.left, 1), dfs(node.right, 1))
+      } else {
+        res = dfs(node.left, 0) + dfs(node.right, 0)
+      }
+    } else if(node.val === 3) {
+      if(expected) {
+        res = dfs(node.left, 1) + dfs(node.right, 1)
+      } else {
+        res = Math.min(dfs(node.left, 0), dfs(node.right, 0))
+      }
+    } else if(node.val === 4) {
+      if(expected) {
+        res = Math.min(dfs(node.left, 0) + dfs(node.right, 1), dfs(node.left, 1) + dfs(node.right, 0))
+      } else {
+        res = Math.min(dfs(node.left, 1) + dfs(node.right, 1), dfs(node.left, 0) + dfs(node.right, 0))
+      }
+      
+    } else if(node.val === 5) {
+      const child = node.left || node.right
+      if(expected) {
+        res = dfs(child, 0)
+      } else {
+        res = dfs(child, 1)
+      }
+    }
+    
+    if(!dp.has(node)) dp.set(node, new Map())
+    dp.get(node).set(expected, res)
+    return res
+  }
+};
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val, left, right) {

From 24e90ea7b2fd6135978b93834ef34315132af946 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Nov 2023 13:06:28 +0800
Subject: [PATCH 2847/3374] Update
 2458-height-of-binary-tree-after-subtree-removal-queries.js

---
 ...nary-tree-after-subtree-removal-queries.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/2458-height-of-binary-tree-after-subtree-removal-queries.js b/2458-height-of-binary-tree-after-subtree-removal-queries.js
index e3869df4..15e3aad3 100644
--- a/2458-height-of-binary-tree-after-subtree-removal-queries.js
+++ b/2458-height-of-binary-tree-after-subtree-removal-queries.js
@@ -1,3 +1,54 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const treeQueries = function(root, queries) {
+  const depth = [], height = [], depthHash = []
+  dfs(root, 0)
+  const res = []
+  for(const e of queries) {
+    const d = depth[e], h = height[e], row = depthHash[d]
+    if(row.length === 1) {
+       res.push(d - 1)
+    } else if(h === row[0]) {
+        res.push(d + row[1])
+    } else {
+        res.push(d + row[0])
+    }
+  }
+  return res
+
+  function dfs(node, d) {
+    if(node == null) return 0
+    const {val} = node
+    const h = Math.max(dfs(node.left, d + 1), dfs(node.right, d + 1))
+    depth[val] = d
+    height[val] = h
+    if(depthHash[d] == null) depthHash[d] = []
+    depthHash[d].push(h)
+    keepLargestTwo(depthHash[d])
+    return h + 1
+  }
+  function keepLargestTwo(arr) {
+      arr.sort((a,b) => b - a)
+      if(arr.length > 2) {
+         arr.splice(2, arr.length - 2)
+      }
+  }
+};
+
+// another
+
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val, left, right) {

From 2c60bd14698e0bfd6980831b53af13942a89df92 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Nov 2023 14:13:42 +0800
Subject: [PATCH 2848/3374] Update 2277-closest-node-to-path-in-tree.js

---
 2277-closest-node-to-path-in-tree.js | 51 ++++++++++++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/2277-closest-node-to-path-in-tree.js b/2277-closest-node-to-path-in-tree.js
index 275e550d..b8ef00ef 100644
--- a/2277-closest-node-to-path-in-tree.js
+++ b/2277-closest-node-to-path-in-tree.js
@@ -1,3 +1,54 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} query
+ * @return {number[]}
+ */
+const closestNode = function(n, edges, query) {
+  const g = new Map()
+  for(const [p, q] of edges) {
+    if(!g.has(p)) g.set(p, new Set())
+    if(!g.has(q)) g.set(q, new Set())
+    g.get(p).add(q)
+    g.get(q).add(p)
+  }
+  const dist = Array.from({ length: n }, () => Array(n).fill(null))
+  for(let i = 0; i < n; i++) dfs(i, i, 0)
+  const res = []
+  // console.log(dist)
+  for(const [s, e, t] of query) {
+    let tmp = Infinity, cur = s, el
+    while(true) {
+      if(dist[cur][t] < tmp) {
+          tmp = dist[cur][t]
+          el = cur
+      }
+      if(cur === e) break
+      for(const nxt of (g.get(cur) || [])) {
+        if(dist[cur][e] === dist[nxt][e] + 1) {
+          cur = nxt
+          break
+        }
+      }
+    }
+    res.push(el)
+  }
+    
+  return res
+  
+  function dfs(root, node, d) {
+    dist[root][node] = d
+    for(const nxt of (g.get(node) || [])) {
+      if(nxt !== root && dist[root][nxt] == null) {
+          dfs(root, nxt, d + 1)
+      }
+    }
+  }
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From f4c7ba2c314e29848af4b47dd3ae7231df4fdff0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Nov 2023 13:10:29 +0800
Subject: [PATCH 2849/3374] Create
 2920-maximum-points-after-collecting-coins-from-all-nodes.js

---
 ...s-after-collecting-coins-from-all-nodes.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 2920-maximum-points-after-collecting-coins-from-all-nodes.js

diff --git a/2920-maximum-points-after-collecting-coins-from-all-nodes.js b/2920-maximum-points-after-collecting-coins-from-all-nodes.js
new file mode 100644
index 00000000..02020d94
--- /dev/null
+++ b/2920-maximum-points-after-collecting-coins-from-all-nodes.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[]} coins
+ * @param {number} k
+ * @return {number}
+ */
+const maximumPoints = function (edges, coins, k) {
+  const n = coins.length
+  const g = Array(n)
+    .fill()
+    .map(() => [])
+  for (const edge of edges) {
+    const [u, v] = edge
+    g[u].push(v)
+    g[v].push(u)
+  }
+  const dp = Array(n)
+    .fill()
+    .map(() => Array(15).fill(-1))
+  const dfs = (node, parent, reduce) => {
+    if (dp[node][reduce] !== -1) {
+      return dp[node][reduce]
+    }
+    if (reduce >= 14) {
+      return (dp[node][reduce] = 0)
+    }
+    let currCoins = coins[node]
+    for (let j = 0; j < reduce; j++) {
+      currCoins = Math.floor(currCoins / 2)
+    }
+    let way1 = currCoins - k
+    let way2 = Math.floor(currCoins / 2)
+    for (const child of g[node]) {
+      if (child !== parent) {
+        dfs(child, node, reduce + 1)
+        dfs(child, node, reduce)
+        way1 += dp[child][reduce]
+        way2 += dp[child][reduce + 1]
+      }
+    }
+    dp[node][reduce] = Math.max(way1, way2)
+    return dp[node][reduce]
+  }
+  dfs(0, -1, 0)
+
+  return dp[0][0]
+}

From 62375ef0f35a4c5ea53a7d06f9b952b178e7980b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 18 Nov 2023 21:34:32 +0800
Subject: [PATCH 2850/3374] Create
 2925-maximum-score-after-applying-operations-on-a-tree.js

---
 ...ore-after-applying-operations-on-a-tree.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 2925-maximum-score-after-applying-operations-on-a-tree.js

diff --git a/2925-maximum-score-after-applying-operations-on-a-tree.js b/2925-maximum-score-after-applying-operations-on-a-tree.js
new file mode 100644
index 00000000..6bcc7db3
--- /dev/null
+++ b/2925-maximum-score-after-applying-operations-on-a-tree.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[]} values
+ * @return {number}
+ */
+var maximumScoreAfterOperations = function(edges, values) {
+    const n = values.length;
+    const g = new Array(n).fill(null).map(() => []);
+    for (const edge of edges) {
+        const [u, v] = edge;
+        g[u].push(v);
+        g[v].push(u);
+    }
+
+    const subtree = new Array(n);
+    for (let i = 0; i < n; i++) {
+        subtree[i] = values[i];
+    }
+
+    const pre = (node, parent) => {
+        for (const child of g[node]) {
+            if (child !== parent) {
+                pre(child, node);
+                subtree[node] += subtree[child];
+            }
+        }
+    };
+
+    pre(0, -1);
+
+    const dp = new Array(n).fill(-1);
+
+    const dfs = (node, parent) => {
+        dp[node] = subtree[node] - values[node];
+        let sum = 0;
+        let cnt = 0;
+        for (const child of g[node]) {
+            if (child !== parent) {
+                dfs(child, node);
+                cnt++;
+                sum += dp[child];
+            }
+        }
+        if (cnt > 0) {
+            dp[node] = Math.max(dp[node], values[node] + sum);
+        }
+    };
+
+    dfs(0, -1);
+    return dp[0];
+};

From 81d3a3e2a2d7640a635e55b85fa0eb24fe7fbb47 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Nov 2023 14:32:03 +0800
Subject: [PATCH 2851/3374] Create
 2940-find-building-where-alice-and-bob-can-meet.js

---
 ...d-building-where-alice-and-bob-can-meet.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2940-find-building-where-alice-and-bob-can-meet.js

diff --git a/2940-find-building-where-alice-and-bob-can-meet.js b/2940-find-building-where-alice-and-bob-can-meet.js
new file mode 100644
index 00000000..ae2e46db
--- /dev/null
+++ b/2940-find-building-where-alice-and-bob-can-meet.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} heights
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var leftmostBuildingQueries = function (heights, queries) {
+    const st = []
+    const [hs, qs] = [heights, queries]
+    let n = qs.length;
+    let ans = new Array(n).fill(-1);
+    let es = new Array(hs.length).fill().map(() => []);
+    for (let i = 0; i < n; i++) {
+        let x = qs[i][0];
+        let y = qs[i][1];
+        if (x > y) {
+            [x, y] = [y, x];
+        }
+        if (hs[y] > hs[x] || x === y) {
+            ans[i] = y;
+        } else {
+            es[y].push([hs[x], i]);
+        }
+    }
+
+    for (let i = hs.length - 1; i >= 0; i--) {
+        let n1 = st.length;
+        for (let [x, y] of es[i]) {
+            let p = search(x);
+            if (p < n1 && p >= 0) {
+                ans[y] = st[p][1];
+            }
+        }
+        while (st.length > 0 && st[st.length - 1][0] <= hs[i]) {
+            st.pop();
+        }
+        st.push([hs[i], i]);
+    }
+    return ans;
+
+  
+     function search(x) {
+        let l = 0;
+        let r = st.length - 1;
+        let ans = -1;
+        while (l <= r) {
+            let m = Math.floor((l + r) / 2);
+            if (st[m][0] > x) {
+                ans = Math.max(ans, m);
+                l = m + 1;
+            } else {
+                r = m - 1;
+            }
+        }
+        return ans;
+    }
+}

From 3340470e222b21655a8240986f260bff7e2b65e4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Nov 2023 14:32:48 +0800
Subject: [PATCH 2852/3374] Create 2939-maximum-xor-product.js

---
 2939-maximum-xor-product.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2939-maximum-xor-product.js

diff --git a/2939-maximum-xor-product.js b/2939-maximum-xor-product.js
new file mode 100644
index 00000000..ec022b12
--- /dev/null
+++ b/2939-maximum-xor-product.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} n
+ * @return {number}
+ */
+var maximumXorProduct = function(a, b, n) {
+    let ans = 0n;
+    let big = 0n;
+    let found = false;
+    a = BigInt(a)
+    b = BigInt(b)
+
+    for (let i = 50; i >= 0; i--) {
+        let curr = BigInt(1) << BigInt(i);
+
+        if (((a & curr) == 0n) && ((b & curr) == 0n)) {
+            if (i < n) ans += curr;
+        } else if (((a & curr)) && ((b & curr) == 0n)) {
+            if (big == 0) big = -1;
+            else if (big == -1 && i < n) ans += curr;
+        } else if (((a & curr) == 0n) && ((b & curr))) {
+            if (big == 0) big = 1;
+            else if (big == 1 && i < n) ans += curr;
+        }
+    }
+
+    let mod = BigInt(1000000007);
+    a ^= ans;
+    b ^= ans;
+    a %= mod;
+    b %= mod;
+    ans = (a * b) % mod;
+
+    return Number(ans);
+};

From 0f0c811e61c25db745b6374acf67c12276f2477d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Nov 2023 14:33:22 +0800
Subject: [PATCH 2853/3374] Create 2938-separate-black-and-white-balls.js

---
 2938-separate-black-and-white-balls.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2938-separate-black-and-white-balls.js

diff --git a/2938-separate-black-and-white-balls.js b/2938-separate-black-and-white-balls.js
new file mode 100644
index 00000000..1e12ea4b
--- /dev/null
+++ b/2938-separate-black-and-white-balls.js
@@ -0,0 +1,18 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minimumSteps = function(s) {
+  let n = s.length
+  let left = n - 1
+  let right = n - 1
+  let cnt = 0
+  while (left >= 0) {
+    if (s.charAt(left) === '1') {
+      cnt += right - left
+      right--
+    }
+    left--
+  }
+  return cnt
+};

From 8e06c7ae822d7d073fe6315de6e58c0f85071ecd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Nov 2023 14:33:51 +0800
Subject: [PATCH 2854/3374] Create 2937-make-three-strings-equal.js

---
 2937-make-three-strings-equal.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 2937-make-three-strings-equal.js

diff --git a/2937-make-three-strings-equal.js b/2937-make-three-strings-equal.js
new file mode 100644
index 00000000..47bdc08e
--- /dev/null
+++ b/2937-make-three-strings-equal.js
@@ -0,0 +1,26 @@
+/**
+ * @param {string} s1
+ * @param {string} s2
+ * @param {string} s3
+ * @return {number}
+ */
+var findMinimumOperations = function(s1, s2, s3) {
+  let a = s1.length
+  let b = s2.length
+  let c = s3.length
+
+  let min = Math.min(a, Math.min(b, c))
+  let i = 0
+  for (; i < min; i++) {
+    let c1 = s1.charAt(i)
+    let c2 = s2.charAt(i)
+    let c3 = s3.charAt(i)
+    if (c1 !== c2 || c2 !== c3) {
+      break
+    }
+  }
+  if (i === 0) return -1
+  let ans = 0
+  ans = a - i + b - i + c - i
+  return ans
+};

From d74f8754209770ebb8cfa733aaf3f3de58733648 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Nov 2023 19:29:15 +0800
Subject: [PATCH 2855/3374] Update
 1707-maximum-xor-with-an-element-from-array.js

---
 ...-maximum-xor-with-an-element-from-array.js | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
index 7aa24804..bfe49032 100644
--- a/1707-maximum-xor-with-an-element-from-array.js
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -99,3 +99,58 @@ const maximizeXor = function (nums, queries) {
   }
   return result
 }
+
+// another
+// though not enough memory, this method still provides a method to solve this kind of problem
+
+class Trie {
+  constructor() {
+    this.next = Array(2).fill(null)
+  }
+}
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maximizeXor = function(nums, queries) {
+  nums.sort((a, b) => a - b)
+  queries.forEach((e, i) => e.push(i))
+  queries.sort((a, b) => a[1] - b[1])
+  const n = nums.length
+  let idx = 0
+  const res = []
+  const root = new Trie()
+  for(const [x, m, qi] of queries) {
+    
+    while(idx < n && nums[idx] <= m) {
+      let cur = root, val = nums[idx]
+      for(let i = 29; i >= 0; i--) {
+        const tmp = (val >> i) & 1
+        if(cur.next[tmp] == null) cur.next[tmp] = new Trie()
+        cur = cur.next[tmp]
+      }
+      idx++
+    }
+    if(idx === 0) {
+      res[qi] = -1
+      continue
+    }
+    
+    let tmp = 0, cur = root
+    for(let i = 29; i >= 0; i--) {
+      const val = 1 - ((x >> i) & 1)
+      if(cur.next[val] != null) {
+        tmp = tmp * 2 + 1
+        cur = cur.next[val]
+      } else {
+        tmp = tmp * 2
+        cur = cur.next[1 - val]
+      }
+
+    }
+    
+    res[qi] = tmp
+  }
+  return res
+};

From 8caa8cb1936eedd53893728b5092fbb9980840cb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 20 Nov 2023 19:31:54 +0800
Subject: [PATCH 2856/3374] Update
 1707-maximum-xor-with-an-element-from-array.js

---
 ...-maximum-xor-with-an-element-from-array.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
index bfe49032..f33846b8 100644
--- a/1707-maximum-xor-with-an-element-from-array.js
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -1,3 +1,50 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maximizeXor = function(nums, queries) {
+  nums.sort((a, b) => a - b)
+  queries.forEach((e, i) => e.push(i))
+  queries.sort((a, b) => a[1] - b[1])
+  const n = nums.length
+  let idx = 0
+  const res = []
+  const root = [null, null]
+  for(const [x, m, qi] of queries) {
+    while(idx < n && nums[idx] <= m) {
+      let cur = root, val = nums[idx]
+      for(let i = 29; i >= 0; i--) {
+        const tmp = (val >> i) & 1
+        if(cur[tmp] == null) cur[tmp] = [null, null]
+        cur = cur[tmp]
+      }
+      idx++
+    }
+    if(idx === 0) {
+      res[qi] = -1
+      continue
+    }
+    
+    let tmp = 0, cur = root
+    for(let i = 29; i >= 0; i--) {
+      const val = 1 - ((x >> i) & 1)
+      if(cur[val] != null) {
+        tmp = tmp * 2 + 1
+        cur = cur[val]
+      } else {
+        tmp = tmp * 2
+        cur = cur[1 - val]
+      }
+    }
+    res[qi] = tmp
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[][]} queries

From 0cc33a334434fb92e11e3d7c82965f42916baa69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 Nov 2023 19:43:56 +0800
Subject: [PATCH 2857/3374] Update 1803-count-pairs-with-xor-in-a-range.js

---
 1803-count-pairs-with-xor-in-a-range.js | 48 +++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1803-count-pairs-with-xor-in-a-range.js b/1803-count-pairs-with-xor-in-a-range.js
index 1cd9f17c..03ee2ffe 100644
--- a/1803-count-pairs-with-xor-in-a-range.js
+++ b/1803-count-pairs-with-xor-in-a-range.js
@@ -44,3 +44,51 @@ class Trie {
     return ans
   }
 }
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} low
+ * @param {number} high
+ * @return {number}
+ */
+const countPairs = function(nums, low, high) {
+  let res = 0, n = nums.length, trie = { cnt: 0 }
+  for(const e of nums) {
+    res += helper(e, high + 1) - helper(e, low)
+    insert(e)
+  }
+  return res
+  
+  function helper(e, limit) {
+    let res = 0, cur = trie
+    for(let i = 14; i >= 0; i--) {
+      const a = (e >> i) & 1
+      const b = (limit >> i) & 1
+      if(cur == null) break
+      if(b === 0) {
+        cur = cur[a]
+        continue
+      }
+      if(cur[a]) {
+        res += cur[a].cnt
+      }
+      cur = cur[1 - a]
+    }
+    
+    return res
+  }
+  
+  function insert(e) {
+    let cur = trie
+    for(let i = 14; i >= 0; i--) {
+      const tmp = (e >> i) & 1
+      if(!(tmp in cur)) cur[tmp] = {cnt:0}
+      cur[tmp].cnt++
+      cur = cur[tmp]
+    }
+  }
+  
+};

From 6901a48c60329725728b47328417d3bfff8d53c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 Nov 2023 14:21:39 +0800
Subject: [PATCH 2858/3374] Create
 2479-maximum-xor-of-two-non-overlapping-subtrees.js

---
 ...mum-xor-of-two-non-overlapping-subtrees.js | 102 ++++++++++++++++++
 1 file changed, 102 insertions(+)
 create mode 100644 2479-maximum-xor-of-two-non-overlapping-subtrees.js

diff --git a/2479-maximum-xor-of-two-non-overlapping-subtrees.js b/2479-maximum-xor-of-two-non-overlapping-subtrees.js
new file mode 100644
index 00000000..1ffd85a5
--- /dev/null
+++ b/2479-maximum-xor-of-two-non-overlapping-subtrees.js
@@ -0,0 +1,102 @@
+class TrieNode {
+  constructor() {
+    this.next = [null, null]
+  }
+}
+const bigIntMinAndMax = (...args) => {
+  return args.reduce(
+    ([min, max], e) => {
+      return [e < min ? e : min, e > max ? e : max]
+    },
+    [args[0], args[0]],
+  )
+}
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} values
+ * @return {number}
+ */
+const maxXor = function (n, edges, values) {
+  const ins = new Solution()
+  return Number(ins.maxXor(n, edges, values))
+}
+
+class Solution {
+  constructor() {
+    this.next = []
+    this.val = []
+    this.values = []
+    this.root = null
+    this.ret = 0n
+  }
+
+  insert(num) {
+    let node = this.root
+    num = BigInt(num)
+    for (let i = 63n; i >= 0n; i--) {
+      const d = (num >> i) & 1n
+      if (node.next[d] === null) {
+        node.next[d] = new TrieNode()
+      }
+      node = node.next[d]
+    }
+  }
+
+  find(num) {
+    num = BigInt(num)
+    let node = this.root
+    if (this.root.next[0] === null && this.root.next[1] === null) {
+      return 0
+    }
+    let ret = 0n
+    for (let i = 63n; i >= 0n; i--) {
+      const d = (num >> i) & 1n
+      if (node.next[1n - d] !== null) {
+        ret += 1n << i
+        node = node.next[1n - d]
+      } else {
+        ret += 0n
+        node = node.next[d]
+      }
+    }
+    return ret
+  }
+
+  maxXor(n, edges, values) {
+    this.values = values
+    for (let i = 0; i < n; i++) {
+      this.next[i] = []
+    }
+    for (let i = 0; i < edges.length; i++) {
+      const [a, b] = edges[i]
+      this.next[a].push(b)
+      this.next[b].push(a)
+    }
+    this.root = new TrieNode()
+    this.dfs(0, -1)
+    this.dfs2(0, -1)
+    return this.ret
+  }
+
+  dfs(cur, parent) {
+    let v = this.values[cur]
+    for (let i = 0; i < this.next[cur].length; i++) {
+      const nxt = this.next[cur][i]
+      if (nxt === parent) continue
+      v += this.dfs(nxt, cur)
+    }
+    this.val[cur] = v
+    return v
+  }
+
+  dfs2(cur, parent) {
+    for (let i = 0; i < this.next[cur].length; i++) {
+      const nxt = this.next[cur][i]
+      if (nxt === parent) continue
+      this.ret = bigIntMinAndMax(this.ret, this.find(this.val[nxt]))[1]
+      this.dfs2(nxt, cur)
+      this.insert(this.val[nxt])
+    }
+  }
+}

From dfdfb8112fffb3b0be8275832f761348a1cb2f69 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Nov 2023 18:22:19 +0800
Subject: [PATCH 2859/3374] Update 2416-sum-of-prefix-scores-of-strings.js

---
 2416-sum-of-prefix-scores-of-strings.js | 41 +++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2416-sum-of-prefix-scores-of-strings.js b/2416-sum-of-prefix-scores-of-strings.js
index 11ea9edf..32d5f713 100644
--- a/2416-sum-of-prefix-scores-of-strings.js
+++ b/2416-sum-of-prefix-scores-of-strings.js
@@ -1,3 +1,44 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const sumPrefixScores = (words) => {
+  const n = words.length
+  const trie = { _count: 0 }
+  const result = []
+
+  // Create our own custom trie with _count property.
+  // We are storing how many time we passed current node.
+  for (let i = 0; i < n; i++) {
+    const word = words[i]
+
+    let node = trie
+    for (let j = 0; j < word.length; j++) {
+      if (!node[word[j]]) node[word[j]] = {}
+      node = node[word[j]]
+      node._count = (node._count || 0) + 1
+    }
+  }
+
+  // Collect all _count values together as a result
+  for (let i = 0; i < n; i++) {
+    const word = words[i]
+    let count = 0
+
+    let node = trie
+    for (let j = 0; j < word.length; j++) {
+      node = node[word[j]]
+      count += node._count || 0
+    }
+
+    result[i] = count
+  }
+
+  return result
+}
+
+// another
+
 /**
  * @param {string[]} words
  * @return {number[]}

From b0a42a8e67517d420d31e98e04d2f7bb1a96f922 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Nov 2023 19:45:06 +0800
Subject: [PATCH 2860/3374] Update 632-smallest-range.js

---
 632-smallest-range.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/632-smallest-range.js b/632-smallest-range.js
index 16153b17..0dcca794 100644
--- a/632-smallest-range.js
+++ b/632-smallest-range.js
@@ -188,7 +188,7 @@ var smallestRange = function(nums) {
 
 // another
 
-class PriorityQueue {
+class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []
     this.top = 0
@@ -260,7 +260,7 @@ class PriorityQueue {
  * @return {number[]}
  */
 const smallestRange = function (nums) {
-  const pq = new PriorityQueue((a, b) => a[0] < b[0])
+  const pq = new PQ((a, b) => a[0] < b[0])
   const limit = 10 ** 5,
     n = nums.length,
     { max } = Math

From e69dcb5adc4053dfb6645b30e99f54476465fa61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Nov 2023 19:51:04 +0800
Subject: [PATCH 2861/3374] Create
 2948-make-lexicographically-smallest-array-by-swapping-elements.js

---
 ...lly-smallest-array-by-swapping-elements.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 2948-make-lexicographically-smallest-array-by-swapping-elements.js

diff --git a/2948-make-lexicographically-smallest-array-by-swapping-elements.js b/2948-make-lexicographically-smallest-array-by-swapping-elements.js
new file mode 100644
index 00000000..48a8a6d5
--- /dev/null
+++ b/2948-make-lexicographically-smallest-array-by-swapping-elements.js
@@ -0,0 +1,61 @@
+//////////////////////////// Template /////////////////////////////////
+function DJSet(n) {
+    let parent = Array(n).fill(-1);
+    return { find, union, count, equiv, par, grp }
+    function find(x) {
+        return parent[x] < 0 ? x : parent[x] = find(parent[x]);
+    }
+    function union(x, y) {
+        x = find(x);
+        y = find(y);
+        if (x == y) return false;
+        if (parent[x] < parent[y]) [x, y] = [y, x];
+        parent[x] += parent[y];
+        parent[y] = x;
+        return true;
+    }
+    function count() { // total groups
+        return parent.filter(v => v < 0).length;
+    }
+    function equiv(x, y) { // isConnected
+        return find(x) == find(y);
+    }
+    function par() {
+        return parent;
+    }
+    function grp() {
+        let groups = [];
+        for (let i = 0; i < n; i++) groups.push([]);
+        for (let i = 0; i < n; i++) groups[find(i)].push(i); // sorted and unique
+        return groups;
+    }
+}
+////////////////////////////////////////////////////////////////
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number[]}
+ */
+var lexicographicallySmallestArray = function(nums, limit) {
+    let d = nums.map((x, i) => [x, i]).sort((x, y) => x[0] - y[0] || x[1] - y[1]), pairs = [];
+    for (let i = 1; i < nums.length; i++) {
+        if (d[i][0] - d[i - 1][0] <= limit) pairs.push([d[i - 1][1], d[i][1]]);
+    }
+    return LexicalSmallestArrayWithSwaps(nums, pairs)
+};
+
+
+// reference: https://leetcode.com/problems/smallest-string-with-swaps/
+function LexicalSmallestArrayWithSwaps (a, pairs) {
+    let n = a.length, ds = new DJSet(n), res = Array(n).fill(0);
+    for (const [x, y] of pairs) ds.union(x, y);
+    let groups = ds.grp().filter(e => e.length);
+    for (const group of groups) {
+        let ga = [];
+        for (let i of group) ga.push(a[i]);
+        ga.sort((x, y) => x - y);
+        for (let i = 0; i < group.length; i++) res[group[i]] = ga[i];
+    }
+    return res;
+};
+

From 9c1303d8271d77898f8fb1a4ad3fed1bfdb18407 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Nov 2023 19:51:54 +0800
Subject: [PATCH 2862/3374] Create 2949-count-beautiful-substrings-ii.js

---
 2949-count-beautiful-substrings-ii.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2949-count-beautiful-substrings-ii.js

diff --git a/2949-count-beautiful-substrings-ii.js b/2949-count-beautiful-substrings-ii.js
new file mode 100644
index 00000000..e1f8c0b0
--- /dev/null
+++ b/2949-count-beautiful-substrings-ii.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var beautifulSubstrings = function(s, k) {
+    let ans = 0, cur = 0;
+    let mp = new Map();
+    mp.set(0, [-1]);
+    for (let i = 0; i < s.length; i++) {
+        let ch = s[i];
+        if (ch === 'a' || ch === 'e' || ch === 'i' || ch === 'o' || ch === 'u') {
+            cur++;
+        } else {
+            cur--;
+        }
+        for (let x of (mp.get(cur) || []) ) {
+            let d = (i - x) / 2;
+            if (Math.pow(d, 2) % k === 0) {
+                ans++;
+            }
+        }
+        if (!mp.has(cur)) mp.set(cur, []);
+        mp.get(cur).push(i);
+    }
+    return ans;
+};

From 4a2985f5d14e959ec42a091b65bab272ccc60016 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Nov 2023 19:52:38 +0800
Subject: [PATCH 2863/3374] Create 2947-count-beautiful-substrings-i.js

---
 2947-count-beautiful-substrings-i.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 2947-count-beautiful-substrings-i.js

diff --git a/2947-count-beautiful-substrings-i.js b/2947-count-beautiful-substrings-i.js
new file mode 100644
index 00000000..d16869a5
--- /dev/null
+++ b/2947-count-beautiful-substrings-i.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var beautifulSubstrings = function(s, k) {
+        let counter=0;
+        for(let i=0;i<s.length;i++){
+            let vow=0;
+            let con=0;
+            for(let j=i;j<s.length;j++){
+                let c=s.charAt(j);
+                if(c=='a'||c=='e'||c=='i'||c=='o'||c=='u'){
+                    vow++;
+                }
+                let df=j-i;
+                df++;
+                con=df;
+                con=con-vow;
+
+                if(vow==con &&(vow*con)%k==0){
+                    counter++;
+                }
+            }
+        }
+        return counter;
+};

From 0b721b6f9e0727a5ba7aa69254816fa9be8e1767 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 Nov 2023 19:53:06 +0800
Subject: [PATCH 2864/3374] Create
 2946-matrix-similarity-after-cyclic-shifts.js

---
 2946-matrix-similarity-after-cyclic-shifts.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2946-matrix-similarity-after-cyclic-shifts.js

diff --git a/2946-matrix-similarity-after-cyclic-shifts.js b/2946-matrix-similarity-after-cyclic-shifts.js
new file mode 100644
index 00000000..e1c852ee
--- /dev/null
+++ b/2946-matrix-similarity-after-cyclic-shifts.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[][]} mat
+ * @param {number} k
+ * @return {boolean}
+ */
+var areSimilar = function(mat, k) {
+  const m = mat.length, n = mat[0].length
+  const clone = Array.from({ length: m }, () => Array(n).fill(null))
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      clone[i][j] = mat[i][j]
+    }
+  }
+  for(let i = 0; i < m; i++) {
+    const odd = i % 2 === 1
+    if(odd) {
+      sr(clone, i)
+    } else {
+      sl(clone, i)
+    }
+  }
+  // console.log(clone)
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(mat[i][j] !== clone[i][j]) return false
+    }
+  }
+  
+  
+  return true
+  
+  function sr(mat, i) {
+    const row = mat[i]
+    const idx = k % n
+    mat[i] = row.slice(n - idx).concat(row.slice(0, n - idx)) 
+  }
+  function sl(mat, i) {
+    const row = mat[i]
+    const idx = k % n
+    mat[i] = row.slice(idx, n).concat(row.slice(0, idx)) 
+  }
+};

From 31587c5e9d9924e53ae782a4d3e49c007c51e89c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Nov 2023 12:45:25 +0800
Subject: [PATCH 2865/3374] Update 1675-minimize-deviation-in-array.js

---
 1675-minimize-deviation-in-array.js | 94 +++++++++++++++++++++++++++++
 1 file changed, 94 insertions(+)

diff --git a/1675-minimize-deviation-in-array.js b/1675-minimize-deviation-in-array.js
index 4d2821fe..f8fab346 100644
--- a/1675-minimize-deviation-in-array.js
+++ b/1675-minimize-deviation-in-array.js
@@ -1,3 +1,97 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minimumDeviation = function(nums) {
+  const pq = new PQ((a, b) => a > b)
+  let min = Infinity
+  for(const e of nums) {
+      const tmp = e % 2 === 1 ?  e * 2: e
+      pq.push(tmp)
+      min = Math.min(min, tmp)
+  }
+  let res = Infinity
+  while(pq.peek() % 2 === 0) {
+     const e = pq.pop()
+     res = Math.min(res, e - min)
+     min = Math.min(min, e / 2)
+     pq.push(e / 2)
+  }
+  if(pq.size()) {
+      res = Math.min(res, pq.peek() - min)
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 09e6ece2806bc3e1b3a4528e1740740f4b9ebf46 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 28 Nov 2023 13:28:59 +0800
Subject: [PATCH 2866/3374] Update 1825-finding-mk-average.js

---
 1825-finding-mk-average.js | 76 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/1825-finding-mk-average.js b/1825-finding-mk-average.js
index a6936047..8ef45ae2 100644
--- a/1825-finding-mk-average.js
+++ b/1825-finding-mk-average.js
@@ -1,3 +1,79 @@
+class BIT {
+  constructor(n) {
+    this.arr = new Array(n + 1).fill(0)
+  }
+
+  update(i, v) {
+    while (i < this.arr.length) {
+      this.arr[i] += v
+      i += i & -i
+    }
+  }
+
+  prefixSum(i) {
+    let res = 0
+    while (i > 0) {
+      res += this.arr[i]
+      i -= i & -i
+    }
+    return res
+  }
+
+  upper_bound(v) {
+    const n = Math.floor(Math.log2(this.arr.length))
+    let pos = 0
+    let s = 0
+    for (let i = n; i >= 0; i--) {
+      if (
+        pos + (1 << i) < this.arr.length &&
+        s + this.arr[pos + (1 << i)] <= v
+      ) {
+        pos += 1 << i
+        s += this.arr[pos]
+      }
+    }
+    return pos + 1
+  }
+}
+
+class MKAverage {
+  constructor(m, k) {
+    this.m = m
+    this.k = k
+    this.cnt = new BIT(10 ** 5)
+    this.bit = new BIT(10 ** 5)
+    this.q = []
+  }
+
+  addElement(num) {
+    this.q.push(num)
+    this.cnt.update(num, 1)
+    this.bit.update(num, num)
+    if (this.q.length > this.m) {
+      const x = this.q.shift()
+      this.cnt.update(x, -1)
+      this.bit.update(x, -x)
+    }
+  }
+
+  calculateMKAverage() {
+    if (this.q.length < this.m) {
+      return -1
+    }
+    const l = this.k
+    const r = this.m - this.k
+    const i = this.cnt.upper_bound(l)
+    const j = this.cnt.upper_bound(r)
+    let ans = this.bit.prefixSum(j) - this.bit.prefixSum(i)
+    ans += (this.cnt.prefixSum(i) - l) * i
+    ans -= (this.cnt.prefixSum(j) - r) * j
+    return Math.floor(ans / (this.m - 2 * this.k))
+  }
+}
+
+// another
+
+
 /**
  * @param {number} m
  * @param {number} k

From f789525a2dcf4369041401da76507306443df479 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Nov 2023 13:29:47 +0800
Subject: [PATCH 2867/3374] Update 1847-closest-room.js

---
 1847-closest-room.js | 50 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/1847-closest-room.js b/1847-closest-room.js
index f2c7aa85..388d0746 100644
--- a/1847-closest-room.js
+++ b/1847-closest-room.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number[][]} rooms
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var closestRoom = function (rooms, queries) {
+  const n = rooms.length
+  const k = queries.length
+  const indexes = new Array(k)
+  for (let i = 0; i < k; i++) {
+    indexes[i] = i
+  }
+  rooms.sort((a, b) => b[1] - a[1]) // Sort by decreasing order of room size
+  indexes.sort((a, b) => queries[b][1] - queries[a][1]) // Sort by decreasing order of query minSize
+  const roomIdsSoFar = new Set()
+  const ans = new Array(k)
+  let i = 0
+  for (const index of indexes) {
+    while (i < n && rooms[i][1] >= queries[index][1]) {
+      // Add id of the room which its size >= query minSize
+      roomIdsSoFar.add(rooms[i++][0])
+    }
+    ans[index] = searchClosetRoomId(roomIdsSoFar, queries[index][0])
+    if (ans[index] == Infinity || ans[index] == -Infinity) ans[index] = -1
+  }
+  return ans
+
+  function searchClosetRoomId(treeSet, preferredId) {
+    let floor = -Infinity
+    let ceiling = Infinity
+    for (const id of treeSet) {
+      if (id <= preferredId) {
+        floor = Math.max(floor, id)
+      } else {
+        ceiling = Math.min(ceiling, id)
+      }
+    }
+    if (floor === -Infinity) {
+      return ceiling
+    } else if (ceiling === Infinity) {
+      return floor
+    } else if (preferredId - floor <= ceiling - preferredId) {
+      return floor
+    } else {
+      return ceiling
+    }
+  }
+}
+
+// another
 
 /**
  * @param {number[][]} rooms

From 9bfeecb60f22fea8bb6690aa3d3887ac2b77e027 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 Nov 2023 14:13:00 +0800
Subject: [PATCH 2868/3374] Update 1847-closest-room.js

---
 1847-closest-room.js | 58 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/1847-closest-room.js b/1847-closest-room.js
index 388d0746..f23d4cf2 100644
--- a/1847-closest-room.js
+++ b/1847-closest-room.js
@@ -47,6 +47,64 @@ var closestRoom = function (rooms, queries) {
   }
 }
 
+// another
+
+/**
+ * @param {number[][]} rooms
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const closestRoom = function (rooms, queries) {
+  const n = rooms.length
+  const m = queries.length
+  const idxArr = Array.from({ length: m }, (_, i) => i)
+  const res = []
+  rooms.sort((a, b) => b[1] - a[1])
+  idxArr.sort((a, b) => queries[b][1] - queries[a][1])
+  const set = new Set()
+  let j = 0
+  for (let i = 0; i < m; i++) {
+    const q = queries[idxArr[i]]
+    while (j < n && rooms[j][1] >= q[1]) {
+      set.add(rooms[j][0])
+      j++
+    }
+    res[idxArr[i]] = helper(q[0])
+  }
+
+  return res
+
+  function helper(preferedId) {
+    let floor = -Infinity,
+      ceil = Infinity
+    for (const roomId of set) {
+      if (roomId < preferedId && roomId > floor) {
+        floor = roomId
+      }
+      if (roomId >= preferedId && roomId < ceil) {
+        ceil = roomId
+      }
+    }
+    let res = -1
+    if (floor === -Infinity) {
+      res = ceil
+    } else if (ceil === Infinity) {
+      res = floor
+    } else {
+      if (preferedId - floor === ceil - preferedId) {
+        res = floor
+      } else if (preferedId - floor < ceil - preferedId) {
+        res = floor
+      } else {
+        res = ceil
+      }
+    }
+
+    return res === Infinity || res === -Infinity ? -1 : res
+  }
+}
+
+
 // another
 
 /**

From 47fa994f4fdd77858e22b67b69222f85f934b32a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 30 Nov 2023 19:34:48 +0800
Subject: [PATCH 2869/3374] Create 2612-minimum-reverse-operations.js

---
 2612-minimum-reverse-operations.js | 93 ++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 2612-minimum-reverse-operations.js

diff --git a/2612-minimum-reverse-operations.js b/2612-minimum-reverse-operations.js
new file mode 100644
index 00000000..76c1dec0
--- /dev/null
+++ b/2612-minimum-reverse-operations.js
@@ -0,0 +1,93 @@
+////////////////////////// Template ////////////////////////////////////
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] > x ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+///////////////////////////////////////////////////////////////////
+
+/**
+ * @param {number} n
+ * @param {number} p
+ * @param {number[]} banned
+ * @param {number} k
+ * @return {number[]}
+ */
+var minReverseOperations = function (n, p, banned, k) {
+  const distances = new Array(n).fill(Number.MAX_SAFE_INTEGER)
+  for (const x of banned) {
+    distances[x] = -1
+  }
+
+  const nodes = [p],
+    newNodes = []
+  distances[p] = 0
+
+  while (nodes.length > 0) {
+    let iMin = Number.MAX_SAFE_INTEGER
+    let iMax = Number.MIN_SAFE_INTEGER
+
+    for (const node of nodes) {
+      const base = node - k + 1
+
+      // j: segment start position
+      // i: update position
+      const j2i = (j) => base + (j - base) * 2
+
+      const update = (i) => {
+        if (distances[i] === Number.MAX_SAFE_INTEGER) {
+          distances[i] = distances[node] + 1
+          newNodes.push(i)
+        }
+      }
+
+      // inclusive
+      const lo = j2i(Math.max(0, base))
+      const hi = j2i(Math.min(node + k, n) - k)
+      for (let i = lo; i <= Math.min(hi, iMin - 2); i += 2) {
+        update(i)
+      }
+      for (let i = Math.max(lo, iMax + 2); i <= hi; i += 2) {
+        update(i)
+      }
+      iMin = Math.min(iMin, lo)
+      iMax = Math.max(iMax, hi)
+    }
+
+    nodes.splice(0, nodes.length, ...newNodes)
+    newNodes.length = 0
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (distances[i] === Number.MAX_SAFE_INTEGER) {
+      distances[i] = -1
+    }
+  }
+  return distances
+}

From 5c7a5fee0b48d199e952d765986261a6bc1f0506 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 1 Dec 2023 12:29:28 +0800
Subject: [PATCH 2870/3374] Create 2736-maximum-sum-queries.js

---
 2736-maximum-sum-queries.js | 79 +++++++++++++++++++++++++++++++++++++
 1 file changed, 79 insertions(+)
 create mode 100644 2736-maximum-sum-queries.js

diff --git a/2736-maximum-sum-queries.js b/2736-maximum-sum-queries.js
new file mode 100644
index 00000000..b3381012
--- /dev/null
+++ b/2736-maximum-sum-queries.js
@@ -0,0 +1,79 @@
+class SegmentTree {
+  constructor(n) {
+    this.size = n
+    this.segTree = Array(n * 2).fill(0)
+  }
+  update(index, val) {
+    let n = this.size,
+      idx = index + n
+    this.segTree[idx] = Math.max(this.segTree[idx], val)
+    idx = Math.floor(idx / 2)
+
+    while (idx > 0) {
+      this.segTree[idx] = Math.max(
+        this.segTree[idx * 2],
+        this.segTree[idx * 2 + 1],
+      )
+      idx = Math.floor(idx / 2)
+    }
+  }
+  maxRange(left, right) {
+    let n = this.size,
+      max = 0
+    let left_idx = left + n,
+      right_idx = right + n
+    while (left_idx <= right_idx) {
+      if (left_idx % 2 === 1) max = Math.max(max, this.segTree[left_idx++])
+      if (right_idx % 2 === 0) max = Math.max(max, this.segTree[right_idx--])
+      left_idx = Math.floor(left_idx / 2)
+      right_idx = Math.floor(right_idx / 2)
+    }
+    return max
+  }
+}
+
+
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const maximumSumQueries = function (nums1, nums2, queries) {
+  let nums = [],
+    n = nums1.length,
+    indexMap = {}
+  for (let i = 0; i < n; i++) {
+    nums.push([nums1[i], nums2[i]])
+    indexMap[nums2[i]] = 1
+  }
+  nums.sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : b[0] - a[0]))
+  for (let [_x, y] of queries) {
+    indexMap[y] = 1
+  }
+  let index = 0
+  for (let value in indexMap) {
+    indexMap[value] = index++ // assign a minimized index to each value
+  }
+  queries = queries
+    .map(([x, y], i) => [x, y, i])
+    .sort((a, b) => (a[0] === b[0] ? b[1] - a[1] : b[0] - a[0]))
+
+  let m = queries.length,
+    ans = Array(m)
+  let segTree = new SegmentTree(index),
+    numsIndex = 0
+  for (let [x, y, queryIndex] of queries) {
+    while (numsIndex < n && nums[numsIndex][0] >= x) {
+      segTree.update(
+        indexMap[nums[numsIndex][1]],
+        nums[numsIndex][0] + nums[numsIndex][1],
+      )
+      numsIndex++
+    }
+    let max = segTree.maxRange(indexMap[y], index - 1)
+    ans[queryIndex] = max === 0 ? -1 : max
+  }
+  return ans
+}
+

From ba011c5fad22ccaf093e749079d6a9a9c701c46b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Dec 2023 12:35:41 +0800
Subject: [PATCH 2871/3374] Create 2926-maximum-balanced-subsequence-sum.js

---
 2926-maximum-balanced-subsequence-sum.js | 98 ++++++++++++++++++++++++
 1 file changed, 98 insertions(+)
 create mode 100644 2926-maximum-balanced-subsequence-sum.js

diff --git a/2926-maximum-balanced-subsequence-sum.js b/2926-maximum-balanced-subsequence-sum.js
new file mode 100644
index 00000000..463b1dcf
--- /dev/null
+++ b/2926-maximum-balanced-subsequence-sum.js
@@ -0,0 +1,98 @@
+////////////////////// Template /////////////////////////////////
+function Bisect() {
+  return { insort_right, insort_left, bisect_left, bisect_right }
+  function insort_right(a, x, lo = 0, hi = null) {
+    lo = bisect_right(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_right(a, x, lo = 0, hi = null) {
+    // > upper_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] > x ? (hi = mid) : (lo = mid + 1)
+    }
+    return lo
+  }
+  function insort_left(a, x, lo = 0, hi = null) {
+    lo = bisect_left(a, x, lo, hi)
+    a.splice(lo, 0, x)
+  }
+  function bisect_left(a, x, lo = 0, hi = null) {
+    // >= lower_bound
+    if (lo < 0) throw new Error('lo must be non-negative')
+    if (hi == null) hi = a.length
+    while (lo < hi) {
+      let mid = parseInt((lo + hi) / 2)
+      a[mid] < x ? (lo = mid + 1) : (hi = mid)
+    }
+    return lo
+  }
+}
+
+function SegmentTreeRMQArray(A) {
+  // max
+  let n = A.length,
+    h = Math.ceil(Math.log2(n)),
+    len = 2 * 2 ** h,
+    a = Array(len).fill(Number.MIN_SAFE_INTEGER)
+  h = 2 ** h
+  initializeFromArray()
+  return { update, maxx, tree }
+  function initializeFromArray() {
+    for (let i = 0; i < n; i++) a[h + i] = A[i]
+    for (let i = h - 1; i >= 1; i--) pushup(i)
+  }
+  function update(pos, v) {
+    a[h + pos] = v
+    for (let i = parent(h + pos); i >= 1; i = parent(i)) pushup(i)
+  }
+  function pushup(i) {
+    a[i] = Math.max(a[left(i)], a[right(i)])
+  }
+  function maxx(l, r) {
+    // [l, r)
+    let max = Number.MIN_SAFE_INTEGER
+    if (l >= r) return max
+    l += h
+    r += h
+    for (; l < r; l = parent(l), r = parent(r)) {
+      if (l & 1) max = Math.max(max, a[l++])
+      if (r & 1) max = Math.max(max, a[--r])
+    }
+    return max
+  }
+  function parent(i) {
+    return i >> 1
+  }
+  function left(i) {
+    return 2 * i
+  }
+  function right(i) {
+    return 2 * i + 1
+  }
+  function tree() {
+    return a
+  }
+}
+/////////////////////////////////////////////////////////////
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxBalancedSubsequenceSum = (a) => {
+  let vals = a.map((x, i) => x - i).sort((x, y) => x - y)
+  vals = [...new Set(vals)]
+  let n = a.length,
+    st = new SegmentTreeRMQArray(Array(n + 1).fill(Number.MIN_SAFE_INTEGER)),
+    bi = new Bisect()
+  for (let i = 0; i < n; i++) {
+    let v = a[i] - i,
+      idx = bi.bisect_left(vals, v)
+    let max = st.maxx(0, idx + 1) // query [0, idx]
+    if (max < 0) max = 0
+    st.update(idx, a[i] + max) // each time accumulate previous [0, idx] max, and update new max sum
+  }
+  return st.maxx(0, n + 1) // query [0, n]
+}

From 69504e0425e0ed0c3f9d7cee522487497a8f7822 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Dec 2023 20:36:48 +0800
Subject: [PATCH 2872/3374] Update 2926-maximum-balanced-subsequence-sum.js

---
 2926-maximum-balanced-subsequence-sum.js | 43 ++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/2926-maximum-balanced-subsequence-sum.js b/2926-maximum-balanced-subsequence-sum.js
index 463b1dcf..2f551a65 100644
--- a/2926-maximum-balanced-subsequence-sum.js
+++ b/2926-maximum-balanced-subsequence-sum.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxBalancedSubsequenceSum = (nums) => {
+    const stack = [[-Infinity, 0]];
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] > 0) {
+            const key = nums[i] - i;
+
+            let left = 0, right = stack.length - 1;
+            while (left <= right) {
+                const mid = left + Math.floor((right - left) / 2);
+                if (stack[mid][0] > key) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            }
+
+            const sum = nums[i] + Math.max(0, stack[left - 1][1]);
+            if (left === stack.length) {
+                stack.push([key, sum]);
+            } else {
+                stack.splice(left, 0, [key, sum]);
+            }
+
+            let k = left + 1;
+            while (k < stack.length && sum >= stack[k][1]) {
+                stack.splice(k, 1);
+            }
+        }
+    }
+
+    if (stack.length > 1) {
+        return stack[stack.length - 1][1];
+    }
+
+    return Math.max(...nums);
+}
+
+// another
+
 ////////////////////// Template /////////////////////////////////
 function Bisect() {
   return { insort_right, insort_left, bisect_left, bisect_right }

From 4653d5366b4660247ad7b3925b86d17f684ec4a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 2 Dec 2023 22:33:47 +0800
Subject: [PATCH 2873/3374] Update 2926-maximum-balanced-subsequence-sum.js

---
 2926-maximum-balanced-subsequence-sum.js | 58 ++++++++++++------------
 1 file changed, 29 insertions(+), 29 deletions(-)

diff --git a/2926-maximum-balanced-subsequence-sum.js b/2926-maximum-balanced-subsequence-sum.js
index 2f551a65..ec53d630 100644
--- a/2926-maximum-balanced-subsequence-sum.js
+++ b/2926-maximum-balanced-subsequence-sum.js
@@ -3,40 +3,40 @@
  * @return {number}
  */
 const maxBalancedSubsequenceSum = (nums) => {
-    const stack = [[-Infinity, 0]];
-    for (let i = 0; i < nums.length; i++) {
-        if (nums[i] > 0) {
-            const key = nums[i] - i;
+  const stack = [[-Infinity, 0]]
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] > 0) {
+      const key = nums[i] - i
 
-            let left = 0, right = stack.length - 1;
-            while (left <= right) {
-                const mid = left + Math.floor((right - left) / 2);
-                if (stack[mid][0] > key) {
-                    right = mid - 1;
-                } else {
-                    left = mid + 1;
-                }
-            }
-
-            const sum = nums[i] + Math.max(0, stack[left - 1][1]);
-            if (left === stack.length) {
-                stack.push([key, sum]);
-            } else {
-                stack.splice(left, 0, [key, sum]);
-            }
-
-            let k = left + 1;
-            while (k < stack.length && sum >= stack[k][1]) {
-                stack.splice(k, 1);
-            }
+      let left = 0,
+        right = stack.length - 1
+      while (left < right) {
+        const mid = left + Math.floor((right - left) / 2)
+        if (stack[mid][0] <= key) {
+          left = mid + 1
+        } else {
+          right = mid
         }
+      }
+      if (stack[left][0] <= key) left++
+      const sum = nums[i] + Math.max(0, stack[left - 1][1])
+      if (left === stack.length) {
+        stack.push([key, sum])
+      } else {
+        stack.splice(left, 0, [key, sum])
+      }
+      let k = left + 1
+      while (k < stack.length && sum >= stack[k][1]) {
+        stack.splice(k, 1)
+      }
     }
+  }
 
-    if (stack.length > 1) {
-        return stack[stack.length - 1][1];
-    }
+  if (stack.length > 1) {
+    return stack[stack.length - 1][1]
+  }
 
-    return Math.max(...nums);
+  return Math.max(...nums)
 }
 
 // another

From e16628a80de5cd3644af8afad956a997a92f4254 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 14:41:23 +0800
Subject: [PATCH 2874/3374] Create 2953-count-complete-substrings.js

---
 2953-count-complete-substrings.js | 65 +++++++++++++++++++++++++++++++
 1 file changed, 65 insertions(+)
 create mode 100644 2953-count-complete-substrings.js

diff --git a/2953-count-complete-substrings.js b/2953-count-complete-substrings.js
new file mode 100644
index 00000000..74632582
--- /dev/null
+++ b/2953-count-complete-substrings.js
@@ -0,0 +1,65 @@
+/**
+ * @param {string} word
+ * @param {number} k
+ * @return {number}
+ */
+var countCompleteSubstrings = function (word, k) {
+  let w = word
+  function calc(s) {
+    let res = 0;
+    let v = s.length;
+    for (let i = 1; i < 27; i++) {
+      if (i * k > v) break;
+      let l = i * k;
+      let len = i * k
+      let cnt = {};
+      for (let j = 0; j < l; j++) {
+        if (cnt[s[j]] == null) {
+          cnt[s[j]] = 0;
+        }
+        cnt[s[j]]++
+      }
+      let freq = {};
+      for (let key in cnt) {
+        if (freq[cnt[key]] == null) {
+          freq[cnt[key]] = 0;
+        }
+        freq[cnt[key]]++;
+      }
+      // console.log(freq)
+
+      if (freq[k] === i) res++;
+      for (let idx = 0; idx < v - len; idx++) {
+        if (cnt[s[idx]] == null) cnt[s[idx]] = 0
+        if (freq[cnt[s[idx]]] == null) freq[cnt[s[idx]]] = 0
+        freq[cnt[s[idx]]]--;
+        cnt[s[idx]]--;
+        if (freq[cnt[s[idx]]] == null) freq[cnt[s[idx]]] = 0
+        freq[cnt[s[idx]]]++;
+
+        if (cnt[s[idx + len]] == null) cnt[s[idx + len]] = 0
+        if (freq[cnt[s[idx + len]]] == null) freq[cnt[s[idx + len]]] = 0
+        freq[cnt[s[idx + len]]]--;
+        cnt[s[idx + len]]++;
+        if (freq[cnt[s[idx + len]]] == null) freq[cnt[s[idx + len]]] = 0
+        freq[cnt[s[idx + len]]]++;
+        if (freq[k] === i) res++;
+      }
+      // console.log(res, freq, cnt)
+    }
+    return res;
+  }
+
+  let idx = 0;
+  let ans = 0;
+  let n = w.length;
+  for (let i = 1; i < n; i++) {
+    if (Math.abs(w.charCodeAt(i) - w.charCodeAt(i - 1)) > 2) {
+      ans += calc(w.slice(idx, i));
+      idx = i;
+    }
+  }
+  // console.log(ans, idx)
+  ans += calc(w.slice(idx));
+  return ans;
+};

From 370f64ea5ebe6b51ce08881769073731e95a8924 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 14:42:00 +0800
Subject: [PATCH 2875/3374] Create 2952-minimum-number-of-coins-to-be-added.js

---
 2952-minimum-number-of-coins-to-be-added.js | 29 +++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 2952-minimum-number-of-coins-to-be-added.js

diff --git a/2952-minimum-number-of-coins-to-be-added.js b/2952-minimum-number-of-coins-to-be-added.js
new file mode 100644
index 00000000..1fb390fc
--- /dev/null
+++ b/2952-minimum-number-of-coins-to-be-added.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} coins
+ * @param {number} target
+ * @return {number}
+ */
+var minimumAddedCoins = function (coins, target) {
+  coins.sort((a, b) => a - b)
+  let currin = 1
+  let res = 0
+
+  for (let coin of coins) {
+    while (coin > currin) {
+      res += 1
+      currin *= 2
+    }
+    currin += coin
+
+    if (currin > target) {
+      break
+    }
+  }
+
+  while (currin <= target) {
+    res += 1
+    currin *= 2
+  }
+
+  return res
+}

From 05874644f42c93be9ed1f586a9db8286c03c59de Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 14:43:15 +0800
Subject: [PATCH 2876/3374] Create 2951-find-the-peaks.js

---
 2951-find-the-peaks.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2951-find-the-peaks.js

diff --git a/2951-find-the-peaks.js b/2951-find-the-peaks.js
new file mode 100644
index 00000000..e564e870
--- /dev/null
+++ b/2951-find-the-peaks.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} mountain
+ * @return {number[]}
+ */
+var findPeaks = function(mountain) {
+  const res = []
+  const n = mountain.length
+  for(let i = 1; i < n - 1; i++) {
+    if(mountain[i] > mountain[i - 1] && mountain[i] > mountain[i + 1]) res.push(i)
+  }
+  
+  return res
+};

From b81744b0cc75909abe2357ed8e14469b12861742 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 17:16:58 +0800
Subject: [PATCH 2877/3374] Create
 2954-count-the-number-of-infection-sequences.js

---
 ...count-the-number-of-infection-sequences.js | 163 ++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 2954-count-the-number-of-infection-sequences.js

diff --git a/2954-count-the-number-of-infection-sequences.js b/2954-count-the-number-of-infection-sequences.js
new file mode 100644
index 00000000..5891fe6a
--- /dev/null
+++ b/2954-count-the-number-of-infection-sequences.js
@@ -0,0 +1,163 @@
+//#region Modulo
+class Modulo {
+  /**
+   * @param {number} modulo
+   */
+  constructor(modulo) {
+    /** @type {number} @readonly */
+    this.modulo = modulo;
+  }
+
+  /**
+   * @param  {...number} numbers
+   */
+  add(...numbers) {
+    let result = 0;
+    for (let number of numbers) {
+      result = (result + (number % this.modulo)) % this.modulo;
+    }
+
+    if (result < 0) result += this.modulo;
+    return result;
+  }
+
+  /**
+   * @private
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  _quickMul(a, b) {
+    a = ((a % this.modulo) + this.modulo) % this.modulo;
+    b = ((b % this.modulo) + this.modulo) % this.modulo;
+    if (a === 0 || b === 0) return 0;
+    if (Math.log2(a) + Math.log2(b) < 50) return (a * b) % this.modulo;
+
+    let result = 0;
+    while (b) {
+      while (b % 2 === 0) {
+        a = (a * 2) % this.modulo;
+        b /= 2;
+      }
+
+      if (b % 2 !== 0) {
+        result = (result + a) % this.modulo;
+        b--;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * @param  {...number} numbers
+   */
+  mul(...numbers) {
+    let result = 1;
+    for (let number of numbers) {
+      result = this._quickMul(result, number);
+      if (result === 0) return 0;
+    }
+
+    if (result < 0) result += this.modulo;
+    return result;
+  }
+
+  /**
+   * @param {number} a
+   * @param {number} b
+   * @returns {number}
+   */
+  pow(a, b) {
+    a = ((a % this.modulo) + this.modulo) % this.modulo;
+    if (a === 0) return 0;
+
+    let result = 1;
+    while (b) {
+      while (b % 2 === 0) {
+        a = this._quickMul(a, a);
+        b /= 2;
+      }
+
+      if (b % 2 !== 0) {
+        result = this._quickMul(result, a);
+        b--;
+      }
+    }
+
+    return result;
+  }
+}
+//#endregion
+
+//#region Division
+/** @private @type {undefined | number} */
+Modulo.prototype._phi = undefined;
+
+/**
+ * @returns {number}
+ */
+Modulo.prototype.getPhi = function () {
+  if (this._phi !== undefined) return this._phi;
+
+  let result = this.modulo;
+  let temp = this.modulo;
+  for (let i = 2; i <= Math.sqrt(temp); i++) {
+    if (temp % i === 0) {
+      result /= i;
+      result *= i - 1;
+    }
+    while (temp % i === 0) temp /= i;
+  }
+  if (temp > 1) {
+    result /= temp;
+    result *= temp - 1;
+  }
+
+  this._phi = result;
+  return result;
+};
+
+/**
+ * @param {number} a
+ * @returns {number}
+ */
+Modulo.prototype.getInverse = function (a) {
+  return this.pow(a, this.getPhi() - 1);
+};
+
+/**
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ */
+Modulo.prototype.div = function (a, b) {
+  return this._quickMul(a, this.getInverse(b));
+};
+//#endregion
+
+let mod = new Modulo(1000000007);
+
+let FACTS = new Uint32Array(100001);
+FACTS[0] = 1;
+for (let i = 1; i <= 1e5; ++i) FACTS[i] = mod.mul(FACTS[i - 1], i);
+
+/**
+ * @param {number} n
+ * @param {number[]} sick
+ * @return {number}
+ */
+var numberOfSequence = function (n, sick) {
+  let m = sick.length;
+  let e = FACTS[n - m];
+  let d = mod.mul(FACTS[sick[0]], FACTS[n - 1 - sick[m - 1]]);
+
+  for (let i = 1; i < m; ++i) {
+    let dis = sick[i] - sick[i - 1] - 1;
+    if (dis <= 1) continue;
+    e = mod.mul(e, mod.pow(2, dis - 1));
+    d = mod.mul(d, FACTS[dis]);
+  }
+
+  return mod.div(e, d);
+};

From 097b9094310330f4a5e1f507957a9888f93af153 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 20:26:33 +0800
Subject: [PATCH 2878/3374] Update 2952-minimum-number-of-coins-to-be-added.js

---
 2952-minimum-number-of-coins-to-be-added.js | 27 +++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2952-minimum-number-of-coins-to-be-added.js b/2952-minimum-number-of-coins-to-be-added.js
index 1fb390fc..e106e731 100644
--- a/2952-minimum-number-of-coins-to-be-added.js
+++ b/2952-minimum-number-of-coins-to-be-added.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} coins
+ * @param {number} target
+ * @return {number}
+ */
+var minimumAddedCoins = function (coins, target) {
+  coins.sort((a, b) => a - b)
+  let current_max = 0;
+  let additions = 0;
+  let index = 0;
+
+  while (current_max < target) {
+      if (index < coins.length && coins[index] <= current_max + 1) {
+          current_max += coins[index];
+          index++;
+      } else {
+          current_max += current_max + 1;
+          additions++;
+      }
+  }
+
+  return additions;
+}
+
+
+// another
+
 /**
  * @param {number[]} coins
  * @param {number} target

From 3eca4642129713961bb27b1962b37018c4b88139 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Dec 2023 20:55:07 +0800
Subject: [PATCH 2879/3374] Update 330-patching-array.js

---
 330-patching-array.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/330-patching-array.js b/330-patching-array.js
index 83e6f9f6..7b101bf8 100644
--- a/330-patching-array.js
+++ b/330-patching-array.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number} n
+ * @return {number}
+ */
+const minPatches = function(nums, n) {
+  const len = nums.length
+  let miss = 1, res = 0, i = 0
+  while(miss <= n) {
+    if(i < len && nums[i] <= miss) {
+      miss += nums[i]
+      i++
+    } else {
+      res++
+      miss += miss
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} n

From 8411e0e3df8a046df923bc818d88722c6e53fc37 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Dec 2023 14:05:00 +0800
Subject: [PATCH 2880/3374] Update
 2940-find-building-where-alice-and-bob-can-meet.js

---
 ...d-building-where-alice-and-bob-can-meet.js | 89 +++++++++----------
 1 file changed, 43 insertions(+), 46 deletions(-)

diff --git a/2940-find-building-where-alice-and-bob-can-meet.js b/2940-find-building-where-alice-and-bob-can-meet.js
index ae2e46db..6a06b0bd 100644
--- a/2940-find-building-where-alice-and-bob-can-meet.js
+++ b/2940-find-building-where-alice-and-bob-can-meet.js
@@ -4,53 +4,50 @@
  * @return {number[]}
  */
 var leftmostBuildingQueries = function (heights, queries) {
-    const st = []
-    const [hs, qs] = [heights, queries]
-    let n = qs.length;
-    let ans = new Array(n).fill(-1);
-    let es = new Array(hs.length).fill().map(() => []);
-    for (let i = 0; i < n; i++) {
-        let x = qs[i][0];
-        let y = qs[i][1];
-        if (x > y) {
-            [x, y] = [y, x];
-        }
-        if (hs[y] > hs[x] || x === y) {
-            ans[i] = y;
-        } else {
-            es[y].push([hs[x], i]);
-        }
+  const st = []
+  const [hs, qs] = [heights, queries]
+  let n = qs.length;
+  let ans = new Array(n).fill(-1);
+  let es = new Array(hs.length).fill().map(() => []);
+  for (let i = 0; i < n; i++) {
+    let x = qs[i][0];
+    let y = qs[i][1];
+    if (x > y) {
+      [x, y] = [y, x];
     }
-
-    for (let i = hs.length - 1; i >= 0; i--) {
-        let n1 = st.length;
-        for (let [x, y] of es[i]) {
-            let p = search(x);
-            if (p < n1 && p >= 0) {
-                ans[y] = st[p][1];
-            }
-        }
-        while (st.length > 0 && st[st.length - 1][0] <= hs[i]) {
-            st.pop();
-        }
-        st.push([hs[i], i]);
+    if (hs[y] > hs[x] || x === y) {
+      ans[i] = y;
+    } else {
+      es[y].push([hs[x], i]);
     }
-    return ans;
-
-  
-     function search(x) {
-        let l = 0;
-        let r = st.length - 1;
-        let ans = -1;
-        while (l <= r) {
-            let m = Math.floor((l + r) / 2);
-            if (st[m][0] > x) {
-                ans = Math.max(ans, m);
-                l = m + 1;
-            } else {
-                r = m - 1;
-            }
-        }
-        return ans;
+  }
+  for (let i = hs.length - 1; i >= 0; i--) {
+    let n1 = st.length;
+    for (let [x, y] of es[i]) {
+      let p = search(x);
+      if (p < n1 && p >= 0) {
+        ans[y] = st[p][1];
+      }
+    }
+    while (st.length > 0 && st[st.length - 1][0] <= hs[i]) {
+      st.pop();
     }
+    st.push([hs[i], i]);
+  }
+  return ans;
+  function search(x) {
+    let l = 0;
+    let r = st.length - 1;
+    let ans = -1;
+    while (l <= r) {
+      let m = Math.floor((l + r) / 2);
+      if (st[m][0] > x) {
+        ans = Math.max(ans, m);
+        l = m + 1;
+      } else {
+        r = m - 1;
+      }
+    }
+    return ans;
+  }
 }

From 31be44413240bcbf9ee817321254ed66fefaea52 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 4 Dec 2023 18:34:08 +0800
Subject: [PATCH 2881/3374] Update
 2940-find-building-where-alice-and-bob-can-meet.js

---
 ...d-building-where-alice-and-bob-can-meet.js | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/2940-find-building-where-alice-and-bob-can-meet.js b/2940-find-building-where-alice-and-bob-can-meet.js
index 6a06b0bd..d32ecd9f 100644
--- a/2940-find-building-where-alice-and-bob-can-meet.js
+++ b/2940-find-building-where-alice-and-bob-can-meet.js
@@ -1,3 +1,110 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[]} heights
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const leftmostBuildingQueries = function(heights, queries) {
+  const n = queries.length, m = heights.length
+  const res = Array(n).fill(-1)
+  const pq = new PQ((a,b) => a[0] < b[0])
+  const que = Array.from({ length: m }, () => Array())
+  for(let i = 0; i < n; i++) {
+    let [a, b] = queries[i];
+    if(a < b && heights[a] < heights[b]) {
+      res[i] = b
+    } else if(a > b && heights[a] > heights[b]) {
+      res[i] = a
+    } else if(a === b) {
+      res[i] = a
+    } else {
+      que[Math.max(a, b)].push([Math.max(heights[a], heights[b]), i])
+    }
+  }
+  
+  for(let i = 0; i < m; i++) {
+    while(!pq.isEmpty() && pq.peek()[0] < heights[i]) {
+      const e = pq.pop()
+      res[e[1]] = i
+    }
+
+    for(const e of que[i]) {
+      pq.push(e)
+    }
+  }
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} heights
  * @param {number[][]} queries

From d9d7eb48e9a7ac923091a2523540ed679ae56a53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Dec 2023 10:32:36 +0800
Subject: [PATCH 2882/3374] Update 85-maximal-rectangle.js

---
 85-maximal-rectangle.js | 48 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/85-maximal-rectangle.js b/85-maximal-rectangle.js
index fd57a2d6..2f06ea31 100644
--- a/85-maximal-rectangle.js
+++ b/85-maximal-rectangle.js
@@ -1,3 +1,51 @@
+/**
+ * @param {character[][]} matrix
+ * @return {number}
+ */
+const maximalRectangle = function(matrix) {
+  const m = matrix.length, n = matrix[0].length
+  const heights = Array(n).fill(0), left = Array(n).fill(0), right = Array(n).fill(n)
+  let res = 0
+  for(let i = 0; i < m; i++) {
+    let l = 0, r = n
+    for(let j = 0; j < n; j++) {
+      if(matrix[i][j] === '1') {
+        heights[j]++
+      } else {
+        heights[j] = 0
+      }
+    }
+
+    for(let j = 0; j < n; j++) {
+      if(matrix[i][j] === '1') {
+        left[j] = Math.max(l, left[j])
+      } else {
+        left[j] = 0
+        l = j + 1
+      }
+    }
+
+    for(let j = n - 1; j >= 0; j--) {
+      if(matrix[i][j] === '1') {
+        right[j] = Math.min(r, right[j])
+      } else {
+        right[j] = n
+        r = j
+      }
+    }
+
+    for(let j = 0; j < n; j++) {
+      res = Math.max(res, heights[j] * (right[j] - left[j]))
+    }
+
+  }
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {character[][]} matrix
  * @return {number}

From 248645d1cc0399463e05e0b831a4249ae70a2b3f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Dec 2023 13:07:04 +0800
Subject: [PATCH 2883/3374] Create
 2945-find-maximum-non-decreasing-array-length.js

---
 ...ind-maximum-non-decreasing-array-length.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2945-find-maximum-non-decreasing-array-length.js

diff --git a/2945-find-maximum-non-decreasing-array-length.js b/2945-find-maximum-non-decreasing-array-length.js
new file mode 100644
index 00000000..95bf4479
--- /dev/null
+++ b/2945-find-maximum-non-decreasing-array-length.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaximumLength = function(nums) {
+   let res = 0
+   const n = nums.length
+   const stk = [[0,0,0]]
+   let pre = 0
+   for(let i = 0, j = 0; i < n; i++) {
+     pre += nums[i]
+     j = Math.min(j, stk.length - 1)
+     while(j + 1 < stk.length && pre >= stk[j + 1][0]) j++
+     const [val, preVal, preDp] = stk[j]
+     const curDp = preDp + 1
+     res = curDp
+     const last = pre - preVal
+     while(stk.length && stk.at(-1)[0] >= last + pre) stk.pop()
+     stk.push([last + pre, pre, curDp])
+   }
+
+   return res
+};

From 00bc41524bf4214d17de4cfeac5ac8b7eed4a4b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Dec 2023 12:16:42 +0800
Subject: [PATCH 2884/3374] Create
 2856-minimum-array-length-after-pair-removals.js

---
 ...inimum-array-length-after-pair-removals.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2856-minimum-array-length-after-pair-removals.js

diff --git a/2856-minimum-array-length-after-pair-removals.js b/2856-minimum-array-length-after-pair-removals.js
new file mode 100644
index 00000000..59dd8e37
--- /dev/null
+++ b/2856-minimum-array-length-after-pair-removals.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minLengthAfterRemovals = function(nums) {
+  const map = new Map(), n = nums.length
+  for(const e of nums) {
+    if(!map.has(e)) map.set(e, 0)
+    map.set(e, map.get(e) + 1)
+  }
+  let maxFreq = 0
+  for(const [k, v] of map) {
+    maxFreq = Math.max(maxFreq, v)
+  }
+  if(maxFreq <= n / 2) {
+    return n % 2
+  }
+  
+  return 2 * maxFreq - n
+};

From d2705d261687f489358b61c87e44060aecc4df68 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Dec 2023 12:40:29 +0800
Subject: [PATCH 2885/3374] Update
 2856-minimum-array-length-after-pair-removals.js

---
 ...inimum-array-length-after-pair-removals.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/2856-minimum-array-length-after-pair-removals.js b/2856-minimum-array-length-after-pair-removals.js
index 59dd8e37..69e868e1 100644
--- a/2856-minimum-array-length-after-pair-removals.js
+++ b/2856-minimum-array-length-after-pair-removals.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minLengthAfterRemovals = function(nums) {
+  const n = nums.length, rightStart = Math.floor((n + 1) / 2)
+  let i = 0, j = rightStart
+  let num = 0
+  while(i < rightStart && j < n) {
+    if(nums[i] < nums[j]) {
+      num += 2
+      i++
+      j++
+    } else j++
+  }
+
+  return n - num
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 1ecbd90de82c248a7a4096174b522fc29914ef2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Dec 2023 13:56:36 +0800
Subject: [PATCH 2886/3374] Update
 2945-find-maximum-non-decreasing-array-length.js

---
 ...ind-maximum-non-decreasing-array-length.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2945-find-maximum-non-decreasing-array-length.js b/2945-find-maximum-non-decreasing-array-length.js
index 95bf4479..44b294ba 100644
--- a/2945-find-maximum-non-decreasing-array-length.js
+++ b/2945-find-maximum-non-decreasing-array-length.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const findMaximumLength = function(nums) {
+  const n = nums.length
+  const stk = [0]
+  const preSum = Array(n + 1).fill(0)
+  const maxLen = Array(n + 1).fill(0)
+  const last = Array(n + 1).fill(0)
+  for(let i = 1; i <= n; i++) {
+    preSum[i] = preSum[i - 1] + nums[i - 1]
+  }
+  // console.log(preSum)
+  let stkPtr = 0
+  last[0] = nums[0]
+  for(let i = 1; i <= n; i++) {
+    stkPtr = Math.min(stkPtr, stk.length - 1)
+    while(stkPtr < stk.length - 1 && preSum[stk[stkPtr + 1]] + last[stk[stkPtr + 1]] <= preSum[i]) stkPtr++
+    const idx = stk[stkPtr]
+    maxLen[i] = maxLen[idx] + 1
+    last[i] = preSum[i] - preSum[idx]
+    while(stk.length && preSum[stk.at(-1)] + last[stk.at(-1)] >= preSum[i] + last[i]) stk.pop()
+    stk.push(i)
+  }
+  // console.log(maxLen)
+  return maxLen[n]
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 322e9f32a957ea117af2f98daa29306a052b3db6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Dec 2023 13:58:47 +0800
Subject: [PATCH 2887/3374] Update
 2945-find-maximum-non-decreasing-array-length.js

---
 2945-find-maximum-non-decreasing-array-length.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/2945-find-maximum-non-decreasing-array-length.js b/2945-find-maximum-non-decreasing-array-length.js
index 44b294ba..1d94bfdb 100644
--- a/2945-find-maximum-non-decreasing-array-length.js
+++ b/2945-find-maximum-non-decreasing-array-length.js
@@ -15,7 +15,6 @@ const findMaximumLength = function(nums) {
   let stkPtr = 0
   last[0] = nums[0]
   for(let i = 1; i <= n; i++) {
-    stkPtr = Math.min(stkPtr, stk.length - 1)
     while(stkPtr < stk.length - 1 && preSum[stk[stkPtr + 1]] + last[stk[stkPtr + 1]] <= preSum[i]) stkPtr++
     const idx = stk[stkPtr]
     maxLen[i] = maxLen[idx] + 1

From 87487a16259b76deb513ee3000df79f1598a389f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Dec 2023 10:55:21 +0800
Subject: [PATCH 2888/3374] Create 2860-happy-students.js

---
 2860-happy-students.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 2860-happy-students.js

diff --git a/2860-happy-students.js b/2860-happy-students.js
new file mode 100644
index 00000000..0ab1d182
--- /dev/null
+++ b/2860-happy-students.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countWays = function(nums) {
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+  let res = 0, num = 0
+  if(nums[0] !== 0) res = 1
+  for(let i = 0; i < n; i++) {
+    num++
+    if(num > nums[i]) {
+      if(i + 1 < n && num < nums[i + 1]) res++
+      else if(i + 1 === n) res++
+    }
+  }
+  return res
+};

From e407860ef53473ec3a80414d92bbfdc8c6e594ae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Dec 2023 19:23:22 +0800
Subject: [PATCH 2889/3374] Create
 2862-maximum-element-sum-of-a-complete-subset-of-indices.js

---
 ...ent-sum-of-a-complete-subset-of-indices.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2862-maximum-element-sum-of-a-complete-subset-of-indices.js

diff --git a/2862-maximum-element-sum-of-a-complete-subset-of-indices.js b/2862-maximum-element-sum-of-a-complete-subset-of-indices.js
new file mode 100644
index 00000000..3489dde0
--- /dev/null
+++ b/2862-maximum-element-sum-of-a-complete-subset-of-indices.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumSum = function(nums) {
+    const n = nums.length;
+    
+    // Find squares 
+    let sq = [1];
+    while(sq.at(-1) < n) sq.push((sq.length+1) ** 2);
+
+    let res = 0;
+    for(let i=1; i<=n; ++i) {
+        let cur = 0;
+        for(const s of sq) { // s*i will give {i*1, i*4, i*9, ...}
+            const idx = s*i;
+            if(idx>n) break;
+            cur += nums[idx-1];
+        }
+        res = Math.max(res, cur);
+    }
+
+    return res;
+};

From 1e400f9d415ba340b44e1e16573b6dfd3dd65ba2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Dec 2023 20:11:46 +0800
Subject: [PATCH 2890/3374] Create
 2960-count-tested-devices-after-test-operations.js

---
 ...count-tested-devices-after-test-operations.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 2960-count-tested-devices-after-test-operations.js

diff --git a/2960-count-tested-devices-after-test-operations.js b/2960-count-tested-devices-after-test-operations.js
new file mode 100644
index 00000000..014419e9
--- /dev/null
+++ b/2960-count-tested-devices-after-test-operations.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} batteryPercentages
+ * @return {number}
+ */
+var countTestedDevices = function(batteryPercentages) {
+  const arr = batteryPercentages
+  const n = arr.length
+  let cnt = 0
+  for(let i = 0; i < n; i++) {
+    const e = Math.max(0, arr[i] - cnt)
+    if(e > 0) {
+      cnt++
+    }
+  }
+  return  cnt
+};

From 90d5259c032af855e5f078c2814c281ca5db6f62 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Dec 2023 20:12:33 +0800
Subject: [PATCH 2891/3374] Create 2961-double-modular-exponentiation.js

---
 2961-double-modular-exponentiation.js | 36 +++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 2961-double-modular-exponentiation.js

diff --git a/2961-double-modular-exponentiation.js b/2961-double-modular-exponentiation.js
new file mode 100644
index 00000000..a6643495
--- /dev/null
+++ b/2961-double-modular-exponentiation.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[][]} variables
+ * @param {number} target
+ * @return {number[]}
+ */
+var getGoodIndices = function (variables, target) {
+  const res = []
+  let index = 0
+  for (let v of variables) {
+    let a = v[0]
+    let b = v[1]
+    let c = v[2]
+    let m = v[3]
+    let x = pw(a, b, 10)
+    let y = pw(x, c, m)
+    // console.log(y)
+    if (y === BigInt(target)) {
+      res.push(index)
+    }
+    index++
+  }
+  return res
+
+  function pw(a, b, m) {
+    let res = 1n
+    a = BigInt(a)
+    while (b) {
+      if (b & 1) {
+        res = (1n * res * a) % BigInt(m)
+      }
+      a = (1n * a * a) % BigInt(m)
+      b >>= 1
+    }
+    return res
+  }
+}

From 87c2c65d673e81a2e1f64fc0a3a60be306f808d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Dec 2023 20:13:00 +0800
Subject: [PATCH 2892/3374] Create
 2962-count-subarrays-where-max-element-appears-at-least-k-times.js

---
 ...re-max-element-appears-at-least-k-times.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 2962-count-subarrays-where-max-element-appears-at-least-k-times.js

diff --git a/2962-count-subarrays-where-max-element-appears-at-least-k-times.js b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
new file mode 100644
index 00000000..c8731fea
--- /dev/null
+++ b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var countSubarrays = function (nums, k) {
+  const n = nums.length
+  const mx = Math.max(...nums)
+  const prefix = new Array(n + 2).fill(0)
+  for (let i = 1; i <= n; i++) {
+    prefix[i] = prefix[i - 1] + (nums[i - 1] === mx ? 1 : 0)
+  }
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    let l = i
+    let r = n
+    while (r - l > 1) {
+      let mid = Math.floor((l + r) / 2)
+      if (prefix[mid + 1] - prefix[i] < k) {
+        l = mid
+      } else {
+        r = mid
+      }
+    }
+    res += n - i
+    if (l === i && k === 1 && nums[i] === mx) {
+      continue
+    }
+    res -= l - i + 1
+  }
+  return res
+}

From e76d9532d3f07c80b2cdf2cdd4b754078a7635be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Dec 2023 20:13:26 +0800
Subject: [PATCH 2893/3374] Create 2963-count-the-number-of-good-partitions.js

---
 2963-count-the-number-of-good-partitions.js | 54 +++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 2963-count-the-number-of-good-partitions.js

diff --git a/2963-count-the-number-of-good-partitions.js b/2963-count-the-number-of-good-partitions.js
new file mode 100644
index 00000000..149c3feb
--- /dev/null
+++ b/2963-count-the-number-of-good-partitions.js
@@ -0,0 +1,54 @@
+class Interval {
+  constructor(left, right) {
+    this.left = left
+    this.right = right
+  }
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var numberOfGoodPartitions = function (nums) {
+  const mod = BigInt(1000000007)
+  const mapFst = new Map()
+  const mapLst = new Map()
+
+  for (let i = 0; i < nums.length; i++) {
+    const item = nums[i]
+    if (mapFst.has(item)) {
+      mapLst.set(item, i)
+    } else {
+      mapFst.set(item, i)
+    }
+  }
+
+  const l = []
+  for (const key of mapLst.keys()) {
+    l.push(new Interval(mapFst.get(key), mapLst.get(key)))
+  }
+  l.sort((a, b) => a.left - b.left)
+
+  const st = []
+  for (let i = 0; i < l.length; i++) {
+    const cur = l[i]
+    if (st.length === 0) {
+      st.push(cur)
+    } else {
+      const pre = st.pop()
+      if (cur.left < pre.right) {
+        st.push(new Interval(pre.left, Math.max(pre.right, cur.right)))
+      } else {
+        st.push(pre)
+        st.push(cur)
+      }
+    }
+  }
+
+  let n = nums.length - 1
+  while (st.length > 0) {
+    const item = st.pop()
+    n -= item.right - item.left
+  }
+
+  return BigInt(2) ** BigInt(n) % mod
+}

From 41945beefc779febc3ee2e788b3a91b20773d351 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Dec 2023 11:06:52 +0800
Subject: [PATCH 2894/3374] Create 2680-maximum-or.js

---
 2680-maximum-or.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2680-maximum-or.js

diff --git a/2680-maximum-or.js b/2680-maximum-or.js
new file mode 100644
index 00000000..99d1130f
--- /dev/null
+++ b/2680-maximum-or.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumOr = function(nums, k) {
+  let base = 0n, backup = 0n, best = 0n;
+  k = BigInt(k)
+  for (let num of nums) {
+    num = BigInt(num)
+    backup |= base & num;
+    base |= num;
+  }
+  for (let num of nums) {
+    num = BigInt(num)
+    best = max(best, base - num | backup | num << k);
+  }
+  return Number(best);    
+};
+
+function max(a, b) {
+  return a > b ? a : b
+}

From 1d23d7f02c0264b007910f4075bc926cf17669e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Dec 2023 11:29:19 +0800
Subject: [PATCH 2895/3374] Update 2680-maximum-or.js

---
 2680-maximum-or.js | 38 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2680-maximum-or.js b/2680-maximum-or.js
index 99d1130f..8a5abec4 100644
--- a/2680-maximum-or.js
+++ b/2680-maximum-or.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumOr = function(nums, k) {
+  let res = 0n
+  const n = nums.length, pre = Array(n).fill(0), suf = Array(n).fill(0)
+  pre[0] = nums[0]
+  suf[n - 1] = nums.at(-1)
+  for(let i = 1; i < n; i++) {
+    const e = nums[i]
+    pre[i] = pre[i - 1] | e
+    suf[n - 1 - i] = suf[n - i] | nums[n - 1 - i]
+  }
+
+  k = bi(k)
+  for(let i = 0; i < n; i++) {
+    const e = bi(nums[i])
+    let tmp = e << k
+    if(i - 1 >= 0) tmp |= bi(pre[i - 1])
+    if(i + 1 < n) tmp |= bi(suf[i + 1])
+
+    res = max(res, tmp)
+  }
+
+  return Number(res)
+};
+function bi(num) {
+  return BigInt(num)
+}
+function max(a, b) {
+  return a > b ? a : b
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 30cb61d17d9800a2c2f350b67c2cb7a97b53aa15 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Dec 2023 21:12:10 +0800
Subject: [PATCH 2896/3374] Update
 1625-lexicographically-smallest-string-after-applying-operations.js

---
 ...allest-string-after-applying-operations.js | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
index f624d743..ed184351 100644
--- a/1625-lexicographically-smallest-string-after-applying-operations.js
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -1,3 +1,49 @@
+/**
+ * @param {string} s
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */ 
+const findLexSmallestString = function(s, a, b) {
+  let res = s
+  const visited = new Set()
+  dfs(s)
+  return res
+  
+  function dfs(str) {
+    if(isVisited(str)) return
+    visit(str)
+    dfs(add(str))
+    dfs(rotate(str))
+  }
+  
+  function isVisited(str) {
+    return visited.has(str)
+  }
+  
+  function visit(str) {
+    if(str < res) res = str
+    visited.add(str)
+  }
+  
+  function add(str) {
+    const arr = str.split('').map(e => +e)
+    for(let i = 1; i < str.length; i += 2) {
+      arr[i] = (arr[i] + a) % 10
+    }
+    return arr.join('')
+  }
+  
+  function rotate(str) {
+    const n = str.length
+    const len = b % str.length
+    const pre = str.slice(0,n - len), suf = str.slice(n - len)
+    return `${suf}${pre}`
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {number} a

From e88019b1b341c3bfe5bd0b23623103c597c51690 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 15 Dec 2023 12:38:25 +0800
Subject: [PATCH 2897/3374] Update
 795-number-of-subarrays-with-bounded-maximum.js

---
 ...umber-of-subarrays-with-bounded-maximum.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/795-number-of-subarrays-with-bounded-maximum.js b/795-number-of-subarrays-with-bounded-maximum.js
index beb84f9d..61e17d9d 100644
--- a/795-number-of-subarrays-with-bounded-maximum.js
+++ b/795-number-of-subarrays-with-bounded-maximum.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} left
+ * @param {number} right
+ * @return {number}
+ */
+const numSubarrayBoundedMax = function(nums, left, right) {
+  let prev = -1, res = 0, dp = 0
+  const n = nums.length
+
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    if(e < left) {
+    
+    } else if(e > right) {
+      prev = i
+      dp = 0
+    } else {
+      dp = i - prev
+    }
+
+    res += dp
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} L

From fd8d20f2ad8da34b9ea143899a521cbb7a7d09b1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Dec 2023 11:24:54 +0800
Subject: [PATCH 2898/3374] Create
 2968-apply-operations-to-maximize-frequency-score.js

---
 ...-operations-to-maximize-frequency-score.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 2968-apply-operations-to-maximize-frequency-score.js

diff --git a/2968-apply-operations-to-maximize-frequency-score.js b/2968-apply-operations-to-maximize-frequency-score.js
new file mode 100644
index 00000000..a1f407e6
--- /dev/null
+++ b/2968-apply-operations-to-maximize-frequency-score.js
@@ -0,0 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxFrequencyScore = function (nums, k) {
+  nums.sort((a, b) => a - b)
+
+  const n = nums.length
+  const prefixSum = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; ++i) {
+    prefixSum[i + 1] = prefixSum[i] + nums[i]
+  }
+
+  let start = 0
+  let end = 1
+  let maxScore = 1
+
+  while (end < n) {
+    ++end
+    const mid = Math.floor((start + end) / 2)
+    const target = nums[mid]
+    let cost =
+      target * (mid - start) -
+      (prefixSum[mid] - prefixSum[start]) +
+      (prefixSum[end] - prefixSum[mid] - target * (end - mid))
+
+    while (start < end && cost > k) {
+      ++start
+      const mid = Math.floor((start + end) / 2)
+      const target = nums[mid]
+      cost =
+        target * (mid - start) -
+        (prefixSum[mid] - prefixSum[start]) +
+        (prefixSum[end] - prefixSum[mid] - target * (end - mid))
+    }
+
+    maxScore = Math.max(maxScore, end - start)
+  }
+
+  return maxScore
+}

From 1319977302d2bf545e9b7d4b778612060114e00f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Dec 2023 11:25:54 +0800
Subject: [PATCH 2899/3374] Create
 2967-minimum-cost-to-make-array-equalindromic.js

---
 ...inimum-cost-to-make-array-equalindromic.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 2967-minimum-cost-to-make-array-equalindromic.js

diff --git a/2967-minimum-cost-to-make-array-equalindromic.js b/2967-minimum-cost-to-make-array-equalindromic.js
new file mode 100644
index 00000000..2ec531c4
--- /dev/null
+++ b/2967-minimum-cost-to-make-array-equalindromic.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumCost = function (nums) {
+  nums.sort((a, b) => a - b)
+  let costs = []
+  let numbersPalindromic = getPalindromic(nums[Math.floor(nums.length / 2)])
+  for (let i = 0; i < numbersPalindromic.length; i++) {
+    costs.push(caculateCost(nums, numbersPalindromic[i]))
+  }
+  return Math.min(...costs)
+}
+
+function getPalindromic(number) {
+  let numbers = []
+  let nextNumber = number
+  let prevNumber = number
+  while (numbers.length <= 2) {
+    if (reverseString(nextNumber.toString()) === nextNumber.toString()) {
+      numbers.push(nextNumber)
+    }
+    if (reverseString(prevNumber.toString()) === prevNumber.toString()) {
+      numbers.push(prevNumber)
+    }
+    nextNumber++
+    prevNumber--
+  }
+  return numbers
+}
+
+function caculateCost(nums, palindromic) {
+  let cost = 0
+  for (let i = 0; i < nums.length; i++) {
+    cost += Math.abs(nums[i] - palindromic)
+  }
+  return cost
+}
+
+function reverseString(str) {
+  return str.split('').reverse().join('')
+}

From c8114352044c69223ab9a38effb29617cd1269e7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Dec 2023 11:26:32 +0800
Subject: [PATCH 2900/3374] Create
 2966-divide-array-into-arrays-with-max-difference.js

---
 ...e-array-into-arrays-with-max-difference.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 2966-divide-array-into-arrays-with-max-difference.js

diff --git a/2966-divide-array-into-arrays-with-max-difference.js b/2966-divide-array-into-arrays-with-max-difference.js
new file mode 100644
index 00000000..a6bf20b2
--- /dev/null
+++ b/2966-divide-array-into-arrays-with-max-difference.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number[][]}
+ */
+const divideArray = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  const res = [], n = nums.length
+  for(let i = 2; i < n; i += 3) {
+    if(nums[i] - nums[i - 2] > k) {
+      return res
+    }
+  }
+  for(let i = 0; i < n;) {
+    const tmp = []
+    let num = 3
+    while(num) {
+      tmp.push(nums[i])
+      i++
+      num--
+    }
+    res.push(tmp)
+  }
+  return res
+};

From a715752c6309d764ceb7c434f364964f05c24ccd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Dec 2023 11:27:13 +0800
Subject: [PATCH 2901/3374] Create 2965-find-missing-and-repeated-values.js

---
 2965-find-missing-and-repeated-values.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 2965-find-missing-and-repeated-values.js

diff --git a/2965-find-missing-and-repeated-values.js b/2965-find-missing-and-repeated-values.js
new file mode 100644
index 00000000..11c0b988
--- /dev/null
+++ b/2965-find-missing-and-repeated-values.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[][]} grid
+ * @return {number[]}
+ */
+var findMissingAndRepeatedValues = function(grid) {
+  const hash = {}, res = []
+  const m = grid.length, n = grid[0].length
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      const e = grid[i][j]
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+      if(hash[e] === 2) res[0] = e
+    }
+  }
+  for(let i = 1; i <= n * n; i++) {
+    if(hash[i] == null) res[1] = i
+  }
+  return res
+};

From 531115b741a55c24402b1cd1aacf1457bdfa9440 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Dec 2023 13:17:02 +0800
Subject: [PATCH 2902/3374] Update 2768-number-of-black-blocks.js

---
 2768-number-of-black-blocks.js | 48 ++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/2768-number-of-black-blocks.js b/2768-number-of-black-blocks.js
index 48067a99..241fd1fe 100644
--- a/2768-number-of-black-blocks.js
+++ b/2768-number-of-black-blocks.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} coordinates
+ * @return {number[]}
+ */
+const countBlackBlocks = function(m, n, coordinates) {
+  const hash = {}
+  const key = ([x, y]) => `${x},${y}`
+  for (const e of coordinates) {
+    const [x, y] = e
+    if(x === m - 1 && y === n - 1) {
+      if(hash[`${x - 1},${y - 1}`]==null) hash[`${x - 1},${y - 1}`] = 0
+      hash[`${x - 1},${y - 1}`]++       
+    } else if(x === m - 1) {
+      if(hash[`${x - 1},${y - 1}`]==null) hash[`${x - 1},${y - 1}`] = 0
+      if(hash[`${x - 1},${y}`]==null) hash[`${x - 1},${y}`] = 0
+      hash[`${x - 1},${y}`]++
+      hash[`${x - 1},${y - 1}`]++
+    } else if(y === n - 1) {
+      if(hash[`${x - 1},${y - 1}`]==null) hash[`${x - 1},${y - 1}`] = 0
+      if(hash[`${x},${y- 1}`]==null) hash[`${x},${y-1}`] = 0
+      hash[`${x},${y-1}`]++
+      hash[`${x-1},${y - 1}`]++
+    } else {
+      if(hash[`${x - 1},${y - 1}`]==null) hash[`${x - 1},${y - 1}`] = 0
+      if(hash[`${x},${y- 1}`]==null) hash[`${x},${y-1}`] = 0
+      if(hash[`${x - 1},${y}`]==null) hash[`${x - 1},${y}`] = 0
+      if(hash[`${x},${y}`]==null) hash[`${x},${y}`] = 0
+      hash[`${x},${y}`]++
+      hash[`${x},${y-1}`]++
+      hash[`${x-1},${y}`]++
+      hash[`${x-1},${y - 1}`]++
+    }
+  }
+  // console.log(hash)
+  const res = Array(5).fill(0)
+  for(const [k, v] of Object.entries(hash)) {
+    const [x, y] = k.split(',').map(e => +e)
+    if(x >= 0 && y >= 0) res[v]++
+  }
+  const sum = res.reduce((ac, e) => ac + e, 0)
+  res[0] = (m - 1) * (n - 1) - sum
+  return res
+};
+
+// another
+
 /**
  * @param {number} m
  * @param {number} n

From 418dc8e0a7080d06660929eed5446bd8545e4570 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Dec 2023 12:19:54 +0800
Subject: [PATCH 2903/3374] Create
 2857-count-pairs-of-points-with-distance-k.js

---
 2857-count-pairs-of-points-with-distance-k.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2857-count-pairs-of-points-with-distance-k.js

diff --git a/2857-count-pairs-of-points-with-distance-k.js b/2857-count-pairs-of-points-with-distance-k.js
new file mode 100644
index 00000000..bff65742
--- /dev/null
+++ b/2857-count-pairs-of-points-with-distance-k.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[][]} coordinates
+ * @param {number} k
+ * @return {number}
+ */
+const countPairs = function(coordinates, k) {
+  const hash = new Map()
+  const n = coordinates.length
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const [x, y] = coordinates[i]
+    for(let v = 0; v <= k; v++) {
+      const xx = v ^ x
+      const yy = (k - v) ^ y
+      const key = `${xx},${yy}`
+      res += hash.get(key) || 0
+    }
+    const kk = `${x},${y}`
+    hash.set(kk, (hash.get(kk) || 0) + 1)
+  }
+  
+  return res
+};

From f56e26536535f0c1351bf01f038a9c83126a8e06 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Dec 2023 14:54:15 +0800
Subject: [PATCH 2904/3374] Create
 1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.js

---
 ...er-of-neighbors-at-a-threshold-distance.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.js

diff --git a/1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.js b/1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.js
new file mode 100644
index 00000000..d728de89
--- /dev/null
+++ b/1334-find-the-city-with-the-smallest-number-of-neighbors-at-a-threshold-distance.js
@@ -0,0 +1,42 @@
+function floyd_warshall (n, edges, start) {
+  let d = [...Array(n)].map(() => Array(n).fill(Number.MAX_SAFE_INTEGER))
+  for (const [u, v, cost] of edges) {
+    // UG
+    let c = cost == undefined ? 1 : cost
+    d[u][v] = d[v][u] = c
+  }
+  // for (const [u, v, cost] of edges) d[u][v] = cost == undefined ? 1 : cost; // DG
+  for (let i = start; i < n; i++) d[i][i] = 0
+  for (let k = start; k < n; k++) {
+    for (let i = start; i < n; i++) {
+      for (let j = start; j < n; j++) {
+        if (d[i][j] > d[i][k] + d[k][j]) d[i][j] = d[i][k] + d[k][j]
+      }
+    }
+  }
+  return d
+}
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} distanceThreshold
+ * @return {number}
+ */
+const findTheCity = function(n, edges, distanceThreshold) {
+  let dis = floyd_warshall(n, edges, 0),
+  res = []
+  for (let start = 0; start < n; start++) {
+    let canReach = new Set()
+    for (let dest = 0; dest < n; dest++) {
+      if (start == dest) continue
+      if (dis[start][dest] <= distanceThreshold) canReach.add(dest)
+    }
+    res.push([start, canReach.size])
+  }
+  res.sort((x, y) => {
+    if (x[1] != y[1]) return x[1] - y[1]
+    return y[0] - x[0]
+  })
+  return res[0][0]
+}
+

From ffea6bf69240c48ff3849690f7a9fbd9fd115acd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Dec 2023 20:36:07 +0800
Subject: [PATCH 2905/3374] Update 391-perfect-rectangle.js

---
 391-perfect-rectangle.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/391-perfect-rectangle.js b/391-perfect-rectangle.js
index a6b001fa..d58a967f 100644
--- a/391-perfect-rectangle.js
+++ b/391-perfect-rectangle.js
@@ -21,3 +21,35 @@ const isRectangleCover = function(rectangles) {
   }
   return tls.size === 1 && trs.size === 1 && bls.size === 1 && brs.size === 1
 }
+
+// another
+
+/**
+ * @param {number[][]} rectangles
+ * @return {boolean}
+ */
+var isRectangleCover = function(rectangles) {
+  const n =  rectangles.length
+  const rects = rectangles, set = new Set()
+  let area = 0
+  const p = (x, y) => `${x},${y}`
+  let xmin = Infinity, xmax = -Infinity, ymin = Infinity, ymax = -Infinity
+  for(const [x,y,a,b] of rects) {
+    xmin = Math.min(xmin, x)
+    xmax = Math.max(xmax, a)
+    ymin = Math.min(ymin, y)
+    ymax = Math.max(ymax, b)
+    area += (a - x) * (b - y)
+    const p0 = p(x,y), p1 = p(a,b),p2=p(x,b),p3=p(a,y)
+    if(set.has(p0)) set.delete(p0)
+    else set.add(p0)
+    if(set.has(p1)) set.delete(p1)
+    else set.add(p1)
+    if(set.has(p2)) set.delete(p2)
+    else set.add(p2)
+    if(set.has(p3)) set.delete(p3)
+    else set.add(p3)
+  }
+  if(set.size !== 4 || !set.has(p(xmin, ymin)) || !set.has(p(xmax, ymax)) || !set.has(p(xmin, ymax)) || !set.has(p(xmax, ymin)) ) return false
+  return area === (xmax - xmin) * (ymax - ymin)
+};

From f6255faa2d7c3bdcea403c2dd71787a4a5ddb993 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Dec 2023 11:53:43 +0800
Subject: [PATCH 2906/3374] Update
 2642-design-graph-with-shortest-path-calculator.js

---
 ...ign-graph-with-shortest-path-calculator.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/2642-design-graph-with-shortest-path-calculator.js b/2642-design-graph-with-shortest-path-calculator.js
index 2d1a48d4..41a0be10 100644
--- a/2642-design-graph-with-shortest-path-calculator.js
+++ b/2642-design-graph-with-shortest-path-calculator.js
@@ -77,3 +77,59 @@ Graph.prototype.shortestPath = function (node1, node2) {
  * obj.addEdge(edge)
  * var param_2 = obj.shortestPath(node1,node2)
  */
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ */
+const Graph = function(n, edges) {
+  const matrix = Array.from({ length: n }, () => Array(n).fill(1e12))
+  this.mat = matrix
+  this.n = n
+  for(let i = 0; i < n; i++) {
+    this.mat[i][i] = 0
+  }
+  for(const [u,v,c] of edges) {
+    this.mat[u][v] = c
+  }
+  for(let k = 0; k < n; k++) {
+    for(let i = 0; i < n; i++) {
+      for(let j = 0; j < n; j++) {
+        this.mat[i][j] = Math.min(this.mat[i][j], this.mat[i][k] + this.mat[k][j])
+      } 
+    }
+  }
+};
+
+/** 
+ * @param {number[]} edge
+ * @return {void}
+ */
+Graph.prototype.addEdge = function(edge) {
+  const [u, v, c] = edge
+  this.mat[u][v] = Math.min(this.mat[u][v], c)
+  const n = this.n
+  for(let i = 0; i < n; i++) {
+    for(let j = 0; j < n; j++) {
+      this.mat[i][j] = Math.min(this.mat[i][j], this.mat[i][u] + this.mat[v][j] + c)
+    } 
+  }
+};
+
+/** 
+ * @param {number} node1 
+ * @param {number} node2
+ * @return {number}
+ */
+Graph.prototype.shortestPath = function(node1, node2) {
+  return this.mat[node1][node2] === 1e12 ? -1 : this.mat[node1][node2]
+};
+
+/** 
+ * Your Graph object will be instantiated and called as such:
+ * var obj = new Graph(n, edges)
+ * obj.addEdge(edge)
+ * var param_2 = obj.shortestPath(node1,node2)
+ */

From 06d84ebf539293f35a18b3bb0b60209623c133bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Dec 2023 16:37:54 +0800
Subject: [PATCH 2907/3374] Create
 2959-number-of-possible-sets-of-closing-branches.js

---
 ...er-of-possible-sets-of-closing-branches.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2959-number-of-possible-sets-of-closing-branches.js

diff --git a/2959-number-of-possible-sets-of-closing-branches.js b/2959-number-of-possible-sets-of-closing-branches.js
new file mode 100644
index 00000000..5a070465
--- /dev/null
+++ b/2959-number-of-possible-sets-of-closing-branches.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number} n
+ * @param {number} maxDistance
+ * @param {number[][]} roads
+ * @return {number}
+ */
+const numberOfSets = function(n, maxDistance, roads) {
+    let res = 0;
+    for(let i = 0; i < 1 << n; i++) {
+        let g = Array.from({ length: n }, () => Array(n).fill(1e9));
+        for(let j = 0; j < roads.length; j++) {
+            let [x, y, w] = roads[j];
+            if((i >> x & 1) && (i >> y & 1)) {
+                g[x][y] = g[y][x] = Math.min(g[x][y], w);
+            }
+        }
+        for(let j = 0; j < n; j++) {
+            g[j][j] = 0;
+        }
+        for(let p = 0; p < n; p++) {
+            for(let q = 0; q < n; q++) {
+                for(let k = 0; k < n; k++) {
+                    g[q][k] = Math.min(g[q][k], g[q][p] + g[p][k]);
+                }
+            }
+        }
+        let ok = 1;
+        for(let j = 0; j < n; j++) {
+            for(let k = 0; k < n; k++) {
+                if((i >> j & 1) && (i >> k & 1)) {
+                    ok &= (g[j][k] <= maxDistance);
+                }
+            }
+        }
+        res += ok;
+    }
+    return res; 
+};

From 636e8e760e0e0390b2afa08cc587eab5c5866b3e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Dec 2023 19:40:44 +0800
Subject: [PATCH 2908/3374] Update
 2959-number-of-possible-sets-of-closing-branches.js

---
 ...er-of-possible-sets-of-closing-branches.js | 56 ++++++++++---------
 1 file changed, 29 insertions(+), 27 deletions(-)

diff --git a/2959-number-of-possible-sets-of-closing-branches.js b/2959-number-of-possible-sets-of-closing-branches.js
index 5a070465..2c497516 100644
--- a/2959-number-of-possible-sets-of-closing-branches.js
+++ b/2959-number-of-possible-sets-of-closing-branches.js
@@ -5,34 +5,36 @@
  * @return {number}
  */
 const numberOfSets = function(n, maxDistance, roads) {
-    let res = 0;
-    for(let i = 0; i < 1 << n; i++) {
-        let g = Array.from({ length: n }, () => Array(n).fill(1e9));
-        for(let j = 0; j < roads.length; j++) {
-            let [x, y, w] = roads[j];
-            if((i >> x & 1) && (i >> y & 1)) {
-                g[x][y] = g[y][x] = Math.min(g[x][y], w);
-            }
-        }
-        for(let j = 0; j < n; j++) {
-            g[j][j] = 0;
-        }
-        for(let p = 0; p < n; p++) {
-            for(let q = 0; q < n; q++) {
-                for(let k = 0; k < n; k++) {
-                    g[q][k] = Math.min(g[q][k], g[q][p] + g[p][k]);
-                }
-            }
+  let res = 0
+  const {min} = Math
+  for(let i = 0, limit = 1<<n; i < limit; i++) {
+    const mat = Array.from({ length: n }, () => Array(n).fill(1e9))
+    for(const [u,v,w] of roads) {
+      if( (1 & (i >> u)) && (1 & (i >> v))) {
+        mat[u][v] = mat[v][u] = min(w, mat[u][v])
+      }
+    }
+    for(let x = 0; x < n; x++) mat[x][x] = 0
+
+    for(let k = 0; k < n; k++) {
+      for(let x = 0; x < n; x++) {
+        for(let y = 0; y < n; y++) {
+          mat[x][y] = min(mat[x][y], mat[x][k] + mat[k][y])
         }
-        let ok = 1;
-        for(let j = 0; j < n; j++) {
-            for(let k = 0; k < n; k++) {
-                if((i >> j & 1) && (i >> k & 1)) {
-                    ok &= (g[j][k] <= maxDistance);
-                }
-            }
+      }
+    }
+
+    let tmp = true
+    for(let x = 0; x < n; x++) {
+      for(let y = 0; y < n; y++) {
+        if( (1 & (i >> x)) && (1 & (i >> y))) {
+          tmp &= mat[x][y] <= maxDistance
         }
-        res += ok;
+      }
     }
-    return res; 
+
+    res += tmp ? 1 : 0
+  }
+  
+  return res
 };

From 17ecb6269a5568d9563e1255a72ef612630bdf3a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Dec 2023 19:00:17 +0800
Subject: [PATCH 2909/3374] Update 743-network-delay-time.js

---
 743-network-delay-time.js | 55 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/743-network-delay-time.js b/743-network-delay-time.js
index bf562c67..893d1432 100644
--- a/743-network-delay-time.js
+++ b/743-network-delay-time.js
@@ -1,3 +1,58 @@
+/**
+ * @param {number[][]} times
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const networkDelayTime = function(times, n, k) {
+  const g = Array.from({ length: n + 1 }, () => Array(n + 1).fill(Infinity))
+  const graph = {} 
+  for(const [u,v,w] of times) {
+    if(graph[u] == null) graph[u] = {}
+    graph[u][v] = w
+    g[u][v] = w
+  }
+  for(let k = 1; k <= n; k++) {
+    for(let i = 1; i <= n; i++) {
+      for(let j = 1; j <= n; j++) {
+        g[i][j] = Math.min(g[i][j], g[i][k] + g[k][j])
+      }
+    }
+  }
+
+  let q = [k]
+  const visited = new Set()
+  const dis = Array(n + 1).fill(Infinity)
+  let res = 0
+  dis[k] = 0
+  // console.log(g)
+  while(q.length) {
+    const size = q.length, tmp = []
+    for(let i = 0; i < size; i++) {
+      const e = q[i]
+      visited.add(e)
+      for(let nxt of (Object.keys(graph[e] || {}) || [])) {
+        nxt = +nxt
+        if(!visited.has(nxt)) {
+          tmp.push(nxt)
+        }
+        if(g[e][nxt]) dis[nxt] = Math.min(dis[nxt], dis[e] + g[e][nxt])
+      }
+    }
+
+    q = tmp
+  }
+  // console.log(dis)
+  for(let i = 1; i <= n; i++) {
+    if(i === k) continue
+    res = Math.max(res, dis[i])
+  }
+
+  return visited.size === n ? res : -1
+};
+
+// another
+
 /**
  * @param {number[][]} times
  * @param {number} n

From ac8208885efa3210863256501fe37e60b22bf404 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Dec 2023 13:08:32 +0800
Subject: [PATCH 2910/3374] Create 2977-minimum-cost-to-convert-string-ii.js

---
 2977-minimum-cost-to-convert-string-ii.js | 78 +++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 2977-minimum-cost-to-convert-string-ii.js

diff --git a/2977-minimum-cost-to-convert-string-ii.js b/2977-minimum-cost-to-convert-string-ii.js
new file mode 100644
index 00000000..6246f37f
--- /dev/null
+++ b/2977-minimum-cost-to-convert-string-ii.js
@@ -0,0 +1,78 @@
+/**
+ * @param {string} source
+ * @param {string} target
+ * @param {string[]} original
+ * @param {string[]} changed
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minimumCost = function (source, target, original, changed, cost) {
+  const index = {}
+  original.forEach((o) => {
+    if (!(o in index)) {
+      index[o] = Object.keys(index).length
+    }
+  })
+  changed.forEach((c) => {
+    if (!(c in index)) {
+      index[c] = Object.keys(index).length
+    }
+  })
+
+  const n = Object.keys(index).length
+  const dis = new Array(n)
+    .fill(null)
+    .map(() => new Array(n).fill(Number.POSITIVE_INFINITY))
+
+  for (let i = 0; i < cost.length; ++i) {
+    dis[index[original[i]]][index[changed[i]]] = Math.min(
+      dis[index[original[i]]][index[changed[i]]],
+      cost[i],
+    )
+  }
+
+  for (let k = 0; k < n; ++k) {
+    for (let i = 0; i < n; ++i) {
+      if (dis[i][k] < Number.POSITIVE_INFINITY) {
+        for (let j = 0; j < n; ++j) {
+          if (dis[k][j] < Number.POSITIVE_INFINITY) {
+            dis[i][j] = Math.min(dis[i][j], dis[i][k] + dis[k][j])
+          }
+        }
+      }
+    }
+  }
+
+  const substrLengths = new Set(original.map((o) => o.length))
+
+  const dp = new Array(target.length + 1).fill(Number.POSITIVE_INFINITY)
+  dp[0] = 0
+
+  for (let i = 0; i < target.length; ++i) {
+    if (dp[i] === Number.POSITIVE_INFINITY) {
+      continue
+    }
+
+    if (target[i] === source[i]) {
+      dp[i + 1] = Math.min(dp[i + 1], dp[i])
+    }
+
+    for (const t of substrLengths) {
+      if (i + t >= dp.length) {
+        continue
+      }
+
+      const subSource = source.substring(i, i + t)
+      const subTarget = target.substring(i, i + t)
+
+      const c1 = subSource in index ? index[subSource] : -1
+      const c2 = subTarget in index ? index[subTarget] : -1
+
+      if (c1 >= 0 && c2 >= 0 && dis[c1][c2] < Number.POSITIVE_INFINITY) {
+        dp[i + t] = Math.min(dp[i + t], dp[i] + dis[c1][c2])
+      }
+    }
+  }
+
+  return dp[dp.length - 1] !== Number.POSITIVE_INFINITY ? dp[dp.length - 1] : -1
+}

From 389da8f344a4aa142180716a970bf992bf1c479c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Dec 2023 13:09:03 +0800
Subject: [PATCH 2911/3374] Create 2976-minimum-cost-to-convert-string-i.js

---
 2976-minimum-cost-to-convert-string-i.js | 39 ++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2976-minimum-cost-to-convert-string-i.js

diff --git a/2976-minimum-cost-to-convert-string-i.js b/2976-minimum-cost-to-convert-string-i.js
new file mode 100644
index 00000000..bccec13d
--- /dev/null
+++ b/2976-minimum-cost-to-convert-string-i.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} source
+ * @param {string} target
+ * @param {character[]} original
+ * @param {character[]} changed
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minimumCost = function(source, target, original, changed, cost) {
+   const mat = Array.from({ length: 26 }, () => Array(26).fill(Number.MAX_SAFE_INTEGER))
+   const a = 'a'.charCodeAt(0)
+   const len = cost.length
+   for(let i = 0; i < len; i++) {
+     const u = original[i].charCodeAt(0) - a
+     const v = changed[i].charCodeAt(0) - a
+     const w = cost[i]
+     mat[u][v] = Math.min(w, mat[u][v])
+   }
+   for(let i = 0; i < 26; i++) mat[i][i] = 0
+   
+   for(let k = 0; k < 26; k++) {
+     for(let i = 0; i < 26; i++) {
+       for(let j = 0; j < 26; j++) {
+         mat[i][j] = Math.min(mat[i][j], mat[i][k] + mat[k][j])
+       }
+     }
+   }
+  
+   let res = 0
+   const n = source.length
+   for(let i = 0; i < n; i++) {
+     const u = source[i].charCodeAt(0) - a
+     const v = target[i].charCodeAt(0) - a
+     if(mat[u][v] === Number.MAX_SAFE_INTEGER) return -1
+     res += mat[u][v]
+   }
+   
+   return res
+};

From a16354a1aa3f03370db14b0fb140300efa1aaa58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Dec 2023 13:09:28 +0800
Subject: [PATCH 2912/3374] Create
 2975-maximum-square-area-by-removing-fences-from-a-field.js

---
 ...re-area-by-removing-fences-from-a-field.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 2975-maximum-square-area-by-removing-fences-from-a-field.js

diff --git a/2975-maximum-square-area-by-removing-fences-from-a-field.js b/2975-maximum-square-area-by-removing-fences-from-a-field.js
new file mode 100644
index 00000000..8cca4a09
--- /dev/null
+++ b/2975-maximum-square-area-by-removing-fences-from-a-field.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[]} hFences
+ * @param {number[]} vFences
+ * @return {number}
+ */
+const maximizeSquareArea = function (m, n, hFences, vFences) {
+  hFences.sort((a, b) => a - b)
+  vFences.sort((a, b) => a - b)
+  const hSet = new Set(),
+    vSet = new Set()
+
+  const mod = 10 ** 9 + 7
+
+  hFences.unshift(1)
+  hFences.push(m)
+  vFences.unshift(1)
+  vFences.push(n)
+  for (let i = 0; i < vFences.length; i++) {
+    for (let j = i + 1; j < vFences.length; j++) {
+      vSet.add(vFences[j] - vFences[i])
+    }
+  }
+  for (let i = 0; i < hFences.length; i++) {
+    for (let j = i + 1; j < hFences.length; j++) {
+      hSet.add(hFences[j] - hFences[i])
+    }
+  }
+
+  let max = -1
+  for (const v of vSet) {
+    if (hSet.has(v)) {
+      max = Math.max(max, v)
+    }
+  }
+  if (max === -1) return -1
+
+  return Number((BigInt(max) * BigInt(max)) % BigInt(mod))
+}

From a2b78218a8b8fcf4b80f0f6dbd912d9e23e9ea3b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Dec 2023 13:09:59 +0800
Subject: [PATCH 2913/3374] Create 2974-minimum-number-game.js

---
 2974-minimum-number-game.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 2974-minimum-number-game.js

diff --git a/2974-minimum-number-game.js b/2974-minimum-number-game.js
new file mode 100644
index 00000000..81bfdcfb
--- /dev/null
+++ b/2974-minimum-number-game.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var numberGame = function(nums) {
+  nums.sort((a, b) => a - b)
+  const res = []
+  for(let i = 0; i < nums.length - 1; i+=2) {
+    const a = nums[i], b = nums[i + 1]
+    res.push(b, a)
+  }
+  return res
+};

From cf27a137173719d67a9d1a636adf96c268aaeb6f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Dec 2023 11:00:48 +0800
Subject: [PATCH 2914/3374] Update 407-trapping-rain-water-ii.js

---
 407-trapping-rain-water-ii.js | 104 ++++++++++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/407-trapping-rain-water-ii.js b/407-trapping-rain-water-ii.js
index 21892090..31ef3c93 100644
--- a/407-trapping-rain-water-ii.js
+++ b/407-trapping-rain-water-ii.js
@@ -1,3 +1,107 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[][]} heightMap
+ * @return {number}
+ */
+const trapRainWater = function(heightMap) {
+  const pq = new PQ((a, b) => a[1] < b[1])
+  const m = heightMap.length, n = heightMap[0].length
+  const visited = Array.from({ length: m }, () => Array(n).fill(false))
+  for(let i = 0; i < m; i++) {
+    visited[i][0] = visited[i][n - 1] = true
+    pq.push([[i, 0], heightMap[i][0]])
+    pq.push([[i, n - 1], heightMap[i][n - 1]])
+  }
+  for(let j = 0; j < n; j++) {
+    visited[0][j] = visited[m - 1][j] = true
+    pq.push([[0, j], heightMap[0][j]])
+    pq.push([[m - 1, j], heightMap[m - 1][j]])
+  }
+  const dirs = [[1,0],[-1,0],[0,1],[0,-1]]
+  let res = 0
+  while(!pq.isEmpty()) {
+    const [coord, h] = pq.pop()
+    const [r, c] = coord
+    for(const [dr, dc] of dirs) {
+      const nr = r + dr, nc = c + dc
+      if(nr >= 0 && nr < m && nc >= 0 && nc < n && !visited[nr][nc]) {
+        visited[nr][nc] = true
+        if (h > heightMap[nr][nc]) res += h - heightMap[nr][nc]
+        pq.push([[nr, nc], Math.max(heightMap[nr][nc], h)])
+      }
+    }
+  }/*  */
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} heightMap
  * @return {number}

From 5da730d69fc66629b990c2c9dfcd14aca79ada8e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Dec 2023 12:25:36 +0800
Subject: [PATCH 2915/3374] Update
 2503-maximum-number-of-points-from-grid-queries.js

---
 ...imum-number-of-points-from-grid-queries.js | 112 ++++++++++++++++++
 1 file changed, 112 insertions(+)

diff --git a/2503-maximum-number-of-points-from-grid-queries.js b/2503-maximum-number-of-points-from-grid-queries.js
index fbc8688f..af835d99 100644
--- a/2503-maximum-number-of-points-from-grid-queries.js
+++ b/2503-maximum-number-of-points-from-grid-queries.js
@@ -1,3 +1,115 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+/**
+ * @param {number[][]} grid
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+const maxPoints = function (grid, queries) {
+  const m = grid.length, n = grid[0].length, k = queries.length
+  const q = [...queries]
+  const pq = new PQ((a, b) => a[1] < b[1])
+  const dirs = [[0, 1],[0, -1],[1, 0],[-1,0]]
+  
+  q.sort((a, b) => a - b)
+  const hash = {}
+  const visited = Array.from({ length: m }, () => Array(n).fill(false))
+
+  pq.push([[0, 0], grid[0][0]])
+  visited[0][0] = true
+
+  let cnt = 0
+  for(const e of q) {
+    while(!pq.isEmpty()) {
+      const [coord, v] = pq.peek()
+      const [r, c] = coord
+      if(e <= v) break
+      pq.pop()
+      for(const [dr, dc] of dirs) {
+        const nr = r + dr, nc = c + dc
+        if(nr >= 0 && nr < m && nc >= 0 && nc < n && visited[nr][nc] === false) {
+          visited[nr][nc] = true
+          pq.push([[nr, nc], grid[nr][nc]])
+        }
+      }
+      cnt++
+    }
+
+    hash[e] = cnt
+  }
+// console.log(hash)
+  return queries.map(e => hash[e])
+}
+
+// another
+
+
 /**
  * @param {number[][]} grid
  * @param {number[]} queries

From 319d6cf7a3c5aaf7604d98f0d3fe171ba4946c6d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Dec 2023 19:46:54 +0800
Subject: [PATCH 2916/3374] Update
 2577-minimum-time-to-visit-a-cell-in-a-grid.js

---
 ...-minimum-time-to-visit-a-cell-in-a-grid.js | 107 ++++++++++++++++++
 1 file changed, 107 insertions(+)

diff --git a/2577-minimum-time-to-visit-a-cell-in-a-grid.js b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
index 05a9d259..7412633f 100644
--- a/2577-minimum-time-to-visit-a-cell-in-a-grid.js
+++ b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
@@ -1,3 +1,110 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minimumTime = function (grid) {
+  if (grid[0][1] > 1 && grid[1][0] > 1) return -1;
+  const dirs = [
+    [-1, 0],
+    [0, 1],
+    [1, 0],
+    [0, -1],
+  ]
+  let m = grid.length,
+    n = grid[0].length
+  const visited = Array.from({ length: m }, () => Array(n).fill(false))
+  const pq = new PQ((a, b) => a[0] < b[0])
+  pq.push([grid[0][0], 0, 0])
+
+  while(!pq.isEmpty()) {
+    const [v, r, c] = pq.pop()
+    if(r === m - 1 && c === n - 1) return v
+    if(visited[r][c]) continue
+    visited[r][c] = true
+    for(const [dr, dc] of dirs) {
+      const nr = r + dr, nc = c + dc
+      if(nr >= 0 && nr < m && nc >= 0 && nc < n && visited[nr][nc] === false) {
+        const wait = (grid[nr][nc] - v) % 2 === 0 ? 1 : 0
+        pq.push([Math.max(v + 1, grid[nr][nc] + wait), nr, nc])
+      }
+    }
+  }
+
+  return -1
+}
+
+
+// another
+
+
 /**
  * @param {number[][]} grid
  * @return {number}

From b8ebc090737025d7f13733593085673911ac9556 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Dec 2023 14:04:19 +0800
Subject: [PATCH 2917/3374] Update
 2662-minimum-cost-of-a-path-with-special-roads.js

---
 ...nimum-cost-of-a-path-with-special-roads.js | 109 ++++++++++++++++++
 1 file changed, 109 insertions(+)

diff --git a/2662-minimum-cost-of-a-path-with-special-roads.js b/2662-minimum-cost-of-a-path-with-special-roads.js
index b1e7bb8c..648f3bd3 100644
--- a/2662-minimum-cost-of-a-path-with-special-roads.js
+++ b/2662-minimum-cost-of-a-path-with-special-roads.js
@@ -1,3 +1,112 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number[]} start
+ * @param {number[]} target
+ * @param {number[][]} specialRoads
+ * @return {number}
+ */
+const minimumCost = function(start, target, specialRoads) {
+  const n = specialRoads.length, INF = Number.MAX_SAFE_INTEGER
+
+  const {abs, min, max} = Math
+  const dis = Array(n).fill(INF)
+  const pq = new PQ((a,b) => a[0] < b[0])
+  
+  let res = abs(start[0] - target[0]) + abs(start[1] - target[1])  
+  for(let i = 0; i < n; i++) {
+    const e = specialRoads[i]
+    const tmp = abs(e[0] - start[0]) + abs(e[1] - start[1]) + e[4]
+    dis[i] = tmp
+    pq.push([tmp, i])
+  }
+
+  while(!pq.isEmpty()) {
+    const [d, i] = pq.pop()
+    // if(d !== dis[i]) continue
+    res = min(res, d + abs(target[0] - specialRoads[i][2]) + abs(target[1] - specialRoads[i][3]))
+
+    for(let nxt = 0; nxt < n; nxt++) {
+      const nv = abs(specialRoads[nxt][0] - specialRoads[i][2]) + abs(specialRoads[nxt][1] - specialRoads[i][3]) + specialRoads[nxt][4]
+      if(d + nv < dis[nxt]) {
+        dis[nxt] = d + nv
+        pq.push([dis[nxt], nxt])
+      }
+    }
+  }
+
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {number[]} start
  * @param {number[]} target

From 7f83ec00993408384d090bd9eb06ecae19fa325e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Dec 2023 14:07:02 +0800
Subject: [PATCH 2918/3374] Update
 2662-minimum-cost-of-a-path-with-special-roads.js

---
 2662-minimum-cost-of-a-path-with-special-roads.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2662-minimum-cost-of-a-path-with-special-roads.js b/2662-minimum-cost-of-a-path-with-special-roads.js
index 648f3bd3..ecd4338c 100644
--- a/2662-minimum-cost-of-a-path-with-special-roads.js
+++ b/2662-minimum-cost-of-a-path-with-special-roads.js
@@ -88,7 +88,7 @@ const minimumCost = function(start, target, specialRoads) {
 
   while(!pq.isEmpty()) {
     const [d, i] = pq.pop()
-    // if(d !== dis[i]) continue
+    if(d > dis[i]) continue
     res = min(res, d + abs(target[0] - specialRoads[i][2]) + abs(target[1] - specialRoads[i][3]))
 
     for(let nxt = 0; nxt < n; nxt++) {

From c349e00ce10d5f98ff3c76f9fba80b2b09680be8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Dec 2023 13:15:04 +0800
Subject: [PATCH 2919/3374] Create 2699-modify-graph-edge-weights.js

---
 2699-modify-graph-edge-weights.js | 146 ++++++++++++++++++++++++++++++
 1 file changed, 146 insertions(+)
 create mode 100644 2699-modify-graph-edge-weights.js

diff --git a/2699-modify-graph-edge-weights.js b/2699-modify-graph-edge-weights.js
new file mode 100644
index 00000000..49500eff
--- /dev/null
+++ b/2699-modify-graph-edge-weights.js
@@ -0,0 +1,146 @@
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} source
+ * @param {number} destination
+ * @param {number} target
+ * @return {number[][]}
+ */
+const modifiedGraphEdges = function (n, edges, source, destination, target) {
+  const kMax = Number.MAX_SAFE_INTEGER
+  const graph = Array(n)
+    .fill(null)
+    .map(() => [])
+
+  for (const [u, v, w] of edges) {
+    if (w === -1) {
+      continue
+    }
+    graph[u].push([v, w])
+    graph[v].push([u, w])
+  }
+
+  const distToDestination = dijkstra(graph, source, destination)
+  if (distToDestination < target) {
+    return []
+  }
+  if (distToDestination === target) {
+    // Change the weights of negative edges to an impossible value.
+    for (const edge of edges) {
+      if (edge[2] === -1) {
+        edge[2] = kMax
+      }
+    }
+    return edges
+  }
+
+  for (let i = 0; i < edges.length; i++) {
+    const [u, v, w] = edges[i]
+    if (w !== -1) {
+      continue
+    }
+    edges[i][2] = 1
+    graph[u].push([v, 1])
+    graph[v].push([u, 1])
+    const distToDestination = dijkstra(graph, source, destination)
+    if (distToDestination <= target) {
+      edges[i][2] += target - distToDestination
+      // Change the weights of negative edges to an impossible value.
+      for (let j = i + 1; j < edges.length; j++) {
+        if (edges[j][2] === -1) {
+          edges[j][2] = kMax
+        }
+      }
+      return edges
+    }
+  }
+
+  return []
+}
+
+function dijkstra(graph, src, dst) {
+  const dist = Array(graph.length).fill(Infinity)
+  const minHeap = new PQ((a, b) => a[0] < b[0])
+
+  dist[src] = 0
+  minHeap.push([dist[src], src])
+
+  while (!minHeap.isEmpty()) {
+    const [d, u] = minHeap.pop()
+    for (const [v, w] of graph[u] || []) {
+      if (d + w < dist[v]) {
+        dist[v] = d + w
+        minHeap.push([dist[v], v])
+      }
+    }
+  }
+
+  return dist[dst]
+}

From 4c3700aed37de6a5d6187c9bf923404674a9ba58 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 29 Dec 2023 19:26:08 +0800
Subject: [PATCH 2920/3374] Update 2699-modify-graph-edge-weights.js

---
 2699-modify-graph-edge-weights.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/2699-modify-graph-edge-weights.js b/2699-modify-graph-edge-weights.js
index 49500eff..73626624 100644
--- a/2699-modify-graph-edge-weights.js
+++ b/2699-modify-graph-edge-weights.js
@@ -74,7 +74,7 @@ class PQ {
  * @return {number[][]}
  */
 const modifiedGraphEdges = function (n, edges, source, destination, target) {
-  const kMax = Number.MAX_SAFE_INTEGER
+  const kMax = 1e9
   const graph = Array(n)
     .fill(null)
     .map(() => [])

From b93298a0d66f0ed00e3ccbc41b7816557a9178a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 31 Dec 2023 18:49:59 +0800
Subject: [PATCH 2921/3374] Create
 2791-count-paths-that-can-form-a-palindrome-in-a-tree.js

---
 ...hs-that-can-form-a-palindrome-in-a-tree.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 2791-count-paths-that-can-form-a-palindrome-in-a-tree.js

diff --git a/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js b/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js
new file mode 100644
index 00000000..797a8d80
--- /dev/null
+++ b/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} parent
+ * @param {string} s
+ * @return {number}
+ */
+const countPalindromePaths = function (parent, s) {
+  let n = parent.length
+  let dp = Array(n).fill(undefined)
+  dp[0] = 0
+
+  function getDp(x) {
+    if (dp[x] != undefined) return dp[x]
+    dp[x] = getDp(parent[x]) ^ getMask(s[x])
+    return dp[x]
+  }
+
+  for (let i = 1; i < n; i++) getDp(i)
+  dp.sort((a, b) => a - b)
+  let counter = {}
+  let res = 0
+
+  for (let i = 0; i <= n; i++) {
+    if (counter[dp[i]]) counter[dp[i]]++
+    else {
+      counter[dp[i]] = 1
+
+      if (i) {
+        let temp = dp[i - 1]
+        let cntPrev = counter[temp]
+        let c = 0
+
+        while (temp) {
+          let b = temp & -temp
+          c += counter[dp[i - 1] ^ b] ?? 0
+          temp ^= b
+        }
+
+        res += c * cntPrev + (cntPrev * (cntPrev - 1)) / 2
+      }
+    }
+  }
+
+  return res
+}
+function getMask(c) {
+  return 1 << (c.charCodeAt() - 97)
+}

From f73669b57cab48123d7b2c3a5b2f57712f504f45 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Jan 2024 18:21:57 +0800
Subject: [PATCH 2922/3374] Update
 2876-count-visited-nodes-in-a-directed-graph.js

---
 ...count-visited-nodes-in-a-directed-graph.js | 47 ++++++++++---------
 1 file changed, 25 insertions(+), 22 deletions(-)

diff --git a/2876-count-visited-nodes-in-a-directed-graph.js b/2876-count-visited-nodes-in-a-directed-graph.js
index 0def283d..1fc4fc24 100644
--- a/2876-count-visited-nodes-in-a-directed-graph.js
+++ b/2876-count-visited-nodes-in-a-directed-graph.js
@@ -2,27 +2,30 @@
  * @param {number[]} edges
  * @return {number[]}
  */
-var countVisitedNodes = function(edges) {
-    let n = edges.length, res = new Array(n).fill(0), j = 0;
-    for (let i = 0; i < n; i++) {
-        let j = i
-        let seen = new Set();
-        let s = [];
-        while (!seen.has(j) && res[j] == 0) {
-            seen.add(j);
-            s.push(j);
-            j = edges[j];
-        }
-        if (seen.has(j)) { // hit the cycle
-            let k = s.length - s.indexOf(j);
-            for (j = 0; j < k; ++j) {
-                res[s.pop()] = k;
-            }
-        }
-        while (s.length) {
-            j = s.pop();
-            res[j] = res[edges[j]] + 1;
-        }
+const countVisitedNodes = function(edges) {
+  const n = edges.length, res = Array(n).fill(0)
+  for(let i = 0; i < n; i++) {
+    const visited = new Set()
+    let j = i, q = []
+    while(res[j] === 0 && !visited.has(j)) {
+      q.push(j)
+      visited.add(j)
+      j = edges[j]
     }
-    return res;  
+
+    if(visited.has(j)) {
+      const k = q.length - q.indexOf(j)
+      for(let ii = 0; ii < k; ii++) {
+        res[q.pop()] = k
+      }
+    }
+
+    while(q.length) {
+      const ii = q.pop()
+      res[ii] = res[edges[ii]] + 1
+    }
+
+  }
+
+  return res
 };

From cbea16dbae94e4ce01bb8c374b103b785e4823f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Jan 2024 10:35:10 +0800
Subject: [PATCH 2923/3374] Update 2831-find-the-longest-equal-subarray.js

---
 2831-find-the-longest-equal-subarray.js | 28 +++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/2831-find-the-longest-equal-subarray.js b/2831-find-the-longest-equal-subarray.js
index a2fdf369..c4a214cb 100644
--- a/2831-find-the-longest-equal-subarray.js
+++ b/2831-find-the-longest-equal-subarray.js
@@ -17,3 +17,31 @@ const longestEqualSubarray = function(nums, k) {
   }
   return maxf;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const longestEqualSubarray = function(nums, k) {
+  const n = nums.length, cnt = {}
+  let i = 0, res = 0
+  for(let j = 0; j < n; j++) {
+    const e = nums[j]
+    if(cnt[e] == null) cnt[e] = 0
+    cnt[e]++
+    res = Math.max(res, cnt[e])
+    
+    while(j - i + 1 - res > k) {
+      const pre = nums[i]
+      if(cnt[pre] == null) cnt[pre] = 0
+      cnt[pre]--
+      i++
+      res = Math.max(res, cnt[nums[i]])
+    }
+  }
+
+  return res
+};

From aa1b47e404f504bf6b43133db0bd755d1a801540 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Jan 2024 10:47:50 +0800
Subject: [PATCH 2924/3374] Update 2831-find-the-longest-equal-subarray.js

---
 2831-find-the-longest-equal-subarray.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/2831-find-the-longest-equal-subarray.js b/2831-find-the-longest-equal-subarray.js
index c4a214cb..db23ba03 100644
--- a/2831-find-the-longest-equal-subarray.js
+++ b/2831-find-the-longest-equal-subarray.js
@@ -34,12 +34,11 @@ const longestEqualSubarray = function(nums, k) {
     cnt[e]++
     res = Math.max(res, cnt[e])
     
-    while(j - i + 1 - res > k) {
+    if(j - i + 1 - res > k) {
       const pre = nums[i]
       if(cnt[pre] == null) cnt[pre] = 0
       cnt[pre]--
       i++
-      res = Math.max(res, cnt[nums[i]])
     }
   }
 

From 33ef71d5ba1a175ceed2222253a47b3c6bb8714e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Jan 2024 20:24:47 +0800
Subject: [PATCH 2925/3374] Update
 2791-count-paths-that-can-form-a-palindrome-in-a-tree.js

---
 ...hs-that-can-form-a-palindrome-in-a-tree.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js b/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js
index 797a8d80..4cc7ad91 100644
--- a/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js
+++ b/2791-count-paths-that-can-form-a-palindrome-in-a-tree.js
@@ -1,3 +1,44 @@
+/**
+ * @param {number[]} parent
+ * @param {string} s
+ * @return {number}
+ */
+const countPalindromePaths = function (parent, s) {
+  const n = parent.length
+  const nxt = Array.from({ length: n }, () => Array())
+  const cnt = {0:0}
+  for(let i = 1; i < n; i++) {
+    nxt[parent[i]].push([i, s[i]])
+  }
+  let res = 0
+  dfs(0, -1, 0)
+  return res
+
+  function dfs(node, parent, state) {
+    if(cnt[state] != null) res += cnt[state]
+    for(let i = 0; i < 26; i++) {
+      const tmp = state ^ (1 << i)
+      if(cnt[tmp] != null) res += cnt[tmp]
+    }
+    if(cnt[state] == null) cnt[state] = 0
+    cnt[state] += 1
+
+    for(const [next, ch] of (nxt[node] || [])) {
+      if(next === parent) continue
+      dfs(next, node, state ^ getMask(ch))
+    }
+
+  }
+
+}
+function getMask(c) {
+  const a = 'a'.charCodeAt(0)
+  return 1 << (c.charCodeAt(0) - a)
+}
+
+
+// another
+
 /**
  * @param {number[]} parent
  * @param {string} s

From 0105aaa6c49a9b2227acce092a86c5217060911a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Jan 2024 11:03:43 +0800
Subject: [PATCH 2926/3374] Create
 2958-length-of-longest-subarray-with-at-most-k-frequency.js

---
 ...ngest-subarray-with-at-most-k-frequency.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 2958-length-of-longest-subarray-with-at-most-k-frequency.js

diff --git a/2958-length-of-longest-subarray-with-at-most-k-frequency.js b/2958-length-of-longest-subarray-with-at-most-k-frequency.js
new file mode 100644
index 00000000..a4688f63
--- /dev/null
+++ b/2958-length-of-longest-subarray-with-at-most-k-frequency.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxSubarrayLength = function(nums, k) {
+  const n = nums.length, cnt = {}, {max} = Math
+  let i = 0, res = 0
+  for(let j = 0; j < n; j++) {
+    const e = nums[j]
+    if(cnt[e] == null) cnt[e] = 0
+    cnt[e]++
+    while(cnt[e] > k) {
+      const tmp = nums[i]
+      cnt[tmp]--
+      i++
+    }
+    res = Math.max(res, j - i + 1)
+  }
+
+  return res
+};

From 03326f2cd403148c57a5b1254e73d1c53eef6903 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Jan 2024 10:54:44 +0800
Subject: [PATCH 2927/3374] Update
 2962-count-subarrays-where-max-element-appears-at-least-k-times.js

---
 ...re-max-element-appears-at-least-k-times.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/2962-count-subarrays-where-max-element-appears-at-least-k-times.js b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
index c8731fea..973791cc 100644
--- a/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
+++ b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countSubarrays = function (nums, k) {
+    const n = nums.length
+    const t = Math.max(...nums)
+    const cnt = {0: -1}
+    let i = 0, num = 0
+    for(let j = 0; j < n; j++) {
+      const e = nums[j]
+      if(e === t) {
+          num++
+          cnt[num] = j
+      }
+    }
+    
+    let res = 0
+    // console.log(cnt)
+    for(let i = k; i <= num; i++) {
+      const preLen = cnt[i - k + 1] - cnt[i - k]
+      const sufLen = n - cnt[i]
+      res += preLen * sufLen
+    }
+  
+  
+    return res
+  }
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From d2d5a9d2e95c13f427ce96389a9e00081c75c6dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Jan 2024 11:32:05 +0800
Subject: [PATCH 2928/3374] Update
 2962-count-subarrays-where-max-element-appears-at-least-k-times.js

---
 ...re-max-element-appears-at-least-k-times.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2962-count-subarrays-where-max-element-appears-at-least-k-times.js b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
index 973791cc..9b4d793f 100644
--- a/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
+++ b/2962-count-subarrays-where-max-element-appears-at-least-k-times.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countSubarrays = function (nums, k) {
+  const n = nums.length
+  const t = Math.max(...nums)
+  let i = 0,
+    num = 0, res = 0
+  for (let j = 0; j < n; j++) {
+    const e = nums[j]
+    if (e === t) {
+      num++
+      while(num >= k) {
+        if(nums[i] === t) num--
+        i++
+        res += n - j
+      }
+    }
+  }
+
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 3d7932c94efa7254ba85144ba0b337b8daa3d180 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Jan 2024 12:52:59 +0800
Subject: [PATCH 2929/3374] Update 2401-longest-nice-subarray.js

---
 2401-longest-nice-subarray.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/2401-longest-nice-subarray.js b/2401-longest-nice-subarray.js
index 9cd9ef95..b6200957 100644
--- a/2401-longest-nice-subarray.js
+++ b/2401-longest-nice-subarray.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const longestNiceSubarray = function (nums) {
+  const n = nums.length
+  let i = 0, mask = 0, res = 0
+  for(let j = 0; j < n; j++) {
+    const e = nums[j]
+    while((mask & e) !== 0) {
+      mask ^= nums[i]
+      i++
+    }
+    mask |= e
+    res = Math.max(res, j - i + 1)
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From f9c336b494ab43f867567f3147e01ab2e93852e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 6 Jan 2024 19:56:18 +0800
Subject: [PATCH 2930/3374] Update 2354-number-of-excellent-pairs.js

---
 2354-number-of-excellent-pairs.js | 36 +++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/2354-number-of-excellent-pairs.js b/2354-number-of-excellent-pairs.js
index b610661b..1907ddcb 100644
--- a/2354-number-of-excellent-pairs.js
+++ b/2354-number-of-excellent-pairs.js
@@ -1,3 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countExcellentPairs = function(nums, k) {
+  const n = nums.length, set = new Set()
+  for(const e of nums) set.add(e)
+  const cnt = Array(30).fill(0)
+  for(const e of set) {
+    const bc = bitCnt(e)
+    if(cnt[bc] == null) cnt[bc] = 0
+    cnt[bc] += 1
+  }
+  let res = 0
+  for(let i = 0; i < 30; i++) {
+    for(let j = 0; j < 30; j++) {
+      if(i + j >= k) res += cnt[i] * cnt[j]
+    }
+  }
+
+  return res
+
+  function bitCnt(num) {
+    let res = 0
+    while(num) {
+      if(num & 1) res++
+      num = num >> 1
+    }
+
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From a7ceeb164735ac2eb8a09d93b855914b4f8e4aa5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jan 2024 10:18:56 +0800
Subject: [PATCH 2931/3374] Create
 10037-maximum-size-of-a-set-after-removals.js

---
 10037-maximum-size-of-a-set-after-removals.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 10037-maximum-size-of-a-set-after-removals.js

diff --git a/10037-maximum-size-of-a-set-after-removals.js b/10037-maximum-size-of-a-set-after-removals.js
new file mode 100644
index 00000000..29bbdb66
--- /dev/null
+++ b/10037-maximum-size-of-a-set-after-removals.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+const maximumSetSize = function(nums1, nums2) {
+  const n = nums1.length, {min} = Math
+  const s1 = new Set(nums1), s2 = new Set(nums2)
+  const common = new Set()
+  for(const e of s1) {
+    if(s2.has(e)) common.add(e)
+  }
+  const n1 = s1.size, n2 = s2.size, c = common.size
+  return min(n, min(n1 - c, n / 2) + min(n2 - c, n / 2) + c)
+};

From 534ab44c506bfe5572e4eb75627d91e37efa3ac6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jan 2024 10:20:00 +0800
Subject: [PATCH 2932/3374] Create 10036-minimum-moves-to-capture-the-queen.js

---
 10036-minimum-moves-to-capture-the-queen.js | 80 +++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 10036-minimum-moves-to-capture-the-queen.js

diff --git a/10036-minimum-moves-to-capture-the-queen.js b/10036-minimum-moves-to-capture-the-queen.js
new file mode 100644
index 00000000..57cd9d85
--- /dev/null
+++ b/10036-minimum-moves-to-capture-the-queen.js
@@ -0,0 +1,80 @@
+/**
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} e
+ * @param {number} f
+ * @return {number}
+ */
+var minMovesToCaptureTheQueen = function(a, b, c, d, e, f) {
+  if(rook() || bishop()) return 1
+  
+  return 2
+  
+  function rook() {
+    if(a === e) {
+      const min = Math.min(b,f), max = Math.max(b,f)
+      if(c !== a) return true
+      else if(d < min || d > max) return true
+      else return false
+    }
+    if(b === f) {
+      const min = Math.min(a,e), max = Math.max(a,e)
+      if(d !== b) return true
+      else if(c < min || c > max) return true
+      else return false
+    }
+    
+    return false
+  }
+  function bishop() {
+    // c,d,e,f
+
+    const dirs = [[-1, -1], [-1, 1], [1, -1], [1, 1]]
+    const visited = new Set()
+    const target = `${e},${f}`
+    const key = (x, y) => `${x},${y}`
+    
+    const ss = new Set()
+    // top-left
+    let x = c, y = d
+    let dd = dirs[0]
+    while(x + dd[0]>= 1 && x + dd[0]<= 8 && y+ dd[1] >= 1 && y+dd[1] <= 8  && (!(x + dd[0] === a && y +dd[1] === b))) {
+      ss.add(key(x +dd[0], y +dd[1]))
+      x += dd[0]
+      y += dd[1]
+    }
+    
+    // top-right
+    x = c, y = d
+     dd = dirs[1]
+    while(x + dd[0]>= 1 && x + dd[0]<= 8 && y+ dd[1] >= 1 && y+dd[1] <= 8  && (!(x + dd[0] === a && y +dd[1] === b))) {
+      ss.add(key(x +dd[0], y +dd[1]))
+            x += dd[0]
+      y += dd[1]
+    }
+    
+    // bottom-left
+    x = c, y = d
+     dd = dirs[2]
+    while(x + dd[0]>= 1 && x + dd[0]<= 8 && y+ dd[1] >= 1 && y+dd[1] <= 8  && (!(x + dd[0] === a && y +dd[1] === b))) {
+      ss.add(key(x +dd[0], y +dd[1]))
+            x += dd[0]
+      y += dd[1]
+    }
+    
+    // bottom-right
+    x = c, y = d
+     dd = dirs[3]
+    while(x + dd[0]>= 1 && x + dd[0]<= 8 && y+ dd[1] >= 1 && y+dd[1] <= 8  && (!(x + dd[0] === a && y +dd[1] === b))) {
+      ss.add(key(x +dd[0], y +dd[1]))
+            x += dd[0]
+      y += dd[1]
+    }
+    if(ss.has(target)) return true
+    
+    
+    return false
+  }
+};

From c9105de39c1d8bbecae6f04f6e1d4a4fd25f32c7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jan 2024 10:20:40 +0800
Subject: [PATCH 2933/3374] Create
 10035-maximum-area-of-longest-diagonal-rectangle.js

---
 10035-maximum-area-of-longest-diagonal-rectangle.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 10035-maximum-area-of-longest-diagonal-rectangle.js

diff --git a/10035-maximum-area-of-longest-diagonal-rectangle.js b/10035-maximum-area-of-longest-diagonal-rectangle.js
new file mode 100644
index 00000000..42991b15
--- /dev/null
+++ b/10035-maximum-area-of-longest-diagonal-rectangle.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[][]} dimensions
+ * @return {number}
+ */
+var areaOfMaxDiagonal = function(dimensions) {
+   let res = 0
+   const n = dimensions
+   const arr = dimensions.map(([l,w]) => [l ** 2 + w ** 2, l * w])
+   arr.sort((a, b) => a[0] === b[0] ?  b[1] - a[1] : b[0] - a[0])
+   return arr[0][1]
+};

From ae9cbce3188145a39706828341c786f79e143651 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Jan 2024 12:38:20 +0800
Subject: [PATCH 2934/3374] Update
 2461-maximum-sum-of-distinct-subarrays-with-length-k.js

---
 ...sum-of-distinct-subarrays-with-length-k.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)

diff --git a/2461-maximum-sum-of-distinct-subarrays-with-length-k.js b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
index 932c8383..a9700555 100644
--- a/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
+++ b/2461-maximum-sum-of-distinct-subarrays-with-length-k.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumSubarraySum = function(nums, k) {
+  let res = 0, i = 0, sum = 0
+  const map = new Map(), n = nums.length
+  for(let j = 0; j < k; j++) {
+    const e = nums[j]
+    if(map.get(e) == null) map.set(e, 0)
+    map.set(e, (map.get(e) || 0) + 1)
+    sum += e
+  }
+  if(map.size === k) res = sum
+  for(let j = k; j < n; j++) {
+    const e = nums[j]
+    if(map.get(e) == null) map.set(e, 0)
+    map.set(e, (map.get(e) || 0) + 1)
+    sum += e
+
+    // pre
+    const tmp = nums[i]
+    map.set(tmp, map.get(tmp) - 1)
+    if(map.get(tmp) === 0) map.delete(tmp)
+    sum -= tmp
+    i++
+
+    if(map.size === k) res = Math.max(res, sum)
+  }
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 4cfe2550d381efe8c41501f6d224b6234191cad0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 10 Jan 2024 11:53:37 +0800
Subject: [PATCH 2935/3374] Update
 2516-take-k-of-each-character-from-left-and-right.js

---
 ...k-of-each-character-from-left-and-right.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)

diff --git a/2516-take-k-of-each-character-from-left-and-right.js b/2516-take-k-of-each-character-from-left-and-right.js
index f917b2db..3ef81ae2 100644
--- a/2516-take-k-of-each-character-from-left-and-right.js
+++ b/2516-take-k-of-each-character-from-left-and-right.js
@@ -1,3 +1,45 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const takeCharacters = function(s, k) {
+   const n = s.length
+   const cnt = Array(3).fill(0)
+   const a = 'a'.charCodeAt(0)
+   for(const ch of s) {
+     cnt[ch.charCodeAt(0) - a]++
+   }
+   const target = Array(3).fill(0)
+   for(let i = 0; i < 3; i++) {
+     target[i] = cnt[i] - k
+   }
+   for(let e of target) {
+     if(e < 0) return -1
+   }
+   const arr = Array(3).fill(0)
+   let res = 0
+   let i = 0
+   for(let j = 0; j < n; j++) {
+     const idx = s[j].charCodeAt(0) - a
+     arr[idx]++
+     while(!valid()) {
+       const ii = s[i].charCodeAt(0) - a
+       arr[ii]--
+       i++
+     }
+     res = Math.max(res, j - i + 1)
+   }
+
+   return n - res
+
+   function valid() {
+     return arr.every((e, i) => e <= target[i])
+   }
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {number} k

From c254636462a74e979ef08c8c8f6378c021cad9d2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Jan 2024 10:19:43 +0800
Subject: [PATCH 2936/3374] Update
 1838-frequency-of-the-most-frequent-element.js

---
 ...-frequency-of-the-most-frequent-element.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1838-frequency-of-the-most-frequent-element.js b/1838-frequency-of-the-most-frequent-element.js
index b57a76f9..1be16f31 100644
--- a/1838-frequency-of-the-most-frequent-element.js
+++ b/1838-frequency-of-the-most-frequent-element.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxFrequency = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let res = 1
+  const n = nums.length
+  let i = 0, sum = 0
+  for(let j = 1; j < n; j++) {
+    const e = nums[j]
+    const delta = e - nums[j - 1]
+    sum += (j - i) * delta
+    while(sum > k) {
+      sum -= e - nums[i]
+      i++
+    }
+    res = Math.max(res, j - i + 1)
+  }
+   
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 5d926374125fe692c745324a8606f33010aa1051 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Jan 2024 12:59:30 +0800
Subject: [PATCH 2937/3374] Update 2953-count-complete-substrings.js

---
 2953-count-complete-substrings.js | 74 +++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/2953-count-complete-substrings.js b/2953-count-complete-substrings.js
index 74632582..fedf13a6 100644
--- a/2953-count-complete-substrings.js
+++ b/2953-count-complete-substrings.js
@@ -1,3 +1,77 @@
+/**
+ * @param {string} word
+ * @param {number} k
+ * @return {number}
+ */
+const countCompleteSubstrings = function(word, k) {
+  const arr = [], { abs } = Math
+  const n = word.length
+  const code = ch => ch.charCodeAt(0)
+  let i = 0
+  if(n === 1) arr.push(word)
+  for(let j = 1; j < n; j++) {
+    const pre = j - 1
+    if(abs(word[j].charCodeAt(0) - word[pre].charCodeAt(0)) > 2) {
+      arr.push(word.slice(i, j))
+      i = j
+    }
+    if(j === n - 1) {
+      arr.push(word.slice(i))
+    }
+  }
+  // console.log(arr)
+  let res = 0
+  for(const str of arr) {
+    if(str === '') continue
+    res += helper(str)
+  }
+
+  return res
+
+
+  function helper(str) {
+    let res = 0
+    const n = str.length, a = code('a')
+    
+    for(let i = 1; i <= 26; i++) {
+      const len = i * k
+      const arr = Array(26).fill(0)
+      let pre = 0
+      for(let j = 0; j < len && j < n; j++) {
+        const idx = code(str[j]) - a
+        arr[idx]++
+      }
+      if(valid(arr, i)) res++
+
+      for(let j = len; j < n; j++) {
+        const idx = code(str[j]) - a
+        arr[idx]++
+        const preIdx = code(str[pre]) - a
+        arr[preIdx]--
+        if(valid(arr, i)) res++
+        pre++
+      }
+    }
+
+    return res
+  }
+
+  function valid(arr, num) {
+    let cnt = 0
+    for(const e of arr) {
+      if(e === 0) continue
+      if(e !== k) return false
+      else cnt++
+    }
+
+    if(cnt !== num) return false
+    return true
+  }
+};
+
+// another 
+
+
 /**
  * @param {string} word
  * @param {number} k

From 97a9003857dac7076ba7229d0d941fbde03280e3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jan 2024 11:45:34 +0800
Subject: [PATCH 2938/3374] Update
 2967-minimum-cost-to-make-array-equalindromic.js

---
 ...inimum-cost-to-make-array-equalindromic.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/2967-minimum-cost-to-make-array-equalindromic.js b/2967-minimum-cost-to-make-array-equalindromic.js
index 2ec531c4..4a4ca258 100644
--- a/2967-minimum-cost-to-make-array-equalindromic.js
+++ b/2967-minimum-cost-to-make-array-equalindromic.js
@@ -1,3 +1,56 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumCost = function (nums) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  const median = nums[Math.floor(n / 2)]
+
+  // Helper function to find the next palindromic number greater than or equal to x
+  const getNextPalindromic = (x) => {
+    while (true) {
+      const strX = String(x)
+      const revStrX = strX.split('').reverse().join('')
+      if (strX === revStrX) return x
+      x++
+    }
+  }
+
+  // Helper function to find the previous palindromic number smaller than or equal to x
+  const getPrevPalindromic = (x) => {
+    while (true) {
+      const strX = String(x)
+      const revStrX = strX.split('').reverse().join('')
+      if (strX === revStrX) return x
+      x--
+    }
+  }
+
+  const candidate1 = getNextPalindromic(median)
+  const candidate2 = getPrevPalindromic(median)
+
+  let cost1 = 0
+  let cost2 = 0
+
+  // Calculate the cost for candidate1
+  for (const num of nums) {
+    cost1 += Math.abs(num - candidate1)
+  }
+
+  // Calculate the cost for candidate2
+  for (const num of nums) {
+    cost2 += Math.abs(num - candidate2)
+  }
+
+  // Return the minimum cost between candidate1 and candidate2
+  return Math.min(cost1, cost2)
+}
+
+// another
+
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From 99c1c16ddb5ce1919247b1bf52f0a752b190e942 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jan 2024 13:59:58 +0800
Subject: [PATCH 2939/3374] Update 564-find-the-closest-palindrome.js

---
 564-find-the-closest-palindrome.js | 82 ++++++++++++++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/564-find-the-closest-palindrome.js b/564-find-the-closest-palindrome.js
index 8c12f73c..54db51cb 100644
--- a/564-find-the-closest-palindrome.js
+++ b/564-find-the-closest-palindrome.js
@@ -1,3 +1,85 @@
+/**
+ * @param {string} n
+ * @return {string}
+ */
+const nearestPalindromic = function(n) {
+  const {floor} = Math
+  const str = num => `${num}`
+  const a = makeSmaller(n), b = makeGreater(n)
+  // console.log(a, b)
+  if(delta(b, n) >= delta(n, a)) {
+    return a
+  }
+  return b
+
+  function makeGreater(num) {
+    const n = num.length
+    const arr = num.split('')
+    for(let i = 0, j = n - 1; i <= j;) {
+      arr[j] = arr[i]
+      i++
+      j--
+    }
+    const tmp = arr.join('')
+    // console.log(tmp)
+    if(tmp > num) return tmp
+    let carry = 1
+    
+    for(let i = floor((n - 1) / 2); i >= 0; i--) {
+      const cur = +arr[i] + carry
+      if(cur <= 9) {
+        arr[i] = str(cur)
+        carry = 0
+      } else {
+        arr[i] = '0'
+        carry = 1
+      }
+      arr[n - 1 - i] = arr[i]
+    }
+    if(carry) {
+      const ta = Array(n + 1).fill('0')
+      ta[0] = '1'
+      ta[ta.length - 1] = '1'
+      return ta.join('')
+    }
+    return arr.join('')
+  }
+
+  function makeSmaller(num) {
+    const n = num.length
+    const arr = num.split('')
+    for(let i = 0, j = n - 1; i <= j;) {
+      arr[j] = arr[i]
+      i++
+      j--
+    }
+    const tmp = arr.join('')
+    if(tmp < num) return tmp
+    let carry = 1
+    for(let i = floor((n - 1) / 2); i >= 0; i--) {
+      const cur = +arr[i] - carry
+      if(cur >= 0) {
+        arr[i] = str(cur)
+        carry = 0
+      } else {
+        arr[i] = '9'
+        carry = 1
+      }
+      arr[n - 1 - i] = arr[i]
+    }
+    if(arr[0] === '0' && n > 1) {
+      return '9'.repeat(n - 1)
+    }
+    return arr.join('')
+  }
+  function delta(a, b) {
+    return BigInt(a) - BigInt(b)
+  }
+};
+
+// another
+
+
 /**
  * @param {bigint | string} n
  * @return {string}

From 0a92c98cf30e2c339c9af4e3da5cd5cc682a7294 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jan 2024 14:44:42 +0800
Subject: [PATCH 2940/3374] Create
 3008-find-beautiful-indices-in-the-given-array-ii.js

---
 ...beautiful-indices-in-the-given-array-ii.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3008-find-beautiful-indices-in-the-given-array-ii.js

diff --git a/3008-find-beautiful-indices-in-the-given-array-ii.js b/3008-find-beautiful-indices-in-the-given-array-ii.js
new file mode 100644
index 00000000..64d5e414
--- /dev/null
+++ b/3008-find-beautiful-indices-in-the-given-array-ii.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string} s
+ * @param {string} a
+ * @param {string} b
+ * @param {number} k
+ * @return {number[]}
+ */
+var beautifulIndices = function (s, a, b, k) {
+  let res = []
+  let v1 = []
+  let v2 = []
+  getPatternMatchingIndex(s, a, v1)
+  getPatternMatchingIndex(s, b, v2)
+  for (let i = 0, j = 0; i < v1.length; i++) {
+    while (j < v2.length && v1[i] > v2[j] && Math.abs(v1[i] - v2[j]) > k) {
+      j++
+    }
+    if (j < v2.length && Math.abs(v1[i] - v2[j]) <= k) {
+      res.push(v1[i])
+    }
+  }
+  return res
+}
+
+function getPatternMatchingIndex(s, a, v) {
+  let t = a + '@' + s
+  let lps = [0]
+  for (let i = 1; i < t.length; i++) {
+    let ind = lps[i - 1]
+    while (ind > 0 && t[ind] !== t[i]) {
+      ind = lps[ind - 1]
+    }
+    lps.push(t[ind] === t[i] ? ind + 1 : 0)
+  }
+  for (let i = 0; i < lps.length; i++) {
+    if (lps[i] === a.length) {
+      v.push(i - 2 * a.length)
+    }
+  }
+}

From 338cd2ca135327306b940081b3d4e3d2f7e952d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Jan 2024 19:18:55 +0800
Subject: [PATCH 2941/3374] Update 330-patching-array.js

---
 330-patching-array.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/330-patching-array.js b/330-patching-array.js
index 7b101bf8..295d8b70 100644
--- a/330-patching-array.js
+++ b/330-patching-array.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @param {number} n
+ * @return {number}
+ */
+const minPatches = function(nums, n) {
+  let sum = 1, res = 0, i = 0
+  while(sum <= n) {
+    if(i < nums.length && nums[i] <= sum) {
+      sum += nums[i]
+      i++
+    } else {
+      res++
+      sum *= 2
+    }
+  }
+
+  return res 
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} n

From 62a6e737a706754c0591deaccc74c017923c433f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 17 Jan 2024 12:58:17 +0800
Subject: [PATCH 2942/3374] Update
 1798-maximum-number-of-consecutive-values-you-can-make.js

---
 ...mber-of-consecutive-values-you-can-make.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/1798-maximum-number-of-consecutive-values-you-can-make.js b/1798-maximum-number-of-consecutive-values-you-can-make.js
index 3f896373..2aee0b58 100644
--- a/1798-maximum-number-of-consecutive-values-you-can-make.js
+++ b/1798-maximum-number-of-consecutive-values-you-can-make.js
@@ -11,3 +11,26 @@ const getMaximumConsecutive = function(coins) {
   }
   return res; 
 };
+
+// another
+
+/**
+ * @param {number[]} coins
+ * @return {number}
+ */
+const getMaximumConsecutive = function(coins) {
+  coins.sort((a, b) => a - b)
+  let sum = 1, res = 1, i = 0
+  while(true) {
+    const e = coins[i]
+    if(i >= coins.length) break
+    if(e <= sum) {
+      sum += e
+      i++
+    } else {
+      break
+    }
+  }
+
+  return sum
+};

From 1402d71851fb27dea0736fdec65836fdcc26756e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Jan 2024 18:46:04 +0800
Subject: [PATCH 2943/3374] Update 2952-minimum-number-of-coins-to-be-added.js

---
 2952-minimum-number-of-coins-to-be-added.js | 25 +++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/2952-minimum-number-of-coins-to-be-added.js b/2952-minimum-number-of-coins-to-be-added.js
index e106e731..a2d2e7d5 100644
--- a/2952-minimum-number-of-coins-to-be-added.js
+++ b/2952-minimum-number-of-coins-to-be-added.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} coins
+ * @param {number} target
+ * @return {number}
+ */
+const minimumAddedCoins = function(coins, target) {
+  coins.sort((a,b) => a - b)
+  const n = coins.length
+  let sum = 1, i = 0, res = 0
+  while(true) {
+    const e = coins[i]
+    if(sum > target) break
+    if(e <= sum) {
+      sum += e
+      i++
+    } else {
+      sum *= 2
+      res++
+    }
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} coins
  * @param {number} target

From 68809b798b037183439bf3a4027647af8337b204 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Jan 2024 14:45:36 +0800
Subject: [PATCH 2944/3374] Create
 2957-remove-adjacent-almost-equal-characters.js

---
 ...remove-adjacent-almost-equal-characters.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 2957-remove-adjacent-almost-equal-characters.js

diff --git a/2957-remove-adjacent-almost-equal-characters.js b/2957-remove-adjacent-almost-equal-characters.js
new file mode 100644
index 00000000..f3d6b9b6
--- /dev/null
+++ b/2957-remove-adjacent-almost-equal-characters.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+var removeAlmostEqualCharacters = function(word) {
+  const n = word.length, { abs } = Math
+
+  let res = 0
+  for(let i = 1; i < n;) {
+    const delta = abs(word.charCodeAt(i) - word.charCodeAt(i - 1))
+    if(delta <= 1) {
+      res++
+      i += 2
+    } else i++
+
+  }
+
+  return res
+};

From fc8d8417df096c28563f212fc48334a04bc64306 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Jan 2024 18:21:31 +0800
Subject: [PATCH 2945/3374] Create 2983-palindrome-rearrangement-queries.js

---
 2983-palindrome-rearrangement-queries.js | 70 ++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 2983-palindrome-rearrangement-queries.js

diff --git a/2983-palindrome-rearrangement-queries.js b/2983-palindrome-rearrangement-queries.js
new file mode 100644
index 00000000..291d8bfe
--- /dev/null
+++ b/2983-palindrome-rearrangement-queries.js
@@ -0,0 +1,70 @@
+function canMakePalindromeQueries(s, queries) {
+  const n = s.length
+  // Prefix sum (difference)
+  const psd = [0]
+  for (let i = 0, j = n - 1; i < j; i++, j--) {
+    psd.push(psd[psd.length - 1] + (s[i] !== s[j] ? 1 : 0))
+  }
+  // Prefix sum (count)
+  const cnt = new Array(26).fill(0)
+  const psc = [cnt.slice()]
+  for (const c of s) {
+    cnt[c.charCodeAt(0) - 'a'.charCodeAt(0)]++
+    psc.push([...cnt])
+  }
+  const ans = []
+  for (const q of queries) {
+    const a1 = q[0],
+      b1 = q[1] + 1,
+      a2 = n - q[0],
+      b2 = n - 1 - q[1]
+    const c1 = q[2],
+      d1 = q[3] + 1,
+      c2 = n - q[2],
+      d2 = n - 1 - q[3]
+    // No difference allowed outside the query ranges
+    if (
+      (min(a1, d2) && psd[min(a1, d2)]) ||
+      (n / 2 > max(b1, c2) && psd[Math.floor(n / 2)] - psd[max(b1, c2)]) ||
+      (d2 > b1 && psd[d2] - psd[b1]) ||
+      (a1 > c2 && psd[a1] - psd[c2])
+    ) {
+      ans.push(false)
+    } else {
+      // Intersection of query ranges in the lower half must equate to that in the upper half
+      const ix1 = psc[d1].map((val, i) => val - (psc[c1][i] || 0))
+      const ix2 = psc[b1].map((val, i) => val - (psc[a1][i] || 0))
+      if (a1 > d2) {
+        ix1.forEach(
+          (val, i) => (ix1[i] -= psc[Math.min(a1, c2)][i] - (psc[d2][i] || 0)),
+        )
+      }
+      if (c2 > b1) {
+        ix1.forEach(
+          (val, i) => (ix1[i] -= psc[c2][i] - (psc[Math.max(b1, d2)][i] || 0)),
+        )
+      }
+      if (c1 > b2) {
+        ix2.forEach(
+          (val, i) => (ix2[i] -= psc[Math.min(c1, a2)][i] - (psc[b2][i] || 0)),
+        )
+      }
+      if (a2 > d1) {
+        ix2.forEach(
+          (val, i) => (ix2[i] -= psc[a2][i] - (psc[Math.max(d1, b2)][i] || 0)),
+        )
+      }
+      ans.push(ix1.every((val, i) => val >= 0 && val === ix2[i]))
+    }
+  }
+  return ans
+}
+
+// Helper functions
+function min(a, b) {
+  return a < b ? a : b
+}
+
+function max(a, b) {
+  return a > b ? a : b
+}

From 954c7ef1bf591f2257f8714cc66a20ddcc05f540 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Jan 2024 15:23:07 +0800
Subject: [PATCH 2946/3374] Update
 452-minimum-number-of-arrows-to-burst-balloons.js

---
 ...imum-number-of-arrows-to-burst-balloons.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
index c47b87fa..bd476101 100644
--- a/452-minimum-number-of-arrows-to-burst-balloons.js
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+const findMinArrowShots = function(points) {
+  const n = points.length
+  if(n === 0) return 0
+  points.sort((a, b) => a[1] - b[1])
+  let res = 1
+  let end = points[0][1]
+
+  for(let i = 1; i < n; i++) {
+    if(end >= points[i][0]) continue
+    res++
+    end = points[i][1]
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} points
  * @return {number}

From 4f95c59b19e449adb5f75d8be5f84ad3fd81908c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Jan 2024 13:49:57 +0800
Subject: [PATCH 2947/3374] Update 646-maximum-length-of-pair-chain.js

---
 646-maximum-length-of-pair-chain.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/646-maximum-length-of-pair-chain.js b/646-maximum-length-of-pair-chain.js
index ec50ac9d..9ec23294 100755
--- a/646-maximum-length-of-pair-chain.js
+++ b/646-maximum-length-of-pair-chain.js
@@ -1,3 +1,26 @@
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+const findLongestChain = function(pairs) {
+  let res = 0
+  const n = pairs.length
+  if(n === 0) return res
+  pairs.sort((a, b) => a[1] - b[1])
+  let end = pairs[0][1]
+  res++
+  for(let i = 1; i < n; i++) {
+    const e = pairs[i]
+    if(e[0] <= end) continue
+    res++
+    end = e[1]
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} pairs
  * @return {number}

From 8c45c2d3d3794c8ebbd9893e8130254c20966da3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Jan 2024 13:07:30 +0800
Subject: [PATCH 2948/3374] Update 1024-video-stitching.js

---
 1024-video-stitching.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/1024-video-stitching.js b/1024-video-stitching.js
index fdc1b195..2ce978c9 100644
--- a/1024-video-stitching.js
+++ b/1024-video-stitching.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} clips
+ * @param {number} time
+ * @return {number}
+ */
+const videoStitching = function(clips, time) {
+  const n = clips.length
+  if(time === 0) return 0
+  clips.sort((a, b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])
+  let res = 0, start = 0, end = 0, nextEnd = 0, idx = 0
+
+  while(idx < n) {
+    nextEnd = end
+    while(idx < n && clips[idx][0] <= end) {
+        nextEnd = Math.max(nextEnd, clips[idx][1])
+        idx++
+    }
+    res++
+    if(nextEnd >= time) return res
+    else if(nextEnd === end) return -1
+    else {
+       end = nextEnd 
+    }
+  }
+
+  return -1
+
+};
+
+// anonther
+
 /**
  * @param {number[][]} clips
  * @param {number} T

From b3f79499eeb5dc62ddcab1acc9ab3c7da753f8c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Jan 2024 15:24:33 +0800
Subject: [PATCH 2949/3374] Update 757-set-intersection-size-at-least-two.js

---
 757-set-intersection-size-at-least-two.js | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/757-set-intersection-size-at-least-two.js b/757-set-intersection-size-at-least-two.js
index c89077ec..1675a247 100644
--- a/757-set-intersection-size-at-least-two.js
+++ b/757-set-intersection-size-at-least-two.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+const intersectionSizeTwo = function (intervals) {
+  if (intervals.length === 1) return 2
+  intervals.sort((a, b) => (a[1] !== b[1] ? a[1] - b[1] : b[0] - a[0]))
+  let right = intervals[0][1]
+  let left = right - 1
+  let res = 2
+
+  for (let i = 1, len = intervals.length; i < len; i++) {
+    const cur = intervals[i]
+    if(cur[0] <= left) continue
+    else if(cur[0] <= right) {
+      res++
+      left = right
+      right = cur[1]
+    } else {
+      res += 2
+      right = cur[1]
+      left = right - 1
+    }
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number[][]} intervals
  * @return {number}

From c3919bccce04c9fad5d02ffdfcbc2785715b4880 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Jan 2024 11:52:22 +0800
Subject: [PATCH 2950/3374] Update
 1326-minimum-number-of-taps-to-open-to-water-a-garden.js

---
 ...umber-of-taps-to-open-to-water-a-garden.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/1326-minimum-number-of-taps-to-open-to-water-a-garden.js b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
index e228bae1..1acc085e 100644
--- a/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
+++ b/1326-minimum-number-of-taps-to-open-to-water-a-garden.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number[]} ranges
+ * @return {number}
+ */
+const minTaps = function(n, ranges) {
+  const len = ranges.length, {min, max} = Math
+  const arr = []
+  for(let i = 0; i < len; i++) {
+    arr.push([max(0, i - ranges[i]), i + ranges[i]])
+  }
+  // arr.sort((a, b) => a[1] === b[1] ? a[0] - b[0]: a[1] - b[1])
+  arr.sort((a, b) => a[0] === b[0] ? b[1] - a[1] : a[0] - b[0])
+  let res = 0, end = 0, nextEnd = 0, idx = 0
+  while(idx < len) {
+    nextEnd = end
+    while(idx < len && arr[idx][0] <= end) {
+      nextEnd = max(nextEnd, arr[idx][1])
+      idx++
+    }
+    res++
+    if(nextEnd >= n) return res
+    else if(nextEnd === end) return -1
+    end = nextEnd
+  }
+
+
+  return -1
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[]} ranges

From f181b21783dcc1abf429b0be03b5be1613e08b8e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jan 2024 11:01:20 +0800
Subject: [PATCH 2951/3374] Create
 3020-find-the-maximum-number-of-elements-in-subset.js

---
 ...he-maximum-number-of-elements-in-subset.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 3020-find-the-maximum-number-of-elements-in-subset.js

diff --git a/3020-find-the-maximum-number-of-elements-in-subset.js b/3020-find-the-maximum-number-of-elements-in-subset.js
new file mode 100644
index 00000000..d2d6f16f
--- /dev/null
+++ b/3020-find-the-maximum-number-of-elements-in-subset.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumLength = function (nums) {
+  const um = new Map()
+
+  for (const val of nums) {
+    if (um.has(val)) {
+      um.set(val, um.get(val) + 1)
+    } else {
+      um.set(val, 1)
+    }
+  }
+
+  if (um.size === 1) {
+    return 1
+  }
+
+  let cnt = 0
+  let res = 1
+
+  for (const [key, value] of um) {
+    // .5 = 1/2 which is square root
+    let fnd = Math.pow(key, 0.5)
+    cnt = 1
+
+    // yha condition greate than equal 2 isiliye rkha
+    // to avoid the infinite loop as use calculator
+    // and find root(2)->root(root(2))...so on
+    // it will never end
+    while (fnd >= 2) {
+      if (um.has(fnd)) {
+        if (um.get(fnd) >= 2) {
+          cnt += 2
+        } else {
+          break
+        }
+        fnd = Math.pow(fnd, 0.5)
+      } else {
+        break
+      }
+    }
+
+    res = Math.max(res, cnt)
+    cnt = 0
+  }
+
+  let maxi = 0
+  if (um.has(1)) {
+    maxi = um.get(1)
+  }
+
+  if (maxi > ans) {
+    if (maxi & 1) {
+      return maxi
+    }
+    return maxi - 1
+  }
+
+  return res
+}

From fce30493b482ec5828530a4e4a7f6e0f5ad11424 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jan 2024 11:02:22 +0800
Subject: [PATCH 2952/3374] Create 3019-number-of-changing-keys.js

---
 3019-number-of-changing-keys.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 3019-number-of-changing-keys.js

diff --git a/3019-number-of-changing-keys.js b/3019-number-of-changing-keys.js
new file mode 100644
index 00000000..0d18c3a5
--- /dev/null
+++ b/3019-number-of-changing-keys.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var countKeyChanges = function(s) {
+    const ss = s.toLowerCase()
+    let res = 0
+    for(let i = 1;i < ss.length; i++) {
+      if(ss[i] !== ss[i - 1]) res++
+    }
+    return res
+};

From 621186f209612960abb5349eaa73f17e3e538de3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jan 2024 11:03:04 +0800
Subject: [PATCH 2953/3374] Create 3021-alice-and-bob-playing-flower-game.js

---
 3021-alice-and-bob-playing-flower-game.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 3021-alice-and-bob-playing-flower-game.js

diff --git a/3021-alice-and-bob-playing-flower-game.js b/3021-alice-and-bob-playing-flower-game.js
new file mode 100644
index 00000000..b201a348
--- /dev/null
+++ b/3021-alice-and-bob-playing-flower-game.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+var flowerGame = function(n, m) {
+  let res = 0
+  let oddNum = 0, evenNum = 0
+  let oddNum1 = 0, evenNum1 = 0
+  for(let i = 1; i <= n; i++) {
+    if(i % 2 === 1) oddNum++
+    else evenNum++
+  }
+  for(let i = 1; i <= m; i++) {
+    if(i % 2 === 1) oddNum1++
+    else evenNum1++
+  }
+  res += oddNum * evenNum1
+  res += evenNum * oddNum1
+  
+  return res
+};

From e39ae144d171a0244c7cff17a907d3bd972beea1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jan 2024 11:07:12 +0800
Subject: [PATCH 2954/3374] Create
 3022-minimize-or-of-remaining-elements-using-operations.js

---
 ...-of-remaining-elements-using-operations.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3022-minimize-or-of-remaining-elements-using-operations.js

diff --git a/3022-minimize-or-of-remaining-elements-using-operations.js b/3022-minimize-or-of-remaining-elements-using-operations.js
new file mode 100644
index 00000000..f82b89ba
--- /dev/null
+++ b/3022-minimize-or-of-remaining-elements-using-operations.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minOrAfterOperations = function(nums, k) {
+  let n = nums.length; //length of the array
+  let res = 0; //this will contain the 'or' of all final elements of array
+
+  //Iterating from MSB to LSB
+  for (let j = 30; j >= 0; j--) 
+  {
+      let cnt = 0; //count of elements which have 0 at jth bit
+
+      //we will do & of all elements and store it here in 'cur' variable
+      let cur = (1 << 30) - 1; //this is basically all last 30 bits set to 1
+
+      let target = res | ((1 << j) - 1); //jth bit is set 0 here, and bits from 0 to (j-1)th index are set to 1
+
+      for (let x of nums) 
+      {
+          cur &= x;
+          if ((cur | target) == target) 
+          {
+              cnt++;
+              cur = (1 << 30) - 1;
+          }
+      }
+
+      //we have to keep the jth bit if (n-cnt) is greater than k otherwise we can remove jth bit in less than or equal to k operations
+      if (n - cnt > k) 
+      {
+          res |= (1 << j);
+      }
+  }
+  return res;  
+};

From 6fbb9a2697cdccecdd668e51e88a49dc66d43a00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Jan 2024 19:57:21 +0800
Subject: [PATCH 2955/3374] Update 2589-minimum-time-to-complete-all-tasks.js

---
 2589-minimum-time-to-complete-all-tasks.js | 35 ++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2589-minimum-time-to-complete-all-tasks.js b/2589-minimum-time-to-complete-all-tasks.js
index 6999599c..9f9f7cb8 100644
--- a/2589-minimum-time-to-complete-all-tasks.js
+++ b/2589-minimum-time-to-complete-all-tasks.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number[][]} tasks
+ * @return {number}
+ */
+const findMinimumTime = function(tasks) {
+  tasks.sort((a, b) => a[1] - b[1])
+  const {max} = Math
+  let maxEnd = -1
+  for(const [s,e,d] of tasks) maxEnd = max(maxEnd, e)
+  const arr = Array(maxEnd + 1).fill(0)
+  const n = tasks.length
+
+  for(let i = 0; i < n; i++) {
+    let [s, e, d] = tasks[i]
+    let overlap = 0
+    for(let j = e; j >= s; j--) {
+      if(arr[j]) overlap++
+    }
+    if(overlap >= d) continue
+    let diff = d - overlap
+    for(let j = e; j >= s; j--) {
+      if(arr[j] === 0) {
+        diff--
+        arr[j] = 1
+      } else continue
+      if(diff === 0) break
+    }
+
+  }
+
+  return arr.reduce((ac, e) => ac + e, 0)
+};
+
+// another
+
 /**
  * @param {number[][]} tasks
  * @return {number}

From 6965e203eb119f334e26657b392385e765053b50 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Jan 2024 12:19:35 +0800
Subject: [PATCH 2956/3374] Create 1012-numbers-with-repeated-digits.js

---
 1012-numbers-with-repeated-digits.js | 32 ++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 1012-numbers-with-repeated-digits.js

diff --git a/1012-numbers-with-repeated-digits.js b/1012-numbers-with-repeated-digits.js
new file mode 100644
index 00000000..d033da97
--- /dev/null
+++ b/1012-numbers-with-repeated-digits.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numDupDigitsAtMostN = function(n) {
+  const digits = [], {floor} = Math
+  let tmp = n + 1
+  while(tmp) {
+    digits.push(tmp % 10)
+    tmp = floor(tmp / 10)
+  }
+  let res = 0
+  const len = digits.length
+  let cur = 9
+  for(let i = 0; i < len - 1; i++) {
+    res += cur
+    cur *= (9 - i)
+  }
+  cur = floor(cur / 9)
+  const seen = Array(10).fill(false)
+  for(let i = 0; i < len; i++) {
+    const d = digits[len - i - 1]
+    for(let j = (i === 0 ? 1 : 0); j < d; j++) {
+      if(!seen[j]) res += cur
+    }
+    cur = floor(cur / (9 - i))
+    if(seen[d]) break
+    seen[d] = true
+  }
+
+  return n - res
+};

From eba8608f42d26a7c908a92a4b19e00721e6e6567 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 31 Jan 2024 16:10:14 +0800
Subject: [PATCH 2957/3374] Update 1012-numbers-with-repeated-digits.js

---
 1012-numbers-with-repeated-digits.js | 64 ++++++++++++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/1012-numbers-with-repeated-digits.js b/1012-numbers-with-repeated-digits.js
index d033da97..dec2580e 100644
--- a/1012-numbers-with-repeated-digits.js
+++ b/1012-numbers-with-repeated-digits.js
@@ -1,3 +1,67 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+function numDupDigitsAtMostN(n) {
+  let numNoDupDigits = 0; // the number of positive integers less than or equal to n with no repeated digits
+
+  let lst = Array.from(String(n), Number);
+  let n_digits = lst.length;
+
+  // if n = 8765, lst = [8,7,6,5],
+  // the number without repeated digit can the the following format:
+  // XXX
+  // XX
+  // X
+  for (let i = 1; i < n_digits; i++) {
+    // the number of i digits without repeated digit
+    // the leading digit cannot be 0
+    numNoDupDigits += 9 * perm(9, i - 1);
+  }
+
+  // and
+  // 1XXX ~ 7XXX
+  // 80XX ~ 86XX
+  // 870X ~ 875X
+  // 8760 ~ 8764
+  let seen = new Set();
+  for (let i = 0; i < lst.length; i++) {
+    let x = lst[i];
+    for (let y = (i === 0 ? 1 : 0); y < x; y++) {
+      if (!seen.has(y)) {
+        // the leading digit used - y
+        // for the remaining positions we cannot use digits in set seen and y
+        numNoDupDigits += perm(9 - i, n_digits - i - 1);
+      }
+    }
+    if (seen.has(x)) {
+      break;
+    }
+    seen.add(x);
+  }
+
+  // and
+  // 8765
+  if (n_digits === new Set(lst).size) {
+    numNoDupDigits += 1;
+  }
+
+  return n - numNoDupDigits;
+}
+
+function perm(m, n) {
+  let res = 1
+  for(let i = 0; i < n; i++) {
+    res *= m
+    m--
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From 792201ab7816a595e2e42bc4aebc5d17820d4aa0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Feb 2024 13:06:15 +0800
Subject: [PATCH 2958/3374] Update 2801-count-stepping-numbers-in-range.js

---
 2801-count-stepping-numbers-in-range.js | 76 +++++++++++++++++++++++++
 1 file changed, 76 insertions(+)

diff --git a/2801-count-stepping-numbers-in-range.js b/2801-count-stepping-numbers-in-range.js
index 8fbb85c9..27af38b6 100644
--- a/2801-count-stepping-numbers-in-range.js
+++ b/2801-count-stepping-numbers-in-range.js
@@ -1,3 +1,79 @@
+/**
+ * @param {string} low
+ * @param {string} high
+ * @return {number}
+ */
+var countSteppingNumbers = function (low, high) {
+  const mod = 1000000007
+  let init = () => new Array(101)
+    .fill(null)
+    .map(() =>
+      new Array(2)
+        .fill(null)
+        .map(() => new Array(2).fill(null).map(() => new Array(11).fill(-1))),
+    )
+//   console.log(dp)
+  const helper = (pos, tight, isZero, prevDigit, s) => {
+    if (pos === s.length) {
+      if (isZero) return 0
+      return 1
+    }
+
+    if (dp[pos][tight][isZero][prevDigit + 1] !== -1)
+      return dp[pos][tight][isZero][prevDigit + 1]
+
+    let res = 0
+    let limit
+
+    if (tight) limit = parseInt(s[pos])
+    else limit = 9
+
+    for (let curDigit = 0; curDigit <= limit; curDigit++) {
+      let newTight = tight
+      if (tight && curDigit < limit) newTight = 0
+
+      let willBeZero = isZero
+      if (isZero && curDigit > 0) willBeZero = 0
+
+      if (isZero) {
+        res += helper(pos + 1, newTight, willBeZero, curDigit, s)
+        res %= mod
+      } else {
+        if (Math.abs(curDigit - prevDigit) === 1) {
+          res += helper(pos + 1, newTight, willBeZero, curDigit, s)
+          res %= mod
+        }
+      }
+    }
+
+    dp[pos][tight][isZero][prevDigit + 1] = res
+    return res
+  }
+  let dp = init()
+  let l = helper(0, 1, 1, -1, low)
+
+  dp = init()
+  let r = helper(0, 1, 1, -1, high)
+
+  let res = r - l
+  res = (res + mod) % mod
+
+  let add = true
+  for (let i = 1; i < low.length; i++) {
+    if (Math.abs(low[i] - low[i - 1]) !== 1) {
+      add = false
+      break
+    }
+  }
+  if (add) res++
+
+  res %= mod
+  return res
+}
+
+// another
+
+
 const minus_mod = (x, y, mod) => ((x - y) % mod + mod) % mod;
 const mod = 1e9 + 7, ll = BigInt;
 let memo;

From d8606e1d1373516540ef97dbb3c11fb7f51040ef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Feb 2024 17:40:34 +0800
Subject: [PATCH 2959/3374] Create
 2827-number-of-beautiful-integers-in-the-range.js

---
 ...mber-of-beautiful-integers-in-the-range.js | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 2827-number-of-beautiful-integers-in-the-range.js

diff --git a/2827-number-of-beautiful-integers-in-the-range.js b/2827-number-of-beautiful-integers-in-the-range.js
new file mode 100644
index 00000000..1d2b4390
--- /dev/null
+++ b/2827-number-of-beautiful-integers-in-the-range.js
@@ -0,0 +1,54 @@
+/**
+ * @param {number} low
+ * @param {number} high
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfBeautifulIntegers = function (low, high, k) {
+  const memo = new Map();
+
+  function dp(index, diff, isLimit, isZero, numStr, m) {
+    if (index === numStr.length) {
+      return Number(isZero) & (diff === 0) & (m === 0);
+    }
+
+    const memoKey = `${index}-${diff}-${isLimit ? 1 : 0}-${isZero ? 1 : 0}-${numStr}-${m}`;
+    if (memo.has(memoKey)) {
+      return memo.get(memoKey);
+    }
+
+    let res = 0;
+    if (!isZero) {
+      res = dp(index + 1, diff, false, false, numStr, m);
+    }
+    const bound = isLimit ? parseInt(numStr[index]) : 9;
+
+    for (let d = 1 - Number(isZero); d <= bound; d++) {
+      if (d % 2 === 1) {
+        res += dp(
+          index + 1,
+          diff + 1,
+          isLimit && d === bound,
+          true,
+          numStr,
+          (m + d * Math.pow(10, numStr.length - index - 1)) % k
+        );
+      } else {
+        res += dp(
+          index + 1,
+          diff - 1,
+          isLimit && d === bound,
+          true,
+          numStr,
+          (m + d * Math.pow(10, numStr.length - index - 1)) % k
+        );
+      }
+    }
+
+    memo.set(memoKey, res);
+    return res;
+  }
+
+  return dp(0, 0, true, false, String(high), 0) - dp(0, 0, true, false, String(low - 1), 0);
+}
+

From 3a2a0ba455e4d640b0a86745dca41673e5bfee7a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Feb 2024 17:50:30 +0800
Subject: [PATCH 2960/3374] Create
 2999-count-the-number-of-powerful-integers.js

---
 2999-count-the-number-of-powerful-integers.js | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 2999-count-the-number-of-powerful-integers.js

diff --git a/2999-count-the-number-of-powerful-integers.js b/2999-count-the-number-of-powerful-integers.js
new file mode 100644
index 00000000..1a2b8079
--- /dev/null
+++ b/2999-count-the-number-of-powerful-integers.js
@@ -0,0 +1,54 @@
+/**
+ * @param {number} num
+ * @param {number} limit
+ * @param {string} s
+ */
+function adjust(num, limit, s) {
+  let sn = parseInt(s);
+  let sufMod = 10 ** s.length;
+
+  let suf = num % sufMod;
+  num = Math.floor(num / sufMod);
+  if (suf < sn) --num;
+
+  if (num <= 0) return num + 1;
+
+  let sNum = num.toString();
+  let res = sNum.charCodeAt(0) - 48;
+  let tight = 1;
+  if (res > limit) {
+    return (limit + 1) ** sNum.length;
+  }
+  
+  for (let i = 1; i < sNum.length; ++i) {
+    res *= (limit + 1);
+    
+    if (tight) {
+      let c = sNum.charCodeAt(i) - 48;
+      if (c > limit) {
+        tight = 0;
+        res += limit + 1;
+      }
+      else {
+        res += c;
+      }
+    }
+  }
+
+  return res + tight;
+}
+/**
+ * @param {number} start
+ * @param {number} finish
+ * @param {number} limit
+ * @param {string} s
+ * @return {number}
+ */
+var numberOfPowerfulInt = function (start, finish, limit, s) {
+  --start;
+
+  let ss = adjust(start, limit, s);
+  let ff = adjust(finish, limit, s);
+
+  return ff - ss;
+};

From 7d586db5b2712dfb0cf27d116c762d05007e27ec Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 5 Feb 2024 19:52:02 +0800
Subject: [PATCH 2961/3374] Update 233-number-of-digit-one.js

---
 233-number-of-digit-one.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/233-number-of-digit-one.js b/233-number-of-digit-one.js
index 82678200..d3df405e 100644
--- a/233-number-of-digit-one.js
+++ b/233-number-of-digit-one.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const countDigitOne = function(n) {
+  let res = 0
+  const s = `${n}`
+  const len = s.length, {floor, pow} = Math
+
+  for(let i = 1; i <= len; i++) {
+    const np = pow(10, i - 1)
+    const pre = floor(n / pow(10, i))
+    const remain = n % np
+    
+    res += pre * np
+    const e = +s[len - i]
+    if(e > 1) {
+        res += np
+    } else if(e === 1) {
+        res += remain + 1
+    }
+  }
+
+  return res
+};
+
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From f16a5720a6ee8c1866ca37b1bcd2c5fc30048250 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Feb 2024 16:44:14 +0800
Subject: [PATCH 2962/3374] Update 1367-linked-list-in-binary-tree.js

---
 1367-linked-list-in-binary-tree.js | 54 ++++++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)

diff --git a/1367-linked-list-in-binary-tree.js b/1367-linked-list-in-binary-tree.js
index 41e48b07..c1dd0e33 100644
--- a/1367-linked-list-in-binary-tree.js
+++ b/1367-linked-list-in-binary-tree.js
@@ -1,3 +1,57 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+const isSubPath = function(head, root) {
+  return dfs(root)
+  
+  function dfs(node) {
+    if(node == null) return false
+    if(head.val === node.val) {
+      let cur = head
+      let q = [node]
+      while(q.length) {
+        const v = cur.val
+        const tmp = []
+        let mark = false
+        for(const e of q) {
+          if(e.val === v) {
+            mark = true
+            if(e.left) tmp.push(e.left)
+            if(e.right) tmp.push(e.right)
+          }
+        }
+        if(cur && !mark) break
+        cur = cur.next
+        if(cur == null) return true
+        q = tmp
+      }
+    }
+    return dfs(node.left) || dfs(node.right)
+  }
+  
+};
+
+
+// another
+
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val, next) {

From 8f765dca185da2e5bef0c22e61dc7feae743b3d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Feb 2024 23:08:03 +0800
Subject: [PATCH 2963/3374] Update 1367-linked-list-in-binary-tree.js

---
 1367-linked-list-in-binary-tree.js | 60 ++++++++++++++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/1367-linked-list-in-binary-tree.js b/1367-linked-list-in-binary-tree.js
index c1dd0e33..f186049e 100644
--- a/1367-linked-list-in-binary-tree.js
+++ b/1367-linked-list-in-binary-tree.js
@@ -1,3 +1,63 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {TreeNode} root
+ * @return {boolean}
+ */
+function isSubPath(head, root) {
+  let needle = convertLinkedListToArray(head);
+  let lps = computeKMPTable(needle);
+  return kmpSearch(root, 0);
+
+  function kmpSearch(i, j) {
+    if (j === needle.length) return true;
+    if (i === null) return false;
+    while (j > 0 && i.val !== needle[j]) j = lps[j - 1];
+    if (i.val === needle[j]) j++;
+    return kmpSearch(i.left, j) || kmpSearch(i.right, j);
+  }
+
+  function computeKMPTable(pattern) {
+    let n = pattern.length;
+    let lps = new Array(n);
+    for (let i = 0; i < n; i++) {
+      lps[i] = 0;
+    }
+    for (let i = 1, j = 0; i < n; i++) {
+      while (j > 0 && pattern[i] !== pattern[j]) j = lps[j - 1];
+      if (pattern[i] === pattern[j]) lps[i] = ++j;
+    }
+    return lps;
+  }
+
+  function convertLinkedListToArray(head) {
+    let list = [];
+    while (head !== null) {
+      list.push(head.val);
+      head = head.next;
+    }
+    return list;
+  }
+}
+
+
+// another
+
+
 /**
  * Definition for singly-linked list.
  * function ListNode(val, next) {

From 2adc62ba1d11a7e1c1febb12e08f1f1c5c08449c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Feb 2024 14:36:06 +0800
Subject: [PATCH 2964/3374] Update
 1764-form-array-by-concatenating-subarrays-of-another-array.js

---
 ...oncatenating-subarrays-of-another-array.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/1764-form-array-by-concatenating-subarrays-of-another-array.js b/1764-form-array-by-concatenating-subarrays-of-another-array.js
index 1fd9fc52..c8013442 100644
--- a/1764-form-array-by-concatenating-subarrays-of-another-array.js
+++ b/1764-form-array-by-concatenating-subarrays-of-another-array.js
@@ -1,3 +1,59 @@
+/**
+ * @param {number[][]} groups
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const canChoose = function (groups, nums) {
+  const dp = new Array(1000).fill(0)
+  const lsps = preprocess(groups)
+  let cur = 0
+  for (let i = 0; i < groups.length; i++) {
+    if (cur >= nums.length) return false
+    cur = find(nums, cur, groups[i], lsps[i])
+    if (cur === -1) return false
+    cur += groups[i].length
+  }
+  return true
+  function find(nums, cur, p, lsp) {
+    const n = nums.length
+    dp[cur] = p[0] === nums[cur] ? 1 : 0
+    if (lsp.length === 1 && dp[cur] === 1) {
+      return cur
+    }
+    for (let i = cur + 1; i < n; i++) {
+      let j = dp[i - 1]
+      while (j > 0 && p[j] !== nums[i]) {
+        j = lsp[j - 1]
+      }
+      dp[i] = j + (p[j] === nums[i])
+      if (dp[i] === p.length) {
+        return i - p.length + 1
+      }
+    }
+    return -1
+  }
+
+  function preprocess(groups) {
+    const rets = []
+    for (let g of groups) {
+      const n = g.length
+      const dp = new Array(n)
+      dp[0] = 0
+      for (let i = 1; i < n; i++) {
+        let j = dp[i - 1]
+        while (j > 0 && g[j] !== g[i]) {
+          j = dp[j - 1]
+        }
+        dp[i] = j + (g[j] === g[i] ? 1 : 0)
+      }
+      rets.push(dp)
+    }
+    return rets
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} groups
  * @param {number[]} nums

From 0367f0526c19f2d26fe3389e574ead2aec4599e6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Feb 2024 12:31:45 +0800
Subject: [PATCH 2965/3374] Create 2301-match-substring-after-replacement.js

---
 2301-match-substring-after-replacement.js | 39 +++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 2301-match-substring-after-replacement.js

diff --git a/2301-match-substring-after-replacement.js b/2301-match-substring-after-replacement.js
new file mode 100644
index 00000000..8d2d3a0f
--- /dev/null
+++ b/2301-match-substring-after-replacement.js
@@ -0,0 +1,39 @@
+let adj = new Uint8Array(3844);
+
+/**
+ * @param {string} ch
+ */
+function encode(ch) {
+  let c = ch.charCodeAt();
+  if (c >= 97) return c - 97;
+  if (c >= 65) return c - 39;
+  return c + 4;
+}
+
+/**
+ * @param {string} s
+ * @param {string} sub
+ * @param {character[][]} mappings
+ * @return {boolean}
+ */
+var matchReplacement = function (s, sub, mappings) {
+  let n = s.length;
+  let m = sub.length;
+
+  adj.fill(0);
+  for (let [cf, ct] of mappings) {
+    adj[encode(cf) * 62 + encode(ct)] = 1;
+  };
+  for (let i = 0; i < 62; ++i) {
+    adj[i * 62 + i] = 1;
+  }
+
+  for (let l = n - m; l >= 0; --l) {
+    for (let d = 0, r = l; ; ++d, ++r) {
+      if (d == m) return true;
+      if (!adj[encode(sub[d]) * 62 + encode(s[r])]) break;
+    }
+  }
+
+  return false;
+};

From e9909d19d87b253ac927b915861b5a69862fe213 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Feb 2024 14:42:13 +0800
Subject: [PATCH 2966/3374] Update 2301-match-substring-after-replacement.js

---
 2301-match-substring-after-replacement.js | 41 +++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2301-match-substring-after-replacement.js b/2301-match-substring-after-replacement.js
index 8d2d3a0f..1e507b5e 100644
--- a/2301-match-substring-after-replacement.js
+++ b/2301-match-substring-after-replacement.js
@@ -1,3 +1,44 @@
+/**
+ * @param {string} ch
+ */
+function encode(ch) {
+  let c = ch.charCodeAt(0)
+  const a = 'a'.charCodeAt(0)
+  const A = 'A'.charCodeAt(0)
+  const zero = '0'.charCodeAt(0)
+  if (c >= a) return c - a;
+  if (c >= A) return c - A + 26;
+  return c - zero + 52;
+}
+
+/**
+ * @param {string} s
+ * @param {string} sub
+ * @param {character[][]} mappings
+ * @return {boolean}
+ */
+const matchReplacement = function (s, sub, mappings) {
+  const adj = Array(62 * 62).fill(0)
+  const m = s.length, n = sub.length
+  for(const ch of sub) adj[encode(ch) * 62 + encode(ch)] = 1
+  for(const [f, t] of mappings) {
+    adj[encode(f) * 62 + encode(t)] = 1
+  }
+  
+  for(let i = m - n; i >= 0; i--) {
+    for(let si = i, j = 0;; si++, j++) {
+      if(j === n) return true
+      if(adj[encode(sub[j]) * 62 + encode(s[si])] === 0) break
+    }
+  }
+  
+  return false
+};
+
+
+// another
+
+
 let adj = new Uint8Array(3844);
 
 /**

From d7d00a1ebe953862f8a288dfd7b54240a69cd96d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 17 Feb 2024 22:52:15 +0800
Subject: [PATCH 2967/3374] Update 28-implement-strStr().js

---
 28-implement-strStr().js | 41 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/28-implement-strStr().js b/28-implement-strStr().js
index 98513914..5bd5a760 100755
--- a/28-implement-strStr().js
+++ b/28-implement-strStr().js
@@ -1,3 +1,44 @@
+/**
+ * @param {string} haystack
+ * @param {string} needle
+ * @return {number}
+ */
+const strStr = function(haystack, needle) {
+  const m = haystack.length, n = needle.length
+  
+  const lps = process(needle)
+  for(let j = 0, i = 0; i < m; i++) {
+    while(j > 0 && haystack[i] !== needle[j]) {
+      j = lps[j - 1]
+    }
+    if(haystack[i] === needle[j]) {
+      j++
+      if(j === n) {
+        return i - n + 1
+      }
+    }
+  }
+  return -1
+  
+  function process(s) {
+    const n = s.length
+    const lps = Array(n).fill(0)
+    for(let len = 0, i = 1; i < n; i++) {
+      while(len > 0 && s[i] !== s[len]) {
+        len = lps[len - 1]
+      }
+      if(s[i] === s[len]) {
+        len++
+        lps[i] = len
+      }
+    }
+    
+    return lps
+  }
+};
+
+// another
+
 /**
  * @param {string} haystack
  * @param {string} needle

From bfe549824590f6cbd7988c9c37b4fbcd41a28930 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Feb 2024 16:49:02 +0800
Subject: [PATCH 2968/3374] Create 3045-count-prefix-and-suffix-pairs-ii.js

---
 3045-count-prefix-and-suffix-pairs-ii.js | 59 ++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 3045-count-prefix-and-suffix-pairs-ii.js

diff --git a/3045-count-prefix-and-suffix-pairs-ii.js b/3045-count-prefix-and-suffix-pairs-ii.js
new file mode 100644
index 00000000..ace89667
--- /dev/null
+++ b/3045-count-prefix-and-suffix-pairs-ii.js
@@ -0,0 +1,59 @@
+class Trie {
+  constructor() {
+    this.word = null
+    this.children = new Array(27)
+    this.cnt = 0
+  }
+}
+/**
+ * @param {string[]} words
+ * @return {number}
+ */
+var countPrefixSuffixPairs = function (words) {
+  const M = 31
+  let rt1 = new Trie()
+  let rt2 = new Trie()
+  let res = 0
+
+  for (let w of words) {
+    res += addAndCount(w)
+  }
+
+  return res
+
+  function addAndCount(w) {
+    let res = 0
+    let pre = rt1
+    let suf = rt2
+    let n = w.length
+
+    for (let i = 0; i < n; i++) {
+      let a = w.charAt(i)
+      let b = w.charAt(n - 1 - i)
+
+      if (!pre.children[a.charCodeAt() & M]) {
+        pre.children[a.charCodeAt() & M] = new Trie()
+      }
+      if (!suf.children[b.charCodeAt() & M]) {
+        suf.children[b.charCodeAt() & M] = new Trie()
+      }
+
+      pre = pre.children[a.charCodeAt() & M]
+      suf = suf.children[b.charCodeAt() & M]
+
+      if (pre.word && suf.word === pre.word) {
+        res += pre.cnt
+      }
+    }
+
+    if (!pre.word) {
+      pre.word = w
+      suf.word = w
+    }
+
+    pre.cnt++
+    suf.cnt++
+
+    return res
+  }
+}

From 53acb6e096713ef43d53312ecf48ecdbd67d4e1f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Feb 2024 16:49:42 +0800
Subject: [PATCH 2969/3374] Create 3044-most-frequent-prime.js

---
 3044-most-frequent-prime.js | 61 +++++++++++++++++++++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 3044-most-frequent-prime.js

diff --git a/3044-most-frequent-prime.js b/3044-most-frequent-prime.js
new file mode 100644
index 00000000..8b7fde30
--- /dev/null
+++ b/3044-most-frequent-prime.js
@@ -0,0 +1,61 @@
+/**
+ * @param {number[][]} mat
+ * @return {number}
+ */
+var mostFrequentPrime = function (mat) {
+  const DIRS = [
+    [1, 1],
+    [1, -1],
+    [-1, 1],
+    [-1, -1],
+    [1, 0],
+    [0, 1],
+    [-1, 0],
+    [0, -1],
+  ]
+
+  const m = mat.length
+  const n = mat[0].length
+  const f = new Map()
+
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      for (const d of DIRS) {
+        let t = 0
+        for (
+          let k = i, l = j;
+          k >= 0 && k < m && l >= 0 && l < n;
+          k += d[0], l += d[1]
+        ) {
+          t = t * 10 + mat[k][l]
+          f.set(t, (f.get(t) || 0) + 1)
+        }
+      }
+    }
+  }
+
+  let res = -1
+  let maxF = 0
+
+  for (const [val, freq] of f.entries()) {
+    if (val <= 10) continue
+    if (freq >= maxF && isPrime(val)) {
+      if (freq === maxF) {
+        res = Math.max(res, val)
+      } else {
+        res = val
+      }
+      maxF = freq
+    }
+  }
+
+  return res
+}
+function isPrime(N) {
+  if (N < 2) return false
+  const R = Math.sqrt(N)
+  for (let d = 2; d <= R; ++d) {
+    if (N % d === 0) return false
+  }
+  return true
+}

From 3ddbefa738d3a6d844ff9e95b87b08b28f8788f4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Feb 2024 16:50:17 +0800
Subject: [PATCH 2970/3374] Create
 3043-find-the-length-of-the-longest-common-prefix.js

---
 ...the-length-of-the-longest-common-prefix.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3043-find-the-length-of-the-longest-common-prefix.js

diff --git a/3043-find-the-length-of-the-longest-common-prefix.js b/3043-find-the-length-of-the-longest-common-prefix.js
new file mode 100644
index 00000000..266ae19a
--- /dev/null
+++ b/3043-find-the-length-of-the-longest-common-prefix.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @return {number}
+ */
+var longestCommonPrefix = function (arr1, arr2) {
+  let f = new Set()
+  for (let i of arr1) {
+    for (; i > 0; i = Math.floor(i / 10)) {
+      f.add(i)
+    }
+  }
+  let res = 0
+  for (let i of arr2) {
+    for (; i > 0; i = Math.floor(i / 10)) {
+      if (f.has(i)) {
+        res = Math.max(res, i.toString().length)
+        break
+      }
+    }
+  }
+  return res
+}

From 35937bcc5d29d58412a81529a14e538750c66742 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Feb 2024 16:50:57 +0800
Subject: [PATCH 2971/3374] Create 3042-count-prefix-and-suffix-pairs-i.js

---
 3042-count-prefix-and-suffix-pairs-i.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3042-count-prefix-and-suffix-pairs-i.js

diff --git a/3042-count-prefix-and-suffix-pairs-i.js b/3042-count-prefix-and-suffix-pairs-i.js
new file mode 100644
index 00000000..576bdace
--- /dev/null
+++ b/3042-count-prefix-and-suffix-pairs-i.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string[]} words
+ * @return {number}
+ */
+var countPrefixSuffixPairs = function (words) {
+  let count = 0
+  for (let i = 0; i < words.length; i++) {
+    for (let j = i + 1; j < words.length; j++) {
+      let str1 = words[i]
+      let str2 = words[j]
+      if (isPrefixAndSuffix(str1, str2)) {
+        count++
+      }
+    }
+  }
+  return count
+  function isPrefixAndSuffix(s1, s2) {
+    if (s2.startsWith(s1) && s2.endsWith(s1)) {
+      return true
+    }
+    return false
+  }
+}

From 4399d7f95a9359b44f8850d31aa843e1547e4f25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 Feb 2024 18:13:57 +0800
Subject: [PATCH 2972/3374] Update 2851-string-transformation.js

---
 2851-string-transformation.js | 67 +++++++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/2851-string-transformation.js b/2851-string-transformation.js
index 7becb586..84013a0f 100644
--- a/2851-string-transformation.js
+++ b/2851-string-transformation.js
@@ -1,3 +1,70 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @param {number} k
+ * @return {number}
+ */
+const numberOfWays = function (s, t, k) {
+  const n = s.length,
+    M = 1e9 + 7
+  const pos = kmp(s + s.slice(0, n-1), t)
+  const fk = [0, 0]
+  calcFK()
+
+  let res = 0
+  for (let p of pos) {
+    if (p === 0) res = (res + fk[0]) % M
+    else res = (res + fk[1]) % M
+  }
+  return res
+
+  function kmp(s, t) {
+    const m = s.length,
+      n = t.length
+    const pi = new Array(n).fill(0)
+    for (let i = 1; i < n; ++i) {
+      let j = pi[i - 1]
+      while (j > 0 && t.charAt(j) !== t.charAt(i)) j = pi[j - 1]
+      if (j === 0 && t.charAt(0) !== t.charAt(i)) pi[i] = 0
+      else pi[i] = j + 1
+    }
+    let j = 0
+    const res = []
+    for (let i = 0; i < m; ++i) {
+      while (j >= n || (j > 0 && s.charAt(i) !== t.charAt(j))) j = pi[j - 1]
+      if (s.charAt(i) === t.charAt(j)) j++
+      if (j === n) res.push(i - n + 1)
+    }
+    return res
+  }
+  
+  function calcFK() {
+    fk[1] =
+      (((powWrap(n - 1, k, M) + BigInt(((k % 2) * 2 - 1)) + BigInt(M)) % BigInt(M)) * powWrap(n, M - 2, M)) % BigInt(M)
+    fk[0] = (fk[1] - BigInt(((k % 2) * 2 - 1)) + BigInt(M)) % BigInt(M)
+    // console.log(fk)
+    fk[1] = Number(fk[1])
+    fk[0] = Number(fk[0])
+  }
+  
+  function powWrap(a,b,M) {
+    a = BigInt(a)
+    b = BigInt(b)
+    M = BigInt(M)
+    return pow(a,b,M)
+  }
+  
+  function pow(a, b, M) {
+    if (b === 0n) return 1n
+    if ((b & 1n) === 0n) return pow((a * a) % M, b >> 1n, M)
+    return (a * pow((a * a) % M, b >> 1n, M)) % M
+  }  
+}
+
+
+// another
+
+
 class Modulo {
   /**
    * @param {number} modulo

From ab956d281c390762fe7687a513801061bc2fc40a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Feb 2024 18:00:33 +0800
Subject: [PATCH 2973/3374] Update
 3008-find-beautiful-indices-in-the-given-array-ii.js

---
 ...beautiful-indices-in-the-given-array-ii.js | 82 +++++++++++++++++++
 1 file changed, 82 insertions(+)

diff --git a/3008-find-beautiful-indices-in-the-given-array-ii.js b/3008-find-beautiful-indices-in-the-given-array-ii.js
index 64d5e414..578fdaf5 100644
--- a/3008-find-beautiful-indices-in-the-given-array-ii.js
+++ b/3008-find-beautiful-indices-in-the-given-array-ii.js
@@ -1,3 +1,85 @@
+/**
+ * @param {string} s
+ * @param {string} a
+ * @param {string} b
+ * @param {number} k
+ * @return {number[]}
+ */
+var beautifulIndices = function (s, a, b, k) {
+  const is = kmp(s, a)
+  if (is.length === 0) return []
+  
+  const js = kmp(s, b)
+  if (js.length === 0) return []
+
+  const answer = []
+  let p = 0
+  let q = 0
+
+  while (p < is.length && q < js.length) {
+    const distance = Math.abs(is[p] - js[q])
+
+    if (distance <= k) {
+      answer.push(is[p])
+      p++
+    } else if (is[p] < js[q]) {
+      p++
+    } else {
+      q++
+    }
+  }
+
+  return answer
+}
+
+function kmp(str1, str2) {
+  const pattern = buildPattern(str2)
+
+  const answer = []
+  let i = 0
+  let j = 0
+
+  while (i < str1.length) {
+    if (str1[i] === str2[j]) {
+      i++
+      j++
+
+      if (j === str2.length) {
+        answer.push(i - str2.length)
+        j = pattern[j - 1] + 1
+      }
+    } else if (j > 0) {
+      j = pattern[j - 1] + 1
+    } else {
+      i++
+    }
+  }
+
+  return answer
+}
+
+function buildPattern(str) {
+  const pattern = new Array(str.length).fill(-1)
+  let i = 1
+  let j = 0
+
+  while (i < str.length) {
+    if (str[i] === str[j]) {
+      pattern[i] = j
+      i++
+      j++
+    } else if (j > 0) {
+      j = pattern[j - 1] + 1
+    } else {
+      i++
+    }
+  }
+
+  return pattern
+}
+
+// another
+
 /**
  * @param {string} s
  * @param {string} a

From 95411efab64452837f3e7cfddbc551aa422ef825 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Feb 2024 18:49:56 +0800
Subject: [PATCH 2974/3374] Update
 3008-find-beautiful-indices-in-the-given-array-ii.js

---
 ...beautiful-indices-in-the-given-array-ii.js | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/3008-find-beautiful-indices-in-the-given-array-ii.js b/3008-find-beautiful-indices-in-the-given-array-ii.js
index 578fdaf5..905ac00b 100644
--- a/3008-find-beautiful-indices-in-the-given-array-ii.js
+++ b/3008-find-beautiful-indices-in-the-given-array-ii.js
@@ -12,7 +12,7 @@ var beautifulIndices = function (s, a, b, k) {
   const js = kmp(s, b)
   if (js.length === 0) return []
 
-  const answer = []
+  const res = []
   let p = 0
   let q = 0
 
@@ -20,7 +20,7 @@ var beautifulIndices = function (s, a, b, k) {
     const distance = Math.abs(is[p] - js[q])
 
     if (distance <= k) {
-      answer.push(is[p])
+      res.push(is[p])
       p++
     } else if (is[p] < js[q]) {
       p++
@@ -29,13 +29,13 @@ var beautifulIndices = function (s, a, b, k) {
     }
   }
 
-  return answer
+  return res
 }
 
 function kmp(str1, str2) {
   const pattern = buildPattern(str2)
 
-  const answer = []
+  const res = []
   let i = 0
   let j = 0
 
@@ -43,33 +43,32 @@ function kmp(str1, str2) {
     if (str1[i] === str2[j]) {
       i++
       j++
-
       if (j === str2.length) {
-        answer.push(i - str2.length)
-        j = pattern[j - 1] + 1
+        res.push(i - str2.length)
+        j = pattern[j - 1]
       }
     } else if (j > 0) {
-      j = pattern[j - 1] + 1
+      j = pattern[j - 1]
     } else {
       i++
     }
   }
 
-  return answer
+  return res
 }
 
 function buildPattern(str) {
-  const pattern = new Array(str.length).fill(-1)
+  const pattern = new Array(str.length).fill(0)
   let i = 1
   let j = 0
 
   while (i < str.length) {
     if (str[i] === str[j]) {
+      j++
       pattern[i] = j
       i++
-      j++
     } else if (j > 0) {
-      j = pattern[j - 1] + 1
+      j = pattern[j - 1]
     } else {
       i++
     }
@@ -78,6 +77,7 @@ function buildPattern(str) {
   return pattern
 }
 
+
 // another
 
 /**

From 88d23b08c684c98f34a4455f02595a050ba3bc90 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Feb 2024 20:06:58 +0800
Subject: [PATCH 2975/3374] Create
 3031-minimum-time-to-revert-word-to-initial-state-ii.js

---
 ...time-to-revert-word-to-initial-state-ii.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3031-minimum-time-to-revert-word-to-initial-state-ii.js

diff --git a/3031-minimum-time-to-revert-word-to-initial-state-ii.js b/3031-minimum-time-to-revert-word-to-initial-state-ii.js
new file mode 100644
index 00000000..6906f960
--- /dev/null
+++ b/3031-minimum-time-to-revert-word-to-initial-state-ii.js
@@ -0,0 +1,20 @@
+/**
+ * @param {string} word
+ * @param {number} k
+ * @return {number}
+ */
+var minimumTimeToInitialState = function(word, k) {
+  const n = word.length;
+  let v = 0;
+  let dp = new Array(n).fill(0);
+  for (let i = 1; i < n; i++) {
+    while (v > 0 && word.charAt(i) != word.charAt(v)) {
+      v = dp[v - 1];
+    }
+    v = dp[i] = v + (word.charAt(i) == word.charAt(v) ? 1 : 0);
+  }
+  while (v > 0 && (n - v) % k > 0) {
+    v = dp[v - 1];
+  }
+  return Math.ceil((n - v) / k);  
+};

From a96b15806d9059ff8f1643ee50e0b36cc8d93060 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Feb 2024 18:38:29 +0800
Subject: [PATCH 2976/3374] Create
 3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js

---
 ...ray-into-subarrays-with-minimum-cost-ii.js | 651 ++++++++++++++++++
 1 file changed, 651 insertions(+)
 create mode 100644 3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js

diff --git a/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js b/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js
new file mode 100644
index 00000000..aa249ecd
--- /dev/null
+++ b/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js
@@ -0,0 +1,651 @@
+//#region AVL Tree
+/**
+ * @typedef {"keep-all" | "override" | "ignore"} DuplicateMode
+ */
+/**
+ * @template TItem
+ * @typedef {(a: TItem, b: TItem) => number} Comparer<TItem>
+ */
+/**
+ * @template TItem
+ * @typedef {Object} AvlConfigs<TItem>
+ * @property {Comparer<TItem>} comparer
+ * @property {DuplicateMode} duplicateMode Defines the behavior to add a node when the result of comparer is 0.
+ * @property {AvlNodesPool} nodesPool Keeping node instances to avoid creating too many AVL Nodes.
+ */
+
+/**
+ * @template TItem
+ */
+class AvlNode {
+  /** @type {AvlNode<TItem> | undefined} */
+  left;
+  /** @type {AvlNode<TItem> | undefined} */
+  right;
+
+  /** @type {TItem} */
+  value;
+
+  /** @type {number} */
+  height;
+  /** @type {number} */
+  size;
+
+  /**
+   * @param {TItem} value
+   */
+  constructor(value) {
+    this.value = value;
+    this.height = 1;
+    this.size = 1;
+  }
+
+  getBalanceFactor() {
+    return (this.left?.height ?? 0) - (this.right?.height ?? 0);
+  }
+
+  recalculateHeight() {
+    this.height = 1 + Math.max(this.left?.height ?? 0, this.right?.height ?? 0);
+  }
+
+  recalculateSize() {
+    this.size = 1 + (this.left?.size ?? 0) + (this.right?.size ?? 0);
+  }
+
+  dispose() {
+    delete this.left;
+    delete this.right;
+    delete this.height;
+    delete this.value;
+    delete this.height;
+    delete this.size;
+  }
+}
+
+/**
+ * @template TItem
+ */
+class AvlTree {
+  //#region Constructor
+  /**
+   * @param {AvlConfigs<TItem>} configs
+   */
+  constructor(configs) {
+    /** @private */
+    this._comparer = configs.comparer;
+    /** @private */
+    this._duplicationMode = configs.duplicateMode ?? "keep-all";
+    /** @private */
+    this._nodesPool = configs.nodesPool;
+
+    /** @private @type {AvlNode<TItem> | undefined} */
+    this._root = undefined;
+  }
+
+  get size() {
+    return this._root?.size ?? 0;
+  }
+
+  /**
+   * @private
+   * @param {number} order
+   * @returns {number}
+   */
+  _adjustOrder(order) {
+    return ((order % this.size) + this.size) % this.size;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} parent
+   * @param {number} parentOrder
+   */
+  _calculateLeftNodeOrder(parent, parentOrder) {
+    return parentOrder - 1 - (parent?.left?.right?.size ?? 0);
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} parent
+   * @param {number} parentOrder
+   */
+  _calculateRightNodeOrder(parent, parentOrder) {
+    return parentOrder + 1 + (parent?.right?.left?.size ?? 0);
+  }
+  //#endregion
+
+  //#region Balancing
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateLeft(node) {
+    let newTop = node.right;
+    node.right = newTop.left;
+    newTop.left = node;
+
+    node.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateRight(node) {
+    let newTop = node.left;
+    node.left = newTop.right;
+    newTop.right = node;
+
+    node.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateDoubleLeft(node) {
+    let newRight = node.right;
+    let newTop = newRight.left;
+    node.right = newTop.left;
+    newRight.left = newTop.right;
+    newTop.left = node;
+    newTop.right = newRight;
+
+    node.recalculateHeight();
+    newRight.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newRight.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateDoubleRight(node) {
+    let newLeft = node.left;
+    let newTop = newLeft.right;
+    node.left = newTop.right;
+    newLeft.right = newTop.left;
+    newTop.right = node;
+    newTop.left = newLeft;
+
+    node.recalculateHeight();
+    newLeft.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newLeft.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _balance(node) {
+    let bf = node.getBalanceFactor();
+    if (bf < -1) {
+      bf = node.right.getBalanceFactor();
+      if (bf < 0) return this._rotateLeft(node);
+      else return this._rotateDoubleLeft(node);
+    } else if (bf > 1) {
+      bf = node.left.getBalanceFactor();
+      if (bf > 0) return this._rotateRight(node);
+      else return this._rotateDoubleRight(node);
+    }
+
+    return node;
+  }
+  //#endregion
+
+  //#region Add
+  /**
+   * @private
+   * @param {TItem} item
+   * @returns {AvlNode<TItem>}
+   */
+  _createNode(item) {
+    if (this._nodesPool) return this._nodesPool.provide(item);
+    return new AvlNode(item);
+  }
+
+  /**
+   * @private
+   * @param {TItem} item
+   * @param {AvlNode<TItem> | undefined} node
+   * @returns {AvlNode<TItem>}
+   */
+  _addFromNode(item, node) {
+    if (!node) return this._createNode(item);
+    const cmp = this._comparer(item, node.value);
+    const isToLeftNode = cmp < 0;
+
+    if (cmp == 0) {
+      switch (this._duplicationMode) {
+        case "keep-all":
+          break;
+        case "override": {
+          node.value = item;
+          return node;
+        }
+        case "ignore": {
+          return node;
+        }
+      }
+    }
+
+    if (isToLeftNode) node.left = this._addFromNode(item, node.left);
+    else node.right = this._addFromNode(item, node.right);
+    node.recalculateHeight();
+    node.recalculateSize();
+    return this._balance(node);
+  }
+
+  /**
+   * @param {...TItem} items
+   */
+  add(...items) {
+    for (let i = 0; i < items.length; i++) {
+      this._root = this._addFromNode(items[i], this._root);
+    }
+  }
+  //#endregion
+
+  //#region Retrieve
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _findLeftMostFromNode(node) {
+    let res = node;
+    while (res?.left) res = res.left;
+    return res;
+  }
+
+  findLeftMostItem() {
+    return this._findLeftMostFromNode(this._root)?.value;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _findRightMostFromNode(node) {
+    let res = node;
+    while (res?.right) res = res.right;
+    return res;
+  }
+
+  findRightMostItem() {
+    return this._findRightMostFromNode(this._root)?.value;
+  }
+
+  /**
+   * @private
+   * @param {number} order
+   * @returns {AvlNode<TItem>}
+   */
+  _getNodeAt(order) {
+    if (!this.size) return undefined;
+
+    order = this._adjustOrder(order);
+    let res = this._root;
+    let leftSize = res;
+
+    while (true) {
+      leftSize = res.left?.size ?? 0;
+      if (order === leftSize) return res;
+      if (order < leftSize) {
+        res = res.left;
+      } else {
+        res = res.right;
+        order -= leftSize + 1;
+      }
+    }
+  }
+
+  /**
+   * @param {number} order
+   * @returns {TItem}
+   */
+  getItemAt(order) {
+    return this._getNodeAt(order)?.value;
+  }
+
+  /**
+   * @param {TItem} item
+   * @param {number} start
+   * @returns {number}
+   */
+  findFirstOrder(item, start = 0) {
+    if (!this.size) return -1;
+    start = this._adjustOrder(start);
+
+    let node = this._root;
+    let order = node.left?.size ?? 0;
+    let res = -1;
+
+    while (node) {
+      if (order < start) {
+        order = this._calculateRightNodeOrder(node, order);
+        node = node.right;
+      } else {
+        let cmp = this._comparer(item, node.value);
+        if (cmp === 0) res = order;
+        if (cmp <= 0) {
+          order = this._calculateLeftNodeOrder(node, order);
+          node = node?.left;
+        } else {
+          order = this._calculateRightNodeOrder(node, order);
+          node = node.right;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @param {TItem} item
+   * @param {number} end
+   * @returns {number}
+   */
+  findLastOrder(item, end = -1) {
+    if (!this.size) return -1;
+    end = this._adjustOrder(end);
+
+    let node = this._root;
+    let order = node.left?.size ?? 0;
+    let res = -1;
+
+    while (node) {
+      if (order > end) {
+        order = this._calculateLeftNodeOrder(node, order);
+        node = node.left;
+      } else {
+        let cmp = this._comparer(item, node.value);
+        if (cmp === 0) res = order;
+        if (cmp < 0) {
+          order = this._calculateLeftNodeOrder(node, order);
+          node = node?.left;
+        } else {
+          order = this._calculateRightNodeOrder(node, order);
+          node = node.right;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @param {TItem} item
+   * @returns {number}
+   */
+  count(item) {
+    let first = this.findFirstOrder(item);
+    if (first === -1) return 0;
+    let last = this.findLastOrder(item);
+    return last - first + 1;
+  }
+
+  /**
+   * Find the right-est value that can be added to the the left of item
+   * @param {TItem} item
+   * @returns {TItem | undefined}
+   */
+  findLeftBound(item) {
+    let node = this._root;
+    let res = undefined;
+
+    while (node) {
+      let cmp = this._comparer(item, node.value);
+      if (cmp < 0) node = node.left;
+      else {
+        res = node.value;
+        node = node.right;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Find the left-est value that can be added to the the right of item
+   * @param {TItem} item
+   * @returns {TItem | undefined}
+   */
+  findRightBound(item) {
+    let node = this._root;
+    let res = undefined;
+
+    while (node) {
+      let cmp = this._comparer(item, node.value);
+      if (cmp > 0) node = node.right;
+      else {
+        res = node.value;
+        node = node.left;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @private
+   * @param {(item: TItem, order: number) => any} fn
+   * @param {AvlNode<TItem>} node
+   * @param {number} startOrder
+   */
+  _forLeftToRightNode(fn, node, startOrder) {
+    if (!node) return;
+    this._forLeftToRightNode(fn, node.left, startOrder);
+    fn(node.value, startOrder + (node.left?.size ?? 0));
+    this._forLeftToRightNode(
+      fn,
+      node.right,
+      startOrder + (node.left?.size ?? 0) + 1
+    );
+  }
+  /**
+   * @param {(item: TItem, order: number) => any} fn
+   */
+  forLeftToRight(fn) {
+    this._forLeftToRightNode(fn, this._root, 0);
+  }
+
+  /**
+   * @private
+   * @param {(item: TItem, order: number) => any} fn
+   * @param {AvlNode<TItem>} node
+   * @param {number} startOrder
+   */
+  _forRightToLeftNode(fn, node, startOrder) {
+    if (!node) return;
+    this._forRightToLeftNode(fn, node.right, startOrder);
+    fn(node.value, startOrder - (node.right?.size ?? 0));
+    this._forRightToLeftNode(
+      fn,
+      node.left,
+      startOrder - (node.right?.size ?? 0) - 1
+    );
+  }
+
+  /**
+   * @param {(item: TItem, order: number) => any} fn
+   */
+  forRightToLeft(fn) {
+    this._forRightToLeftNode(fn, this._root, this.size - 1);
+  }
+  //#endregion
+
+  //#region Remove
+  /**
+   * @private
+   * @param {AvlNode} node
+   */
+  _destroyNode(node) {
+    if (this._nodesPool) this._nodesPool.return(node);
+    else node.dispose();
+  }
+
+  /**
+   * @private
+   * @param {TItem} item
+   * @param {AvlNode<TItem> | undefined} node
+   * @returns {AvlNode<TItem>}
+   */
+  _removeFromNode(item, node) {
+    if (!node) return node;
+
+    const cmp = this._comparer(item, node.value);
+    if (cmp < 0) node.left = this._removeFromNode(item, node.left);
+    else if (cmp > 0) node.right = this._removeFromNode(item, node.right);
+    else {
+      if (!node.left) {
+        let child = node.right;
+        this._destroyNode(node);
+        return child;
+      }
+      if (!node.right) {
+        let child = node.left;
+        this._destroyNode(node);
+        return child;
+      }
+
+      let leftMostOfRight = this._findLeftMostFromNode(node.right);
+      node.value = leftMostOfRight.value;
+      node.right = this._removeFromNode(leftMostOfRight.value, node.right);
+    }
+    node.recalculateHeight();
+    node.recalculateSize();
+    return this._balance(node);
+  }
+
+  /**
+   * @param {...TItem} items
+   */
+  remove(...items) {
+    for (let i = 0; i < items.length; i++) {
+      this._root = this._removeFromNode(items[i], this._root);
+    }
+  }
+
+  /**
+   * @param {AvlNode} node
+   */
+  _clearFromNode(node) {
+    if (!node) return;
+    if (node.left) this._clearFromNode(node.left);
+    if (node.right) this._clearFromNode(node.right);
+    this._destroyNode(node);
+  }
+
+  clear() {
+    if (!this._root) return;
+    this._clearFromNode(this._root);
+    delete this._root;
+  }
+  //#endregion
+}
+//#endregion
+
+//#region AVL Nodes Pool
+class AvlNodesPool {
+  /**
+   * @private
+   * @type {AvlNode[]}
+   */
+  _nodes = [];
+  /**
+   * @private
+   * @type {number}
+   */
+  _top = 0;
+
+  provide(value) {
+    if (this._top) {
+      let result = this._nodes[--this._top];
+      result.value = value;
+      result.left = null;
+      result.right = null;
+      result.size = 1;
+      result.height = 1;
+      return result;
+    }
+    return new AvlNode(value);
+  }
+
+  /**
+   * @param {AvlNode} node
+   */
+  return(node) {
+    if (this._top === this._nodes.length) this._nodes.push(node);
+    else this._nodes[this._top] = node;
+    this._top++;
+  }
+}
+//#endregion
+
+let avl = new AvlTree({
+  comparer: (a, b) => a - b,
+  duplicateMode: "keep-all",
+  nodesPool: new AvlNodesPool(),
+});
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} dist
+ * @return {number}
+ */
+var minimumCost = function (nums, k, dist) {
+  let n = nums.length;
+  avl.clear();
+
+  let sum = 0;
+  for (let i = 1; i < k; ++i) {
+    sum += nums[i];
+    avl.add(nums[i]);
+  }
+  let res = sum;
+
+  for (let i = k; i < n; ++i) {
+    avl.add(nums[i]);
+    let p = avl.findLastOrder(nums[i]);
+    if (p < k - 1) {
+      sum += nums[i];
+      sum -= avl.getItemAt(k - 1);
+    }
+    if (i - dist > 1) {
+      p = avl.findLastOrder(nums[i - dist - 1]);
+      avl.remove(nums[i - dist - 1]);
+      if (p < k - 1) {
+        sum -= nums[i - dist - 1];
+        sum += avl.getItemAt(k - 2);
+      }
+    }
+
+    res = Math.min(res, sum);
+  }
+
+  return res + nums[0];
+};

From 58485993f2cc747ce8111d9c66662210cd6c8891 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 27 Feb 2024 18:41:27 +0800
Subject: [PATCH 2977/3374] Update
 3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js

---
 ...ray-into-subarrays-with-minimum-cost-ii.js | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)

diff --git a/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js b/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js
index aa249ecd..8c181741 100644
--- a/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js
+++ b/3013-divide-an-array-into-subarrays-with-minimum-cost-ii.js
@@ -1,3 +1,86 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} dist
+ * @return {number}
+ */
+var minimumCost = function (nums, k, dist) {
+  // store k-1 smallest elements
+  const maxHeap = new PriorityQueue({ compare: (a, b) => b - a })
+  // store dist - k + 1 biggest elements
+  const minHeap = new PriorityQueue({ compare: (a, b) => a - b })
+  const maxDiscard = {}
+  const minDiscard = {}
+  let sum = nums[0]
+  let start = 1
+  let end = start
+  while (end - start < k - 1) {
+    maxHeap.enqueue(nums[end])
+    sum += nums[end]
+    end++
+  }
+  // now there are k-1 elemetns in the Max heap
+  while (end - start <= dist) {
+    maxHeap.enqueue(nums[end])
+    sum += nums[end]
+    let dequeued = maxHeap.dequeue()
+    sum -= dequeued
+    minHeap.enqueue(dequeued)
+    end++
+  }
+
+  let minSum = sum
+  while (end < nums.length) {
+    if (k - 2 === dist) {
+      sum += nums[end++]
+      sum -= nums[start++]
+    } else {
+      discardMin()
+
+      if (nums[start] < minHeap.front()) {
+        maxDiscard[nums[start]] = 1 + (maxDiscard[nums[start]] ?? 0)
+        sum -= nums[start]
+
+        sum += minHeap.front()
+        maxHeap.enqueue(minHeap.dequeue())
+      } else minDiscard[nums[start]] = 1 + (minDiscard[nums[start]] ?? 0)
+
+      maxHeap.enqueue(nums[end])
+      sum += nums[end]
+
+      discardMax()
+      sum -= maxHeap.front()
+      minHeap.enqueue(maxHeap.dequeue())
+
+      end++
+      start++
+    }
+    minSum = Math.min(minSum, sum)
+  }
+
+  function discardMax() {
+    if (maxHeap.isEmpty()) return
+
+    while (maxDiscard[maxHeap.front()]) {
+      maxDiscard[maxHeap.front()]--
+      maxHeap.dequeue()
+    }
+  }
+  function discardMin() {
+    if (minHeap.isEmpty()) return
+
+    while (minDiscard[minHeap.front()]) {
+      minDiscard[minHeap.front()]--
+      minHeap.dequeue()
+    }
+  }
+
+  return minSum
+}
+
+// another
+
+
 //#region AVL Tree
 /**
  * @typedef {"keep-all" | "override" | "ignore"} DuplicateMode

From a07264df26f6b32a099b317b665c45b6681b4882 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 Feb 2024 20:38:03 +0800
Subject: [PATCH 2978/3374] Update
 1942-the-number-of-the-smallest-unoccupied-chair.js

---
 ...number-of-the-smallest-unoccupied-chair.js | 103 ++++++++++++++++++
 1 file changed, 103 insertions(+)

diff --git a/1942-the-number-of-the-smallest-unoccupied-chair.js b/1942-the-number-of-the-smallest-unoccupied-chair.js
index 0876ec69..643058c6 100644
--- a/1942-the-number-of-the-smallest-unoccupied-chair.js
+++ b/1942-the-number-of-the-smallest-unoccupied-chair.js
@@ -1,3 +1,106 @@
+/**
+ * @param {number[][]} times
+ * @param {number} targetFriend
+ * @return {number}
+ */
+const smallestChair = function(times, targetFriend) {
+  times.forEach((e, i) => e[2] = i)
+  times.sort((a, b) => a[0] - b[0])
+  const pq = new PQ((a, b) => a[1] < b[1])
+  const available = new PQ((a, b) => a < b)
+  const n = times.length
+  for(let i = 0; i < n; i++) {
+    available.push(i)
+  }
+  const seat = available.pop()
+  times[0].push(seat)
+  pq.push(times[0])
+  if(times[0][2] === targetFriend) return seat
+  for(let i = 1; i < n; i++) {
+    const el = times[i]
+    const [s, e, idx] = el
+    while(!pq.isEmpty() && pq.peek()[1] <= s) {
+      const tmp = pq.pop()
+      available.push(tmp[3])
+    }
+    const seat = available.pop()
+    if(targetFriend === idx) return seat
+    el.push(seat)
+    pq.push(el)
+  }
+  
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[][]} times
  * @param {number} targetFriend

From 492e715b99d556b44c2633d517912aa62cab6b77 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Mar 2024 19:59:47 +0800
Subject: [PATCH 2979/3374] Create
 3069-distribute-elements-into-two-arrays-i.js

---
 3069-distribute-elements-into-two-arrays-i.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 3069-distribute-elements-into-two-arrays-i.js

diff --git a/3069-distribute-elements-into-two-arrays-i.js b/3069-distribute-elements-into-two-arrays-i.js
new file mode 100644
index 00000000..966a77aa
--- /dev/null
+++ b/3069-distribute-elements-into-two-arrays-i.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var resultArray = function(nums) {
+  const n = nums.length
+  const a1 = [], a2 = []
+  a1.push(nums[0])
+  a2.push(nums[1])
+  for(let i = 2; i < n; i++) {
+    const e = nums[i]
+    const l1 = a1[a1.length - 1], l2 = a2[a2.length - 1]
+    if(l1 > l2) {
+      a1.push(e)
+    } else {
+      a2.push(e)
+    }
+  }
+  
+  return a1.concat(a2)
+};

From 18c326d50642d54169f07651ea30e7e2d0764862 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Mar 2024 20:00:16 +0800
Subject: [PATCH 2980/3374] Create
 3070-count-submatrices-with-top-left-element-and-sum-less-than-k.js

---
 ...th-top-left-element-and-sum-less-than-k.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 3070-count-submatrices-with-top-left-element-and-sum-less-than-k.js

diff --git a/3070-count-submatrices-with-top-left-element-and-sum-less-than-k.js b/3070-count-submatrices-with-top-left-element-and-sum-less-than-k.js
new file mode 100644
index 00000000..f451b12f
--- /dev/null
+++ b/3070-count-submatrices-with-top-left-element-and-sum-less-than-k.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ */
+var countSubmatrices = function (grid, k) {
+  const n = grid.length
+  const m = grid[0].length
+  const acc = new Array(m + 1).fill(0)
+
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    const tmp = new Array(m + 1).fill(0)
+    for (let j = 0; j < m; j++) {
+      tmp[j + 1] = tmp[j] + grid[i][j]
+    }
+
+    for (let j = 0; j < m; j++) {
+      acc[j + 1] += tmp[j + 1]
+      if (acc[j + 1] <= k) {
+        res += 1
+      }
+    }
+  }
+  return res
+}

From e319489a63323c3bbc618bd9dbf7b4fc8d62c2af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Mar 2024 20:00:45 +0800
Subject: [PATCH 2981/3374] Create
 3071-minimum-operations-to-write-the-letter-y-on-a-grid.js

---
 ...rations-to-write-the-letter-y-on-a-grid.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 3071-minimum-operations-to-write-the-letter-y-on-a-grid.js

diff --git a/3071-minimum-operations-to-write-the-letter-y-on-a-grid.js b/3071-minimum-operations-to-write-the-letter-y-on-a-grid.js
new file mode 100644
index 00000000..3caf484f
--- /dev/null
+++ b/3071-minimum-operations-to-write-the-letter-y-on-a-grid.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumOperationsToWriteY = function (grid) {
+  const mapY = new Map()
+  const mapNotY = new Map()
+  const n = grid.length
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < n; j++) {
+      let inY = false
+      if (i <= n / 2) {
+        if (i === j || i + j === n - 1) {
+          inY = true
+        }
+      } else {
+        if (j === Math.floor(n / 2)) {
+          inY = true
+        }
+      }
+
+      const item = grid[i][j]
+      if (inY) {
+        mapY.set(item, (mapY.get(item) || 0) + 1)
+      } else {
+        mapNotY.set(item, (mapNotY.get(item) || 0) + 1)
+      }
+    }
+  }
+  const countY = n + Math.floor(n / 2)
+  const countNotY = n * n - countY
+  let res = Infinity
+  for (let a = 0; a <= 2; a++) {
+    for (let b = 0; b <= 2; b++) {
+      if (a === b) continue
+      const tmp1 = mapY.get(a) || 0
+      const tmp2 = mapNotY.get(b) || 0
+
+      const tmp = countY - tmp1 + (countNotY - tmp2)
+      res = Math.min(res, tmp)
+    }
+  }
+  return res
+}

From fa961879ddf24a908c2e39a3f43aaf8ba5e24193 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Mar 2024 20:02:05 +0800
Subject: [PATCH 2982/3374] Create
 3072-distribute-elements-into-two-arrays-ii.js

---
 ...-distribute-elements-into-two-arrays-ii.js | 657 ++++++++++++++++++
 1 file changed, 657 insertions(+)
 create mode 100644 3072-distribute-elements-into-two-arrays-ii.js

diff --git a/3072-distribute-elements-into-two-arrays-ii.js b/3072-distribute-elements-into-two-arrays-ii.js
new file mode 100644
index 00000000..ea9db49d
--- /dev/null
+++ b/3072-distribute-elements-into-two-arrays-ii.js
@@ -0,0 +1,657 @@
+//#region AVL Tree
+/**
+ * @typedef {"keep-all" | "override" | "ignore"} DuplicateMode
+ */
+/**
+ * @template TItem
+ * @typedef {(a: TItem, b: TItem) => number} Comparer<TItem>
+ */
+/**
+ * @template TItem
+ * @typedef {Object} AvlConfigs<TItem>
+ * @property {Comparer<TItem>} comparer
+ * @property {DuplicateMode} duplicateMode Defines the behavior to add a node when the result of comparer is 0.
+ * @property {AvlNodesPool} nodesPool Keeping node instances to avoid creating too many AVL Nodes.
+ */
+
+/**
+ * @template TItem
+ */
+class AvlNode {
+  /** @type {AvlNode<TItem> | undefined} */
+  left;
+  /** @type {AvlNode<TItem> | undefined} */
+  right;
+
+  /** @type {TItem} */
+  value;
+
+  /** @type {number} */
+  height;
+  /** @type {number} */
+  size;
+
+  /**
+   * @param {TItem} value
+   */
+  constructor(value) {
+    this.value = value;
+    this.height = 1;
+    this.size = 1;
+  }
+
+  getBalanceFactor() {
+    return (this.left?.height ?? 0) - (this.right?.height ?? 0);
+  }
+
+  recalculateHeight() {
+    this.height = 1 + Math.max(this.left?.height ?? 0, this.right?.height ?? 0);
+  }
+
+  recalculateSize() {
+    this.size = 1 + (this.left?.size ?? 0) + (this.right?.size ?? 0);
+  }
+
+  dispose() {
+    delete this.left;
+    delete this.right;
+    delete this.height;
+    delete this.value;
+    delete this.height;
+    delete this.size;
+  }
+}
+
+/**
+ * @template TItem
+ */
+class AvlTree {
+  //#region Constructor
+  /**
+   * @param {AvlConfigs<TItem>} configs
+   */
+  constructor(configs) {
+    /** @private */
+    this._comparer = configs.comparer;
+    /** @private */
+    this._duplicationMode = configs.duplicateMode ?? "keep-all";
+    /** @private */
+    this._nodesPool = configs.nodesPool;
+
+    /** @private @type {AvlNode<TItem> | undefined} */
+    this._root = undefined;
+  }
+
+  get size() {
+    return this._root?.size ?? 0;
+  }
+
+  /**
+   * @private
+   * @param {number} order
+   * @returns {number}
+   */
+  _adjustOrder(order) {
+    return ((order % this.size) + this.size) % this.size;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} parent
+   * @param {number} parentOrder
+   */
+  _calculateLeftNodeOrder(parent, parentOrder) {
+    return parentOrder - 1 - (parent?.left?.right?.size ?? 0);
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} parent
+   * @param {number} parentOrder
+   */
+  _calculateRightNodeOrder(parent, parentOrder) {
+    return parentOrder + 1 + (parent?.right?.left?.size ?? 0);
+  }
+  //#endregion
+
+  //#region Balancing
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateLeft(node) {
+    let newTop = node.right;
+    node.right = newTop.left;
+    newTop.left = node;
+
+    node.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateRight(node) {
+    let newTop = node.left;
+    node.left = newTop.right;
+    newTop.right = node;
+
+    node.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateDoubleLeft(node) {
+    let newRight = node.right;
+    let newTop = newRight.left;
+    node.right = newTop.left;
+    newRight.left = newTop.right;
+    newTop.left = node;
+    newTop.right = newRight;
+
+    node.recalculateHeight();
+    newRight.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newRight.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _rotateDoubleRight(node) {
+    let newLeft = node.left;
+    let newTop = newLeft.right;
+    node.left = newTop.right;
+    newLeft.right = newTop.left;
+    newTop.right = node;
+    newTop.left = newLeft;
+
+    node.recalculateHeight();
+    newLeft.recalculateHeight();
+    newTop.recalculateHeight();
+    node.recalculateSize();
+    newLeft.recalculateSize();
+    newTop.recalculateSize();
+    return newTop;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _balance(node) {
+    let bf = node.getBalanceFactor();
+    if (bf < -1) {
+      bf = node.right.getBalanceFactor();
+      if (bf < 0) return this._rotateLeft(node);
+      else return this._rotateDoubleLeft(node);
+    } else if (bf > 1) {
+      bf = node.left.getBalanceFactor();
+      if (bf > 0) return this._rotateRight(node);
+      else return this._rotateDoubleRight(node);
+    }
+
+    return node;
+  }
+  //#endregion
+
+  //#region Add
+  /**
+   * @private
+   * @param {TItem} item
+   * @returns {AvlNode<TItem>}
+   */
+  _createNode(item) {
+    if (this._nodesPool) return this._nodesPool.provide(item);
+    return new AvlNode(item);
+  }
+
+  /**
+   * @private
+   * @param {TItem} item
+   * @param {AvlNode<TItem> | undefined} node
+   * @returns {AvlNode<TItem>}
+   */
+  _addFromNode(item, node) {
+    if (!node) return this._createNode(item);
+    const cmp = this._comparer(item, node.value);
+    const isToLeftNode = cmp < 0;
+
+    if (cmp == 0) {
+      switch (this._duplicationMode) {
+        case "keep-all":
+          break;
+        case "override": {
+          node.value = item;
+          return node;
+        }
+        case "ignore": {
+          return node;
+        }
+      }
+    }
+
+    if (isToLeftNode) node.left = this._addFromNode(item, node.left);
+    else node.right = this._addFromNode(item, node.right);
+    node.recalculateHeight();
+    node.recalculateSize();
+    return this._balance(node);
+  }
+
+  /**
+   * @param {TItem} item
+   */
+  add(item) {
+    this._root = this._addFromNode(item, this._root);
+  }
+  //#endregion
+
+  //#region Retrieve
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _findLeftMostFromNode(node) {
+    let res = node;
+    while (res?.left) res = res.left;
+    return res;
+  }
+
+  findLeftMostItem() {
+    return this._findLeftMostFromNode(this._root)?.value;
+  }
+
+  /**
+   * @private
+   * @param {AvlNode<TItem>} node
+   * @returns {AvlNode<TItem>}
+   */
+  _findRightMostFromNode(node) {
+    let res = node;
+    while (res?.right) res = res.right;
+    return res;
+  }
+
+  findRightMostItem() {
+    return this._findRightMostFromNode(this._root)?.value;
+  }
+
+  /**
+   * @private
+   * @param {number} order
+   * @returns {AvlNode<TItem>}
+   */
+  _getNodeAt(order) {
+    if (!this.size) return undefined;
+
+    order = this._adjustOrder(order);
+    let res = this._root;
+    let leftSize = res;
+
+    while (true) {
+      leftSize = res.left?.size ?? 0;
+      if (order === leftSize) return res;
+      if (order < leftSize) {
+        res = res.left;
+      } else {
+        res = res.right;
+        order -= leftSize + 1;
+      }
+    }
+  }
+
+  /**
+   * @param {number} order
+   * @returns {TItem}
+   */
+  getItemAt(order) {
+    return this._getNodeAt(order)?.value;
+  }
+
+  /**
+   * @param {TItem} item
+   * @param {number} start
+   * @returns {number}
+   */
+  findFirstOrder(item, start = 0) {
+    if (!this.size) return -1;
+    start = this._adjustOrder(start);
+
+    let node = this._root;
+    let order = node.left?.size ?? 0;
+    let res = -1;
+
+    while (node) {
+      if (order < start) {
+        order = this._calculateRightNodeOrder(node, order);
+        node = node.right;
+      } else {
+        let cmp = this._comparer(item, node.value);
+        if (cmp === 0) res = order;
+        if (cmp <= 0) {
+          order = this._calculateLeftNodeOrder(node, order);
+          node = node?.left;
+        } else {
+          order = this._calculateRightNodeOrder(node, order);
+          node = node.right;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @param {TItem} item
+   * @param {number} end
+   * @returns {number}
+   */
+  findLastOrder(item, end = -1) {
+    if (!this.size) return -1;
+    end = this._adjustOrder(end);
+
+    let node = this._root;
+    let order = node.left?.size ?? 0;
+    let res = -1;
+
+    while (node) {
+      if (order > end) {
+        order = this._calculateLeftNodeOrder(node, order);
+        node = node.left;
+      } else {
+        let cmp = this._comparer(item, node.value);
+        if (cmp === 0) res = order;
+        if (cmp < 0) {
+          order = this._calculateLeftNodeOrder(node, order);
+          node = node?.left;
+        } else {
+          order = this._calculateRightNodeOrder(node, order);
+          node = node.right;
+        }
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @param {TItem} item
+   * @returns {number}
+   */
+  count(item) {
+    let first = this.findFirstOrder(item);
+    if (first === -1) return 0;
+    let last = this.findLastOrder(item);
+    return last - first + 1;
+  }
+
+  /**
+   * Find the right-est value that can be added to the the left of item
+   * @param {TItem} item
+   * @returns {TItem | undefined}
+   */
+  findLeftBound(item) {
+    let node = this._root;
+    let res = undefined;
+
+    while (node) {
+      let cmp = this._comparer(item, node.value);
+      if (cmp < 0) node = node.left;
+      else {
+        res = node.value;
+        node = node.right;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * Find the left-est value that can be added to the the right of item
+   * @param {TItem} item
+   * @returns {TItem | undefined}
+   */
+  findRightBound(item) {
+    let node = this._root;
+    let res = undefined;
+
+    while (node) {
+      let cmp = this._comparer(item, node.value);
+      if (cmp > 0) node = node.right;
+      else {
+        res = node.value;
+        node = node.left;
+      }
+    }
+
+    return res;
+  }
+
+  /**
+   * @private
+   * @param {(item: TItem, order: number) => any} fn
+   * @param {AvlNode<TItem>} node
+   * @param {number} startOrder
+   */
+  _forLeftToRightNode(fn, node, startOrder) {
+    if (!node) return;
+    this._forLeftToRightNode(fn, node.left, startOrder);
+    fn(node.value, startOrder + (node.left?.size ?? 0));
+    this._forLeftToRightNode(
+      fn,
+      node.right,
+      startOrder + (node.left?.size ?? 0) + 1
+    );
+  }
+  /**
+   * @param {(item: TItem, order: number) => any} fn
+   */
+  forLeftToRight(fn) {
+    this._forLeftToRightNode(fn, this._root, 0);
+  }
+
+  /**
+   * @private
+   * @param {(item: TItem, order: number) => any} fn
+   * @param {AvlNode<TItem>} node
+   * @param {number} startOrder
+   */
+  _forRightToLeftNode(fn, node, startOrder) {
+    if (!node) return;
+    this._forRightToLeftNode(fn, node.right, startOrder);
+    fn(node.value, startOrder - (node.right?.size ?? 0));
+    this._forRightToLeftNode(
+      fn,
+      node.left,
+      startOrder - (node.right?.size ?? 0) - 1
+    );
+  }
+
+  /**
+   * @param {(item: TItem, order: number) => any} fn
+   */
+  forRightToLeft(fn) {
+    this._forRightToLeftNode(fn, this._root, this.size - 1);
+  }
+  //#endregion
+
+  //#region Remove
+  /**
+   * @private
+   * @param {AvlNode} node
+   */
+  _destroyNode(node) {
+    if (this._nodesPool) this._nodesPool.return(node);
+    else node.dispose();
+  }
+
+  /**
+   * @private
+   * @param {TItem} item
+   * @param {AvlNode<TItem> | undefined} node
+   * @returns {AvlNode<TItem>}
+   */
+  _removeFromNode(item, node) {
+    if (!node) return node;
+
+    const cmp = this._comparer(item, node.value);
+    if (cmp < 0) node.left = this._removeFromNode(item, node.left);
+    else if (cmp > 0) node.right = this._removeFromNode(item, node.right);
+    else {
+      if (!node.left) {
+        let child = node.right;
+        this._destroyNode(node);
+        return child;
+      }
+      if (!node.right) {
+        let child = node.left;
+        this._destroyNode(node);
+        return child;
+      }
+
+      let leftMostOfRight = this._findLeftMostFromNode(node.right);
+      node.value = leftMostOfRight.value;
+      node.right = this._removeFromNode(leftMostOfRight.value, node.right);
+    }
+    node.recalculateHeight();
+    node.recalculateSize();
+    return this._balance(node);
+  }
+
+  /**
+   * @param {TItem} item
+   */
+  remove(item) {
+    this._root = this._removeFromNode(item, this._root);
+  }
+
+  /**
+   * @param {AvlNode} node
+   */
+  _clearFromNode(node) {
+    if (!node) return;
+    if (node.left) this._clearFromNode(node.left);
+    if (node.right) this._clearFromNode(node.right);
+    this._destroyNode(node);
+  }
+
+  clear() {
+    if (!this._root) return;
+    this._clearFromNode(this._root);
+    delete this._root;
+  }
+  //#endregion
+}
+//#endregion
+
+//#region AVL Nodes Pool
+class AvlNodesPool {
+  /**
+   * @private
+   * @type {AvlNode[]}
+   */
+  _nodes = [];
+  /**
+   * @private
+   * @type {number}
+   */
+  _top = 0;
+
+  provide(value) {
+    if (this._top) {
+      let result = this._nodes[--this._top];
+      result.value = value;
+      result.left = null;
+      result.right = null;
+      result.size = 1;
+      result.height = 1;
+      return result;
+    }
+    return new AvlNode(value);
+  }
+
+  /**
+   * @param {AvlNode} node
+   */
+  return(node) {
+    if (this._top === this._nodes.length) this._nodes.push(node);
+    else this._nodes[this._top] = node;
+    this._top++;
+  }
+}
+//#endregion
+
+let pool = new AvlNodesPool();
+let avl1 = new AvlTree({
+  comparer: (a, b) => b - a,
+  duplicateMode: "keep-all",
+  nodesPool: pool,
+});
+let avl2 = new AvlTree({
+  comparer: (a, b) => b - a,
+  duplicateMode: "keep-all",
+  nodesPool: pool,
+});
+let addTo1 = new Uint8Array(1e5);
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var resultArray = function (nums) {
+  let n = nums.length;
+  avl1.clear();
+  avl2.clear();
+
+  addTo1[0] = 1;
+  avl1.add(nums[0]);
+  addTo1[1] = 0;
+  avl2.add(nums[1]);
+
+  for (let i = 2; i < n; ++i) {
+    let b1 = avl1.findLeftBound(nums[i] + 1);
+    b1 = b1 == null ? 0 : avl1.findLastOrder(b1) + 1;
+    let b2 = avl2.findLeftBound(nums[i] + 1);
+    b2 = b2 == null ? 0 : avl2.findLastOrder(b2) + 1;
+
+    addTo1[i] = b1 > b2 || (b1 == b2 && avl1.size <= avl2.size);
+    if (addTo1[i]) {
+      avl1.add(nums[i]);
+    } else {
+      avl2.add(nums[i]);
+    }
+  }
+
+  let res = new Uint32Array(n);
+  let l = 0;
+  let r = avl1.size;
+  for (let i = 0; i < n; ++i) {
+    if (addTo1[i]) {
+      res[l++] = nums[i];
+    } else {
+      res[r++] = nums[i];
+    }
+  }
+
+  return res;
+};

From 552f63fb314c66b3fa996f9e5b3b930f26dc3383 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Mar 2024 19:13:10 +0800
Subject: [PATCH 2983/3374] Create
 2871-split-array-into-maximum-number-of-subarrays.js

---
 ...-array-into-maximum-number-of-subarrays.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 2871-split-array-into-maximum-number-of-subarrays.js

diff --git a/2871-split-array-into-maximum-number-of-subarrays.js b/2871-split-array-into-maximum-number-of-subarrays.js
new file mode 100644
index 00000000..a71c473c
--- /dev/null
+++ b/2871-split-array-into-maximum-number-of-subarrays.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubarrays = function(nums) {
+  let n = nums.length;
+  let s = nums[0];
+  for (let i = 1; i < n; i++) s &= nums[i];
+  if (s > 0) return 1;
+  
+  let res = 0;
+  let l = 0;
+  let cs = nums[l];
+  for (let r = 0; r < n; r++) {
+    cs &= nums[r];
+    if (cs == 0) {
+      res++;
+      l = r + 1;
+      cs = nums[l];
+    }
+  }
+
+  return res;  
+};

From d5db5343ae4e5bfe3f67d684c2009afef8e31b13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 7 Mar 2024 18:50:18 +0800
Subject: [PATCH 2984/3374] Update
 3022-minimize-or-of-remaining-elements-using-operations.js

---
 ...-of-remaining-elements-using-operations.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/3022-minimize-or-of-remaining-elements-using-operations.js b/3022-minimize-or-of-remaining-elements-using-operations.js
index f82b89ba..d72db393 100644
--- a/3022-minimize-or-of-remaining-elements-using-operations.js
+++ b/3022-minimize-or-of-remaining-elements-using-operations.js
@@ -35,3 +35,36 @@ var minOrAfterOperations = function(nums, k) {
   }
   return res;  
 };
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minOrAfterOperations = function(nums, k) {
+  const n = nums.length;
+  let ans = 0;
+
+  for (let j = 30; j >= 0; j--) {
+    let cnt = 0;
+    let cur = (1 << 30) - 1;
+    let target = ans | ((1 << j) - 1);
+
+    for (let i = 0; i < n; i++) {
+      cur &= nums[i];
+      if ((cur | target) === target) {
+        cnt++;
+        cur = (1 << 30) - 1;
+      }
+    }
+
+    if (n - cnt > k) {
+      ans |= (1 << j);
+    }
+  }
+
+  return ans;
+};

From 0fb6b0912e268d008a0dbcbb918a2000ab378415 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Mar 2024 20:58:19 +0800
Subject: [PATCH 2985/3374] Create
 3027-find-the-number-of-ways-to-place-people-ii.js

---
 ...d-the-number-of-ways-to-place-people-ii.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 3027-find-the-number-of-ways-to-place-people-ii.js

diff --git a/3027-find-the-number-of-ways-to-place-people-ii.js b/3027-find-the-number-of-ways-to-place-people-ii.js
new file mode 100644
index 00000000..088053d5
--- /dev/null
+++ b/3027-find-the-number-of-ways-to-place-people-ii.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var numberOfPairs = function(points) {
+    points.sort((a, b) => {
+        if (a[0] === b[0]) return b[1] - a[1];
+        return a[0] - b[0];
+    });
+
+    let solution = 0;
+    for (let i = 0; i < points.length; i++) {
+        let c = points[i];
+        let currentMax = -Infinity;
+        for (let j = i + 1; j < points.length; j++) {
+            let t = points[j];
+            if (c[1] < t[1]) continue;
+            if (currentMax >= t[1]) continue;
+            currentMax = Math.max(currentMax, t[1]);
+            solution++;
+        }
+    }
+
+    return solution;
+};

From c61eef20757be3942b8dc7118aa0b3d6e1124440 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Mar 2024 20:09:17 +0800
Subject: [PATCH 2986/3374] Create 3048-earliest-second-to-mark-indices-i.js

---
 3048-earliest-second-to-mark-indices-i.js | 31 +++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3048-earliest-second-to-mark-indices-i.js

diff --git a/3048-earliest-second-to-mark-indices-i.js b/3048-earliest-second-to-mark-indices-i.js
new file mode 100644
index 00000000..1b9a33f0
--- /dev/null
+++ b/3048-earliest-second-to-mark-indices-i.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} changeIndices
+ * @return {number}
+ */
+var earliestSecondToMarkIndices = function(nums, changeIndices) {
+  let isPossible = function (mid) {
+    let last = new Uint16Array(nums.length);
+    for (let i = 0; i <= mid; ++i) last[changeIndices[i]] = i;
+
+    let count = 0, marked = 0;
+    for (let i = 0; i <= mid; ++i) {
+      if (last[changeIndices[i]] === i) {
+        count -= nums[changeIndices[i]];
+        if (count < 0) return false;
+        ++marked;
+      } else {
+        ++count;
+      }
+    }
+    return marked === nums.length;
+  };
+
+  changeIndices = changeIndices.map((x) => x - 1);
+  let l = 0, r = changeIndices.length - 1;
+  while (l < r) {
+    let mid = (l + r) >> 1;
+    isPossible(mid) ? r = mid : l = mid + 1;
+  }
+  return isPossible(l) ? l + 1 : -1;
+};

From c380c14e5b33117b5af2fc85706b26d2d9444cf6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Mar 2024 20:31:53 +0800
Subject: [PATCH 2987/3374] Create
 3077-maximum-strength-of-k-disjoint-subarrays.js

---
 ...aximum-strength-of-k-disjoint-subarrays.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3077-maximum-strength-of-k-disjoint-subarrays.js

diff --git a/3077-maximum-strength-of-k-disjoint-subarrays.js b/3077-maximum-strength-of-k-disjoint-subarrays.js
new file mode 100644
index 00000000..5cb724d4
--- /dev/null
+++ b/3077-maximum-strength-of-k-disjoint-subarrays.js
@@ -0,0 +1,40 @@
+let pre = Array(10001).fill(0);
+let cur = Array(10001).fill(0);
+let ps = Array(10001).fill(0);
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumStrength = function (nums, k) {
+  let n = nums.length;
+
+  ps[0] = 0;
+  for (let i = 0; i < n; ++i) {
+    ps[i + 1] = ps[i] + nums[i];
+  }
+
+  ++n;
+  cur.fill(0, 0, n);
+
+  for (let i = 1; i <= k; ++i) {
+    let tem = pre;
+    pre = cur;
+    cur = tem;
+
+    let t = 1 + k - i;
+    if (!(i & 1)) t = -t;
+
+    let m = pre[i - 1] - ps[i - 1] * t;
+    cur[i] = ps[i] * t + m;
+    m = Math.max(m, pre[i] - ps[i] * t);
+
+    for (let j = i + 1; j < n; ++j) {
+      cur[j] = Math.max(cur[j - 1], ps[j] * t + m);
+      m = Math.max(m, pre[j] - ps[j] * t);
+    }
+  }
+
+  return cur[n - 1];
+};

From a1d929a2ae15613fc064da49fab920571053023e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Mar 2024 20:33:15 +0800
Subject: [PATCH 2988/3374] Create
 3076-shortest-uncommon-substring-in-an-array.js

---
 ...shortest-uncommon-substring-in-an-array.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 3076-shortest-uncommon-substring-in-an-array.js

diff --git a/3076-shortest-uncommon-substring-in-an-array.js b/3076-shortest-uncommon-substring-in-an-array.js
new file mode 100644
index 00000000..9a5ad533
--- /dev/null
+++ b/3076-shortest-uncommon-substring-in-an-array.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string[]} arr
+ * @return {string[]}
+ */
+var shortestSubstrings = function(arr) {
+function* gen(s) {
+  const s_len = s.length
+  for (let i = 0; i < s_len; i++) {
+    for (let j = i; j < s_len; j++) {
+      yield s.slice(i, j + 1)
+    }
+  }
+}
+
+const ans = []
+const n = arr.length
+for (let i = 0; i < n; i++) {
+  const cur_s = arr[i]
+  let cur_ans = null
+  for (const s of gen(cur_s)) {
+    if (arr.filter((_, j) => j !== i).every((str) => !str.includes(s))) {
+      if (cur_ans === null) {
+        cur_ans = s
+      } else if (s.length < cur_ans.length) {
+        cur_ans = s
+      } else if (s.length === cur_ans.length && s < cur_ans) {
+        cur_ans = s
+      }
+    }
+  }
+  ans.push(cur_ans || '')
+}
+return ans  
+};

From 0592897e5687b5eb6d0724088c8333ed904d4d6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Mar 2024 20:34:14 +0800
Subject: [PATCH 2989/3374] Create
 3075-maximize-happiness-of-selected-children.js

---
 3075-maximize-happiness-of-selected-children.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 3075-maximize-happiness-of-selected-children.js

diff --git a/3075-maximize-happiness-of-selected-children.js b/3075-maximize-happiness-of-selected-children.js
new file mode 100644
index 00000000..2b02155d
--- /dev/null
+++ b/3075-maximize-happiness-of-selected-children.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} happiness
+ * @param {number} k
+ * @return {number}
+ */
+var maximumHappinessSum = function(happiness, k) {
+happiness.sort((a, b) => b - a)
+let ans = 0
+for (let i = 0; i < k; i++) {
+  ans += Math.max(happiness[i] - i, 0)
+}
+return ans 
+};

From 9362f4dd7cd3a58197ddd27f2f99971b02df44cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 10 Mar 2024 20:34:49 +0800
Subject: [PATCH 2990/3374] Create 3074-apple-redistribution-into-boxes.js

---
 3074-apple-redistribution-into-boxes.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 3074-apple-redistribution-into-boxes.js

diff --git a/3074-apple-redistribution-into-boxes.js b/3074-apple-redistribution-into-boxes.js
new file mode 100644
index 00000000..14d29e3f
--- /dev/null
+++ b/3074-apple-redistribution-into-boxes.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} apple
+ * @param {number[]} capacity
+ * @return {number}
+ */
+var minimumBoxes = function(apple, capacity) {
+let total_apple = apple.reduce((a, b) => a + b, 0)
+capacity.sort((a, b) => b - a)
+let ans = 0
+let cur = 0
+for (let c of capacity) {
+  cur += c
+  ans += 1
+  if (cur >= total_apple) {
+    return ans
+  }
+}
+};

From 6bbcdbf2109d87150a36e3ffc62828e577bd703a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Mar 2024 12:34:04 +0800
Subject: [PATCH 2991/3374] Update 3074-apple-redistribution-into-boxes.js

---
 3074-apple-redistribution-into-boxes.js | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/3074-apple-redistribution-into-boxes.js b/3074-apple-redistribution-into-boxes.js
index 14d29e3f..37b7dc67 100644
--- a/3074-apple-redistribution-into-boxes.js
+++ b/3074-apple-redistribution-into-boxes.js
@@ -4,15 +4,15 @@
  * @return {number}
  */
 var minimumBoxes = function(apple, capacity) {
-let total_apple = apple.reduce((a, b) => a + b, 0)
-capacity.sort((a, b) => b - a)
-let ans = 0
-let cur = 0
-for (let c of capacity) {
-  cur += c
-  ans += 1
-  if (cur >= total_apple) {
-    return ans
+  const sum = apple.reduce((ac, e) => ac+ e, 0)
+  capacity.sort((a, b) => b - a)
+  let res = 0
+  let remain = sum, i = 0
+  while(remain > 0) {
+      res++
+      remain -= capacity[i]
+      i++
   }
-}
+  
+  return res
 };

From 34f8586f155e067c9fa4b50f317a0e0625259061 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 12 Mar 2024 18:47:27 +0800
Subject: [PATCH 2992/3374] Create 3049-earliest-second-to-mark-indices-ii.js

---
 3049-earliest-second-to-mark-indices-ii.js | 93 ++++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 3049-earliest-second-to-mark-indices-ii.js

diff --git a/3049-earliest-second-to-mark-indices-ii.js b/3049-earliest-second-to-mark-indices-ii.js
new file mode 100644
index 00000000..cd88f7d4
--- /dev/null
+++ b/3049-earliest-second-to-mark-indices-ii.js
@@ -0,0 +1,93 @@
+function heapfy_up(heap, current) {
+  if (current == 1) return
+  let parent = current >> 1
+  if (heap[current] < heap[parent]) {
+    ;[heap[parent], heap[current]] = [heap[current], heap[parent]]
+    heapfy_up(heap, parent)
+  }
+}
+
+function heapfy_down(heap, current) {
+  let left = current << 1
+  let right = (current << 1) + 1
+  let min = current
+  if (left < heap.length && heap[left] < heap[min]) min = left
+  if (right < heap.length && heap[right] < heap[min]) min = right
+  if (min != current) {
+    ;[heap[min], heap[current]] = [heap[current], heap[min]]
+    heapfy_down(heap, min)
+  }
+}
+
+function heap_pop(heap) {
+  ;[heap[1], heap[heap.length - 1]] = [heap[heap.length - 1], heap[1]]
+  heap.pop()
+  heapfy_down(heap, 1)
+}
+
+function heap_push(heap, num) {
+  heap.push(num)
+  heapfy_up(heap, heap.length - 1)
+}
+
+/**
+ * @param {number[]} nums
+ * @param {number[]} changeIndices
+ * @return {number}
+ */
+var earliestSecondToMarkIndices = function (nums, changeIndices) {
+  const search = function (ceil) {
+    let heap = [0]
+    let set = new Set()
+    let is_first = new Array(ceil).fill(false)
+    for (let i = 0; i <= ceil - 1; i++) {
+      if (set.has(changeIndices[i])) continue
+      else {
+        set.add(changeIndices[i])
+        is_first[i] = true
+      }
+    }
+
+    for (let i = ceil - 1; i >= 0; i--) {
+      let max_size = (ceil - i + 1) >> 1
+      if (nums[changeIndices[i] - 1] == 0) continue
+      if (is_first[i] == false) continue
+      if (heap.length - 1 < max_size) {
+        heap_push(heap, nums[changeIndices[i] - 1])
+        continue
+      } else {
+        if (heap[1] < nums[changeIndices[i] - 1]) {
+          heap_pop(heap)
+          heap_push(heap, nums[changeIndices[i] - 1])
+          continue
+        }
+      }
+    }
+
+    let days_on_hand = ceil + 1 - heap.length + 1
+    let days_need = nums.length
+    for (let num of nums) days_need += num
+    for (let i = 1; i <= heap.length - 1; i++) {
+      days_need -= heap[i]
+    }
+
+    if (days_need > days_on_hand) return -1
+    else return 1
+  }
+
+  let r = changeIndices.length - 1
+  let l = nums.length - 1
+  if (search(r) == -1) return -1
+
+  while (l < r) {
+    let mid = (l + r) >> 1
+    let res = search(mid)
+    if (res == -1) {
+      l = mid + 1
+    } else {
+      r = mid
+    }
+  }
+
+  return l + 1
+}

From 21be0308a751fcbde6784f42799a568a2bb5c828 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 14 Mar 2024 18:38:15 +0800
Subject: [PATCH 2993/3374] Create 781-rabbits-in-forest.js

---
 781-rabbits-in-forest.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 781-rabbits-in-forest.js

diff --git a/781-rabbits-in-forest.js b/781-rabbits-in-forest.js
new file mode 100644
index 00000000..870444fa
--- /dev/null
+++ b/781-rabbits-in-forest.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} answers
+ * @return {number}
+ */
+const numRabbits = function(answers) {
+  const h = {}
+  for(const e of answers) {
+    if(h[e] == null) h[e] = 0
+    h[e]++
+  }
+  let res = 0
+  for(let [k,v] of Object.entries(h)) {
+    k = +k
+    if(k >= v ) res += k + 1
+    else {
+      res += Math.ceil(v / (k + 1) ) * (k + 1)
+    }
+  }
+  
+  return res
+};

From 4c5e057e92f94af690f5b7a50e2f750cc9c27ebb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Mar 2024 18:25:40 +0800
Subject: [PATCH 2994/3374] Create 3086-minimum-moves-to-pick-k-ones.js

---
 3086-minimum-moves-to-pick-k-ones.js | 29 ++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3086-minimum-moves-to-pick-k-ones.js

diff --git a/3086-minimum-moves-to-pick-k-ones.js b/3086-minimum-moves-to-pick-k-ones.js
new file mode 100644
index 00000000..22705b40
--- /dev/null
+++ b/3086-minimum-moves-to-pick-k-ones.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} maxChanges
+ * @return {number}
+ */
+var minimumMoves = function(nums, k, maxChanges) {
+  let A = [0];
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] > 0) {
+      A.push(A[A.length - 1] + i);
+    }
+  }
+
+  let n = A.length - 1;
+  let m = Math.max(0, k - maxChanges);
+  let res = Number.MAX_VALUE;
+
+  for (let l = m; l <= Math.min(n, Math.min(m + 3, k)); l++) {
+    for (let i = 0; i <= n - l; i++) {
+      let mid1 = i + Math.floor(l / 2);
+      let mid2 = i + l - Math.floor(l / 2);
+      let cur = A[i + l] - A[mid2] - (A[mid1] - A[i]);
+      res = Math.min(res, cur + (k - l) * 2);
+    }
+  }
+
+  return res;  
+};

From 7edd1bef758834c99a6230868e16072424aa4829 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Mar 2024 18:27:53 +0800
Subject: [PATCH 2995/3374] Create
 3085-minimum-deletions-to-make-string-k-special.js

---
 ...imum-deletions-to-make-string-k-special.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 3085-minimum-deletions-to-make-string-k-special.js

diff --git a/3085-minimum-deletions-to-make-string-k-special.js b/3085-minimum-deletions-to-make-string-k-special.js
new file mode 100644
index 00000000..560f121a
--- /dev/null
+++ b/3085-minimum-deletions-to-make-string-k-special.js
@@ -0,0 +1,34 @@
+/**
+ * @param {string} word
+ * @param {number} k
+ * @return {number}
+ */
+var minimumDeletions = function(word, k) {
+  let freq = new Array(26).fill(0);
+  let deleted = 0;
+  let ans = word.length;
+  
+  for (let i = 0; i < word.length; i++) {
+    freq[word.charCodeAt(i) - 'a'.charCodeAt(0)]++;
+  }
+  
+  freq.sort((a, b) => a - b);
+  
+  for (let i = 0; i < freq.length; i++) {
+    let res = deleted;
+    let minFreq = freq[i];
+    
+    for (let j = freq.length - 1; j > i; j--) {
+      if (freq[j] - minFreq <= k) {
+        break;
+      }
+      
+      res += freq[j] - minFreq - k;
+    }
+    
+    ans = Math.min(ans, res);
+    deleted += freq[i];
+  }
+  
+  return ans;
+};

From 21c881a298683c724e5154616c265ac076cc8d83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Mar 2024 15:40:13 +0800
Subject: [PATCH 2996/3374] Update 169-majority-element.js

---
 169-majority-element.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/169-majority-element.js b/169-majority-element.js
index 34d524d4..927293c3 100755
--- a/169-majority-element.js
+++ b/169-majority-element.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var majorityElement = function(nums) {
+  let el, cnt = 0
+  for(let e of nums) {
+      if(cnt === 0) {
+          el = e
+          cnt++
+      } else if(el === e) {
+          cnt++
+      } else {
+          cnt--
+      }
+  }
+  let tmp = 0
+  for(const e of nums) {
+     if(e === el) tmp++
+  }
+  return tmp > Math.floor(nums.length / 2) ? el : null
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 90c56517f3f6ae167335da28ed237ba6ac4a2608 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Mar 2024 15:43:28 +0800
Subject: [PATCH 2997/3374] Create
 3084-count-substrings-starting-and-ending-with-given-character.js

---
 ...tarting-and-ending-with-given-character.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 3084-count-substrings-starting-and-ending-with-given-character.js

diff --git a/3084-count-substrings-starting-and-ending-with-given-character.js b/3084-count-substrings-starting-and-ending-with-given-character.js
new file mode 100644
index 00000000..a3a501d1
--- /dev/null
+++ b/3084-count-substrings-starting-and-ending-with-given-character.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {character} c
+ * @return {number}
+ */
+const countSubstrings = function(s, c) {
+  const n = s.length
+  const arr = []
+  for(let i = 0; i < n; i++) {
+    if(s[i] === c) {
+      arr.push(i)
+    }
+  }
+  let len = arr.length
+  let res = 0
+  while(len) {
+    res += len
+    len--
+  }
+  
+  return res
+};

From 94cfe98cc3baaecdda7ea842a10e521f049f6261 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Mar 2024 15:44:34 +0800
Subject: [PATCH 2998/3374] Create
 3083-existence-of-a-substring-in-a-string-and-its-reverse.js

---
 ...a-substring-in-a-string-and-its-reverse.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3083-existence-of-a-substring-in-a-string-and-its-reverse.js

diff --git a/3083-existence-of-a-substring-in-a-string-and-its-reverse.js b/3083-existence-of-a-substring-in-a-string-and-its-reverse.js
new file mode 100644
index 00000000..51754026
--- /dev/null
+++ b/3083-existence-of-a-substring-in-a-string-and-its-reverse.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isSubstringPresent = function(s) {
+  let res = false
+  const n = s.length
+  for(let i = 0; i < n - 1; i++) {
+    const e = s[i] + s[i + 1]
+    for(let j = n - 1; j > 0; j--) {
+      if(s[j] === s[i] && s[j - 1] === s[i + 1]) {
+        res = true
+        return res
+      }
+    }
+  }
+  
+  return res
+};

From d380d4c03402c6ef32fee859a20717d537061bb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Mar 2024 11:11:55 +0800
Subject: [PATCH 2999/3374] Update 11-container-with-most-water.js

---
 11-container-with-most-water.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/11-container-with-most-water.js b/11-container-with-most-water.js
index 2b3aa808..763f29d5 100755
--- a/11-container-with-most-water.js
+++ b/11-container-with-most-water.js
@@ -12,3 +12,27 @@ const maxArea = function(height) {
   }
   return res
 };
+
+// another
+
+/**
+ * @param {number[]} height
+ * @return {number}
+ */
+const maxArea = function(height) {
+  const n = height.length, {min,max} = Math
+  let i = 0, j = n - 1, leftMax = height[i], rightMax = height[j]
+  let res = 0
+  while(i < j) {
+    res = max(res, (j - i) * min(leftMax, rightMax))
+    if(leftMax <= rightMax) {
+      i++
+      leftMax = max(leftMax, height[i])
+    } else {
+      j--
+      rightMax = max(rightMax, height[j])
+    }
+  }
+  
+  return res
+};

From 4a74f7fe85f8dd20ceafd61933ecc9f2a1acf8f3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Mar 2024 11:46:40 +0800
Subject: [PATCH 3000/3374] Update 15-3sum.js

---
 15-3sum.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/15-3sum.js b/15-3sum.js
index 498fc859..65defff5 100755
--- a/15-3sum.js
+++ b/15-3sum.js
@@ -88,5 +88,37 @@ const threeSum = function(nums) {
     }
   }  
 
+  return res
+};
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number[][]}
+ */
+const threeSum = function(nums) {
+  nums.sort((a, b) => a - b)
+  const n = nums.length
+  let res = []
+  for(let i = 0; i < n - 2; i++) {
+      const e = nums[i], target = -e
+      let l = i + 1, r = n - 1
+      while(l < r) {
+          const tmp = nums[l] + nums[r]
+          if(tmp < target) l++
+          else if(tmp > target) r--
+          else {
+              res.push([nums[i], nums[l], nums[r]])
+              l++
+              r--
+              while(l < r && nums[l] === nums[l - 1]) l++
+              while(l < r && nums[r] === nums[r + 1]) r--
+          }
+      }
+      while(i + 1 < n && nums[i + 1] === e) i++
+  }
+  
+  
   return res
 };

From 1f9f70fdc9194a8f3c472d061d8ccde0c426b4d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Mar 2024 14:02:11 +0800
Subject: [PATCH 3001/3374] Update 16-3sum-closest.js

---
 16-3sum-closest.js | 30 ++++++++++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/16-3sum-closest.js b/16-3sum-closest.js
index fbe0b658..014c404e 100755
--- a/16-3sum-closest.js
+++ b/16-3sum-closest.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number}
+ */
+const threeSumClosest = function(nums, target) {
+  let n = nums.length, {abs, min, max} = Math
+  let res = nums[0] + nums[1] + nums[2]
+  nums.sort((a, b) => a - b)
+  for(let i = 0; i < n - 2; i++) {
+    let e = nums[i]
+    let l = i + 1, r = n - 1
+    if(i > 0 && nums[i] === nums[i - 1]) continue
+    while(l < r) {
+        const tmp = e + nums[l] + nums[r]
+        if(abs(tmp - target) < abs(res - target)) {
+           res = tmp
+        }
+        if(tmp > target) r--
+        else if (tmp < target) l++
+        else return tmp
+    }
+  }
+  
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} target

From de80e0a414c8f5914a0d1a9747208992175f7491 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Mar 2024 14:46:24 +0800
Subject: [PATCH 3002/3374] Update 18-4sum.js

---
 18-4sum.js | 36 ++++++++++++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/18-4sum.js b/18-4sum.js
index 069b349b..fd34cdf7 100644
--- a/18-4sum.js
+++ b/18-4sum.js
@@ -88,3 +88,39 @@ function nSum(nums, target, k, start) {
   }
   return res;
 }
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[][]}
+ */
+const fourSum = function(nums, target) {
+  const res = [], n = nums.length
+  nums.sort((a, b) => a - b)
+  for(let a = 0; a < n - 3; a++) {
+    if(a > 0 && nums[a] === nums[a - 1]) continue
+    for(let b = a + 1; b < n - 2; b++) {
+        if(b > a + 1 && nums[b] === nums[a + 1]) continue
+        if(b > a + 1 && nums[b] === nums[b - 1]) continue
+        const t = target - nums[a] - nums[b]
+        let l = b + 1, r = n - 1
+        while(l < r) {
+            const sum = nums[l] + nums[r]
+            if(sum < t) l++
+            else if(sum > t) r--
+            else {
+                res.push([nums[a], nums[b], nums[l], nums[r]])
+                l++
+                r--
+                while(l < r && nums[l] === nums[l - 1]) l++
+                while(l < r && nums[r] === nums[r + 1]) r--
+            }
+        }
+    }
+  }
+  
+  return res
+};

From 43a6fcbc1fc9856e6af5b74ba5926512412f5a0d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 20 Mar 2024 13:58:41 +0800
Subject: [PATCH 3003/3374] Update 218-the-skyline-problem.js

---
 218-the-skyline-problem.js | 147 +++++++++++++++++++++++++++++++++++++
 1 file changed, 147 insertions(+)

diff --git a/218-the-skyline-problem.js b/218-the-skyline-problem.js
index 515675d3..0d7016ee 100644
--- a/218-the-skyline-problem.js
+++ b/218-the-skyline-problem.js
@@ -53,3 +53,150 @@ function combineOutputs(a, b) {
   }
   return combined
 }
+
+
+// another
+
+/**
+ * @param {number[][]} buildings
+ * @return {number[][]}
+ */
+const getSkyline = function (buildings) {
+  const n = buildings.length
+  const arr = []
+  const res = []
+  for(const [s, e, h] of buildings) {
+      arr.push([s, -h])
+      arr.push([e, h])
+  }
+  arr.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0])
+  const ms = new MultiSet()
+  ms.insert(0)
+  let pre = 0
+  for(const [p, h] of arr) {
+    h < 0 ? ms.insert(-h) : ms.eraseOne(h)
+    const cur = ms.last()
+    if(cur !== pre) {
+        res.push([p, cur])
+        pre = cur
+    }
+  }
+  
+  
+  return res
+}
+
+//////////////////////// Template //////////////////////////////////
+function Bisect() {
+    return { insort_right, insort_left, bisect_left, bisect_right }
+    function insort_right(a, x, lo = 0, hi = null) {
+        lo = bisect_right(a, x, lo, hi);
+        a.splice(lo, 0, x);
+    }
+    function bisect_right(a, x, lo = 0, hi = null) { // > upper_bound
+        if (lo < 0) throw new Error('lo must be non-negative');
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+            let mid = parseInt((lo + hi) / 2);
+            a[mid] > x ? hi = mid : lo = mid + 1;
+        }
+        return lo;
+    }
+    function insort_left(a, x, lo = 0, hi = null) {
+        lo = bisect_left(a, x, lo, hi);
+        a.splice(lo, 0, x);
+    }
+    function bisect_left(a, x, lo = 0, hi = null) { // >= lower_bound
+        if (lo < 0) throw new Error('lo must be non-negative');
+        if (hi == null) hi = a.length;
+        while (lo < hi) {
+            let mid = parseInt((lo + hi) / 2);
+            a[mid] < x ? lo = mid + 1 : hi = mid;
+        }
+        return lo;
+    }
+}
+
+function MultiSet(elements) {
+    let a = [], m = new Map(), bi = new Bisect();
+    initialize();
+    return { insert, first, last, get, search, poll, pollLast, lower_bound, upper_bound, findKth, eraseByIndex, eraseOne, eraseAll, contains, size, clear, show };
+    function initialize() {
+        if (elements) {
+            for (const x of elements) {
+                bi.insort_right(a, x);
+                m.set(x, m.get(x) + 1 || 1);
+            }
+        }
+    }
+    function insert(x) {
+        bi.insort_right(a, x);
+        m.set(x, m.get(x) + 1 || 1);
+    }
+    function first() {
+        return a[0];
+    }
+    function last() {
+        return a[a.length - 1];
+    }
+    function get(i) {
+        return a[i];
+    }
+    function poll() {
+        let res = a[0];
+        a.splice(0, 1);
+        removeOneOrManyMap(m, res);
+        return res;
+    }
+    function pollLast() {
+        let res = a.pop();
+        removeOneOrManyMap(m, res);
+        return res;
+    }
+    function lower_bound(x) {
+        return bi.bisect_left(a, x);
+    }
+    function upper_bound(x) {
+        return bi.bisect_right(a, x);
+    }
+    function findKth(k) {
+        return a[k - 1];
+    }
+    function search(x) {
+        return lower_bound(x);
+    }
+    function eraseByIndex(idx) {
+        removeOneOrManyMap(m, a[idx]);
+        a.splice(idx, 1);
+    }
+    function eraseOne(x) {
+        let idx = lower_bound(x);
+        if (a[idx] == x) a.splice(idx, 1);
+        removeOneOrManyMap(m, x);
+    }
+    function eraseAll(x) {
+        if (contains(x)) {
+            let idx = search(x), occ = m.get(x);
+            while (occ--) a.splice(idx, 1);
+            m.delete(x);
+        }
+    }
+    function removeOneOrManyMap(m, x, cnt = 1) {
+        let occ = m.get(x);
+        occ > cnt ? m.set(x, occ - cnt) : m.delete(x);
+    }
+    function contains(x) {
+        return m.has(x);
+    }
+    function size() {
+        return a.length;
+    }
+    function clear() {
+        a = [];
+        m.clear();
+    }
+    function show() {
+        return a;
+    }
+}
+///////////////////////////////////////////////////////////////////

From 4351270c111db3ebcb0399bae2f0855518b063a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Mar 2024 18:27:31 +0800
Subject: [PATCH 3004/3374] Update 699-falling-squares.js

---
 699-falling-squares.js | 54 +++++++++++++++++++++++-------------------
 1 file changed, 29 insertions(+), 25 deletions(-)

diff --git a/699-falling-squares.js b/699-falling-squares.js
index aeebee63..f0d08104 100644
--- a/699-falling-squares.js
+++ b/699-falling-squares.js
@@ -1,36 +1,40 @@
+class Interval {
+  constructor(s,e,h) {
+    this.start = s
+    this.end = e
+    this.height = h
+  }
+}
 /**
  * @param {number[][]} positions
  * @return {number[]}
  */
-class Interval {
-  constructor(start, end, height) {
-    this.start = start
-    this.end = end
-    this.height = height
-  }
-}
-function fallingSquares(positions) {
-  const intervals = []
+const fallingSquares = function(positions) {
+  const n = positions.length
   const res = []
-  let h = 0
-  for (let pos of positions) {
-    let cur = new Interval(pos[0], pos[0] + pos[1], pos[1])
-    h = Math.max(h, getHeight(intervals, cur))
-    res.push(h)
+  const intervals = []
+  let curMax = 0
+  for(let i = 0; i < n; i++) {
+    const [s, len] = positions[i]
+    const ins = new Interval(s, s + len, len)
+    curMax = Math.max(curMax, getHeight(intervals, ins))
+    res.push(curMax)
   }
-  console.log(intervals)
+  
   return res
-}
-function getHeight(intervals, cur) {
-  let preMaxHeight = 0
-  for (let i of intervals) {
-    if (i.end <= cur.start) continue
-    if (i.start >= cur.end) continue
-    preMaxHeight = Math.max(preMaxHeight, i.height)
+};
+
+function getHeight(intervals, ins) {
+  let preMax = 0
+  for(const e of intervals) {
+    if(ins.start >= e.end) continue
+    if(ins.end <= e.start) continue
+    preMax = Math.max(preMax, e.height)
   }
-  cur.height += preMaxHeight
-  intervals.push(cur)
-  return cur.height
+  
+  ins.height += preMax
+  intervals.push(ins)
+  return ins.height
 }
 
 // another

From 7aa0135505c5eea96a27fb9b9225173a107f837f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Mar 2024 14:00:11 +0800
Subject: [PATCH 3005/3374] Update
 3072-distribute-elements-into-two-arrays-ii.js

---
 ...-distribute-elements-into-two-arrays-ii.js | 50 +++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/3072-distribute-elements-into-two-arrays-ii.js b/3072-distribute-elements-into-two-arrays-ii.js
index ea9db49d..e8e54dec 100644
--- a/3072-distribute-elements-into-two-arrays-ii.js
+++ b/3072-distribute-elements-into-two-arrays-ii.js
@@ -1,3 +1,53 @@
+const binarySearch = function (arr, val) {
+    let start = 0, 
+        end = arr.length - 1
+    while (start < end) {
+        const mid = Math.floor((start + end) / 2)
+        if (arr[mid] > val) {
+            end = mid    
+        } else {
+            start = mid + 1 
+        }
+    }
+    if (arr[start] <= val) {
+        start++;
+    }
+    return [arr.length - start, start]
+}
+
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const resultArray = function(nums) {
+     const arr1 = [nums[0]],
+           arr2 = [nums[1]]
+     let sortedArr1 = [nums[0]],
+         sortedArr2 = [nums[1]]
+     for (let i = 2; i < nums.length; i++) {
+         const n = nums[i],
+               [gc1, s1] = binarySearch(sortedArr1, n),
+               [gc2, s2] = binarySearch(sortedArr2, n)
+         if (gc1 > gc2) {
+             arr1.push(n)
+             sortedArr1.splice(s1, 0, n)
+         } else if (gc2 > gc1) {
+             arr2.push(n)
+             sortedArr2.splice(s2, 0, n)
+         } else if (arr2.length < arr1.length){
+             arr2.push(n)
+             sortedArr2.splice(s2, 0, n)
+         } else {
+             arr1.push(n)
+             sortedArr1.splice(s1, 0, n)
+         }
+     }
+    return [...arr1, ...arr2]
+};
+
+// another
+
+
 //#region AVL Tree
 /**
  * @typedef {"keep-all" | "override" | "ignore"} DuplicateMode

From 063980a58f9291e463476bc33b2fe3dc9ae5d0f9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 25 Mar 2024 14:19:16 +0800
Subject: [PATCH 3006/3374] Update
 3072-distribute-elements-into-two-arrays-ii.js

---
 ...-distribute-elements-into-two-arrays-ii.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/3072-distribute-elements-into-two-arrays-ii.js b/3072-distribute-elements-into-two-arrays-ii.js
index e8e54dec..96356a43 100644
--- a/3072-distribute-elements-into-two-arrays-ii.js
+++ b/3072-distribute-elements-into-two-arrays-ii.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+const resultArray = function(nums) {
+  const n = nums.length
+  const a1 = [nums[0]], a2 = [nums[1]], a1s = [nums[0]], a2s = [nums[1]]
+  for(let i = 2; i < n; i++) {
+    const e = nums[i]
+    const [gc1, s1] = bs(a1s, e)
+    const [gc2, s2] = bs(a2s, e)
+    if(gc1 > gc2) {
+        a1.push(e)
+        a1s.splice(s1, 0, e)
+    } else if(gc1 < gc2) {
+        a2.push(e)
+        a2s.splice(s2, 0, e)
+    } else if(a1.length > a2.length) {
+        a2.push(e)
+        a2s.splice(s2, 0, e)
+    } else {
+        a1.push(e)
+        a1s.splice(s1, 0, e)
+    }
+  }
+    
+  return [...a1, ...a2]
+    
+  function bs(arr, val) {
+     const n = arr.length
+     let l = 0, r = n - 1
+     while(l < r) {
+         const mid = Math.floor((l + r) / 2)
+         if(arr[mid] > val) r = mid
+         else l = mid + 1
+     }
+     if(arr[l] <= val) l++
+     return [n - l, l]
+  }
+};
+
+// another
+
 const binarySearch = function (arr, val) {
     let start = 0, 
         end = arr.length - 1

From 668efd3743c572691de56e7b63143fdbc59ff257 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Mar 2024 12:42:37 +0800
Subject: [PATCH 3007/3374] Create
 2916-subarrays-distinct-element-sum-of-squares-ii.js

---
 ...rays-distinct-element-sum-of-squares-ii.js | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 2916-subarrays-distinct-element-sum-of-squares-ii.js

diff --git a/2916-subarrays-distinct-element-sum-of-squares-ii.js b/2916-subarrays-distinct-element-sum-of-squares-ii.js
new file mode 100644
index 00000000..041d74da
--- /dev/null
+++ b/2916-subarrays-distinct-element-sum-of-squares-ii.js
@@ -0,0 +1,67 @@
+const MOD = 1e9 + 7;
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumCounts = function(nums) {
+    let n = nums.length;
+    const last_pos = Array(100001).fill(-1);
+
+    const tree = new SegmentTree(n);
+    let res = 0;
+
+    for (let j = 0; j < n; j ++) {            
+        let st = last_pos[nums[j]] + 1, ed = j;
+        tree.AddOne(st, ed);
+
+        res = (res + tree.sqr[0]) % MOD;
+
+        last_pos[nums[j]] = j;
+    }
+    return res;
+};
+
+
+class SegmentTree {    
+    constructor (n) {
+        this.n = n
+        this.lzy = Array(4*n).fill(0);
+        this.sum = Array(4*n).fill(0);
+        this.sqr = Array(4*n).fill(0);
+    }
+    
+   update_lzy( l,  r,  i) {
+       const {lzy, sum, sqr} = this
+
+        if (l != r) {
+            lzy[i*2+1] += lzy[i];
+            lzy[i*2+2] += lzy[i];
+        }
+        let gap = r-l+1;
+        let new_sum = sum[i] + lzy[i]*gap;
+        let new_sqr = sqr[i] + lzy[i]*sum[i]*2 + lzy[i]*lzy[i]*gap;
+        
+        sum[i] = new_sum % MOD;
+        sqr[i] = new_sqr % MOD;
+        lzy[i] = 0;
+    }
+    
+    AddOne ( x,  y,  l = 0,  r = -1,  i = 0) {
+       const {lzy, sum, sqr, n} = this
+        if (r == -1) r += n;
+        this.update_lzy(l, r, i);
+        
+        if (r < x || l > y) return;
+        if (l >= x && r <= y) {
+            lzy[i] = 1;
+            return this.update_lzy(l, r, i);
+        }
+        
+        let m = (l+r) >> 1;
+        this.AddOne (x, y, l, m, i*2+1);
+        this.AddOne (x, y, m+1, r, i*2+2);
+        
+        sum[i] = (sum[i*2+1] + sum[i*2+2]) % MOD;
+        sqr[i] = (sqr[i*2+1] + sqr[i*2+2]) % MOD;
+    }    
+};

From 2f9f65a8812896e5f1f87fd0f04ae94f1d3c74bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Mar 2024 15:50:01 +0800
Subject: [PATCH 3008/3374] Update 2977-minimum-cost-to-convert-string-ii.js

---
 2977-minimum-cost-to-convert-string-ii.js | 62 +++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/2977-minimum-cost-to-convert-string-ii.js b/2977-minimum-cost-to-convert-string-ii.js
index 6246f37f..0d152f85 100644
--- a/2977-minimum-cost-to-convert-string-ii.js
+++ b/2977-minimum-cost-to-convert-string-ii.js
@@ -1,3 +1,65 @@
+/**
+ * @param {string} source
+ * @param {string} target
+ * @param {string[]} original
+ * @param {string[]} changed
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minimumCost = function (source, target, original, changed, cost) {
+  const index = {}
+  const set = new Set()
+  for(const e of original) set.add(e)
+  for(const e of changed) set.add(e)
+  let idx = 0
+  for(const e of set) {
+      index[e] = idx
+      idx++
+  }
+
+  const n = set.size
+  const dis = Array.from({ length: n }, () => Array(n).fill(Infinity))
+  for(let i = 0; i < original.length; i++) {
+      const s = index[original[i]], e = index[changed[i]]
+      dis[s][e] = Math.min(dis[s][e], cost[i])
+  }
+  for(let k = 0; k < n; k++) {
+      for(let i = 0; i < n; i++) {
+          if(dis[i][k] === Infinity) continue
+          for(let j = 0; j < n; j++) {
+              if(dis[k][j] === Infinity) continue
+              dis[i][j] = Math.min(dis[i][j], dis[i][k] + dis[k][j])
+          }
+      }
+  }
+  const lenSet = new Set()
+  for(const e of original) lenSet.add(e.length)
+  const len = source.length
+  const dp = Array(len + 1).fill(Infinity)
+  dp[0] = 0
+  for(let i = 0; i < len; i++) {
+      if(dp[i] === Infinity) continue
+      if(source[i] === target[i]) {
+          dp[i + 1] = Math.min(dp[i + 1], dp[i])
+      }
+      for(const le of lenSet) {
+          if(i + le > len) continue
+          const sub = source.slice(i, i + le)
+          const subT = target.slice(i, i + le)
+          const sIdx = index.hasOwnProperty(sub) ? index[sub] : -1
+           const tIdx = index.hasOwnProperty(subT) ? index[subT] : -1
+         if(sIdx >= 0 && tIdx >= 0 && dis[sIdx][tIdx] !== Infinity) {
+             dp[i + le] = Math.min(dp[i + le], dp[i] + dis[sIdx][tIdx])
+         }
+      }
+  }
+  // console.log(dis,dp)
+  return dp.at(-1) === Infinity ? -1 : dp.at(-1)
+}
+
+// another
+
+
 /**
  * @param {string} source
  * @param {string} target

From 87af4396e5d9e6d248c9b893a10abefe0fdd60c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 30 Mar 2024 18:45:34 +0800
Subject: [PATCH 3009/3374] Create
 3041-maximize-consecutive-elements-in-an-array-after-modification.js

---
 ...elements-in-an-array-after-modification.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3041-maximize-consecutive-elements-in-an-array-after-modification.js

diff --git a/3041-maximize-consecutive-elements-in-an-array-after-modification.js b/3041-maximize-consecutive-elements-in-an-array-after-modification.js
new file mode 100644
index 00000000..f18f6a25
--- /dev/null
+++ b/3041-maximize-consecutive-elements-in-an-array-after-modification.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSelectedElements = function (nums) {
+  let dp = new Uint32Array(1e6 + 2)
+  let n = nums.length
+  nums.sort((a, b) => a - b)
+
+  dp.fill(0, 0, nums[n - 1] + 1)
+  let res = 1
+  for (let i = 0; i < n; ++i) {
+    let x = nums[i]
+    dp[x + 1] = dp[x] + 1
+    dp[x] = dp[x - 1] + 1
+    res = Math.max(res, dp[x], dp[x + 1])
+  }
+
+  return res
+}

From 2860ff373f546b22700b0d94abb7fb36f9506ec7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Apr 2024 12:45:21 +0800
Subject: [PATCH 3010/3374] Update
 3077-maximum-strength-of-k-disjoint-subarrays.js

---
 ...aximum-strength-of-k-disjoint-subarrays.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/3077-maximum-strength-of-k-disjoint-subarrays.js b/3077-maximum-strength-of-k-disjoint-subarrays.js
index 5cb724d4..87e664b8 100644
--- a/3077-maximum-strength-of-k-disjoint-subarrays.js
+++ b/3077-maximum-strength-of-k-disjoint-subarrays.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumStrength = function(nums, k) {
+    const n = nums.length;
+    let dp = new Array(n + 1).fill(0);
+    
+    for (let i = 0; i < k; i++) {
+        let m = k - i;
+        m = (i % 2 === 0) ? m : -m;
+        const nextdp = new Array(n + 1).fill(-Infinity);
+        for (let j = 1; j <= n; j++) {
+            nextdp[j] = Math.max(nextdp[j-1], dp[j-1]) + nums[j-1] * m;
+        }
+        dp = nextdp;
+        for (let j = 1; j <= n; j++) {
+            dp[j] = Math.max(dp[j-1], dp[j]);
+        }
+    }
+    return dp[n];
+};
+
+
+// another
+
 let pre = Array(10001).fill(0);
 let cur = Array(10001).fill(0);
 let ps = Array(10001).fill(0);

From e240cda597abac5f8a89c7b59b994aef0f315637 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 1 Apr 2024 13:55:28 +0800
Subject: [PATCH 3011/3374] Update
 3077-maximum-strength-of-k-disjoint-subarrays.js

---
 ...aximum-strength-of-k-disjoint-subarrays.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/3077-maximum-strength-of-k-disjoint-subarrays.js b/3077-maximum-strength-of-k-disjoint-subarrays.js
index 87e664b8..b37816ec 100644
--- a/3077-maximum-strength-of-k-disjoint-subarrays.js
+++ b/3077-maximum-strength-of-k-disjoint-subarrays.js
@@ -23,6 +23,33 @@ const maximumStrength = function(nums, k) {
 };
 
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumStrength = function(nums, k) {
+  let dp = new Array(k + 1).fill(0).map(() => new Array(nums.length + 1).fill(0));
+
+  for (let i = 1; i <= k; i++) {
+    let maxSum = Number.MIN_SAFE_INTEGER / 2;
+    let curr = Number.MIN_SAFE_INTEGER / 2;
+    let multiplier = (i % 2 === 1) ? (k + 1 - i) : (i - 1 - k);
+
+    for (let j = i - 1; j < nums.length; j++) {
+      curr = Math.max(curr + nums[j] * multiplier, dp[i - 1][j] + nums[j] * multiplier);
+      maxSum = Math.max(maxSum, curr);
+      dp[i][j + 1] = maxSum;
+    }
+  }
+
+  return dp[k][nums.length];
+};
+
+
+
 // another
 
 let pre = Array(10001).fill(0);

From 9a9988b991efb70f8ec115216bf4857245a253cd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Apr 2024 11:48:49 +0800
Subject: [PATCH 3012/3374] Create
 3082-find-the-sum-of-the-power-of-all-subsequences.js

---
 ...d-the-sum-of-the-power-of-all-subsequences.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3082-find-the-sum-of-the-power-of-all-subsequences.js

diff --git a/3082-find-the-sum-of-the-power-of-all-subsequences.js b/3082-find-the-sum-of-the-power-of-all-subsequences.js
new file mode 100644
index 00000000..200422a2
--- /dev/null
+++ b/3082-find-the-sum-of-the-power-of-all-subsequences.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const sumOfPower = function(nums, k) {
+  const n = nums.length, mod = 1e9 + 7;
+  const dp = Array(k + 1).fill(0)
+  dp[0] = 1;
+  for (const a of nums) {
+      for (let v = k; v >= 0; v--) {
+          dp[v] = (dp[v] * 2 % mod + (v >= a ? dp[v - a] : 0)) % mod
+      }
+  }
+  return dp[k];
+};

From 3c391fa597544bc93b048e7580ebe9ee0c247ede Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Apr 2024 12:24:12 +0800
Subject: [PATCH 3013/3374] Update
 3082-find-the-sum-of-the-power-of-all-subsequences.js

---
 ...he-sum-of-the-power-of-all-subsequences.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/3082-find-the-sum-of-the-power-of-all-subsequences.js b/3082-find-the-sum-of-the-power-of-all-subsequences.js
index 200422a2..9944513e 100644
--- a/3082-find-the-sum-of-the-power-of-all-subsequences.js
+++ b/3082-find-the-sum-of-the-power-of-all-subsequences.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const sumOfPower = function(nums, k) {
+  const n = nums.length, mod = 1e9 + 7;
+  const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(0))
+  dp[0][0] = 1
+  let res = 0, pow = 1
+  for(const e of nums) {
+    for(let j = k; j >= e; j--) {
+      for(let i = n; i > 0; i--) {
+        dp[i][j] = (dp[i][j] + dp[i - 1][j - e]) % mod  
+      }
+    }
+  }
+  for(let i = n; i > 0; i--) {
+    res = (res + (dp[i][k] * pow) % mod) % mod
+    pow *= 2
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 03c201075e1c6c7e6c7488f6d786feebea309eb5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Apr 2024 12:52:12 +0800
Subject: [PATCH 3014/3374] Create
 2930-number-of-strings-which-can-be-rearranged-to-contain-substring.js

---
 ...-can-be-rearranged-to-contain-substring.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 2930-number-of-strings-which-can-be-rearranged-to-contain-substring.js

diff --git a/2930-number-of-strings-which-can-be-rearranged-to-contain-substring.js b/2930-number-of-strings-which-can-be-rearranged-to-contain-substring.js
new file mode 100644
index 00000000..d9dac832
--- /dev/null
+++ b/2930-number-of-strings-which-can-be-rearranged-to-contain-substring.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+const stringCount = function(n) {
+  const LEET = parseInt('1111', 2),
+        L = parseInt('1000', 2),
+        FE = parseInt('0100', 2),
+        SE = parseInt('0010', 2),
+        T = parseInt('0001', 2),
+        MOD = 1e9 + 7
+  const dp = Array.from({ length: n }, () => Array(16).fill(-1))
+  return helper(0, 0)
+  
+  function helper(i, mask) {
+    if(i === n) {
+      return mask === LEET ? 1 : 0
+    }
+    if(dp[i][mask] !== -1) return dp[i][mask]
+    
+    let res = (helper(i + 1, mask | L) + helper(i + 1, mask | T)) % MOD
+    if(mask & FE) {
+      res = (res + helper(i + 1, mask | SE)) % MOD
+    } else {
+      res = (res + helper(i + 1, mask | FE)) % MOD
+    }
+    res = (res + 23 * helper(i + 1, mask)) % MOD
+    dp[i][mask] = res
+    return dp[i][mask]
+  }
+};

From 5c61474190ab76336de15f731dcdf2454bd8a2e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Apr 2024 18:59:08 +0800
Subject: [PATCH 3015/3374] Create 3098-find-the-sum-of-subsequence-powers.js

---
 3098-find-the-sum-of-subsequence-powers.js | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 3098-find-the-sum-of-subsequence-powers.js

diff --git a/3098-find-the-sum-of-subsequence-powers.js b/3098-find-the-sum-of-subsequence-powers.js
new file mode 100644
index 00000000..4b9902f7
--- /dev/null
+++ b/3098-find-the-sum-of-subsequence-powers.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var sumOfPowers = function (nums, k) {
+  const mod = 1e9 + 7
+
+  let n, res, a, memo
+  a = nums
+  a.sort((x, y) => x - y)
+  n = a.length
+  memo = new Map()
+  const dfs = (i, k, pre, mi) => {
+    if (k == 0) return mi
+    if (n - i - 1 < k) return 0
+    let ke = i + ' ' + k + ' ' + pre + ' ' + mi
+    if (memo.has(ke)) return memo.get(ke)
+    res = dfs(i + 1, k - 1, a[i + 1], Math.min(mi, a[i + 1] - pre))
+    res += dfs(i + 1, k, pre, mi)
+    memo.set(ke, res)
+    return res % mod
+  }
+  res = dfs(-1, k, -Infinity, Infinity)
+  return res
+}

From a5b7b3e51aff5b2750cfd71d732d5e1436a57a04 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Apr 2024 17:04:36 +0800
Subject: [PATCH 3016/3374] Update
 2954-count-the-number-of-infection-sequences.js

---
 ...count-the-number-of-infection-sequences.js | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/2954-count-the-number-of-infection-sequences.js b/2954-count-the-number-of-infection-sequences.js
index 5891fe6a..86db31f4 100644
--- a/2954-count-the-number-of-infection-sequences.js
+++ b/2954-count-the-number-of-infection-sequences.js
@@ -1,3 +1,68 @@
+const MOD = 1e9 + 7;
+const MX = 100000;
+const big = BigInt
+
+const FAC = new Array(MX).fill(0);
+const INV_FAC = new Array(MX).fill(0);
+
+FAC[0] = 1;
+for (let i = 1; i < MX; i++) {
+  FAC[i] = mul(FAC[i - 1], i) % MOD;
+}
+
+INV_FAC[MX - 1] = pow(FAC[MX - 1], MOD - 2);
+for (let i = MX - 1; i > 0; i--) {
+  INV_FAC[i - 1] = mul(INV_FAC[i], i) % MOD;
+}
+
+function comb(n, k) {
+  return mul(mul(FAC[n], INV_FAC[k]),  INV_FAC[n - k]) % MOD;
+}  
+/**
+ * @param {number} n
+ * @param {number[]} sick
+ * @return {number}
+ */
+var numberOfSequence = function(n, sick) {
+  const a = sick  
+  const m = a.length;
+  let total = n - m;
+  let ans = mul(comb(total, a[0]), comb(total - a[0], n - a[m - 1] - 1));
+  total -= a[0] + n - a[m - 1] - 1;
+  let e = 0;
+  for (let i = 1; i < m; i++) {
+    const k = a[i] - a[i - 1] - 1;
+    if (k > 0) {
+      e += k - 1;
+      ans = mul(ans, comb(total, k));
+      total -= k;
+    }
+  }
+  return mul(ans, pow(2, e));
+};
+
+function pow(x, n) {
+
+  const mod = big(MOD)
+  let res = 1n;
+  x = big(x)
+  while (n > 0) {
+    if (n % 2 === 1) {
+      res = (res * x) % mod;
+    }
+    x = (x * x) % mod;
+    n = Math.floor(n / 2);
+  }
+  return Number(res);
+}
+
+function mul(a, b) {
+  return Number(big(a) * big(b) % big(MOD))
+}
+
+// another
+
+
 //#region Modulo
 class Modulo {
   /**

From 49bb420ef73ecde4e0062118c7b692448decf7f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Apr 2024 12:09:26 +0800
Subject: [PATCH 3017/3374] Create
 3105-longest-strictly-increasing-or-strictly-decreasing-subarray.js

---
 ...reasing-or-strictly-decreasing-subarray.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 3105-longest-strictly-increasing-or-strictly-decreasing-subarray.js

diff --git a/3105-longest-strictly-increasing-or-strictly-decreasing-subarray.js b/3105-longest-strictly-increasing-or-strictly-decreasing-subarray.js
new file mode 100644
index 00000000..0be0a8fc
--- /dev/null
+++ b/3105-longest-strictly-increasing-or-strictly-decreasing-subarray.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var longestMonotonicSubarray = function(nums) {
+  const n = nums.length
+  return Math.max(inc(), desc()) 
+    
+  function inc() {
+    let res = 1, cur = 1
+    for(let i = 1; i < n; i++) {
+      if(nums[i] > nums[i - 1]) {
+        cur++
+        res = Math.max(res, cur)
+      } else {
+        cur = 1
+      }
+    }
+    
+    return res
+  }
+  
+  function desc() {
+    let res = 1, cur = 1
+    for(let i = 1; i < n; i++) {
+      if(nums[i] < nums[i - 1]) {
+        cur++
+        res = Math.max(res, cur)
+      } else {
+        cur = 1
+      }
+    }
+    
+    return res
+  }
+};

From 2e4b11e97ed3a832d06b05035806501ccea8036d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Apr 2024 12:10:04 +0800
Subject: [PATCH 3018/3374] Create
 3106-lexicographically-smallest-string-after-operations-with-constraint.js

---
 ...string-after-operations-with-constraint.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3106-lexicographically-smallest-string-after-operations-with-constraint.js

diff --git a/3106-lexicographically-smallest-string-after-operations-with-constraint.js b/3106-lexicographically-smallest-string-after-operations-with-constraint.js
new file mode 100644
index 00000000..c2e9da1b
--- /dev/null
+++ b/3106-lexicographically-smallest-string-after-operations-with-constraint.js
@@ -0,0 +1,37 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+const getSmallestString = function(s, k) {
+  const n = s.length
+  s = s + s
+  const a = 'a'.charCodeAt(0)
+  let res = '', idx = 0
+  for(let j = 0; j < n; j++) {
+    for(let i = 0; i < 26; i++) {
+      const len = chk(a + i, j)
+      if(len === 0) {
+         res += s[j]
+         break
+      } else if(len && len <= k) {
+        k -= len
+        res += String.fromCharCode(a + i)
+        break
+      }
+    }
+  }
+
+    
+  return res
+  
+  function chk(code, targetIdx) {
+    const targetCode = s[targetIdx].charCodeAt(0)
+    if(targetCode > code) {
+          return Math.min(targetCode - code, code + 26 - targetCode)
+    } else {
+      return Math.min(code - targetCode, targetCode + 26 - code)
+    }
+
+  }
+};

From e6e824b66bedf43fa59e1d60f951cb864c4a4504 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Apr 2024 12:10:48 +0800
Subject: [PATCH 3019/3374] Create
 3107-minimum-operations-to-make-median-of-array-equal-to-k.js

---
 ...ions-to-make-median-of-array-equal-to-k.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 3107-minimum-operations-to-make-median-of-array-equal-to-k.js

diff --git a/3107-minimum-operations-to-make-median-of-array-equal-to-k.js b/3107-minimum-operations-to-make-median-of-array-equal-to-k.js
new file mode 100644
index 00000000..af16bb11
--- /dev/null
+++ b/3107-minimum-operations-to-make-median-of-array-equal-to-k.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minOperationsToMakeMedianK = function(nums, k) {
+    nums.sort((a, b) => a - b)
+
+    let n = nums.length
+    let medIdx = Math.floor(n / 2)
+    let res = 0
+
+    for(let i = 0; i < n; i++) {
+        if(nums[i] < k && medIdx <= i) {
+            res = res + (k - nums[i])
+        }
+        else if(nums[i] > k && medIdx >= i) {
+            res = res + (nums[i] - k)
+        }
+    }
+
+    return res
+};
+

From f18d8b95266d2cacae6496ca2a11b1ea3f5febc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Apr 2024 12:11:22 +0800
Subject: [PATCH 3020/3374] Create 3108-minimum-cost-walk-in-weighted-graph.js

---
 3108-minimum-cost-walk-in-weighted-graph.js | 94 +++++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 3108-minimum-cost-walk-in-weighted-graph.js

diff --git a/3108-minimum-cost-walk-in-weighted-graph.js b/3108-minimum-cost-walk-in-weighted-graph.js
new file mode 100644
index 00000000..d538c09b
--- /dev/null
+++ b/3108-minimum-cost-walk-in-weighted-graph.js
@@ -0,0 +1,94 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} query
+ * @return {number[]}
+ */
+var minimumCost = function (n, edges, query) {
+  const map = new Map()
+  const ufs = new UFS(n)
+
+  for (let i = 0; i < edges.length; i++) {
+    const [a, b, e] = edges[i]
+    ufs.union(a, b)
+  }
+
+  for (let i = 0; i < edges.length; i++) {
+    const [a, b, e] = edges[i]
+    const rootA = ufs.find(a)
+    const rootB = ufs.find(b)
+
+    const root = ufs.find(a)
+    let tmp = e
+    if (map.has(rootA)) {
+      tmp = e & map.get(rootA)
+    }
+    if (map.has(rootB)) {
+      tmp = e & map.get(rootB)
+    }
+    map.set(root, tmp)
+  }
+
+  const ans = []
+  for (let i = 0; i < query.length; i++) {
+    const [s, t] = query[i]
+    const rootA = ufs.find(s)
+    const rootB = ufs.find(t)
+
+    if (rootA !== rootB) {
+      ans.push(-1)
+    } else if (s === t) {
+      ans.push(0)
+    } else {
+      ans.push(map.get(rootA))
+    }
+  }
+
+  return ans
+}
+
+class UFS {
+  constructor(n) {
+    this.parent = new Array(n).fill(0).map((_, i) => i)
+    this.rank = new Array(n).fill(0)
+    this.size = n
+    this.sz = new Array(n).fill(1)
+  }
+
+  find(x) {
+    if (x !== this.parent[x]) {
+      this.parent[x] = this.find(this.parent[x])
+    }
+    return this.parent[x]
+  }
+
+  union(x, y) {
+    const px = this.find(x)
+    const py = this.find(y)
+
+    if (px === py) {
+      return false
+    }
+
+    if (this.rank[px] > this.rank[py]) {
+      this.parent[py] = px
+      this.sz[px] += this.sz[py]
+    } else if (this.rank[px] < this.rank[py]) {
+      this.parent[px] = py
+      this.sz[py] += this.sz[px]
+    } else {
+      this.parent[px] = py
+      this.sz[py] += this.sz[px]
+      this.rank[px]++
+    }
+
+    this.size--
+    return true
+  }
+
+  reset() {
+    this.parent = new Array(n).fill(0).map((_, i) => i)
+    this.rank = new Array(n).fill(0)
+    this.size = n
+  }
+}

From bf03657fd90f7e5d3998559d97272efd6577c952 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Apr 2024 14:14:28 +0800
Subject: [PATCH 3021/3374] Update
 462-minimum-moves-to-equal-array-elements-II.js

---
 ...inimum-moves-to-equal-array-elements-II.js | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)

diff --git a/462-minimum-moves-to-equal-array-elements-II.js b/462-minimum-moves-to-equal-array-elements-II.js
index 4919debd..1695d55a 100755
--- a/462-minimum-moves-to-equal-array-elements-II.js
+++ b/462-minimum-moves-to-equal-array-elements-II.js
@@ -14,3 +14,63 @@ const minMoves2 = function(nums) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const minMoves2 = function (nums) {
+  const n = nums.length
+  const mid = Math.floor(n / 2)
+  const nth = nthElement(nums, mid, (a, b) => a - b)
+  let res = 0
+  for (let i = 0; i < n; i++) {
+    res += Math.abs(nums[i] - nth)
+  }
+
+  return res
+}
+
+function nthElement(arr, n, compareFn) {
+  if (n < 0 || n >= arr.length) {
+    throw new Error('Invalid index')
+  }
+
+  const partition = (arr, left, right, pivotIndex) => {
+    const pivotValue = arr[pivotIndex]
+    ;[arr[pivotIndex], arr[right]] = [arr[right], arr[pivotIndex]]
+    let storeIndex = left
+
+    for (let i = left; i < right; i++) {
+      if (compareFn(arr[i], pivotValue) < 0) {
+        ;[arr[i], arr[storeIndex]] = [arr[storeIndex], arr[i]]
+        storeIndex++
+      }
+    }
+
+    ;[arr[right], arr[storeIndex]] = [arr[storeIndex], arr[right]]
+    return storeIndex
+  }
+
+  const select = (arr, left, right, k) => {
+    if (left === right) {
+      return arr[left]
+    }
+
+    let pivotIndex = Math.floor(Math.random() * (right - left + 1)) + left
+    pivotIndex = partition(arr, left, right, pivotIndex)
+
+    if (k === pivotIndex) {
+      return arr[k]
+    } else if (k < pivotIndex) {
+      return select(arr, left, pivotIndex - 1, k)
+    } else {
+      return select(arr, pivotIndex + 1, right, k)
+    }
+  }
+
+  return select(arr, 0, arr.length - 1, n)
+}
+

From a3a343cb39b561ff7c247073bed4a3373e75f830 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 8 Apr 2024 13:36:57 +0800
Subject: [PATCH 3022/3374] Update 2448-minimum-cost-to-make-array-equal.js

---
 2448-minimum-cost-to-make-array-equal.js | 41 ++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/2448-minimum-cost-to-make-array-equal.js b/2448-minimum-cost-to-make-array-equal.js
index ea777961..39f0e560 100644
--- a/2448-minimum-cost-to-make-array-equal.js
+++ b/2448-minimum-cost-to-make-array-equal.js
@@ -29,3 +29,44 @@ const minCost = function (nums, cost) {
     return res
   }
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[]} cost
+ * @return {number}
+ */
+const minCost = function(nums, cost) {
+  const n = nums.length
+  const {min, max, abs, floor} = Math
+  let l = Infinity, r = -Infinity
+  
+  for(const e of nums) {
+    l = min(e, l)
+    r = max(e, r)
+  }
+  let res = calcCost(l)
+  while(l < r) {
+    const mid = floor((l + r) / 2)
+    const v1 = calcCost(mid)
+    const v2 = calcCost(mid + 1)
+    res = min(res, v1, v2)
+    if(v1 < v2) {
+      r = mid
+    } else {
+      l = mid + 1
+    }
+  }
+  
+  return res
+  
+   
+  function calcCost(x) {
+    let res = 0
+    for(let i = 0; i < n; i++) {
+      res += abs(nums[i] - x) * cost[i]
+    }
+    return res
+  }
+};

From adf51d2447e0d3a9c7e5a80ce920ce3d54bcc8a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 9 Apr 2024 18:32:47 +0800
Subject: [PATCH 3023/3374] Update
 2033-minimum-operations-to-make-a-uni-value-grid.js

---
 ...mum-operations-to-make-a-uni-value-grid.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/2033-minimum-operations-to-make-a-uni-value-grid.js b/2033-minimum-operations-to-make-a-uni-value-grid.js
index edb3acc4..43f45805 100644
--- a/2033-minimum-operations-to-make-a-uni-value-grid.js
+++ b/2033-minimum-operations-to-make-a-uni-value-grid.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} x
+ * @return {number}
+ */
+function minOperations(grid, x) {
+  const m = grid.length, n = grid[0].length
+  const len = m * n, arr = []
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      arr.push(grid[i][j])
+    }
+  }
+  arr.sort((a, b) => a - b)
+  const mid = arr[Math.floor(len / 2)]
+  let res = 0
+  for(const e of arr) {
+    const d = Math.abs(e - mid)
+    if(d % x !== 0) return -1
+    res += d / x
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} grid
  * @param {number} x

From b8a22917074ad280f670dc29c7d4823378a069bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Apr 2024 16:43:08 +0800
Subject: [PATCH 3024/3374] Create
 3116-kth-smallest-amount-with-single-denomination-combination.js

---
 ...nt-with-single-denomination-combination.js | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 3116-kth-smallest-amount-with-single-denomination-combination.js

diff --git a/3116-kth-smallest-amount-with-single-denomination-combination.js b/3116-kth-smallest-amount-with-single-denomination-combination.js
new file mode 100644
index 00000000..fd7401cf
--- /dev/null
+++ b/3116-kth-smallest-amount-with-single-denomination-combination.js
@@ -0,0 +1,59 @@
+function calcLcm(a, b) {
+  let p = a * b
+
+  let t = 0
+  while (b) {
+    t = b
+    b = a % b
+    a = t
+  }
+
+  return p / a
+}
+
+/**
+ * @param {number[]} coins
+ * @param {number} k
+ * @return {number}
+ */
+var findKthSmallest = function (coins, k) {
+  let n = coins.length
+
+  let cnt = 0
+  let lcm = 1
+  let sgn = -1
+  let cur = 0
+  let res = 0
+
+  let l = 1
+  let r = 50000000000
+
+  while (l <= r) {
+    cur = Math.floor((l + r) / 2)
+    cnt = 0
+    bt(0)
+
+    if (cnt >= k) {
+      res = cur
+      r = cur - 1
+    } else {
+      l = cur + 1
+    }
+  }
+
+  return res
+  
+  function bt(i) {
+    let bak = lcm
+    lcm = calcLcm(lcm, coins[i])
+    sgn = -sgn
+    cnt += sgn * Math.floor(cur / lcm)
+
+    ++i
+    if (i < n) bt(i)
+
+    lcm = bak
+    sgn = -sgn
+    if (i < n) bt(i)
+  }
+}

From d88619c9d56108273fecab9fbe69c01f71724419 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Apr 2024 16:46:30 +0800
Subject: [PATCH 3025/3374] Create
 3117-minimum-sum-of-values-by-dividing-array.js

---
 ...minimum-sum-of-values-by-dividing-array.js | 243 ++++++++++++++++++
 1 file changed, 243 insertions(+)
 create mode 100644 3117-minimum-sum-of-values-by-dividing-array.js

diff --git a/3117-minimum-sum-of-values-by-dividing-array.js b/3117-minimum-sum-of-values-by-dividing-array.js
new file mode 100644
index 00000000..7c6eb968
--- /dev/null
+++ b/3117-minimum-sum-of-values-by-dividing-array.js
@@ -0,0 +1,243 @@
+//#region Circular Queue
+/**
+ * @template TItem
+ */
+class CircularQueue {
+  /**
+   * @param {number} capacity
+   */
+  constructor(capacity) {
+    /**
+     * @private
+     * @type {number}
+     */
+    this._capacity = capacity
+    /**
+     * @private
+     * @type {number}
+     */
+    this._size = 0
+    /**
+     * @private
+     * @type {number}
+     */
+    this._bottom = 0
+
+    /**
+     * @private
+     * @type {number}
+     */
+    this._maxSize = 0
+
+    /**
+     * @private
+     * @type {TItem[]}
+     */
+    this._data = Array(capacity).fill(undefined)
+  }
+
+  /**
+   * @private
+   * @param {number} index
+   * @returns {number}
+   */
+  _getCircularIndex(index) {
+    const result = index % this._capacity
+    if (result < 0) result += this._capacity
+    return result
+  }
+
+  get capacity() {
+    return this._capacity
+  }
+
+  get size() {
+    return this._size
+  }
+
+  get nextItem() {
+    return this._size ? this._data[this._bottom] : undefined
+  }
+
+  get lastItem() {
+    return this._size
+      ? this._data[this._getCircularIndex(this._bottom + this._size - 1)]
+      : undefined
+  }
+
+  fromFirst(index) {
+    return index < this._size
+      ? this._data[this._getCircularIndex(this._bottom + index)]
+      : undefined
+  }
+
+  fromLast(index) {
+    return index < this._size
+      ? this._data[
+          this._getCircularIndex(this._bottom + this._size - 1 - index)
+        ]
+      : undefined
+  }
+
+  /**
+   * @param  {...TItem} items
+   */
+  enqueue(...items) {
+    if (this._size + items.length > this._capacity)
+      throw new Error('Queue capacity exceeded.')
+
+    let queueIndex = (this._bottom + this._size) % this._capacity
+    this._size += items.length
+    this._maxSize = Math.max(this._size, this._maxSize)
+    for (let i = 0; i < items.length; ++i) {
+      this._data[queueIndex] = items[i]
+      queueIndex = (queueIndex + 1) % this._capacity
+    }
+  }
+
+  /**
+   * @returns {TItem | undefined}
+   */
+  dequeue() {
+    if (!this._size) return undefined
+
+    const result = this._data[this._bottom]
+    this._bottom = (this._bottom + 1) % this._capacity
+    --this._size
+
+    return result
+  }
+
+  /**
+   * @returns {TItem | undefined}
+   */
+  popLast() {
+    if (!this._size) return undefined
+
+    --this._size
+    const result = this._data[(this._bottom + this._size) % this._capacity]
+
+    return result
+  }
+
+  clear() {
+    this._size = 0
+  }
+
+  get maxSize() {
+    return this._maxSize
+  }
+
+  asArray() {
+    let res = []
+    for (let i = 0; i < this._size; ++i) {
+      res.push(this.fromFirst(i))
+    }
+
+    return res
+  }
+}
+//#endregion
+
+let oo = 1048575
+let dp = new Uint32Array(10001)
+let dq = new CircularQueue(10001)
+
+//#region Segment tree
+let st = new Uint32Array(40004)
+
+function buildST(nums, root, l, r) {
+  if (l == r) {
+    st[root] = nums[l]
+    return
+  }
+
+  let m = (l + r) >> 1
+  let c = root * 2 + 1
+  buildST(nums, c, l, m)
+  buildST(nums, c + 1, m + 1, r)
+
+  st[root] = st[c] & st[c + 1]
+}
+
+function queryST(ql, qr, root, l, r) {
+  if (qr < l || ql > r) return oo
+  if (ql <= l && r <= qr) return st[root]
+
+  let m = (l + r) >> 1
+  let c = root * 2 + 1
+  let x = queryST(ql, qr, c, l, m)
+  let y = queryST(ql, qr, c + 1, m + 1, r)
+
+  return x & y
+}
+//#endregion
+
+
+/**
+ * @param {number[]} nums
+ * @param {number[]} andValues
+ * @return {number}
+ */
+var minimumValueSum = function (nums, andValues) {
+  let n = nums.length
+  let m = andValues.length
+  buildST(nums, 0, 0, n - 1)
+
+  dp.fill(oo, 0, n)
+  let a = nums[0]
+  let t = andValues[0]
+  for (let i = 0; i < n; ++i) {
+    a &= nums[i]
+
+    if (a == t) {
+      dp[i] = nums[i]
+    }
+  }
+
+  for (let j = 1; j < m; ++j) {
+    dq.clear()
+    t = andValues[j]
+    let ll = n
+    let rr = n - 1
+
+    for (let i = n - 1; i >= 0; --i) {
+      if (rr > i) {
+        rr = i
+      }
+
+      a = queryST(rr, i, 0, 0, n - 1)
+      while (rr > 1 && a > t && (a & nums[rr - 1]) >= t) {
+        a &= nums[--rr]
+      }
+
+      if (a != t || !rr) {
+        dp[i] = oo
+        continue
+      }
+
+      if (ll > rr) {
+        ll = rr
+        dq.clear()
+        dq.enqueue(ll - 1)
+      }
+
+      while (ll > 1 && (a & nums[ll - 1]) == a) {
+        --ll
+
+        while (dq.size && dp[ll - 1] <= dp[dq.fromLast(0)]) {
+          dq.popLast()
+        }
+        dq.enqueue(ll - 1)
+      }
+
+      while (dq.size && dq.fromFirst(0) >= rr) {
+        dq.dequeue()
+      }
+
+      dp[i] = Math.min(dp[dq.fromFirst(0)] + nums[i], oo)
+    }
+  }
+
+  return dp[n - 1] >= oo ? -1 : dp[n - 1]
+}

From 2b294c92e96e4ab9432b5cf3cdf60413aba39ad5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Apr 2024 16:47:40 +0800
Subject: [PATCH 3026/3374] Create 3115-maximum-prime-difference.js

---
 3115-maximum-prime-difference.js | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 3115-maximum-prime-difference.js

diff --git a/3115-maximum-prime-difference.js b/3115-maximum-prime-difference.js
new file mode 100644
index 00000000..9dfe499c
--- /dev/null
+++ b/3115-maximum-prime-difference.js
@@ -0,0 +1,32 @@
+const isPrime = num => {
+    for(let i = 2, s = Math.sqrt(num); i <= s; i++) {
+        if(num % i === 0) return false;
+    }
+    return num > 1;
+}
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumPrimeDifference = function(nums) {
+  let fi = -1, li = nums.length
+  const n = nums.length
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    if(isPrime(e)) {
+      fi = i
+      break
+    }
+  }
+  for(let i = n - 1; i >= 0; i--) {
+    const e = nums[i]
+    if(isPrime(e)) {
+      li = i
+      break
+    }
+  }
+  
+  if(fi === -1) return 0
+  
+  return li - fi
+};

From 1c11c80a583bd8e2100a624be56eaef26919cbd0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 16 Apr 2024 16:48:18 +0800
Subject: [PATCH 3027/3374] Create
 3114-latest-time-you-can-obtain-after-replacing-characters.js

---
 ...u-can-obtain-after-replacing-characters.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 3114-latest-time-you-can-obtain-after-replacing-characters.js

diff --git a/3114-latest-time-you-can-obtain-after-replacing-characters.js b/3114-latest-time-you-can-obtain-after-replacing-characters.js
new file mode 100644
index 00000000..df8e8040
--- /dev/null
+++ b/3114-latest-time-you-can-obtain-after-replacing-characters.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var findLatestTime = function (s) {
+  let l = s.split('')
+
+  if (l[0] === '?') {
+    l[0] = l[1] === '?' || parseInt(l[1]) <= 1 ? '1' : '0'
+  }
+
+  if (l[1] === '?') {
+    l[1] = l[0] === '1' ? '1' : '9'
+  }
+
+  if (l[3] === '?') {
+    l[3] = '5'
+  }
+
+  if (l[4] === '?') {
+    l[4] = '9'
+  }
+
+  return l.join('')
+}

From 0f4d4c8913068d5ff6aa2ad26f26548f39cffb06 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Apr 2024 19:53:53 +0800
Subject: [PATCH 3028/3374] Create 1131-maximum-of-absolute-value-expression.js

---
 1131-maximum-of-absolute-value-expression.js | 23 ++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 1131-maximum-of-absolute-value-expression.js

diff --git a/1131-maximum-of-absolute-value-expression.js b/1131-maximum-of-absolute-value-expression.js
new file mode 100644
index 00000000..ca0c1470
--- /dev/null
+++ b/1131-maximum-of-absolute-value-expression.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} arr1
+ * @param {number[]} arr2
+ * @return {number}
+ */
+var maxAbsValExpr = function(arr1, arr2) {
+    let n = arr1.length;
+    let combs = [
+      [1,1],[1,-1],[-1,1],[-1,-1]
+    ];
+    let result = -Infinity;
+    for(let [p,q] of combs) {
+      let max = -Infinity, min = Infinity;
+      for(let i=0; i < n; i++) {
+        let value = (p * arr1[i]) + (q * arr2[i]) + i;
+        max = Math.max(max,value);
+        min = Math.min(min,value);
+      };
+      result = Math.max(result, max-min);
+    };
+    return result;
+};
+

From 19d3893d4421be858ef7bf62005c87c09ad8b454 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Apr 2024 22:02:01 +0800
Subject: [PATCH 3029/3374] Update
 2584-split-the-array-to-make-coprime-products.js

---
 ...plit-the-array-to-make-coprime-products.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)

diff --git a/2584-split-the-array-to-make-coprime-products.js b/2584-split-the-array-to-make-coprime-products.js
index 3d148bc2..dae2db5e 100644
--- a/2584-split-the-array-to-make-coprime-products.js
+++ b/2584-split-the-array-to-make-coprime-products.js
@@ -1,3 +1,54 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findValidSplit = function(nums) {
+    const rightCounter = new Map();
+
+    for (const num of nums) {
+        for (const [prime, count] of getPrimesCount(num)) {
+            rightCounter.set(prime, (rightCounter.get(prime) ?? 0) + count);
+        }
+    }
+
+    const leftCounter = new Map();
+    const common = new Set();
+
+    for (let i = 0; i < nums.length - 1; i++) {
+        for (const [prime, count] of getPrimesCount(nums[i])) {
+            leftCounter.set(prime, (leftCounter.get(prime) ?? 0) + count);
+            rightCounter.set(prime, rightCounter.get(prime) - count);
+
+            if (rightCounter.get(prime) > 0) common.add(prime);
+            if (rightCounter.get(prime) === 0) common.delete(prime);
+        }
+
+        if (common.size === 0) return i;
+    }
+
+    return -1;
+};
+
+function getPrimesCount(n) {
+    const count = new Map();
+
+    for (let i = 2; (i * i) <= n; i++) {
+        while (n % i === 0) {
+            count.set(i, (count.get(i) ?? 0) + 1);
+            n /= i;
+        }
+    }
+
+    if (n > 1) {
+        count.set(n, (count.get(n) ?? 0) + 1);
+    }
+
+    return count;
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From 6bb73892e2d0d2cf26efd3a525d06a50db7ca664 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Apr 2024 21:04:02 +0800
Subject: [PATCH 3030/3374] Create 3123-find-edges-in-shortest-paths.js

---
 3123-find-edges-in-shortest-paths.js | 139 +++++++++++++++++++++++++++
 1 file changed, 139 insertions(+)
 create mode 100644 3123-find-edges-in-shortest-paths.js

diff --git a/3123-find-edges-in-shortest-paths.js b/3123-find-edges-in-shortest-paths.js
new file mode 100644
index 00000000..670b3013
--- /dev/null
+++ b/3123-find-edges-in-shortest-paths.js
@@ -0,0 +1,139 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean[]}
+ */
+var findAnswer = function (n, edges) {
+  let graph = {}
+  let edgeMapWithIndex = {}
+
+  for (let i = 0; i < n; i++) {
+    graph[i] = []
+  }
+
+  for (let i = 0; i < edges.length; i++) {
+    let [node1, node2, cost] = edges[i]
+    graph[node1].push([node2, cost])
+    graph[node2].push([node1, cost])
+    edgeMapWithIndex[String(node1) + '.' + String(node2)] = i
+    edgeMapWithIndex[String(node2) + '.' + String(node1)] = i
+  }
+
+  let distance = new Array(n).fill(Infinity)
+  distance[0] = 0
+
+  let pq = new PQ((a, b) => a[1] < b[1])
+
+  // node,cost
+  pq.push([0, 0, [0]])
+
+  let shortestPath = null
+  let visited = new Array(edges.length).fill(false)
+
+  while (!pq.isEmpty()) {
+    let [node, currentCost, path] = pq.pop()
+
+    if (node === n - 1) {
+      if (shortestPath === null) {
+        shortestPath = currentCost
+      } else if (shortestPath !== currentCost) {
+        continue
+      }
+
+      for (let i = 0; i < path.length - 1; i++) {
+        let key1 = String(path[i]) + '.' + String(path[i + 1])
+        let key2 = String(path[i + 1]) + '.' + String(path[i])
+
+        if (edgeMapWithIndex[key1] !== undefined) {
+          visited[edgeMapWithIndex[key1]] = true
+        } else if (edgeMapWithIndex[key2] !== undefined) {
+          visited[edgeMapWithIndex[key2]] = true
+        }
+      }
+      continue
+    }
+
+    if (shortestPath !== null && currentCost >= shortestPath) {
+      continue
+    }
+
+    let neighbours = graph[node]
+
+    for (let [neighbour, cost] of neighbours) {
+      if (currentCost + cost <= distance[neighbour]) {
+        distance[neighbour] = currentCost + cost
+        pq.push([neighbour, distance[neighbour], [...path, neighbour]])
+      }
+    }
+  }
+
+  return visited
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From cd6d6a8d9b48e3ac117758d127c2614e38771da3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Apr 2024 12:26:13 +0800
Subject: [PATCH 3031/3374] Create 3131-find-the-integer-added-to-array-i.js

---
 3131-find-the-integer-added-to-array-i.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 3131-find-the-integer-added-to-array-i.js

diff --git a/3131-find-the-integer-added-to-array-i.js b/3131-find-the-integer-added-to-array-i.js
new file mode 100644
index 00000000..59378cf0
--- /dev/null
+++ b/3131-find-the-integer-added-to-array-i.js
@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var addedInteger = function(nums1, nums2) {
+  nums1.sort((a,b) => a - b)
+  nums2.sort((a,b) => a - b)
+  return nums2[0] - nums1[0]
+};

From 89e8154bc6d8627c5489a006aea5fed4bf020c77 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Apr 2024 12:26:54 +0800
Subject: [PATCH 3032/3374] Create 3132-find-the-integer-added-to-array-ii.js

---
 3132-find-the-integer-added-to-array-ii.js | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 3132-find-the-integer-added-to-array-ii.js

diff --git a/3132-find-the-integer-added-to-array-ii.js b/3132-find-the-integer-added-to-array-ii.js
new file mode 100644
index 00000000..aae98108
--- /dev/null
+++ b/3132-find-the-integer-added-to-array-ii.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var minimumAddedInteger = function (nums1, nums2) {
+  nums1.sort((a, b) => a - b)
+  nums2.sort((a, b) => a - b)
+  let min = Number.MAX_SAFE_INTEGER
+  for (let i = 0; i < nums1.length - 1; i++) {
+    for (let j = i + 1; j < nums1.length; j++) {
+      const [flag, value] = judgeEqual(nums1, nums2, i, j)
+      if (flag && min > value) {
+        min = value
+      }
+    }
+  }
+  return min
+}
+
+function judgeEqual(nums1, nums2, i, j) {
+  let m = 0
+  let n = 0
+  let flag = false
+  let value = 0
+  while (m < nums1.length) {
+    if (m === i || m === j) {
+      m++
+      continue
+    }
+    if (!flag) {
+      value = nums2[n] - nums1[m]
+      m++
+      n++
+      flag = true
+      continue
+    }
+    if (nums2[n] - nums1[m] !== value) {
+      return [false, 0]
+    }
+    m++
+    n++
+  }
+  return [true, value]
+}

From df72253518087cb578d58f21d3f31f67035e4a0b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Apr 2024 12:27:35 +0800
Subject: [PATCH 3033/3374] Create 3133-minimum-array-end.js

---
 3133-minimum-array-end.js | 39 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 3133-minimum-array-end.js

diff --git a/3133-minimum-array-end.js b/3133-minimum-array-end.js
new file mode 100644
index 00000000..037aa7b4
--- /dev/null
+++ b/3133-minimum-array-end.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number} n
+ * @param {number} x
+ * @return {number}
+ */
+var minEnd = function (n, x) {
+  let str = x.toString(2).padStart(50, '0')
+
+  let map = new Map()
+  let c = 1
+  for (let i = str.length - 1; i >= 0; i--) {
+    if (str[i] === '0') {
+      map.set(c, i)
+      c *= 2
+    }
+  }
+
+  let sb = str.split('')
+  let cur = n
+  ;[...map.keys()]
+    .sort((a, b) => b - a)
+    .forEach((key) => {
+      if (cur > key) {
+        cur -= key
+        sb[map.get(key)] = '1'
+      }
+    })
+
+  let ans = 0
+  let step = 1
+  for (let i = sb.length - 1; i >= 0; i--) {
+    if (sb[i] === '1') {
+      ans += step
+    }
+    step *= 2
+  }
+
+  return ans
+}

From a08249c12bbf658a50a7e801cc8f6a0abf1a7d43 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Apr 2024 12:28:09 +0800
Subject: [PATCH 3034/3374] Create
 3134-find-the-median-of-the-uniqueness-array.js

---
 ...find-the-median-of-the-uniqueness-array.js | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 3134-find-the-median-of-the-uniqueness-array.js

diff --git a/3134-find-the-median-of-the-uniqueness-array.js b/3134-find-the-median-of-the-uniqueness-array.js
new file mode 100644
index 00000000..9e7dce3c
--- /dev/null
+++ b/3134-find-the-median-of-the-uniqueness-array.js
@@ -0,0 +1,61 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var medianOfUniquenessArray = function (nums) {
+  let low = 1
+  let high = nums.length
+  let n = nums.length
+
+  while (low < high) {
+    let mid = low + Math.floor((high - low) / 2)
+    if (countDistinct(nums, mid) >= Math.floor(((n * (n + 1)) / 2 + 1) / 2)) {
+      high = mid
+    } else {
+      low = mid + 1
+    }
+  }
+
+  if (
+    countDistinct(nums, low - 1) === Math.floor(((n * (n + 1)) / 2 + 1) / 2)
+  ) {
+    return low - 1
+  }
+  return low
+}
+
+function countDistinct(nums, k) {
+  let occurrences = new Map()
+  let left = 0
+  let count = 0
+  let result = 0
+
+  for (let right = 0; right < nums.length; right++) {
+    occurrences.set(nums[right], (occurrences.get(nums[right]) || 0) + 1)
+    if (occurrences.get(nums[right]) === 1) {
+      count++
+    }
+    while (count > k) {
+      occurrences.set(nums[left], occurrences.get(nums[left]) - 1)
+      if (occurrences.get(nums[left]) === 0) {
+        count--
+      }
+      left++
+    }
+    result += right - left + 1
+  }
+  return result
+}
+
+function force(nums) {
+  let l = []
+  for (let i = 0; i < nums.length; i++) {
+    let set = new Set()
+    for (let j = i; j < nums.length; j++) {
+      set.add(nums[j])
+      l.push(set.size)
+    }
+  }
+  l.sort((a, b) => a - b)
+  return l[Math.floor(l.length / 2)]
+}

From 89ccb83fdfcb13a48e8016ba0c514255cb738344 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 29 Apr 2024 17:21:24 +0800
Subject: [PATCH 3035/3374] Update 787-cheapest-flights-within-k-stops.js

---
 787-cheapest-flights-within-k-stops.js | 43 ++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/787-cheapest-flights-within-k-stops.js b/787-cheapest-flights-within-k-stops.js
index c0cd2f99..db9dd6dc 100644
--- a/787-cheapest-flights-within-k-stops.js
+++ b/787-cheapest-flights-within-k-stops.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number[][]} flights
+ * @param {number} src
+ * @param {number} dst
+ * @param {number} K
+ * @return {number}
+ */
+const findCheapestPrice = function(n, flights, src, dst, K) {
+  const arr = Array(n).fill(Infinity)
+  arr[src] = 0
+  const g = {}
+  for(const [u,v,p] of flights) {
+    if(g[u] == null) g[u] = []
+    g[u].push([v, p])
+  }
+
+  let step = 0
+  let q = [[src,0]]
+  while(step < K + 1 && q.length) {
+    const len = q.length
+    const row = []
+    for(let i = 0; i < len; i++) {
+      const el = q[i]
+      const [s, dis] = el
+      for(const e of (g[s] || [])) {
+        const [nxt, p] = e
+        if(arr[nxt] > p + dis) {
+          arr[nxt] = p + dis
+          row.push([nxt, arr[nxt]])
+        }
+        
+      }      
+    }
+    q = row
+    step++
+  }
+  
+  return arr[dst] === Infinity ? -1 : arr[dst]
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} flights

From e3b21c3338308f23a82d0a059043107cb2a25e5a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 May 2024 20:35:52 +0800
Subject: [PATCH 3036/3374] Update 1514-path-with-maximum-probability.js

---
 1514-path-with-maximum-probability.js | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/1514-path-with-maximum-probability.js b/1514-path-with-maximum-probability.js
index bd47209e..e134e58b 100644
--- a/1514-path-with-maximum-probability.js
+++ b/1514-path-with-maximum-probability.js
@@ -6,7 +6,7 @@
  * @param {number} end
  * @return {number}
  */
-const maxProbability = function (n, edges, succProb, start, end) {
+var maxProbability = function (n, edges, succProb, start, end) {
   const g = {}
   for (let i = 0; i < edges.length; ++i) {
     const a = edges[i][0],
@@ -16,15 +16,13 @@ const maxProbability = function (n, edges, succProb, start, end) {
     g[a].push([b, i])
     g[b].push([a, i])
   }
-  const p = new Array(n).fill(0)
+  const p = new Array(n).fill(-1)
   p[start] = 1
-  const pq = new PriorityQueue((a, b) => p[a] > p[b])
+  const pq = new PQ((a, b) => p[a] > p[b])
   pq.push(start)
   while (!pq.isEmpty()) {
     const cur = pq.pop()
-    if (cur === end) {
-      return p[end]
-    }
+
     for (let a of g[cur] || []) {
       const neighbor = a[0],
         index = a[1]
@@ -34,9 +32,9 @@ const maxProbability = function (n, edges, succProb, start, end) {
       }
     }
   }
-  return 0
+  return p[end] === -1 ? 0 : p[end]
 }
-class PriorityQueue {
+class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []
     this.top = 0

From c597f2f475e5eddb8bb5b939b7f3b25bce512cdb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 May 2024 14:08:46 +0800
Subject: [PATCH 3037/3374] Create 3136-valid-word.js

---
 3136-valid-word.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 3136-valid-word.js

diff --git a/3136-valid-word.js b/3136-valid-word.js
new file mode 100644
index 00000000..a5f51edb
--- /dev/null
+++ b/3136-valid-word.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} word
+ * @return {boolean}
+ */
+var isValid = function (word) {
+  const set = new Set(['a', 'e', 'i', 'o', 'u'])
+  let ans = true
+  ans = ans && word.length >= 3
+  ans =
+    ans &&
+    [...word].every(
+      (char) =>
+        (char >= '0' && char <= '9') ||
+        (char >= 'a' && char <= 'z') ||
+        (char >= 'A' && char <= 'Z'),
+    )
+  ans = ans && [...word].some((char) => set.has(char.toLowerCase()))
+  ans =
+    ans &&
+    [...word].some(
+      (char) =>
+        char.toLowerCase() >= 'a' &&
+        char.toLowerCase() <= 'z' &&
+        !set.has(char.toLowerCase()),
+    )
+  return ans
+}

From 800294cb625a09423f10611b3d78ab025279a96c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 May 2024 14:09:20 +0800
Subject: [PATCH 3038/3374] Create
 3137-minimum-number-of-operations-to-make-word-k-periodic.js

---
 ...mber-of-operations-to-make-word-k-periodic.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3137-minimum-number-of-operations-to-make-word-k-periodic.js

diff --git a/3137-minimum-number-of-operations-to-make-word-k-periodic.js b/3137-minimum-number-of-operations-to-make-word-k-periodic.js
new file mode 100644
index 00000000..2180881a
--- /dev/null
+++ b/3137-minimum-number-of-operations-to-make-word-k-periodic.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} word
+ * @param {number} k
+ * @return {number}
+ */
+var minimumOperationsToMakeKPeriodic = function (word, k) {
+  const n = Math.floor(word.length / k)
+  const map = new Map()
+
+  for (let i = 0; i < word.length; i += k) {
+    const sub = word.substring(i, i + k)
+    map.set(sub, (map.get(sub) || 0) + 1)
+  }
+
+  return n - Math.max(...map.values())
+}

From e020460a5334a665d2272bd349ab5eec4de247d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 May 2024 14:09:50 +0800
Subject: [PATCH 3039/3374] Create
 3138-minimum-length-of-anagram-concatenation.js

---
 ...minimum-length-of-anagram-concatenation.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3138-minimum-length-of-anagram-concatenation.js

diff --git a/3138-minimum-length-of-anagram-concatenation.js b/3138-minimum-length-of-anagram-concatenation.js
new file mode 100644
index 00000000..823168ce
--- /dev/null
+++ b/3138-minimum-length-of-anagram-concatenation.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minAnagramLength = function (s) {
+  const n = s.length
+
+  function checkI(k) {
+    const set = new Set()
+    for (let i = 0; i < n; i += k) {
+      const sub = s
+        .substring(i, i + k)
+        .split('')
+        .sort()
+        .join('')
+      set.add(sub)
+      if (set.size > 1) return false
+    }
+    return true
+  }
+
+  for (let i = 1; i <= n; i++) {
+    if (n % i === 0) {
+      if (checkI(i)) {
+        return i
+      }
+    }
+  }
+
+  return s.length
+}

From 2ec1c17f4c13275f445a4f21584e7472305d8878 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 5 May 2024 14:10:24 +0800
Subject: [PATCH 3040/3374] Create 3139-minimum-cost-to-equalize-array.js

---
 3139-minimum-cost-to-equalize-array.js | 54 ++++++++++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 3139-minimum-cost-to-equalize-array.js

diff --git a/3139-minimum-cost-to-equalize-array.js b/3139-minimum-cost-to-equalize-array.js
new file mode 100644
index 00000000..d7a2e76d
--- /dev/null
+++ b/3139-minimum-cost-to-equalize-array.js
@@ -0,0 +1,54 @@
+/**
+ * @param {number[]} nums
+ * @param {number} cost1
+ * @param {number} cost2
+ * @return {number}
+ */
+var minCostToEqualizeArray = function (nums, cost1, cost2) {
+  const big = BigInt
+  const mod = big(1e9 + 7)
+  const max = Math.max(...nums)
+  
+  cost1 = big(cost1)
+  cost2 = big(cost2)
+  
+  const l = []
+  let sum = 0n
+  for (let i = 0; i < nums.length; i++) {
+    const diff = big(max - nums[i])
+    sum += diff
+    l.push(diff)
+  }
+  l.sort((a ,b) => {
+    if(a > b) {
+      return -1;
+    } else if (a < b){
+      return 1;
+    } else {
+      return 0;
+    }
+  });
+
+  if (cost1 * 2n <= cost2) {
+    return Number((sum * cost1) % mod)
+  }
+
+  let ans = big(1e30)
+  for (let add = 0; add <= max; add++) {
+    let tmp = 0n
+    if (l[0] <= sum / 2n) {
+      tmp += (sum / 2n) * cost2
+      tmp += (sum % 2n) * cost1
+      if(tmp < ans) ans = tmp
+    } else {
+      tmp += (sum - l[0]) * cost2
+      tmp += (l[0] - (sum - l[0])) * cost1
+      if(tmp < ans) ans = tmp
+    }
+
+    l[0]++
+    sum += big(nums.length)
+  }
+
+  return ans % mod
+}

From 8569327149c1c0a5718c949679b4d4dd4e73b115 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 May 2024 16:36:38 +0800
Subject: [PATCH 3041/3374] Create
 2203-minimum-weighted-subgraph-with-the-required-paths.js

---
 ...ighted-subgraph-with-the-required-paths.js | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 2203-minimum-weighted-subgraph-with-the-required-paths.js

diff --git a/2203-minimum-weighted-subgraph-with-the-required-paths.js b/2203-minimum-weighted-subgraph-with-the-required-paths.js
new file mode 100644
index 00000000..fe35f1de
--- /dev/null
+++ b/2203-minimum-weighted-subgraph-with-the-required-paths.js
@@ -0,0 +1,64 @@
+const initializeGraph = (n) => {
+  let g = []
+  for (let i = 0; i < n; i++) {
+    g.push([])
+  }
+  return g
+}
+const packDGCost = (g, ig, edges) => {
+  for (const [u, v, cost] of edges) {
+    g[u].push([v, cost])
+    ig[v].push([u, cost])
+  }
+}
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} src1
+ * @param {number} src2
+ * @param {number} dest
+ * @return {number}
+ */
+var minimumWeight = function(n, edges, src1, src2, dest) {
+  let g = initializeGraph(n),
+    ig = initializeGraph(n)
+  packDGCost(g, ig, edges)
+  /*
+        src1 -> x
+        src2 -> x
+        x -> dest  find smallest distance from all nodes to the destination, run Dijkstra in reverse from the destination
+     */
+  let d1 = dijkstra(g, src1),
+    d2 = dijkstra(g, src2),
+    d3 = dijkstra(ig, dest),
+    res = Number.MAX_SAFE_INTEGER
+  for (let i = 0; i < n; i++) res = Math.min(res, d1[i] + d2[i] + d3[i])
+  return res == Number.MAX_SAFE_INTEGER ? -1 : res
+}
+
+const dijkstra = (g, start) => {
+  // store the shortest distance from startNode to all other nodes
+  let n = g.length,
+    dis = Array(n).fill(Number.MAX_SAFE_INTEGER)
+  let pq = new MinPriorityQueue({
+    compare: (x, y) => {
+      if (x[0] != y[0]) return x[0] - y[0]
+      return x[1] - y[1]
+    },
+  })
+  dis[start] = 0
+  pq.enqueue([start, 0])
+  while (pq.size()) {
+    let [cur, d] = pq.dequeue()
+    if (d > dis[cur]) continue // larger distance, no need to find the route to next node
+    for (const [child, cost] of g[cur]) {
+      let toChildCost = d + cost
+      if (toChildCost < dis[child]) {
+        // each time total wight/cost to current child is smaller, updated it
+        dis[child] = toChildCost
+        pq.enqueue([child, toChildCost])
+      }
+    }
+  }
+  return dis    
+};

From 01dc7d657106e83c21d6a8fd20710c6b707f9aab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 May 2024 18:41:40 +0800
Subject: [PATCH 3042/3374] Create
 3112-minimum-time-to-visit-disappearing-nodes.js

---
 ...inimum-time-to-visit-disappearing-nodes.js | 123 ++++++++++++++++++
 1 file changed, 123 insertions(+)
 create mode 100644 3112-minimum-time-to-visit-disappearing-nodes.js

diff --git a/3112-minimum-time-to-visit-disappearing-nodes.js b/3112-minimum-time-to-visit-disappearing-nodes.js
new file mode 100644
index 00000000..96acaeeb
--- /dev/null
+++ b/3112-minimum-time-to-visit-disappearing-nodes.js
@@ -0,0 +1,123 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} disappear
+ * @return {number[]}
+ */
+var minimumTime = function(n, edges, disappear) {
+    const graph = {}; 
+    for (let i = 0; i < n; i++) {
+        graph[i] = [];
+    }
+    for (const [u, v, length] of edges) {
+        graph[u].push({ node: v, length });
+        graph[v].push({ node: u, length });
+    }
+
+    const answer = new Array(n).fill(-1);
+    const pq = new MinHeap();
+    const visited = new Set(); 
+
+    pq.insert(0, 0); 
+
+    while (!pq.isEmpty()) {
+        const [node, distance] = pq.removeMin();
+
+        if (visited.has(node)) continue; 
+        visited.add(node);
+
+        answer[node] = distance; 
+
+        for (const { node: adjNode, length } of graph[node]) {
+            if (disappear[adjNode] > distance + length && !visited.has(adjNode)) {
+                pq.insert(adjNode, distance + length);
+            }
+        }
+    }
+
+    return answer;
+};
+
+// Basic MinHeap implementation 
+class MinHeap {
+    constructor() {
+        this.heap = []; 
+    }
+
+    insert(node, distance) {
+        this.heap.push([node, distance]);
+        this.heapifyUp(); 
+    }
+
+    removeMin() {
+        [this.heap[0], this.heap[this.heap.length - 1]] = [this.heap[this.heap.length - 1], this.heap[0]]; 
+        const min = this.heap.pop();
+        this.heapifyDown();
+        return min;
+    }
+
+    heapifyUp() {
+        let index = this.heap.length - 1;
+        while (this.hasParent(index) && this.parent(index)[1] > this.heap[index][1]) {
+            [this.heap[this.parentIndex(index)], this.heap[index]] = [this.heap[index], this.heap[this.parentIndex(index)]];
+            index = this.parentIndex(index);
+        }
+    }
+
+    heapifyDown() {
+        let index = 0;
+        while (this.hasLeftChild(index)) {
+            let smallerChildIndex = this.leftChildIndex(index);
+            if (this.hasRightChild(index) && this.rightChild(index)[1] < this.leftChild(index)[1]) {
+                smallerChildIndex = this.rightChildIndex(index);
+            }
+
+            if (this.heap[index][1] < this.heap[smallerChildIndex][1]) {
+                break;
+            } else {
+                [this.heap[index], this.heap[smallerChildIndex]] = [this.heap[smallerChildIndex], this.heap[index]];
+            }
+            index = smallerChildIndex;
+        }
+    }
+
+    isEmpty() {
+        return this.heap.length === 0;
+    }
+
+    parentIndex(index) {
+        return Math.floor((index - 1) / 2);
+    }
+
+    leftChildIndex(index) {
+        return 2 * index + 1;
+    }
+
+    rightChildIndex(index) {
+        return 2 * index + 2;
+    }
+
+    hasParent(index) {
+        return this.parentIndex(index) >= 0;
+    }
+
+    hasLeftChild(index) {
+        return this.leftChildIndex(index) < this.heap.length;
+    }
+
+    hasRightChild(index) {
+        return this.rightChildIndex(index) < this.heap.length;
+    }
+
+    parent(index) {
+        return this.heap[this.parentIndex(index)];
+    }
+
+    leftChild(index) {
+        return this.heap[this.leftChildIndex(index)];
+    }
+
+    rightChild(index) {
+        return this.heap[this.rightChildIndex(index)];
+    }
+}

From 74b2154bed02caeca4aff2e898063c7a79d3b796 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 May 2024 21:20:15 +0800
Subject: [PATCH 3043/3374] Create
 3149-find-the-minimum-cost-array-permutation.js

---
 ...find-the-minimum-cost-array-permutation.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 3149-find-the-minimum-cost-array-permutation.js

diff --git a/3149-find-the-minimum-cost-array-permutation.js b/3149-find-the-minimum-cost-array-permutation.js
new file mode 100644
index 00000000..f9c6e032
--- /dev/null
+++ b/3149-find-the-minimum-cost-array-permutation.js
@@ -0,0 +1,49 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var findPermutation = function (nums) {
+  const n = nums.length
+  const memo = new Array(n).fill(0)
+  let min = Infinity
+  let res = null
+
+  recursive([], 0)
+
+  return res
+  
+  function recursive (oneCase, acc) {
+    if (acc > min) return
+
+    let flag = 0
+
+    for (let i = 0; i < n; i += 1) {
+      if (!memo[i]) {
+        flag = 1
+        memo[i] = 1
+        oneCase.push(i)
+        recursive(
+          oneCase,
+          oneCase.length >= 2
+            ? acc +
+                Math.abs(
+                  oneCase[oneCase.length - 2] -
+                    nums[oneCase[oneCase.length - 1]],
+                )
+            : acc,
+        )
+        memo[i] = 0
+        oneCase.pop()
+      }
+    }
+
+    if (!flag) {
+      acc += Math.abs(oneCase[oneCase.length - 1] - nums[oneCase[0]])
+
+      if (acc < min) {
+        res = [...oneCase]
+        min = acc
+      }
+    }
+  }
+}

From 9d33e89b980d082751861091522fafa00bf423a3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 May 2024 21:20:54 +0800
Subject: [PATCH 3044/3374] Create 3148-maximum-difference-score-in-a-grid.js

---
 3148-maximum-difference-score-in-a-grid.js | 41 ++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 3148-maximum-difference-score-in-a-grid.js

diff --git a/3148-maximum-difference-score-in-a-grid.js b/3148-maximum-difference-score-in-a-grid.js
new file mode 100644
index 00000000..ece4039f
--- /dev/null
+++ b/3148-maximum-difference-score-in-a-grid.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxScore = function (grid) {
+  const rows = grid.length
+  const cols = grid[0].length
+  const dp = new Array(rows)
+    .fill()
+    .map(() => new Array(cols).fill(-Infinity))
+
+  dp[rows - 1][cols - 1] = grid[rows - 1][cols - 1]
+
+  let res = -Infinity
+
+  for (let i = rows - 1; i >= 0; i--) {
+    for (let j = cols - 1; j >= 0; j--) {
+      if (i < rows - 1) {
+        dp[i][j] = Math.max(dp[i][j], dp[i + 1][j])
+      }
+
+      if (j < cols - 1) {
+        dp[i][j] = Math.max(dp[i][j], dp[i][j + 1])
+      }
+
+      dp[i][j] = Math.max(dp[i][j], grid[i][j])
+    }
+  }
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < cols; j++) {
+      if (i < rows - 1) {
+        res = Math.max(res, dp[i + 1][j] - grid[i][j])
+      }
+      if (j < cols - 1) {
+        res = Math.max(res, dp[i][j + 1] - grid[i][j])
+      }
+    }
+  }
+  return res
+}

From d3ca5f2136bbb94ab4932239d3e4abc2bf6e81a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 May 2024 21:21:27 +0800
Subject: [PATCH 3045/3374] Create
 3147-taking-maximum-energy-from-the-mystic-dungeon.js

---
 ...-maximum-energy-from-the-mystic-dungeon.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3147-taking-maximum-energy-from-the-mystic-dungeon.js

diff --git a/3147-taking-maximum-energy-from-the-mystic-dungeon.js b/3147-taking-maximum-energy-from-the-mystic-dungeon.js
new file mode 100644
index 00000000..2c4b1f17
--- /dev/null
+++ b/3147-taking-maximum-energy-from-the-mystic-dungeon.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} energy
+ * @param {number} k
+ * @return {number}
+ */
+var maximumEnergy = function (energy, k) {
+  const n = energy.length
+  const sum = new Array(n).fill(0)
+  const arr = new Array(k).fill(0)
+
+  let max = -Infinity
+
+  for (let i = 0; i < n; i++) {
+    arr[i % k] += energy[i]
+  }
+
+  for (let i = 0; i < k; i++) {
+    sum[i] = arr[i]
+    max = Math.max(sum[i], max)
+  }
+
+  for (let i = k; i < n; i++) {
+    sum[i] = sum[i - k] - energy[i - k]
+    max = Math.max(sum[i], max)
+  }
+
+  return max
+}

From 90db0b786cd792a31480ba24bd9947a916d15fad Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 12 May 2024 21:21:57 +0800
Subject: [PATCH 3046/3374] Create
 3146-permutation-difference-between-two-strings.js

---
 ...ermutation-difference-between-two-strings.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 3146-permutation-difference-between-two-strings.js

diff --git a/3146-permutation-difference-between-two-strings.js b/3146-permutation-difference-between-two-strings.js
new file mode 100644
index 00000000..a0191c21
--- /dev/null
+++ b/3146-permutation-difference-between-two-strings.js
@@ -0,0 +1,17 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {number}
+ */
+var findPermutationDifference = function(s, t) {
+    let  mp1 = {} ,mp2 = {}
+    for (let i = 0; i < s.length; i++) {
+        mp1[s[i]] = i
+        mp2[t[i]] = i
+    }
+    let res = 0
+    for (let i = 0; i < s.length; i++) {
+        res += Math.abs(mp1[s[i]] - mp2[s[i]])
+    }
+    return res
+};

From d3115a5a5faa31a36fc903fdb2339986deea0637 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 May 2024 17:15:45 +0800
Subject: [PATCH 3047/3374] Update
 1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js

---
 ...smallest-sum-of-a-matrix-with-sorted-rows.js | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
index 249cfbc6..11628f47 100644
--- a/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
+++ b/1439-find-the-kth-smallest-sum-of-a-matrix-with-sorted-rows.js
@@ -16,20 +16,23 @@ const kthSmallest = function(mat, k) {
     if (row === mat.length) return 1;
     let totalcnt = 0;
     for(let v of mat[row]) {
-      const cnt = check(row + 1, v + sum, limit);
+      let cnt = check(row+1, v+sum, limit);
       totalcnt += cnt;
-      if (cnt === 0 || totalcnt > k) break;  
+      if (cnt === 0 || totalcnt > k) break;
+      
     }
+    
     return totalcnt;
   };
 
-  while(lo <= hi) {
-    const m = (lo + (hi - lo) / 2) >> 0;
-    const cnt = check(0, 0, m);
+  
+  while(lo < hi) {
+    let m = Math.floor((lo+hi)/2);
+    let cnt = check(0,0,m);
     if (cnt < k) {
-      lo = m + 1;
+      lo = m+1;
     } else {
-      hi = m - 1;
+      hi = m;
     }
   }
 

From 5df9c67b035363ab1625ba930b0eaac863d72ccf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 May 2024 21:49:43 +0800
Subject: [PATCH 3048/3374] Update 786-k-th-smallest-prime-fraction.js

---
 786-k-th-smallest-prime-fraction.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/786-k-th-smallest-prime-fraction.js b/786-k-th-smallest-prime-fraction.js
index 28d7e73d..99e39b35 100644
--- a/786-k-th-smallest-prime-fraction.js
+++ b/786-k-th-smallest-prime-fraction.js
@@ -1,9 +1,10 @@
 /**
- * @param {number[]} A
- * @param {number} K
+ * @param {number[]} arr
+ * @param {number} k
  * @return {number[]}
  */
-const kthSmallestPrimeFraction = function(A, K) {
+var kthSmallestPrimeFraction = function(arr, k) {
+  const A = arr, K = k
   let ans = []
   let left = 0.0
   let right = 1.0
@@ -34,4 +35,4 @@ const kthSmallestPrimeFraction = function(A, K) {
     }
     return { count, p, q }
   }
-}
+};

From 08d82e4cb6ab2beaf2e70d232bef5c1f600070d4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 May 2024 21:52:03 +0800
Subject: [PATCH 3049/3374] Create 3151-special-array-i.js

---
 3151-special-array-i.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 3151-special-array-i.js

diff --git a/3151-special-array-i.js b/3151-special-array-i.js
new file mode 100644
index 00000000..005d43aa
--- /dev/null
+++ b/3151-special-array-i.js
@@ -0,0 +1,12 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var isArraySpecial = function (nums) {
+  for (let i = 0; i < nums.length - 1; i++) {
+    if (nums[i] % 2 == nums[i + 1] % 2) {
+      return false
+    }
+  }
+  return true
+}

From f2b880cc36682d6282eb1a721ae70aa41e863dc8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 May 2024 21:52:49 +0800
Subject: [PATCH 3050/3374] Create 3152-special-array-ii.js

---
 3152-special-array-ii.js | 40 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3152-special-array-ii.js

diff --git a/3152-special-array-ii.js b/3152-special-array-ii.js
new file mode 100644
index 00000000..82743e5e
--- /dev/null
+++ b/3152-special-array-ii.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+var isArraySpecial = function (nums, queries) {
+  let n = nums.length
+  let sameParity = new Array(n - 1).fill(false)
+
+
+  for (let i = 0; i < n - 1; ++i) {
+    if (nums[i] % 2 === nums[i + 1] % 2) {
+      sameParity[i] = true
+    }
+  }
+
+
+  let prefixSameParity = new Array(n).fill(0)
+  for (let i = 1; i < n; ++i) {
+    prefixSameParity[i] = prefixSameParity[i - 1] + (sameParity[i - 1] ? 1 : 0)
+  }
+
+  let res = []
+  for (const query of queries) {
+    let start = query[0]
+    let end = query[1]
+    if (start === end) {
+      // A single element subarray is always special
+      res.push(true)
+    } else {
+      if (prefixSameParity[end] - prefixSameParity[start] > 0) {
+        res.push(false)
+      } else {
+        res.push(true)
+      }
+    }
+  }
+
+  return res
+}

From 58c1557fd7595a9d3588f1d96150b1612c7dc486 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 May 2024 21:53:22 +0800
Subject: [PATCH 3051/3374] Create
 3153-sum-of-digit-differences-of-all-pairs.js

---
 3153-sum-of-digit-differences-of-all-pairs.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3153-sum-of-digit-differences-of-all-pairs.js

diff --git a/3153-sum-of-digit-differences-of-all-pairs.js b/3153-sum-of-digit-differences-of-all-pairs.js
new file mode 100644
index 00000000..03abf0ca
--- /dev/null
+++ b/3153-sum-of-digit-differences-of-all-pairs.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var sumDigitDifferences = function (nums) {
+  const numDigits = nums[0].toString().length
+  const n = nums.length
+  let totalDiff = 0
+
+  for (let pos = 0; pos < numDigits; ++pos) {
+    const digitCount = new Array(10).fill(0)
+    for (const num of nums) {
+      const digit = parseInt(num.toString()[pos])
+      digitCount[digit]++
+    }
+    for (let digit = 0; digit < 10; ++digit) {
+      const pairsCount = digitCount[digit] * (n - digitCount[digit])
+      totalDiff += pairsCount
+    }
+  }
+
+  return Math.floor(totalDiff / 2)
+}

From 9844c152d6e360fd7dfc9d8706a2ebb6826701ed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 May 2024 21:54:11 +0800
Subject: [PATCH 3052/3374] Create
 3154-find-number-of-ways-to-reach-the-k-th-stair.js

---
 ...-number-of-ways-to-reach-the-k-th-stair.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 3154-find-number-of-ways-to-reach-the-k-th-stair.js

diff --git a/3154-find-number-of-ways-to-reach-the-k-th-stair.js b/3154-find-number-of-ways-to-reach-the-k-th-stair.js
new file mode 100644
index 00000000..feefb525
--- /dev/null
+++ b/3154-find-number-of-ways-to-reach-the-k-th-stair.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} k
+ * @return {number}
+ */
+var waysToReachStair = function (k) {
+  const memo = new Map()
+
+  return dfs(1, 0, true)
+
+  function dfs(cur, jump, minus) {
+    const key = `${cur}-${jump}-${minus}`
+    if (memo.has(key)) return memo.get(key)
+
+    let ret = 0
+    if (cur - 2 > k) {
+      memo.set(key, ret)
+      return ret
+    }
+    if (cur === k) {
+      ret += 1
+    }
+    if (cur > 0 && minus) {
+      ret += dfs(cur - 1, jump, false)
+    }
+    ret += dfs(cur + 2 ** jump, jump + 1, true)
+
+    memo.set(key, ret)
+    return ret
+  }
+}

From 326a6fcbfd47061fe365b9abcc1bab65dd671803 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 21 May 2024 20:20:59 +0800
Subject: [PATCH 3053/3374] Update 1201-ugly-number-iii.js

---
 1201-ugly-number-iii.js | 43 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1201-ugly-number-iii.js b/1201-ugly-number-iii.js
index b2d7011a..b553502c 100644
--- a/1201-ugly-number-iii.js
+++ b/1201-ugly-number-iii.js
@@ -28,3 +28,46 @@ const nthUglyNumber = function(n, a, b, c) {
     return b === 0 ? a : gcd(b, a % b)
   }
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @return {number}
+ */
+var nthUglyNumber = function (n, a, b, c) {
+  const {floor} = Math
+  let lo = 1,
+    hi = 2 * (1e9 | 0)
+  ;(a = BigInt(a)), (b = BigInt(b)), (c = BigInt(c))
+  let ab = (a * b) / gcd(a, b)
+  let bc = (b * c) / gcd(b, c)
+  let ac = (a * c) / gcd(a, c)
+  let abc = (a * bc) / gcd(a, bc)
+
+  while (lo < hi) {
+    let mid = lo + ((hi - lo) >> 1)
+    let cnt =
+      floor(mid / Number(a)) +
+      floor(mid / Number(b)) +
+      floor(mid / Number(c)) -
+      floor(mid / Number(ab)) -
+      floor(mid / Number(bc)) -
+      floor(mid / Number(ac)) +
+      floor(mid / Number(abc))
+    if (cnt < n) {
+      lo = mid + 1
+    } else {
+      hi = mid
+    }
+  }
+
+  return lo
+
+  function gcd(a, b) {
+    return b ? gcd(b, a % b) : a
+  }
+}

From df5844713bbbd812c837f3bf3f673abfb797d285 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 23 May 2024 22:19:13 +0800
Subject: [PATCH 3054/3374] Update
 3116-kth-smallest-amount-with-single-denomination-combination.js

---
 ...nt-with-single-denomination-combination.js | 84 +++++++++++++++++++
 1 file changed, 84 insertions(+)

diff --git a/3116-kth-smallest-amount-with-single-denomination-combination.js b/3116-kth-smallest-amount-with-single-denomination-combination.js
index fd7401cf..b7c432bf 100644
--- a/3116-kth-smallest-amount-with-single-denomination-combination.js
+++ b/3116-kth-smallest-amount-with-single-denomination-combination.js
@@ -1,3 +1,87 @@
+/**
+ * @param {number[]} coins
+ * @param {number} k
+ * @return {number}
+ */
+var findKthSmallest = function (coins, k) {
+    const n = coins.length;
+    const dic = new Map();
+    for (let i = 1; i <= n; i++) {
+        const combinations = getCombinations(coins, i);
+        for (const comb of combinations) {
+            const lcm = getLCM(comb);
+            if (!dic.has(i)) {
+                dic.set(i, []);
+            }
+            dic.get(i).push(lcm);
+        }
+    }
+
+    function count(dic, target) {
+        let ans = 0;
+        for (let i = 1; i <= n; i++) {
+            const lcms = dic.get(i);
+            for (const lcm of lcms) {
+                ans += Math.floor(target / lcm) * Math.pow(-1, i + 1);
+            }
+        }
+        return ans;
+    }
+
+    let start = Math.min(...coins);
+    let end = Math.min(...coins) * k;
+    while (start + 1 < end) {
+        const mid = Math.floor((start + end) / 2);
+        if (count(dic, mid) >= k) {
+            end = mid;
+        } else {
+            start = mid;
+        }
+    }
+    if (count(dic, start) >= k) {
+        return start;
+    } else {
+        return end;
+    }
+
+    function getCombinations(arr, k) {
+        const combinations = [];
+        const helper = (start, current) => {
+            if (current.length === k) {
+                combinations.push([...current]);
+                return;
+            }
+            for (let i = start; i < arr.length; i++) {
+                current.push(arr[i]);
+                helper(i + 1, current);
+                current.pop();
+            }
+        };
+        helper(0, []);
+        return combinations;
+    }
+
+    function getLCM(arr) {
+        const gcd = (a, b) => {
+            if (b === 0) {
+                return a;
+            }
+            return gcd(b, a % b);
+        };
+        let lcm = arr[0];
+        for (let i = 1; i < arr.length; i++) {
+            const g = gcd(lcm, arr[i]);
+            lcm = (lcm * arr[i]) / g;
+        }
+        return lcm;
+    }
+}
+
+
+// another
+
+
+
 function calcLcm(a, b) {
   let p = a * b
 

From df99eef740e4a59ffbf9849921fb47d74e22768b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 May 2024 18:54:35 +0800
Subject: [PATCH 3055/3374] Create 2861-maximum-number-of-alloys.js

---
 2861-maximum-number-of-alloys.js | 46 ++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 2861-maximum-number-of-alloys.js

diff --git a/2861-maximum-number-of-alloys.js b/2861-maximum-number-of-alloys.js
new file mode 100644
index 00000000..d5c0891b
--- /dev/null
+++ b/2861-maximum-number-of-alloys.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @param {number} budget
+ * @param {number[][]} composition
+ * @param {number[]} stock
+ * @param {number[]} cost
+ * @return {number}
+ */
+var maxNumberOfAlloys = function (n, k, budget, composition, stock, cost) {
+  let low = 1,
+    high = 1e9
+  let ans = 0 // intialise the ans = 0;
+
+  while (low <= high) {
+    let mid = low + Math.floor((high - low) / 2)
+    if (isPossible(n, k, budget, composition, stock, cost, mid)) {
+      low = mid + 1
+      ans = mid // we can form the "mid" quantity of alloys from any of the compositions in the given "budget";
+    } else {
+      high = mid - 1
+    }
+  }
+
+  return ans
+}
+function isPossible(n, k, budget, composition, stock, costs, fixed_alloy) {
+  for (let i = 0; i < k; i++) {
+    let calBudget = 0
+    for (let j = 0; j < n; j++) {
+      // this much quantity of jth metal is required to form the "fixed_alloy";
+      let required = 1 * composition[i][j] * fixed_alloy
+      // subtracting the stocked portion of the jth metal;
+      required -= stock[j]
+      if (required > 0) {
+        // adding the cost for required quantity of jth metal to form the "fixed_alloy";
+        calBudget += 1 * required * costs[j]
+      }
+    }
+    // "fixed alloy can be formed with the ith machine";
+    if (calBudget <= 1 * budget) return true
+  }
+
+  // can't be formed with any of the machine;
+  return false
+}

From f3c93b029214b23afc5633ba389c6dd85a5adcf1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 May 2024 14:34:18 +0800
Subject: [PATCH 3056/3374] Create
 3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js

---
 ...-subsequence-with-non-adjacent-elements.js | 83 +++++++++++++++++++
 1 file changed, 83 insertions(+)
 create mode 100644 3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js

diff --git a/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
new file mode 100644
index 00000000..4b978766
--- /dev/null
+++ b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
@@ -0,0 +1,83 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var maximumSumSubsequence = function(nums, queries) {
+    const ninf = -0x1ffffffffffff;
+    const mod = 1000000007;
+    const n = nums.length;
+    let tree = new Tree(n);
+
+    for (let i = 0; i < n; ++i) {
+        tree.modify(1, 0, tree.nn, i, nums[i]);
+    }
+    for (let i = n; i < tree.nn; ++i) {
+        tree.modify(1, 0, tree.nn, i, 0);
+    }
+
+    let ans = 0;
+
+    for (let q of queries) {
+        let pos = q[0];
+        let x = q[1];
+        tree.modify(1, 0, tree.nn, pos, x);
+        ans += mod + tree.query() % mod; // [0, 2*mod)
+    }
+
+    ans %= mod;
+    return ans;
+};
+
+class Tree {
+    constructor(n) {
+        this.nn = n;
+        this.space = new Array(4 * n + 1).fill(null).map(() => ({ mx: [[0, -0x1ffffffffffff], [-0x1ffffffffffff, 0]] }));
+        for (; ;) {
+            let low_bit = this.nn & -this.nn;
+            if (low_bit == this.nn) {
+                break;
+            }
+            this.nn += low_bit;
+        }
+    }
+
+    modify(index, sl, sr, q, qv) {
+        let v = this.space[index];
+        if (sl + 1 == sr) {
+            v.mx = [
+                [0, -0x1ffffffffffff],
+                [-0x1ffffffffffff, qv]
+            ];
+            return;
+        }
+        let m = (sl + sr) >> 1;
+        if (q < m) {
+            this.modify(index * 2, sl, m, q, qv);
+        } else {
+            this.modify(index * 2 + 1, m, sr, q, qv);
+        }
+        let l = this.space[index * 2];
+        let r = this.space[index * 2 + 1];
+        for (let lb of [0, 1]) {
+            for (let rb of [0, 1]) {
+                let ans = -0x1ffffffffffff;
+                ans = Math.max(ans, l.mx[lb][1] + r.mx[0][rb]);
+                ans = Math.max(ans, l.mx[lb][0] + r.mx[1][rb]);
+                ans = Math.max(ans, l.mx[lb][0] + r.mx[0][rb]);
+                v.mx[lb][rb] = ans;
+            }
+        }
+    }
+
+    query() {
+        let v = this.space[1];
+        let ans = -0x1ffffffffffff;
+        for (let i = 0; i < 2; i++) {
+            for (let j = 0; j < 2; j++) {
+                ans = Math.max(ans, v.mx[i][j]);
+            }
+        }
+        return ans;
+    }
+}

From 869a79183eb89e1de221ada7966cdba7ea76df85 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 May 2024 14:34:56 +0800
Subject: [PATCH 3057/3374] Create 3164-find-the-number-of-good-pairs-ii.js

---
 3164-find-the-number-of-good-pairs-ii.js | 33 ++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3164-find-the-number-of-good-pairs-ii.js

diff --git a/3164-find-the-number-of-good-pairs-ii.js b/3164-find-the-number-of-good-pairs-ii.js
new file mode 100644
index 00000000..0ac0139c
--- /dev/null
+++ b/3164-find-the-number-of-good-pairs-ii.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfPairs = function(nums1, nums2, k) {
+  const freqMap = new Map()
+  for (const num of nums2) {
+    freqMap.set(num, (freqMap.get(num) || 0) + 1)
+  }
+
+  let res = 0
+
+  for (const num1 of nums1) {
+    let factor = 1
+    while (factor * factor <= num1) {
+      if (num1 % factor === 0) {
+        if (factor % k === 0 && freqMap.has(factor / k)) {
+          res += freqMap.get(factor / k)
+        }
+        if (factor !== num1 / factor) {
+          if ((num1 / factor) % k === 0 && freqMap.has(num1 / factor / k)) {
+            res += freqMap.get(num1 / factor / k)
+          }
+        }
+      }
+      factor++
+    }
+  }
+
+  return res 
+};

From b55eb2f585df952b05cce33174785b687936c80c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 May 2024 14:35:25 +0800
Subject: [PATCH 3058/3374] Create 3163-string-compression-iii.js

---
 3163-string-compression-iii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3163-string-compression-iii.js

diff --git a/3163-string-compression-iii.js b/3163-string-compression-iii.js
new file mode 100644
index 00000000..0b170072
--- /dev/null
+++ b/3163-string-compression-iii.js
@@ -0,0 +1,28 @@
+/**
+ * @param {string} word
+ * @return {string}
+ */
+var compressedString = function(word) {
+  let res = ''
+  let c = word[0]
+  let cnt = 0
+  for (let i = 0; i < word.length; i++) {
+    if (c === word[i]) {
+      cnt++
+      if (cnt === 9) {
+        res += `${cnt}${c}`
+        cnt = 0
+      }
+    } else {
+      if (cnt !== 0) {
+        res += `${cnt}${c}`
+      }
+      c = word[i]
+      cnt = 1
+    }
+  }
+  if (cnt !== 0) {
+    res += `${cnt}${c}`
+  }
+  return res
+};

From e5d46707d4865330dd47121bb76ef39b533e1f42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 May 2024 14:35:59 +0800
Subject: [PATCH 3059/3374] Create 3162-find-the-number-of-good-pairs-i.js

---
 3162-find-the-number-of-good-pairs-i.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 3162-find-the-number-of-good-pairs-i.js

diff --git a/3162-find-the-number-of-good-pairs-i.js b/3162-find-the-number-of-good-pairs-i.js
new file mode 100644
index 00000000..9741659c
--- /dev/null
+++ b/3162-find-the-number-of-good-pairs-i.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfPairs = function (nums1, nums2, k) {
+  let res = 0
+  for (let i = 0; i < nums1.length; i++) {
+    for (let j = 0; j < nums2.length; j++) {
+      if (nums1[i] % (nums2[j] * k) === 0) {
+        res++
+      }
+    }
+  }
+  return res
+}

From 29bc71cd0224ce092ec1fa2e189d1b4078f70c90 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 26 May 2024 21:52:51 +0800
Subject: [PATCH 3060/3374] Create
 3097-shortest-subarray-with-or-at-least-k-ii.js

---
 ...shortest-subarray-with-or-at-least-k-ii.js | 74 +++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 3097-shortest-subarray-with-or-at-least-k-ii.js

diff --git a/3097-shortest-subarray-with-or-at-least-k-ii.js b/3097-shortest-subarray-with-or-at-least-k-ii.js
new file mode 100644
index 00000000..c5c4f5fc
--- /dev/null
+++ b/3097-shortest-subarray-with-or-at-least-k-ii.js
@@ -0,0 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minimumSubarrayLength = function (nums, k) {
+  const a = nums
+  let n = a.length,
+    st = new SegmentTreeRORQ(a),
+    res = Number.MAX_SAFE_INTEGER
+  for (let i = 0; i < n; i++) {
+    let L = i,
+      R = n - 1,
+      len = Number.MAX_SAFE_INTEGER
+    while (L <= R) {
+      const mid = L + Math.floor((R - L) / 2)
+      let v = st.query(i, mid + 1)
+      if (v >= k) {
+        len = mid - i + 1
+        R = mid - 1
+      } else {
+        L = mid + 1
+      }
+    }
+    res = Math.min(res, len)
+  }
+  return res === Number.MAX_SAFE_INTEGER ? -1 : res
+}
+
+/////////////////////////// Template ///////////////////////////
+function SegmentTreeRORQ(A) {
+  let n = A.length,
+    h = Math.ceil(Math.log2(n)),
+    len = 2 * 2 ** h,
+    a = Array(len).fill(0)
+  initializeFromArray()
+  return { update, query, tree }
+  function initializeFromArray() {
+    for (let i = 0; i < n; i++) a[n + i] = A[i]
+    for (let i = n - 1; i >= 1; i--) pushup(i)
+  }
+  function update(pos, v) {
+    a[n + pos] = v
+    for (let i = parent(n + pos); i >= 1; i = parent(i)) pushup(i)
+  }
+  function pushup(i) {
+    a[i] = a[left(i)] | a[right(i)]
+  }
+  function query(l, r) {
+    // [L, R)
+    let or = 0
+    if (l >= r) return 0
+    l += n
+    r += n
+    for (; l < r; l = parent(l), r = parent(r)) {
+      if (l & 1) or |= a[l++]
+      if (r & 1) or |= a[--r]
+    }
+    return or
+  }
+  function parent(i) {
+    return i >> 1
+  }
+  function left(i) {
+    return 2 * i
+  }
+  function right(i) {
+    return 2 * i + 1
+  }
+  function tree() {
+    return a
+  }
+}
+////////////////////////////////////////////////////////////////

From a451c7d9de94c3db9cdcf9ecbfe7cedbb10c2d86 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 May 2024 12:14:38 +0800
Subject: [PATCH 3061/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 30 ++++++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index f597e751..921973e8 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const subarraysWithKDistinct = function(nums, k) {
+  return mostK(k) - mostK(k - 1)
+  
+  function mostK(k) {
+    const map = new Map(), n = nums.length
+    let i = 0, j = 0, res = 0
+    for(; j < n; j++) {
+      const e = nums[j]
+      map.set(e, (map.get(e) || 0) + 1)
+      while(map.size > k) {
+        const tmp = nums[i]
+        map.set(tmp, map.get(tmp) - 1)
+        if(map.get(tmp) === 0) map.delete(tmp)
+        i++
+      }
+      res += j - i + 1
+    }
+    
+    
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From ba8b453db22418fd4e2cb577d0cb4eaf9f5a70ca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 29 May 2024 17:30:25 +0800
Subject: [PATCH 3062/3374] Update
 3-longest-substring-without-repeating-characters.js

---
 ...-substring-without-repeating-characters.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/3-longest-substring-without-repeating-characters.js b/3-longest-substring-without-repeating-characters.js
index 78f0636b..d345eadf 100755
--- a/3-longest-substring-without-repeating-characters.js
+++ b/3-longest-substring-without-repeating-characters.js
@@ -1,3 +1,24 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstring = function(s) {
+  const n = s.length, hash = {}
+  let res = 0
+  let i = -1
+  for(j = 0;j < n; j++) {
+    const e = s[j]
+    if(hash[e] != null) i = Math.max(i, hash[e])
+    hash[e] = j
+    res = Math.max(res, j - i)
+  }
+  
+  return res
+};
+
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From bc990f615860d34c6d84ecb9cc279aeea8fcfa86 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Jun 2024 18:27:06 +0800
Subject: [PATCH 3063/3374] Update 2537-count-the-number-of-good-subarrays.js

---
 2537-count-the-number-of-good-subarrays.js | 24 ++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/2537-count-the-number-of-good-subarrays.js b/2537-count-the-number-of-good-subarrays.js
index 58df8f51..8eb898ce 100644
--- a/2537-count-the-number-of-good-subarrays.js
+++ b/2537-count-the-number-of-good-subarrays.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countGood = function(nums, k) {
+    let res = 0;
+    const count = new Map();
+    for(let i = 0, j = 0; j < nums.length; j++){
+        k -= count.get(nums[j]) || 0;
+        count.set(nums[j], (count.get(nums[j]) || 0)+1);
+
+        while(k <= 0){
+            count.set(nums[i],count.get(nums[i])-1);
+            k += count.get(nums[i]);
+            i++
+        }
+        res += i;
+    }
+    return res;
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 8f8bc5357601979c5ea57724fc5e397ad3316704 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jun 2024 17:04:03 +0800
Subject: [PATCH 3064/3374] Create
 3168-minimum-number-of-chairs-in-a-waiting-room.js

---
 ...imum-number-of-chairs-in-a-waiting-room.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3168-minimum-number-of-chairs-in-a-waiting-room.js

diff --git a/3168-minimum-number-of-chairs-in-a-waiting-room.js b/3168-minimum-number-of-chairs-in-a-waiting-room.js
new file mode 100644
index 00000000..8fa89084
--- /dev/null
+++ b/3168-minimum-number-of-chairs-in-a-waiting-room.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minimumChairs = function(s) {
+  let currentChairs = 0
+  let maxChairsNeeded = 0
+
+  for (let event of s) {
+    if (event === 'E') {
+      currentChairs++
+      maxChairsNeeded = Math.max(maxChairsNeeded, currentChairs)
+    } else if (event === 'L') {
+      currentChairs--
+    }
+  }
+
+  return maxChairsNeeded
+};

From df0956dc3c70c5df156a31ca5c6d9d28ef931cb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jun 2024 17:04:56 +0800
Subject: [PATCH 3065/3374] Create 3169-count-days-without-meetings.js

---
 3169-count-days-without-meetings.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 3169-count-days-without-meetings.js

diff --git a/3169-count-days-without-meetings.js b/3169-count-days-without-meetings.js
new file mode 100644
index 00000000..17da932d
--- /dev/null
+++ b/3169-count-days-without-meetings.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number} days
+ * @param {number[][]} meetings
+ * @return {number}
+ */
+var countDays = function (days, meetings) {
+  let uniqueMeetings = Array.from(new Set(meetings.map(JSON.stringify))).map(
+    JSON.parse,
+  )
+  uniqueMeetings.sort((a, b) => a[0] - b[0])
+  let mergedMeetings = [uniqueMeetings[0]]
+  for (let i = 1; i < uniqueMeetings.length; i++) {
+    if (uniqueMeetings[i][0] <= mergedMeetings[mergedMeetings.length - 1][1]) {
+      mergedMeetings[mergedMeetings.length - 1][1] = Math.max(
+        mergedMeetings[mergedMeetings.length - 1][1],
+        uniqueMeetings[i][1],
+      )
+    } else {
+      mergedMeetings.push(uniqueMeetings[i])
+    }
+  }
+  let totalWork = mergedMeetings.reduce(
+    (acc, meeting) => acc + (meeting[1] - meeting[0] + 1),
+    0,
+  )
+  return days - totalWork
+}

From 260b77e4e51f0a9f040a9b8897978627fc2f7844 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jun 2024 17:05:27 +0800
Subject: [PATCH 3066/3374] Create
 3170-lexicographically-minimum-string-after-removing-stars.js

---
 ...lly-minimum-string-after-removing-stars.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 3170-lexicographically-minimum-string-after-removing-stars.js

diff --git a/3170-lexicographically-minimum-string-after-removing-stars.js b/3170-lexicographically-minimum-string-after-removing-stars.js
new file mode 100644
index 00000000..e0bb7c0e
--- /dev/null
+++ b/3170-lexicographically-minimum-string-after-removing-stars.js
@@ -0,0 +1,36 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var clearStars = function (s) {
+  let starPos = []
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '*') {
+      starPos.push(i)
+    }
+  }
+  let toDel = new Set(starPos)
+  if (starPos.length === 0) {
+    return s
+  }
+  let chsPos = Array.from({ length: 26 }, () => [])
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '*') {
+      for (let j = 0; j < 26; j++) {
+        if (chsPos[j].length > 0) {
+          toDel.add(chsPos[j].pop())
+          break
+        }
+      }
+    } else {
+      chsPos[s.charCodeAt(i) - 'a'.charCodeAt(0)].push(i)
+    }
+  }
+  let t = ''
+  for (let i = 0; i < s.length; i++) {
+    if (!toDel.has(i)) {
+      t += s[i]
+    }
+  }
+  return t
+}

From d9cbc3a37c67cb4d8dcb5ebff644cee00b533d44 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Jun 2024 21:22:44 +0800
Subject: [PATCH 3067/3374] Create
 3130-find-all-possible-stable-binary-arrays-ii.js

---
 ...nd-all-possible-stable-binary-arrays-ii.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 3130-find-all-possible-stable-binary-arrays-ii.js

diff --git a/3130-find-all-possible-stable-binary-arrays-ii.js b/3130-find-all-possible-stable-binary-arrays-ii.js
new file mode 100644
index 00000000..8518dd04
--- /dev/null
+++ b/3130-find-all-possible-stable-binary-arrays-ii.js
@@ -0,0 +1,42 @@
+let MOD = 1000000007;
+
+function createDpArray() {
+  return Array.from({ length: 1001 }, () => new Uint32Array(1001));
+}
+
+let dp0 = createDpArray();
+let dp1 = createDpArray();
+
+/**
+ * @param {number} zero
+ * @param {number} one
+ * @param {number} limit
+ * @return {number}
+ */
+var numberOfStableArrays = function (zero, one, limit) {
+  ++limit;
+
+  for (let i = 0; i <= zero; ++i) {
+    for (let j = 0; j <= one; ++j) {
+      if (!i && !j) continue;
+      if (!i) {
+        dp1[i][j] = j < limit;
+        dp0[i][j] = 0;
+        continue;
+      }
+      if (!j) {
+        dp0[i][j] = i < limit;
+        dp1[i][j] = 0;
+        continue;
+      }
+
+      dp1[i][j] = (dp0[i][j - 1] + dp1[i][j - 1]) % MOD;
+      if (j >= limit) dp1[i][j] = (dp1[i][j] - dp0[i][j - limit] + MOD) % MOD;
+
+      dp0[i][j] = (dp0[i - 1][j] + dp1[i - 1][j]) % MOD;
+      if (i >= limit) dp0[i][j] = (dp0[i][j] - dp1[i - limit][j] + MOD) % MOD;
+    }
+  }
+
+  return (dp0[zero][one] + dp1[zero][one]) % MOD;
+};

From abea6ac0b17867d000e2e1ae3e488f6e651291cc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Jun 2024 13:43:07 +0800
Subject: [PATCH 3068/3374] Update 1473-paint-house-iii.js

---
 1473-paint-house-iii.js | 48 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1473-paint-house-iii.js b/1473-paint-house-iii.js
index d5fc1315..6ae1b718 100644
--- a/1473-paint-house-iii.js
+++ b/1473-paint-house-iii.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number[]} houses
+ * @param {number[][]} cost
+ * @param {number} m
+ * @param {number} n
+ * @param {number} target
+ * @return {number}
+ */
+const minCost = function (houses, cost, m, n, target) {
+  const dp = Array(m)
+    .fill(null)
+    .map(() =>
+      Array(target)
+        .fill(null)
+        .map(() => Array(n + 1).fill(0))
+    )
+
+  const res = dfs(0, target, -1)
+  return res === Infinity ? -1 : res
+
+  function dfs(i, t, p) {
+    if (i === m && t === 0) {
+      return 0
+    } else if (t < 0 || m - i < t || (i === m && t > 0)) {
+      return Infinity
+    } else if (p > -1 && dp[i][t][p]) {
+      return dp[i][t][p]
+    } else {
+      let res = Infinity
+      if (houses[i]) {
+        const tmp = houses[i] !== p ? 1 : 0
+        res = dfs(i + 1, t - tmp, houses[i])
+      } else {
+        for (let k = 1; k <= n; k++) {
+          const tmp = k !== p ? 1 : 0
+          res = Math.min(res, cost[i][k - 1] + dfs(i + 1, t - tmp, k))
+        }
+      }
+      if (p > -1) {
+        dp[i][t][p] = res
+      }
+      return res
+    }
+  }
+}
+
+// another
+
 /**
  * @param {number[]} houses
  * @param {number[][]} cost

From aedd57c6b3e66edd8fa0915ff77eb5512757ee02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Jun 2024 17:19:43 +0800
Subject: [PATCH 3069/3374] Create
 3122-minimum-number-of-operations-to-satisfy-conditions.js

---
 ...ber-of-operations-to-satisfy-conditions.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3122-minimum-number-of-operations-to-satisfy-conditions.js

diff --git a/3122-minimum-number-of-operations-to-satisfy-conditions.js b/3122-minimum-number-of-operations-to-satisfy-conditions.js
new file mode 100644
index 00000000..0d99473c
--- /dev/null
+++ b/3122-minimum-number-of-operations-to-satisfy-conditions.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minimumOperations = function(grid) {
+  const m = grid.length, n = grid[0].length
+  const dp = Array.from({ length: n }, () => Array(10).fill(Infinity))
+  for(let i = 0; i < n; i++) {
+    for(let v = 0; v < 10; v++) {
+      let cost = 0
+      
+      for(let j = 0; j < m; j++) {
+        if(grid[j][i] !== v) cost++
+      }
+      
+      if(i == 0) dp[i][v] = cost
+      else {
+        for(let p = 0; p < 10; p++) {
+          if(p === v) continue
+          dp[i][v] = Math.min(dp[i][v], dp[i - 1][p] + cost)
+        }
+      }
+    }
+  }
+  
+  let res = Infinity
+  
+  for(let v = 0; v < 10; v++) {
+    res = Math.min(res, dp[n - 1][v])
+  }
+  
+  return res
+};

From 6596039b5d2c670ea8801247a0fd7e2e37752d2b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 6 Jun 2024 13:26:25 +0800
Subject: [PATCH 3070/3374] Update 198-house-robber.js

---
 198-house-robber.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/198-house-robber.js b/198-house-robber.js
index 3ce91fff..17f82e5f 100644
--- a/198-house-robber.js
+++ b/198-house-robber.js
@@ -31,3 +31,18 @@ const rob = function(nums) {
   
   return dp[n]
 };
+
+// another
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const rob = function(nums) {
+  const n = nums.length
+  const dp = Array(n + 1).fill(0)
+  for(let i = 1; i <= n; i++) {
+    const e = nums[i - 1]
+    dp[i] = Math.max(dp[i - 1], (i === 1 ? 0 : dp[i - 2]) + e)
+  }
+  return dp[n]
+};

From 0803af6edb6f8b2a5967f26c211ea957ad27aed0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Jun 2024 18:36:04 +0800
Subject: [PATCH 3071/3374] Update 337-house-robber-iii.js

---
 337-house-robber-iii.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/337-house-robber-iii.js b/337-house-robber-iii.js
index a1417bf8..9ec5af05 100644
--- a/337-house-robber-iii.js
+++ b/337-house-robber-iii.js
@@ -1,3 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const rob = function(root) {
+  if(root == null) return 0
+  return Math.max(...dfs(root))
+  
+  function dfs(node) {
+    if(node == null) return [0, 0]
+    const l = dfs(node.left), r = dfs(node.right)
+    return [node.val + l[1] + r[1], Math.max(...l) + Math.max(...r)]
+  }
+};
+
+// another
+
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 431cecdc14d877ac8afc36f2c55070f774d60e6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jun 2024 19:45:05 +0800
Subject: [PATCH 3072/3374] Create
 3181-maximum-total-reward-using-operations-ii.js

---
 ...aximum-total-reward-using-operations-ii.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 3181-maximum-total-reward-using-operations-ii.js

diff --git a/3181-maximum-total-reward-using-operations-ii.js b/3181-maximum-total-reward-using-operations-ii.js
new file mode 100644
index 00000000..d9c941b4
--- /dev/null
+++ b/3181-maximum-total-reward-using-operations-ii.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} rewardValues
+ * @return {number}
+ */
+var maxTotalReward = function (rewardValues) {
+    rewardValues.sort((a, b) => a-b);
+    
+    let dp = new Uint8Array(rewardValues.at(-1)*2).fill(0);
+    let max = rewardValues.at(-1);
+
+    dp[0] = 1;
+
+    for(let i = 0; i < rewardValues.length; ++i) {
+        let val = rewardValues[i];
+        if(i > 0 && rewardValues[i-1] === val) { continue; }
+        let curMax = Math.min(val-1, (max-val)-1);
+
+
+        for(let j = 0; j <= curMax; ++j) {
+            if(dp[j] === 1) {
+                let found = j + val;
+                dp[found] = 1;
+            } else if(dp[j] === 2) {
+                //skip ahead
+                j += 100;
+            } else {
+                //determine how big the gap is
+                let runStart = j;
+                let target = runStart + 100;
+                while(j < curMax && j <= target && dp[j] === 0) {
+                    ++j;
+                }
+
+                if(j >= target) {
+                    //the gap is at least 100, mark it as skippable
+                    dp[runStart] = 2;
+                }
+                if(dp[j]) { --j; }
+            }
+        }
+
+        //we found max-1, since we're including max, no need to continue
+        if(dp[max-1]) {
+            break;
+        }
+
+    }
+    
+    for(let i = dp.length-1; i >= 0; --i) {
+        if(dp[i]) {
+            return i + max;
+        }
+    }
+
+    return -1;
+}

From 2501db9762cf44c73de8ccd77f7e8f61bad651a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jun 2024 19:45:38 +0800
Subject: [PATCH 3073/3374] Create
 3180-maximum-total-reward-using-operations-i.js

---
 ...maximum-total-reward-using-operations-i.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3180-maximum-total-reward-using-operations-i.js

diff --git a/3180-maximum-total-reward-using-operations-i.js b/3180-maximum-total-reward-using-operations-i.js
new file mode 100644
index 00000000..a89e6d64
--- /dev/null
+++ b/3180-maximum-total-reward-using-operations-i.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} rewardValues
+ * @return {number}
+ */
+var maxTotalReward = function (rewardValues) {
+  rewardValues.sort((a, b) => a - b)
+  const ts = new Set([0])
+  for (const item of rewardValues) {
+    const set = new Set()
+    for (const t of ts) {
+      if (t < item) {
+        set.add(t + item)
+      }
+    }
+    for (const value of set) {
+      ts.add(value)
+    }
+  }
+  return Math.max(...ts)
+}

From 9ff98e376afb4156079dd45b9da6694039287283 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jun 2024 19:46:08 +0800
Subject: [PATCH 3074/3374] Create 3179-find-the-n-th-value-after-k-seconds.js

---
 3179-find-the-n-th-value-after-k-seconds.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 3179-find-the-n-th-value-after-k-seconds.js

diff --git a/3179-find-the-n-th-value-after-k-seconds.js b/3179-find-the-n-th-value-after-k-seconds.js
new file mode 100644
index 00000000..09ae164a
--- /dev/null
+++ b/3179-find-the-n-th-value-after-k-seconds.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var valueAfterKSeconds = function(n, k) {
+  const mod = 1e9 + 7
+  let a = new Array(n).fill(1)
+
+  for (let i = 0; i < k; i++) {
+    for (let j = 1; j < n; j++) {
+      a[j] = (a[j] + a[j - 1]) % mod
+    }
+  }
+
+  return a[n - 1]
+};

From c825e86bcdda941c330d23bf491071c1ccdb7c02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Jun 2024 19:46:40 +0800
Subject: [PATCH 3075/3374] Create
 3178-find-the-child-who-has-the-ball-after-k-seconds.js

---
 ...find-the-child-who-has-the-ball-after-k-seconds.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 3178-find-the-child-who-has-the-ball-after-k-seconds.js

diff --git a/3178-find-the-child-who-has-the-ball-after-k-seconds.js b/3178-find-the-child-who-has-the-ball-after-k-seconds.js
new file mode 100644
index 00000000..18916378
--- /dev/null
+++ b/3178-find-the-child-who-has-the-ball-after-k-seconds.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var numberOfChild = function(n, k) {
+  let l = 2 * (n-1)
+  let r = k % l
+  if (r < n) return r
+  else return l - r
+};

From ba97c288353faf199ee892cff935eb45b29f0eb6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Jun 2024 12:06:57 +0800
Subject: [PATCH 3076/3374] Update
 3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js

---
 ...-subsequence-with-non-adjacent-elements.js | 137 +++++++++---------
 1 file changed, 71 insertions(+), 66 deletions(-)

diff --git a/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
index 4b978766..e51d1067 100644
--- a/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
+++ b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
@@ -3,81 +3,86 @@
  * @param {number[][]} queries
  * @return {number}
  */
-var maximumSumSubsequence = function(nums, queries) {
-    const ninf = -0x1ffffffffffff;
-    const mod = 1000000007;
-    const n = nums.length;
-    let tree = new Tree(n);
+var maximumSumSubsequence = function (nums, queries) {
+  const ninf = -Infinity
+  const mod = 1e9 + 7
+  const n = nums.length
+  let tree = new Tree(n)
 
-    for (let i = 0; i < n; ++i) {
-        tree.modify(1, 0, tree.nn, i, nums[i]);
-    }
-    for (let i = n; i < tree.nn; ++i) {
-        tree.modify(1, 0, tree.nn, i, 0);
-    }
+  for (let i = 0; i < n; ++i) {
+    tree.modify(1, 0, tree.nn, i, nums[i])
+  }
+  for (let i = n; i < tree.nn; ++i) {
+    tree.modify(1, 0, tree.nn, i, 0)
+  }
 
-    let ans = 0;
+  let res = 0
 
-    for (let q of queries) {
-        let pos = q[0];
-        let x = q[1];
-        tree.modify(1, 0, tree.nn, pos, x);
-        ans += mod + tree.query() % mod; // [0, 2*mod)
-    }
+  for (let q of queries) {
+    let pos = q[0]
+    let x = q[1]
+    tree.modify(1, 0, tree.nn, pos, x)
+    res += mod + (tree.query() % mod) // [0, 2*mod)
+  }
 
-    ans %= mod;
-    return ans;
-};
+  res %= mod
+  return res
+}
 
 class Tree {
-    constructor(n) {
-        this.nn = n;
-        this.space = new Array(4 * n + 1).fill(null).map(() => ({ mx: [[0, -0x1ffffffffffff], [-0x1ffffffffffff, 0]] }));
-        for (; ;) {
-            let low_bit = this.nn & -this.nn;
-            if (low_bit == this.nn) {
-                break;
-            }
-            this.nn += low_bit;
-        }
+  constructor(n) {
+    this.nn = n
+    this.space = new Array(4 * n + 1).fill(null).map(() => ({
+      mx: [
+        [0, -0x1ffffffffffff],
+        [-0x1ffffffffffff, 0],
+      ],
+    }))
+    for (;;) {
+      let low_bit = this.nn & -this.nn
+      if (low_bit == this.nn) {
+        break
+      }
+      this.nn += low_bit
     }
+  }
 
-    modify(index, sl, sr, q, qv) {
-        let v = this.space[index];
-        if (sl + 1 == sr) {
-            v.mx = [
-                [0, -0x1ffffffffffff],
-                [-0x1ffffffffffff, qv]
-            ];
-            return;
-        }
-        let m = (sl + sr) >> 1;
-        if (q < m) {
-            this.modify(index * 2, sl, m, q, qv);
-        } else {
-            this.modify(index * 2 + 1, m, sr, q, qv);
-        }
-        let l = this.space[index * 2];
-        let r = this.space[index * 2 + 1];
-        for (let lb of [0, 1]) {
-            for (let rb of [0, 1]) {
-                let ans = -0x1ffffffffffff;
-                ans = Math.max(ans, l.mx[lb][1] + r.mx[0][rb]);
-                ans = Math.max(ans, l.mx[lb][0] + r.mx[1][rb]);
-                ans = Math.max(ans, l.mx[lb][0] + r.mx[0][rb]);
-                v.mx[lb][rb] = ans;
-            }
-        }
+  modify(index, sl, sr, q, qv) {
+    let v = this.space[index]
+    if (sl + 1 == sr) {
+      v.mx = [
+        [0, -0x1ffffffffffff],
+        [-0x1ffffffffffff, qv],
+      ]
+      return
+    }
+    let m = (sl + sr) >> 1
+    if (q < m) {
+      this.modify(index * 2, sl, m, q, qv)
+    } else {
+      this.modify(index * 2 + 1, m, sr, q, qv)
+    }
+    let l = this.space[index * 2]
+    let r = this.space[index * 2 + 1]
+    for (let lb of [0, 1]) {
+      for (let rb of [0, 1]) {
+        let ans = -0x1ffffffffffff
+        ans = Math.max(ans, l.mx[lb][1] + r.mx[0][rb])
+        ans = Math.max(ans, l.mx[lb][0] + r.mx[1][rb])
+        ans = Math.max(ans, l.mx[lb][0] + r.mx[0][rb])
+        v.mx[lb][rb] = ans
+      }
     }
+  }
 
-    query() {
-        let v = this.space[1];
-        let ans = -0x1ffffffffffff;
-        for (let i = 0; i < 2; i++) {
-            for (let j = 0; j < 2; j++) {
-                ans = Math.max(ans, v.mx[i][j]);
-            }
-        }
-        return ans;
+  query() {
+    let v = this.space[1]
+    let ans = -0x1ffffffffffff
+    for (let i = 0; i < 2; i++) {
+      for (let j = 0; j < 2; j++) {
+        ans = Math.max(ans, v.mx[i][j])
+      }
     }
+    return ans
+  }
 }

From 54699c69f6926668f1976a11b8abf68e81575921 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Jun 2024 13:07:17 +0800
Subject: [PATCH 3077/3374] Update
 3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js

---
 ...-subsequence-with-non-adjacent-elements.js | 93 +++++++++++++++++++
 1 file changed, 93 insertions(+)

diff --git a/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
index e51d1067..64433f77 100644
--- a/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
+++ b/3165-maximum-sum-of-subsequence-with-non-adjacent-elements.js
@@ -1,3 +1,96 @@
+const M = 1e9 + 7
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var maximumSumSubsequence = function (nums, queries) {
+  const n = nums.length
+  const root = new SegTreeNode(0, n - 1, nums)
+  let res = 0
+  for (const q of queries) {
+    root.updateRange(q[0], q[1])
+    res += Math.max(root.info00, root.info01, root.info10, root.info11)
+    res %= M
+  }
+  return res
+}
+
+class SegTreeNode {
+  constructor(a, b, vals) {
+    this.left = null
+    this.right = null
+    this.start = a
+    this.end = b
+    if (a === b) {
+      this.info11 = vals[a]
+      this.info01 = -1e18
+      this.info10 = -1e18
+      this.info00 = 0
+      return
+    }
+    const mid = Math.floor((a + b) / 2)
+    this.left = new SegTreeNode(a, mid, vals)
+    this.right = new SegTreeNode(mid + 1, b, vals)
+    this.info11 = Math.max(
+      this.left.info10 + this.right.info01,
+      this.left.info11 + this.right.info01,
+      this.left.info10 + this.right.info11,
+    )
+    this.info00 = Math.max(
+      this.left.info00 + this.right.info00,
+      this.left.info01 + this.right.info00,
+      this.left.info00 + this.right.info10,
+    )
+    this.info10 = Math.max(
+      this.left.info10 + this.right.info00,
+      this.left.info10 + this.right.info10,
+      this.left.info11 + this.right.info00,
+    )
+    this.info01 = Math.max(
+      this.left.info00 + this.right.info01,
+      this.left.info01 + this.right.info01,
+      this.left.info00 + this.right.info11,
+    )
+  }
+
+  updateRange(a, val) {
+    if (a < this.start || a > this.end) {
+      return
+    }
+    if (this.start === this.end) {
+      this.info00 = 0
+      this.info11 = val
+      return
+    }
+    this.left.updateRange(a, val)
+    this.right.updateRange(a, val)
+    this.info11 = Math.max(
+      this.left.info10 + this.right.info01,
+      this.left.info11 + this.right.info01,
+      this.left.info10 + this.right.info11,
+    )
+    this.info00 = Math.max(
+      this.left.info00 + this.right.info00,
+      this.left.info01 + this.right.info00,
+      this.left.info00 + this.right.info10,
+    )
+    this.info10 = Math.max(
+      this.left.info10 + this.right.info00,
+      this.left.info10 + this.right.info10,
+      this.left.info11 + this.right.info00,
+    )
+    this.info01 = Math.max(
+      this.left.info00 + this.right.info01,
+      this.left.info01 + this.right.info01,
+      this.left.info00 + this.right.info11,
+    )
+  }
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number[][]} queries

From a972890178aedcdae7352df6fe02936b3451d30e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jun 2024 15:02:16 +0800
Subject: [PATCH 3078/3374] Create 3187-peaks-in-array.js

---
 3187-peaks-in-array.js | 86 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)
 create mode 100644 3187-peaks-in-array.js

diff --git a/3187-peaks-in-array.js b/3187-peaks-in-array.js
new file mode 100644
index 00000000..21184be7
--- /dev/null
+++ b/3187-peaks-in-array.js
@@ -0,0 +1,86 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var countOfPeaks = function (nums, queries) {
+  const n = nums.length
+  const bit = new BIT()
+  bit.init(n)
+  for (let i = 0; i < n; i++) {
+    if (isPeak(nums, i)) {
+      bit.add(i + 1, 1)
+    }
+  }
+  const res = []
+  for (const q of queries) {
+    if (q[0] === 1) {
+      const [l, r] = [q[1], q[2]]
+      let cnt = bit.query(r + 1) - bit.query(l)
+      if (isPeak(nums, l)) {
+        cnt--
+      }
+      if (isPeak(nums, r)) {
+        cnt--
+      }
+      if (isPeak(nums, l) && l === r) {
+        cnt++
+      }
+      res.push(cnt)
+    } else {
+      const [idx, val] = [q[1], q[2]]
+      if (isPeak(nums, idx)) {
+        bit.add(idx + 1, -1)
+      }
+      if (idx > 0 && isPeak(nums, idx - 1)) {
+        bit.add(idx, -1)
+      }
+      if (idx < n - 1 && isPeak(nums, idx + 1)) {
+        bit.add(idx + 2, -1)
+      }
+      nums[idx] = val
+      if (isPeak(nums, idx)) {
+        bit.add(idx + 1, 1)
+      }
+      if (idx > 0 && isPeak(nums, idx - 1)) {
+        bit.add(idx, 1)
+      }
+      if (idx < n - 1 && isPeak(nums, idx + 1)) {
+        bit.add(idx + 2, 1)
+      }
+    }
+  }
+  return res
+}
+function isPeak(nums, i) {
+  if (i === 0 || i === nums.length - 1) {
+    return false
+  }
+  return nums[i] > nums[i - 1] && nums[i] > nums[i + 1]
+}
+
+class BIT {
+  constructor() {
+    this.tree = []
+  }
+
+  init(n) {
+    this.tree = new Array(n + 1).fill(0)
+  }
+
+  add(i, val) {
+    while (i < this.tree.length) {
+      this.tree[i] += val
+      i += i & -i
+    }
+  }
+
+  query(i) {
+    let sum = 0
+    while (i > 0) {
+      sum += this.tree[i]
+      i -= i & -i
+    }
+    return sum
+  }
+}

From 648628c0185ce50a5385c02a152fe2185df31e35 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jun 2024 15:02:45 +0800
Subject: [PATCH 3079/3374] Create
 3186-maximum-total-damage-with-spell-casting.js

---
 ...maximum-total-damage-with-spell-casting.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3186-maximum-total-damage-with-spell-casting.js

diff --git a/3186-maximum-total-damage-with-spell-casting.js b/3186-maximum-total-damage-with-spell-casting.js
new file mode 100644
index 00000000..d6de86f5
--- /dev/null
+++ b/3186-maximum-total-damage-with-spell-casting.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} power
+ * @return {number}
+ */
+var maximumTotalDamage = function (power) {
+  power.sort((a, b) => a - b)
+  const freqMap = new Map()
+  for (const p of power) {
+    freqMap.set(p, (freqMap.get(p) || 0) + 1)
+  }
+  const uniqueDamages = Array.from(freqMap.keys()).sort((a, b) => a - b)
+  const n = uniqueDamages.length
+  const dp = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    const damage = uniqueDamages[i]
+    const totalDamage = damage * freqMap.get(damage)
+
+    dp[i + 1] = Math.max(dp[i + 1], dp[i])
+
+    let j = i - 1
+    while (j >= 0 && uniqueDamages[j] >= damage - 2) {
+      j--
+    }
+    dp[i + 1] = Math.max(dp[i + 1], (j >= 0 ? dp[j + 1] : 0) + totalDamage)
+  }
+
+  return dp[n]
+}

From a64a20af78bdf3d9ef9eb5f0b1ce38e97fb736de Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jun 2024 15:03:17 +0800
Subject: [PATCH 3080/3374] Create
 3185-count-pairs-that-form-a-complete-day-ii.js

---
 ...count-pairs-that-form-a-complete-day-ii.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3185-count-pairs-that-form-a-complete-day-ii.js

diff --git a/3185-count-pairs-that-form-a-complete-day-ii.js b/3185-count-pairs-that-form-a-complete-day-ii.js
new file mode 100644
index 00000000..5ceff702
--- /dev/null
+++ b/3185-count-pairs-that-form-a-complete-day-ii.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} hours
+ * @return {number}
+ */
+var countCompleteDayPairs = function(hours) {
+  const map = new Map()
+  const n = hours.length
+  let res = 0
+  for(let i = 0;  i < n; i++) {
+    const e = hours[i]
+    const remain = e % 24
+    if(remain === 0 || remain === 24) res += (map.get(24) || 0) + (map.get(0) || 0)
+    else res += (map.get(24 - remain) || 0)
+    // console.log('res', res)
+    map.set(remain, (map.get(remain) || 0) + 1)
+  }
+  // console.log(map)
+  
+  return res
+};

From e8c54c1c5dae796f8fc358490d6cdc0c313b009f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Jun 2024 15:03:42 +0800
Subject: [PATCH 3081/3374] Create
 3184-count-pairs-that-form-a-complete-day-i.js

---
 3184-count-pairs-that-form-a-complete-day-i.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 3184-count-pairs-that-form-a-complete-day-i.js

diff --git a/3184-count-pairs-that-form-a-complete-day-i.js b/3184-count-pairs-that-form-a-complete-day-i.js
new file mode 100644
index 00000000..01f56b42
--- /dev/null
+++ b/3184-count-pairs-that-form-a-complete-day-i.js
@@ -0,0 +1,14 @@
+/**
+ * @param {number[]} hours
+ * @return {number}
+ */
+var countCompleteDayPairs = function(hours) {
+  let res = 0
+  const n = hours.length
+  for(let i = 0; i < n; i++) {
+    for(let j = i + 1; j < n; j++) {
+      if((hours[i] + hours[j]) % 24 === 0) res++
+    }
+  }
+  return res
+};

From c8ec9701acc0e0dd89ce0e73560697550ede2aa8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Jun 2024 12:41:53 +0800
Subject: [PATCH 3082/3374] Update 218-the-skyline-problem.js

---
 218-the-skyline-problem.js | 43 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/218-the-skyline-problem.js b/218-the-skyline-problem.js
index 0d7016ee..39846b9c 100644
--- a/218-the-skyline-problem.js
+++ b/218-the-skyline-problem.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[][]} buildings
+ * @return {number[][]}
+ */
+var getSkyline = function(buildings) {
+    const edgeSet = new Set();
+    for (let i = 0; i < buildings.length; i++) {
+        const [from, to] = buildings[i];
+        edgeSet.add(from);
+        edgeSet.add(to);
+    }
+    const positions = [...edgeSet];
+    positions.sort((a, b) => a - b);
+
+    const pq = new PriorityQueue({compare: (a, b) => b[2] - a[2]});
+
+    const result = [];
+
+    let j = 0;
+    for (let i = 0; i < positions.length; i++) {
+        const position = positions[i];
+
+        for (j; j < buildings.length && buildings[j][0] <= position; j++) {
+            pq.enqueue(buildings[j]);
+        }
+
+        while (!pq.isEmpty() && pq.front()[1] <= position) {
+            pq.dequeue();
+        }
+
+        let maxHeight = pq.front()?.[2] ?? 0;
+
+        if (!result.length || result.at(-1)[1] !== maxHeight) {
+            result.push([position, maxHeight]);
+        }
+    }
+
+    return result;
+};
+
+// another
+
+
 /**
  * @param {number[][]} buildings
  * @return {number[][]}

From e436aa03991ffc281ef0c07b09ae94de4c1feff1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jun 2024 20:33:39 +0800
Subject: [PATCH 3083/3374] Create
 3194-minimum-average-of-smallest-and-largest-elements.js

---
 ...m-average-of-smallest-and-largest-elements.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3194-minimum-average-of-smallest-and-largest-elements.js

diff --git a/3194-minimum-average-of-smallest-and-largest-elements.js b/3194-minimum-average-of-smallest-and-largest-elements.js
new file mode 100644
index 00000000..e8182c15
--- /dev/null
+++ b/3194-minimum-average-of-smallest-and-largest-elements.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumAverage = function(nums) {
+  nums.sort((a, b) => a - b)
+  const arr = []
+  let i = 0, j = nums.length - 1
+  while(i < j) {
+    let a = nums[i], b = nums[j]
+    arr.push((a+b)/2)
+    i++
+    j--
+  }
+  return Math.min(...arr)
+};

From b0c43519273957f1f25e18ef27876eaa1ae0bfda Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jun 2024 20:34:08 +0800
Subject: [PATCH 3084/3374] Create
 3195-find-the-minimum-area-to-cover-all-ones-i.js

---
 ...nd-the-minimum-area-to-cover-all-ones-i.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3195-find-the-minimum-area-to-cover-all-ones-i.js

diff --git a/3195-find-the-minimum-area-to-cover-all-ones-i.js b/3195-find-the-minimum-area-to-cover-all-ones-i.js
new file mode 100644
index 00000000..7b0e8296
--- /dev/null
+++ b/3195-find-the-minimum-area-to-cover-all-ones-i.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumArea = function(grid) {
+  const m = grid.length, n = grid[0].length
+  let rmax = -1, rmin = Infinity, cmax = -1, cmin = Infinity
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+      if(grid[i][j] === 1) {
+        rmin = Math.min(rmin, i)
+        cmin = Math.min(cmin, j)
+        rmax = Math.max(rmax, i)
+        cmax = Math.max(cmax, j)
+      }
+    }
+  }
+  return (rmax - rmin + 1) * (cmax - cmin + 1)
+};

From 4acddd32420cdd6d35a507ad2c36242d22ea13c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jun 2024 20:34:42 +0800
Subject: [PATCH 3085/3374] Create
 3196-maximize-total-cost-of-alternating-subarrays.js

---
 ...ize-total-cost-of-alternating-subarrays.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 3196-maximize-total-cost-of-alternating-subarrays.js

diff --git a/3196-maximize-total-cost-of-alternating-subarrays.js b/3196-maximize-total-cost-of-alternating-subarrays.js
new file mode 100644
index 00000000..d6e45781
--- /dev/null
+++ b/3196-maximize-total-cost-of-alternating-subarrays.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumTotalCost = function (nums) {
+  const n = nums.length
+  const cache = new Map()
+
+  return dfs(n - 1)
+  function dfs(i) {
+    if (cache.has(i)) return cache.get(i)
+    if (i === 0) {
+      return nums[0]
+    } else if (i === 1) {
+      return nums[0] + Math.abs(nums[1])
+    } else {
+      const result = Math.max(
+        dfs(i - 1) + nums[i],
+        dfs(i - 2) + nums[i - 1] - nums[i],
+      )
+      cache.set(i, result)
+      return result
+    }
+  }
+}

From 598755a129ee6c84b94ae0c124169192af818bc6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 23 Jun 2024 20:35:23 +0800
Subject: [PATCH 3086/3374] Create
 3198-find-the-minimum-area-to-cover-all-ones-ii.js

---
 ...d-the-minimum-area-to-cover-all-ones-ii.js | 117 ++++++++++++++++++
 1 file changed, 117 insertions(+)
 create mode 100644 3198-find-the-minimum-area-to-cover-all-ones-ii.js

diff --git a/3198-find-the-minimum-area-to-cover-all-ones-ii.js b/3198-find-the-minimum-area-to-cover-all-ones-ii.js
new file mode 100644
index 00000000..5bdd1380
--- /dev/null
+++ b/3198-find-the-minimum-area-to-cover-all-ones-ii.js
@@ -0,0 +1,117 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumSum = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+  let ans = n * m
+
+  for (let i = 0; i < n - 1; i++) {
+    const grid1 = grid.slice(0, i + 1).map((row) => row.slice())
+    const ret1 = minimumArea(grid1)
+
+    for (let j = 0; j < m - 1; j++) {
+      const grid2 = grid.slice(i + 1).map((row) => row.slice(0, j + 1))
+      const grid3 = grid.slice(i + 1).map((row) => row.slice(j + 1))
+      // console.log(grid1, grid2, grid3);
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  for (let i = 0; i < n - 1; i++) {
+    const grid1 = grid.slice(i + 1).map((row) => row.slice())
+    const ret1 = minimumArea(grid1)
+
+    for (let j = 0; j < m - 1; j++) {
+      const grid2 = grid.slice(0, i + 1).map((row) => row.slice(0, j + 1))
+      const grid3 = grid.slice(0, i + 1).map((row) => row.slice(j + 1))
+      // console.log(grid1, grid2, grid3);
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  for (let j = 0; j < m - 1; j++) {
+    const grid1 = grid.map((row) => row.slice(0, j + 1))
+    const ret1 = minimumArea(grid1)
+
+    for (let i = 0; i < n - 1; i++) {
+      const grid2 = grid.slice(0, i + 1).map((row) => row.slice(j + 1))
+      const grid3 = grid.slice(i + 1).map((row) => row.slice(j + 1))
+      // console.log(grid1, grid2, grid3);
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  for (let j = 0; j < m - 1; j++) {
+    const grid1 = grid.map((row) => row.slice(j + 1))
+    const ret1 = minimumArea(grid1)
+
+    for (let i = 0; i < n - 1; i++) {
+      const grid2 = grid.slice(0, i + 1).map((row) => row.slice(0, j + 1))
+      const grid3 = grid.slice(i + 1).map((row) => row.slice(0, j + 1))
+      // console.log(grid1, grid2, grid3);
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  for (let i = 0; i < n - 1; i++) {
+    const grid1 = grid.slice(0, i + 1).map((row) => row.slice())
+    const ret1 = minimumArea(grid1)
+
+    for (let k = i + 1; k < n - 1; k++) {
+      const grid2 = grid.slice(i + 1, k + 1).map((row) => row.slice())
+      const grid3 = grid.slice(k + 1).map((row) => row.slice())
+
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  for (let j = 0; j < m - 1; j++) {
+    const grid1 = grid.map((row) => row.slice(0, j + 1))
+    const ret1 = minimumArea(grid1)
+
+    for (let k = j + 1; k < m - 1; k++) {
+      const grid2 = grid.map((row) => row.slice(j + 1, k + 1))
+      const grid3 = grid.map((row) => row.slice(k + 1))
+      const ret2 = minimumArea(grid2)
+      const ret3 = minimumArea(grid3)
+      ans = Math.min(ans, ret1 + ret2 + ret3)
+    }
+  }
+
+  return ans
+
+  function minimumArea(grid) {
+    const n = grid.length
+    const m = grid[0].length
+    let x1 = n
+    let x2 = 0
+    let y1 = m
+    let y2 = 0
+
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < m; j++) {
+        if (grid[i][j] === 1) {
+          x1 = Math.min(x1, i)
+          x2 = Math.max(x2, i)
+          y1 = Math.min(y1, j)
+          y2 = Math.max(y2, j)
+        }
+      }
+    }
+
+    const ret = (x2 - x1 + 1) * (y2 - y1 + 1)
+    return ret
+  }
+}

From ff490a66c9d4ee4704d3d25abde5c0e63ebe1af6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 25 Jun 2024 12:16:07 +0800
Subject: [PATCH 3087/3374] Create 3161-block-placement-queries.js

---
 3161-block-placement-queries.js | 89 +++++++++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)
 create mode 100644 3161-block-placement-queries.js

diff --git a/3161-block-placement-queries.js b/3161-block-placement-queries.js
new file mode 100644
index 00000000..e33d5d7c
--- /dev/null
+++ b/3161-block-placement-queries.js
@@ -0,0 +1,89 @@
+/**
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+var getResults = function(queries) {
+    const max = queries.reduce((max, [_, x, sz = 0]) => Math.max(max, x, sz), 0) + 1;
+    const segmentTree = new SegmentTree(max)
+    const results = [];
+    for (const [type, x, sz = 0] of queries) {
+        if (type === 1) {
+            segmentTree.add(x);
+        } else {
+            results.push(segmentTree.query(x)[2] >= sz)
+        }
+    }
+    return results;
+};
+
+class SegmentTree {
+    n = 0
+    minBlock = []
+    maxBlock = []
+    max = []
+
+    constructor(n) {
+        this.n = n
+        this.minBlock = new Array(2 * 2 ** Math.ceil(Math.log2(n))).fill(0);
+        this.maxBlock = new Array(2 * 2 ** Math.ceil(Math.log2(n))).fill(0);
+        this.max = new Array(2 * 2 ** Math.ceil(Math.log2(n))).fill(1);
+        this.populate()
+    }
+
+    populate(idx = 0, l = 0, r = this.n - 1) {
+        if (l === r) return;
+        const mid = l + r >> 1;
+        this.populate(idx * 2 + 1, l, mid);
+        this.populate(idx * 2 + 2, mid + 1, r);
+        this.max[idx] = r - l + 1;
+    }
+
+    update(idx, l, r) {
+        const left = idx * 2 + 1;
+        const leftSplit = this.maxBlock[left] > 0;
+        const right = idx * 2 + 2;
+        const rightSplit = this.minBlock[right] > 0;
+
+        if (leftSplit && rightSplit) {
+            this.minBlock[idx] = this.minBlock[left];
+            this.maxBlock[idx] = this.maxBlock[right];
+            this.max[idx] = Math.max(this.max[left], this.max[right], this.minBlock[right] - this.maxBlock[left]);
+        } else if (leftSplit) {
+            this.minBlock[idx] = this.minBlock[left];
+            this.maxBlock[idx] = this.maxBlock[left];
+            this.max[idx] = r - this.maxBlock[left] + 1;
+        } else if (rightSplit) {
+            this.minBlock[idx] = this.minBlock[right];
+            this.maxBlock[idx] = this.maxBlock[right];
+            this.max[idx] = this.minBlock[right] - l;
+        }
+    }
+
+
+    add(x, idx = 0, l = 0, r = this.n - 1) {
+        if (l === r) {
+            this.minBlock[idx] = x;
+            this.maxBlock[idx] = x;
+            return;
+        }
+        const mid = l + r >> 1;
+        if (x <= mid + 1) this.add(x, idx * 2 + 1, l, mid);
+        else this.add(x, idx * 2 + 2, mid + 1, r);
+        this.update(idx, l, r)
+    }
+
+    query(x, idx = 0, l = 0, r = this.n - 1) {
+        if (x <= l) return [0, 0, 0];
+        if (x > r) return [this.minBlock[idx], this.maxBlock[idx], this.max[idx]];
+        const mid = l + r >> 1;
+        if (x <= mid + 1) return this.query(x, idx * 2 + 1, l, mid);
+        const [lMinBlock, lMaxBlock, lMax] = this.query(x, idx * 2 + 1, l, mid);
+        const [rMinBlock, rMaxBlock, rMax] = this.query(x, idx * 2 + 2, mid + 1, r);
+        const leftEnd = lMaxBlock || l;
+        return [
+            lMinBlock || rMinBlock,
+            rMaxBlock || lMaxBlock,
+            Math.max(lMax, rMax, (rMinBlock ? Math.min(rMinBlock, x) : x) - leftEnd)
+        ]
+    }
+}

From 90a75e8b320bc5427b6fc4c305011e2c387ccf6c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Jun 2024 17:59:05 +0800
Subject: [PATCH 3088/3374] Create
 3171-find-subarray-with-bitwise-or-closest-to-k.js

---
 ...d-subarray-with-bitwise-or-closest-to-k.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3171-find-subarray-with-bitwise-or-closest-to-k.js

diff --git a/3171-find-subarray-with-bitwise-or-closest-to-k.js b/3171-find-subarray-with-bitwise-or-closest-to-k.js
new file mode 100644
index 00000000..2aba1d29
--- /dev/null
+++ b/3171-find-subarray-with-bitwise-or-closest-to-k.js
@@ -0,0 +1,33 @@
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minimumDifference = function(nums, k) {
+  const bits = new Array(32).fill(0);
+  let res = Number.MAX_SAFE_INTEGER, n = nums.length;
+  let left = 0, right = 0;
+  while (right < n) {
+      let curr = update(nums[right], 1);
+      res = Math.min(res, Math.abs(curr - k));
+      while (left < right && curr > k) {
+          curr = update(nums[left++], -1);
+          res = Math.min(res, Math.abs(curr - k));
+      }
+      right++;
+  }
+  return res;
+  function update(num, val) {
+      let res = 0;
+      for (let i = 0; i < 32; i++) {
+          if ((num >> i) & 1) {
+              bits[i] += val;
+          }
+          if (bits[i]) res |= 1 << i;
+      }
+      return res;
+    }
+};
+
+

From b039bd5dddd5affac5ff226c647bbaca291c8e1f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Jun 2024 12:05:37 +0800
Subject: [PATCH 3089/3374] Update 3187-peaks-in-array.js

---
 3187-peaks-in-array.js | 128 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)

diff --git a/3187-peaks-in-array.js b/3187-peaks-in-array.js
index 21184be7..44d7bf11 100644
--- a/3187-peaks-in-array.js
+++ b/3187-peaks-in-array.js
@@ -84,3 +84,131 @@ class BIT {
     return sum
   }
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var countOfPeaks = function (nums, queries) {
+    const n = nums.length
+    const peak = new Array(n).fill(0)
+
+    for (let i = 1; i < n - 1; ++i) {
+      if (nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) peak[i] = 1
+    }
+
+    const ans = []
+    const st = new SegmentTree(n)
+    st.build(0, 0, n - 1, peak)
+
+    for (let i = 0; i < queries.length; ++i) {
+      const q = queries
+      const type = q[i][0]
+
+      if (type === 1) {
+        const l = q[i][1]
+        const r = q[i][2]
+
+        if (l === r) {
+          ans.push(0)
+          continue
+        }
+
+        let red = 0
+
+        if (peak[l] === 1) ++red
+
+        if (peak[r] === 1) ++red
+
+        const res = st.query(0, 0, n - 1, l, r)
+        ans.push(res - red)
+      } else if (type === 2) {
+        const p = q[i][1]
+        const x = q[i][2]
+
+        nums[p] = x
+
+        if (p - 1 >= 0 && p + 1 < n) {
+          if (nums[p] > nums[p - 1] && nums[p] > nums[p + 1]) {
+            st.update(0, 0, n - 1, p, 1)
+            peak[p] = 1
+          } else {
+            st.update(0, 0, n - 1, p, 0)
+            peak[p] = 0
+          }
+        }
+
+        if (p - 2 >= 0 && p < n) {
+          if (nums[p - 1] > nums[p - 2] && nums[p - 1] > nums[p]) {
+            st.update(0, 0, n - 1, p - 1, 1)
+            peak[p - 1] = 1
+          } else {
+            st.update(0, 0, n - 1, p - 1, 0)
+            peak[p - 1] = 0
+          }
+        }
+
+        if (p >= 0 && p + 2 < n) {
+          if (nums[p + 1] > nums[p] && nums[p + 1] > nums[p + 2]) {
+            st.update(0, 0, n - 1, p + 1, 1)
+            peak[p + 1] = 1
+          } else {
+            st.update(0, 0, n - 1, p + 1, 0)
+            peak[p + 1] = 0
+          }
+        }
+      }
+    }
+
+    return ans
+}
+
+class SegmentTree {
+  constructor(n) {
+    this.seg = new Array(4 * n + 1).fill(0)
+  }
+
+  build(ind, low, high, arr) {
+    if (low === high) {
+      this.seg[ind] = arr[low]
+      return
+    }
+
+    const mid = Math.floor((low + high) / 2)
+
+    this.build(2 * ind + 1, low, mid, arr)
+    this.build(2 * ind + 2, mid + 1, high, arr)
+
+    this.seg[ind] = this.seg[2 * ind + 1] + this.seg[2 * ind + 2]
+  }
+
+  query(ind, low, high, l, r) {
+    if (r < low || high < l) return 0
+
+    if (low >= l && high <= r) return this.seg[ind]
+
+    const mid = Math.floor((low + high) / 2)
+    const left = this.query(2 * ind + 1, low, mid, l, r)
+    const right = this.query(2 * ind + 2, mid + 1, high, l, r)
+
+    return left + right
+  }
+
+  update(ind, low, high, i, val) {
+    if (low === high) {
+      this.seg[ind] = val
+      return
+    }
+
+    const mid = Math.floor((low + high) / 2)
+
+    if (i <= mid) this.update(2 * ind + 1, low, mid, i, val)
+    else this.update(2 * ind + 2, mid + 1, high, i, val)
+
+    this.seg[ind] = this.seg[2 * ind + 1] + this.seg[2 * ind + 2]
+  }
+}
+

From cca1990a0b5376823a5853432ba116537fb0e4fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jun 2024 15:59:18 +0800
Subject: [PATCH 3090/3374] Create 3200-maximum-height-of-a-triangle.js

---
 3200-maximum-height-of-a-triangle.js | 46 ++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 3200-maximum-height-of-a-triangle.js

diff --git a/3200-maximum-height-of-a-triangle.js b/3200-maximum-height-of-a-triangle.js
new file mode 100644
index 00000000..76d80fbd
--- /dev/null
+++ b/3200-maximum-height-of-a-triangle.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} red
+ * @param {number} blue
+ * @return {number}
+ */
+const maxHeightOfTriangle = function(red, blue) {
+  let blueFirst = 0, redFirst = 0
+  let bb = blue, rb = red
+  let b = 1, r = 2
+  let bl = 0, rl = 0
+  while(bb >= b) {
+    bl++
+    bb -= b
+    b += 2
+  }
+  while(rb >= r && rl < bl) {
+    rl++
+    rb -= r
+    r += 2
+  }
+  if(bl - rl > 1) bl = rl + 1
+  
+  blueFirst = bl + rl
+  
+  bb = blue, rb = red
+  b = 2, r = 1
+  bl = 0, rl = 0
+  while(rb >= r) {
+    rl++
+    rb -= r
+    r += 2
+  }
+  
+  while(bb >= b && bl < rl) {
+    bl++
+    bb -= b
+    b += 2
+  }
+  if(rl - bl > 1) rl = bl + 1
+
+  redFirst = bl + rl
+  
+  
+  // return blueFirst
+  return Math.max(blueFirst, redFirst)
+};

From a88ed9a04fd1b5d07e9e78fd28c86c0dc011da61 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jun 2024 15:59:49 +0800
Subject: [PATCH 3091/3374] Create
 3201-find-the-maximum-length-of-valid-subsequence-i.js

---
 ...e-maximum-length-of-valid-subsequence-i.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 3201-find-the-maximum-length-of-valid-subsequence-i.js

diff --git a/3201-find-the-maximum-length-of-valid-subsequence-i.js b/3201-find-the-maximum-length-of-valid-subsequence-i.js
new file mode 100644
index 00000000..2e32d6ca
--- /dev/null
+++ b/3201-find-the-maximum-length-of-valid-subsequence-i.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumLength = function (nums) {
+  const n = nums.length
+  const arr = new Array(n)
+  let zeroCnt = 0
+  let firstZeroIdx = -1
+  let firstOneIdx = -1
+  for (let i = 0; i < n; i++) {
+    arr[i] = nums[i] % 2
+    if (arr[i] === 0) {
+      if (firstZeroIdx < 0) {
+        firstZeroIdx = i
+      }
+      zeroCnt++
+    } else {
+      if (firstOneIdx < 0) {
+        firstOneIdx = i
+      }
+    }
+  }
+  const oneCnt = n - zeroCnt
+  // Assume the subsequence's modulo is 0
+  let res = Math.max(zeroCnt, oneCnt)
+  // Modulo is 1
+  if (firstZeroIdx >= 0) {
+    let tmp = 1
+    let last = 0
+    for (let i = firstZeroIdx + 1; i < n; i++) {
+      if ((last ^ arr[i]) === 1) {
+        tmp++
+        last = arr[i]
+      }
+    }
+    res = Math.max(res, tmp)
+  }
+  if (firstOneIdx >= 0) {
+    let tmp = 1
+    let last = 1
+    for (let i = firstOneIdx + 1; i < n; i++) {
+      if ((last ^ arr[i]) === 1) {
+        tmp++
+        last = arr[i]
+      }
+    }
+    res = Math.max(res, tmp)
+  }
+  return res
+}

From 75c4cdbab702cc8102990bb0ab9d2febef26186a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jun 2024 16:00:21 +0800
Subject: [PATCH 3092/3374] Create
 3202-find-the-maximum-length-of-valid-subsequence-ii.js

---
 ...-maximum-length-of-valid-subsequence-ii.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3202-find-the-maximum-length-of-valid-subsequence-ii.js

diff --git a/3202-find-the-maximum-length-of-valid-subsequence-ii.js b/3202-find-the-maximum-length-of-valid-subsequence-ii.js
new file mode 100644
index 00000000..6b361e6c
--- /dev/null
+++ b/3202-find-the-maximum-length-of-valid-subsequence-ii.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximumLength = function (nums, k) {
+  const n = nums.length;
+  const dp = Array.from({ length: n }, () => Array(k).fill(1));
+  table(nums, k, dp);
+
+  let maxLength = 0;
+  for (const row of dp) {
+    for (const length of row) {
+      maxLength = Math.max(maxLength, length);
+    }
+  }
+  return maxLength;
+}
+function table(nums, k, dp) {
+  const n = nums.length;
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < i; j++) {
+      const remainder = (nums[i] + nums[j]) % k;
+      dp[i][remainder] = Math.max(dp[i][remainder], dp[j][remainder] + 1);
+    }
+  }
+}
+
+
+

From c3d0937ea692f0492d4aca233bbe1ed847c6906e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Jun 2024 16:00:52 +0800
Subject: [PATCH 3093/3374] Create
 3203-find-minimum-diameter-after-merging-two-trees.js

---
 ...inimum-diameter-after-merging-two-trees.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 3203-find-minimum-diameter-after-merging-two-trees.js

diff --git a/3203-find-minimum-diameter-after-merging-two-trees.js b/3203-find-minimum-diameter-after-merging-two-trees.js
new file mode 100644
index 00000000..78df2dd8
--- /dev/null
+++ b/3203-find-minimum-diameter-after-merging-two-trees.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @return {number}
+ */
+var minimumDiameterAfterMerge = function (edges1, edges2) {
+  const getDiameter = (edges) => {
+    if (edges.length === 0) {
+      return 0
+    }
+    const graph = new Map()
+    for (const [u, v] of edges) {
+      if (!graph.has(u)) {
+        graph.set(u, [])
+      }
+      graph.get(u).push(v)
+      if (!graph.has(v)) {
+        graph.set(v, [])
+      }
+      graph.get(v).push(u)
+    }
+
+    function dfs(node, parent) {
+      // return longest path length and farthest node
+      let res = [0, node]
+      for (const neighbor of graph.get(node) || []) {
+        if (neighbor === parent) {
+          continue
+        }
+        const tmp = dfs(neighbor, node)
+        if (tmp[0] > res[0]) res = tmp
+      }
+      res[0] += 1
+      return res
+    }
+
+    const [_, endNode] = dfs(0, -1)
+    const [diameter, __] = dfs(endNode, -1)
+    return diameter - 1
+  }
+
+  const diameter1 = getDiameter(edges1)
+  const diameter2 = getDiameter(edges2)
+  const radius1 = Math.floor((diameter1 + 1) / 2)
+  const radius2 = Math.floor((diameter2 + 1) / 2)
+  return Math.max(radius1 + radius2 + 1, diameter1, diameter2)
+}

From 1cc6aec69ae0fb60dd9295e5e28f94c428262991 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Jul 2024 11:33:06 +0800
Subject: [PATCH 3094/3374] Update 56-merge-intervals.js

---
 56-merge-intervals.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/56-merge-intervals.js b/56-merge-intervals.js
index a772b911..244a9fad 100644
--- a/56-merge-intervals.js
+++ b/56-merge-intervals.js
@@ -1,3 +1,28 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+const merge = function(intervals) {
+  intervals.sort((a, b) => a[0] - b[0])
+  const res = []
+  let cur = intervals[0]
+  const n = intervals.length
+  res.push(cur)
+  for(let i = 1; i < n; i++) {
+    const e = intervals[i]
+    if(e[0] <= cur[1]) {
+      cur[1] = Math.max(e[1], cur[1])
+    } else {
+      res.push(e)
+      cur = e
+    }
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[][]} intervals
  * @return {number[][]}

From ffde7b2501073aed618953c56c2fbaa5cee1ae77 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 3 Jul 2024 12:04:40 +0800
Subject: [PATCH 3095/3374] Update 57-insert-interval.js

---
 57-insert-interval.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/57-insert-interval.js b/57-insert-interval.js
index 60d4663b..d7611a1c 100644
--- a/57-insert-interval.js
+++ b/57-insert-interval.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[][]} intervals
+ * @param {number[]} newInterval
+ * @return {number[][]}
+ */
+const insert = function(intervals, newInterval) {
+  const res = [], n = intervals.length
+  let i = 0
+  while(i < n && intervals[i][1] < newInterval[0]) {
+    res.push(intervals[i])
+    i++
+  }
+  while(i < n && intervals[i][0] <= newInterval[1]) {
+    newInterval[0] = Math.min(newInterval[0], intervals[i][0])
+    newInterval[1] = Math.max(newInterval[1], intervals[i][1])
+    i++
+  }
+  res.push(newInterval)
+  while(i < n) {
+    res.push(intervals[i])
+    i++
+  }
+
+  return res
+};
+
+// another
 /**
  * @param {number[][]} intervals
  * @param {number[]} newInterval

From b67f5fe68b04d26c5dbb37e6fd1dc307c6707de1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Jul 2024 12:00:02 +0800
Subject: [PATCH 3096/3374] Update 986-interval-list-intersections.js

---
 986-interval-list-intersections.js | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/986-interval-list-intersections.js b/986-interval-list-intersections.js
index d82ad773..362e81d3 100644
--- a/986-interval-list-intersections.js
+++ b/986-interval-list-intersections.js
@@ -21,3 +21,29 @@ const intervalIntersection = function (A, B) {
   }
   return intersection
 }
+
+// another
+
+/**
+ * @param {number[][]} firstList
+ * @param {number[][]} secondList
+ * @return {number[][]}
+ */
+const intervalIntersection = function(firstList, secondList) {
+    const res = [];
+    let i = 0;
+    let j = 0;
+    while (i < firstList.length && j < secondList.length) {
+        const [start1, end1] = firstList[i];
+        const [start2, end2] = secondList[j];
+        if (start1 <= end2 && start2 <= end1) {
+            res.push([Math.max(start1, start2), Math.min(end1, end2)]);
+        }
+        if (end1 < end2) {
+            i++;
+        } else {
+            j++;
+        }
+    }
+    return res;
+};

From 28fed09b4d29d4b5f5a21e1bb67a9cc6c0f3b9bf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 5 Jul 2024 17:11:29 +0800
Subject: [PATCH 3097/3374] Update
 1589-maximum-sum-obtained-of-any-permutation.js

---
 ...maximum-sum-obtained-of-any-permutation.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/1589-maximum-sum-obtained-of-any-permutation.js b/1589-maximum-sum-obtained-of-any-permutation.js
index 54b7f955..2a42dd8b 100644
--- a/1589-maximum-sum-obtained-of-any-permutation.js
+++ b/1589-maximum-sum-obtained-of-any-permutation.js
@@ -1,3 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} requests
+ * @return {number}
+ */
+const maxSumRangeQuery = function(nums, requests) {
+  nums.sort((a, b) => b - a)
+  const n = nums.length
+  const arr = Array(n).fill(0)
+  for(const [s, e] of requests) {
+    arr[s] += 1
+    if(e + 1 < n) arr[e + 1] -= 1
+  }
+  for(let i = 1; i < n; i++) {
+    arr[i] += arr[i - 1]
+  }
+  arr.sort((a, b) => b - a)
+  
+  let res = 0
+  const mod = 1e9 + 7
+  
+  for(let i = 0; i < n; i++) {
+    res = (res + nums[i] * arr[i]) % mod
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[][]} requests

From 28e69519052c8bb973dc3f79459509461f3d27e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Jul 2024 16:38:00 +0800
Subject: [PATCH 3098/3374] Create 3210-find-the-encrypted-string.js

---
 3210-find-the-encrypted-string.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3210-find-the-encrypted-string.js

diff --git a/3210-find-the-encrypted-string.js b/3210-find-the-encrypted-string.js
new file mode 100644
index 00000000..76e5c960
--- /dev/null
+++ b/3210-find-the-encrypted-string.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {string}
+ */
+var getEncryptedString = function(s, k) {
+  const ss=s+s
+  const n = s.length
+  let res = ''
+  for(let i = 0; i < n; i++) {
+    const idx = (i + k) % n
+    res += ss[idx]
+  }
+  
+  return res
+};

From e64ea0038abc24dc0f3881b1e922892f85fbcbfa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Jul 2024 16:38:33 +0800
Subject: [PATCH 3099/3374] Create
 3211-generate-binary-strings-without-adjacent-zeros.js

---
 ...e-binary-strings-without-adjacent-zeros.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 3211-generate-binary-strings-without-adjacent-zeros.js

diff --git a/3211-generate-binary-strings-without-adjacent-zeros.js b/3211-generate-binary-strings-without-adjacent-zeros.js
new file mode 100644
index 00000000..7e1be42e
--- /dev/null
+++ b/3211-generate-binary-strings-without-adjacent-zeros.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number} n
+ * @return {string[]}
+ */
+var validStrings = function(n) {
+  const set= new Set()
+  bt(1, '0')
+  bt(1, '1')
+  return Array.from(set)
+  
+  function bt(i, cur) {
+    if(i === n) {
+      set.add(cur)
+      return
+    }
+    const last = cur[cur.length - 1]
+    if(last === '0') {
+      bt(i + 1, cur + '1')
+    } else {
+      bt(i + 1, cur + '1')
+      bt(i + 1, cur + '0')
+    }
+  }
+};

From 8b87f257dc42ea9cb8f4a576a11195bfc0b011f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Jul 2024 16:39:04 +0800
Subject: [PATCH 3100/3374] Create
 3212-count-submatrices-with-equal-frequency-of-x-and-y.js

---
 ...atrices-with-equal-frequency-of-x-and-y.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3212-count-submatrices-with-equal-frequency-of-x-and-y.js

diff --git a/3212-count-submatrices-with-equal-frequency-of-x-and-y.js b/3212-count-submatrices-with-equal-frequency-of-x-and-y.js
new file mode 100644
index 00000000..5e2a229b
--- /dev/null
+++ b/3212-count-submatrices-with-equal-frequency-of-x-and-y.js
@@ -0,0 +1,37 @@
+/**
+ * @param {character[][]} grid
+ * @return {number}
+ */
+var numberOfSubmatrices = function (grid) {
+  let r = grid.length
+  let c = grid[0].length
+  let prex = new Array(r + 1).fill(0).map(() => new Array(c + 1).fill(0))
+  let prey = new Array(r + 1).fill(0).map(() => new Array(c + 1).fill(0))
+
+  for (let i = 1; i <= r; i++) {
+    for (let j = 1; j <= c; j++) {
+      prex[i][j] =
+        prex[i - 1][j] +
+        prex[i][j - 1] -
+        prex[i - 1][j - 1] +
+        (grid[i - 1][j - 1] === 'X' ? 1 : 0)
+      prey[i][j] =
+        prey[i - 1][j] +
+        prey[i][j - 1] -
+        prey[i - 1][j - 1] +
+        (grid[i - 1][j - 1] === 'Y' ? 1 : 0)
+    }
+  }
+
+  let res = 0
+  for (let i = 0; i < r; i++) {
+    for (let j = 0; j < c; j++) {
+      let cx = prex[i + 1][j + 1] - prex[0][j + 1] - prex[i + 1][0] + prex[0][0]
+      let cy = prey[i + 1][j + 1] - prey[0][j + 1] - prey[i + 1][0] + prey[0][0]
+      if (cx === cy && cx > 0) {
+        res++
+      }
+    }
+  }
+  return res
+}

From 080b770b1afc84039d6782248d7f57fe4608bc42 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 7 Jul 2024 16:39:33 +0800
Subject: [PATCH 3101/3374] Create 3213-construct-string-with-minimum-cost.js

---
 3213-construct-string-with-minimum-cost.js | 59 ++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 3213-construct-string-with-minimum-cost.js

diff --git a/3213-construct-string-with-minimum-cost.js b/3213-construct-string-with-minimum-cost.js
new file mode 100644
index 00000000..1f8666b3
--- /dev/null
+++ b/3213-construct-string-with-minimum-cost.js
@@ -0,0 +1,59 @@
+const mx = 1000000000
+/**
+ * @param {string} target
+ * @param {string[]} words
+ * @param {number[]} costs
+ * @return {number}
+ */
+var minimumCost = function (target, words, costs) {
+  const n = target.length
+  const dp = new Array(n + 1).fill(mx)
+  const t = new Trie(30)
+
+  for (let i = 0; i < words.length; i++) {
+    t.insert(words[i], costs[i])
+  }
+
+  dp[n] = 0
+
+  for (let i = n - 1; i >= 0; i--) {
+    let cur = t
+    for (let j = i; j <= n && cur !== null; j++) {
+      if (cur.cost !== mx) {
+        dp[i] = Math.min(dp[j] + cur.cost, dp[i])
+      }
+      if (j < n) {
+        cur = cur.sons[target.charCodeAt(j) - 'a'.charCodeAt(0)]
+      }
+    }
+  }
+
+  return dp[0] === mx ? -1 : dp[0]
+}
+
+class Trie {
+  constructor(range) {
+    this.range = range
+    this.cost = mx
+    this.sons = new Array(range).fill(null)
+  }
+
+  insert(str, cost) {
+    let cur = this
+    for (let c of str) {
+      if (cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)] === null) {
+        cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)] = new Trie(this.range)
+      }
+      cur = cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)]
+    }
+    cur.cost = Math.min(cur.cost, cost)
+  }
+
+  destroy() {
+    for (let t of this.sons) {
+      if (t !== null) {
+        t.destroy()
+      }
+    }
+  }
+}

From f8beae1e6d2b0c090a54c9c3e86b911bbc0b3aa7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Jul 2024 10:31:59 +0800
Subject: [PATCH 3102/3374] Update 218-the-skyline-problem.js

---
 218-the-skyline-problem.js | 85 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/218-the-skyline-problem.js b/218-the-skyline-problem.js
index 39846b9c..81f1f00c 100644
--- a/218-the-skyline-problem.js
+++ b/218-the-skyline-problem.js
@@ -1,3 +1,88 @@
+/**
+ * @param {number[][]} buildings
+ * @return {number[][]}
+ */
+const getSkyline = function(buildings) {
+  const hash = {}
+  for(const b of buildings) {
+    const [s, e, h] = b
+    if(hash[s] == null) hash[s] = []
+    if(hash[e] == null) hash[e] = []
+    hash[s].push(h)
+    hash[e].push(-h)
+  }
+  const ms = new MultiSet()
+  const res = []
+
+  for(const [pos, hs] of Object.entries(hash)) {
+    for(const h of hs) {
+      if(h > 0) {
+        ms.add(h)
+      } else {
+        ms.remove(-h)
+      }
+    }
+    const h = ms.max || 0
+    if(res.length === 0 || res[res.length - 1][1] !== h) {
+      res.push([+pos, h])
+    }
+  }
+
+
+  return res
+};
+
+class MultiSet {
+  constructor() {
+    this.countMap = new Map()
+    this.valueList = []
+  }
+  remove(value) {
+    if(!this.countMap.has(value)) return false
+    let index = binarySearch(this.valueList, value)
+    if (this.countMap.get(value) === 1) {
+      this.valueList.splice(index, 1)
+      this.countMap.delete(value)
+    } else {
+      this.countMap.set(value, (this.countMap.get(value) || 0) - 1)
+    }
+    return true
+  }
+  add(value) {
+    let index = binarySearch(this.valueList, value)
+    if (index < 0) {
+      this.valueList.splice(-index - 1, 0, value)
+      this.countMap.set(value, 1)
+    } else {
+      this.countMap.set(value, this.countMap.get(value) + 1)
+    }
+  }
+  get max() {
+    return this.valueList[this.valueList.length - 1]
+  }
+  get min() {
+    return this.valueList[0]
+  }
+}
+
+function binarySearch(arr, val) {
+  let l = 0, r = arr.length
+  while( l < r ) {
+    const mid = Math.floor((l + r) / 2)
+    if(arr[mid] < val) {
+       l = mid + 1
+    } else {
+      r = mid
+    }
+  }
+  if(arr[l] !== val) return -(l + 1)
+  
+  return l
+}
+
+// another
+
+
 /**
  * @param {number[][]} buildings
  * @return {number[][]}

From 851893a275e7b5273a25ba7db128a6ed8046fe20 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Jul 2024 13:39:13 +0800
Subject: [PATCH 3103/3374] Update 3213-construct-string-with-minimum-cost.js

---
 3213-construct-string-with-minimum-cost.js | 95 ++++++++++++++++++++++
 1 file changed, 95 insertions(+)

diff --git a/3213-construct-string-with-minimum-cost.js b/3213-construct-string-with-minimum-cost.js
index 1f8666b3..0b505d8a 100644
--- a/3213-construct-string-with-minimum-cost.js
+++ b/3213-construct-string-with-minimum-cost.js
@@ -1,3 +1,98 @@
+/**
+ * @param {string} target
+ * @param {string[]} words
+ * @param {number[]} costs
+ * @return {number}
+ */
+var minimumCost = function (target, words, costs) {
+  let ac = new AhoCorasick()
+  for (let i = 0; i < words.length; i++) {
+    ac.put(words[i], costs[i])
+  }
+  ac.build_fail()
+
+  let n = target.length
+  let f = new Array(n + 1).fill(Infinity)
+  f[0] = 0
+  let cur = (root = ac.root)
+  for (let i = 1; i <= n; i++) {
+    cur = cur.son[target.charCodeAt(i - 1) - 'a'.charCodeAt(0)]
+    if (cur.len) {
+      f[i] = Math.min(f[i], f[i - cur.len] + cur.cost)
+    }
+    let fail = cur.last
+    while (fail !== root) {
+      let tmp = f[i - fail.len] + fail.cost
+      if (tmp < f[i]) {
+        f[i] = tmp
+      }
+      fail = fail.last
+    }
+  }
+  return f[n] === Infinity ? -1 : f[n]
+}
+
+class Node {
+  constructor() {
+    this.son = new Array(26).fill(null)
+    this.fail = null
+    this.last = null
+    this.len = 0
+    this.cost = Infinity
+  }
+}
+
+class AhoCorasick {
+  constructor() {
+    this.root = new Node()
+  }
+
+  put(s, cost) {
+    let cur = this.root
+    for (let i = 0; i < s.length; i++) {
+      let b = s.charCodeAt(i) - 'a'.charCodeAt(0)
+      if (cur.son[b] === null) {
+        cur.son[b] = new Node()
+      }
+      cur = cur.son[b]
+    }
+    cur.len = s.length
+    cur.cost = Math.min(cur.cost, cost)
+  }
+
+  build_fail() {
+    this.root.fail = this.root.last = this.root
+    let q = []
+    for (let i = 0; i < this.root.son.length; i++) {
+      let son = this.root.son[i]
+      if (son === null) {
+        this.root.son[i] = this.root
+      } else {
+        son.fail = son.last = this.root
+        q.push(son)
+      }
+    }
+    while (q.length > 0) {
+      let cur = q.shift()
+      for (let i = 0; i < cur.son.length; i++) {
+        let son = cur.son[i]
+        if (son === null) {
+          cur.son[i] = cur.fail.son[i]
+          continue
+        }
+        son.fail = cur.fail.son[i]
+        son.last = son.fail.len ? son.fail : son.fail.last
+        q.push(son)
+      }
+    }
+  }
+}
+
+
+
+
+// TLE below
+
 const mx = 1000000000
 /**
  * @param {string} target

From 68c3a80e05d5d41c877b506926753b06c5f06f30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 12 Jul 2024 11:58:28 +0800
Subject: [PATCH 3104/3374] Create
 2617-minimum-number-of-visited-cells-in-a-grid.js

---
 ...nimum-number-of-visited-cells-in-a-grid.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 2617-minimum-number-of-visited-cells-in-a-grid.js

diff --git a/2617-minimum-number-of-visited-cells-in-a-grid.js b/2617-minimum-number-of-visited-cells-in-a-grid.js
new file mode 100644
index 00000000..c29802c8
--- /dev/null
+++ b/2617-minimum-number-of-visited-cells-in-a-grid.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumVisitedCells = function (grid) {
+    const m = grid.length,
+      n = grid[0].length
+    const dp = Array(m)
+        .fill(0)
+        .map(() => Array(n).fill(Infinity)),
+      colStacks = Array(n)
+        .fill(0)
+        .map(() => []) // colStacks[j] = stack of row indexes for column j
+    dp[m - 1][n - 1] = 1
+    colStacks[n - 1].push(m - 1)
+  
+    for (let i = m - 1; i >= 0; i--) {
+      let rowStack = i === m - 1 ? [n - 1] : [] // stack of column indexes for row i
+      for (let j = n - 1; j >= 0; j--) {
+        let colIndex = findIndex(rowStack, grid[i][j] + j)
+        if (colIndex >= 0)
+          dp[i][j] = Math.min(dp[i][j], 1 + dp[i][rowStack[colIndex]])
+        let colStack = colStacks[j],
+          rowIndex = findIndex(colStack, grid[i][j] + i)
+        if (rowIndex >= 0)
+          dp[i][j] = Math.min(dp[i][j], 1 + dp[colStack[rowIndex]][j])
+  
+        while (
+          rowStack.length &&
+          dp[i][rowStack[rowStack.length - 1]] >= dp[i][j]
+        )
+          rowStack.pop()
+        rowStack.push(j)
+        while (
+          colStack.length &&
+          dp[colStack[colStack.length - 1]][j] >= dp[i][j]
+        )
+          colStack.pop()
+        colStack.push(i)
+      }
+    }
+    return dp[0][0] === Infinity ? -1 : dp[0][0]
+  }
+  
+  function findIndex(stack, maxIndex) {
+    if (!stack.length) return -1
+    let low = 0,
+      high = stack.length - 1
+    while (low < high) {
+      let mid = Math.floor((low + high) / 2)
+      if (stack[mid] <= maxIndex) high = mid
+      else low = mid + 1
+    }
+    return stack[low] <= maxIndex ? low : -1
+  }
+  

From 2b71861c7b8e4cbc26e1743a5612764b8835f646 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Jul 2024 22:34:49 +0800
Subject: [PATCH 3105/3374] Create
 3216-lexicographically-smallest-string-after-a-swap.js

---
 ...cographically-smallest-string-after-a-swap.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3216-lexicographically-smallest-string-after-a-swap.js

diff --git a/3216-lexicographically-smallest-string-after-a-swap.js b/3216-lexicographically-smallest-string-after-a-swap.js
new file mode 100644
index 00000000..a4d57bf8
--- /dev/null
+++ b/3216-lexicographically-smallest-string-after-a-swap.js
@@ -0,0 +1,16 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var getSmallestString = function(s) {
+  const arr = s.split('')
+  const n = arr.length
+  for(let i = 1; i < n; i++) {
+    const valid = +arr[i] % 2 === +arr[i - 1] % 2
+    if(valid && (+arr[i] < +arr[i - 1])) {
+      ;[arr[i - 1], arr[i]] = [arr[i], arr[i - 1]]
+      return arr.join('')
+    }
+  }
+  return s
+};

From 4554214ade6746b6c40080cbfefef67dc973bf94 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Jul 2024 22:35:18 +0800
Subject: [PATCH 3106/3374] Create
 3217-delete-nodes-from-linked-list-present-in-array.js

---
 ...nodes-from-linked-list-present-in-array.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 3217-delete-nodes-from-linked-list-present-in-array.js

diff --git a/3217-delete-nodes-from-linked-list-present-in-array.js b/3217-delete-nodes-from-linked-list-present-in-array.js
new file mode 100644
index 00000000..d83363b4
--- /dev/null
+++ b/3217-delete-nodes-from-linked-list-present-in-array.js
@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val, next) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.next = (next===undefined ? null : next)
+ * }
+ */
+/**
+ * @param {number[]} nums
+ * @param {ListNode} head
+ * @return {ListNode}
+ */
+var modifiedList = function(nums, head) {
+    const arr = []
+    let cur = head
+    while(cur) {
+      arr.push(cur)
+      cur = cur.next
+    }
+   const set = new Set(nums)
+   let i = 0
+   for(const e of arr) {
+     if(set.has(e.val)) {
+       arr[i] = null
+     }
+     i++
+   }
+   const res = arr.filter(e => e != null)
+   for(let i = 0; i < res.length; i++) {
+     const e = res[i]
+     if(i === res.length - 1) {
+       e.next = null
+       break
+     }
+     e.next = res[i + 1]
+   }
+   return res[0]
+};

From 721f84e7c821d5f26ae0b25f483d166ed6f36cf1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Jul 2024 22:35:45 +0800
Subject: [PATCH 3107/3374] Create 3218-minimum-cost-for-cutting-cake-i.js

---
 3218-minimum-cost-for-cutting-cake-i.js | 40 +++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3218-minimum-cost-for-cutting-cake-i.js

diff --git a/3218-minimum-cost-for-cutting-cake-i.js b/3218-minimum-cost-for-cutting-cake-i.js
new file mode 100644
index 00000000..5ad408c9
--- /dev/null
+++ b/3218-minimum-cost-for-cutting-cake-i.js
@@ -0,0 +1,40 @@
+class Cut {
+  constructor(cost, type) {
+    this.cost = cost
+    this.type = type
+  }
+}
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[]} horizontalCut
+ * @param {number[]} verticalCut
+ * @return {number}
+ */
+var minimumCost = function (m, n, horizontalCut, verticalCut) {
+  const cuts = []
+  for (let i = 0; i < horizontalCut.length; i++) {
+    cuts.push(new Cut(horizontalCut[i], 'H'))
+  }
+  for (let j = 0; j < verticalCut.length; j++) {
+    cuts.push(new Cut(verticalCut[j], 'V'))
+  }
+
+  cuts.sort((a, b) => -a.cost + b.cost)
+
+  let totalCost = 0
+  let horizontalSegments = 1
+  let verticalSegments = 1
+
+  for (const cut of cuts) {
+    if (cut.type === 'H') {
+      totalCost += cut.cost * verticalSegments
+      horizontalSegments++
+    } else {
+      totalCost += cut.cost * horizontalSegments
+      verticalSegments++
+    }
+  }
+
+  return totalCost
+}

From d40cce155c2c3d7f12d05ca7c4a5910b39bf25db Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 14 Jul 2024 22:36:18 +0800
Subject: [PATCH 3108/3374] Create 3219-minimum-cost-for-cutting-cake-ii.js

---
 3219-minimum-cost-for-cutting-cake-ii.js | 40 ++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3219-minimum-cost-for-cutting-cake-ii.js

diff --git a/3219-minimum-cost-for-cutting-cake-ii.js b/3219-minimum-cost-for-cutting-cake-ii.js
new file mode 100644
index 00000000..fca6dce0
--- /dev/null
+++ b/3219-minimum-cost-for-cutting-cake-ii.js
@@ -0,0 +1,40 @@
+class Cut {
+  constructor(cost, type) {
+    this.cost = cost
+    this.type = type
+  }
+}
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[]} horizontalCut
+ * @param {number[]} verticalCut
+ * @return {number}
+ */
+var minimumCost = function(m, n, horizontalCut, verticalCut) {
+  let cuts = []
+  for (let i = 0; i < horizontalCut.length; i++) {
+    cuts.push(new Cut(horizontalCut[i], 'H'))
+  }
+  for (let j = 0; j < verticalCut.length; j++) {
+    cuts.push(new Cut(verticalCut[j], 'V'))
+  }
+
+  cuts.sort((a, b) => -a.cost + b.cost)
+
+  let ans = 0
+  let hCount = 1
+  let vCount = 1
+
+  for (let cut of cuts) {
+    if (cut.type === 'H') {
+      ans += cut.cost * vCount
+      hCount++
+    } else {
+      ans += cut.cost * hCount
+      vCount++
+    }
+  }
+
+  return ans
+};

From cca30549cac59a4111d18d20635792b95e99349e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 15 Jul 2024 10:40:02 +0800
Subject: [PATCH 3109/3374] Update 2963-count-the-number-of-good-partitions.js

---
 2963-count-the-number-of-good-partitions.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/2963-count-the-number-of-good-partitions.js b/2963-count-the-number-of-good-partitions.js
index 149c3feb..4e94ff51 100644
--- a/2963-count-the-number-of-good-partitions.js
+++ b/2963-count-the-number-of-good-partitions.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numberOfGoodPartitions = function(nums) {
+  const n = nums.length, mod = 1e9 + 7, lastIdxHash = {}
+  let res = 1
+  for (let i = 0; i < n; i++) lastIdxHash[nums[i]] = i
+  let j = 0
+  for(let i = 0; i < n; i++) {
+      if(i > j) res = (res * 2) % mod
+      j = Math.max(j, lastIdxHash[nums[i]])
+  }
+
+
+  return res
+};
+
+// another
+
 class Interval {
   constructor(left, right) {
     this.left = left

From 60cc6fe7c06409952aac5a69bac4d4220bf2b1d9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 18 Jul 2024 11:23:33 +0800
Subject: [PATCH 3110/3374] Create
 3197-find-the-minimum-area-to-cover-all-ones-ii.js

---
 ...d-the-minimum-area-to-cover-all-ones-ii.js | 122 ++++++++++++++++++
 1 file changed, 122 insertions(+)
 create mode 100644 3197-find-the-minimum-area-to-cover-all-ones-ii.js

diff --git a/3197-find-the-minimum-area-to-cover-all-ones-ii.js b/3197-find-the-minimum-area-to-cover-all-ones-ii.js
new file mode 100644
index 00000000..7d16a72e
--- /dev/null
+++ b/3197-find-the-minimum-area-to-cover-all-ones-ii.js
@@ -0,0 +1,122 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const minimumSum = function(grid) {
+  const m = grid.length, n = grid[0].length
+  let res = Infinity
+//   case 1
+/*
+1 | 2 | 3
+*/
+for(let i = 0; i < n - 2; i++) {
+  const one = calc(0, m - 1, 0, i, grid)
+  for(let j = i + 1; j < n - 1; j++) {
+    const two = calc(0, m - 1, i + 1, j, grid)
+    const three = calc(0, m - 1, j + 1, n - 1, grid)
+    res = Math.min(res, one + two + three)
+  }
+}
+
+
+//   case 2
+/*
+1
+-
+2
+-
+3
+*/
+for(let i = 0; i < m - 2; i++) {
+    const one = calc(0, i, 0, n - 1, grid)
+    for(let j = i + 1; j < m - 1; j++) {
+      const two = calc(i + 1, j, 0, n - 1, grid)
+      const three = calc(j + 1, m - 1, 0, n - 1, grid)
+      res = Math.min(res, one + two + three)
+    }
+}
+
+
+//   case 3
+/*
+2 | 3
+-----
+  1
+*/
+for(let i = m - 1; i >= 1; i--) {
+  const one = calc(i, m - 1, 0, n - 1, grid)
+  for(let j = 0; j < n - 1; j++) {
+    const two = calc(0, i - 1, 0, j, grid)
+    const three = calc(0, i - 1, j + 1, n - 1, grid)
+    res = Math.min(res, one + two + three)
+  }
+
+}
+
+
+//   case 4
+/*
+2 |
+--| 1
+3 |
+*/
+for(let i = n - 1; i >= 1; i--) {
+    const one = calc(0, m - 1, i, n - 1, grid)
+    for(let j = 0; j < m - 1; j++) {
+      const two = calc(0, j, 0, i - 1, grid)
+      const three = calc(j + 1, m - 1, 0, i - 1, grid)
+      res = Math.min(res, one + two + three)
+    }
+  }
+
+
+//   case 5
+/*
+  1  
+-----
+2 | 3
+*/
+for(let i = 0; i < m - 1; i++) {
+    const one = calc(0, i, 0, n - 1, grid)
+    for(let j = 0; j < n - 1; j++) {
+      const two = calc(i + 1, m - 1, 0, j, grid)
+      const three = calc(i + 1, m - 1, j + 1, n - 1, grid)
+      res = Math.min(res, one + two + three)
+    }
+  
+}
+
+
+//   case 6
+/*
+   | 2
+ 1 |--
+   | 3
+*/
+for(let j = 0; j < n - 1; j++) {
+    const one = calc(0, m - 1, 0, j, grid)
+    for(let i = 0; i < m - 1; i++) {
+      const two = calc(0, i, j + 1, n - 1, grid)
+      const three = calc(i + 1, m - 1, j + 1, n - 1, grid)
+      res = Math.min(res, one + two + three)
+    }
+}
+
+  return res
+};
+
+function calc(rs, re, cs, ce, grid) {
+
+    let rmin = Infinity, rmax = -Infinity, cmin = Infinity, cmax = -Infinity
+    for(let i = rs; i <= re; i++) {
+        for(let j = cs; j <= ce; j++) {
+        if(grid[i][j] === 1) {
+            rmin = Math.min(rmin, i)
+            rmax = Math.max(rmax, i)
+            cmin = Math.min(cmin, j)
+            cmax = Math.max(cmax, j)
+        }
+        }
+    }
+    return (rmax - rmin + 1) * (cmax - cmin + 1)
+}

From c4119a5b20dd4c082f1be71a75114f13e72a22e1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 19 Jul 2024 11:10:20 +0800
Subject: [PATCH 3111/3374] Update
 3186-maximum-total-damage-with-spell-casting.js

---
 ...maximum-total-damage-with-spell-casting.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/3186-maximum-total-damage-with-spell-casting.js b/3186-maximum-total-damage-with-spell-casting.js
index d6de86f5..7db66a9f 100644
--- a/3186-maximum-total-damage-with-spell-casting.js
+++ b/3186-maximum-total-damage-with-spell-casting.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} power
+ * @return {number}
+ */
+const maximumTotalDamage = function(power) {
+    const freq = new Map()
+    for (const p of power) {
+        freq.set(p, (freq.get(p) || 0) + 1)
+    }
+    const sorted = Array.from(freq.keys()).sort((a, b) => a - b)
+    const n = sorted.length
+    const dp = Array(n+1).fill(0)
+    dp[1] = sorted[0] * freq.get(sorted[0])
+    for(let i = 2; i <= n; i++) {
+        const val = sorted[i-1]
+        const cur = val * freq.get(val)
+        let j = i - 2
+        
+        if(j >= 0 && sorted[j] + 1 === val) {
+            j--
+        }
+        if(j >= 0 && sorted[j] + 2 === val) {
+            j--
+        }
+        
+        if(j >= 0) {
+            dp[i] = Math.max(dp[i-1], dp[j+1] + cur)
+        } else {
+            dp[i] = Math.max(dp[i-1], cur)
+        }
+        
+    }
+
+    return dp[n]
+};
+
+// another
+
 /**
  * @param {number[]} power
  * @return {number}

From 5054e4e2cd7b3963f0ab87c044c9c4929cf5dfc2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Jul 2024 18:57:41 +0800
Subject: [PATCH 3112/3374] Create
 3144-minimum-substring-partition-of-equal-character-frequency.js

---
 ...-partition-of-equal-character-frequency.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3144-minimum-substring-partition-of-equal-character-frequency.js

diff --git a/3144-minimum-substring-partition-of-equal-character-frequency.js b/3144-minimum-substring-partition-of-equal-character-frequency.js
new file mode 100644
index 00000000..e543b411
--- /dev/null
+++ b/3144-minimum-substring-partition-of-equal-character-frequency.js
@@ -0,0 +1,40 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minimumSubstringsInPartition = function (s) {
+  const n = s.length;
+  const dp = new Array(n + 1).fill();
+  dp[0] = 0;
+  const chars = new Array(26).fill();
+
+  for (let i = 0; i < n; i++) {
+    dp[i + 1] = 1 + dp[i];
+    chars.forEach((_, idx) => (chars[idx] = undefined));
+    const idxOne = s.charCodeAt(i) - 97;
+    chars[idxOne] = 1;
+
+    for (let j = i - 1; j >= 0; j--) {
+      const idxTwo = s.charCodeAt(j) - 97;
+      chars[idxTwo] = (chars[idxTwo] || 0) + 1;
+      if (isOk(chars)) {
+        dp[i + 1] = Math.min(dp[j] + 1, dp[i + 1]);
+      }
+    }
+  }
+
+  return dp[n];
+};
+
+function isOk(chars) {
+  let freq = undefined;
+  for (let i = 0; i < chars.length; i++) {
+    if (chars[i] === undefined) continue;
+    if (freq === undefined) {
+      freq = chars[i];
+    } else if (chars[i] !== freq) {
+      return false;
+    }
+  }
+  return true;
+}

From 2b9097010b809e585d1a270de185d949ad70c0c3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jul 2024 15:36:14 +0800
Subject: [PATCH 3113/3374] Create
 3226-number-of-bit-changes-to-make-two-integers-equal.js

---
 ...-bit-changes-to-make-two-integers-equal.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3226-number-of-bit-changes-to-make-two-integers-equal.js

diff --git a/3226-number-of-bit-changes-to-make-two-integers-equal.js b/3226-number-of-bit-changes-to-make-two-integers-equal.js
new file mode 100644
index 00000000..b9150e96
--- /dev/null
+++ b/3226-number-of-bit-changes-to-make-two-integers-equal.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+var minChanges = function(n, k) {
+  const s = num2bin(n)
+  const t = num2bin(k)
+  let res = 0
+  const len = s.length
+  
+  for(let i = 0; i < len; i++) {
+    const e = s[i], e1 = t[i]
+    if(e !== e1) {
+      if(e === '1') {
+        res++
+      } else {
+        return -1
+      }
+    }
+  }
+  
+  return res
+};
+
+function num2bin(n) {
+  let tmp = (n >>> 0).toString(2)
+  if(tmp.length < 32) {
+    return '0'.repeat(32 - tmp.length) + tmp
+  }
+  
+  return tmp
+}

From 50e1d5c9bbdde5c455fef6602986c53151400f2f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jul 2024 15:36:47 +0800
Subject: [PATCH 3114/3374] Create 3227-vowels-game-in-a-string.js

---
 3227-vowels-game-in-a-string.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)
 create mode 100644 3227-vowels-game-in-a-string.js

diff --git a/3227-vowels-game-in-a-string.js b/3227-vowels-game-in-a-string.js
new file mode 100644
index 00000000..48c81e27
--- /dev/null
+++ b/3227-vowels-game-in-a-string.js
@@ -0,0 +1,12 @@
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var doesAliceWin = function(s) {
+  let v = 0
+  for(let c of s){
+    if(c ==='a' || c ==='e' || c ==='i' || c ==='o'|| c ==='u') v++
+  }
+  if(v === 0) return false
+  else return true
+};

From 5394aa91abc4614fdb441fae998a369c44212738 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jul 2024 15:37:17 +0800
Subject: [PATCH 3115/3374] Create
 3228-maximum-number-of-operations-to-move-ones-to-the-end.js

---
 ...r-of-operations-to-move-ones-to-the-end.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3228-maximum-number-of-operations-to-move-ones-to-the-end.js

diff --git a/3228-maximum-number-of-operations-to-move-ones-to-the-end.js b/3228-maximum-number-of-operations-to-move-ones-to-the-end.js
new file mode 100644
index 00000000..f4b76f1d
--- /dev/null
+++ b/3228-maximum-number-of-operations-to-move-ones-to-the-end.js
@@ -0,0 +1,29 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var maxOperations = function(s) {
+  let ss = ''
+  for (let ch of s) {
+    if (ss === '') {
+      ss += ch
+      continue
+    }
+    if (ch === '0' && ss[ss.length - 1] === '0') {
+      continue
+    } else {
+      ss += ch
+    }
+  }
+  s = ss
+  let res = 0
+  let cnt = 0
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === '0') {
+      res += cnt
+    } else {
+      cnt += 1
+    }
+  }
+  return res
+};

From b89bff4fe0e7a42a9e5566e10e0fa7ce615806b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 21 Jul 2024 15:37:56 +0800
Subject: [PATCH 3116/3374] Create
 3229-minimum-operations-to-make-array-equal-to-target.js

---
 ...perations-to-make-array-equal-to-target.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3229-minimum-operations-to-make-array-equal-to-target.js

diff --git a/3229-minimum-operations-to-make-array-equal-to-target.js b/3229-minimum-operations-to-make-array-equal-to-target.js
new file mode 100644
index 00000000..a1edda5b
--- /dev/null
+++ b/3229-minimum-operations-to-make-array-equal-to-target.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} target
+ * @return {number}
+ */
+var minimumOperations = function(nums, target) {
+  if (nums.length !== target.length) {
+    return -1
+  }
+
+  const diff = nums.map((num, i) => -num + target[i])
+
+  let res = 0
+  for (let i = 0; i < diff.length; i++) {
+    if (i === 0 || diff[i] * diff[i - 1] <= 0) {
+      res += Math.abs(diff[i])
+    } else {
+      res += Math.max(Math.abs(diff[i]) - Math.abs(diff[i - 1]), 0)
+    }
+  }
+
+  return res
+};

From 0f4d954864330209ddd79e346863cd2b61d309d3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 22 Jul 2024 13:06:45 +0800
Subject: [PATCH 3117/3374] Update
 3202-find-the-maximum-length-of-valid-subsequence-ii.js

---
 ...-maximum-length-of-valid-subsequence-ii.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/3202-find-the-maximum-length-of-valid-subsequence-ii.js b/3202-find-the-maximum-length-of-valid-subsequence-ii.js
index 6b361e6c..f0e09cd1 100644
--- a/3202-find-the-maximum-length-of-valid-subsequence-ii.js
+++ b/3202-find-the-maximum-length-of-valid-subsequence-ii.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumLength = function(nums, k) {
+  const n = nums.length;
+  const dp = Array.from({ length: k + 1 }, () => Array(k + 1).fill(0));
+  let res = 0
+  for(const e of nums) {
+    const cur = e % k;
+    for(let remain = 0; remain < k; remain++) {
+      const prev = (k + remain - cur) % k;
+      dp[cur][remain] = Math.max(dp[cur][remain], dp[prev][remain] + 1)
+      res = Math.max(res, dp[cur][remain])
+    }
+  }
+
+  return res
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From a5c884e63afc0370fe19748e365aba9136c267bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 23 Jul 2024 11:25:09 +0800
Subject: [PATCH 3118/3374] Update
 3196-maximize-total-cost-of-alternating-subarrays.js

---
 ...ize-total-cost-of-alternating-subarrays.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/3196-maximize-total-cost-of-alternating-subarrays.js b/3196-maximize-total-cost-of-alternating-subarrays.js
index d6e45781..e2c72e8f 100644
--- a/3196-maximize-total-cost-of-alternating-subarrays.js
+++ b/3196-maximize-total-cost-of-alternating-subarrays.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maximumTotalCost = function(nums) {
+  const n = nums.length;
+  const dp = Array.from({ length: n + 1 }, () => Array(2).fill(0));
+  dp[1][0] = nums[0]
+  dp[1][1] = nums[0]
+    for (let i = 2; i <= n; i++) {
+        const e = nums[i - 1]
+        dp[i][0] = Math.max(dp[i - 1][1], dp[i - 1][0]) + e
+        dp[i][1] = dp[i - 1][0] - e
+    }
+
+
+  return Math.max(dp[n][0], dp[n][1])
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From e2b9b277e3645ef42aa78b4939c015524b909529 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 24 Jul 2024 11:37:11 +0800
Subject: [PATCH 3119/3374] Create
 3176-find-the-maximum-length-of-a-good-subsequence-i.js

---
 ...-maximum-length-of-a-good-subsequence-i.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3176-find-the-maximum-length-of-a-good-subsequence-i.js

diff --git a/3176-find-the-maximum-length-of-a-good-subsequence-i.js b/3176-find-the-maximum-length-of-a-good-subsequence-i.js
new file mode 100644
index 00000000..f8f16f5a
--- /dev/null
+++ b/3176-find-the-maximum-length-of-a-good-subsequence-i.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumLength = function (nums, k) {
+  const n = nums.length
+  const res = Array(k + 1).fill(0)
+  const dp = Array.from({ length: k + 1 }, () => new Map())
+  for (const a of nums) {
+    for (let i = k; i >= 0; i--) {
+      const v = dp[i].get(a) || 0
+      dp[i].set(a, Math.max(v + 1, i > 0 ? res[i - 1] + 1 : 0))
+      res[i] = Math.max(res[i], dp[i].get(a))
+    }
+  }
+
+  return res[k]
+}

From c161a43a60c5a59b3f8a24421c04569059b556a4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 25 Jul 2024 10:32:53 +0800
Subject: [PATCH 3120/3374] Create
 3177-find-the-maximum-length-of-a-good-subsequence-ii.js

---
 ...maximum-length-of-a-good-subsequence-ii.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3177-find-the-maximum-length-of-a-good-subsequence-ii.js

diff --git a/3177-find-the-maximum-length-of-a-good-subsequence-ii.js b/3177-find-the-maximum-length-of-a-good-subsequence-ii.js
new file mode 100644
index 00000000..d5739f7b
--- /dev/null
+++ b/3177-find-the-maximum-length-of-a-good-subsequence-ii.js
@@ -0,0 +1,19 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maximumLength = function(nums, k) {
+  const n = nums.length;
+    const res = Array(k + 1).fill(0);
+    const dp = Array.from({ length: k + 1 }, () => new Map());
+    for (const a of nums) {
+        for (let i = k; i >= 0; i--) {
+            const v = dp[i].get(a) || 0;
+            const vv = Math.max(v + 1, i > 0 ? res[i - 1] + 1 : 0)
+            dp[i].set(a, vv);
+            res[i] = Math.max(res[i], vv);
+        }
+    }
+    return res[k]  
+};

From c1466600c3d127416530111f1cfd4a5c41dcd73f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 26 Jul 2024 13:02:10 +0800
Subject: [PATCH 3121/3374] Update 629-k-inverse-pairs-array.js

---
 629-k-inverse-pairs-array.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/629-k-inverse-pairs-array.js b/629-k-inverse-pairs-array.js
index 4ea54181..e653e9b5 100644
--- a/629-k-inverse-pairs-array.js
+++ b/629-k-inverse-pairs-array.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {number}
+ */
+const kInversePairs = function(n, k) {
+  const mod = 1e9 + 7
+  const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(0))
+  for(let i = 0; i <= n; i++) dp[i][0] = 1
+  for(let i = 2; i <= n; i++) {
+    for(let j = 1; j <= k; j++) {
+        if(j >= i) dp[i][j] = (dp[i - 1][j] + dp[i][j - 1] - dp[i - 1][j - i]) % mod
+        else dp[i][j] = (dp[i - 1][j] + dp[i][j - 1]) % mod
+
+        if(dp[i][j] < 0) dp[i][j] += mod
+    }
+  }
+
+  return dp[n][k]
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number} k

From a918f2d842c8dc2ccf658d563b2076580d8b4b02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 27 Jul 2024 19:57:35 +0800
Subject: [PATCH 3122/3374] Create 3193-count-the-number-of-inversions.js

---
 3193-count-the-number-of-inversions.js | 78 ++++++++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 3193-count-the-number-of-inversions.js

diff --git a/3193-count-the-number-of-inversions.js b/3193-count-the-number-of-inversions.js
new file mode 100644
index 00000000..04abfd9c
--- /dev/null
+++ b/3193-count-the-number-of-inversions.js
@@ -0,0 +1,78 @@
+/**
+ * @param {number} n
+ * @param {number[][]} requirements
+ * @return {number}
+ */
+var numberOfPermutations = function(n, requirements) {
+    // setup map/vector for tracking inversions
+    let inv = new Array(n + 1).fill(-1);
+    for (let req of requirements) {
+        if (inv[req[0] + 1] === -1) {
+            inv[req[0] + 1] = req[1];
+        } else {
+            return 0;
+        }
+    }
+
+    // sanity check
+    // if length of the sequence is l 
+    // then there can be at most l*(l-1)/2 inversion pairs
+    // in the case of decreasing order
+    for (let i = 1; i <= n; i++) {
+        if (inv[i] > (i * (i - 1)) / 2) {
+            return 0;
+        }
+    }
+
+    // dp[len][inv]
+    // solution for the prefix of length len, and inv inversion pairs
+
+    // setup dp
+    const m = 400;
+    const MOD = 1e9 + 7;
+    let dp = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+
+    // base case
+    // i == 0, dp[0][j] = 0, j > 1, in memset
+    // i == 0 && j == 0, dp[0][0] = 1
+    dp[0][0] = 1;
+
+    /*
+    Note:
+    suppose we have a sequence of length (l-1), and we want to extend it to 
+    a sequence of length l, then what can happen to the number of inversion?
+
+    you can increase the number of inversions by at most (l-1).
+
+    so we need to check dp[i-1][j] for dp[i][c]
+    where j = c-0, c-1, ..... , c-(l-1)
+    */
+
+    // recursion
+    for (let i = 1; i <= n; i++) { // length
+        // case 1, we have a requirement given
+        // then just iterate for that value, 
+        if (inv[i] !== -1) {
+            for (let k = 0; k < i; k++) {
+                if (inv[i] - k < 0) break;
+                dp[i][inv[i]] = (dp[i][inv[i]] + dp[i - 1][inv[i] - k]) % MOD;
+            }
+        }
+        // case 2 when we don't have any given requirement
+        // then iterate over all the values
+        else {
+            for (let c = 0; c <= m; c++) {
+                // maximum number of inversions
+                if (c > (i * (i - 1)) / 2) break;
+
+                for (let k = 0; k < i; k++) {
+                    if (c - k < 0) break;
+                    dp[i][c] = (dp[i][c] + dp[i - 1][c - k]) % MOD;
+                }
+            }
+        }
+    }
+
+    // return the ans
+    return dp[n][inv[n]];
+};

From e8041d2bdcacdb081f1ef8af9340e027132de4dc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Jul 2024 15:17:47 +0800
Subject: [PATCH 3123/3374] Create 3232-find-if-digit-game-can-be-won.js

---
 3232-find-if-digit-game-can-be-won.js | 13 +++++++++++++
 1 file changed, 13 insertions(+)
 create mode 100644 3232-find-if-digit-game-can-be-won.js

diff --git a/3232-find-if-digit-game-can-be-won.js b/3232-find-if-digit-game-can-be-won.js
new file mode 100644
index 00000000..01b19f48
--- /dev/null
+++ b/3232-find-if-digit-game-can-be-won.js
@@ -0,0 +1,13 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canAliceWin = function(nums) {
+  const sum = nums.reduce((ac, e) => ac + e, 0)
+  let as = 0
+  for(const e of nums) {
+    if(e < 10) as += e
+  }
+  
+  return as !== sum - as
+};

From d6de59ff65173eebdbf88492098b20c14a2266d0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Jul 2024 15:18:33 +0800
Subject: [PATCH 3124/3374] Create
 3233-find-the-count-of-numbers-which-are-not-special.js

---
 ...-count-of-numbers-which-are-not-special.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 3233-find-the-count-of-numbers-which-are-not-special.js

diff --git a/3233-find-the-count-of-numbers-which-are-not-special.js b/3233-find-the-count-of-numbers-which-are-not-special.js
new file mode 100644
index 00000000..96cb6e7f
--- /dev/null
+++ b/3233-find-the-count-of-numbers-which-are-not-special.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+const nonSpecialCount = function (l, r) {
+  let res = 0
+  for (
+    let i = Math.floor(Math.sqrt(l)) - 10;
+    i <= Math.floor(Math.sqrt(r)) + 10;
+    i++
+  ) {
+    if (isPrime(i) && l <= i * i && i * i <= r) {
+      res += 1
+    }
+  }
+  return r - l + 1 - res
+}
+
+function isPrime(n) {
+  if (n <= 1) {
+    return false
+  }
+  if (n <= 3) {
+    return true
+  }
+  if (n % 2 === 0 || n % 3 === 0) {
+    return false
+  }
+  let i = 5
+  while (i * i <= n) {
+    if (n % i === 0 || n % (i + 2) === 0) {
+      return false
+    }
+    i += 6
+  }
+  return true
+}

From e663b849ab87864b3680e5309844a5d1893c002a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Jul 2024 15:19:03 +0800
Subject: [PATCH 3125/3374] Create
 3234-count-the-number-of-substrings-with-dominant-ones.js

---
 ...number-of-substrings-with-dominant-ones.js | 55 +++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 3234-count-the-number-of-substrings-with-dominant-ones.js

diff --git a/3234-count-the-number-of-substrings-with-dominant-ones.js b/3234-count-the-number-of-substrings-with-dominant-ones.js
new file mode 100644
index 00000000..a285974c
--- /dev/null
+++ b/3234-count-the-number-of-substrings-with-dominant-ones.js
@@ -0,0 +1,55 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var numberOfSubstrings = function(s) {
+    const n = s.length;
+    let result = 0;
+
+    // Iterate through possible zero counts (1 to sqrt(n))
+    for (let k = 1; k <= Math.floor(Math.sqrt(n)); k++) {
+        const zeros = [];  // Array to store positions of zeros
+        let lastzero = -1; // Position of the zero before the first zero in our window
+        let ones = 0;      // Count of ones in our current window
+
+        // Scan through the string
+        for (let right = 0; right < n; right++) {
+            if (s[right] === '0') {
+                zeros.push(right);
+                // If we have more than k zeros, remove the leftmost one
+                while (zeros.length > k) {
+                    ones -= (zeros[0] - lastzero - 1);  // Subtract ones between lastzero and the removed zero
+                    lastzero = zeros.shift();
+                }
+            } else {
+                ones++;
+            }
+
+            // If we have exactly k zeros and at least k^2 ones
+            if (zeros.length === k && ones >= k ** 2) {
+                // Add the minimum of:
+                // 1. Number of ways to extend to the left (zeros[0] - lastzero)
+                // 2. Number of ways to extend to the right (ones - k^2 + 1)
+                result += Math.min(zeros[0] - lastzero, ones - k ** 2 + 1);
+            }
+        }
+    }
+
+    // Handle all-ones substrings
+    let i = 0;
+    while (i < n) {
+        if (s[i] === '0') {
+            i++;
+            continue;
+        }
+        let sz = 0;
+        while (i < n && s[i] === '1') {
+            sz++;
+            i++;
+        }
+        // Add number of all-ones substrings
+        result += (sz * (sz + 1)) / 2;
+    }
+
+    return result;
+};

From 510f462e69e714380509a5d8d3d8ae0351ec3849 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 28 Jul 2024 15:19:31 +0800
Subject: [PATCH 3126/3374] Create
 3235-check-if-the-rectangle-corner-is-reachable.js

---
 ...ck-if-the-rectangle-corner-is-reachable.js | 68 +++++++++++++++++++
 1 file changed, 68 insertions(+)
 create mode 100644 3235-check-if-the-rectangle-corner-is-reachable.js

diff --git a/3235-check-if-the-rectangle-corner-is-reachable.js b/3235-check-if-the-rectangle-corner-is-reachable.js
new file mode 100644
index 00000000..04a3269c
--- /dev/null
+++ b/3235-check-if-the-rectangle-corner-is-reachable.js
@@ -0,0 +1,68 @@
+/**
+ * @param {number} X
+ * @param {number} Y
+ * @param {number[][]} circles
+ * @return {boolean}
+ */
+var canReachCorner = function(X, Y, circles) {
+  let width = X, height = Y
+  const numCircles = circles.length
+  const circleInfo = circles.map((circle) => [circle[0], circle[1], circle[2]])
+  const adjacencyList = Array.from({ length: numCircles + 4 }, () => [])
+
+  for (let i = 0; i < numCircles; i++) {
+    const [x, y, radius] = circleInfo[i]
+
+    if (x - radius <= 0) {
+      adjacencyList[i].push(numCircles)
+      adjacencyList[numCircles].push(i)
+    }
+    if (width - x <= radius) {
+      adjacencyList[i].push(numCircles + 2)
+      adjacencyList[numCircles + 2].push(i)
+    }
+    if (y - radius <= 0) {
+      adjacencyList[i].push(numCircles + 1)
+      adjacencyList[numCircles + 1].push(i)
+    }
+    if (height - y <= radius) {
+      adjacencyList[i].push(numCircles + 3)
+      adjacencyList[numCircles + 3].push(i)
+    }
+
+    for (let j = i + 1; j < numCircles; j++) {
+      const [x2, y2, radius2] = circleInfo[j]
+      const dx = x - x2
+      const dy = y - y2
+      const distanceSquared = dx * dx + dy * dy
+      const radiusSum = radius + radius2
+
+      if (distanceSquared <= radiusSum * radiusSum) {
+        adjacencyList[i].push(j)
+        adjacencyList[j].push(i)
+      }
+    }
+  }
+
+  function bfs(startNode, targetNode1, targetNode2) {
+    const queue = [startNode]
+    const visited = Array(numCircles + 4).fill(0)
+    visited[startNode] = 1
+
+    while (queue.length > 0) {
+      const currentNode = queue.shift()
+      for (const neighbor of adjacencyList[currentNode]) {
+        if (!visited[neighbor]) {
+          visited[neighbor] = 1
+          queue.push(neighbor)
+        }
+      }
+    }
+    return visited[targetNode1] || visited[targetNode2]
+  }
+
+  return !(
+    bfs(numCircles, numCircles + 1, numCircles + 2) ||
+    bfs(numCircles + 3, numCircles + 2, numCircles + 1)
+  )
+};

From 92d166ccb967141b0034d4a9508930a86df9176e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 2 Aug 2024 18:53:12 +0800
Subject: [PATCH 3127/3374] Create
 3209-number-of-subarrays-with-and-value-of-k.js

---
 ...number-of-subarrays-with-and-value-of-k.js | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 3209-number-of-subarrays-with-and-value-of-k.js

diff --git a/3209-number-of-subarrays-with-and-value-of-k.js b/3209-number-of-subarrays-with-and-value-of-k.js
new file mode 100644
index 00000000..9a46894b
--- /dev/null
+++ b/3209-number-of-subarrays-with-and-value-of-k.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var countSubarrays = function (nums, k) {
+  return atLeastK(nums, k) - atLeastK(nums, k + 1)
+}
+
+function atLeastK(nums, k) {
+  let ans = 0
+  let temp = new Array(32).fill(0)
+
+  let l = 0
+  for (let r = 0; r < nums.length; r++) {
+    for (let i = 0; i < 32; i++) {
+      if ((1 << i) & nums[r]) {
+        temp[i]++
+      }
+    }
+
+    while (r - l + 1 > 0 && calc(temp, r - l + 1) < k) {
+      for (let i = 0; i < 32; i++) {
+        if ((1 << i) & nums[l]) {
+          temp[i]--
+        }
+      }
+      l++
+    }
+    ans += r - l + 1
+  }
+
+  return ans
+}
+
+// function to calculate the AND from frequency vector
+function calc(temp, w) {
+  let ans = 0
+  for (let i = 0; i < 32; i++) {
+    if (temp[i] === w) {
+      ans += 1 << i
+    }
+  }
+
+  return ans
+}

From a60ab31926e4928ea155fefb203e5ef312c41edb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 3 Aug 2024 18:16:52 +0800
Subject: [PATCH 3128/3374] Create 2867-count-valid-paths-in-a-tree.js

---
 2867-count-valid-paths-in-a-tree.js | 97 +++++++++++++++++++++++++++++
 1 file changed, 97 insertions(+)
 create mode 100644 2867-count-valid-paths-in-a-tree.js

diff --git a/2867-count-valid-paths-in-a-tree.js b/2867-count-valid-paths-in-a-tree.js
new file mode 100644
index 00000000..519dd339
--- /dev/null
+++ b/2867-count-valid-paths-in-a-tree.js
@@ -0,0 +1,97 @@
+let eratosthenesSieve;
+
+/**
+ * @param {number} n
+ */
+function initEratosthenesSieve(n) {
+  eratosthenesSieve = Array(n + 1).fill(1);
+  eratosthenesSieve[0] = 0;
+  eratosthenesSieve[1] = 0;
+
+  for (let i = 2; i <= n; i++) {
+    if (eratosthenesSieve[i]) {
+      for (let j = 2 * i; j <= n; j += i) {
+        eratosthenesSieve[j] = 0;
+      }
+    }
+  }
+}
+initEratosthenesSieve(100000);
+
+/**
+ * @typedef {{ parent: number, children: number[], p0: number, p1: number, res }} TNode
+ */
+
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var countPaths = function(n, edges) {
+  /** @type {TNode[]} */
+  let nodes = [undefined];
+
+  for (let i = 1; i <= n; i++) nodes.push({ 
+    parent: 0,
+    children: [],
+    p0: 0,
+    p1: 0,
+  });
+
+  for (let [u,v] of edges) {
+    nodes[u].children.push(v);
+    nodes[v].children.push(u);
+  }
+
+  function buildRoot(x, parent) {
+    const node = nodes[x];
+    node.parent = parent;
+
+    for (let c of node.children) {
+      if (c !== parent) buildRoot(c, x)
+    }
+  }
+
+  buildRoot(1);
+  let res = 0;
+
+  function dp(x) {
+    const isPrime = eratosthenesSieve[x];
+    const node = nodes[x];
+    let exc = 0;
+    let cp0 = 0;
+    let cp1 = 0;
+
+    for (let c of node.children) {
+      if (c !== node.parent) {
+        dp(c);
+        let nodeC = nodes[c];
+        cp0 += nodeC.p0;
+        cp1 += nodeC.p1;
+
+        if (isPrime) {
+          exc += nodeC.p0 * (nodeC.p0 - 1) / 2 - nodeC.p0;
+        }
+        else {
+          exc += nodeC.p0 * nodeC.p1;
+        }
+      }
+    }
+
+    if (isPrime) {
+      node.p0 = 0;
+      node.p1 = cp0 + 1;
+      res += cp0 * (cp0 - 1) / 2 - exc;
+    }
+    else {
+      node.p0 = cp0 + 1;
+      node.p1 = cp1;
+      res += (cp0 + 1) * cp1 - exc
+    }
+  }
+  
+  dp(1);
+
+  return res;
+};
+

From 911f8df4858b7b730b7039b6914e2daca3867172 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Aug 2024 17:56:35 +0800
Subject: [PATCH 3129/3374] Create
 2973-find-number-of-coins-to-place-in-tree-nodes.js

---
 ...-number-of-coins-to-place-in-tree-nodes.js | 133 ++++++++++++++++++
 1 file changed, 133 insertions(+)
 create mode 100644 2973-find-number-of-coins-to-place-in-tree-nodes.js

diff --git a/2973-find-number-of-coins-to-place-in-tree-nodes.js b/2973-find-number-of-coins-to-place-in-tree-nodes.js
new file mode 100644
index 00000000..a9a5f44e
--- /dev/null
+++ b/2973-find-number-of-coins-to-place-in-tree-nodes.js
@@ -0,0 +1,133 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[]} cost
+ * @return {number[]}
+ */
+var placedCoins = function (edges, cost) {
+  let tree = buildRootedTree(buildGraph(cost.length, edges), 0)
+  let res = Array(cost.length).fill()
+
+  function solve(root) {
+    let node = tree[root]
+    let c = cost[root]
+
+    if (c > 0) node.max1 = c
+    else node.min1 = c
+
+    for (let child of node.aNodes) {
+      solve(child)
+      let childNode = tree[child]
+      opt(node, childNode.max1)
+      opt(node, childNode.max2)
+      opt(node, childNode.max3)
+      opt(node, childNode.min1)
+      opt(node, childNode.min2)
+      opt(node, childNode.min3)
+    }
+
+    let cnt =
+      !!node.min1 +
+      !!node.min2 +
+      !!node.min3 +
+      !!node.max1 +
+      !!node.max2 +
+      !!node.max3
+    if (cnt < 3) {
+      res[root] = 1
+      return
+    }
+
+    res[root] = 0
+    let v = node.max1 * node.max2 * node.max3
+    if (v > res[root]) res[root] = v
+    v = node.max1 * node.min1 * node.min2
+    if (v > res[root]) res[root] = v
+  }
+
+  solve(0)
+  return res
+}
+
+/**
+ * @typedef {{ aNodes: number[] }} TGraphNode
+ * @param {number} n
+ * @param {[number,number,number?][]} edges
+ * @return {TGraphNode[]}
+ */
+function buildGraph(n, edges) {
+  /** @type {TGraphNode[]} */
+  let nodes = []
+  for (let i = 0; i < n; i++) nodes.push({ aNodes: [] })
+
+  let m = edges.length
+  for (let i = 0; i < m; i++) {
+    let [u, v] = edges[i]
+    nodes[u].aNodes.push(v)
+    nodes[v].aNodes.push(u)
+  }
+
+  return nodes
+}
+
+/**
+ * @typedef {{ parent: number, min1, min2, min3, max1, max2, max3 }} TTreeNode
+ * @param {(TGraphNode & TTreeNode)[]} graph
+ * @param {number} root
+ * @param {number?} parent
+ * @return {(TGraphNode & TTreeNode)[]}
+ */
+function buildRootedTree(graph, root, parent) {
+  let node = graph[root]
+  node.parent = parent
+
+  let m = node.aNodes.length
+  let parentIndex = undefined
+  for (let i = 0; i < m; i++) {
+    if (node.aNodes[i] == parent) parentIndex = i
+    else buildRootedTree(graph, node.aNodes[i], root)
+  }
+
+  if (parentIndex != undefined) {
+    node.aNodes[parentIndex] = node.aNodes[m - 1]
+    node.aNodes.pop()
+  }
+
+  node.max1 = 0
+  node.max2 = 0
+  node.max3 = 0
+  node.min1 = 0
+  node.min2 = 0
+  node.min3 = 0
+  return graph
+}
+
+/**
+ * @param {TTreeNode} node
+ * @param {number} cost
+ */
+function opt(node, cost) {
+  if (!cost) return
+  if (cost > 0) {
+    if (cost >= node.max1) {
+      node.max3 = node.max2
+      node.max2 = node.max1
+      node.max1 = cost
+    } else if (cost >= node.max2) {
+      node.max3 = node.max2
+      node.max2 = cost
+    } else if (cost > node.max3) {
+      node.max3 = cost
+    }
+  } else {
+    if (cost <= node.min1) {
+      node.min3 = node.min2
+      node.min2 = node.min1
+      node.min1 = cost
+    } else if (cost <= node.min2) {
+      node.min3 = node.min2
+      node.min2 = cost
+    } else if (cost < node.min3) {
+      node.min3 = cost
+    }
+  }
+}

From f9e97503e87b11821ae9184f58eaec99fc13398c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 4 Aug 2024 18:05:26 +0800
Subject: [PATCH 3130/3374] Create
 3244-shortest-distance-after-road-addition-queries-ii.js

---
 ...distance-after-road-addition-queries-ii.js | 351 ++++++++++++++++++
 1 file changed, 351 insertions(+)
 create mode 100644 3244-shortest-distance-after-road-addition-queries-ii.js

diff --git a/3244-shortest-distance-after-road-addition-queries-ii.js b/3244-shortest-distance-after-road-addition-queries-ii.js
new file mode 100644
index 00000000..5a992a9c
--- /dev/null
+++ b/3244-shortest-distance-after-road-addition-queries-ii.js
@@ -0,0 +1,351 @@
+/**
+ * @param {number} n
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var shortestDistanceAfterQueries = function(n, queries) {
+    let tree = new SplayTree(), res = [];
+    for (let i = 0; i < n; i++) tree.insert(i);
+    for (const [l, r] of queries) {
+        while (1) {
+            let pre = tree.higher(l);
+            if (pre >= r) break;
+            tree.remove(pre);
+        }
+        res.push(tree.size() - 1);
+    }
+    return res;
+};
+
+///////////////////////// Template //////////////////////////////
+class SplayNode {
+    constructor(value) {
+        this.parent = null;
+        this.left = null;
+        this.right = null;
+        this.val = value;
+        this.sum = value;
+        this.sz = 1;
+    }
+    update() {
+        this.sz = (this.left != null ? this.left.sz : 0) + (this.right != null ? this.right.sz : 0) + 1;
+        this.sum = (this.left != null ? this.left.sum : 0) + (this.right != null ? this.right.sum : 0) + this.val;
+    }
+    isLeft() {
+        return this.parent != null && this.parent.left == this;
+    }
+    isRight() {
+        return this.parent != null && this.parent.right == this;
+    }
+    isRoot(guard = null) {
+        return this.parent == guard;
+    }
+}
+
+// MultiSet
+class SplayTree {
+    constructor() {
+        this.root = null;
+        this.cmp = (x, y) => x >= y ? 0 : 1;
+    }
+    zig(x) { // right rotation
+        let y = x.parent;
+        if (x.right != null) x.right.parent = y;
+        y.left = x.right;
+        x.right = y;
+        if (y.isLeft()) {
+            y.parent.left = x;
+        } else if (y.isRight()) {
+            y.parent.right = x;
+        }
+        x.parent = y.parent;
+        y.parent = x;
+        y.update();
+        x.update();
+    }
+    zag(x) { // left rotation
+        let y = x.parent;
+        if (x.left != null) x.left.parent = y;
+        y.right = x.left;
+        x.left = y;
+        if (y.isLeft()) {
+            y.parent.left = x;
+        } else if (y.isRight()) {
+            y.parent.right = x;
+        }
+        x.parent = y.parent;
+        y.parent = x;
+        y.update();
+        x.update();
+    }
+    zigzig(x) { // RR
+        this.zig(x.parent);
+        this.zig(x);
+    }
+    zigzag(x) { // RL
+        this.zig(x);
+        this.zag(x);
+    }
+    zagzag(x) { // LL
+        this.zag(x.parent);
+        this.zag(x);
+    }
+    zagzig(x) { // LR
+        this.zag(x);
+        this.zig(x);
+    }
+    splay(node, guard = null) { // splay node under guard, default splay to root
+        while (!node.isRoot(guard)) {
+            if (node.parent.isRoot(guard)) {
+                if (node.isLeft()) {
+                    this.zig(node);
+                } else {
+                    this.zag(node);
+                }
+            } else {
+                if (node.parent.isLeft()) {
+                    if (node.isLeft()) {
+                        this.zigzig(node);
+                    } else {
+                        this.zagzig(node);
+                    }
+                } else {
+                    if (node.isRight()) {
+                        this.zagzag(node);
+                    } else {
+                        this.zigzag(node);
+                    }
+                }
+            }
+        }
+        if (guard == null) this.root = node;
+    }
+    LastNode(x) {
+        this.splay(x);
+        let node = x.left;
+        if (node == null) return null;
+        while (node.right != null) node = node.right;
+        this.splay(node);
+        return node;
+    }
+    NextNode(x) {
+        this.splay(x);
+        let node = x.right;
+        if (node == null) return null;
+        while (node.left != null) node = node.left;
+        this.splay(node);
+        return node;
+    }
+    find(value) {
+        return this.findFirstOf(value);
+    }
+    findFirstOf(value) {
+        let node = this.root, res = null, last_visited = null;
+        while (node != null) {
+            last_visited = node;
+            if (this.cmp(value, node.val)) {
+                node = node.left;
+            } else if (this.cmp(node.val, value)) {
+                node = node.right;
+            } else {
+                res = node;
+                node = node.left;
+            }
+        }
+        if (last_visited != null) this.splay(last_visited);
+        return res;
+    }
+    findLastOf(value) {
+        let node = this.root, res = null, last_visited = null;
+        while (node != null) {
+            last_visited = node;
+            if (this.cmp(value, node.val)) {
+                node = node.left;
+            } else if (this.cmp(node.val, value)) {
+                node = node.right;
+            } else {
+                res = node;
+                node = node.right;
+            }
+        }
+        if (last_visited != null) this.splay(last_visited);
+        return res;
+    }
+    findRankOf(node) {
+        this.splay(node);
+        return node.left == null ? 0 : node.left.sz;
+    }
+    findSuccessorOf(value) {
+        let node = this.root, res = null, last_visited = null;
+        while (node != null) {
+            last_visited = node;
+            if (this.cmp(value, node.val)) {
+                res = node;
+                node = node.left;
+            } else {
+                node = node.right;
+            }
+        }
+        if (last_visited != null) this.splay(last_visited);
+        return res;
+    }
+    findPrecursorOf(value) {
+        let node = this.root, res = null, last_visited = null;
+        while (node != null) {
+            last_visited = node;
+            if (this.cmp(node.val, value)) {
+                res = node;
+                node = node.right;
+            } else {
+                node = node.left;
+            }
+        }
+        if (last_visited != null) this.splay(last_visited);
+        return res;
+    }
+    findKthNode(rank) {
+        if (rank < 0 || rank >= this.size()) return null;
+        let node = this.root;
+        while (node != null) {
+            let leftsize = node.left == null ? 0 : node.left.sz;
+            if (leftsize == rank) break;
+            if (leftsize > rank) {
+                node = node.left;
+            } else {
+                rank -= leftsize + 1;
+                node = node.right;
+            }
+        }
+        this.splay(node);
+        return node;
+    }
+    make(value) {
+        return new SplayNode(value);
+    }
+    removeNode(node) {
+        node = null;
+    }
+
+    // -------------------------------- Public Usage --------------------------------------
+    insert(value) { // allow duplicates  LST.set()
+        if (this.root == null) {
+            this.root = this.make(value);
+            return this.root;
+        }
+        let node = this.root;
+        while (node != null) {
+            if (this.cmp(value, node.val)) {
+                if (node.left == null) {
+                    node.left = this.make(value);
+                    node.left.parent = node;
+                    node = node.left;
+                    break;
+                }
+                node = node.left;
+            } else {
+                if (node.right == null) {
+                    node.right = this.make(value);
+                    node.right.parent = node;
+                    node = node.right;
+                    break;
+                }
+                node = node.right;
+            }
+        }
+        this.splay(node);
+        return node;
+    }
+    remove(value) { // remove one node, not all   LST.unset()
+        let node = this.find(value);
+        if (node == null) return false;
+        this.splay(node);
+        if (node.left == null) {
+            this.root = node.right;
+            if (node.right != null) node.right.parent = null;
+            this.removeNode(node);
+            return true;
+        }
+        if (node.right == null) {
+            this.root = node.left;
+            if (node.left != null) node.left.parent = null;
+            this.removeNode(node);
+            return true;
+        }
+        let last_node = this.LastNode(node);
+        let next_node = this.NextNode(node);
+        this.splay(last_node);
+        this.splay(next_node, last_node);
+        this.removeNode(next_node.left);
+        next_node.left = null;
+        next_node.update();
+        last_node.update();
+        return true;
+    }
+    has(value) { // LST.get()
+        return this.count(value) > 0;
+    }
+    count(value) {
+        let x = this.findFirstOf(value);
+        if (x == null) return 0;
+        let rank_x = this.findRankOf(x);
+        let y = this.findLastOf(value);
+        let rank_y = this.findRankOf(y);
+        return rank_y - rank_x + 1;
+    }
+    rankOf(value) { // The number of elements strictly less than value
+        let x = this.findPrecursorOf(value);
+        return x == null ? 0 : this.findRankOf(x) + 1;
+    }
+    findKth(rank) { // (0-indexed)
+        let x = this.findKthNode(rank);
+        return x == null ? null : (x.val);
+    }
+    higher(value) { // > upper_bound()
+        let node = this.findSuccessorOf(value);
+        return node == null ? null : (node.val);
+    }
+    lower(value) { // < 
+        let node = this.findPrecursorOf(value);
+        return node == null ? null : (node.val);
+    }
+    ceiling(value) { // >= lower_bound()  LST.next(value)
+        return this.has(value) ? value : this.higher(value);
+    }
+    floor(value) { // <=                  LST.prev(value)
+        return this.has(value) ? value : this.lower(value);
+    }
+    first() {
+        return this.findKth(0);
+    }
+    last() {
+        return this.findKth(this.size() - 1);
+    }
+    poll() {
+        let res = this.first();
+        this.remove(res);
+        return res;
+    }
+    pollLast() {
+        let res = this.last();
+        this.remove(res);
+        return res;
+    }
+    size() {
+        return this.root == null ? 0 : this.root.sz;
+    }
+    isEmpty() {
+        return this.root == null;
+    }
+    show() {
+        let res = [];
+        const dfs = (x) => {
+            if (x == null) return;
+            dfs(x.left);
+            res.push(x.val);
+            dfs(x.right);
+        };
+        dfs(this.root);
+        return res;
+    }
+}
+

From 04a300d694bfcf79814162810f46f13d0787208f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Aug 2024 12:14:09 +0800
Subject: [PATCH 3131/3374] Update
 3203-find-minimum-diameter-after-merging-two-trees.js

---
 ...inimum-diameter-after-merging-two-trees.js | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/3203-find-minimum-diameter-after-merging-two-trees.js b/3203-find-minimum-diameter-after-merging-two-trees.js
index 78df2dd8..99d3cb1a 100644
--- a/3203-find-minimum-diameter-after-merging-two-trees.js
+++ b/3203-find-minimum-diameter-after-merging-two-trees.js
@@ -45,3 +45,55 @@ var minimumDiameterAfterMerge = function (edges1, edges2) {
   const radius2 = Math.floor((diameter2 + 1) / 2)
   return Math.max(radius1 + radius2 + 1, diameter1, diameter2)
 }
+
+// another
+
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @return {number}
+ */
+var minimumDiameterAfterMerge = function(edges1, edges2) {
+    const [d1, i, j] = diameter(edges1);
+    const [d2, ii, jj] = diameter(edges2);
+    return Math.max(d1, d2, Math.floor((d1 + 1) / 2) + Math.floor((d2 + 1) / 2) + 1); 
+    function farthest(G, i) {
+        const n = G.length;
+        const bfs = [i];
+        const seen = new Array(n).fill(0);
+        seen[i] = 1;
+        let res = -1;
+        let maxd = -1;
+        for (let k = 0; k < bfs.length; k++) {
+            const node = bfs[k];
+            for (let j = 0; j < G[node].length; j++) {
+                const neighbor = G[node][j];
+                if (seen[neighbor] === 0) {
+                    seen[neighbor] = seen[node] + 1;
+                    bfs.push(neighbor);
+                    if (seen[neighbor] > maxd) {
+                        res = neighbor;
+                        maxd = seen[neighbor];
+                    }
+                }
+            }
+        }
+        return [res, maxd - 1];
+    }
+
+    function diameter(edges) {
+        if (edges.length === 0) {
+            return [0, 0, 0];
+        }
+        const n = edges.length + 1;
+        const G = Array.from({ length: n }, () => []);
+        for (let k = 0; k < edges.length; k++) {
+            const [i, j] = edges[k];
+            G[i].push(j);
+            G[j].push(i);
+        }
+        let [v1, d] = farthest(G, 0);
+        [v1, d] = farthest(G, v1);
+        return [d, v1, v1];
+    }
+};

From 0f9582e1e30f37a94e30541ada62496c4b35988e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 6 Aug 2024 13:03:54 +0800
Subject: [PATCH 3132/3374] Update
 3203-find-minimum-diameter-after-merging-two-trees.js

---
 3203-find-minimum-diameter-after-merging-two-trees.js | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/3203-find-minimum-diameter-after-merging-two-trees.js b/3203-find-minimum-diameter-after-merging-two-trees.js
index 99d3cb1a..c6d788b9 100644
--- a/3203-find-minimum-diameter-after-merging-two-trees.js
+++ b/3203-find-minimum-diameter-after-merging-two-trees.js
@@ -57,13 +57,14 @@ var minimumDiameterAfterMerge = function(edges1, edges2) {
     const [d1, i, j] = diameter(edges1);
     const [d2, ii, jj] = diameter(edges2);
     return Math.max(d1, d2, Math.floor((d1 + 1) / 2) + Math.floor((d2 + 1) / 2) + 1); 
+
     function farthest(G, i) {
         const n = G.length;
         const bfs = [i];
         const seen = new Array(n).fill(0);
         seen[i] = 1;
-        let res = -1;
-        let maxd = -1;
+        let res = 0;
+        let maxd = 0;
         for (let k = 0; k < bfs.length; k++) {
             const node = bfs[k];
             for (let j = 0; j < G[node].length; j++) {
@@ -93,7 +94,8 @@ var minimumDiameterAfterMerge = function(edges1, edges2) {
             G[j].push(i);
         }
         let [v1, d] = farthest(G, 0);
-        [v1, d] = farthest(G, v1);
-        return [d, v1, v1];
+        let [v2, d2] = farthest(G, v1);
+        return [d2, v1, v2];
     }
 };
+

From f4d3a0f89e1204d3724dce074b3a5b21fc120789 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 8 Aug 2024 15:25:55 +0800
Subject: [PATCH 3133/3374] Update 662-maximum-width-of-binary-tree.js

---
 662-maximum-width-of-binary-tree.js | 34 +++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/662-maximum-width-of-binary-tree.js b/662-maximum-width-of-binary-tree.js
index 7f457617..9c8f8874 100644
--- a/662-maximum-width-of-binary-tree.js
+++ b/662-maximum-width-of-binary-tree.js
@@ -1,3 +1,37 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val, left, right) {
+ *     this.val = (val===undefined ? 0 : val)
+ *     this.left = (left===undefined ? null : left)
+ *     this.right = (right===undefined ? null : right)
+ * }
+ */
+/**
+ * @param {TreeNode} root
+ * @return {number}
+ */
+const widthOfBinaryTree = function (root) {
+  let max = 1n
+  const stack = []
+  const bi = BigInt
+  const width = (root, level, pos) => {
+    if (root == null) return
+    if (level >= stack.length) stack.push(pos)
+    else {
+      // console.log(stack)
+      const tmp = pos - stack[level] + 1n
+      if(tmp > max) max = tmp
+    }
+    width(root.left, level + 1, 2n * pos)
+    width(root.right, level + 1, 2n * pos + 1n)
+  }
+  width(root, 0, 1n)
+  return Number(max)
+}
+
+
+// another
+
 /**
  * Definition for a binary tree node.
  * function TreeNode(val) {

From 36d3b43d56e13cb3922cf22fcfb5c541342b45f6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 Aug 2024 20:59:04 +0800
Subject: [PATCH 3134/3374] Update 3213-construct-string-with-minimum-cost.js

---
 3213-construct-string-with-minimum-cost.js | 124 +++++++++++++++------
 1 file changed, 87 insertions(+), 37 deletions(-)

diff --git a/3213-construct-string-with-minimum-cost.js b/3213-construct-string-with-minimum-cost.js
index 0b505d8a..cb8cf652 100644
--- a/3213-construct-string-with-minimum-cost.js
+++ b/3213-construct-string-with-minimum-cost.js
@@ -88,67 +88,117 @@ class AhoCorasick {
   }
 }
 
+// another
 
+class TrieNode {
+  constructor() {
+    this.sfx = null // Suffix link
+    this.dict = null // Dictionary link
+    this.child = new Array(26).fill(null)
+    this.word_id = -1 // Index of the word ending at this node
+  }
+}
+// Speeds up Trie construction
+const preallocated_nodes = Array.from({ length: 50005 }, () => new TrieNode())
 
-
-// TLE below
-
-const mx = 1000000000
 /**
  * @param {string} target
  * @param {string[]} words
  * @param {number[]} costs
  * @return {number}
  */
-var minimumCost = function (target, words, costs) {
+function minimumCost(target, words, costs) {
+  const trie = new Trie(words, costs)
   const n = target.length
-  const dp = new Array(n + 1).fill(mx)
-  const t = new Trie(30)
+  const dp = new Array(n + 1).fill(Infinity)
+  dp[0] = 0
 
-  for (let i = 0; i < words.length; i++) {
-    t.insert(words[i], costs[i])
+  for (let i = 1; i <= n; ++i) {
+    const suffixes = trie.suffixesAfterAppending(target[i - 1])
+    for (const j of suffixes) {
+      dp[i] = Math.min(dp[i], dp[i - words[j].length] + costs[j])
+    }
   }
 
-  dp[n] = 0
+  return dp[n] === Infinity ? -1 : dp[n]
+}
 
-  for (let i = n - 1; i >= 0; i--) {
-    let cur = t
-    for (let j = i; j <= n && cur !== null; j++) {
-      if (cur.cost !== mx) {
-        dp[i] = Math.min(dp[j] + cur.cost, dp[i])
+class Trie {
+  constructor(words, costs) {
+    this.count = 0
+    this.root = this.newTrieNode()
+    this.root.sfx = this.root.dict = this.root
+
+    for (let i = 0; i < words.length; ++i) {
+      const word = words[i]
+      let u = this.root
+      for (const c of word) {
+        const index = c.charCodeAt(0) - 'a'.charCodeAt(0)
+        if (!u.child[index]) {
+          u.child[index] = this.newTrieNode()
+        }
+        u = u.child[index]
       }
-      if (j < n) {
-        cur = cur.sons[target.charCodeAt(j) - 'a'.charCodeAt(0)]
+      if (u.word_id < 0 || costs[i] < costs[u.word_id]) {
+        u.word_id = i
       }
     }
-  }
 
-  return dp[0] === mx ? -1 : dp[0]
-}
+    // BFS is used to set up the suffix and dictionary links for each node
+    // The suffix link of a node points to the longest proper suffix of the word represented by the node that is also a prefix of some word in the dictionary.
+    // The dictionary link is used to quickly find the next node in the dictionary chain.
+    const queue = [this.root]
+    while (queue.length > 0) {
+      const u = queue.shift()
+      for (let i = 0; i < 26; ++i) {
+        const v = u.child[i]
+        if (!v) continue
+
+        let p = u.sfx
+        while (p !== this.root && !p.child[i]) {
+          p = p.sfx
+        }
 
-class Trie {
-  constructor(range) {
-    this.range = range
-    this.cost = mx
-    this.sons = new Array(range).fill(null)
-  }
+        if (u !== this.root && p.child[i]) {
+          v.sfx = p.child[i]
+        } else {
+          v.sfx = this.root
+        }
 
-  insert(str, cost) {
-    let cur = this
-    for (let c of str) {
-      if (cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)] === null) {
-        cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)] = new Trie(this.range)
+        v.dict = v.sfx.word_id >= 0 ? v.sfx : v.sfx.dict
+        queue.push(v)
       }
-      cur = cur.sons[c.charCodeAt(0) - 'a'.charCodeAt(0)]
     }
-    cur.cost = Math.min(cur.cost, cost)
+    this.curr = this.root
   }
 
-  destroy() {
-    for (let t of this.sons) {
-      if (t !== null) {
-        t.destroy()
+  newTrieNode() {
+    preallocated_nodes[this.count] = new TrieNode()
+    return preallocated_nodes[this.count++]
+  }
+
+  // This method is used to update the current node and find all matching suffixes after appending a character
+  suffixesAfterAppending(letter) {
+    const index = letter.charCodeAt(0) - 'a'.charCodeAt(0)
+
+    // It follows suffix links until it finds a child node corresponding to the character or reaches the root.
+    while (this.curr !== this.root && !this.curr.child[index]) {
+      this.curr = this.curr.sfx
+    }
+
+    // If a valid child node is found, it updates the current node and collects all word IDs reachable through the dictionary links.
+    const result = []
+    if (this.curr.child[index]) {
+      this.curr = this.curr.child[index]
+      let u = this.curr
+      if (u.word_id < 0) {
+        u = u.dict
+      }
+      while (u.word_id >= 0) {
+        result.push(u.word_id)
+        u = u.dict
       }
     }
+    return result
   }
 }

From 4f3155c05a5495d62742a9952675ee7dfb9ca625 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 14 Aug 2024 13:22:27 +0800
Subject: [PATCH 3135/3374] Update
 1674-minimum-moves-to-make-array-complementary.js

---
 ...nimum-moves-to-make-array-complementary.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/1674-minimum-moves-to-make-array-complementary.js b/1674-minimum-moves-to-make-array-complementary.js
index c257d2e2..3c5243ef 100644
--- a/1674-minimum-moves-to-make-array-complementary.js
+++ b/1674-minimum-moves-to-make-array-complementary.js
@@ -116,4 +116,31 @@ const minMoves = function (nums, limit) {
   return res
 }
 
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} limit
+ * @return {number}
+ */
+const minMoves = function(nums, limit) {
+  const n = nums.length
+  const arr = Array(2 * limit + 2).fill(0)
+  for(let i = 0; i < n / 2; i++) {
+    const a = nums[i], b = nums[n - 1 - i]
+    const l = Math.min(a, b), r = Math.max(a, b)
+    arr[l + 1]--
+    arr[l + r]--
+    arr[l + r + 1]++
+    arr[r + limit + 1]++
+  }
+  let res = n, cur = n
+  for(let e of arr) {
+    cur += e
+    res = Math.min(res, cur)
+  }
+  
+  return res
+};
+
 

From 5581777febe9b1662cef1e80d174b494c9ef6fc5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 15 Aug 2024 11:37:33 +0800
Subject: [PATCH 3136/3374] Create
 3224-minimum-array-changes-to-make-differences-equal.js

---
 ...array-changes-to-make-differences-equal.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 3224-minimum-array-changes-to-make-differences-equal.js

diff --git a/3224-minimum-array-changes-to-make-differences-equal.js b/3224-minimum-array-changes-to-make-differences-equal.js
new file mode 100644
index 00000000..52dce081
--- /dev/null
+++ b/3224-minimum-array-changes-to-make-differences-equal.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minChanges = function(nums, k) {
+  const n = nums.length
+  const arr = Array(1e5 + 1).fill(0)
+  for(let i = 0; i < n /2; i++) {
+    const a = nums[i], b = nums[n - 1 - i]
+    const l = Math.min(a, b), r = Math.max(a, b)
+    const maxDiff = Math.max(l, r, k - l)
+    arr[0]--
+    arr[r - l]--
+    arr[r - l + 1]++
+    arr[maxDiff + 1]++
+  }
+  let res = n, cur = n
+  for(const e of arr) {
+    cur += e
+    res = Math.min(res, cur)
+  }
+  return res
+};

From 1403e6348e93af51c7e27926313d41dfafc59c8e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 16 Aug 2024 12:17:42 +0800
Subject: [PATCH 3137/3374] Update 834-sum-of-distances-in-tree.js

---
 834-sum-of-distances-in-tree.js | 41 +++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/834-sum-of-distances-in-tree.js b/834-sum-of-distances-in-tree.js
index 673af449..2e4df1d7 100644
--- a/834-sum-of-distances-in-tree.js
+++ b/834-sum-of-distances-in-tree.js
@@ -1,3 +1,44 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var sumOfDistancesInTree = function(n, edges) {
+  const res = new Array(n).fill(0);
+  const count = new Array(n).fill(1);
+  const graph = Array.from({ length: n }, () => []);
+    for (const [u, v] of edges) {
+        graph[u].push(v);
+        graph[v].push(u);
+    }
+    dfs1(0, -1);
+    dfs2(0, -1);
+
+  return res
+
+  function dfs1(node, parent) {
+    for (const child of graph[node]) {
+      if (child === parent) {
+        continue;
+      }
+      dfs1(child, node);
+      count[node] += count[child];
+      res[node] += res[child] + count[child];
+    }
+  }
+  function dfs2(node, parent) {
+    for (const child of graph[node]) {
+      if (child === parent) {
+        continue;
+      }
+      res[child] = res[node] - count[child] + n - count[child];
+      dfs2(child, node);
+    }
+  }
+};
+
+// another
+
 /**
  * @param {number} N
  * @param {number[][]} edges

From e18939edb5ae63fc19659f805efdb590a70d87d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 Aug 2024 13:07:46 +0800
Subject: [PATCH 3138/3374] Create 3241-time-taken-to-mark-all-nodes.js

---
 3241-time-taken-to-mark-all-nodes.js | 66 ++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 3241-time-taken-to-mark-all-nodes.js

diff --git a/3241-time-taken-to-mark-all-nodes.js b/3241-time-taken-to-mark-all-nodes.js
new file mode 100644
index 00000000..d5268745
--- /dev/null
+++ b/3241-time-taken-to-mark-all-nodes.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var timeTaken = function(edges) {
+    let n = edges.length + 1;
+    let adj = Array.from({ length: n }, () => []);
+    for (let edge of edges) {
+        adj[edge[0]].push(edge[1]);
+        adj[edge[1]].push(edge[0]);
+    }
+
+    // first, use 0 as root and calculate below:
+    // far1[i]: the farthest children for the subtree with root i
+    // far2[i]: the second farthest children for the subtree with root i
+    let far1 = Array(n).fill(0);
+    let far2 = Array(n).fill(0);
+    buildFar(0, adj, far1, far2);
+
+    // by far1 and far2, we can use re-rooting to help us find the answer
+    let ans = Array(n).fill(0);
+    calcOthers(0, 0, adj, far1, far2, ans);
+
+    return ans;
+};
+
+function buildFar(curr, adj, far1, far2) {
+    let maxChild1 = 0, maxChild2 = 0;
+    // Iterate through each child (branch), and find the two farthest children.
+    for (let child of adj[curr]) {
+        if (child <= curr) continue;
+
+        buildFar(child, adj, far1, far2);
+        let dist = ((child & 1) ? 1 : 2) + far1[child];
+        if (dist >= maxChild1) {
+            maxChild2 = maxChild1;
+            maxChild1 = dist;
+        } else if (dist > maxChild2) {
+            maxChild2 = dist;
+        }
+    }
+
+    far1[curr] = maxChild1;
+    far2[curr] = maxChild2;
+}
+
+function calcOthers(curr, parentDist, adj, far1, far2, ans) {
+    // parentDist: the farthest distance when node[parent] is the root
+
+    ans[curr] = Math.max(parentDist, far1[curr]);
+
+    for (let child of adj[curr]) {
+        if (child < curr) continue;
+
+        let toParent = (curr & 1) ? 1 : 2;
+        let toChild = (child & 1) ? 1 : 2;
+        // For this child, exclude itself or it is not correct
+        // (If the branch containing this child is the farthest for node curr, we should use the second farthest)
+        let farthestChildExceptThisChild = (far1[curr] === (toChild + far1[child])) ? far2[curr] : far1[curr];
+
+        calcOthers(child, toParent + Math.max(parentDist, farthestChildExceptThisChild), adj, far1, far2, ans);
+    }
+}
+
+
+

From 3bbddffca52d98991c56cecd1111422c5d441715 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 Aug 2024 16:17:08 +0800
Subject: [PATCH 3139/3374] Update
 1707-maximum-xor-with-an-element-from-array.js

---
 ...-maximum-xor-with-an-element-from-array.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/1707-maximum-xor-with-an-element-from-array.js b/1707-maximum-xor-with-an-element-from-array.js
index f33846b8..b7104d10 100644
--- a/1707-maximum-xor-with-an-element-from-array.js
+++ b/1707-maximum-xor-with-an-element-from-array.js
@@ -1,3 +1,65 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var maximizeXor = function(nums, queries) {
+    nums.sort((a, b) => a - b)
+    const n = nums.length
+    queries.forEach((query, index) => {
+        query.push(index)
+    })
+    queries.sort((a, b) => a[1] - b[1])
+    const trie = new Trie()
+    let i = 0
+    const res = []
+    queries.forEach(([x, m, index]) => {
+        while (i < n && nums[i] <= m) {
+            trie.insert(nums[i])
+            i++
+        }
+
+        res[index] = trie.query(x)
+        
+    })
+    return res
+};
+
+class Trie {
+    constructor() {
+        this.root = {}
+    }
+    insert(num) {
+        let node = this.root
+        for (let i = 31; i >= 0; i--) {
+            const bit = (num >> i) & 1
+            if (!node[bit]) {
+                node[bit] = {}
+            }
+            node = node[bit]
+        }
+    }
+    query(num) {
+        let node = this.root
+        if (Object.keys(node).length === 0) return -1
+        let res = 0
+        for (let i = 31; i >= 0; i--) {
+            const bit = (num >> i) & 1
+            if(node == null) break
+            if (node[1 - bit]) {
+                res |= 1 << i
+                node = node[1 - bit]
+            } else {
+              node = node[bit]
+            }
+        }
+        return res
+    }
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number[][]} queries

From ae7d047e485e7d1ef50f944a59d3cf4f587b1a95 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 25 Aug 2024 19:34:16 +0800
Subject: [PATCH 3140/3374] Create
 3261-count-substrings-that-satisfy-k-constraint-ii.js

---
 ...substrings-that-satisfy-k-constraint-ii.js | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 3261-count-substrings-that-satisfy-k-constraint-ii.js

diff --git a/3261-count-substrings-that-satisfy-k-constraint-ii.js b/3261-count-substrings-that-satisfy-k-constraint-ii.js
new file mode 100644
index 00000000..2d536e71
--- /dev/null
+++ b/3261-count-substrings-that-satisfy-k-constraint-ii.js
@@ -0,0 +1,72 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var countKConstraintSubstrings = function(s, k, queries) {
+    let binaryString = s, maxZerosOnes = k, queriesList = queries
+    let length = binaryString.length;
+    let zeroPrefixSum = Array(length + 1).fill(0);
+
+    for (let idx = 0; idx < length; idx++) {
+        zeroPrefixSum[idx + 1] = (binaryString[idx] === '0' ? 1 : 0) + zeroPrefixSum[idx];
+    }
+
+    let endIndex = Array(length).fill(0);
+
+    for (let start = 0; start < length; start++) {
+        let end = start;
+        let low = start, high = length - 1;
+
+        while (low <= high) {
+            let mid = low + Math.floor((high - low) / 2);
+            let zeroCount = zeroPrefixSum[mid + 1] - zeroPrefixSum[start];
+            let oneCount = mid + 1 - start - zeroCount;
+
+            if (zeroCount <= maxZerosOnes || oneCount <= maxZerosOnes) {
+                end = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+        endIndex[start] = end;
+    }
+
+    for (let i = 0; i < length; i++) {
+        zeroPrefixSum[i + 1] = (endIndex[i] - i + 1) + zeroPrefixSum[i];
+    }
+
+    let results = [];
+
+    /* Template by Bharadwaj ( LEETCODE JAVASCRIPT ) */
+    /* Youtube : https://youtube.com/@code-with-Bharadwaj */
+    /* Portfolio : https://manu-bharadwaj-portfolio.vercel.app/ */
+
+    for (let query of queriesList) {
+        let left = query[0];
+        let right = query[1];
+        let validIndex = left - 1;
+        let low = left, high = right;
+        let totalCount = 0;
+
+        while (low <= high) {
+            let mid = low + Math.floor((high - low) / 2);
+
+            if (endIndex[mid] < right) {
+                validIndex = mid;
+                low = mid + 1;
+            } else {
+                high = mid - 1;
+            }
+        }
+
+        totalCount += zeroPrefixSum[validIndex + 1] - zeroPrefixSum[left];
+        let difference = right - validIndex;
+        totalCount += (difference * (difference + 1)) / 2;
+        results.push(totalCount);
+    }
+
+    return results;
+};

From cad1ed69467f99c8eaf6041359c4c86feab5ce7e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 28 Aug 2024 13:56:18 +0800
Subject: [PATCH 3141/3374] Update 907-sum-of-subarray-minimums.js

---
 907-sum-of-subarray-minimums.js | 35 +++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/907-sum-of-subarray-minimums.js b/907-sum-of-subarray-minimums.js
index 52e0a139..ffb2c2a1 100644
--- a/907-sum-of-subarray-minimums.js
+++ b/907-sum-of-subarray-minimums.js
@@ -67,3 +67,38 @@ const sumSubarrayMins = function (arr) {
 
   return res
 }
+
+// another
+
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+const sumSubarrayMins = function(arr) {
+  const stk1 = [], stk2 = []
+    const len = arr.length, mod = 1e9 + 7
+    const left = new Array(len), right = new Array(len)
+    for(let i = 0; i < len; i++) {
+        left[i] = i + 1
+        right[i] = len - i
+    }
+    for(let i = 0; i < len; i++) {
+        while(stk1.length && arr[stk1[stk1.length - 1]] > arr[i]) {
+            stk1.pop()
+        }
+        left[i] = i - (stk1.length ? stk1[stk1.length - 1] : -1)
+        stk1.push(i)
+
+        while(stk2.length && arr[stk2[stk2.length - 1]] > arr[i]) {
+            let index = stk2.pop()
+            right[index] = i - index
+        }
+        stk2.push(i)
+    }
+
+    let res = 0
+    for(let i = 0; i < len; i++) {
+        res = (res + arr[i] * left[i] * right[i]) % mod
+    }
+    return res
+};

From 2602592b0af90d98917cbc7c63f5628749227ceb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Sep 2024 17:04:05 +0800
Subject: [PATCH 3142/3374] Create
 2972-count-the-number-of-incremovable-subarrays-ii.js

---
 ...the-number-of-incremovable-subarrays-ii.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 2972-count-the-number-of-incremovable-subarrays-ii.js

diff --git a/2972-count-the-number-of-incremovable-subarrays-ii.js b/2972-count-the-number-of-incremovable-subarrays-ii.js
new file mode 100644
index 00000000..e21dcf60
--- /dev/null
+++ b/2972-count-the-number-of-incremovable-subarrays-ii.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var incremovableSubarrayCount = function(nums) {
+  let n = nums.length;
+  let l = 0;
+  while (nums[l + 1] > nums[l]) ++l;
+  if (l + 1 == n) return (n * (n + 1)) / 2;
+
+  let res = l + 2;
+  let r = n;
+  do {
+    --r;
+    while (l >= 0 && nums[l] >= nums[r]) --l;
+    res += l + 2
+  }
+  while (nums[r] > nums[r-1])
+
+  return res;
+};

From 6dc38794f4807a783fc05356ce160c848263d765 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Sep 2024 18:02:12 +0800
Subject: [PATCH 3143/3374] Create
 3283-maximum-number-of-moves-to-kill-all-pawns.js

---
 ...ximum-number-of-moves-to-kill-all-pawns.js | 126 ++++++++++++++++++
 1 file changed, 126 insertions(+)
 create mode 100644 3283-maximum-number-of-moves-to-kill-all-pawns.js

diff --git a/3283-maximum-number-of-moves-to-kill-all-pawns.js b/3283-maximum-number-of-moves-to-kill-all-pawns.js
new file mode 100644
index 00000000..228f3afb
--- /dev/null
+++ b/3283-maximum-number-of-moves-to-kill-all-pawns.js
@@ -0,0 +1,126 @@
+/**
+ * @param {number} kx
+ * @param {number} ky
+ * @param {number[][]} positions
+ * @return {number}
+ */
+var maxMoves = function (kx, ky, positions) {
+  //alice goes first
+  //alice wants to maximize result
+
+  //add the starting position
+  positions.unshift([kx, ky])
+
+  let dp = new Float64Array(positions.length * 2 ** positions.length)
+  let degreesBetweenPawnPairs = new Float64Array(
+    positions.length * positions.length,
+  )
+
+  computeAllDegreesBetweenPawns()
+
+  //if the mask is equal to this, we've visited all pawns
+  let targetMask = (1 << positions.length) - 1
+
+  //alice starts, so we set maximize to true
+  return dfs(0, true, 1)
+
+  function dfs(pawn1Idx, maximize, mask) {
+    if (mask === targetMask) {
+      return 0
+    }
+
+    let dpIdx = pawn1Idx * 2 ** positions.length + mask
+    if (dp[dpIdx] > 0) {
+      return dp[dpIdx] - 1
+    }
+
+    let best = Infinity
+    let worst = 0
+
+    for (let pawn2Idx = 0; pawn2Idx < positions.length; ++pawn2Idx) {
+      if (mask & (1 << pawn2Idx)) {
+        continue
+      }
+
+      let cur = degreeBetween(pawn1Idx, pawn2Idx)
+      cur += dfs(pawn2Idx, !maximize, mask | (1 << pawn2Idx))
+
+      best = Math.min(best, cur)
+      worst = Math.max(worst, cur)
+    }
+
+    let ret
+    if (maximize) {
+      ret = worst
+    } else {
+      ret = best
+    }
+
+    dp[dpIdx] = ret + 1
+    return ret
+  }
+
+  function computeAllDegreesBetweenPawns() {
+    let targets = new Map(positions.map(([x, y], idx) => [y * 50 + x, idx]))
+
+    let visited = new Array(50 * 50).fill(0)
+    const MOVES = [
+      [2, 1],
+      [-2, 1],
+      [2, -1],
+      [-2, -1],
+      [1, -2],
+      [1, 2],
+      [-1, 2],
+      [-1, -2],
+    ]
+
+    for (let i = 0; i < positions.length; ++i) {
+      let q = [positions[i]]
+      let q2 = []
+      let steps = 0
+
+      visited[positions[i][1] * 50 + positions[i][0]] = i
+
+      while (q.length) {
+        let [x, y] = q.pop()
+
+        {
+          let dpIdx = y * 50 + x
+          if (targets.has(dpIdx)) {
+            let v1 = i
+            let v2 = targets.get(dpIdx)
+            degreesBetweenPawnPairs[v1 * positions.length + v2] = steps
+            degreesBetweenPawnPairs[v2 * positions.length + v1] = steps
+          }
+        }
+
+        for (let [offx, offy] of MOVES) {
+          let newX = x + offx
+          let newY = y + offy
+
+          if (newX >= 50 || newY >= 50 || newX < 0 || newY < 0) {
+            continue
+          }
+          let visitedDpIdx = newY * 50 + newX
+          if (visited[visitedDpIdx] === i) {
+            continue
+          }
+          visited[visitedDpIdx] = i
+          q2.push([newX, newY])
+        }
+
+        if (!q.length) {
+          ;[q2, q] = [q, q2]
+          ++steps
+        }
+      }
+    }
+  }
+
+  function degreeBetween(i, j) {
+    return degreesBetweenPawnPairs[i * positions.length + j]
+  }
+}
+
+

From d0d8753925c1d429cdfc67981eb595dbc7e47f83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Sep 2024 18:03:06 +0800
Subject: [PATCH 3144/3374] Create 3282-reach-end-of-array-with-max-score.js

---
 3282-reach-end-of-array-with-max-score.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 3282-reach-end-of-array-with-max-score.js

diff --git a/3282-reach-end-of-array-with-max-score.js b/3282-reach-end-of-array-with-max-score.js
new file mode 100644
index 00000000..2fb4bb45
--- /dev/null
+++ b/3282-reach-end-of-array-with-max-score.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var findMaximumScore = function(nums) {
+    let n = nums.length
+
+    if(n==1)return 0
+    let res = 0,mx = nums[0],prev = nums[0]
+    for(let i=1;i<n;i++){
+        res+=mx
+        if(nums[i]>mx)mx = nums[i]
+    }
+    return res
+};

From 616f5ff37a9a5d79556ee2845f9a50d3534d25c6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Sep 2024 18:03:40 +0800
Subject: [PATCH 3145/3374] Create 3281-maximize-score-of-numbers-in-ranges.js

---
 3281-maximize-score-of-numbers-in-ranges.js | 30 +++++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 3281-maximize-score-of-numbers-in-ranges.js

diff --git a/3281-maximize-score-of-numbers-in-ranges.js b/3281-maximize-score-of-numbers-in-ranges.js
new file mode 100644
index 00000000..9a71ae2e
--- /dev/null
+++ b/3281-maximize-score-of-numbers-in-ranges.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} start
+ * @param {number} d
+ * @return {number}
+ */
+var maxPossibleScore = function (start, d) {
+  start.sort((a, b) => a - b)
+  let low = 0,
+    high = start[start.length - 1] + d - start[0]
+  while (low <= high) {
+    let mid = low + Math.floor((high - low) / 2)
+    if (f(start, d, mid)) {
+      low = mid + 1
+    } else {
+      high = mid - 1
+    }
+  }
+  return low - 1
+}
+function f(start, d, mini) {
+  let ans = start[0]
+  for (let i = 1; i < start.length; i++) {
+    let nextMin = ans + mini
+    if (nextMin > start[i] + d) {
+      return false
+    }
+    ans = Math.max(start[i], nextMin)
+  }
+  return true
+}

From ca8a47c3069ef8ba0220677e6f53361c93480ecb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 8 Sep 2024 18:04:24 +0800
Subject: [PATCH 3146/3374] Create 3280-convert-date-to-binary.js

---
 3280-convert-date-to-binary.js | 31 +++++++++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3280-convert-date-to-binary.js

diff --git a/3280-convert-date-to-binary.js b/3280-convert-date-to-binary.js
new file mode 100644
index 00000000..48190272
--- /dev/null
+++ b/3280-convert-date-to-binary.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} date
+ * @return {string}
+ */
+var convertDateToBinary = function(date) {
+    let temp = [], res =[]
+    for(let i of date){
+        if(i=='-'){
+            temp = dec_to_bin(temp.join(''))
+            res.push(...temp)
+            temp = []
+            res.push('-')
+        }
+        else temp.push(i)
+    }
+    temp = dec_to_bin(temp.join(''))
+    res.push(...temp)
+    return res.join('')
+};
+
+function dec_to_bin( a){
+    let b = +(a)
+    let res = []
+    while(b>0){
+        if(b&1)res.push('1')
+        else res.push('0')
+        b>>=1
+    }
+    res.reverse()
+    return res
+}

From 074366407f9cc85ca35161bf83aa8febfb2ccf8b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Sep 2024 13:15:35 +0800
Subject: [PATCH 3147/3374] Update 691-stickers-to-spell-word.js

---
 691-stickers-to-spell-word.js | 39 +++++++++++++++++++++++++++++++++++
 1 file changed, 39 insertions(+)

diff --git a/691-stickers-to-spell-word.js b/691-stickers-to-spell-word.js
index 8c0574c5..b81b80ea 100644
--- a/691-stickers-to-spell-word.js
+++ b/691-stickers-to-spell-word.js
@@ -1,3 +1,42 @@
+/**
+ * @param {string[]} stickers
+ * @param {string} target
+ * @return {number}
+ */
+const minStickers = function(stickers, target) {
+  const n = target.length
+  const limit = 1 << n
+  const dp = Array(limit).fill(Infinity)
+  dp[0] = 0
+  for(let state = 0; state < limit; state++) {
+    if(dp[state] === Infinity) continue
+    for(let s of stickers) {
+      const ns = helper(state, target, s)
+      dp[ns] = Math.min(dp[ns], dp[state] + 1)      
+    }
+
+  }
+  
+  return dp[limit -  1] === Infinity ? -1 : dp[limit - 1]
+  
+  function helper(state, target, s) {
+    const n = target.length
+    for(const ch of s) {
+      for(let i = 0; i < n; i++) {
+        if(target[i] === ch && ((state >> i) & 1) === 0) {
+          state |= (1 << i)
+          break
+        }
+      }
+    }
+    
+    return state
+  }
+};
+
+// another
+
+
 /**
  * @param {string[]} stickers
  * @param {string} target

From 0e865b87317bca08a57829db66ee89e5309e62b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 14 Sep 2024 13:34:13 +0800
Subject: [PATCH 3148/3374] Update 1125-smallest-sufficient-team.js

---
 1125-smallest-sufficient-team.js | 44 ++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/1125-smallest-sufficient-team.js b/1125-smallest-sufficient-team.js
index 4b890c98..a617f780 100644
--- a/1125-smallest-sufficient-team.js
+++ b/1125-smallest-sufficient-team.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string[]} req_skills
+ * @param {string[][]} people
+ * @return {number[]}
+ */
+var smallestSufficientTeam = function(req_skills, people) {
+   const n = req_skills.length, m = people.length
+   const limit = 1 << n
+   const reqSet = new Set(req_skills)
+   const si = {}
+   for(let i = 0; i < n; i++) si[req_skills[i]] = i
+   const ps = {}
+   for(let i = 0; i < m; i++) {
+     const p = people[i]
+     let mask = 0
+     for(const s of p) {
+       if(!reqSet.has(s)) continue
+       mask |= (1 << si[s])
+     }
+     ps[i] = mask
+   }
+   const res = Array.from({ length: limit }, () => new Array())
+   let dp = Array(limit).fill(Infinity)
+   dp[0] = 0
+   for(let i = 0; i < m; i++) {
+     const pMask = ps[i]
+     const dp2 = [...dp]
+     for(let mask = 0; mask < limit; mask++) {
+       const newMask = mask | pMask
+       if(dp2[newMask] > dp[mask] + 1) {
+         dp2[newMask] = dp[mask] + 1
+         res[newMask] = [...res[mask]]
+         res[newMask].push(i)
+       }
+     }
+     dp = dp2
+   }
+   
+   return res[limit - 1]
+};
+
+// another
+
+
 /**
  * @param {string[]} req_skills
  * @param {string[][]} people

From d121bbab4c24be42a74c8b12cde11b9af79d85b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Sep 2024 16:17:26 +0800
Subject: [PATCH 3149/3374] Create 3295-report-spam-message.js

---
 3295-report-spam-message.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 3295-report-spam-message.js

diff --git a/3295-report-spam-message.js b/3295-report-spam-message.js
new file mode 100644
index 00000000..125acf6d
--- /dev/null
+++ b/3295-report-spam-message.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string[]} message
+ * @param {string[]} bannedWords
+ * @return {boolean}
+ */
+var reportSpam = function(message, bannedWords) {
+  let res = false
+  const m = message.length, n = bannedWords.length
+  let cnt = 0
+  const bs = new Set(bannedWords)
+  for(let i = 0; i < m; i++) {
+    const str = message[i]
+    /*
+    for(let j = 0; j < n; j++) {
+      const e = bannedWords[j]
+      if(str === e) {
+        cnt++
+        break
+      }
+    }
+    */
+    if(bs.has(str)) cnt++
+    if(cnt >= 2) return true
+  }
+  
+  return res
+};

From a422d87bd503ee0a6b0999febcc1d647617ed0e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Sep 2024 16:18:37 +0800
Subject: [PATCH 3150/3374] Create
 3296-minimum-number-of-seconds-to-make-mountain-height-zero.js

---
 ...of-seconds-to-make-mountain-height-zero.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3296-minimum-number-of-seconds-to-make-mountain-height-zero.js

diff --git a/3296-minimum-number-of-seconds-to-make-mountain-height-zero.js b/3296-minimum-number-of-seconds-to-make-mountain-height-zero.js
new file mode 100644
index 00000000..369cd1c9
--- /dev/null
+++ b/3296-minimum-number-of-seconds-to-make-mountain-height-zero.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number} mountainHeight
+ * @param {number[]} workerTimes
+ * @return {number}
+ */
+var minNumberOfSeconds = function (mountainHeight, workerTimes) {
+  let low = 0,
+    high = 1e18
+  while (low < high) {
+    let mid = low + Math.floor((high - low) / 2)
+    let totalHeightReduced = 0
+    for (let workerTime of workerTimes) {
+      totalHeightReduced += f(mid, workerTime)
+      if (totalHeightReduced >= mountainHeight) break
+    }
+    if (totalHeightReduced >= mountainHeight) high = mid
+    else low = mid + 1
+  }
+  return low
+}
+function f(T, workerTime) {
+  let low = 0,
+    high = 1e6
+  while (low < high) {
+    let mid = low + Math.floor((high - low + 1) / 2)
+    let timeRequired = (workerTime * mid * (mid + 1)) / 2
+    if (timeRequired <= T) low = mid
+    else high = mid - 1
+  }
+  return low
+}

From 1dfef76e331b88d39ff39fa060f807caf501e052 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Sep 2024 16:19:29 +0800
Subject: [PATCH 3151/3374] Create
 3297-count-substrings-that-can-be-rearranged-to-contain-a-string-i.js

---
 ...can-be-rearranged-to-contain-a-string-i.js | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 3297-count-substrings-that-can-be-rearranged-to-contain-a-string-i.js

diff --git a/3297-count-substrings-that-can-be-rearranged-to-contain-a-string-i.js b/3297-count-substrings-that-can-be-rearranged-to-contain-a-string-i.js
new file mode 100644
index 00000000..541fc927
--- /dev/null
+++ b/3297-count-substrings-that-can-be-rearranged-to-contain-a-string-i.js
@@ -0,0 +1,44 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var validSubstringCount = function (word1, word2) {
+  const mp1 = new Array(26).fill(0)
+  const mp2 = new Array(26).fill(0)
+  let missing = 0
+
+  for (const c of word2) {
+    mp1[c.charCodeAt(0) - 'a'.charCodeAt(0)]++
+  }
+
+  for (let i = 0; i < 26; i++) {
+    if (mp1[i] > 0) {
+      missing += mp1[i]
+    }
+  }
+
+  let res = 0
+  let left = 0
+  const n = word1.length
+
+  for (let right = 0; right < n; right++) {
+    const c = word1[right].charCodeAt(0) - 'a'.charCodeAt(0)
+    mp2[c]++
+    if (mp1[c] > 0 && mp2[c] <= mp1[c]) {
+      missing--
+    }
+
+    while (missing === 0) {
+      res += n - right
+      const left_char = word1[left].charCodeAt(0) - 'a'.charCodeAt(0)
+      if (mp1[left_char] > 0 && mp2[left_char] <= mp1[left_char]) {
+        missing++
+      }
+      mp2[left_char]--
+      left++
+    }
+  }
+
+  return res
+}

From 8ff315bd5814ea8c83139223af14ceead7b2919c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Sep 2024 16:20:18 +0800
Subject: [PATCH 3152/3374] Create
 3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js

---
 ...an-be-rearranged-to-contain-a-string-ii.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js

diff --git a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
new file mode 100644
index 00000000..6c77b42b
--- /dev/null
+++ b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
@@ -0,0 +1,49 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var validSubstringCount = function (word1, word2) {
+  const mp1 = new Array(26).fill(0)
+  const mp2 = new Array(26).fill(0)
+  let count = 0
+
+  for (const c of word2) {
+    mp1[c.charCodeAt(0) - 'a'.charCodeAt(0)]++
+  }
+
+  for (let i = 0; i < 26; i++) {
+    if (mp1[i] > 0) {
+      count += mp1[i]
+    }
+  }
+
+  let res = 0
+  let left = 0
+
+  for (let right = 0; right < word1.length; right++) {
+    mp2[word1.charCodeAt(right) - 'a'.charCodeAt(0)]++
+    if (
+      mp1[word1.charCodeAt(right) - 'a'.charCodeAt(0)] > 0 &&
+      mp2[word1.charCodeAt(right) - 'a'.charCodeAt(0)] <=
+        mp1[word1.charCodeAt(right) - 'a'.charCodeAt(0)]
+    ) {
+      count--
+    }
+
+    while (count === 0) {
+      res += word1.length - right
+      if (
+        mp1[word1.charCodeAt(left) - 'a'.charCodeAt(0)] > 0 &&
+        mp2[word1.charCodeAt(left) - 'a'.charCodeAt(0)] <=
+          mp1[word1.charCodeAt(left) - 'a'.charCodeAt(0)]
+      ) {
+        count++
+      }
+      mp2[word1.charCodeAt(left) - 'a'.charCodeAt(0)]--
+      left++
+    }
+  }
+
+  return res
+}

From bb76d23baf3fa11cf3dafd4d5cfec6436c6fe9d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Sep 2024 18:13:07 +0800
Subject: [PATCH 3153/3374] Update 1799-maximize-score-after-n-operations.js

---
 1799-maximize-score-after-n-operations.js | 40 +++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/1799-maximize-score-after-n-operations.js b/1799-maximize-score-after-n-operations.js
index 28e97a5c..4e4ec0cf 100644
--- a/1799-maximize-score-after-n-operations.js
+++ b/1799-maximize-score-after-n-operations.js
@@ -1,3 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const maxScore = function (nums) {
+  const len = nums.length
+  const n = len / 2
+  const allMask = 2 ** 14 - 1
+  const memo = Array.from({ length: n + 1 }, () => Array())
+  
+  return helper(1, 0)
+  
+  function helper(op, mask) {
+    if(op > n) return 0
+    if(memo[op][mask]) return memo[op][mask]
+
+    let res = 0
+    for(let i = 0; i < len; i++) {
+      const a = nums[i]
+      for(let j = i + 1; j < len; j++) {
+        const b = nums[j]
+        const newMask = (1 << i) + (1 << j)
+        if((mask & newMask) === 0) {
+          res = Math.max(res, op * gcd(a, b) + helper(op + 1, mask | newMask))
+        }
+      }
+    }
+    // console.log(res)
+    memo[op][mask] = res
+    
+    return memo[op][mask]
+  }
+}
+
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b)
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 8c0ff0c66bd1e7a171dad4b2269af6c574a68cb9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Sep 2024 12:42:49 +0800
Subject: [PATCH 3154/3374] Update 1994-the-number-of-good-subsets.js

---
 1994-the-number-of-good-subsets.js | 86 ++++++++++++++++++++++++++++++
 1 file changed, 86 insertions(+)

diff --git a/1994-the-number-of-good-subsets.js b/1994-the-number-of-good-subsets.js
index 8ca7236d..bcf0f37d 100644
--- a/1994-the-number-of-good-subsets.js
+++ b/1994-the-number-of-good-subsets.js
@@ -1,3 +1,89 @@
+const M = 1e9 + 7
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const numberOfGoodSubsets = function (nums) {
+  const set = new Set([
+    2, 3, 5, 6, 7, 10, 11, 13, 14, 15, 17, 19, 21, 22, 23, 26, 29, 30,
+  ])
+  const map = new Map()
+  let count1 = 0
+
+  for (const x of nums) {
+    if (set.has(x)) {
+      map.set(x, (map.get(x) || 0) + 1)
+    }
+    if (x === 1) {
+      count1++
+    }
+  }
+
+  const n = map.size
+  const count = []
+  const digit = []
+  for (const [key, value] of map) {
+    digit.push(key)
+    count.push(value)
+  }
+
+  let ret = 0
+  for (let state = 1; state < 1 << n; state++) {
+    let flag = 1
+    for (let i = 0; i < n; i++) {
+      if (((state >> i) & 1) === 0) continue
+      for (let j = i + 1; j < n; j++) {
+        if (((state >> j) & 1) === 0) continue
+        if (gcd(digit[i], digit[j]) !== 1) {
+          flag = 0
+          break
+        }
+      }
+      if (flag === 0) break
+    }
+
+    if (flag === 0) continue
+
+    let ans = 1
+    for (let i = 0; i < n; i++) {
+      if (((state >> i) & 1) === 0) continue
+      ans = mul(ans, count[i])
+    }
+    ret = (ret + ans) % M
+  }
+
+  ret = mul(ret, quickMul(2, count1))
+  return ret
+}
+
+function quickMul(x, N) {
+  if (N === 0) {
+    return 1
+  }
+  const y = quickMul(x, Math.floor(N / 2))
+  return N % 2 === 0 ? mul(y, y) : mul(y, y, x)
+}
+
+function mul(...arr) {
+  let res = 1n
+  for (const e of arr) {
+    res *= BigInt(e)
+  }
+
+  return Number(res % BigInt(M))
+}
+
+function gcd(a, b) {
+  while (b) {
+    ;[a, b] = [b, a % b]
+  }
+  return a
+}
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From bf53c5c67ceba811902185f59f657e4731decfba Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 24 Sep 2024 17:34:52 +0800
Subject: [PATCH 3155/3374] Update 1994-the-number-of-good-subsets.js

---
 1994-the-number-of-good-subsets.js | 67 ++++++++++++++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/1994-the-number-of-good-subsets.js b/1994-the-number-of-good-subsets.js
index bcf0f37d..56f86517 100644
--- a/1994-the-number-of-good-subsets.js
+++ b/1994-the-number-of-good-subsets.js
@@ -1,3 +1,70 @@
+const primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
+const M = 1e9 + 7
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var numberOfGoodSubsets = function (nums) {
+  const n = primes.length
+  const dp = new Array(1 << n).fill(0)
+  dp[0] = 1
+
+  const map = new Map()
+  for (const x of nums) {
+    map.set(x, (map.get(x) || 0) + 1)
+  }
+
+  let count1 = 0
+  for (const [x, count] of map) {
+    if (x === 1) continue
+    const encode = encoding(x)
+    if (encode === -1) continue
+
+    for (let state = (1 << n) - 1; state >= 1; state--) {
+      if (state - encode === (state ^ encode)) {
+        dp[state] = (dp[state] + ((dp[state - encode] * count) % M)) % M
+      }
+    }
+  }
+
+  let ret = 0
+  for (let state = 1; state < 1 << n; state++) {
+    ret = (ret + dp[state]) % M
+  }
+
+  let power2 = 1
+  for (let i = 0; i < (map.get(1) || 0); i++) {
+    power2 = (power2 * 2) % M
+  }
+
+  return mul(ret, power2)
+}
+
+function mul(...arr) {
+  let res = 1n
+  for (const e of arr) {
+    res *= BigInt(e)
+  }
+
+  return Number(res % BigInt(M))
+}
+
+function encoding(num) {
+  let encode = 0
+  for (let i = 0; i < primes.length; i++) {
+    if (num % primes[i] === 0) {
+      encode += 1 << i
+      num /= primes[i]
+    }
+    if (num % primes[i] === 0) {
+      return -1
+    }
+  }
+  return encode
+}
+
+// another
+
 const M = 1e9 + 7
 
 /**

From 97fc11deeba92e1eeaf19fbd39cc8290862a8834 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Sep 2024 10:55:42 +0800
Subject: [PATCH 3156/3374] Update
 2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js

---
 ...-length-of-two-palindromic-subsequences.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
index f6126c88..49a6f516 100644
--- a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
+++ b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
@@ -1,3 +1,46 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxProduct = function(s) {
+  const n = s.length
+  const limit = (1 << n) - 1
+  let res = 0
+  for(let mask = 1; mask < limit; mask++) {
+    res = Math.max(res, lp(mask) * lp(limit - mask))
+  }
+  return res
+  
+  function lp(state) {
+    if(state === 0) return 0
+    const str = []
+    let idx = 0
+    // console.log((state))
+    while(idx < s.length) {
+      // console.log((state >>> 0).toString(2))
+      if((state >> idx) & 1) str.push(s[s.length - 1 - idx])
+      idx++
+    }
+    // console.log(str)
+    const len = str.length
+    const dp = Array.from({ length: len }, () => Array(len).fill(0))
+    for(let i = 0; i < len; i++) dp[i][i] = 1
+    
+    for(let length = 2; length <= len; length++) {
+      for(let i = 0; i + length - 1 < len; i++) {
+        const j = i + length - 1
+        if(str[i] === str[j]) dp[i][j] = dp[i + 1][j - 1] + 2
+        else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1])
+      }
+    }
+    
+    // console.log(dp, len)
+    return dp[0][len - 1]
+  } 
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 99536f2f5026e3925024415d5c2e3fd1f72e5c13 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 26 Sep 2024 14:51:26 +0800
Subject: [PATCH 3157/3374] Update 1125-smallest-sufficient-team.js

---
 1125-smallest-sufficient-team.js | 43 ++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/1125-smallest-sufficient-team.js b/1125-smallest-sufficient-team.js
index a617f780..2e8e9754 100644
--- a/1125-smallest-sufficient-team.js
+++ b/1125-smallest-sufficient-team.js
@@ -1,3 +1,46 @@
+/**
+ * @param {string[]} req_skills
+ * @param {string[][]} people
+ * @return {number[]}
+ */
+var smallestSufficientTeam = function(req_skills, people) {
+   const n = req_skills.length, m = people.length
+   const limit = 1 << n
+   const reqSet = new Set(req_skills)
+   const si = {}
+   for(let i = 0; i < n; i++) si[req_skills[i]] = i
+   const ps = {}
+   for(let i = 0; i < m; i++) {
+     const p = people[i]
+     let mask = 0
+     for(const s of p) {
+       if(!reqSet.has(s)) continue
+       mask |= (1 << si[s])
+     }
+     ps[i] = mask
+   }
+   const res = Array.from({ length: limit }, () => new Array())
+   let dp = Array(limit).fill(Infinity)
+   dp[0] = 0
+   for(let i = 0; i < m; i++) {
+     const pMask = ps[i]
+     // const dp2 = [...dp]
+     for(let mask = 0; mask < limit; mask++) {
+       const newMask = mask | pMask
+       if(dp[newMask] > dp[mask] + 1) {
+         dp[newMask] = dp[mask] + 1
+         res[newMask] = [...res[mask]]
+         res[newMask].push(i)
+       }
+     }
+     // dp = dp2
+   }
+   
+   return res[limit - 1]
+};
+
+// another
+
 /**
  * @param {string[]} req_skills
  * @param {string[][]} people

From c5d45d8586471644d1492e8c7d920d73f3664fce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Sep 2024 12:21:45 +0800
Subject: [PATCH 3158/3374] Create
 3276-select-cells-in-grid-with-maximum-score.js

---
 ...select-cells-in-grid-with-maximum-score.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 3276-select-cells-in-grid-with-maximum-score.js

diff --git a/3276-select-cells-in-grid-with-maximum-score.js b/3276-select-cells-in-grid-with-maximum-score.js
new file mode 100644
index 00000000..bdb2ac33
--- /dev/null
+++ b/3276-select-cells-in-grid-with-maximum-score.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxScore = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+  const values = []
+
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      values.push([grid[i][j], i, j])
+    }
+  }
+
+  values.sort((a, b) => b[0] - a[0])
+  const dp = {}
+
+  return recur(values, 0, 0, dp)
+}
+
+function recur(values, idx, mask_row, dp) {
+  const n = values.length
+  if (idx === n) return 0
+
+  const key = `${idx},${mask_row}`
+  if (key in dp) return dp[key]
+
+  let ans = 0
+  const row = values[idx][1]
+  if ((1 << row) & mask_row) {
+    ans += recur(values, idx + 1, mask_row, dp)
+  } else {
+    let j = idx
+    while (j < n && values[idx][0] === values[j][0]) j++
+
+    const ans1 = values[idx][0] + recur(values, j, mask_row | (1 << row), dp)
+    const ans2 = recur(values, idx + 1, mask_row, dp)
+
+    ans = Math.max(ans1, ans2)
+  }
+
+  dp[key] = ans
+  return ans
+}

From 8ee2cfe184a68a325cee04b5c5346b8912b27932 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 30 Sep 2024 11:43:09 +0800
Subject: [PATCH 3159/3374] Update 1494-parallel-courses-ii.js

---
 1494-parallel-courses-ii.js | 52 +++++++++++++++++++++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/1494-parallel-courses-ii.js b/1494-parallel-courses-ii.js
index 0882499f..17397e68 100644
--- a/1494-parallel-courses-ii.js
+++ b/1494-parallel-courses-ii.js
@@ -1,3 +1,55 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number} k
+ * @return {number}
+ */
+const minNumberOfSemesters = function(n, relations, k) {
+  const limit = (1 << n)
+  const dp = Array(limit).fill(Number.MAX_SAFE_INTEGER)
+  const preCourse = Array(n).fill(0)
+  const preState = Array(limit).fill(0)
+  
+  for(const [s, d] of relations) {
+    preCourse[d - 1] |= (1 << (s - 1))
+  }
+  for(let state = 0; state < limit; state++) {
+    for(let i = 0; i < n; i++) {
+      if(state & (1 << i)) {
+        preState[state] |= preCourse[i]
+      }
+    }
+    if(preState[state] === 0 && bitCnt(state) <= k) dp[state] = 1
+  }
+  dp[0] = 0
+  for(let state = 1; state < limit; state++) {
+    for(let sub = state; sub >= 0; sub = (sub - 1) & state) {
+      if(
+        bitCnt(state) - bitCnt(sub) <= k &&
+        ((preState[state] & sub) === preState[state])
+      ) {
+        // console.log('d', state, sub, dp)
+        dp[state] = Math.min(dp[state], dp[sub] + 1)
+      }
+      if(sub === 0) break
+    }
+  }
+  
+  // console.log(limit)
+  return dp[limit - 1]
+};
+
+function bitCnt(num) {
+  let res = 0
+  while(num) {
+    res++
+    num &= (num - 1)
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} dependencies

From 67267993fb0611557e4e77dadde106fc6627b1ac Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Oct 2024 16:52:52 +0800
Subject: [PATCH 3160/3374] Update 638-shopping-offers.js

---
 638-shopping-offers.js | 43 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/638-shopping-offers.js b/638-shopping-offers.js
index 9870b16c..9f031c87 100644
--- a/638-shopping-offers.js
+++ b/638-shopping-offers.js
@@ -1,3 +1,46 @@
+/**
+ * @param {number[]} price
+ * @param {number[][]} special
+ * @param {number[]} needs
+ * @return {number}
+ */
+const shoppingOffers = function (price, special, needs) {
+  return helper(price, special, needs, 0);
+}
+
+
+function helper(price, special, needs, pos) {
+    let local_min = directPurchase(price, needs);
+    for (let i = pos; i < special.length; i++) {
+        let offer = special[i];
+        let temp = [];
+        for (let j = 0; j < needs.length; j++) {
+            if (needs[j] < offer[j]) { // check if the current offer is valid
+                temp = null;
+                break;
+            }
+            temp.push(needs[j] - offer[j]);
+        }
+
+        if (temp !== null) { // use the current offer and try next
+            local_min = Math.min(local_min, offer[offer.length - 1] + helper(price, special, temp, i));
+        }
+    }
+
+    return local_min;
+}
+
+function directPurchase(price, needs) {
+    let total = 0;
+    for (let i = 0; i < needs.length; i++) {
+        total += price[i] * needs[i];
+    }
+
+    return total;
+}
+
+// another
+
 /**
  * @param {number[]} price
  * @param {number[][]} special

From aa7ad7cdad55ca1017e37f945c934759884cf468 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 11 Oct 2024 16:54:19 +0800
Subject: [PATCH 3161/3374] Update 638-shopping-offers.js

---
 638-shopping-offers.js | 49 +++++++++++++++++++++++-------------------
 1 file changed, 27 insertions(+), 22 deletions(-)

diff --git a/638-shopping-offers.js b/638-shopping-offers.js
index 9f031c87..49747e60 100644
--- a/638-shopping-offers.js
+++ b/638-shopping-offers.js
@@ -5,40 +5,45 @@
  * @return {number}
  */
 const shoppingOffers = function (price, special, needs) {
-  return helper(price, special, needs, 0);
+  return helper(price, special, needs, 0)
 }
 
-
 function helper(price, special, needs, pos) {
-    let local_min = directPurchase(price, needs);
-    for (let i = pos; i < special.length; i++) {
-        let offer = special[i];
-        let temp = [];
-        for (let j = 0; j < needs.length; j++) {
-            if (needs[j] < offer[j]) { // check if the current offer is valid
-                temp = null;
-                break;
-            }
-            temp.push(needs[j] - offer[j]);
-        }
+  let local_min = directPurchase(price, needs)
+  for (let i = pos; i < special.length; i++) {
+    let offer = special[i]
+    let temp = []
+    for (let j = 0; j < needs.length; j++) {
+      if (needs[j] < offer[j]) {
+        // check if the current offer is valid
+        temp = null
+        break
+      }
+      temp.push(needs[j] - offer[j])
+    }
 
-        if (temp !== null) { // use the current offer and try next
-            local_min = Math.min(local_min, offer[offer.length - 1] + helper(price, special, temp, i));
-        }
+    if (temp !== null) {
+      // use the current offer and try next
+      local_min = Math.min(
+        local_min,
+        offer[offer.length - 1] + helper(price, special, temp, i),
+      )
     }
+  }
 
-    return local_min;
+  return local_min
 }
 
 function directPurchase(price, needs) {
-    let total = 0;
-    for (let i = 0; i < needs.length; i++) {
-        total += price[i] * needs[i];
-    }
+  let total = 0
+  for (let i = 0; i < needs.length; i++) {
+    total += price[i] * needs[i]
+  }
 
-    return total;
+  return total
 }
 
+
 // another
 
 /**

From f0e6a773d5ae325409a33f87c7edaf4143bf0abf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Oct 2024 22:02:23 +0800
Subject: [PATCH 3162/3374] Create 1545-find-kth-bit-in-nth-binary-string.js

---
 1545-find-kth-bit-in-nth-binary-string.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 1545-find-kth-bit-in-nth-binary-string.js

diff --git a/1545-find-kth-bit-in-nth-binary-string.js b/1545-find-kth-bit-in-nth-binary-string.js
new file mode 100644
index 00000000..86e2aa48
--- /dev/null
+++ b/1545-find-kth-bit-in-nth-binary-string.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {character}
+ */
+var findKthBit = function(n, k) {
+  let count = 0, l = (1 << n) - 1;
+  while (k > 1) {
+    if (k == Math.floor(l / 2) + 1) return count % 2 == 0 ? '1' : '0';
+    if (k > l / 2) {
+      k = l + 1 - k;
+      count++;
+    }
+    l = Math.floor(l / 2);
+  }
+  return count % 2 === 0 ? '0' : '1'; 
+};

From ee21cb486cee00163a1d33a64aa8c67bb03120be Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 14 Oct 2024 12:46:30 +0800
Subject: [PATCH 3163/3374] Update 2376-count-special-integers.js

---
 2376-count-special-integers.js | 56 ++++++++++++++++++++++++++++++++++
 1 file changed, 56 insertions(+)

diff --git a/2376-count-special-integers.js b/2376-count-special-integers.js
index c2f74b4f..af386f2f 100644
--- a/2376-count-special-integers.js
+++ b/2376-count-special-integers.js
@@ -58,3 +58,59 @@ const countSpecialNumbers = function (n) {
     return (dp[idx][tight][mask] = ans)
   }
 }
+
+// another
+
+const dp = Array.from({ length: 11 }, () =>
+  Array.from({ length: 2 }, () => Array(1024).fill(-1)),
+)
+
+function gogo(s, tight = 1, pos = 0, mask = 0) {
+  // Base case
+  if (pos === s.length) {
+    // Mask = 0, represents 00000...0 which should not be counted
+    return mask !== 0
+  }
+
+  // DP state
+  if (dp[pos][tight][mask] !== -1) {
+    return dp[pos][tight][mask]
+  }
+
+  let ans = 0
+
+  if (tight === 1) {
+    // Limit the current digit
+    for (let i = 0; i <= s[pos] - '0'; i++) {
+      // Check if digit repeated, ie, present in the mask
+      if (mask & (1 << i)) continue
+
+      const newMask = mask === 0 && i === 0 ? mask : mask | (1 << i)
+
+      if (i === s[pos] - '0') {
+        // Tight case
+        ans += gogo(s, 1, pos + 1, newMask)
+      } else {
+        ans += gogo(s, 0, pos + 1, newMask)
+      }
+    }
+  } else {
+    for (let i = 0; i <= 9; i++) {
+      // Check if digit repeated, ie, present in the mask
+      if (mask & (1 << i)) continue
+
+      const newMask = mask === 0 && i === 0 ? mask : mask | (1 << i)
+      ans += gogo(s, 0, pos + 1, newMask)
+    }
+  }
+  return (dp[pos][tight][mask] = ans)
+}
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countSpecialNumbers = function (n) {
+  const s = n.toString()
+  dp.forEach((arr) => arr.forEach((innerArr) => innerArr.fill(-1)))
+  return gogo(s)
+}

From 1cd3d557eeea7cd15621699e7d73955b05a44774 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 15 Oct 2024 14:42:40 +0800
Subject: [PATCH 3164/3374] Update 1012-numbers-with-repeated-digits.js

---
 1012-numbers-with-repeated-digits.js | 49 ++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/1012-numbers-with-repeated-digits.js b/1012-numbers-with-repeated-digits.js
index dec2580e..b9c88524 100644
--- a/1012-numbers-with-repeated-digits.js
+++ b/1012-numbers-with-repeated-digits.js
@@ -94,3 +94,52 @@ var numDupDigitsAtMostN = function(n) {
 
   return n - res
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numDupDigitsAtMostN = function(n) {
+  return n - helper(n)
+  function helper(num) {
+    let res = 0
+    const s = `${num}`
+    const slen = s.length
+    for(let len = 1; len < slen; len++) {
+      res += perm(10, len) - perm(9, len - 1)
+    }
+    const visited = Array(10).fill(null)
+    dfs(s, 0, visited)
+    
+    return res
+    function dfs(s, i, visited) {
+      const n = s.length
+      if(i === n) {
+        res++
+        return
+      }
+      for(let d = 0; d <= 9; d++) {
+        if(d === 0 && i === 0) continue
+        if(visited[d]) continue
+        if(d < +s[i]) {
+          res += perm(10 - i - 1, n - i - 1)
+        } else if(d === +s[i]) {
+          visited[d] = 1
+          dfs(s, i + 1, visited)
+          visited[d] = 0
+        }
+      }
+    }
+  }
+
+  function perm(m, n) {
+    if(n === 0) return 1
+    let res = 1
+    for(let i = 0; i < n; i++) {
+      res *= m - i
+    }
+    return res
+  }
+};

From ff475e3e3a5e6a6039684554fd532f4da6b13f27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 16 Oct 2024 15:22:18 +0800
Subject: [PATCH 3165/3374] Create 2719-count-of-integers.js

---
 2719-count-of-integers.js | 59 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 2719-count-of-integers.js

diff --git a/2719-count-of-integers.js b/2719-count-of-integers.js
new file mode 100644
index 00000000..0dae13c5
--- /dev/null
+++ b/2719-count-of-integers.js
@@ -0,0 +1,59 @@
+/**
+ * @param {string} num1
+ * @param {string} num2
+ * @param {number} min_sum
+ * @param {number} max_sum
+ * @return {number}
+ */
+const count = function (num1, num2, min_sum, max_sum) {
+  const mod = 1e9 + 7
+  let res = 0
+  res =
+    (cntNoGreater(num2, max_sum) - cntNoGreater(num2, min_sum - 1) + mod) % mod -
+    (cntNoGreater(num1, max_sum) - cntNoGreater(num1, min_sum - 1) + mod) % mod
+  res = (res + mod) % mod
+  const sum1 = calc(num1)
+  if (sum1 >= min_sum && sum1 <= max_sum) {
+    res = (res + 1) % mod
+  }
+
+  return res
+
+  function cntNoGreater(num, maxSum) {
+    const memo = Array.from({ length: 2 }, () =>
+      Array.from({ length: 23 }, () => Array(401).fill(-1))
+    )
+    return dfs(num, maxSum, 0, 0, 1, memo)
+  }
+  function dfs(num, maxSum, idx, sum, isSame, memo) {
+    if(sum > maxSum) {
+      return 0
+    }
+    if (idx === num.length) {
+      return 1
+    }
+    if(memo[isSame][idx][sum] !== -1) {
+      return memo[isSame][idx][sum]
+    }
+    let res = 0
+    if(isSame) {
+        for(let i = 0; i < num[idx]; i++) {
+            res = (res + dfs(num, maxSum, idx + 1, sum + i, 0, memo)) % mod
+        }
+        res = (res + dfs(num, maxSum, idx + 1, sum + +num[idx], 1, memo)) % mod
+    } else {
+        for (let i = 0; i <= 9; i++) {
+            res = (res + dfs(num, maxSum, idx + 1, sum + i, 0, memo)) % mod
+        }
+    }
+
+    return memo[isSame][idx][sum] = res
+  }
+  function calc(num) {
+    let res = 0
+    for (const e of num) {
+      res += +e
+    }
+    return res
+  }
+}

From f8f14d7fda468276539f0704f097dc56e383ed81 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 17 Oct 2024 15:14:08 +0800
Subject: [PATCH 3166/3374] Update 2801-count-stepping-numbers-in-range.js

---
 2801-count-stepping-numbers-in-range.js | 62 +++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/2801-count-stepping-numbers-in-range.js b/2801-count-stepping-numbers-in-range.js
index 27af38b6..17ea13df 100644
--- a/2801-count-stepping-numbers-in-range.js
+++ b/2801-count-stepping-numbers-in-range.js
@@ -109,3 +109,65 @@ const countSteppingNumbers = (low, high) => {
     return minus_mod(x, y, mod);
 };
 
+// another
+
+
+/**
+ * @param {string} low
+ * @param {string} high
+ * @return {number}
+ */
+const countSteppingNumbers = function(low, high) {
+  const mod = 1e9 + 7
+  let res = 0
+  res = (helper(high) - helper(low) + isSteppingNumber(low) + mod) % mod
+
+  return res
+
+  function helper(num) {
+    let res = 0
+    const n = num.length
+    const memo = Array.from({ length: 2 }, () => Array.from({ length: 11 }, () => Array.from({ length: n + 1 }, () => -1)))
+    for (let len = 1; len < n; len++) {
+        for(let i = 1; i < 10; i++){
+          res = (res + dfs(len - 1, i, false, num, memo)) % mod
+        }
+    }
+    const d = num[0] - '0'
+    for(let i = 1; i < d; i++){
+      res = (res + dfs(n - 1, i, false, num, memo)) % mod
+    }
+    res = (res + dfs(n - 1, d, true, num, memo)) % mod
+    return res
+  }
+  function dfs(len, prev, isSame, num, memo) {
+    if(len === 0) return 1
+    if(memo[+isSame][prev][len] !== -1) return memo[+isSame][prev][len]
+    let res = 0
+    if(isSame){
+        const d = num[num.length - len] - '0'
+        if(prev + 1 < d) res = (res + dfs(len - 1, prev + 1, false, num, memo)) % mod
+        else if(prev + 1 === d) res = (res + dfs(len - 1, prev + 1, true, num, memo)) % mod
+        if(prev - 1 >= 0 && prev - 1 < d) res = (res + dfs(len - 1, prev - 1, false, num, memo)) % mod
+        else if(prev - 1 === d) res = (res + dfs(len - 1, prev - 1, true, num, memo)) % mod
+
+
+    } else {
+        if(prev + 1 < 10) res = (res + dfs(len - 1, prev + 1, false, num, memo)) % mod
+        if(prev - 1 >= 0) res = (res + dfs(len - 1, prev - 1, false, num, memo)) % mod
+    }
+
+    memo[+isSame][prev][len] = res
+
+    return res
+  }
+  function isSteppingNumber(num){
+    if(num.length === 1) return 1
+    for(let i = 1; i < num.length; i++){
+      if(Math.abs(num[i] - num[i - 1]) !== 1) return 0
+    }
+    return 1
+  }
+};
+
+

From d5950f84b308c3e5fe531ac80affcdc4c59daa68 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 21 Oct 2024 21:04:49 +0800
Subject: [PATCH 3167/3374] Create
 3258-count-substrings-that-satisfy-k-constraint-i.js

---
 ...-substrings-that-satisfy-k-constraint-i.js | 27 +++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 3258-count-substrings-that-satisfy-k-constraint-i.js

diff --git a/3258-count-substrings-that-satisfy-k-constraint-i.js b/3258-count-substrings-that-satisfy-k-constraint-i.js
new file mode 100644
index 00000000..af54fbc5
--- /dev/null
+++ b/3258-count-substrings-that-satisfy-k-constraint-i.js
@@ -0,0 +1,27 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var countKConstraintSubstrings = function(s, k) {
+  let res = 0
+  const n = s.length
+  for(let len = 1; len <= n; len++) {
+    for(let j = 0; j + len <= n; j++) {
+      const sub = s.slice(j, j + len)
+      if(valid(sub)) res++
+    }
+  }
+  
+  return res
+  
+  function valid(str) {
+    let one = 0
+    const n = str.length
+    for(const e of str) {
+      if(e === '1') one++
+    }
+    
+    return one <= k || n - one <= k 
+  }
+};

From 0aeb8d9074da769c836d8aef5e6805902d12f3c4 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 22 Oct 2024 13:30:16 +0800
Subject: [PATCH 3168/3374] Update
 3258-count-substrings-that-satisfy-k-constraint-i.js

---
 ...-substrings-that-satisfy-k-constraint-i.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/3258-count-substrings-that-satisfy-k-constraint-i.js b/3258-count-substrings-that-satisfy-k-constraint-i.js
index af54fbc5..04445896 100644
--- a/3258-count-substrings-that-satisfy-k-constraint-i.js
+++ b/3258-count-substrings-that-satisfy-k-constraint-i.js
@@ -1,3 +1,33 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const countKConstraintSubstrings = function (s, k) {
+  const n = s.length
+  let res = 0,
+    l = 0,
+    r = 0,
+    zero = 0,
+    one = 0
+  while (r < n) {
+    if (s[r] === "0") zero++
+    else one++
+    while (zero > k && one > k) {
+      if (s[l] === "0") zero--
+      else one--
+      l++
+    }
+    res += r - l + 1
+    r++
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {string} s
  * @param {number} k

From 8d0ac4060478fd39a2be9c84dfb71166e4e9a30d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Oct 2024 15:46:36 +0800
Subject: [PATCH 3169/3374] Update 76-minimum-window-substring.js

---
 76-minimum-window-substring.js | 38 ++++++++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/76-minimum-window-substring.js b/76-minimum-window-substring.js
index a6fbcb99..7b3ac3e1 100644
--- a/76-minimum-window-substring.js
+++ b/76-minimum-window-substring.js
@@ -1,3 +1,41 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function(s, t) {
+  const a = 'a'.charCodeAt(0)
+  const A = 'A'.charCodeAt(0)
+  const arr = new Array(52).fill(0)
+  const n = s.length
+  const idx = (ch) => {
+    const code = ch.charCodeAt(0)
+    return code - (code >= a ? a : A) + (code >= a ? 26 : 0)
+  }
+  for (const ch of t) {
+    arr[idx(ch)]++
+  }
+  let l = 0, r = 0
+  let res = ''
+  while(r < n) {
+    const i = idx(s[r])
+    arr[i]--
+    while(l < r && arr[idx(s[l])] < 0) {
+        arr[idx(s[l])]++
+        l++
+    }
+    const tmp = s.slice(l, r + 1)
+    if(arr.every(x => x <= 0) && (res === '' || tmp.length < res.length)) {
+      res = tmp
+    }
+    r++
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string} t

From a8f1e1675da9a69bfc4a1b5f1030075e2643b87f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 24 Oct 2024 17:14:24 +0800
Subject: [PATCH 3170/3374] Update 992-subarrays-with-k-different-integers.js

---
 992-subarrays-with-k-different-integers.js | 31 ++++++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index 921973e8..21afa918 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -108,3 +108,34 @@ const subarraysWithKDistinct = function (A, K) {
   }
 }
 
+// another
+
+const subarraysWithKDistinct = function (nums, k) {
+  const n = nums.length
+  const atMost = (k) => {
+    const freq = new Array(n + 1).fill(0)
+    let l = 0,
+      r = 0
+    let res = 0
+    let cnt = 0
+    while (r < n) {
+      if (freq[nums[r]] === 0) {
+        cnt++
+      }
+      freq[nums[r]]++
+      while (cnt > k) {
+        freq[nums[l]]--
+        if (freq[nums[l]] === 0) {
+          cnt--
+        }
+        l++
+      }
+      res += r - l + 1
+      r++
+    }
+    return res
+  }
+  return atMost(k) - atMost(k - 1)
+}
+
+

From 4e9105a593a67341de9dfab00e0742da5534de67 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 25 Oct 2024 11:48:46 +0800
Subject: [PATCH 3171/3374] Update
 3-longest-substring-without-repeating-characters.js

---
 ...-substring-without-repeating-characters.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)

diff --git a/3-longest-substring-without-repeating-characters.js b/3-longest-substring-without-repeating-characters.js
index d345eadf..773dc4ff 100755
--- a/3-longest-substring-without-repeating-characters.js
+++ b/3-longest-substring-without-repeating-characters.js
@@ -40,6 +40,36 @@ const lengthOfLongestSubstring = function(s) {
 
 // another
 
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstring = function(s) {
+    const n = s.length, hash = {}
+    let res = 0
+    let l = 0, r = 0
+    while(r < n) {
+        const ch = s[r]
+        if(hash[ch] == null) hash[ch] = 0
+        hash[ch]++
+        while(hash[s[l]] > 1) {
+            hash[s[l]]--
+            l++
+        }
+        while(l <= r && Object.keys(hash).length !== r - l + 1) {
+            hash[s[l]]--
+            if(hash[s[l]] === 0) delete hash[s[l]]
+            l++
+        }
+        res = Math.max(res, r - l + 1)
+        r++
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From ae3212f1d1fb4b48c821bb3a0d4310a67263a539 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2024 03:15:26 -0700
Subject: [PATCH 3172/3374] Create
 3337-total-characters-in-string-after-transformations-ii.js

---
 ...ters-in-string-after-transformations-ii.js | 76 +++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 3337-total-characters-in-string-after-transformations-ii.js

diff --git a/3337-total-characters-in-string-after-transformations-ii.js b/3337-total-characters-in-string-after-transformations-ii.js
new file mode 100644
index 00000000..c0bab8a1
--- /dev/null
+++ b/3337-total-characters-in-string-after-transformations-ii.js
@@ -0,0 +1,76 @@
+const MOD = 1e9 + 7;
+const MODn = BigInt(MOD);
+/**
+ * @param {string} s
+ * @param {number} t
+ * @param {number[]} nums
+ * @return {number}
+ */
+var lengthAfterTransformations = function(s, t, nums) {
+    let vec = new Array(26).fill(0);
+    for(let i = 0; i < s.length; ++i) {
+        let chr = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        vec[chr] += 1;
+    }
+    let mat = new Array(26).fill(0).map(_ => new Array(26).fill(0n));
+    for(let i = 0; i < 26; ++i) {
+        let count = nums[i];
+        let j = (i + 1) % 26;
+        while(count > 0) {
+            mat[i][j] = 1n;
+            --count;
+            
+            j = (j + 1) % 26;
+        }
+
+    }
+
+    mat = matPow(mat, t);
+    let result = 0;
+    for(let i = 0; i < 26; ++i) {
+        for(let j = 0; j < 26; ++j) {
+            result += vec[i] * Number(mat[i][j]);
+        }
+        result = result % MOD;
+    }
+
+    return result;
+};
+
+
+
+function multiplyInto(mat1, mat2, output, tmp) {
+
+    for(let i = 0; i < output.length; ++i) {
+        for(let j = 0; j < output[0].length; ++j) {
+            let result = 0n;
+            for(let k = 0; k < output.length; ++k) {
+                result += mat1[i][k] * mat2[k][j];
+                result %= MODn;
+            }
+            tmp[i][j] = result;
+        }
+    }
+
+    for(let i = 0; i < output.length; ++i) {
+        for(let j = 0; j < output[0].length; ++j) {
+            output[i][j] = tmp[i][j];
+        }
+    }
+}
+
+function matPow(mat, exp) {
+    const result = new Array(mat.length).fill(0).map(_ => mat[0].slice(0).fill(0n));
+    const tmp = new Array(mat.length).fill(0).map(_ => mat[0].slice(0));
+    for(let i = 0; i < result.length; ++i) {
+        result[i][i] = 1n;
+    }
+
+    while (exp) {
+        if (exp & 1) { multiplyInto(mat, result, result, tmp); }
+        multiplyInto(mat, mat, mat, tmp);
+        exp >>>= 1;
+    }
+
+    return result;
+}

From f4834577772f5b917eb5aeee5ef18cf072397ddf Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2024 03:16:01 -0700
Subject: [PATCH 3173/3374] Create
 3336-find-the-number-of-subsequences-with-equal-gcd.js

---
 ...e-number-of-subsequences-with-equal-gcd.js | 37 +++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3336-find-the-number-of-subsequences-with-equal-gcd.js

diff --git a/3336-find-the-number-of-subsequences-with-equal-gcd.js b/3336-find-the-number-of-subsequences-with-equal-gcd.js
new file mode 100644
index 00000000..68092e4e
--- /dev/null
+++ b/3336-find-the-number-of-subsequences-with-equal-gcd.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var subsequencePairCount = function(nums) {
+    const a = nums
+    let n = a.length,
+        ans = 0,
+        M = 1e9 + 7,
+        dp = Array.from({ length: n }, () =>
+            Array.from({ length: 1 + Math.max(...a) }, () =>
+                new Array(1 + Math.max(...a)).fill(-1)
+            )
+        )
+
+    let recu = (idx, gcd_1, gcd_2) => {
+        if (idx === n)
+            return (gcd_1 === gcd_2 && gcd_1 !== 0)
+
+        if (dp.at(idx).at(gcd_1).at(gcd_2) !== -1)
+            return dp.at(idx).at(gcd_1).at(gcd_2)
+
+        let ans = recu(idx + 1, gcd_1, gcd_2) +
+                  recu(idx + 1, Math.gcd(gcd_1, a.at(idx)), gcd_2) +
+                  recu(idx + 1, gcd_1, Math.gcd(gcd_2, a.at(idx)))
+        ans %= M
+
+        return dp[idx][gcd_1][gcd_2] = ans
+    }
+
+    return recu(0, 0, 0)   
+};
+Math.gcd = function(a, b) {
+    if (b === 0)
+        return a
+    return Math.gcd(b, a % b)
+}

From 93791f9eb6fa6bd3b317293edf170e56c5da8f57 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2024 03:16:29 -0700
Subject: [PATCH 3174/3374] Create
 3335-total-characters-in-string-after-transformations-i.js

---
 ...cters-in-string-after-transformations-i.js | 25 +++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 3335-total-characters-in-string-after-transformations-i.js

diff --git a/3335-total-characters-in-string-after-transformations-i.js b/3335-total-characters-in-string-after-transformations-i.js
new file mode 100644
index 00000000..6e029569
--- /dev/null
+++ b/3335-total-characters-in-string-after-transformations-i.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @param {number} t
+ * @return {number}
+ */
+var lengthAfterTransformations = function (s, t) {
+  const MOD = 10 ** 9 + 7
+  let charCounts = new Array(26).fill(0)
+
+  for (const c of s) {
+    charCounts[c.charCodeAt(0) - 'a'.charCodeAt(0)] += 1
+  }
+
+  for (let i = 0; i < t; i++) {
+    const newCounts = new Array(26).fill(0)
+    for (let j = 0; j < 25; j++) {
+      newCounts[j + 1] += charCounts[j]
+    }
+    newCounts[0] = (newCounts[0] + charCounts[25]) % MOD
+    newCounts[1] = (newCounts[1] + charCounts[25]) % MOD
+    charCounts = newCounts
+  }
+
+  return charCounts.reduce((a, b) => (a + b) % MOD, 0)
+}

From 3c5c9acf078a42b20e4f74e16f0b3110f0c24541 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 27 Oct 2024 03:16:57 -0700
Subject: [PATCH 3175/3374] Create
 3334-find-the-maximum-factor-score-of-array.js

---
 ...-find-the-maximum-factor-score-of-array.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 3334-find-the-maximum-factor-score-of-array.js

diff --git a/3334-find-the-maximum-factor-score-of-array.js b/3334-find-the-maximum-factor-score-of-array.js
new file mode 100644
index 00000000..eab4ecba
--- /dev/null
+++ b/3334-find-the-maximum-factor-score-of-array.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxScore = function (nums) {
+  const n = nums.length
+  if (n === 1) {
+    return nums[0] * nums[0]
+  }
+
+  const totalGcd = gcdOfArray(nums)
+  const totalLcm = lcmOfArray(nums)
+  let res = totalGcd * totalLcm
+
+  for (let i = 0; i < n; i++) {
+    const remaining = nums.slice(0, i).concat(nums.slice(i + 1))
+    const currentGcd = gcdOfArray(remaining)
+    const currentLcm = lcmOfArray(remaining)
+    res = Math.max(res, currentGcd * currentLcm)
+  }
+
+  return res
+}
+
+function lcm(a, b) {
+  return (a / gcd(a, b)) * b
+}
+function gcd(a, b) {
+  return b ? gcd(b, a % b) : a
+}
+
+function lcmOfArray(arr) {
+  return arr.reduce((acc, val) => lcm(acc, val))
+}
+
+function gcdOfArray(arr) {
+  return arr.reduce((acc, val) => gcd(acc, val))
+}
+

From 7ad535dc1228124484f03737278743e003427a07 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 28 Oct 2024 13:19:43 +0800
Subject: [PATCH 3176/3374] Update 2537-count-the-number-of-good-subarrays.js

---
 2537-count-the-number-of-good-subarrays.js | 40 ++++++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/2537-count-the-number-of-good-subarrays.js b/2537-count-the-number-of-good-subarrays.js
index 8eb898ce..59b89eff 100644
--- a/2537-count-the-number-of-good-subarrays.js
+++ b/2537-count-the-number-of-good-subarrays.js
@@ -81,3 +81,43 @@ const countGood = function(nums, k) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countGood = function(nums, k) {
+  let res = 0
+  let total = 0
+  let i = 0, j = 0
+  const n = nums.length
+  const cnt = {}
+  while(i < n) {
+    while(j < n && total < k) {
+      total += calc(cnt, nums[j], 1)
+      cnt[nums[j]] = (cnt[nums[j]] || 0) + 1
+      j++
+    }
+    if(total >= k) {
+        res += n - j + 1
+    }
+    total += calc(cnt, nums[i], -1)
+    cnt[nums[i]]--
+
+    i++
+  }
+  
+  return res
+
+  function calc(cnt, num, delta) {
+    const tmp = cnt[num] || 0
+    let res = tmp * (tmp - 1) / 2
+    const tmp1 = tmp + delta
+    const tmp2 = tmp1 * (tmp1 - 1) / 2
+    res = tmp2 - res
+    return res
+  }
+};

From 282c827a2ed3c95d4ad373ac6265021223a799b8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 29 Oct 2024 13:46:05 +0800
Subject: [PATCH 3177/3374] Update
 3134-find-the-median-of-the-uniqueness-array.js

---
 ...find-the-median-of-the-uniqueness-array.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/3134-find-the-median-of-the-uniqueness-array.js b/3134-find-the-median-of-the-uniqueness-array.js
index 9e7dce3c..0bdfa43b 100644
--- a/3134-find-the-median-of-the-uniqueness-array.js
+++ b/3134-find-the-median-of-the-uniqueness-array.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const medianOfUniquenessArray = function(nums) {
+  const n = nums.length;
+  const {floor} = Math;
+  const total = (n * (n + 1)) / 2;
+  const half = floor((total + 1) / 2);
+  let l = 1, r = n
+  while(l < r) {
+    const mid = l + floor((r - l) / 2);
+    if (atMostK(nums, mid) >= half) {
+      r = mid;
+    } else {
+      l = mid + 1;
+    }
+  }
+  return l
+
+  function atMostK(nums, k) {
+    const hash = new Map(), n = nums.length;
+    let res = 0
+    let i = 0, j = 0
+    while(j < n) {
+        const e = nums[j]
+        if(!hash.has(e)) hash.set(e, 0)
+        hash.set(e, hash.get(e) + 1)
+        while(i < j && hash.size > k) {
+            
+            hash.set(nums[i], hash.get(nums[i]) - 1)
+            if(hash.get(nums[i]) === 0) {
+                hash.delete(nums[i])
+            }
+            i++
+        }
+        res += j - i + 1
+
+        j++
+    }
+
+    return res
+  }
+};
+
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}

From 73cf5d1faf65ecb87feed2d59cf90c2d0820a638 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2024 13:42:37 +0800
Subject: [PATCH 3178/3374] Update
 3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js

---
 ...an-be-rearranged-to-contain-a-string-ii.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)

diff --git a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
index 6c77b42b..a21dc780 100644
--- a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
+++ b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
@@ -47,3 +47,44 @@ var validSubstringCount = function (word1, word2) {
 
   return res
 }
+
+// another
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const validSubstringCount = function(word1, word2) {
+  const n = word1.length;
+  const target = Array(26).fill(0);
+  const a = 'a'.charCodeAt(0);
+  for(const ch of word2) {
+    target[ch.charCodeAt(0) - a]++;
+  }
+  const cur = Array(26).fill(0);
+  let j = 0
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const e = word1[i].charCodeAt(0) - a
+    while(j < n && !valid(cur, target)) {
+        cur[word1[j].charCodeAt(0) - a]++;
+        j++
+    }
+    if(valid(cur, target)) {
+      res += (n - 1) - (j - 1) + 1
+    }
+    cur[e]--;
+  }
+
+  return res
+
+  function valid(arr, target) {
+    for(let i = 0; i < 26; i++) {
+      if(arr[i] < target[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};

From fae5fc7b009bcb1b9e3f597a45741cf749e09635 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2024 15:24:09 +0800
Subject: [PATCH 3179/3374] Update
 3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js

---
 ...an-be-rearranged-to-contain-a-string-ii.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)

diff --git a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
index a21dc780..0111f0d6 100644
--- a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
+++ b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
@@ -1,3 +1,26 @@
+function validSubstringCount(w1, w2) {
+    const cnt = {};
+    for (const ch of w2) {
+        cnt[ch] = (cnt[ch] || 0) + 1;
+    }
+    let match = Object.keys(cnt).length, res = 0, j = 0;
+
+    for (let i = 0; i < w1.length; i++) {
+        cnt[w1[i]] = (cnt[w1[i]] || 0) - 1;
+        match -= cnt[w1[i]] === 0 ? 1 : 0;
+
+        while (match === 0) {
+            res += w1.length - i;
+            match += cnt[w1[j]] === 0 ? 1 : 0;
+            cnt[w1[j]] = (cnt[w1[j]] || 0) + 1;
+            j++;
+        }
+    }
+    return res;
+}
+
+// another
+
 /**
  * @param {string} word1
  * @param {string} word2

From 3ad902aa8a1a1f1a1feb13596c47342e50983095 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 31 Oct 2024 15:39:25 +0800
Subject: [PATCH 3180/3374] Update
 3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js

---
 ...an-be-rearranged-to-contain-a-string-ii.js | 43 +++++++++++++++++++
 1 file changed, 43 insertions(+)

diff --git a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
index 0111f0d6..9de78eab 100644
--- a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
+++ b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
@@ -1,3 +1,46 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const validSubstringCount = function(word1, word2) {
+  const n = word1.length;
+  const target = Array(26).fill(0);
+  const a = 'a'.charCodeAt(0);
+  for(const ch of word2) {
+    target[ch.charCodeAt(0) - a]++;
+  }
+  const targetCnt = target.reduce((acc, cur) => acc += cur > 0 ? 1 : 0, 0);
+  const cur = Array(26).fill(0);
+
+  let j = 0
+  let cnt = 0
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const e = word1[i].charCodeAt(0) - a
+    while(j < n && cnt < targetCnt) {
+        const idx= word1[j].charCodeAt(0) - a;
+        cur[idx]++;
+        if(cur[idx] === target[idx]) {
+          cnt++;
+        }
+        j++
+    }
+    if(cnt === targetCnt) {
+      res += (n - 1) - (j - 1) + 1
+    }
+    cur[e]--;
+    if(cur[e] === target[e] - 1) {
+      cnt--;
+    }
+  }
+  return res
+};
+
+// another
+
+
+
 function validSubstringCount(w1, w2) {
     const cnt = {};
     for (const ch of w2) {

From 0c66305a06c56d921c0cc37126092dbcd86915e8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Nov 2024 12:45:36 +0800
Subject: [PATCH 3181/3374] Create 3093-longest-common-suffix-queries.js

---
 3093-longest-common-suffix-queries.js | 55 +++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 3093-longest-common-suffix-queries.js

diff --git a/3093-longest-common-suffix-queries.js b/3093-longest-common-suffix-queries.js
new file mode 100644
index 00000000..61abc5d8
--- /dev/null
+++ b/3093-longest-common-suffix-queries.js
@@ -0,0 +1,55 @@
+/**
+ * @param {string[]} wordsContainer
+ * @param {string[]} wordsQuery
+ * @return {number[]}
+ */
+const stringIndices = function(wordsContainer, wordsQuery) {
+  const root = new TrieNode();
+  const arr = []
+    for (let i = 0; i < wordsContainer.length; i++) {
+        arr.push({ word: wordsContainer[i], index: i });
+    }
+    arr.sort((a, b) => {
+        if (a.word.length !== b.word.length) return a.word.length - b.word.length;
+        else return a.index - b.index;
+    })
+    for(let i = arr.length - 1; i >= 0; i--) {
+        let node = root;
+        const s = arr[i].word;
+        for(let j = s.length - 1; j >= 0; j--) {
+            const charIndex = s[j].charCodeAt(0) - 'a'.charCodeAt(0);
+            if(node.next[charIndex] === null) {
+                node.next[charIndex] = new TrieNode();
+            }
+            node = node.next[charIndex];
+            node.idx = arr[i].index;
+        }
+    }
+    root.idx = arr[0].index;
+    const res = []
+    for(const query of wordsQuery) {
+        let node = root;
+        let ans = -1;
+        for(let i = query.length - 1; i >= 0; i--) {
+            const charIndex = query[i].charCodeAt(0) - 'a'.charCodeAt(0);
+            if(node.next[charIndex] !== null) {
+                node = node.next[charIndex];
+            } else {
+                ans = node.idx;
+                break;
+            }
+        }
+        if(ans === -1) {
+            ans = node.idx;
+        }
+        res.push(ans);
+    }
+    return res;
+};
+
+class TrieNode {
+    constructor() {
+        this.next = new Array(26).fill(null);
+        this.idx = -1;
+    }
+}

From d02d1cb693291cc183123893800d5e2e4cb2193c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Nov 2024 12:51:31 +0800
Subject: [PATCH 3182/3374] Update 3093-longest-common-suffix-queries.js

---
 3093-longest-common-suffix-queries.js | 87 +++++++++++++--------------
 1 file changed, 43 insertions(+), 44 deletions(-)

diff --git a/3093-longest-common-suffix-queries.js b/3093-longest-common-suffix-queries.js
index 61abc5d8..1866b181 100644
--- a/3093-longest-common-suffix-queries.js
+++ b/3093-longest-common-suffix-queries.js
@@ -3,53 +3,52 @@
  * @param {string[]} wordsQuery
  * @return {number[]}
  */
-const stringIndices = function(wordsContainer, wordsQuery) {
-  const root = new TrieNode();
+const stringIndices = function (wordsContainer, wordsQuery) {
+  const root = new TrieNode()
   const arr = []
-    for (let i = 0; i < wordsContainer.length; i++) {
-        arr.push({ word: wordsContainer[i], index: i });
+  for (let i = 0; i < wordsContainer.length; i++) {
+    arr.push({ word: wordsContainer[i], index: i })
+  }
+  arr.sort((a, b) => {
+    if (a.word.length !== b.word.length) return a.word.length - b.word.length
+    else return a.index - b.index
+  })
+  for (let i = arr.length - 1; i >= 0; i--) {
+    let node = root
+    const s = arr[i].word
+    for (let j = s.length - 1; j >= 0; j--) {
+      const charIndex = s[j].charCodeAt(0) - 'a'.charCodeAt(0)
+      if (node.next[charIndex] === null) {
+        node.next[charIndex] = new TrieNode()
+      }
+      node = node.next[charIndex]
+      node.idx = arr[i].index
     }
-    arr.sort((a, b) => {
-        if (a.word.length !== b.word.length) return a.word.length - b.word.length;
-        else return a.index - b.index;
-    })
-    for(let i = arr.length - 1; i >= 0; i--) {
-        let node = root;
-        const s = arr[i].word;
-        for(let j = s.length - 1; j >= 0; j--) {
-            const charIndex = s[j].charCodeAt(0) - 'a'.charCodeAt(0);
-            if(node.next[charIndex] === null) {
-                node.next[charIndex] = new TrieNode();
-            }
-            node = node.next[charIndex];
-            node.idx = arr[i].index;
-        }
+  }
+  root.idx = arr[0].index
+  const res = []
+  for (const query of wordsQuery) {
+    let node = root
+    let ans = -1
+    for (let i = query.length - 1; i >= 0; i--) {
+      const charIndex = query[i].charCodeAt(0) - 'a'.charCodeAt(0)
+      if (node.next[charIndex] !== null) {
+        node = node.next[charIndex]
+      } else {
+        break
+      }
     }
-    root.idx = arr[0].index;
-    const res = []
-    for(const query of wordsQuery) {
-        let node = root;
-        let ans = -1;
-        for(let i = query.length - 1; i >= 0; i--) {
-            const charIndex = query[i].charCodeAt(0) - 'a'.charCodeAt(0);
-            if(node.next[charIndex] !== null) {
-                node = node.next[charIndex];
-            } else {
-                ans = node.idx;
-                break;
-            }
-        }
-        if(ans === -1) {
-            ans = node.idx;
-        }
-        res.push(ans);
-    }
-    return res;
-};
+
+    ans = node.idx
+
+    res.push(ans)
+  }
+  return res
+}
 
 class TrieNode {
-    constructor() {
-        this.next = new Array(26).fill(null);
-        this.idx = -1;
-    }
+  constructor() {
+    this.next = new Array(26).fill(null)
+    this.idx = -1
+  }
 }

From 5e7d7b36ff4922ead2fd98a7b0f632124cf6f31d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 5 Nov 2024 17:00:05 +0800
Subject: [PATCH 3183/3374] Update
 3076-shortest-uncommon-substring-in-an-array.js

---
 ...shortest-uncommon-substring-in-an-array.js | 65 +++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/3076-shortest-uncommon-substring-in-an-array.js b/3076-shortest-uncommon-substring-in-an-array.js
index 9a5ad533..51afd4bf 100644
--- a/3076-shortest-uncommon-substring-in-an-array.js
+++ b/3076-shortest-uncommon-substring-in-an-array.js
@@ -1,3 +1,68 @@
+/**
+ * @param {string[]} arr
+ * @return {string[]}
+ */
+const shortestSubstrings = function (arr) {
+  const ans = []
+  const head = new Node()
+  for (const s of arr) {
+    for (let i = 0; i < s.length; ++i) add(head, s, i)
+  }
+  for (const s of arr) {
+    let res = s + s
+    for (let i = 0; i < s.length; ++i) remove(head, s, i)
+    for (let i = 0; i < s.length; ++i) {
+      const t = check(head, s, i)
+      if (t.length < res.length || (t.length === res.length && t < res)) res = t
+    }
+    ans.push(res.length <= s.length ? res : "")
+     // add back the current string to the trie
+    for (let i = 0; i < s.length; ++i) add(head, s, i)
+  }
+  return ans
+
+  function add(head, s, ind) {
+    let ptr = head
+    for (let i = ind; i < s.length; ++i) {
+      const c = s.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) ptr.child[c] = new Node()
+      ptr = ptr.child[c]
+      ptr.count++
+    }
+  }
+
+  function remove(head, s, ind) {
+    let ptr = head
+    for (let i = ind; i < s.length; ++i) {
+      ptr = ptr.child[s.charCodeAt(i) - "a".charCodeAt(0)]
+      ptr.count--
+    }
+  }
+
+  function check(head, s, ind) {
+    let ptr = head
+    let ans = ""
+    for (let i = ind; i < s.length; ++i) {
+      const c = s.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) return ans
+      ans += s[i]
+      ptr = ptr.child[c]
+      if (ptr.count < 1) return ans
+    }
+    return s + s
+  }
+}
+
+class Node {
+  constructor() {
+    this.child = new Array(26).fill(null)
+    this.count = 0
+  }
+}
+
+// another
+
+
 /**
  * @param {string[]} arr
  * @return {string[]}

From dc59c61e56ef5ed96f215256157a20d10b551818 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 6 Nov 2024 13:29:01 +0800
Subject: [PATCH 3184/3374] Update
 3076-shortest-uncommon-substring-in-an-array.js

---
 ...shortest-uncommon-substring-in-an-array.js | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)

diff --git a/3076-shortest-uncommon-substring-in-an-array.js b/3076-shortest-uncommon-substring-in-an-array.js
index 51afd4bf..5f202f58 100644
--- a/3076-shortest-uncommon-substring-in-an-array.js
+++ b/3076-shortest-uncommon-substring-in-an-array.js
@@ -1,3 +1,67 @@
+/**
+ * @param {string[]} arr
+ * @return {string[]}
+ */
+const shortestSubstrings = function (arr) {
+  const root = new Node()
+  const res = []
+  for (const s of arr) {
+    for (let i = 0; i < s.length; ++i) {
+      add(root, s, i)
+    }
+  }
+  for (const s of arr) {
+    const tmpRoot = new Node()
+    let resStr = s + s
+    for (let i = 0; i < s.length; ++i) {
+      add(tmpRoot, s, i)
+    }
+
+    for (let i = 0; i < s.length; ++i) {
+      const t = check(root, tmpRoot, s, i)
+      if (
+        t.length < resStr.length ||
+        (t.length === resStr.length && t < resStr)
+      ) {
+        resStr = t
+      }
+    }
+    res.push(resStr.length <= s.length ? resStr : "")
+  }
+
+  return res
+  function add(node, str, start) {
+    let ptr = node
+    for (let i = start; i < str.length; ++i) {
+      const c = str.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) ptr.child[c] = new Node()
+      ptr = ptr.child[c]
+      ptr.count++
+    }
+  }
+  function check(root, node, str, start) {
+    let ptr1 = root
+    let ptr2 = node
+    let res = ""
+    for (let i = start; i < str.length; ++i) {
+      const chIdx = str.charCodeAt(i) - "a".charCodeAt(0)
+      res += str[i]
+      ptr1 = ptr1.child[chIdx]
+      ptr2 = ptr2.child[chIdx]
+      if (ptr1.count === ptr2.count) return res
+    }
+    return str + str
+  }
+}
+class Node {
+  constructor() {
+    this.child = new Array(26).fill(null)
+    this.count = 0
+  }
+}
+
+// another
+
 /**
  * @param {string[]} arr
  * @return {string[]}

From c3e8486c5e7eae9487cd9836a825d6104f522e2e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 8 Nov 2024 15:03:02 +0800
Subject: [PATCH 3185/3374] Update 778-swim-in-rising-water.js

---
 778-swim-in-rising-water.js | 106 ++++++++++++++++++++++++++++++++++++
 1 file changed, 106 insertions(+)

diff --git a/778-swim-in-rising-water.js b/778-swim-in-rising-water.js
index c39e9372..22e51580 100644
--- a/778-swim-in-rising-water.js
+++ b/778-swim-in-rising-water.js
@@ -1,3 +1,109 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const swimInWater = function(grid) {
+    const pq = new PQ((a, b) => a[0] < b[0])
+    const dirs = [
+        [0, 1],
+        [0, -1],
+        [1, 0],
+        [-1, 0]
+    ]
+    const n = grid.length
+    const visited = Array.from({ length: n }, () => Array(n).fill(false))
+    pq.push([grid[0][0], 0, 0])
+    visited[0][0] = true
+    let res = 0
+
+    while (!pq.isEmpty()) {
+        const [h, x, y] = pq.pop()
+        res = Math.max(res, h)
+        if (x === n - 1 && y === n - 1) {
+            return res
+        }
+        for (const [dx, dy] of dirs) {
+            const nx = x + dx
+            const ny = y + dy
+            if (nx < 0 || nx >= n || ny < 0 || ny >= n || visited[nx][ny]) {
+                continue
+            }
+            pq.push([grid[nx][ny], nx, ny])
+            visited[nx][ny] = true
+        }
+    }
+};
+
+class PQ {
+    constructor(comparator = (a, b) => a > b) {
+      this.heap = []
+      this.top = 0
+      this.comparator = comparator
+    }
+    size() {
+      return this.heap.length
+    }
+    isEmpty() {
+      return this.size() === 0
+    }
+    peek() {
+      return this.heap[this.top]
+    }
+    push(...values) {
+      values.forEach((value) => {
+        this.heap.push(value)
+        this.siftUp()
+      })
+      return this.size()
+    }
+    pop() {
+      const poppedValue = this.peek()
+      const bottom = this.size() - 1
+      if (bottom > this.top) {
+        this.swap(this.top, bottom)
+      }
+      this.heap.pop()
+      this.siftDown()
+      return poppedValue
+    }
+    replace(value) {
+      const replacedValue = this.peek()
+      this.heap[this.top] = value
+      this.siftDown()
+      return replacedValue
+    }
+  
+    parent = (i) => ((i + 1) >>> 1) - 1
+    left = (i) => (i << 1) + 1
+    right = (i) => (i + 1) << 1
+    greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+    swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+    siftUp = () => {
+      let node = this.size() - 1
+      while (node > this.top && this.greater(node, this.parent(node))) {
+        this.swap(node, this.parent(node))
+        node = this.parent(node)
+      }
+    }
+    siftDown = () => {
+      let node = this.top
+      while (
+        (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+        (this.right(node) < this.size() && this.greater(this.right(node), node))
+      ) {
+        let maxChild =
+          this.right(node) < this.size() &&
+          this.greater(this.right(node), this.left(node))
+            ? this.right(node)
+            : this.left(node)
+        this.swap(node, maxChild)
+        node = maxChild
+      }
+    }
+  }
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}

From 68cf95b624d2d66e2b24b8f6bc71a2858c62da05 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Nov 2024 06:05:33 -0800
Subject: [PATCH 3186/3374] Update 787-cheapest-flights-within-k-stops.js

---
 787-cheapest-flights-within-k-stops.js | 28 ++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/787-cheapest-flights-within-k-stops.js b/787-cheapest-flights-within-k-stops.js
index db9dd6dc..416e42a9 100644
--- a/787-cheapest-flights-within-k-stops.js
+++ b/787-cheapest-flights-within-k-stops.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number} n
+ * @param {number[][]} flights
+ * @param {number} src
+ * @param {number} dst
+ * @param {number} k
+ * @return {number}
+ */
+var findCheapestPrice = function(n, flights, src, dst, k) {
+    let cost = new Array(n).fill(Number.MAX_SAFE_INTEGER);
+    cost[src] = 0;
+    
+    for (let i = 0; i <= k; i++) {
+        let temp = [...cost];
+        for (let [curr, next, price] of flights) {
+            if (cost[curr] === Number.MAX_SAFE_INTEGER) {
+                continue;
+            }
+            temp[next] = Math.min(temp[next], cost[curr] + price);
+        }
+        cost = temp;
+    }
+    
+    return cost[dst] === Number.MAX_SAFE_INTEGER ? -1 : cost[dst];
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} flights

From 2dc3c96f6ca65a57cd7197d4f3feebff151e8df9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 9 Nov 2024 06:31:26 -0800
Subject: [PATCH 3187/3374] Update 787-cheapest-flights-within-k-stops.js

---
 787-cheapest-flights-within-k-stops.js | 29 +++++++++++++-------------
 1 file changed, 14 insertions(+), 15 deletions(-)

diff --git a/787-cheapest-flights-within-k-stops.js b/787-cheapest-flights-within-k-stops.js
index 416e42a9..ea51e87f 100644
--- a/787-cheapest-flights-within-k-stops.js
+++ b/787-cheapest-flights-within-k-stops.js
@@ -7,23 +7,22 @@
  * @return {number}
  */
 var findCheapestPrice = function(n, flights, src, dst, k) {
-    let cost = new Array(n).fill(Number.MAX_SAFE_INTEGER);
-    cost[src] = 0;
-    
-    for (let i = 0; i <= k; i++) {
-        let temp = [...cost];
-        for (let [curr, next, price] of flights) {
-            if (cost[curr] === Number.MAX_SAFE_INTEGER) {
-                continue;
-            }
-            temp[next] = Math.min(temp[next], cost[curr] + price);
-        }
-        cost = temp;
-    }
-    
-    return cost[dst] === Number.MAX_SAFE_INTEGER ? -1 : cost[dst];
+  let cost = Array(n).fill(Infinity)
+  cost[src] = 0
+  
+  for(let i = 0; i <= k; i++) {
+      const tmp = [...cost]
+      for(const [f, t, p] of flights) {
+          if(cost[f] === Infinity) continue
+          tmp[t] = Math.min(tmp[t], cost[f] + p)
+      }
+      cost = tmp
+  }
+  
+  return cost[dst] === Infinity ? -1 : cost[dst]
 };
 
+
 // another
 
 /**

From 154527e1a799ab7c5332b5c1995b385f1d427305 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2024 12:45:27 +0800
Subject: [PATCH 3188/3374] Create
 3349-adjacent-increasing-subarrays-detection-i.js

---
 ...jacent-increasing-subarrays-detection-i.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3349-adjacent-increasing-subarrays-detection-i.js

diff --git a/3349-adjacent-increasing-subarrays-detection-i.js b/3349-adjacent-increasing-subarrays-detection-i.js
new file mode 100644
index 00000000..98346711
--- /dev/null
+++ b/3349-adjacent-increasing-subarrays-detection-i.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+var hasIncreasingSubarrays = function (nums, k) {
+  const n = nums.length
+
+  for (let i = 0; i <= n - 2 * k; ++i) {
+    let firstIncreasing = true
+    let secondIncreasing = true
+
+    for (let j = i; j < i + k - 1; ++j) {
+      if (nums[j] >= nums[j + 1]) {
+        firstIncreasing = false
+        break
+      }
+    }
+
+    if (!firstIncreasing) continue
+
+    for (let j = i + k; j < i + 2 * k - 1; ++j) {
+      if (nums[j] >= nums[j + 1]) {
+        secondIncreasing = false
+        break
+      }
+    }
+
+    if (firstIncreasing && secondIncreasing) return true
+  }
+
+  return false
+}

From 35e3bffffee739bc1bcf002a2e38e7e9a9c8f930 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2024 12:46:10 +0800
Subject: [PATCH 3189/3374] Create
 3350-adjacent-increasing-subarrays-detection-ii.js

---
 ...acent-increasing-subarrays-detection-ii.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 3350-adjacent-increasing-subarrays-detection-ii.js

diff --git a/3350-adjacent-increasing-subarrays-detection-ii.js b/3350-adjacent-increasing-subarrays-detection-ii.js
new file mode 100644
index 00000000..537a67a3
--- /dev/null
+++ b/3350-adjacent-increasing-subarrays-detection-ii.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxIncreasingSubarrays = function (nums) {
+  const n = nums.length
+
+  const increasingRun = new Array(n).fill(1)
+  for (let i = n - 2; i >= 0; --i) {
+    if (nums[i] < nums[i + 1]) {
+      increasingRun[i] = increasingRun[i + 1] + 1
+    }
+  }
+
+  let left = 1,
+    right = Math.floor(n / 2)
+  let res = 0
+
+  while (left <= right) {
+    const mid = left + Math.floor((right - left) / 2)
+    let found = false
+
+    for (let i = 0; i <= n - 2 * mid; ++i) {
+      if (increasingRun[i] >= mid && increasingRun[i + mid] >= mid) {
+        found = true
+        break
+      }
+    }
+
+    if (found) {
+      res = mid
+      left = mid + 1
+    } else {
+      right = mid - 1
+    }
+  }
+
+  return res
+}

From 6b4f4cf5c576b7a5e011488a58e56aa69f95f283 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2024 12:47:02 +0800
Subject: [PATCH 3190/3374] Create 3351-sum-of-good-subsequences.js

---
 3351-sum-of-good-subsequences.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3351-sum-of-good-subsequences.js

diff --git a/3351-sum-of-good-subsequences.js b/3351-sum-of-good-subsequences.js
new file mode 100644
index 00000000..ce62e9df
--- /dev/null
+++ b/3351-sum-of-good-subsequences.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var sumOfGoodSubsequences = function (nums) {
+    const mod = 1000000007n;
+    const MAX = 100005;
+    const sum = new Array(MAX).fill(0n);
+    const cnt = new Array(MAX).fill(0n);
+
+    for (let i = nums.length - 1; i >= 0; i--) {
+        const v = nums[i];
+        cnt[v]++;
+
+        const tmp = 1n + cnt[v + 1] + (cnt[v - 1] || 0n);
+        cnt[v] += cnt[v + 1];
+        cnt[v] += cnt[v - 1] || 0n;
+
+        sum[v] += BigInt(v) * tmp;
+
+        sum[v] += sum[v + 1];
+        sum[v] += sum[v - 1] || 0n;
+
+        cnt[v] %= mod;
+        sum[v] %= mod;
+    }
+
+    return Number(sum.reduce((a, b) => (a + b) % mod, 0n));
+}

From 27cff671ca04466f2682f918eb7057cbd8522a1b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2024 14:33:59 +0800
Subject: [PATCH 3191/3374] Update 3351-sum-of-good-subsequences.js

---
 3351-sum-of-good-subsequences.js | 39 ++++++++++++--------------------
 1 file changed, 14 insertions(+), 25 deletions(-)

diff --git a/3351-sum-of-good-subsequences.js b/3351-sum-of-good-subsequences.js
index ce62e9df..84b8b7a2 100644
--- a/3351-sum-of-good-subsequences.js
+++ b/3351-sum-of-good-subsequences.js
@@ -2,28 +2,17 @@
  * @param {number[]} nums
  * @return {number}
  */
-var sumOfGoodSubsequences = function (nums) {
-    const mod = 1000000007n;
-    const MAX = 100005;
-    const sum = new Array(MAX).fill(0n);
-    const cnt = new Array(MAX).fill(0n);
-
-    for (let i = nums.length - 1; i >= 0; i--) {
-        const v = nums[i];
-        cnt[v]++;
-
-        const tmp = 1n + cnt[v + 1] + (cnt[v - 1] || 0n);
-        cnt[v] += cnt[v + 1];
-        cnt[v] += cnt[v - 1] || 0n;
-
-        sum[v] += BigInt(v) * tmp;
-
-        sum[v] += sum[v + 1];
-        sum[v] += sum[v - 1] || 0n;
-
-        cnt[v] %= mod;
-        sum[v] %= mod;
-    }
-
-    return Number(sum.reduce((a, b) => (a + b) % mod, 0n));
-}
+const sumOfGoodSubsequences = function(nums) {
+  const limit = 1e5 + 10;
+  const mod = 1e9 + 7;
+  const count = Array(limit).fill(0);
+  const total = Array(limit).fill(0);
+  let res = 0;
+  for(const e of nums) {
+    count[e + 1] = (count[e] + count[e + 1] + count[e + 2] + 1) % mod
+    const cur = total[e] + total[e + 2] + e * (count[e] + count[e + 2] + 1)
+    total[e + 1] = (total[e + 1] + cur) % mod
+    res =(res + cur) % mod
+  }
+  return res
+};

From 3a115fa586b539e67ec8a5a4efebe5315bd8e98e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 11 Nov 2024 16:27:23 +0800
Subject: [PATCH 3192/3374] Create
 3352-count-k-reducible-numbers-less-than-n.js

---
 3352-count-k-reducible-numbers-less-than-n.js | 58 +++++++++++++++++++
 1 file changed, 58 insertions(+)
 create mode 100644 3352-count-k-reducible-numbers-less-than-n.js

diff --git a/3352-count-k-reducible-numbers-less-than-n.js b/3352-count-k-reducible-numbers-less-than-n.js
new file mode 100644
index 00000000..5ce98c75
--- /dev/null
+++ b/3352-count-k-reducible-numbers-less-than-n.js
@@ -0,0 +1,58 @@
+const ll = BigInt,
+  mod = ll(1e9 + 7),
+  N = 1e4 + 15
+let fact = Array(N).fill(0),
+  ifact = Array(N).fill(0),
+  inv = Array(N).fill(0)
+const hcomb = (p, q) => (p == 0 && q == 0 ? 1 : comb(p + q - 1, q))
+const comb_init = () => {
+  fact[0] = ifact[0] = inv[1] = 1n // factorial, inverse factorial
+  for (let i = 2; i < N; i++)
+    inv[i] = ((mod - mod / ll(i)) * inv[mod % ll(i)]) % mod
+  for (let i = 1; i < N; i++) {
+    fact[i] = (fact[i - 1] * ll(i)) % mod
+    ifact[i] = (ifact[i - 1] * inv[i]) % mod
+  }
+}
+
+// combination mod pick k from n
+const comb = (n, k) => {
+  if (n < k || k < 0) return 0
+  return (((fact[n] * ifact[k]) % mod) * ifact[n - k]) % mod
+}
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var countKReducibleNumbers = function (s, k) {
+  let dp = new Array(1000).fill(0)
+  for (let i = 2; i < 1000; i++) {
+    dp[i] = dp[bitCnt(i)] + 1
+  }
+  let c1 = 0
+  let n = s.length
+  let res = 0n
+  comb_init()
+  for (let i = 0; i < n; i++) {
+    if (s[i] === "1") {
+      for (let c2 = 0; c2 < n - i; c2++) {
+        if (c1 + c2 > 0 && dp[c1 + c2] + 1 <= k) {
+          res = res + comb(n - i - 1, c2)
+        }
+      }
+      c1++
+    }
+  }
+  return Number(res % mod)
+
+  function bitCnt(num) {
+    let cnt = 0
+    while (num) {
+      cnt += num & 1
+      num >>= 1
+    }
+    return cnt
+  }
+}

From e47fab6385cc88f165bb9e703c44eed4e3d74e4b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 13 Nov 2024 13:48:01 +0800
Subject: [PATCH 3193/3374] Update
 1786-number-of-restricted-paths-from-first-to-last-node.js

---
 ...estricted-paths-from-first-to-last-node.js | 114 ++++++++++++++++++
 1 file changed, 114 insertions(+)

diff --git a/1786-number-of-restricted-paths-from-first-to-last-node.js b/1786-number-of-restricted-paths-from-first-to-last-node.js
index 6a80fd88..511174a9 100644
--- a/1786-number-of-restricted-paths-from-first-to-last-node.js
+++ b/1786-number-of-restricted-paths-from-first-to-last-node.js
@@ -1,3 +1,117 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countRestrictedPaths = function(n, edges) {
+  const g = {}
+    for (let [u, v, w] of edges) {
+        g[u] = g[u] || []
+        g[u].push([v, w])
+        g[v] = g[v] || []
+        g[v].push([u, w])
+    }
+    const dist = Array(n + 1).fill(Infinity)
+    dist[n] = 0
+    const pq = new PQ((a, b) => a[0] < b[0])
+    pq.push([0, n])
+    while(!pq.isEmpty()) {
+        const [d, u] = pq.pop()
+        if (d !== dist[u]) continue
+        for (let [v, w] of (g[u] || [])) {
+            if (dist[v] > dist[u] + w) {
+                dist[v] = dist[u] + w
+                pq.push([dist[v], v])
+            }
+        }
+    }
+    const mod = 1e9 + 7
+    const memo = Array(n + 1).fill(null)
+    const dfs = (src) => {
+        if (memo[src] !== null) return memo[src]
+        if (src === n) return 1
+        let res = 0
+        for (let [v, w] of (g[src] || [])) {
+            if (dist[src] > dist[v]) {
+                res = (res + dfs(v)) % mod
+            }
+        }
+        return memo[src] = res
+    }
+    return dfs(1)
+};
+
+class PQ {
+    constructor(comparator = (a, b) => a > b) {
+      this.heap = []
+      this.top = 0
+      this.comparator = comparator
+    }
+    size() {
+      return this.heap.length
+    }
+    isEmpty() {
+      return this.size() === 0
+    }
+    peek() {
+      return this.heap[this.top]
+    }
+    push(...values) {
+      values.forEach((value) => {
+        this.heap.push(value)
+        this.siftUp()
+      })
+      return this.size()
+    }
+    pop() {
+      const poppedValue = this.peek()
+      const bottom = this.size() - 1
+      if (bottom > this.top) {
+        this.swap(this.top, bottom)
+      }
+      this.heap.pop()
+      this.siftDown()
+      return poppedValue
+    }
+    replace(value) {
+      const replacedValue = this.peek()
+      this.heap[this.top] = value
+      this.siftDown()
+      return replacedValue
+    }
+  
+    parent = (i) => ((i + 1) >>> 1) - 1
+    left = (i) => (i << 1) + 1
+    right = (i) => (i + 1) << 1
+    greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+    swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+    siftUp = () => {
+      let node = this.size() - 1
+      while (node > this.top && this.greater(node, this.parent(node))) {
+        this.swap(node, this.parent(node))
+        node = this.parent(node)
+      }
+    }
+    siftDown = () => {
+      let node = this.top
+      while (
+        (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+        (this.right(node) < this.size() && this.greater(this.right(node), node))
+      ) {
+        let maxChild =
+          this.right(node) < this.size() &&
+          this.greater(this.right(node), this.left(node))
+            ? this.right(node)
+            : this.left(node)
+        this.swap(node, maxChild)
+        node = maxChild
+      }
+    }
+  }
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From ad8bff65e31f1bb1b5371c7ca528c6a86b7f634f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Nov 2024 05:21:54 -0800
Subject: [PATCH 3194/3374] Create 3354-make-array-elements-equal-to-zero.js

---
 3354-make-array-elements-equal-to-zero.js | 33 +++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3354-make-array-elements-equal-to-zero.js

diff --git a/3354-make-array-elements-equal-to-zero.js b/3354-make-array-elements-equal-to-zero.js
new file mode 100644
index 00000000..7f7a6c0d
--- /dev/null
+++ b/3354-make-array-elements-equal-to-zero.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countValidSelections = function (nums) {
+  let res = 0
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] === 0) {
+      if (canZeroOut(i, -1)) {
+        res += 1
+      }
+      if (canZeroOut(i, 1)) {
+        res += 1
+      }
+    }
+  }
+  return res
+  function canZeroOut(start, direction) {
+    let tempNums = nums.slice()
+    let curr = start
+
+    while (curr >= 0 && curr < tempNums.length) {
+      if (tempNums[curr] === 0) {
+        curr += direction
+      } else {
+        tempNums[curr] -= 1
+        direction *= -1
+        curr += direction
+      }
+    }
+    return tempNums.every((x) => x === 0)
+  }
+}

From 35f6563b677494d7289464ff55288c1e30c393c2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Nov 2024 05:22:27 -0800
Subject: [PATCH 3195/3374] Create 3355-zero-array-transformation-i.js

---
 3355-zero-array-transformation-i.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 3355-zero-array-transformation-i.js

diff --git a/3355-zero-array-transformation-i.js b/3355-zero-array-transformation-i.js
new file mode 100644
index 00000000..db5e35b7
--- /dev/null
+++ b/3355-zero-array-transformation-i.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {boolean}
+ */
+var isZeroArray = function(nums, queries) {
+    const n = nums.length
+    const arr = Array(n + 1).fill(0)
+    for(const [l, r] of queries) {
+        arr[l]++
+        arr[r + 1]--
+    }
+    
+    for(let i = 1; i <= n; i++) {
+        arr[i] += arr[i - 1]
+    }
+    for(let i = 0; i < n; i++) {
+        if(nums[i] > arr[i]) return false
+    }
+    
+    return true
+};

From 4c69a8f737a85381310ed100229ae27fd222722f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Nov 2024 05:22:54 -0800
Subject: [PATCH 3196/3374] Create 3356-zero-array-transformation-ii.js

---
 3356-zero-array-transformation-ii.js | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3356-zero-array-transformation-ii.js

diff --git a/3356-zero-array-transformation-ii.js b/3356-zero-array-transformation-ii.js
new file mode 100644
index 00000000..eeefa1d4
--- /dev/null
+++ b/3356-zero-array-transformation-ii.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  if (nums.every((num) => num === 0)) return 0
+  const n = nums.length
+  const delta = new Array(n + 1).fill(0)
+
+  for (let index = 0; index < queries.length; index++) {
+    const query = queries[index]
+    const l = query[0]
+    const r = query[1]
+    const diff = query[2]
+
+    delta[l] += diff
+    if (r + 1 < n) {
+      delta[r + 1] -= diff
+    }
+
+    let curDiff = 0
+    let success = true
+
+    for (let i = 0; i < n; i++) {
+      curDiff += delta[i]
+      if (nums[i] > curDiff) {
+        success = false
+        break
+      }
+    }
+
+    if (!success) continue
+    return index + 1
+  }
+  return -1
+}

From cd33c0f9fd4e79a10c86ebfb4c279feb2ab2a8d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 18 Nov 2024 12:55:44 +0800
Subject: [PATCH 3197/3374] Update
 2577-minimum-time-to-visit-a-cell-in-a-grid.js

---
 ...-minimum-time-to-visit-a-cell-in-a-grid.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2577-minimum-time-to-visit-a-cell-in-a-grid.js b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
index 7412633f..765f81e5 100644
--- a/2577-minimum-time-to-visit-a-cell-in-a-grid.js
+++ b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumTime = function(grid) {
+    if(grid[0][0] > 0) return -1
+      if(grid[0][1] > 1 && grid[1][0] > 1) return -1
+  const m = grid.length, n = grid[0].length;
+    const pq = new PQ((a, b) => a[0] < b[0]);
+    pq.push([0, 0, 0]);
+    const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]];
+    const dist = Array.from({ length: m }, () => Array(n).fill(-1));
+
+    while (!pq.isEmpty()) {
+        const [t, i, j] = pq.pop();
+        if (dist[i][j] !== -1) continue;
+        dist[i][j] = t
+        if (i === m - 1 && j === n - 1) break;
+        for(const [di, dj] of dirs) {
+            const ni = i + di, nj = j + dj;
+            if (ni < 0 || ni >= m || nj < 0 || nj >= n) continue;
+            if (dist[ni][nj] !== -1) continue;
+            if(grid[ni][nj] <= t + 1) {
+                pq.push([t + 1, ni, nj]);
+            } else if ((grid[ni][nj] - t) % 2 === 0) {
+                pq.push([grid[ni][nj] + 1, ni, nj]);
+            } else {
+                pq.push([grid[ni][nj], ni, nj]);
+            }
+        }
+    }
+
+    return dist[m - 1][n - 1];
+};
+
+
+// another
+
 class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []

From e0d9cdd5740e1e0ab8eb2abef1fa682cbfabd483 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 19 Nov 2024 15:40:06 +0800
Subject: [PATCH 3198/3374] Update
 2662-minimum-cost-of-a-path-with-special-roads.js

---
 ...nimum-cost-of-a-path-with-special-roads.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/2662-minimum-cost-of-a-path-with-special-roads.js b/2662-minimum-cost-of-a-path-with-special-roads.js
index ecd4338c..0133ae63 100644
--- a/2662-minimum-cost-of-a-path-with-special-roads.js
+++ b/2662-minimum-cost-of-a-path-with-special-roads.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} start
+ * @param {number[]} target
+ * @param {number[][]} specialRoads
+ * @return {number}
+ */
+const minimumCost = function(start, target, specialRoads) {
+  const n = specialRoads.length;
+  let res = Infinity;
+  const pq = new PQ((a, b) => a[0] < b[0]);
+  const dist = Array(n).fill(Infinity);
+  const { abs } = Math;
+  for(let i = 0; i < n; i++) {
+    const [x, y, x2, y2, cost] = specialRoads[i];
+    dist[i] = abs(start[0] - x) + abs(start[1] - y) + cost;
+    pq.push([dist[i], i]);
+  }
+  res = abs(target[0] - start[0]) + abs(target[1] - start[1])
+  while(!pq.isEmpty()) {
+    const [d, i] = pq.pop();
+    if(d !== dist[i]) continue;
+    const e = specialRoads[i];
+    res = Math.min(res, d + abs(target[0] - e[2]) + abs(target[1] - e[3]));
+    for(let j = 0; j < n; j++) {
+      const w = abs(e[2] - specialRoads[j][0]) + abs(e[3] - specialRoads[j][1]) + specialRoads[j][4];
+      if(d + w < dist[j]) {
+        dist[j] = d + w;
+        pq.push([dist[j], j]);
+      }
+    }
+  }
+  
+  return res
+};
+
+// another
+
+
 class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []

From 6a80d376f0f13b3758908124e570f4486a632696 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 21 Nov 2024 12:38:17 +0800
Subject: [PATCH 3199/3374] Update
 3112-minimum-time-to-visit-disappearing-nodes.js

---
 ...inimum-time-to-visit-disappearing-nodes.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/3112-minimum-time-to-visit-disappearing-nodes.js b/3112-minimum-time-to-visit-disappearing-nodes.js
index 96acaeeb..ec24d5cc 100644
--- a/3112-minimum-time-to-visit-disappearing-nodes.js
+++ b/3112-minimum-time-to-visit-disappearing-nodes.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} disappear
+ * @return {number[]}
+ */
+const minimumTime = function(n, edges, disappear) {
+  const g = Array.from({ length: n }, () => [])
+    for (const [u, v, w] of edges) {
+        g[u].push([v, w])
+        g[v].push([u, w])
+    }
+    const pq = new PQ((a, b) => a[1] < b[1])
+    pq.push([0, 0])
+    const res = Array(n).fill(-1)
+    while(!pq.isEmpty()) {
+        const [u, t] = pq.pop()
+        if (res[u] !== -1) continue
+        res[u] = t
+        for(const [v, w] of g[u]) {
+            if (res[v] === -1 && t + w < disappear[v]) {
+                pq.push([v, t + w])
+            }
+        }
+    }
+
+    return res
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 9b4cdf58c4b6b8a89b1f3b1c617a6e68360339fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 22 Nov 2024 13:06:13 +0800
Subject: [PATCH 3200/3374] Update 3123-find-edges-in-shortest-paths.js

---
 3123-find-edges-in-shortest-paths.js | 59 ++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)

diff --git a/3123-find-edges-in-shortest-paths.js b/3123-find-edges-in-shortest-paths.js
index 670b3013..3694b4ad 100644
--- a/3123-find-edges-in-shortest-paths.js
+++ b/3123-find-edges-in-shortest-paths.js
@@ -1,3 +1,62 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean[]}
+ */
+const findAnswer = function (n, edges) {
+  const m = edges.length
+  const res = Array(m).fill(false)
+  const MAX = Number.MAX_SAFE_INTEGER
+  const g = Array(n)
+    .fill(null)
+    .map(() => [])
+  for (const [u, v, w] of edges) {
+    g[u].push([v, w])
+    g[v].push([u, w])
+  }
+  const dist = Array(n).fill(MAX)
+  dist[0] = 0
+  const pq = new PQ((a, b) => a[1] < b[1])
+  pq.push([0, 0])
+  while (!pq.isEmpty()) {
+    const [u, d] = pq.pop()
+    if (d > dist[u]) continue
+    for (const [v, w] of g[u]) {
+      if (dist[v] > d + w) {
+        dist[v] = d + w
+        pq.push([v, dist[v]])
+      }
+    }
+  }
+  const dist1 = Array(n).fill(MAX)
+  dist1[n - 1] = 0
+  pq.push([n - 1, 0])
+  while (!pq.isEmpty()) {
+    const [u, d] = pq.pop()
+    if (d > dist1[u]) continue
+    for (const [v, w] of g[u]) {
+      if (dist1[v] > d + w) {
+        dist1[v] = d + w
+        pq.push([v, dist1[v]])
+      }
+    }
+  }
+  for (let i = 0; i < m; i++) {
+    const [u, v, w] = edges[i]
+    if (
+      dist[u] + dist1[v] + w === dist[n - 1] ||
+      dist[v] + dist1[u] + w === dist[n - 1]
+    ) {
+      res[i] = true
+    }
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From b1e7aff6a0cfa61738e2850c59eed5d3487217b9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Nov 2024 02:50:53 -0800
Subject: [PATCH 3201/3374] Create
 3342-find-minimum-time-to-reach-last-room-ii.js

---
 ...find-minimum-time-to-reach-last-room-ii.js | 99 +++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 3342-find-minimum-time-to-reach-last-room-ii.js

diff --git a/3342-find-minimum-time-to-reach-last-room-ii.js b/3342-find-minimum-time-to-reach-last-room-ii.js
new file mode 100644
index 00000000..ce21d124
--- /dev/null
+++ b/3342-find-minimum-time-to-reach-last-room-ii.js
@@ -0,0 +1,99 @@
+/**
+ * @param {number[][]} moveTime
+ * @return {number}
+ */
+var minTimeToReach = function (moveTime) {
+    const a = moveTime
+    let m = a.length, n = a.at(0).length
+
+    let pq = new _PriorityQueue((x, y) => {
+        if (x.at(0) !== y.at(0)) return x.at(0) - y.at(0)
+        if (x.at(2) !== y.at(2)) return x.at(2) - y.at(2)
+    })
+    pq.push([0, 0, 0, 1])
+
+    let di = new Array(m).fill().map(() => new Array(n).fill(1e15))
+    di[0][0] = 0
+
+    while (pq.size()) {
+        let fr = pq.top()
+        pq.pop()
+
+        let d = fr.at(0), x = fr.at(1), y = fr.at(2), st = fr.at(3)
+
+        if (x == m - 1 && y == n - 1)
+            return d
+
+        new Array([-1, 0], [0, -1], [0, 1], [1, 0]).forEach(([dx, dy]) => {
+            if (0 <= x + dx && x + dx < m && 0 <= y + dy && y + dy < n)
+            {
+                let tmp = Math.max(a.at(x + dx).at(y + dy) - d, 0)
+                
+                if (di.at(x + dx).at(y + dy) > d + tmp + st) {
+                    di[x + dx][y + dy] = d + tmp + st
+                    pq.push([di.at(x + dx).at(y + dy), x + dx, y + dy, (st === 1 ? 2 : 1)])
+                }
+            }
+        })
+    }
+}
+
+
+// Binary Heap
+class _PriorityQueue {
+    constructor(cmp) {
+        this.arr = new Array()
+        this.cmp = cmp || ((a, b) => a - b)
+    }
+
+    push(x) {
+        this.arr.push(x)
+        this.heapifyUp()
+    }
+
+    heapifyUp() {
+        let cId = this.size() - 1,
+            pId = this.parentIndex(cId)
+        while (cId > 0 && this.cmp(this.arr.at(cId), this.arr.at(pId)) < 0)
+        {
+            Math.swap(this.arr, cId, pId)
+            cId = pId
+            pId = this.parentIndex(cId)
+        }
+    }
+
+    pop() {
+        if (this.size() === 0)
+            return
+        this.arr[0] = this.arr.pop()
+        this.heapifyDown()
+    }
+
+    heapifyDown() {
+        let pId = 0,
+            lcId = this.leftChildIndex(pId),
+            rcId = this.rightChildIndex(pId)
+        while (lcId < this.size())
+        {
+            let sc = lcId
+            if (rcId < this.size() && this.cmp(this.arr.at(rcId), this.arr.at(lcId)) < 0)
+                sc = rcId
+
+            if (this.cmp(this.arr.at(pId), this.arr.at(sc)) <= 0)
+                return
+
+            Math.swap(this.arr, pId, sc)
+            pId = sc
+            lcId = this.leftChildIndex(pId)
+            rcId = this.rightChildIndex(pId)
+        }
+    }
+
+    size() { return this.arr.length }
+    top() { return this.arr.at(0) }
+    parentIndex = (x) => Math.trunc((x - 1) / 2)
+    leftChildIndex = (x) => 2 * x + 1
+    rightChildIndex = (x) => 2 * x + 2
+}
+
+Math.swap = (obj, i, j) => [obj[i], obj[j]] = [obj[j], obj[i]]

From addc36851bb025571a3e3b5291822bafab5515af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Nov 2024 03:11:46 -0800
Subject: [PATCH 3202/3374] Create
 3367-maximize-sum-of-weights-after-edge-removals.js

---
 ...mize-sum-of-weights-after-edge-removals.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 3367-maximize-sum-of-weights-after-edge-removals.js

diff --git a/3367-maximize-sum-of-weights-after-edge-removals.js b/3367-maximize-sum-of-weights-after-edge-removals.js
new file mode 100644
index 00000000..c0c65a96
--- /dev/null
+++ b/3367-maximize-sum-of-weights-after-edge-removals.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[][]} edges
+ * @param {number} k
+ * @return {number}
+ */
+var maximizeSumOfWeights = function(edges, k) {
+    const n = edges.length + 1;
+    const g = Array.from({ length: n }, () => ({}));
+    
+    for (const [x, y, w] of edges) {
+        g[x][y] = g[y][x] = w;
+    }
+
+    function dfs(idx, p) {
+        const ret = [0, 0];
+        const h = [];
+        
+        for (const ch in g[idx]) {
+            if (ch != p) {
+                const [a, b] = dfs(ch, idx);
+                h.push([a - b, a, b]);
+            }
+        }
+
+        h.sort((a, b) => b[0] - a[0]); // Max-heap simulation
+        let take = 0;
+        let take_k = 0;
+        let leave_k = 0;
+        let leave = 0;
+        let ct = 0;
+
+        while (h.length) {
+            const [_, a, b] = h.pop();
+            ct += 1;
+            if (ct <= k - 1) {
+                take += b;
+            } else if (ct === k) {
+                take_k = b;
+                leave_k = a;
+            } else {
+                leave += a;
+            }
+        }
+
+        const v = take + take_k + leave;
+        const w = take + leave_k + leave + (p !== -1 ? g[p][idx] : 0);
+        return [v, Math.max(v, w)];
+    }
+
+    return dfs(0, -1)[1];  
+};

From 36eaa9cf73e3a5161bc189575e004b2b338c10f0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Nov 2024 03:13:07 -0800
Subject: [PATCH 3203/3374] Create 3366-minimum-array-sum.js

---
 3366-minimum-array-sum.js | 42 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 3366-minimum-array-sum.js

diff --git a/3366-minimum-array-sum.js b/3366-minimum-array-sum.js
new file mode 100644
index 00000000..30021e40
--- /dev/null
+++ b/3366-minimum-array-sum.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} op1
+ * @param {number} op2
+ * @return {number}
+ */
+var minArraySum = function(nums, k, op1, op2) {
+    const n = nums.length;
+    const cache = new Map();
+
+    function dp(idx, left1, left2) {
+        if (idx === n) {
+            return 0;
+        }
+        const key = `${idx},${left1},${left2}`;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+
+        let ret = nums[idx] + dp(idx + 1, left1, left2);
+        if (left1 && left2) {
+            if (nums[idx] >= k) {
+                ret = Math.min(ret, Math.floor((nums[idx] - k + 1) / 2) + dp(idx + 1, left1 - 1, left2 - 1));
+            }
+            if (Math.floor((nums[idx] + 1) / 2) >= k) {
+                ret = Math.min(ret, Math.floor((nums[idx] + 1) / 2) - k + dp(idx + 1, left1 - 1, left2 - 1));
+            }
+        }
+        if (left1) {
+            ret = Math.min(ret, Math.floor((nums[idx] + 1) / 2) + dp(idx + 1, left1 - 1, left2));
+        }
+        if (left2 && nums[idx] >= k) {
+            ret = Math.min(ret, nums[idx] - k + dp(idx + 1, left1, left2 - 1));
+        }
+
+        cache.set(key, ret);
+        return ret;
+    }
+
+    return dp(0, op1, op2);
+};

From c6ae1f195aa96c2458c57bc84345c7823b629042 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Nov 2024 03:13:51 -0800
Subject: [PATCH 3204/3374] Create
 3365-rearrange-k-substrings-to-form-target-string.js

---
 ...ange-k-substrings-to-form-target-string.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3365-rearrange-k-substrings-to-form-target-string.js

diff --git a/3365-rearrange-k-substrings-to-form-target-string.js b/3365-rearrange-k-substrings-to-form-target-string.js
new file mode 100644
index 00000000..2d743b98
--- /dev/null
+++ b/3365-rearrange-k-substrings-to-form-target-string.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @param {number} k
+ * @return {boolean}
+ */
+var isPossibleToRearrange = function (s, t, k) {
+  const d = Math.floor(s.length / k)
+  if (s === t) return true
+  const map = new Map()
+
+  for (let i = 0; i < s.length; i += d) {
+    const req = s.substring(i, i + d)
+    if (map.has(req)) {
+      map.set(req, map.get(req) + 1)
+    } else {
+      map.set(req, 1)
+    }
+  }
+
+  for (let i = 0; i < t.length; i += d) {
+    const tar = t.substring(i, i + d)
+    if (!map.has(tar)) return false
+    else if (map.get(tar) < 1) return false
+    else {
+      map.set(tar, map.get(tar) - 1)
+    }
+  }
+
+  return true
+}

From 358efc4adcc7ebd70552b965e0c094c899615fb0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 24 Nov 2024 03:14:19 -0800
Subject: [PATCH 3205/3374] Create 3364-minimum-positive-sum-subarray.js

---
 3364-minimum-positive-sum-subarray.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)
 create mode 100644 3364-minimum-positive-sum-subarray.js

diff --git a/3364-minimum-positive-sum-subarray.js b/3364-minimum-positive-sum-subarray.js
new file mode 100644
index 00000000..efec413a
--- /dev/null
+++ b/3364-minimum-positive-sum-subarray.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var minimumSumSubarray = function (nums, l, r) {
+  let sum = Infinity
+  for (let i = l; i <= r; i++) {
+    sum = Math.min(minPos(nums, i), sum)
+  }
+  return sum === Infinity ? -1 : sum
+}
+
+function minPos(num, k) {
+  let s = 0
+  let min = Infinity
+  for (let i = 0; i < k; i++) {
+    s += num[i]
+  }
+  if (s > 0) min = s
+  for (let i = k; i < num.length; i++) {
+    s += num[i] - num[i - k]
+    if (s > 0) min = Math.min(min, s)
+  }
+  return min
+}

From 6a72cebd0f773a080d3534434f688735532f625f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 26 Nov 2024 15:47:51 +0800
Subject: [PATCH 3206/3374] Update 210-course-schedule-ii.js

---
 210-course-schedule-ii.js | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/210-course-schedule-ii.js b/210-course-schedule-ii.js
index 350c4d33..acfd8832 100644
--- a/210-course-schedule-ii.js
+++ b/210-course-schedule-ii.js
@@ -104,3 +104,53 @@ const findOrder = function(numCourses, prerequisites) {
     return true
   }
 }
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+var findOrder = function(numCourses, prerequisites) {
+  const inDegree = new Array(numCourses).fill(0);
+    const graph = {};
+    for (let i = 0;i < prerequisites.length;i++) {
+        const e = prerequisites[i];
+        inDegree[e[0]]++;
+        if (graph[e[1]]) {
+            graph[e[1]].push(e[0]);
+        } else {
+            graph[e[1]] = [e[0]];
+        }
+    }
+    let q = []
+    for (let i = 0;i < inDegree.length;i++) {
+        if (inDegree[i] === 0) {
+            q.push(i);
+        }
+    }
+    const res = []
+    let count = 0;
+    while(q.length) {
+        const tmp = []
+        const size = q.length
+        for(let i = 0;i < size;i++) {
+            const node = q[i]
+            res.push(node)
+            count++
+            if (graph[node]) {
+                for (let j = 0;j < graph[node].length;j++) {
+                    inDegree[graph[node][j]]--
+                    if (inDegree[graph[node][j]] === 0) {
+                        tmp.push(graph[node][j])
+                    }
+                }
+            }
+        }
+
+        q = tmp
+    }
+
+    return count === numCourses ? res : [];
+};

From efeceffe1b4e077f17cb82951d4ff12d42adc771 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Nov 2024 12:32:30 +0800
Subject: [PATCH 3207/3374] Update 310-minimum-height-trees.js

---
 310-minimum-height-trees.js | 50 +++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/310-minimum-height-trees.js b/310-minimum-height-trees.js
index eeaa1111..9bdaed7f 100644
--- a/310-minimum-height-trees.js
+++ b/310-minimum-height-trees.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var findMinHeightTrees = function(n, edges) {
+  if(n === 1) return [0]
+  if(n === 2) return [0, 1]
+  const g = {}
+  const degree = new Array(n).fill(0)
+  for(const [u, v] of edges) {
+    degree[u]++
+    degree[v]++
+    if(g[u] == null) g[u] = []
+    if(g[v] == null) g[v] = []
+    g[u].push(v)
+    g[v].push(u)
+  }
+  let q = []
+  for(let i = 0; i < n; i++) {
+    if(degree[i] === 1) q.push(i)
+  }
+  let cnt = 0 
+  while(q.length) {
+    const size = q.length
+    const tmp = []
+    for(let i = 0; i < size; i++) {
+        const node = q[i]
+        cnt++
+        for(const nxt of (g[node] || [])) {
+            degree[nxt]--
+            if(degree[nxt] === 1) {
+                tmp.push(nxt)
+            }
+        }
+    }
+    
+    q = tmp
+    if(n - cnt <= 2) break
+  }
+  
+  const res = []
+  while(q.length) {
+    res.push(q.pop())
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges

From 76d4d56494c9d3b00c801f537888b2d0ad36897c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 28 Nov 2024 12:55:05 +0800
Subject: [PATCH 3208/3374] Update 802-find-eventual-safe-states.js

---
 802-find-eventual-safe-states.js | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/802-find-eventual-safe-states.js b/802-find-eventual-safe-states.js
index f1d74624..14b46cd1 100644
--- a/802-find-eventual-safe-states.js
+++ b/802-find-eventual-safe-states.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+var eventualSafeNodes = function (graph) {
+  const n = graph.length
+  const g = {},
+    rg = {}
+  for (let i = 0; i < n; i++) {
+    const arr = graph[i]
+    g[i] = new Set(arr)
+    for (let j of arr) {
+      if (!rg[j]) {
+        rg[j] = new Set()
+      }
+      rg[j].add(i)
+    }
+  }
+  let q = []
+  for (let i = 0; i < n; i++) {
+    if (g[i].size === 0) {
+      q.push(i)
+    }
+  }
+  const res = []
+  while (q.length) {
+    const size = q.length
+    const nxt = []
+    for (let i = 0; i < size; i++) {
+      const node = q[i]
+      res.push(node)
+      for (let j of rg[node] || []) {
+        g[j].delete(node)
+        if (g[j].size === 0) {
+          nxt.push(j)
+        }
+      }
+    }
+
+    q = nxt
+  }
+
+  res.sort((a, b) => a - b)
+  return res
+}
+
+// another
+
+
 /**
  * @param {number[][]} graph
  * @return {number[]}

From c2a66bad266f8b942f2b8253dfa3df4789ce6265 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Dec 2024 00:27:23 -0800
Subject: [PATCH 3209/3374] Create 3370-smallest-number-with-all-set-bits.js

---
 3370-smallest-number-with-all-set-bits.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 3370-smallest-number-with-all-set-bits.js

diff --git a/3370-smallest-number-with-all-set-bits.js b/3370-smallest-number-with-all-set-bits.js
new file mode 100644
index 00000000..1fecd416
--- /dev/null
+++ b/3370-smallest-number-with-all-set-bits.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var smallestNumber = function(n) {
+    let x = n
+    while ((x & (x + 1)) !== 0) {
+      x += 1
+    }
+    return x
+};

From 49558784037504485c805ec2595702729e2ef2bc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Dec 2024 00:28:04 -0800
Subject: [PATCH 3210/3374] Create
 3371-identify-the-largest-outlier-in-an-array.js

---
 ...dentify-the-largest-outlier-in-an-array.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3371-identify-the-largest-outlier-in-an-array.js

diff --git a/3371-identify-the-largest-outlier-in-an-array.js b/3371-identify-the-largest-outlier-in-an-array.js
new file mode 100644
index 00000000..3e6b4784
--- /dev/null
+++ b/3371-identify-the-largest-outlier-in-an-array.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var getLargestOutlier = function (nums) {
+  let totalSum = 0
+  for (let num of nums) {
+    totalSum += num
+  }
+
+  const freqMap = new Map()
+  for (let num of nums) {
+    freqMap.set(num, (freqMap.get(num) || 0) + 1)
+  }
+  let res = Number.MIN_SAFE_INTEGER
+
+  for (let sumElement of nums) {
+    let potentialOutlier = totalSum - 2 * sumElement
+
+    if (freqMap.has(potentialOutlier)) {
+      if (potentialOutlier === sumElement && freqMap.get(sumElement) < 2) {
+        continue
+      }
+      res = Math.max(res, potentialOutlier)
+    }
+  }
+  return res
+}

From 5dcbf9ac0c51f88df422a621cf5b2b8e38cb922d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Dec 2024 00:28:36 -0800
Subject: [PATCH 3211/3374] Create
 3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js

---
 ...f-target-nodes-after-connecting-trees-i.js | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js

diff --git a/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js b/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js
new file mode 100644
index 00000000..d20c097d
--- /dev/null
+++ b/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @param {number} k
+ * @return {number[]}
+ */
+var maxTargetNodes = function (edges1, edges2, k) {
+  const n = edges1.length + 1
+  const m = edges2.length + 1
+
+  const adj1 = Array.from({ length: n }, () => [])
+  const adj2 = Array.from({ length: m }, () => [])
+
+  for (const edge of edges1) {
+    const [u, v] = edge
+    adj1[u].push(v)
+    adj1[v].push(u)
+  }
+  for (const edge of edges2) {
+    const [u, v] = edge
+    adj2[u].push(v)
+    adj2[v].push(u)
+  }
+
+  const good1 = new Array(n).fill(0)
+  const good2 = new Array(m).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    dfs(i, -1, 0, i, k + 1, good1, adj1)
+  }
+
+  for (let i = 0; i < m; i++) {
+    dfs(i, -1, 0, i, k, good2, adj2)
+  }
+
+  const mx = Math.max(...good2)
+
+  const res = new Array(n)
+  for (let i = 0; i < n; i++) {
+    res[i] = good1[i] + mx
+  }
+  return res
+}
+
+function dfs(node, parent, distance, root, k, good, adj) {
+  if (distance >= k) return
+  good[root]++
+  for (const neighbor of adj[node]) {
+    if (neighbor !== parent) {
+      dfs(neighbor, node, distance + 1, root, k, good, adj)
+    }
+  }
+}

From 3212f8631cdbd0da3cfc7eee4c1f830e712cfac3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 1 Dec 2024 00:29:13 -0800
Subject: [PATCH 3212/3374] Create
 3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js

---
 ...-target-nodes-after-connecting-trees-ii.js | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js

diff --git a/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js b/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js
new file mode 100644
index 00000000..c1ca4e20
--- /dev/null
+++ b/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js
@@ -0,0 +1,90 @@
+class Graph {
+  constructor(n) {
+    this.n = n
+    this.adj = Array.from({ length: n }, () => [])
+    this.weight = new Map()
+    for (let i = 0; i < n; i++) {
+      this.weight.set(i, new Map())
+    }
+  }
+
+  addEdgeOri(i, j, w = 0) {
+    this.adj[i].push(j)
+    this.weight.get(i).set(j, w)
+  }
+
+  addEdge(i, j, w = 0) {
+    // Add w to v's list.
+    this.adj[i].push(j)
+    // Add v to w's list
+    this.adj[j].push(i)
+    this.weight.get(i).set(j, w)
+    this.weight.get(j).set(i, w)
+  }
+}
+
+function dijkstra(graph, source) {
+  const ans = new Array(graph.n).fill(Number.MAX_SAFE_INTEGER / 2)
+  const pq = new MinPriorityQueue({ priority: (item) => item[1] })
+  pq.enqueue([source, 0])
+
+  while (pq.size() > 0) {
+    const [item, dis] = pq.dequeue().element
+    if (ans[item] <= dis) continue
+    ans[item] = dis
+
+    graph.adj[item].forEach((neighbor) => {
+      if (ans[neighbor] >= Number.MAX_SAFE_INTEGER / 2) {
+        pq.enqueue([neighbor, dis + graph.weight.get(item).get(neighbor)])
+      }
+    })
+  }
+  return ans
+}
+
+function maxTargetNodes(edges1, edges2) {
+  const n = edges1.length + 1
+  const m = edges2.length + 1
+  const g1 = new Graph(n)
+  const g2 = new Graph(m)
+
+  edges1.forEach(([a, b]) => g1.addEdge(a, b, 1))
+  edges2.forEach(([a, b]) => g2.addEdge(a, b, 1))
+
+  const dis1 = dijkstra(g1, 0)
+  const dis2 = dijkstra(g2, 0)
+
+  const a0 = new Set()
+  const a1 = new Set()
+  const b0 = new Set()
+  const b1 = new Set()
+
+  for (let i = 0; i < dis1.length; i++) {
+    if (dis1[i] % 2 === 0) {
+      a0.add(i)
+    } else {
+      a1.add(i)
+    }
+  }
+
+  for (let i = 0; i < dis2.length; i++) {
+    if (dis2[i] % 2 === 0) {
+      b0.add(i)
+    } else {
+      b1.add(i)
+    }
+  }
+
+  const b = Math.max(b0.size, b1.size)
+  const ans = []
+
+  for (let i = 0; i < n; i++) {
+    if (a0.has(i)) {
+      ans.push(a0.size + b)
+    } else {
+      ans.push(a1.size + b)
+    }
+  }
+
+  return ans
+}

From ee5ed076a879b182b134a3f59cef475d7741e91a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 2 Dec 2024 11:48:27 +0800
Subject: [PATCH 3213/3374] Update 1462-course-schedule-iv.js

---
 1462-course-schedule-iv.js | 53 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index abbcaf55..d06b42f0 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -1,3 +1,56 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+var checkIfPrerequisite = function(numCourses, prerequisites, queries) {
+   const g = {}
+   const n = numCourses
+   const indegree = Array(n).fill(0)
+   for(const [a, b] of prerequisites) {
+     if(!g[a]) {
+       g[a] = []
+     }
+     g[a].push(b)
+     indegree[b]++
+   }
+   const q = []
+    for(let i = 0; i < n; i++) {
+      if(indegree[i] === 0) {
+        q.push(i)
+      }
+    }
+    const res = []
+    const hash = {}
+    for(const e of q) {
+      dfs(e, new Set())
+    }
+    for(let i = 0; i < queries.length; i++) {
+      const [a, b] = queries[i]
+      res.push(hash[a] && hash[a].has(b))
+    }
+
+    return res
+    function dfs(cur, set) {
+        if(hash[cur]) {
+            return hash[cur]
+        }
+        hash[cur] = new Set()
+        if(g[cur]) {
+            for(const e of g[cur]) {
+                for(const x of dfs(e, set)) {
+                    hash[cur].add(x)
+                }
+            }
+        }
+        hash[cur].add(cur)
+        return hash[cur]
+    }
+};
+
+// another
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites

From 64055328f6e6a0acd631f3e9dc012adddeac3f25 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 3 Dec 2024 15:26:31 +0800
Subject: [PATCH 3214/3374] Update 1591-strange-printer-ii.js

---
 1591-strange-printer-ii.js | 68 ++++++++++++++++++++++++++++++++++++++
 1 file changed, 68 insertions(+)

diff --git a/1591-strange-printer-ii.js b/1591-strange-printer-ii.js
index 4dd5b521..1db9c901 100644
--- a/1591-strange-printer-ii.js
+++ b/1591-strange-printer-ii.js
@@ -1,3 +1,71 @@
+/**
+ * @param {number[][]} targetGrid
+ * @return {boolean}
+ */
+const isPrintable = function(targetGrid) {
+    // solve the problem: BFS
+    // 1. find the top-left and bottom-right corner of each color
+    // 2. check if there is a circle in the graph
+    // 3. if there is a circle, return false
+    // 4. if there is no circle, return true
+    const m = targetGrid.length;
+    const n = targetGrid[0].length;
+    const left = new Array(61).fill(n);
+    const right = new Array(61).fill(-1);
+    const top = new Array(61).fill(m);
+    const bottom = new Array(61).fill(-1);
+    const next = new Array(61).fill(null).map(() => []);
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            const color = targetGrid[i][j];
+            left[color] = Math.min(left[color], j);
+            right[color] = Math.max(right[color], j);
+            top[color] = Math.min(top[color], i);
+            bottom[color] = Math.max(bottom[color], i);
+        }
+    }
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            for (let color = 1; color <= 60; color++) {
+                if (i >= top[color] && i <= bottom[color] && j >= left[color] && j <= right[color]) {
+                    if (color !== targetGrid[i][j]) {
+                        next[targetGrid[i][j]].push(color);
+                    }
+                }
+            }
+        }
+    }
+    const numNodes = 61;
+    const inDegree = new Array(numNodes).fill(0);
+    for (let i = 0; i < numNodes; i++) {
+        for (const j of next[i]) {
+            inDegree[j]++;
+        }
+    }
+    const queue = [];
+    let count = 0;
+    for (let i = 0; i < numNodes; i++) {
+        if (inDegree[i] === 0) {
+            queue.push(i);
+            count++;
+        }
+    }
+    while (queue.length > 0) {
+        const curCourse = queue.shift();
+        for (const child of next[curCourse]) {
+            inDegree[child]--;
+            if (inDegree[child] === 0) {
+                queue.push(child);
+                count++;
+            }
+        }
+    }
+    return count === numNodes;
+};
+
+// another
+
+
 /**
  * @param {number[][]} targetGrid
  * @return {boolean}

From 24d0cde73f3eefbd00da494971c8416dad2b2701 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 4 Dec 2024 15:40:02 +0800
Subject: [PATCH 3215/3374] Update 1632-rank-transform-of-a-matrix.js

---
 1632-rank-transform-of-a-matrix.js | 88 ++++++++++++++++++++++++++++++
 1 file changed, 88 insertions(+)

diff --git a/1632-rank-transform-of-a-matrix.js b/1632-rank-transform-of-a-matrix.js
index 69233377..6145eff0 100644
--- a/1632-rank-transform-of-a-matrix.js
+++ b/1632-rank-transform-of-a-matrix.js
@@ -1,3 +1,91 @@
+class UF {
+    constructor(n) {
+        this.parent = new Array(n + 1).fill(0).map((_, i) => i);
+    }
+    union(x, y) {
+        const rootX = this.find(x);
+        const rootY = this.find(y);
+        if (rootX !== rootY) {
+            this.parent[rootX] = rootY;
+        }
+    }
+    find(x) {
+        if (x !== this.parent[x]) {
+            this.parent[x] = this.find(this.parent[x]);
+        }
+        return this.parent[x];
+    }
+}
+
+// Update the matrixRankTransform function to use the union-find functions
+var matrixRankTransform = function(matrix) {
+    const m = matrix.length
+    const n = matrix[0].length
+    const uf = new UF(m * n)
+    const res = Array.from({ length: m }, () => Array(n).fill(-1))
+
+    for (let i = 0; i < m; i++) {
+        const tmp = []
+        for (let j = 0; j < n; j++) {
+            tmp.push([matrix[i][j], i * n + j])
+        }
+        tmp.sort((a, b) => a[0] - b[0])
+        for (let j = 1; j < n; j++) {
+            if (tmp[j][0] === tmp[j - 1][0] && uf.find(tmp[j][1]) !== uf.find(tmp[j - 1][1])) {
+                uf.union(tmp[j][1], tmp[j - 1][1])
+            }
+        }
+    }
+
+    for (let j = 0; j < n; j++) {
+        const tmp = []
+        for (let i = 0; i < m; i++) {
+            tmp.push([matrix[i][j], i * n + j])
+        }
+        tmp.sort((a, b) => a[0] - b[0])
+        for (let i = 1; i < m; i++) {
+            if (tmp[i][0] === tmp[i - 1][0] && uf.find(tmp[i][1]) !== uf.find(tmp[i - 1][1])) {
+                uf.union(tmp[i][1], tmp[i - 1][1])
+            }
+        }
+    }
+
+    const nums = [], group = {}
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            const key = i * n + j
+            const root = uf.find(key)
+            if(group[root] == null) group[root] = []
+            group[root].push(key)
+            nums.push([matrix[i][j], key])
+        }
+    }
+    nums.sort((a, b) => a[0] - b[0])
+    const rowMax = Array(m).fill(0)
+    const colMax = Array(n).fill(0)
+    for(const e of nums) {
+        const [val, key] = e
+        const [i, j] = [Math.floor(key / n), key % n]
+        if(res[i][j] !== -1) continue
+        let rank = 0
+        for(const k of group[uf.find(key)]) {
+            const [x, y] = [Math.floor(k / n), k % n]
+            rank = Math.max(rank, rowMax[x], colMax[y])
+        }
+        rank++
+        for(const k of group[uf.find(key)]) {
+            const [x, y] = [Math.floor(k / n), k % n]
+            res[x][y] = rank
+            rowMax[x] = rank
+            colMax[y] = rank
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} matrix
  * @return {number[][]}

From 742673af2720aaeff9a23774e98e3f31c6dd7894 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 5 Dec 2024 15:33:01 +0800
Subject: [PATCH 3216/3374] Update
 1857-largest-color-value-in-a-directed-graph.js

---
 ...largest-color-value-in-a-directed-graph.js | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)

diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index ed99ed48..670144e8 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -1,3 +1,70 @@
+/**
+ * @param {string} colors
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const largestPathValue = function(colors, edges) {
+    const n = colors.length;
+    const m = edges.length;
+    const adj = Array(n).fill(0).map(() => []);
+    const inDegree = Array(n).fill(0);
+    for (const [u, v] of edges) {
+        adj[u].push(v);
+        inDegree[v]++;
+    }
+    let res = 1
+    const colorSet = new Set(colors);
+    const a = 'a'.charCodeAt(0);
+    for(const e of colorSet) {
+        const tmp = helper(e.charCodeAt(0) - a);
+        if(tmp === -1) return -1;
+        res = Math.max(res, tmp);
+    }
+
+    return res
+
+    function code(ch) {
+        return ch.charCodeAt(0) - 'a'.charCodeAt(0);
+    }
+    function helper(k) {
+        const ind = [...inDegree];
+        const count = Array(n).fill(0);
+        let nodes = 0
+        let res = 0
+        let q = []
+        for(let i = 0; i < n; i++) {
+            if(ind[i] === 0) {
+                q.push(i);
+                nodes++
+                count[i] = code(colors[i]) === k ? 1 : 0;
+            }
+        }
+
+        while(q.length) {
+            const size = q.length;
+            const tmp = []
+            for(let i = 0; i < size; i++) {
+                const e = q[i];
+                for(const v of adj[e]) {
+                    count[v] = Math.max(count[v], count[e] + (code(colors[v]) === k ? 1 : 0));
+                    res = Math.max(res, count[v]);
+                    ind[v]--;
+                    if(ind[v] === 0) {
+                        tmp.push(v);
+                        nodes++
+                    }
+                }
+            }
+
+            q = tmp
+        }
+
+        return nodes === n ? res : -1
+    }
+};
+
+// another
+
 /**
  * @param {string} colors
  * @param {number[][]} edges

From db023e5ec3aaf455cbac420811b2e0032a9595b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 6 Dec 2024 13:58:34 +0800
Subject: [PATCH 3217/3374] Update 2050-parallel-courses-iii.js

---
 2050-parallel-courses-iii.js | 45 ++++++++++++++++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/2050-parallel-courses-iii.js b/2050-parallel-courses-iii.js
index 1be35f37..521a0eb0 100644
--- a/2050-parallel-courses-iii.js
+++ b/2050-parallel-courses-iii.js
@@ -1,3 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+const minimumTime = function(n, relations, time) {
+  const adj = Array(n + 1).fill(0).map(() => []);
+    const inDegree = Array(n + 1).fill(0);
+    for (const [u, v] of relations) {
+        adj[u].push(v);
+        inDegree[v]++;
+    }
+    let q = []
+    const finishTime = Array(n + 1).fill(0);
+    for(let i = 1; i <= n; i++) {
+        if(inDegree[i] === 0) {
+            q.push(i);
+            finishTime[i] = time[i - 1];
+        }
+    }
+
+
+    while(q.length) {
+        const size = q.length;
+        const tmp = []
+        for(let i = 0; i < size; i++) {
+            const e = q[i];
+            for(const v of adj[e]) {
+                inDegree[v]--;
+                finishTime[v] = Math.max(finishTime[v], finishTime[e] + time[v - 1]);
+                if(inDegree[v] === 0) {
+                    tmp.push(v);
+                }
+            }
+        }
+
+        q = tmp
+    }
+
+    return Math.max(...finishTime.slice(1))
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} relations

From 19b8f4177d430e1d9b90797dcd2fa918c4e0eaef Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2024 10:19:50 +0800
Subject: [PATCH 3218/3374] Create 3379-transformed-array.js

---
 3379-transformed-array.js | 22 ++++++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 3379-transformed-array.js

diff --git a/3379-transformed-array.js b/3379-transformed-array.js
new file mode 100644
index 00000000..2daeba3f
--- /dev/null
+++ b/3379-transformed-array.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var constructTransformedArray = function(nums) {
+    const n = nums.length;
+    const res = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+        if (nums[i] === 0) {
+            res[i] = nums[i];
+        } else if (nums[i] > 0) {
+            const ind = (i + nums[i]) % n;
+            res[i] = nums[ind];
+        } else {
+            const neg = Math.abs(nums[i]) % n;
+            const ind = (i - neg + n) % n;
+            // console.log(ind);
+            res[i] = nums[ind];
+        }
+    }
+    return res;
+};

From ef4c6a62e541a4047b9b6f6e757b34edfe1a176b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2024 10:20:33 +0800
Subject: [PATCH 3219/3374] Create
 3380-maximum-area-rectangle-with-point-constraints-i.js

---
 ...area-rectangle-with-point-constraints-i.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 3380-maximum-area-rectangle-with-point-constraints-i.js

diff --git a/3380-maximum-area-rectangle-with-point-constraints-i.js b/3380-maximum-area-rectangle-with-point-constraints-i.js
new file mode 100644
index 00000000..8247c400
--- /dev/null
+++ b/3380-maximum-area-rectangle-with-point-constraints-i.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var maxRectangleArea = function (points) {
+  const n = points.length
+  const st = new Set()
+  for (const i of points) st.add(i[0] + ',' + i[1])
+  let res = -1
+
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const x1 = points[i][0],
+        y1 = points[i][1],
+        x2 = points[j][0],
+        y2 = points[j][1]
+      if (x1 === x2 || y1 === y2) continue
+      if (st.has(x1 + ',' + y2) && st.has(x2 + ',' + y1)) {
+        const min1 = Math.min(x1, x2),
+          max1 = Math.max(x1, x2),
+          min2 = Math.min(y1, y2),
+          max2 = Math.max(y1, y2)
+        let isid = true
+        for (const point of points) {
+          const cx = point[0],
+            cy = point[1]
+          if (
+            (cx > min1 && cx < max1 && cy > min2 && cy < max2) ||
+            ((cx === min1 || cx === max1) && cy > min2 && cy < max2) ||
+            ((cy === min2 || cy === max2) && cx > min1 && cx < max1)
+          ) {
+            isid = false
+            break
+          }
+        }
+        if (isid) res = Math.max(res, (max1 - min1) * (max2 - min2))
+      }
+    }
+  }
+  return res
+}

From 95c09955f9b260b2a926bf5aa53c7072ace2f5c5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2024 10:21:08 +0800
Subject: [PATCH 3220/3374] Create
 3381-maximum-subarray-sum-with-length-divisible-by-k.js

---
 ...subarray-sum-with-length-divisible-by-k.js | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)
 create mode 100644 3381-maximum-subarray-sum-with-length-divisible-by-k.js

diff --git a/3381-maximum-subarray-sum-with-length-divisible-by-k.js b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
new file mode 100644
index 00000000..d84efd15
--- /dev/null
+++ b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
@@ -0,0 +1,36 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxSubarraySum = function (nums, k) {
+  const n = nums.length
+  let res = -Infinity
+  const pre_sum = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    pre_sum[i + 1] = pre_sum[i] + nums[i]
+  }
+
+  const groups = Array.from({ length: k }, (_, i) => [pre_sum[i]])
+
+  for (let i = k; i <= n; i++) {
+    const idx = i % k
+    groups[idx].push(pre_sum[i])
+  }
+
+  for (let i = 0; i < k; i++) {
+    const group = groups[i]
+    const mx_dp = new Array(group.length + 1).fill(-Infinity)
+
+    for (let j = group.length - 1; j >= 0; j--) {
+      mx_dp[j] = Math.max(mx_dp[j + 1], group[j])
+    }
+
+    for (let j = 0; j < group.length; j++) {
+      res = Math.max(res, mx_dp[j + 1] - group[j])
+    }
+  }
+
+  return res
+}

From 0f1910065e7f5c6a15f9a727f3035311cffcc8b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 9 Dec 2024 12:26:04 +0800
Subject: [PATCH 3221/3374] Create
 3382-maximum-area-rectangle-with-point-constraints-ii.js

---
 ...rea-rectangle-with-point-constraints-ii.js | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 3382-maximum-area-rectangle-with-point-constraints-ii.js

diff --git a/3382-maximum-area-rectangle-with-point-constraints-ii.js b/3382-maximum-area-rectangle-with-point-constraints-ii.js
new file mode 100644
index 00000000..7d1912cc
--- /dev/null
+++ b/3382-maximum-area-rectangle-with-point-constraints-ii.js
@@ -0,0 +1,85 @@
+/**
+ * @param {number[]} xCoord
+ * @param {number[]} yCoord
+ * @return {number}
+ */
+var maxRectangleArea = function (xCoord, yCoord) {
+  const n = xCoord.length
+  const co = []
+  const sy = imap(yCoord)
+
+  for (let i = 0; i < n; i++) {
+    co.push([xCoord[i], binarySearch(sy, yCoord[i])])
+  }
+  co.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+
+  let result = -1
+  const map = new Map()
+  const mapX = new Map()
+  const ft = new Array(sy.length + 1).fill(0)
+  for (let i = 0; i < co.length; i++) {
+    addFenwick(ft, co[i][1], 1)
+
+    if (i - 1 >= 0 && co[i][0] === co[i - 1][0]) {
+      const yc = (BigInt(co[i][1]) << 32n) | BigInt(co[i - 1][1])
+      const aft = sumFenwick(ft, co[i][1]) - sumFenwick(ft, co[i - 1][1] - 1)
+
+      if (map.has(yc)) {
+        const bef = map.get(yc)
+        if (aft === bef + 2) {
+          const x = mapX.get(yc)
+          const S =
+            BigInt(co[i][0] - x) * BigInt(sy[co[i][1]] - sy[co[i - 1][1]])
+          result = Number(BigInt(result) > S ? result : S)
+        }
+      }
+
+      map.set(yc, aft)
+      mapX.set(yc, co[i][0])
+    }
+  }
+
+  return result
+
+  function sumFenwick(ft, i) {
+    let sum = 0
+    for (i += 1; i > 0; i -= i & -i) {
+      sum += ft[i]
+    }
+    return sum
+  }
+
+  function addFenwick(ft, i, v) {
+    if (v === 0 || i < 0) return
+    for (i += 1; i < ft.length; i += i & -i) {
+      ft[i] += v
+    }
+  }
+
+  function imap(a) {
+    const imap = Array.from(a)
+    imap.sort((a, b) => a - b)
+    let p = 1
+
+    for (let i = 1; i < imap.length; i++) {
+      if (imap[i] !== imap[p - 1]) imap[p++] = imap[i]
+    }
+
+    return imap.slice(0, p)
+  }
+
+  function binarySearch(nums, target) {
+    let left = 0
+    let right = nums.length - 1
+    while (left <= right) {
+      const mid = (left + right) >> 1
+      if (nums[mid] === target) return mid
+      if (nums[mid] < target) {
+        left = mid + 1
+      } else {
+        right = mid - 1
+      }
+    }
+    return -1
+  }
+}

From 23b830fb26070709cc9143ad6368f1fb436f22f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 10 Dec 2024 14:11:44 +0800
Subject: [PATCH 3222/3374] Update 2360-longest-cycle-in-a-graph.js

---
 2360-longest-cycle-in-a-graph.js | 49 ++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/2360-longest-cycle-in-a-graph.js b/2360-longest-cycle-in-a-graph.js
index da87392d..32eed7a3 100644
--- a/2360-longest-cycle-in-a-graph.js
+++ b/2360-longest-cycle-in-a-graph.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} edges
+ * @return {number}
+ */
+const longestCycle = function(edges) {
+  const n = edges.length;
+  const visited = new Array(n).fill(false);
+  const ind = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    if (edges[i] !== -1) {
+      ind[edges[i]]++;
+    }
+  }
+  let q = []
+  for(let i = 0; i < n; i++) {
+    if (ind[i] === 0) {
+      q.push(i);
+    }
+  }
+  while(q.length) {
+    const node = q.pop()
+    visited[node] = true;
+    const nxt = edges[node];
+    if(nxt !== -1) {
+      ind[nxt]--;
+      if (ind[nxt] === 0) {
+        q.push(nxt);
+      }
+    }
+  }
+  let res = -1
+  for(let i = 0; i < n; i++) {
+    if (!visited[i]) {
+        let cnt = 0
+        let cur = i
+        while (!visited[cur]) {
+            visited[cur] = true
+            cur = edges[cur]
+            cnt++
+        }
+        res = Math.max(res, cnt)
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} edges
  * @return {number}

From 2367355064afd45adc62fb4e6b63215bc89ec32d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 11 Dec 2024 15:57:39 +0800
Subject: [PATCH 3223/3374] Update 2392-build-a-matrix-with-conditions.js

---
 2392-build-a-matrix-with-conditions.js | 66 ++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
index 8bd4d8ac..a18b14d3 100644
--- a/2392-build-a-matrix-with-conditions.js
+++ b/2392-build-a-matrix-with-conditions.js
@@ -1,3 +1,69 @@
+/**
+ * @param {number} k
+ * @param {number[][]} rowConditions
+ * @param {number[][]} colConditions
+ * @return {number[][]}
+ */
+const buildMatrix = function(k, rowConditions, colConditions) {
+    const col = topo(k, colConditions);
+    const row = topo(k, rowConditions);
+    if(col.length === 0 || row.length === 0) return []
+
+    const res = Array.from({length: k}, () => Array.from({length: k}, () => 0));
+    const colHash = {}, rowHash = {};
+    for(let i = 0; i < k; i++) {
+        colHash[col[i]] = i;
+        rowHash[row[i]] = i;
+    }
+    for(let i = 1; i <= k; i++) {
+        res[rowHash[i]][colHash[i]] = i
+    }
+
+    return res
+
+    function topo(k, conditions) {
+        const n = conditions.length;
+        const ind = new Array(k + 1).fill(0);
+        const adj = Array.from({length: k + 1}, () => []);
+        for(let i = 0; i < n; i++) {
+            const [a, b] = conditions[i];
+            adj[a].push(b);
+            ind[b]++;
+        }
+      // console.log(adj, ind)
+        let q = []
+        for(let i = 1; i <= k; i++) {
+            if (ind[i] === 0) {
+                q.push(i);
+            }
+        }
+        const res = []
+
+        while(q.length) {
+            const size = q.length
+            const tmp = []
+            for(let i = 0; i < size; i++) {
+
+                const node = q[i]
+                res.push(node)
+                for(const nxt of adj[node]) {
+                    ind[nxt]--;
+                    if (ind[nxt] === 0) {
+                        tmp.push(nxt);
+                    }
+                }
+            }
+            q = tmp
+        }
+      // console.log(res)
+        if(res.length !== k) return []
+        return res
+    }
+};
+
+// another
+
+
 /**
  * @param {number} k
  * @param {number[][]} rowConditions

From 4687b6cec89218708f7ff3fcdcd9beb727c51029 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 12 Dec 2024 17:40:52 +0800
Subject: [PATCH 3224/3374] Update 2440-create-components-with-same-value.js

---
 2440-create-components-with-same-value.js | 65 +++++++++++++++++++++++
 1 file changed, 65 insertions(+)

diff --git a/2440-create-components-with-same-value.js b/2440-create-components-with-same-value.js
index fc6e910c..06735c00 100644
--- a/2440-create-components-with-same-value.js
+++ b/2440-create-components-with-same-value.js
@@ -1,3 +1,68 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var componentValue = function(nums, edges) {
+  const n = nums.length;
+  if(n === 1) return 0;
+    const total = nums.reduce((a, b) => a + b, 0);
+    const g = Array.from({ length: n }, () => []);
+    const indegree = Array(n).fill(0);
+    for (const [u, v] of edges) {
+        g[u].push(v);
+        g[v].push(u);
+        indegree[u]++;
+        indegree[v]++;
+    }
+    const sums = []
+    for(let s = 1; s * s <= total; s++) {
+        if(total % s === 0) {
+            sums.push(s);
+            sums.push(total / s);
+        }
+    }
+    sums.sort((a, b) => a - b);
+    let res = 0
+    for(const s of sums) {
+      const ind = [...indegree];
+        const q = [];
+        const visited = Array(n).fill(false);
+        const sum = [...nums];
+        for(let i = 0; i < n; i++) {
+            if(ind[i] === 1) {
+                q.push(i);
+                visited[i] = true;
+            }
+        }
+        let flag = true;
+        while(q.length) {
+            const cur = q.shift();
+            if(sum[cur] > s) {
+                flag = false;
+                break;
+            } else if(sum[cur] === s) {
+                sum[cur] = 0
+            }
+            for(const next of g[cur]) {
+                if(visited[next]) continue;
+                sum[next] += sum[cur];
+                ind[next]--;
+                if(ind[next] === 1) {
+                    q.push(next);
+                    visited[next] = true;
+                }
+            }
+        }
+        if(flag) return total / s - 1;
+
+    }
+    return 0
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number[][]} edges

From d09846527d50f6d4b818cfba27be8379f97340a2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 13 Dec 2024 16:31:07 +0800
Subject: [PATCH 3225/3374] Update 2603-collect-coins-in-a-tree.js

---
 2603-collect-coins-in-a-tree.js | 66 +++++++++++++++++++++++++++++++++
 1 file changed, 66 insertions(+)

diff --git a/2603-collect-coins-in-a-tree.js b/2603-collect-coins-in-a-tree.js
index 211e4335..7b174eb3 100644
--- a/2603-collect-coins-in-a-tree.js
+++ b/2603-collect-coins-in-a-tree.js
@@ -1,3 +1,69 @@
+/**
+ * @param {number[]} coins
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var collectTheCoins = function(coins, edges) {
+  let n = coins.length;
+  let next = Array.from({ length: n }, () => new Set());
+
+  let degree = new Array(n).fill(0);
+  for (let edge of edges) {
+    let a = edge[0],
+      b = edge[1];
+    next[a].add(b);
+    next[b].add(a);
+    degree[a]++;
+    degree[b]++;
+  }
+
+  let deleted = new Array(n).fill(0);
+  let q = [];
+  for (let i = 0; i < n; i++) {
+    if (degree[i] === 1 && coins[i] === 0) q.push(i);
+  }
+  while (q.length > 0) {
+    let len = q.length;
+    while (len--) {
+      let cur = q.shift();
+      deleted[cur] = 1;
+      for (let nxt of next[cur]) {
+        degree[nxt]--;
+        next[nxt].delete(cur);
+        if (degree[nxt] === 1 && coins[nxt] === 0) q.push(nxt);
+      }
+    }
+  }
+
+  let depth = new Array(n).fill(-1);
+  for (let i = 0; i < n; i++) {
+    if (degree[i] === 1 && deleted[i] === 0) {
+      q.push(i);
+      depth[i] = 1;
+    }
+  }
+  while (q.length > 0) {
+    let len = q.length;
+    while (len--) {
+      let cur = q.shift();
+      for (let nxt of next[cur]) {
+        degree[nxt]--;
+        next[nxt].delete(cur);
+        depth[nxt] = Math.max(depth[nxt], depth[cur] + 1);
+        if (degree[nxt] === 1) q.push(nxt);
+      }
+    }
+  }
+
+  let ret = 0;
+  for (let i = 0; i < n; i++) ret += depth[i] >= 3;
+
+  if (ret >= 1) return (ret - 1) * 2;
+  else return 0;
+};
+
+// another
+
 let a, cum, res, v, sum, g;
 const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
 const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };

From 5746c33822d82c37deb635d513589c87a50c0f2a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Dec 2024 11:11:42 +0800
Subject: [PATCH 3226/3374] Update 930-binary-subarrays-with-sum.js

---
 930-binary-subarrays-with-sum.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/930-binary-subarrays-with-sum.js b/930-binary-subarrays-with-sum.js
index 785bf86c..546d03a5 100644
--- a/930-binary-subarrays-with-sum.js
+++ b/930-binary-subarrays-with-sum.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} goal
+ * @return {number}
+ */
+var numSubarraysWithSum = function(nums, goal) {
+  const n = nums.length
+  const hash = { 0: 1 }
+  let res = 0
+  let sum = 0
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    sum += e
+    const diff = sum - goal
+    if(hash[diff] != null) res += hash[diff]
+    if(hash[sum] == null) hash[sum] = 1
+    else hash[sum]++
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} S

From 0419215cd2b62b7a8b9e490fd27c736936068ce0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Dec 2024 10:57:51 +0800
Subject: [PATCH 3227/3374] Update 974-subarray-sums-divisible-by-k.js

---
 974-subarray-sums-divisible-by-k.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/974-subarray-sums-divisible-by-k.js b/974-subarray-sums-divisible-by-k.js
index 26306870..6c456912 100644
--- a/974-subarray-sums-divisible-by-k.js
+++ b/974-subarray-sums-divisible-by-k.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var subarraysDivByK = function(nums, k) {
+    const n = nums.length;
+    const prefix = new Array(n).fill(0);
+    for(let i = 0; i < n; i++) {
+        prefix[i] = (prefix[i - 1] || 0) + nums[i];
+    }
+    const count = new Array(k + 1).fill(0);
+    count[0] = 1;
+    let res = 0
+    for(let i = 0; i < n; i++) {
+        const remain = ((prefix[i] % k) + k) % k
+        res += count[remain];
+        count[remain]++;
+    }
+    return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From e89a69061c28c6807730a202a878c7c03f30d4f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 20 Dec 2024 10:39:42 +0800
Subject: [PATCH 3228/3374] Update
 1371-find-the-longest-substring-containing-vowels-in-even-counts.js

---
 ...string-containing-vowels-in-even-counts.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 0c65e37a..b2c505d0 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var findTheLongestSubstring = function(s) {
+    const hash = {0: -1};
+    const vowels = 'aeiou';
+    const vowelsSet = new Set(vowels);
+    const n = s.length;
+    const key = (ch) => {
+        const idx = vowels.indexOf(ch);
+        return idx === -1 ? 0 : 1 << idx;
+    }
+    let state = 0;
+    let res = 0;
+    for(let i = 0; i < n; i++) {
+        const ch = s[i]
+        let tmp = state;
+        if(vowelsSet.has(ch)) {
+            tmp ^= key(ch);
+        }
+        if(hash[tmp] === undefined) {
+            hash[tmp] = i;
+        }else {
+            res = Math.max(res, i - hash[tmp]);
+        }
+
+        state = tmp
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From 9817c607e37c748a246734f48930ce2c92473a24 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Dec 2024 11:19:26 +0800
Subject: [PATCH 3229/3374] Update
 1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js

---
 ...s-that-can-form-two-arrays-of-equal-xor.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
index 02a65836..efc5f02f 100644
--- a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
+++ b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
@@ -1,4 +1,32 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var countTriplets = function(arr) {
+  const n = arr.length
+  const prefix = new Array(n + 1).fill(0)
+  for(let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] ^ arr[i]
+  }
+  let res = 0, xor = 0
+  const hash = {0: [-1]}
+  for(let i = 0; i < n; i++) {
+    const e = arr[i]
+    xor ^= e
+    if(hash[xor] === undefined) {
+      hash[xor] = []
+    } else {
+        for(const prev of hash[xor]) {
+            res += Math.max(0, i - prev - 1)
+        }
+    }
+    hash[xor].push(i)
+  }
 
+  return res
+};
+
+// another
 /**
  * @param {number[]} arr
  * @return {number}

From 8244f727571332e435dccbe5549434bbc9e253fb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Dec 2024 11:28:58 +0800
Subject: [PATCH 3230/3374] Update
 1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js

---
 ...s-that-can-form-two-arrays-of-equal-xor.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
index efc5f02f..3c66d205 100644
--- a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
+++ b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
@@ -67,3 +67,31 @@ const countTriplets = function(arr) {
   }
   return res
 };
+/*
+
+you have an array : a[0], a[1].... a[n - 1]
+
+
+First things first:
+We need to understand small fact, if xor(a[0....i]) has appeared before at index j then it means xor(a[j+1.....i]) = 0
+Another fact, if xor(a[i....j]) = 0 so this subarray will add (j - i - 1) to the answer.
+
+
+Now say currently we are at index i and let xor([0...i]) = x.
+
+
+Now say x has occurred 3 times previously at indices (i1, i2, i3)
+
+
+our answer for i will be = (i - i1 - 1) + (i - i2 - 1) + (i - i3 - 1)
+
+
+if you simplify this further you get f * i - (i1 + i2 + i3) - f = (i - 1) * f - (i1 + i2 + i3)
+
+
+f = no. of times x has occurred previously.
+
+
+(i1 + i2 + i3) = sum of all the indices where x has occurred previously.
+
+*/

From 77b74af39f0a43f1128d9e8c90895fd1681bd3a8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2024 11:04:13 +0800
Subject: [PATCH 3231/3374] Update 1590-make-sum-divisible-by-p.js

---
 1590-make-sum-divisible-by-p.js | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
index 182ae5a0..4c903d90 100644
--- a/1590-make-sum-divisible-by-p.js
+++ b/1590-make-sum-divisible-by-p.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+var minSubarray = function(nums, p) {
+    const n = nums.length
+    const sum = nums.reduce((acc, cur) => acc + cur, 0)
+    const target = sum % p
+    if(target === 0) return 0
+    const hash = {0: -1}
+    let res = n
+    let curSum = 0
+    for(let i = 0; i < n; i++) {
+        const e = nums[i]
+        curSum += e
+        const remain = curSum % p
+        const diff = (remain - target + p) % p
+        if(hash[diff] != null) {
+            res = Math.min(res, i - hash[diff])
+        }
+        hash[remain] = i
+    }
+
+    return res === n ? -1 : res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} p

From c8509094c4c1ddcb76f576903c059e98627fa378 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 25 Dec 2024 11:35:17 +0800
Subject: [PATCH 3232/3374] Update
 235-lowest-common-ancestor-of-a-binary-search-tree.js

---
 235-lowest-common-ancestor-of-a-binary-search-tree.js | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/235-lowest-common-ancestor-of-a-binary-search-tree.js b/235-lowest-common-ancestor-of-a-binary-search-tree.js
index 205bcf3d..f6716919 100644
--- a/235-lowest-common-ancestor-of-a-binary-search-tree.js
+++ b/235-lowest-common-ancestor-of-a-binary-search-tree.js
@@ -29,6 +29,7 @@ const lowestCommonAncestor = function(root, p, q) {
  *     this.left = this.right = null;
  * }
  */
+
 /**
  * @param {TreeNode} root
  * @param {TreeNode} p
@@ -36,8 +37,8 @@ const lowestCommonAncestor = function(root, p, q) {
  * @return {TreeNode}
  */
 const lowestCommonAncestor = function(root, p, q) {
-    while((root.val - p.val) * (root.val - q.val) > 0) {
-          root = root.val > p.val ? root.left : root.right
-    }
-    return root
+  while((root.val - p.val) * (root.val - q.val) > 0) {
+    root = p.val < root.val ? root.left : root.right
+  }
+  return root
 };

From 2b9a89b48544bd6dc36d7c13955ced7477f8e935 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Dec 2024 11:02:18 +0800
Subject: [PATCH 3233/3374] Update 1915-number-of-wonderful-substrings.js

---
 1915-number-of-wonderful-substrings.js | 29 ++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/1915-number-of-wonderful-substrings.js b/1915-number-of-wonderful-substrings.js
index 99f3a690..800696e7 100644
--- a/1915-number-of-wonderful-substrings.js
+++ b/1915-number-of-wonderful-substrings.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const wonderfulSubstrings = function(word) {
+  const n = word.length;
+  let mask = 0
+  const hash = {0: 1}, a = 'a'.charCodeAt(0)
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    const idx = word.charCodeAt(i) - a
+    mask ^= (1 << idx)
+
+    res += hash[mask] || 0
+    for(let j = 0; j < 10; j++) {
+      const newMask = mask ^ (1 << j)
+      res += hash[newMask] || 0
+    }
+
+    if(hash[mask] == null) hash[mask] = 0
+    hash[mask]++
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} word
  * @return {number}

From 9cb24d64d19a0681b54d537255a60ebbe901d57e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Dec 2024 01:56:33 -0800
Subject: [PATCH 3234/3374] Update 2949-count-beautiful-substrings-ii.js

---
 2949-count-beautiful-substrings-ii.js | 78 +++++++++++++++++++++------
 1 file changed, 62 insertions(+), 16 deletions(-)

diff --git a/2949-count-beautiful-substrings-ii.js b/2949-count-beautiful-substrings-ii.js
index e1f8c0b0..a9497f70 100644
--- a/2949-count-beautiful-substrings-ii.js
+++ b/2949-count-beautiful-substrings-ii.js
@@ -1,27 +1,73 @@
+const set = new Set(['a', 'e', 'i', 'o', 'u']);
 /**
  * @param {string} s
  * @param {number} k
  * @return {number}
  */
 var beautifulSubstrings = function(s, k) {
-    let ans = 0, cur = 0;
-    let mp = new Map();
-    mp.set(0, [-1]);
-    for (let i = 0; i < s.length; i++) {
-        let ch = s[i];
-        if (ch === 'a' || ch === 'e' || ch === 'i' || ch === 'o' || ch === 'u') {
-            cur++;
+    const primes = Eratosthenes(k);
+    let m = 1;
+
+    for (const p of primes) {
+        let count = 0;
+        while (k % p === 0) {
+            count++;
+            k /= p;
+        }
+        if (count !== 0 && count % 2 === 1) {
+            m *= Math.pow(p, (count + 1) / 2);
+        } else if (count !== 0 && count % 2 === 0) {
+            m *= Math.pow(p, count / 2);
+        }
+    }
+    m *= 2;
+
+    const n = s.length;
+    s = '#' + s; // Prepend a character to ensure 1-based indexing
+    let ret = 0;
+
+    const map = new Map();
+    map.set(0, new Map());
+    map.get(0).set(0, 1);
+
+    let count = 0;
+
+    for (let i = 1; i <= n; i++) {
+        if (set.has(s[i])) {
+            count++;
         } else {
-            cur--;
+            count--;
+        }
+
+        if (map.has(count) && map.get(count).has(i % m)) {
+            ret += map.get(count).get(i % m);
         }
-        for (let x of (mp.get(cur) || []) ) {
-            let d = (i - x) / 2;
-            if (Math.pow(d, 2) % k === 0) {
-                ans++;
-            }
+
+        if (!map.has(count)) {
+            map.set(count, new Map());
         }
-        if (!mp.has(cur)) mp.set(cur, []);
-        mp.get(cur).push(i);
+        map.get(count).set(i % m, (map.get(count).get(i % m) || 0) + 1);
     }
-    return ans;
+
+    return ret;
 };
+
+function Eratosthenes(n) {
+    const q = Array(n + 1).fill(0);
+    const primes = [];
+
+    for (let i = 2; i <= Math.sqrt(n); i++) {
+        if (q[i] === 1) continue;
+        for (let j = i * 2; j <= n; j += i) {
+            q[j] = 1;
+        }
+    }
+
+    for (let i = 2; i <= n; i++) {
+        if (q[i] === 0) {
+            primes.push(i);
+        }
+    }
+
+    return primes;
+}

From eef52030e28da09aeb627efd03f65af9f0158844 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 31 Dec 2024 13:04:45 +0800
Subject: [PATCH 3235/3374] Update 2488-count-subarrays-with-median-k.js

---
 2488-count-subarrays-with-median-k.js | 36 +++++++++++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/2488-count-subarrays-with-median-k.js b/2488-count-subarrays-with-median-k.js
index 54a7d129..fadcdcb5 100644
--- a/2488-count-subarrays-with-median-k.js
+++ b/2488-count-subarrays-with-median-k.js
@@ -25,3 +25,39 @@ const permutationArrayWithMedianK = (a, k) => {
   }
   return res;
 };
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var countSubarrays = function(nums, k) {
+  const n = nums.length;
+  for(let i = 0; i < n; i++) {
+    nums[i] = nums[i] < k ? -1 : nums[i] === k ? 0 : 1
+  }
+  const evenSum = {}
+  const oddSum = {}
+  evenSum[0] = 1
+    let sum = 0
+    let res = 0
+    for(let i = 0; i < n; i++) {
+        sum += nums[i]
+        if(i % 2 === 0) {
+            if(evenSum[sum] != null) res += evenSum[sum]
+            if(oddSum[sum - 1] != null) res += oddSum[sum - 1]
+            if(oddSum[sum] == null) oddSum[sum] = 0
+            oddSum[sum]++
+        } else {
+            if(oddSum[sum] != null) res += oddSum[sum]
+            if(evenSum[sum - 1] != null) res += evenSum[sum - 1]
+            if(evenSum[sum] == null) evenSum[sum] = 0
+            evenSum[sum]++
+        }
+    }
+ // console.log(evenSum, oddSum, nums)
+  return res
+};

From 4e4214f3a83bff363312bfbe6f16c256b361ac30 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jan 2025 15:17:09 +0800
Subject: [PATCH 3236/3374] Update
 3381-maximum-subarray-sum-with-length-divisible-by-k.js

---
 ...subarray-sum-with-length-divisible-by-k.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/3381-maximum-subarray-sum-with-length-divisible-by-k.js b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
index d84efd15..7dcf1c3f 100644
--- a/3381-maximum-subarray-sum-with-length-divisible-by-k.js
+++ b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxSubarraySum = function(nums, k) {
+    const ps = [0]
+    for (const e of nums) {
+        ps.push(ps[ps.length - 1] + e)
+    }
+    let res = Number.MIN_SAFE_INTEGER
+    for (let p = 0; p < k; ++p) {
+        let sum = 0
+        for (let i = p; i + k <= nums.length; i += k) {
+            const n = ps[i + k] - ps[i]
+            sum = Math.max(n, sum + n)
+            res = Math.max(res, sum)
+        }
+    }
+    return res
+}
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From ee51d068f0c93dd7ac3269474b47ae590cc7c7af Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 2 Jan 2025 17:14:47 +0800
Subject: [PATCH 3237/3374] Update
 795-number-of-subarrays-with-bounded-maximum.js

---
 ...umber-of-subarrays-with-bounded-maximum.js | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)

diff --git a/795-number-of-subarrays-with-bounded-maximum.js b/795-number-of-subarrays-with-bounded-maximum.js
index 61e17d9d..2634c6fd 100644
--- a/795-number-of-subarrays-with-bounded-maximum.js
+++ b/795-number-of-subarrays-with-bounded-maximum.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @param {number} left
+ * @param {number} right
+ * @return {number}
+ */
+const numSubarrayBoundedMax = function(nums, left, right) {
+  const n = nums.length;
+    let res = 0
+    const preLargerOrEqual = Array(n).fill(-1)
+    const postLarger = Array(n).fill(n)
+    let stk = []
+    stk.push(0)
+    for(let i = 1; i < n; i++) {
+        const e = nums[i]
+        while(stk.length && nums[stk[stk.length - 1]] < e) {
+            stk.pop()
+        }
+        if(stk.length) {
+            preLargerOrEqual[i] = stk[stk.length - 1]
+        }
+        stk.push(i)
+    }
+    stk = []
+    stk.push(n - 1)
+    for(let i = n - 2; i >= 0; i--) {
+        const e = nums[i]
+        while(stk.length && nums[stk[stk.length - 1]] <= e) {
+            stk.pop()
+        }
+        if(stk.length) {
+            postLarger[i] = stk[stk.length - 1]
+        }
+        stk.push(i)
+    }
+    for(let i = 0; i < n; i++) {
+        const e = nums[i]
+        if(e >= left && e <= right) {
+            const pre = preLargerOrEqual[i]
+            const post = postLarger[i]
+            res += (i - pre) * (post - i)
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} left

From 7485378d4b7bd25c476f9d988c9d72d61e774d4f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 3 Jan 2025 15:06:33 +0800
Subject: [PATCH 3238/3374] Update
 1625-lexicographically-smallest-string-after-applying-operations.js

---
 ...allest-string-after-applying-operations.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)

diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
index ed184351..ec693a8b 100644
--- a/1625-lexicographically-smallest-string-after-applying-operations.js
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -1,3 +1,51 @@
+/**
+ * @param {string} s
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const findLexSmallestString = function(s, a, b) {
+    let res = s;
+    const n = s.length;
+
+    let evenLimit = 10;
+    if (b % 2 === 0) evenLimit = 1;
+
+    for (let i = 0; i < evenLimit; i++) {
+        for (let j = 0; j < 10; j++) {
+            let t = s.split('');
+
+            for (let k = 0; k < n; k += 2) {
+                t[k] = (parseInt(t[k]) + a * i) % 10;
+            }
+            for (let k = 1; k < n; k += 2) {
+                t[k] = (parseInt(t[k]) + a * j) % 10;
+            }
+
+            t = t.join('');
+            let p = t;
+            const gcdValue = gcd(n, b);
+            for (let k = 0; k <= n / gcdValue; k++) {
+                p = p.slice(n - b) + p.slice(0, n - b);
+                res = res < p ? res : p;
+            }
+        }
+    }
+
+    return res;    
+};
+
+
+function gcd(x, y) {
+    while (y !== 0) {
+        let temp = y;
+        y = x % y;
+        x = temp;
+    }
+    return x;
+}
+// another
+
 /**
  * @param {string} s
  * @param {number} a

From 5741d55332efe251d61a24e3367bd4de25d9b6fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 6 Jan 2025 12:13:47 +0800
Subject: [PATCH 3239/3374] Update
 1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js

---
 ...ters-to-satisfy-one-of-three-conditions.js | 52 +++++++++++++++++++
 1 file changed, 52 insertions(+)

diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index aa948052..503c429e 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -1,3 +1,55 @@
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+const minCharacters = function(a, b) {
+  const n = a.length, m = b.length;
+    const freqA = Array(26).fill(0), freqB = Array(26).fill(0);
+    const ac = 'a'.charCodeAt(0)
+    for(let i = 0; i < n; i++) {
+        freqA[a.charCodeAt(i) - ac]++
+    }
+    for(let i = 0; i < m; i++) {
+        freqB[b.charCodeAt(i) - ac]++
+    }
+    let res = Infinity
+    for(let i = 0; i < 26; i++) {
+        if(i > 0) {
+            let change = 0
+            for(let j = 0; j < i; j++) {
+                change += freqA[j]
+            }
+            for(let j = i; j < 26; j++) {
+                change += freqB[j]
+            }
+            res = Math.min(res, change)
+            change = 0
+            for(let j = 0; j < i; j++) {
+                change += freqB[j]
+            }
+            for(let j = i; j < 26; j++) {
+                change += freqA[j]
+            }
+            res = Math.min(res, change)
+        }
+        let change = 0
+        for(let j = 0; j < 26; j++) {
+            if(j !== i) {
+                change += freqA[j]
+                change += freqB[j]
+            }
+        }
+        res = Math.min(res, change)
+    }
+
+    return res
+};
+
+
+// another
+
+
 /**
  * @param {string} a
  * @param {string} b

From 5668d6b5b799f03f28881b839ae205f07cd581f1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 7 Jan 2025 14:24:11 +0800
Subject: [PATCH 3240/3374] Update 2013-detect-squares.js

---
 2013-detect-squares.js | 53 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 53 insertions(+)

diff --git a/2013-detect-squares.js b/2013-detect-squares.js
index 3cb84312..4efeefa0 100644
--- a/2013-detect-squares.js
+++ b/2013-detect-squares.js
@@ -1,4 +1,57 @@
 
+var DetectSquares = function() {
+    this.mat = Array.from({length: 1001}, () => Array.from({length: 1001}, () => 0));
+    this.ya = new Map()
+};
+
+/** 
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function(point) {
+    const [x, y] = point;
+    this.mat[x][y]++;
+    if(this.ya.get(y) == null) this.ya.set(y, new Map())
+    if(this.ya.get(y).get(x) == null) this.ya.get(y).set(x, 0)
+    this.ya.get(y).set(x, this.ya.get(y).get(x) + 1)
+};
+
+/** 
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function(point) {
+    const [x, y] = point;
+    let res = 0
+    if(!this.ya.has(y)) return res
+    for(const [key, cnt] of this.ya.get(y)) {
+        const i = +key
+        const d = Math.abs(x - i)
+        if(d === 0) continue
+        let j = y + d
+        if(j >= 0 && j < 1001) {
+            res += cnt * this.mat[x][j] * this.mat[i][j]
+        }
+        j = y - d
+        if(j >= 0 && j < 1001) {
+            res += cnt * this.mat[x][j] * this.mat[i][j]
+        }
+    }
+
+    return res
+};
+
+/** 
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */
+
+// another
+
+
+
 const DetectSquares = function() {
   this.pts = []
   this.ptsCnt = {}

From b9ad1ffe5a4d7a0524dc842979d43e4963884026 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Jan 2025 12:19:15 +0800
Subject: [PATCH 3241/3374] Update 2768-number-of-black-blocks.js

---
 2768-number-of-black-blocks.js | 35 ++++++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/2768-number-of-black-blocks.js b/2768-number-of-black-blocks.js
index 241fd1fe..6f299cd7 100644
--- a/2768-number-of-black-blocks.js
+++ b/2768-number-of-black-blocks.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} coordinates
+ * @return {number[]}
+ */
+var countBlackBlocks = function(m, n, coordinates) {
+  
+  const map = new Map();
+    for (const [x, y] of coordinates) {
+        for(let i = x - 1; i <= x; i++) {
+            for(let j = y - 1; j <= y; j++) {
+                if(i >= 0 && j >= 0 && i < m - 1 && j < n - 1) {
+                    const key = encode(i, j);
+                    map.set(key, (map.get(key) || 0) + 1);
+                }
+            }
+        }
+    }
+    const res = Array(5).fill(0);
+    for (const count of map.values()) {
+        res[count]++;
+    }
+
+    res[0] = (m - 1) * (n - 1) - res[1] - res[2] - res[3] - res[4];
+    return res;
+
+  function encode(x, y) {
+    return x * n + y;
+  }
+};
+
+// another
+
+
 /**
  * @param {number} m
  * @param {number} n

From 0734dff7819d07202ee18fc59df203be7236ffe7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 10 Jan 2025 10:46:30 +0800
Subject: [PATCH 3242/3374] Update
 2857-count-pairs-of-points-with-distance-k.js

---
 2857-count-pairs-of-points-with-distance-k.js | 31 +++++++++++++++++++
 1 file changed, 31 insertions(+)

diff --git a/2857-count-pairs-of-points-with-distance-k.js b/2857-count-pairs-of-points-with-distance-k.js
index bff65742..e85d888c 100644
--- a/2857-count-pairs-of-points-with-distance-k.js
+++ b/2857-count-pairs-of-points-with-distance-k.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} coordinates
+ * @param {number} k
+ * @return {number}
+ */
+var countPairs = function(coordinates, k) {
+    const map = new Map();
+    const n = coordinates.length;
+    const MUL = 1e6
+    let res = 0;
+    for(let i = 0; i < n; i++) {
+        const [x, y] = coordinates[i];
+        for(let e = 0; e <= k; e++) {
+            const x2 = x ^ e;
+            const y2 = (k - e) ^ y;
+            const key = code(x2, y2);
+            res += map.get(key) || 0;
+        }
+        const key = code(x, y);
+        map.set(key, (map.get(key) || 0) + 1);
+    }
+
+    return res
+
+    function code(x, y) {
+        return x * MUL + y
+    }
+};
+
+// another
+
 /**
  * @param {number[][]} coordinates
  * @param {number} k

From c9aec0116e789798aa5a794c84cabbd072e4a6b5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 11 Jan 2025 04:26:27 -0800
Subject: [PATCH 3243/3374] Create 3404-count-special-subsequences.js

---
 3404-count-special-subsequences.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 3404-count-special-subsequences.js

diff --git a/3404-count-special-subsequences.js b/3404-count-special-subsequences.js
new file mode 100644
index 00000000..69fc7410
--- /dev/null
+++ b/3404-count-special-subsequences.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var numberOfSubsequences = function(nums) {
+        let n = nums.length;
+        let res = 0;
+        const cnt = new Map();
+        for (let r = 4; r < n - 2; ++r) {
+            let q = r - 2;
+            for (let p = 0; p < q - 1; ++p) {
+                let key = 1.0 * nums[p] / nums[q];
+                cnt.set(key, (cnt.get(key) || 0) + 1);
+            }
+            for (let s = r + 2; s < n; ++s) {
+                let key = 1.0 * nums[s] / nums[r];
+                res += cnt.get(key) || 0;
+            }
+        }
+        return res;
+};

From 12b4f865244ef14cdf52661dd9072252f6c91afe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 13 Jan 2025 10:42:43 +0800
Subject: [PATCH 3244/3374] Update 435-non-overlapping-intervals.js

---
 435-non-overlapping-intervals.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/435-non-overlapping-intervals.js b/435-non-overlapping-intervals.js
index 5b57a608..7f4ffa45 100644
--- a/435-non-overlapping-intervals.js
+++ b/435-non-overlapping-intervals.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+var eraseOverlapIntervals = function(intervals) {
+    intervals.sort((a, b) => a[1] - b[1]);
+    let res = 0
+    let end = -Infinity
+    for(const [start, finish] of intervals) {
+        if(start < end) res++
+        else end = finish
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} intervals
  * @return {number}

From d5d600931e83e60f356ef8dc38b70c259db3ca5e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 14 Jan 2025 10:47:29 +0800
Subject: [PATCH 3245/3374] Update
 452-minimum-number-of-arrows-to-burst-balloons.js

---
 ...imum-number-of-arrows-to-burst-balloons.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)

diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
index bd476101..ca8f8d45 100644
--- a/452-minimum-number-of-arrows-to-burst-balloons.js
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var findMinArrowShots = function(points) {
+    points.sort((a, b) => a[1] - b[1]);
+    if(points.length === 0) return 0
+    let res = 1
+    let end = points[0][1]
+    for(let i = 1; i < points.length; i++) {
+        const [s,e] = points[i]
+        if(s > end) {
+            res++
+            end = e
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} points
  * @return {number}

From ea84c7f9af48324493f97028fdcb0c433e54b2e9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Jan 2025 10:36:41 +0800
Subject: [PATCH 3246/3374] Update 646-maximum-length-of-pair-chain.js

---
 646-maximum-length-of-pair-chain.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/646-maximum-length-of-pair-chain.js b/646-maximum-length-of-pair-chain.js
index 9ec23294..3a0661cd 100755
--- a/646-maximum-length-of-pair-chain.js
+++ b/646-maximum-length-of-pair-chain.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+var findLongestChain = function(pairs) {
+    pairs.sort((a, b) => a[1] - b[1]);
+    if(pairs.length === 0) return 0
+    let res = 1
+    let end = pairs[0][1]
+    for(let i = 1; i < pairs.length; i++) {
+        if(pairs[i][0] > end) {
+            res++
+            end = pairs[i][1]
+        }
+    }
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} pairs
  * @return {number}

From f0987e3a55d07bb25189fa935af2302f1fb61332 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Jan 2025 11:50:01 +0800
Subject: [PATCH 3247/3374] Update 757-set-intersection-size-at-least-two.js

---
 757-set-intersection-size-at-least-two.js | 28 +++++++++++++++++++++++
 1 file changed, 28 insertions(+)

diff --git a/757-set-intersection-size-at-least-two.js b/757-set-intersection-size-at-least-two.js
index 1675a247..6ee71d49 100644
--- a/757-set-intersection-size-at-least-two.js
+++ b/757-set-intersection-size-at-least-two.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+var intersectionSizeTwo = function(intervals) {
+    intervals.sort((a, b) => a[1] === b[1] ? b[0] - a[0] : a[1] - b[1]);
+    let res = 2
+    let a = intervals[0][1] - 1, b = intervals[0][1]
+
+    for(const [s, e] of intervals) {
+        if(s <= a) continue
+        else if(s <= b) {
+            res++
+            a = b
+            b = e
+        } else {
+            res += 2
+            a = e - 1
+            b = e
+        }
+    }
+
+    return res
+};
+
+// another
+
+
 /**
  * @param {number[][]} intervals
  * @return {number}

From a7c0626917c81bf0f27c97f001a542838b35e786 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Jan 2025 05:05:42 -0800
Subject: [PATCH 3248/3374] Create
 3413-maximum-coins-from-k-consecutive-bags.js

---
 3413-maximum-coins-from-k-consecutive-bags.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 3413-maximum-coins-from-k-consecutive-bags.js

diff --git a/3413-maximum-coins-from-k-consecutive-bags.js b/3413-maximum-coins-from-k-consecutive-bags.js
new file mode 100644
index 00000000..b2928c3e
--- /dev/null
+++ b/3413-maximum-coins-from-k-consecutive-bags.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} coins
+ * @param {number} k
+ * @return {number}
+ */
+var maximumCoins = function(coins, k) {
+    coins.sort((a, b) => a[0] - b[0]);
+    const n = coins.length;
+
+    let res = 0, cur = 0;
+    for (let i = 0, j = 0; i < n; ++i) {
+        while (j < n && coins[j][1] <= coins[i][0] + k - 1) {
+            cur +=(coins[j][1] - coins[j][0] + 1) * (coins[j][2]);
+            j++;
+        }
+        if (j < n) {
+            const part =  Math.max(0, coins[i][0] + k - 1 - coins[j][0] + 1) * (coins[j][2]);
+            res = Math.max(res, cur + part);
+        }
+        cur -=  (coins[i][1] - coins[i][0] + 1) * (coins[i][2]);
+    }
+
+    cur = 0;
+    for (let i = 0, j = 0; i < n; ++i) {
+        cur += 1 * (coins[i][1] - coins[i][0] + 1) * (coins[i][2]);
+        while (coins[j][1] < coins[i][1] - k + 1) {
+            cur -= 1 * (coins[j][1] - coins[j][0] + 1) * (coins[j][2]);
+            j++;
+        }
+        const part = 1 * Math.max(0, coins[i][1] - k - coins[j][0] + 1) * (coins[j][2]);
+        res = Math.max(res, cur - part);
+    }
+
+    return res;
+};

From 1dab92d53fe336be991797bb7429d8d2ed99d3bb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 7 Feb 2025 23:07:37 -0800
Subject: [PATCH 3249/3374] Create
 3395-subsequences-with-a-unique-middle-mode-i.js

---
 ...ubsequences-with-a-unique-middle-mode-i.js | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 3395-subsequences-with-a-unique-middle-mode-i.js

diff --git a/3395-subsequences-with-a-unique-middle-mode-i.js b/3395-subsequences-with-a-unique-middle-mode-i.js
new file mode 100644
index 00000000..0ec3f8f9
--- /dev/null
+++ b/3395-subsequences-with-a-unique-middle-mode-i.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var subsequencesWithMiddleMode = function(nums) {
+  const n = nums.length;
+  // 总方案数为C(n,5)
+  let ans = comb(n, 5);
+  const mod = 10 ** 9 + 7;
+  // 统计不合法的个数
+  // 记录每个元素的个数
+  const hash = new Map();
+  for (const num of nums) hash.set(num, (hash.get(num) || 0) + 1);
+  const pre = new Map(); // 记录之前的元素情况
+  // 枚举x，作为子序列最中间的数
+  for (let i = 0; i < n - 2; i++) {
+    const x = nums[i];
+    hash.set(x, hash.get(x) - 1); // 更新右边元素的个数
+    if (i > 1) {
+      const right = n - 1 - i; // 右边元素个数
+      const left = i; // 左边元素个数
+      const preX = pre.get(x) || 0; // 左边x元素个数
+      const sufX = hash.get(x) || 0; // 右边x元素个数
+      // 不合法：只有一个x的情况，左边选取不是x的两个，右边选取不是x的两个
+      ans -= comb(left - preX, 2) * comb(right - sufX, 2);
+      // 不合法：有两个x，但是要有一个y，出现在2次以上
+      for (const [y, sufY] of hash) {
+        if (y === x) continue;
+        const preY = pre.get(y) || 0;
+        // 左边两个Y，右边一个X, yy x xz(z可以为y)
+        ans -= comb(preY, 2) * sufX * (right - sufX);
+        // 右边两个Y，左边一个X，zx x yy (z可以为y)
+        ans -= comb(sufY, 2) * preX * (left - preX);
+        // 左右各一个y，另一个x在左边，xy x yz(z !== y,避免重复)
+        ans -= preY * preX * sufY * (right - sufX - sufY);
+        // 左右各一个y，另一个x在右边，zy x yx(z !== y,避免重复)
+        ans -= preY * sufY * sufX * (left - preX - preY);
+      }
+    }
+    pre.set(x, (pre.get(x) || 0) + 1); // 更新左边元素的个数
+  }
+  return ans % mod;  
+};
+
+
+/**
+ * @description 求组合数
+ * @param {number} n
+ * @param {number} m
+ * @returns {number}
+ */
+function comb(n, m) {
+  if (n < m) return 0;
+  let top = 1;
+  let bottom = 1;
+  let start = 0;
+  while (start < m) {
+    top *= n - start;
+    bottom *= m - start;
+    start++;
+  }
+  return top / bottom;
+}

From 052d006894c8f2b1fa162f2550a4099764e89eaa Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Feb 2025 02:21:45 -0800
Subject: [PATCH 3250/3374] Create
 3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js

---
 ...mum-sums-of-at-most-size-k-subsequences.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js

diff --git a/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
new file mode 100644
index 00000000..6813ab11
--- /dev/null
+++ b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minMaxSums = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let res = 0n
+  const MOD = 1e9 + 7
+  const ncr = Array.from({ length: nums.length + 1 }, () =>
+    Array(k + 1).fill(0),
+  )
+
+  ncr[0][0] = 1
+  for (let n = 1; n <= nums.length; n++) {
+    ncr[n][0] = 1
+    for (let r = 1; r <= k; r++)
+      ncr[n][r] = (ncr[n - 1][r - 1] + ncr[n - 1][r]) % MOD
+  }
+
+  for (let n = 0; n < nums.length; n++) {
+    let numberOfSubsequences = 0
+    for (let r = 0; r <= k - 1; r++)
+      if (n >= r)
+        numberOfSubsequences = (numberOfSubsequences + ncr[n][r]) % MOD
+    res =
+      (res +
+        ((BigInt(nums[n] + nums[nums.length - n - 1]) *
+          BigInt(numberOfSubsequences)) %
+          BigInt(MOD))) %
+      BigInt(MOD)
+  }
+  return Number(res)
+};

From 391a9eb8aa41fccda5593423d018de2f8bc823fe Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 9 Feb 2025 03:54:08 -0800
Subject: [PATCH 3251/3374] Update
 3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js

---
 ...mum-sums-of-at-most-size-k-subsequences.js | 40 +++++++++++++++++++
 1 file changed, 40 insertions(+)

diff --git a/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
index 6813ab11..7f057c86 100644
--- a/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
+++ b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
@@ -1,3 +1,43 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minMaxSums = function(nums, k) {
+  const big = BigInt
+  const mod = big(1e9 + 7)
+  const n = nums.length
+  const comb = Array.from({ length: n + 1 }, () => Array(k +  1).fill(0n))
+  
+  comb[0][0] = 1n
+  for(let i = 1; i <= n; i++) {
+    comb[i][0] = 1n
+    for(let j = 1; j <= k; j++) {
+        comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j]
+        comb[i][j] %= mod
+    }
+  }
+  
+  nums.sort((a, b) => a - b)
+
+  let res = 0n
+
+  for(let i = 0; i < n; i++) {
+    const e = big(nums[i])
+    for(let j = 0; j <= Math.min(i, k - 1); j++) {
+        res += (comb[i][j] * e) % mod
+    }
+    for(let j = 0; j < k; j++) {
+        res += (comb[n - 1 - i][j] * e) % mod
+    }
+  }
+
+
+  return Number(res % mod) 
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From 8269155622ad32e94e11f5315b94f15a0c06f539 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Feb 2025 03:17:18 -0800
Subject: [PATCH 3252/3374] Update
 3209-number-of-subarrays-with-and-value-of-k.js

---
 ...number-of-subarrays-with-and-value-of-k.js | 54 +++++++++----------
 1 file changed, 27 insertions(+), 27 deletions(-)

diff --git a/3209-number-of-subarrays-with-and-value-of-k.js b/3209-number-of-subarrays-with-and-value-of-k.js
index 9a46894b..64a0b79b 100644
--- a/3209-number-of-subarrays-with-and-value-of-k.js
+++ b/3209-number-of-subarrays-with-and-value-of-k.js
@@ -3,44 +3,44 @@
  * @param {number} k
  * @return {number}
  */
-var countSubarrays = function (nums, k) {
-  return atLeastK(nums, k) - atLeastK(nums, k + 1)
-}
+var countSubarrays = function(nums, k) {
+  return atLeastK(nums, k) - atLeastK(nums, k + 1); 
+};
 
 function atLeastK(nums, k) {
-  let ans = 0
-  let temp = new Array(32).fill(0)
+    let res = 0;
+    let temp = new Array(32).fill(0);
 
-  let l = 0
-  for (let r = 0; r < nums.length; r++) {
-    for (let i = 0; i < 32; i++) {
-      if ((1 << i) & nums[r]) {
-        temp[i]++
-      }
-    }
+    let l = 0;
+    for (let r = 0; r < nums.length; r++) {
+        for (let i = 0; i < 32; i++) {
+            if ((1 << i) & nums[r]) {
+                temp[i]++;
+            }
+        }
 
-    while (r - l + 1 > 0 && calc(temp, r - l + 1) < k) {
-      for (let i = 0; i < 32; i++) {
-        if ((1 << i) & nums[l]) {
-          temp[i]--
+        while ((r - l + 1) > 0 && calc(temp, r - l + 1) < k) {
+            for (let i = 0; i < 32; i++) {
+                if ((1 << i) & nums[l]) {
+                    temp[i]--;
+                }
+            }
+            l++;
         }
-      }
-      l++
+        res += (r - l + 1);
     }
-    ans += r - l + 1
-  }
 
-  return ans
+    return res;
 }
 
 // function to calculate the AND from frequency vector
 function calc(temp, w) {
-  let ans = 0
-  for (let i = 0; i < 32; i++) {
-    if (temp[i] === w) {
-      ans += 1 << i
+    let res = 0;
+    for (let i = 0; i < 32; i++) {
+        if (temp[i] === w) {
+            res += (1 << i);
+        }
     }
-  }
 
-  return ans
+    return res;
 }

From a627800d4a57a35422a9161b709536565e91edae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Feb 2025 03:46:32 -0800
Subject: [PATCH 3253/3374] Create 3290-maximum-multiplication-score.js

---
 3290-maximum-multiplication-score.js | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 3290-maximum-multiplication-score.js

diff --git a/3290-maximum-multiplication-score.js b/3290-maximum-multiplication-score.js
new file mode 100644
index 00000000..ed6eb065
--- /dev/null
+++ b/3290-maximum-multiplication-score.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} a
+ * @param {number[]} b
+ * @return {number}
+ */
+var maxScore = function(a, b) {
+   const dp = Array(4).fill(-4 * 1e5 * 1e5)
+   const {max} = Math
+   for(const e of b) {
+     dp[3] = max(dp[3], dp[2] + e * a[3])
+     dp[2] = max(dp[2], dp[1] + e * a[2])
+     dp[1] = max(dp[1], dp[0] + e * a[1])
+     dp[0] = max(dp[0], e * a[0])
+   }
+
+   return dp[3] 
+};

From f4d938d4034f566e95de1b4b7a05a2cf2301030d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Feb 2025 03:39:13 -0800
Subject: [PATCH 3254/3374] Update
 3350-adjacent-increasing-subarrays-detection-ii.js

---
 ...acent-increasing-subarrays-detection-ii.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/3350-adjacent-increasing-subarrays-detection-ii.js b/3350-adjacent-increasing-subarrays-detection-ii.js
index 537a67a3..c091eba0 100644
--- a/3350-adjacent-increasing-subarrays-detection-ii.js
+++ b/3350-adjacent-increasing-subarrays-detection-ii.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxIncreasingSubarrays = function (nums) {
+  const n = nums.length
+  let up = 1, preMaxUp = 0, res = 0
+
+  for(let i = 1; i < n; i++) {
+    if(nums[i] > nums[i - 1]) up++
+    else {
+        preMaxUp = up
+        up = 1
+    }
+    res = Math.max(res, Math.max(~~(up / 2), Math.min(preMaxUp, up)))
+  }
+
+
+  return res
+}
+
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From e45b007d4bf02cc2c48c37e06d8b0ee59c56d831 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 17 Feb 2025 03:50:50 -0800
Subject: [PATCH 3255/3374] Update 3366-minimum-array-sum.js

---
 3366-minimum-array-sum.js | 50 +++++++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)

diff --git a/3366-minimum-array-sum.js b/3366-minimum-array-sum.js
index 30021e40..b784f5c3 100644
--- a/3366-minimum-array-sum.js
+++ b/3366-minimum-array-sum.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} op1
+ * @param {number} op2
+ * @return {number}
+ */
+var minArraySum = function(nums, k, op1, op2) {
+  let dp = Array.from({ length: op1 + 1 }, () => Array(op2 + 1).fill(Infinity))
+  const {min, floor, ceil} = Math
+  
+  dp[op1][op2] = 0
+
+  for(const e of nums) {
+    const nxt = Array.from({ length: op1 + 1 }, () => Array(op2 + 1).fill(Infinity))
+    for(let i = 0; i <= op1; i++) {
+        for(let j = 0; j <= op2; j++) {
+            nxt[i][j] = min(nxt[i][j], dp[i][j] + e)
+            if(i > 0) {
+                const cur = ceil(e / 2)
+                nxt[i - 1][j] = min(nxt[i - 1][j], dp[i][j] + cur)
+                if(cur >= k && j > 0) {
+                    nxt[i - 1][j - 1] = min(nxt[i - 1][j - 1], dp[i][j] + cur - k)
+                }
+            }
+            if(j > 0 && e >= k) {
+                const cur = e - k
+                nxt[i][j - 1] = min(nxt[i][j - 1], dp[i][j] + cur)
+                if(i > 0) {
+                    nxt[i - 1][j - 1] = min(nxt[i - 1][j - 1], dp[i][j] + ceil(cur / 2))
+                }
+            }
+        }
+    }
+
+    dp = nxt
+  }
+   
+  let res = Infinity
+  for(let i = 0; i <= op1; i++) {
+    for(let j = 0; j <= op2; j++) {
+        res = Math.min(res, dp[i][j])
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k

From e5ec049eb9c66e48dc42b5c25a00f6128c8f4c1a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Feb 2025 07:01:05 -0800
Subject: [PATCH 3256/3374] Create 3376-minimum-time-to-break-locks-i.js

---
 3376-minimum-time-to-break-locks-i.js | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)
 create mode 100644 3376-minimum-time-to-break-locks-i.js

diff --git a/3376-minimum-time-to-break-locks-i.js b/3376-minimum-time-to-break-locks-i.js
new file mode 100644
index 00000000..9925ba38
--- /dev/null
+++ b/3376-minimum-time-to-break-locks-i.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} strength
+ * @param {number} k
+ * @return {number}
+ */
+var findMinimumTime = function(strength, k) {
+    strength.sort((a, b) => a - b)
+    const n = strength.length, {floor} = Math
+    let res = Infinity
+    f(0, 1, 0)
+    return res
+
+    function f(mask, x, tmp) {
+        if(mask === (1 << n) - 1) {
+            res = Math.min(res, tmp)
+            return
+        } 
+        let sum = x, add = 0
+        for(let i = 0; i < n; i++) {
+            if(mask & (1 << i)) continue
+            add = floor((strength[i] + x - 1) / x)
+            f(mask | (1 << i), x + k, tmp + add)
+        }
+    }
+};

From a530000a6ba5fe764905207afa2c09d9e7bd5fca Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Feb 2025 07:04:35 -0800
Subject: [PATCH 3257/3374] Update 3376-minimum-time-to-break-locks-i.js

---
 3376-minimum-time-to-break-locks-i.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3376-minimum-time-to-break-locks-i.js b/3376-minimum-time-to-break-locks-i.js
index 9925ba38..7deee055 100644
--- a/3376-minimum-time-to-break-locks-i.js
+++ b/3376-minimum-time-to-break-locks-i.js
@@ -15,7 +15,7 @@ var findMinimumTime = function(strength, k) {
             res = Math.min(res, tmp)
             return
         } 
-        let sum = x, add = 0
+        let add = 0
         for(let i = 0; i < n; i++) {
             if(mask & (1 << i)) continue
             add = floor((strength[i] + x - 1) / x)

From bc37c34df536db0e14ca36e60b004c4c2127cf03 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Feb 2025 07:06:34 -0800
Subject: [PATCH 3258/3374] Update 3376-minimum-time-to-break-locks-i.js

---
 3376-minimum-time-to-break-locks-i.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/3376-minimum-time-to-break-locks-i.js b/3376-minimum-time-to-break-locks-i.js
index 7deee055..450bba1c 100644
--- a/3376-minimum-time-to-break-locks-i.js
+++ b/3376-minimum-time-to-break-locks-i.js
@@ -18,7 +18,7 @@ var findMinimumTime = function(strength, k) {
         let add = 0
         for(let i = 0; i < n; i++) {
             if(mask & (1 << i)) continue
-            add = floor((strength[i] + x - 1) / x)
+            add = ceil(strength[i] / x)
             f(mask | (1 << i), x + k, tmp + add)
         }
     }

From 1b287d130ba11c7074b3b3e17bd3c45d1b2e1b9d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 19 Feb 2025 23:48:03 -0800
Subject: [PATCH 3259/3374] Create 3393-count-paths-with-the-given-xor-value.js

---
 3393-count-paths-with-the-given-xor-value.js | 29 ++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3393-count-paths-with-the-given-xor-value.js

diff --git a/3393-count-paths-with-the-given-xor-value.js b/3393-count-paths-with-the-given-xor-value.js
new file mode 100644
index 00000000..8403c4b1
--- /dev/null
+++ b/3393-count-paths-with-the-given-xor-value.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ */
+const countPathsWithXorValue = function(grid, k) {
+  const m = grid.length, n = grid[0].length
+  const mod = 1e9 + 7
+  const dp = Array.from({length: m}, () => Array.from({length: n}, () => Array(16).fill(0)))
+  dp[0][0][grid[0][0]] = 1
+
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+        for(let v = 0; v < 16; v++) {
+            if(dp[i][j][v] <= 0) continue
+            if(i + 1 < m) {
+                const e = grid[i + 1][j]
+                dp[i + 1][j][v ^ e] = (dp[i + 1][j][v ^ e] + dp[i][j][v]) % mod
+            }
+            if(j + 1 < n) {
+                const e = grid[i][j + 1]
+                dp[i][j + 1][v ^ e] = (dp[i][j + 1][v ^ e] + dp[i][j][v]) % mod
+            }
+        }
+    }
+  }
+
+  return dp[m - 1][n - 1][k]
+};

From e3e171579e46ef3a4e4a4d98a0c58ed825edee41 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 21 Feb 2025 00:49:37 -0800
Subject: [PATCH 3260/3374] Create
 3444-minimum-increments-for-target-multiples-in-an-array.js

---
 ...ements-for-target-multiples-in-an-array.js | 62 +++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 3444-minimum-increments-for-target-multiples-in-an-array.js

diff --git a/3444-minimum-increments-for-target-multiples-in-an-array.js b/3444-minimum-increments-for-target-multiples-in-an-array.js
new file mode 100644
index 00000000..f7115be1
--- /dev/null
+++ b/3444-minimum-increments-for-target-multiples-in-an-array.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} target
+ * @return {number}
+ */
+var minimumIncrements = function(nums, target) {
+    const k = target.length;
+    const mpp = new Map();
+
+    for (let mask = 1; mask < (1 << k); mask++) {
+        const subset = [];
+        for (let i = 0; i < k; i++) {
+            if (mask & (1 << i)) {
+                subset.push(target[i]);
+            }
+        }
+        let currlcm = subset[0];
+        for (let j = 1; j < subset.length; j++) {
+            currlcm = lcm(currlcm, subset[j]);
+        }
+        mpp.set(mask, currlcm);
+    }
+
+    const fullmask = (1 << k) - 1;
+    const dp = new Array(1 << k).fill(Infinity);
+    dp[0] = 0;
+
+    for (const num of nums) {
+        const maskcost = [];
+        for (const [mask, lcmval] of mpp) {
+            const rm = num % lcmval;
+            const cost = (rm === 0) ? 0 : (lcmval - rm);
+            maskcost.push([mask, cost]);
+        }
+
+        const newdp = [...dp];
+        for (let prevmask = 0; prevmask < (1 << k); prevmask++) {
+            if (dp[prevmask] === Infinity) continue;
+            for (const [mask, cost] of maskcost) {
+                const nmask = prevmask | mask;
+                const ncost = dp[prevmask] + cost;
+                if (ncost < newdp[nmask]) {
+                    newdp[nmask] = ncost;
+                }
+            }
+        }
+
+        dp.splice(0, dp.length, ...newdp);
+    }
+
+    return dp[fullmask] === Infinity ? -1 : dp[fullmask];
+};
+function gcd(a, b) {
+    while (b) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+
+function lcm(a, b) {
+    return (a / gcd(a, b)) * b;
+}

From db354ae71082421008268e25728329381b802475 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 26 Feb 2025 03:19:12 -0800
Subject: [PATCH 3261/3374] Create 3458-select-k-disjoint-special-substrings.js

---
 3458-select-k-disjoint-special-substrings.js | 53 ++++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 3458-select-k-disjoint-special-substrings.js

diff --git a/3458-select-k-disjoint-special-substrings.js b/3458-select-k-disjoint-special-substrings.js
new file mode 100644
index 00000000..e25307b5
--- /dev/null
+++ b/3458-select-k-disjoint-special-substrings.js
@@ -0,0 +1,53 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {boolean}
+ */
+var maxSubstringLength = function (s, k) {
+    const n = s.length;
+    const first = Array(26).fill(-1);
+    const last = Array(26).fill(-1);
+    
+    for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        if (first[c] === -1) first[c] = i;
+        last[c] = i;
+    }
+
+    const intervals = [];
+    for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        if (i !== first[c]) continue;
+
+        let j = last[c];
+        for (let k = i; k <= j; k++) {
+            j = Math.max(j, last[s.charCodeAt(k) - 'a'.charCodeAt(0)]);
+        }
+
+        let flag = true;
+        for (let k = i; k <= j; k++) {
+            if (first[s.charCodeAt(k) - 'a'.charCodeAt(0)] < i) {
+                flag = false;
+                break;
+            }
+        }
+        if (!flag) continue;
+
+        if (i === 0 && j === n - 1) continue;
+
+        intervals.push([i, j]);
+    }
+
+    intervals.sort((a, b) => a[1] - b[1]);
+
+    let cnt = 0;
+    let currend = -1;
+    for (const i of intervals) {
+        if (i[0] > currend) {
+            cnt++;
+            currend = i[1];
+        }
+    }
+
+    return cnt >= k;
+}

From 852870dd3980c52ced7ba8b5ffdd239bb5eb038e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 27 Feb 2025 02:42:49 -0800
Subject: [PATCH 3262/3374] Create
 3394-check-if-grid-can-be-cut-into-sections.js

---
 ...-check-if-grid-can-be-cut-into-sections.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 3394-check-if-grid-can-be-cut-into-sections.js

diff --git a/3394-check-if-grid-can-be-cut-into-sections.js b/3394-check-if-grid-can-be-cut-into-sections.js
new file mode 100644
index 00000000..82710629
--- /dev/null
+++ b/3394-check-if-grid-can-be-cut-into-sections.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number[][]} rectangles
+ * @return {boolean}
+ */
+var checkValidCuts = function(n, rectangles) {
+    const vertical = [];
+    const horizontal = [];
+    for (const it of rectangles) {
+        vertical.push([it[1], it[3]])
+        horizontal.push([it[0], it[2]])
+    }
+    const mergeH = mergeIntervals(horizontal);
+    const mergeV = mergeIntervals(vertical);
+    return mergeH.length >= 3 || mergeV.length >= 3;  
+};
+function mergeIntervals(intervals) {
+    if (intervals.length <= 1) return intervals;
+    intervals.sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    merged.push(intervals[0]);
+    for (let i = 1; i < intervals.length; ++i) {
+        if (intervals[i][0] < merged[merged.length - 1][1]) {
+            merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], intervals[i][1]);
+        } else {
+            merged.push(intervals[i]);
+        }
+    }
+    return merged;
+}

From 96df7e43fb31bd1e00a290f862d06802462af2a7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Mar 2025 03:34:49 -0800
Subject: [PATCH 3263/3374] Create
 2202-maximize-the-topmost-element-after-k-moves.js

---
 ...-maximize-the-topmost-element-after-k-moves.js | 15 +++++++++++++++
 1 file changed, 15 insertions(+)
 create mode 100644 2202-maximize-the-topmost-element-after-k-moves.js

diff --git a/2202-maximize-the-topmost-element-after-k-moves.js b/2202-maximize-the-topmost-element-after-k-moves.js
new file mode 100644
index 00000000..244e6835
--- /dev/null
+++ b/2202-maximize-the-topmost-element-after-k-moves.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumTop = function(nums, k) {
+  const n = nums.length
+  if(k === 0) return n >= 1 ? nums[0] : -1
+  if(k === 1) return n === 1 ? -1 : nums[1]
+  if(n === 1) return k % 2 === 0 ? nums[0] : -1
+  const tmp = nums.slice(0, Math.min(k - 1, n))
+  let res = Math.max(...tmp)
+  if(k < n) res = Math.max(res, nums[k])
+  return res  
+};

From b7d6d71a1f76c879022bd422966d174932b4bce8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Mar 2025 02:19:46 -0800
Subject: [PATCH 3264/3374] Create
 3471-find-the-largest-almost-missing-integer.js

---
 ...find-the-largest-almost-missing-integer.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3471-find-the-largest-almost-missing-integer.js

diff --git a/3471-find-the-largest-almost-missing-integer.js b/3471-find-the-largest-almost-missing-integer.js
new file mode 100644
index 00000000..abe842fa
--- /dev/null
+++ b/3471-find-the-largest-almost-missing-integer.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var largestInteger = function (nums, k) {
+  const freq = new Map()
+
+  for (let i = 0; i <= nums.length - k; i++) {
+    const sub = new Set(nums.slice(i, i + k))
+    for (const num of sub) {
+      freq.set(num, (freq.get(num) || 0) + 1)
+    }
+  }
+
+  let ans = -1
+  for (const [num, count] of freq) {
+    if (count === 1) {
+      ans = Math.max(ans, num)
+    }
+  }
+  return ans
+}

From 4189a78ad291865425f64281363fd4c98fac1b2a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Mar 2025 02:20:26 -0800
Subject: [PATCH 3265/3374] Create
 3472-longest-palindromic-subsequence-after-at-most-k-operations.js

---
 ...-subsequence-after-at-most-k-operations.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 3472-longest-palindromic-subsequence-after-at-most-k-operations.js

diff --git a/3472-longest-palindromic-subsequence-after-at-most-k-operations.js b/3472-longest-palindromic-subsequence-after-at-most-k-operations.js
new file mode 100644
index 00000000..2636a181
--- /dev/null
+++ b/3472-longest-palindromic-subsequence-after-at-most-k-operations.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var longestPalindromicSubsequence = function (s, k) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () =>
+    Array.from({ length: n }, () => Array(k + 1).fill(-1)),
+  )
+
+  function cost(a, b) {
+    const diff = Math.abs(a.charCodeAt(0) - b.charCodeAt(0))
+    return Math.min(diff, 26 - diff)
+  }
+
+  function dfs(i, j, rem) {
+    if (i > j) return 0
+    if (i === j) return 1
+    if (dp[i][j][rem] !== -1) return dp[i][j][rem]
+
+    let res = Math.max(dfs(i + 1, j, rem), dfs(i, j - 1, rem))
+    const c = cost(s[i], s[j])
+    if (c <= rem) {
+      res = Math.max(res, 2 + dfs(i + 1, j - 1, rem - c))
+    }
+    dp[i][j][rem] = res
+    return res
+  }
+
+  return dfs(0, n - 1, k)
+}

From 5da7e555e0e86516a1159faf7fd761738a444ab9 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Mar 2025 02:20:58 -0800
Subject: [PATCH 3266/3374] Create
 3473-sum-of-k-subarrays-with-length-at-least-m.js

---
 ...m-of-k-subarrays-with-length-at-least-m.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3473-sum-of-k-subarrays-with-length-at-least-m.js

diff --git a/3473-sum-of-k-subarrays-with-length-at-least-m.js b/3473-sum-of-k-subarrays-with-length-at-least-m.js
new file mode 100644
index 00000000..7ca52435
--- /dev/null
+++ b/3473-sum-of-k-subarrays-with-length-at-least-m.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} m
+ * @return {number}
+ */
+var maxSum = function (nums, k, m) {
+  const n = nums.length
+
+  const prefix = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] + nums[i]
+  }
+
+  const dp = Array.from({ length: k + 1 }, () =>
+    new Array(n + 1).fill(Number.MIN_SAFE_INTEGER / 2),
+  )
+  for (let i = 0; i <= n; i++) {
+    dp[0][i] = 0
+  }
+  for (let j = 0; j < k; j++) {
+    const best = new Array(n + 1).fill(0)
+    best[0] = dp[j][0] - prefix[0]
+    for (let i = 1; i <= n; i++) {
+      best[i] = Math.max(best[i - 1], dp[j][i] - prefix[i])
+    }
+    for (let i = m; i <= n; i++) {
+      const candidate = prefix[i] + best[i - m]
+      dp[j + 1][i] = i === m ? candidate : Math.max(dp[j + 1][i - 1], candidate)
+    }
+  }
+  return dp[k][n]
+}

From 28071f16b6aabced873386089c081bb7a5a7c349 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 2 Mar 2025 02:21:31 -0800
Subject: [PATCH 3267/3374] Create
 3474-lexicographically-smallest-generated-string.js

---
 ...cographically-smallest-generated-string.js | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 3474-lexicographically-smallest-generated-string.js

diff --git a/3474-lexicographically-smallest-generated-string.js b/3474-lexicographically-smallest-generated-string.js
new file mode 100644
index 00000000..061efbba
--- /dev/null
+++ b/3474-lexicographically-smallest-generated-string.js
@@ -0,0 +1,59 @@
+/**
+ * @param {string} str1
+ * @param {string} str2
+ * @return {string}
+ */
+var generateString = function (str1, str2) {
+  const n = str1.length
+  const m = str2.length
+  const len = n + m - 1
+  const c = '*'
+
+  const ans = new Array(len).fill(c)
+  const forced = new Array(len).fill(false)
+
+  for (let i = 0; i < n; i++) {
+    if (str1[i] === 'T') {
+      for (let j = 0; j < m; j++) {
+        const pos = i + j
+        if (ans[pos] === c) {
+          ans[pos] = str2[j]
+          forced[pos] = true
+        } else {
+          if (ans[pos] !== str2[j]) return ''
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < len; i++) {
+    if (ans[i] === c) {
+      ans[i] = 'a'
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (str1[i] === 'F') {
+      let windowEqual = true
+      for (let j = 0; j < m; j++) {
+        if (ans[i + j] !== str2[j]) {
+          windowEqual = false
+          break
+        }
+      }
+      if (windowEqual) {
+        let modified = false
+        for (let j = m - 1; j >= 0; j--) {
+          const pos = i + j
+          if (!forced[pos]) {
+            ans[pos] = 'b'
+            modified = true
+            break
+          }
+        }
+        if (!modified) return ''
+      }
+    }
+  }
+  return ans.join('')
+}

From d2685c34c3b8401aa7ff6ac55b4db12430f42cc1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Mar 2025 02:12:33 -0800
Subject: [PATCH 3268/3374] Create 2498-frog-jump-ii.js

---
 2498-frog-jump-ii.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 2498-frog-jump-ii.js

diff --git a/2498-frog-jump-ii.js b/2498-frog-jump-ii.js
new file mode 100644
index 00000000..e9fc24fc
--- /dev/null
+++ b/2498-frog-jump-ii.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+var maxJump = function(stones) {
+  let res = stones[1]-stones[0]; 
+  const {max} = Math
+  for(let i = 3; i < stones.length; i+=2) res = max(res, stones[i]-stones[i-2]);
+  for(let i = 2; i < stones.length; i+=2) res = max(res, stones[i]-stones[i-2]);
+  return res; 
+};

From 3271b36b49f517aef80e07b0a2a93e253f198927 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Mar 2025 22:58:04 -0800
Subject: [PATCH 3269/3374] Create
 2499-minimum-total-cost-to-make-arrays-unequal.js

---
 ...nimum-total-cost-to-make-arrays-unequal.js | 34 +++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 2499-minimum-total-cost-to-make-arrays-unequal.js

diff --git a/2499-minimum-total-cost-to-make-arrays-unequal.js b/2499-minimum-total-cost-to-make-arrays-unequal.js
new file mode 100644
index 00000000..67815bc5
--- /dev/null
+++ b/2499-minimum-total-cost-to-make-arrays-unequal.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var minimumTotalCost = function(nums1, nums2) {
+    const n = nums1.length;
+    let ans = 0;
+    const freq = new Map();
+    let maxFrequency = 0, maxFrequencyValue = 0, toSwap = 0;
+
+    for (let i = 0; i < n; i++) {
+        if (nums1[i] === nums2[i]) {
+            freq.set(nums1[i], (freq.get(nums1[i]) || 0) + 1);
+            if (freq.get(nums1[i]) > maxFrequency) {
+                maxFrequencyValue = nums1[i];
+            }
+            maxFrequency = Math.max(maxFrequency, freq.get(nums1[i]));
+            toSwap++;
+            ans += i;
+        }
+    }
+
+    for (let i = 0; i < n; i++) {
+        if (maxFrequency > toSwap / 2 && nums1[i] !== nums2[i] && nums1[i] !== maxFrequencyValue && nums2[i] !== maxFrequencyValue) {
+            ans += i;
+            toSwap++;
+        }
+    }
+
+    if (maxFrequency > toSwap / 2) return -1;
+
+    return ans;
+};

From ff2d09a0a5a7bad3613d3ef8f156e83d9d7cfc0e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Mar 2025 04:14:12 -0800
Subject: [PATCH 3270/3374] Update
 2499-minimum-total-cost-to-make-arrays-unequal.js

---
 ...nimum-total-cost-to-make-arrays-unequal.js | 43 ++++++++++---------
 1 file changed, 22 insertions(+), 21 deletions(-)

diff --git a/2499-minimum-total-cost-to-make-arrays-unequal.js b/2499-minimum-total-cost-to-make-arrays-unequal.js
index 67815bc5..a759f069 100644
--- a/2499-minimum-total-cost-to-make-arrays-unequal.js
+++ b/2499-minimum-total-cost-to-make-arrays-unequal.js
@@ -4,31 +4,32 @@
  * @return {number}
  */
 var minimumTotalCost = function(nums1, nums2) {
-    const n = nums1.length;
-    let ans = 0;
-    const freq = new Map();
-    let maxFrequency = 0, maxFrequencyValue = 0, toSwap = 0;
-
-    for (let i = 0; i < n; i++) {
-        if (nums1[i] === nums2[i]) {
-            freq.set(nums1[i], (freq.get(nums1[i]) || 0) + 1);
-            if (freq.get(nums1[i]) > maxFrequency) {
-                maxFrequencyValue = nums1[i];
-            }
-            maxFrequency = Math.max(maxFrequency, freq.get(nums1[i]));
-            toSwap++;
-            ans += i;
+  const n = nums1.length, {floor, max} = Math
+  let res = 0
+  const freq = new Map()
+  let maxFreq = 0, maxFreqVal = 0, toSwap = 0
+  for(let i = 0; i < n; i++) {
+    if(nums1[i] === nums2[i]) {
+        const e = nums1[i]
+        freq.set(e, (freq.get(e) || 0) + 1)
+        res += i
+        const f = freq.get(e)
+        toSwap++
+        if(f > maxFreq) {
+            maxFreqVal = e
         }
+        maxFreq = max(maxFreq, f)
     }
+  }
 
-    for (let i = 0; i < n; i++) {
-        if (maxFrequency > toSwap / 2 && nums1[i] !== nums2[i] && nums1[i] !== maxFrequencyValue && nums2[i] !== maxFrequencyValue) {
-            ans += i;
-            toSwap++;
-        }
+  for(let i = 0; i < n; i++) {
+    if(maxFreq > floor(toSwap / 2) && nums1[i] !== nums2[i] && nums1[i] !== maxFreqVal && nums2[i] !== maxFreqVal) {
+        toSwap++
+        res += i
     }
+  }
 
-    if (maxFrequency > toSwap / 2) return -1;
+  if(maxFreq > floor(toSwap / 2)) return -1
 
-    return ans;
+  return res
 };

From a01ba1dd301697540a78088c104c7a465a06712c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Mar 2025 23:08:42 -0800
Subject: [PATCH 3271/3374] Create 3477-fruits-into-baskets-ii.js

---
 3477-fruits-into-baskets-ii.js | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3477-fruits-into-baskets-ii.js

diff --git a/3477-fruits-into-baskets-ii.js b/3477-fruits-into-baskets-ii.js
new file mode 100644
index 00000000..ef332803
--- /dev/null
+++ b/3477-fruits-into-baskets-ii.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} fruits
+ * @param {number[]} baskets
+ * @return {number}
+ */
+var numOfUnplacedFruits = function (fruits, baskets) {
+  for (let i = 0; i < fruits.length; i++) {
+    for (let j = 0; j < baskets.length; j++) {
+      if (baskets[j] >= fruits[i]) {
+        baskets[j] = -1
+        break
+      }
+    }
+  }
+  let res = 0
+  for (let i = 0; i < baskets.length; i++) {
+    res += baskets[i] !== -1 ? 1 : 0
+  }
+  return res
+}

From aa69bb5984c5be8059d9e5055ee279b5621ecbdb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Mar 2025 23:09:11 -0800
Subject: [PATCH 3272/3374] Create 3478-choose-k-elements-with-maximum-sum.js

---
 3478-choose-k-elements-with-maximum-sum.js | 120 +++++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 3478-choose-k-elements-with-maximum-sum.js

diff --git a/3478-choose-k-elements-with-maximum-sum.js b/3478-choose-k-elements-with-maximum-sum.js
new file mode 100644
index 00000000..864f3886
--- /dev/null
+++ b/3478-choose-k-elements-with-maximum-sum.js
@@ -0,0 +1,120 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number[]}
+ */
+var findMaxSum = function (nums1, nums2, k) {
+    const n = nums1.length;
+    const answer = new Array(n).fill(0);
+
+    const pairs = new Array(n);
+    for (let i = 0; i < n; i++) {
+        pairs[i] = new Pair(nums1[i], nums2[i], i);
+    }
+
+    pairs.sort((a, b) => a.num1 - b.num1);
+
+    const minHeap = new PQ((a, b) => a < b);
+    let currentSum = 0;
+
+    let i = 0;
+    while (i < n) {
+        let j = i;
+        while (j < n && pairs[j].num1 === pairs[i].num1) {
+            answer[pairs[j].index] = currentSum;
+            j++;
+        }
+        for (let t = i; t < j; t++) {
+            const value = pairs[t].num2;
+            if (minHeap.size() < k) {
+                minHeap.push(value);
+                currentSum += value;
+            } else if (!minHeap.isEmpty() && value > minHeap.peek()) {
+                currentSum -= minHeap.peek();
+                minHeap.pop();
+                minHeap.push(value);
+                currentSum += value;
+            }
+        }
+        i = j;
+    }
+
+    return answer;
+}
+class Pair {
+    constructor(num1, num2, index) {
+        this.num1 = num1;
+        this.num2 = num2;
+        this.index = index;
+    }
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+

From 20abf684cf0d80a777ed7d17bd33d91776e3794b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Mar 2025 23:09:33 -0800
Subject: [PATCH 3273/3374] Create 3479-fruits-into-baskets-iii.js

---
 3479-fruits-into-baskets-iii.js | 73 +++++++++++++++++++++++++++++++++
 1 file changed, 73 insertions(+)
 create mode 100644 3479-fruits-into-baskets-iii.js

diff --git a/3479-fruits-into-baskets-iii.js b/3479-fruits-into-baskets-iii.js
new file mode 100644
index 00000000..d9077763
--- /dev/null
+++ b/3479-fruits-into-baskets-iii.js
@@ -0,0 +1,73 @@
+/**
+ * @param {number[]} fruits
+ * @param {number[]} baskets
+ * @return {number}
+ */
+var numOfUnplacedFruits = function (fruits, baskets) {
+  const n = fruits.length
+  const segTree = new SegmentTree(baskets)
+  let unplaced = 0
+
+  for (const fruit of fruits) {
+    const idx = segTree.query(fruit)
+    if (idx === -1) {
+      unplaced++
+    } else {
+      segTree.update(idx, -1)
+    }
+  }
+  return unplaced
+}
+class SegmentTree {
+  constructor(baskets) {
+    this.n = baskets.length
+    this.tree = new Array(4 * this.n)
+    this.build(baskets, 1, 0, this.n - 1)
+  }
+
+  build(baskets, node, start, end) {
+    if (start === end) {
+      this.tree[node] = baskets[start]
+    } else {
+      const mid = Math.floor((start + end) / 2)
+      this.build(baskets, 2 * node, start, mid)
+      this.build(baskets, 2 * node + 1, mid + 1, end)
+      this.tree[node] = Math.max(this.tree[2 * node], this.tree[2 * node + 1])
+    }
+  }
+
+  update(pos, val) {
+    this.updateNode(1, 0, this.n - 1, pos, val)
+  }
+
+  updateNode(node, start, end, pos, val) {
+    if (start === end) {
+      this.tree[node] = val
+    } else {
+      const mid = Math.floor((start + end) / 2)
+      if (pos <= mid) {
+        this.updateNode(2 * node, start, mid, pos, val)
+      } else {
+        this.updateNode(2 * node + 1, mid + 1, end, pos, val)
+      }
+      this.tree[node] = Math.max(this.tree[2 * node], this.tree[2 * node + 1])
+    }
+  }
+
+  query(required) {
+    if (this.tree[1] < required) return -1
+    return this.queryNode(1, 0, this.n - 1, required)
+  }
+
+  queryNode(node, start, end, required) {
+    if (start === end) {
+      return start
+    }
+    const mid = Math.floor((start + end) / 2)
+    if (this.tree[2 * node] >= required) {
+      return this.queryNode(2 * node, start, mid, required)
+    } else {
+      return this.queryNode(2 * node + 1, mid + 1, end, required)
+    }
+  }
+}

From 6e1732c6685681a69a650e4249541ac05456f327 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 8 Mar 2025 23:09:58 -0800
Subject: [PATCH 3274/3374] Create
 3480-maximize-subarrays-after-removing-one-conflicting-pair.js

---
 ...ays-after-removing-one-conflicting-pair.js | 113 ++++++++++++++++++
 1 file changed, 113 insertions(+)
 create mode 100644 3480-maximize-subarrays-after-removing-one-conflicting-pair.js

diff --git a/3480-maximize-subarrays-after-removing-one-conflicting-pair.js b/3480-maximize-subarrays-after-removing-one-conflicting-pair.js
new file mode 100644
index 00000000..ce7077f2
--- /dev/null
+++ b/3480-maximize-subarrays-after-removing-one-conflicting-pair.js
@@ -0,0 +1,113 @@
+/**
+ * @param {number} n
+ * @param {number[][]} conflictingPairs
+ * @return {number}
+ */
+var maxSubarrays = function (n, conflictingPairs) {
+  const best = new Array(n + 2).fill(n + 1)
+  const second = new Array(n + 2).fill(n + 1)
+  const freq = new Array(n + 2).fill(0)
+
+  for (const pair of conflictingPairs) {
+    let [a, b] = pair
+    if (a > b) {
+      ;[a, b] = [b, a]
+    }
+    if (b < best[a]) {
+      second[a] = best[a]
+      best[a] = b
+      freq[a] = 1
+    } else if (b === best[a]) {
+      freq[a]++
+    } else if (b < second[a]) {
+      second[a] = b
+    }
+  }
+
+  const F = new Array(n + 2).fill(0)
+  const M = new Array(n + 2).fill(0)
+  F[n + 1] = n + 1
+  F[n] = best[n]
+  M[n] = n
+  for (let i = n - 1; i >= 1; i--) {
+    if (best[i] <= F[i + 1]) {
+      F[i] = best[i]
+      M[i] = i
+    } else {
+      F[i] = F[i + 1]
+      M[i] = M[i + 1]
+    }
+  }
+
+  let origTotal = 0
+  for (let i = 1; i <= n; i++) {
+    origTotal += F[i] - i
+  }
+
+  const indicesByM = Array.from({ length: n + 2 }, () => [])
+  for (let i = 1; i <= n; i++) {
+    const idx = M[i]
+    indicesByM[idx].push(i)
+  }
+
+  const rmq = new RMQ(best, n)
+  let bestTotal = origTotal
+
+  for (let a = 1; a <= n; a++) {
+    if (best[a] === n + 1) continue
+    if (freq[a] > 1) continue
+    const B = best[a]
+    const newB = second[a]
+    const T = a < n ? F[a + 1] : n + 1
+    const effectiveCandidate = Math.min(newB, T)
+    if (effectiveCandidate <= B) continue
+
+    let delta = 0
+    for (const i of indicesByM[a]) {
+      const curOld = B
+      let candidate
+      if (i < a) {
+        candidate = rmq.query(i, a - 1)
+      } else {
+        candidate = n + 1
+      }
+      const newVal = Math.min(candidate, effectiveCandidate)
+      let improvement = newVal - curOld
+      if (improvement < 0) improvement = 0
+      delta += improvement
+    }
+    const candidateTotal = origTotal + delta
+    bestTotal = Math.max(bestTotal, candidateTotal)
+  }
+
+  return bestTotal
+}
+
+class RMQ {
+  constructor(arr, n) {
+    this.n = n
+    this.log = new Array(n + 2).fill(0)
+    for (let i = 2; i <= n; i++) {
+      this.log[i] = this.log[Math.floor(i / 2)] + 1
+    }
+    const K = this.log[n] + 1
+    this.st = Array.from({ length: n + 1 }, () => new Array(K).fill(0))
+    for (let i = 1; i <= n; i++) {
+      this.st[i][0] = arr[i]
+    }
+    for (let j = 1; j < K; j++) {
+      for (let i = 1; i + (1 << j) - 1 <= n; i++) {
+        this.st[i][j] = Math.min(
+          this.st[i][j - 1],
+          this.st[i + (1 << (j - 1))][j - 1],
+        )
+      }
+    }
+  }
+
+  query(L, R) {
+    if (L > R) return Infinity
+    const j = this.log[R - L + 1]
+    return Math.min(this.st[L][j], this.st[R - (1 << j) + 1][j])
+  }
+}

From 2705feb5aa4169ee01f96c4a89fa3030c8e062fd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Mar 2025 20:19:18 -0700
Subject: [PATCH 3275/3374] Update
 2576-find-the-maximum-number-of-marked-indices.js

---
 2576-find-the-maximum-number-of-marked-indices.js | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/2576-find-the-maximum-number-of-marked-indices.js b/2576-find-the-maximum-number-of-marked-indices.js
index de2fe1c7..2672d5af 100644
--- a/2576-find-the-maximum-number-of-marked-indices.js
+++ b/2576-find-the-maximum-number-of-marked-indices.js
@@ -2,17 +2,16 @@
  * @param {number[]} nums
  * @return {number}
  */
-const maxNumOfMarkedIndices = function(nums) {
+var maxNumOfMarkedIndices = function(nums) {
   let res = 0
-  const n =  nums.length
+  const n = nums.length
   nums.sort((a, b) => a - b)
-  for(let i = 0, j = n - Math.floor(n / 2); j < n; j++) {
+  for(let i = 0, j = Math.floor((n + 1) / 2); j < n; j++) {
     if(nums[i] * 2 <= nums[j]) {
-      res += 2
-      i++
+        res += 2
+        i++
     }
   }
-  
   return res
 };
 

From bf461b1db3bf3c99b4c078662e459e33e11445f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Mar 2025 04:58:51 -0700
Subject: [PATCH 3276/3374] Update 2745-construct-the-longest-new-string.js

---
 2745-construct-the-longest-new-string.js | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/2745-construct-the-longest-new-string.js b/2745-construct-the-longest-new-string.js
index 523bcf91..cc895595 100644
--- a/2745-construct-the-longest-new-string.js
+++ b/2745-construct-the-longest-new-string.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+var longestString = function(x, y, z) {
+  // x + y
+  // y + x
+  // y + z
+  // z + z
+  let res = 0
+  const {min} = Math
+  const minXY = min(x, y)
+  if(x === y) res = 2 * x + 2 * y + 2 * z
+  else {
+    res = (minXY * 2 + (minXY + 1) * 2 + 2 * z)
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number} x
  * @param {number} y

From 624472e83be72f2d61d94443501943a7b6d11301 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Mar 2025 03:56:52 -0700
Subject: [PATCH 3277/3374] Create
 3487-maximum-unique-subarray-sum-after-deletion.js

---
 3487-maximum-unique-subarray-sum-after-deletion.js | 11 +++++++++++
 1 file changed, 11 insertions(+)
 create mode 100644 3487-maximum-unique-subarray-sum-after-deletion.js

diff --git a/3487-maximum-unique-subarray-sum-after-deletion.js b/3487-maximum-unique-subarray-sum-after-deletion.js
new file mode 100644
index 00000000..f632eb4d
--- /dev/null
+++ b/3487-maximum-unique-subarray-sum-after-deletion.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSum = function(nums) {
+  if (nums.every(num => num < 0)) {
+    return Math.max(...nums)
+  }
+  return Array.from(new Set(nums)).filter(num => num > 0).reduce((acc, num) => acc + num, 0)
+
+};

From 9005ea8e3a83bdf7894dad61acbce966d0ef9cdb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Mar 2025 03:57:17 -0700
Subject: [PATCH 3278/3374] Create 3488-closest-equal-element-queries.js

---
 3488-closest-equal-element-queries.js | 72 +++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 3488-closest-equal-element-queries.js

diff --git a/3488-closest-equal-element-queries.js b/3488-closest-equal-element-queries.js
new file mode 100644
index 00000000..489101fe
--- /dev/null
+++ b/3488-closest-equal-element-queries.js
@@ -0,0 +1,72 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+var solveQueries = function (nums, queries) {
+    const prabhatSize = nums.length;
+    const prabhatMap = new Map();
+
+    for (let prabhatIndex = 0; prabhatIndex < prabhatSize; prabhatIndex++) {
+        if (!prabhatMap.has(nums[prabhatIndex])) {
+            prabhatMap.set(nums[prabhatIndex], []);
+        }
+        prabhatMap.get(nums[prabhatIndex]).push(prabhatIndex);
+    }
+
+    for (const prabhatList of prabhatMap.values()) {
+        prabhatList.sort((a, b) => a - b);
+    }
+
+    const res = new Array(queries.length);
+
+    for (let i = 0; i < queries.length; i++) {
+        const prabhatQuery = queries[i];
+        const prabhatValue = nums[prabhatQuery];
+        const prabhatIndexList = prabhatMap.get(prabhatValue);
+
+        if (prabhatIndexList.length < 2) {
+            res[i] = -1;
+            continue;
+        }
+
+        let prabhatPos = binarySearch(prabhatIndexList, prabhatQuery);
+        if (prabhatPos < 0) {
+            prabhatPos = -prabhatPos - 1;
+        }
+
+        const prabhatLeftIndex = (prabhatPos - 1 + prabhatIndexList.length) % prabhatIndexList.length;
+        const prabhatRightIndex = (prabhatPos + 1) % prabhatIndexList.length;
+
+        const prabhatLeftCandidate = prabhatIndexList[prabhatLeftIndex];
+        const prabhatRightCandidate = prabhatIndexList[prabhatRightIndex];
+
+        let prabhatDistLeft = Math.abs(prabhatQuery - prabhatLeftCandidate);
+        let prabhatDistRight = Math.abs(prabhatQuery - prabhatRightCandidate);
+
+        prabhatDistLeft = Math.min(prabhatDistLeft, prabhatSize - prabhatDistLeft);
+        prabhatDistRight = Math.min(prabhatDistRight, prabhatSize - prabhatDistRight);
+
+        res[i] = Math.min(prabhatDistLeft, prabhatDistRight);
+    }
+
+    return res;
+}
+
+
+function binarySearch(arr, target) {
+    let left = 0;
+    let right = arr.length - 1;
+
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2);
+        if (arr[mid] === target) {
+            return mid; // Found the target
+        } else if (arr[mid] < target) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return -(left + 1); // Target not found
+}

From 61cb71b49cb9c74371c79fe8e13156cdf4081796 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Mar 2025 03:57:53 -0700
Subject: [PATCH 3279/3374] Create 3489-zero-array-transformation-iv.js

---
 3489-zero-array-transformation-iv.js | 37 ++++++++++++++++++++++++++++
 1 file changed, 37 insertions(+)
 create mode 100644 3489-zero-array-transformation-iv.js

diff --git a/3489-zero-array-transformation-iv.js b/3489-zero-array-transformation-iv.js
new file mode 100644
index 00000000..d016ab29
--- /dev/null
+++ b/3489-zero-array-transformation-iv.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  if (nums.every((num) => num === 0)) return 0
+
+  function canZero(k) {
+    for (let i = 0; i < nums.length; i++) {
+      const target = nums[i]
+      const values = []
+      for (let j = 0; j < k; j++) {
+        const [l, r, v] = queries[j]
+        if (i >= l && i <= r) {
+          values.push(v)
+        }
+      }
+      const dp = new Array(target + 1).fill(false)
+      dp[0] = true
+      for (const v of values) {
+        for (let s = target; s >= v; s--) {
+          if (dp[s - v]) dp[s] = true
+        }
+      }
+      if (!dp[target]) return false
+    }
+    return true
+  }
+
+  for (let i = 0; i < queries.length; i++) {
+    if (canZero(i + 1)) {
+      return i + 1
+    }
+  }
+  return -1
+}

From 595c3ab1094a499193e0895268f2a03f9967d9c1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Mar 2025 03:58:27 -0700
Subject: [PATCH 3280/3374] Create 3490-count-beautiful-numbers.js

---
 3490-count-beautiful-numbers.js | 63 +++++++++++++++++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 3490-count-beautiful-numbers.js

diff --git a/3490-count-beautiful-numbers.js b/3490-count-beautiful-numbers.js
new file mode 100644
index 00000000..481277db
--- /dev/null
+++ b/3490-count-beautiful-numbers.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var beautifulNumbers = function (l, r) {
+  const toDigits = (n) => Array.from(String(n), Number)
+
+  const countUpTo = (x) => (x < 0 ? 0n : dp(toDigits(x)))
+  return Number(countUpTo(r) - countUpTo(l - 1))
+
+  function dp(digits) {
+    const n = digits.length
+
+    const seen = new Map()
+
+    function dfs(pos, tight, started, s, p, hasZero) {
+      if (pos === n) {
+        if (!started) return 0n
+        return hasZero || (s !== 0 && p % s === 0) ? 1n : 0n
+      }
+      const key = state(pos, tight, started, s, p, hasZero)
+      if (seen.has(key)) return seen.get(key)
+
+      let ans = 0n
+      const limit = tight ? digits[pos] : 9
+      for (let d = 0; d <= limit; d++) {
+        const newTight = tight && d === limit
+        if (!started && d === 0) {
+          ans += dfs(pos + 1, newTight, false, 0, 1, false)
+        } else {
+          const newStarted = true
+          if (d === 0) {
+            ans += dfs(pos + 1, newTight, newStarted, s + d, 0, true)
+          } else {
+            const newP = !started ? d : p * d
+            ans += dfs(pos + 1, newTight, newStarted, s + d, newP, hasZero)
+          }
+        }
+      }
+      seen.set(key, ans)
+      return ans
+    }
+    return dfs(0, true, false, 0, 1, false)
+  }
+}
+
+function state(pos, tight, started, s, p, hasZero) {
+    return `${pos},${tight},${started},${s},${p},${hasZero}`
+}
+/*
+class State {
+  constructor(pos, tight, started, s, p, hasZero) {
+    this.pos = pos
+    this.tight = tight
+    this.started = started
+    this.s = s
+    this.p = p
+    this.hasZero = hasZero
+  }
+}
+*/
+

From 1a48277c9f51d031a2b9c3a91fad9c3cd227bdc3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Mar 2025 07:54:26 -0700
Subject: [PATCH 3281/3374] Create
 3301-maximize-the-total-height-of-unique-towers.js

---
 ...imize-the-total-height-of-unique-towers.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 3301-maximize-the-total-height-of-unique-towers.js

diff --git a/3301-maximize-the-total-height-of-unique-towers.js b/3301-maximize-the-total-height-of-unique-towers.js
new file mode 100644
index 00000000..6c3f633b
--- /dev/null
+++ b/3301-maximize-the-total-height-of-unique-towers.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} maximumHeight
+ * @return {number}
+ */
+var maximumTotalSum = function(maximumHeight) {
+    const n = maximumHeight.length;
+    maximumHeight.sort((a, b) => a - b);
+    
+    let sum = 0;
+    let lastAssignedHeight = Number.MAX_SAFE_INTEGER;
+    
+    for (let i = n - 1; i >= 0; i--) {
+        const currentHeight = Math.min(maximumHeight[i], lastAssignedHeight - 1);
+        
+        if (currentHeight < 1) {
+            return -1;
+        }
+        
+        sum += currentHeight;
+        lastAssignedHeight = currentHeight;
+    }
+    
+    return sum;  
+};

From d1c49db55d9e986b0d625c6e0faf5b8a353bed82 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Mar 2025 00:03:50 +0800
Subject: [PATCH 3282/3374] Create
 3500-minimum-cost-to-divide-array-into-subarrays.js

---
 ...mum-cost-to-divide-array-into-subarrays.js | 74 +++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 3500-minimum-cost-to-divide-array-into-subarrays.js

diff --git a/3500-minimum-cost-to-divide-array-into-subarrays.js b/3500-minimum-cost-to-divide-array-into-subarrays.js
new file mode 100644
index 00000000..c8b802b0
--- /dev/null
+++ b/3500-minimum-cost-to-divide-array-into-subarrays.js
@@ -0,0 +1,74 @@
+class ConvexHullTrick {
+  constructor() {
+    this.lines = []
+    this.pointer = 0
+  }
+
+  addLine(m, b) {
+    const newLine = { m, b, xLeft: 0 }
+    while (this.lines.length > 0) {
+      const last = this.lines[this.lines.length - 1]
+      const x = this.intersect(newLine, last)
+      if (x <= last.xLeft) {
+        this.lines.pop()
+      } else {
+        break
+      }
+    }
+    if (this.lines.length === 0) {
+      newLine.xLeft = -Infinity
+    } else {
+      newLine.xLeft = this.intersect(newLine, this.lines[this.lines.length - 1])
+    }
+    this.lines.push(newLine)
+  }
+
+  query(x) {
+    if (this.pointer >= this.lines.length) this.pointer = this.lines.length - 1
+    while (
+      this.pointer < this.lines.length - 1 &&
+      this.lines[this.pointer + 1].xLeft <= x
+    ) {
+      this.pointer++
+    }
+    return this.lines[this.pointer].m * x + this.lines[this.pointer].b
+  }
+
+  intersect(line1, line2) {
+    return (line2.b - line1.b) / (line1.m - line2.m)
+  }
+}
+
+function minimumCost(nums, cost, k) {
+  const n = nums.length
+  const preNum = new Array(n + 1).fill(0)
+  const preCost = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    preNum[i + 1] = preNum[i] + nums[i]
+    preCost[i + 1] = preCost[i] + cost[i]
+  }
+
+  const inf = Number.MAX_SAFE_INTEGER / 2
+  const dp = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(inf))
+  dp[0][0] = 0
+
+  for (let j = 1; j <= n; j++) {
+    const cht = new ConvexHullTrick()
+    for (let l = j - 1; l < n; l++) {
+      if (dp[l][j - 1] < inf) {
+        cht.addLine(-preCost[l], dp[l][j - 1])
+      }
+    }
+    for (let i = j; i <= n; i++) {
+      const query = cht.query(preNum[i] + k * j)
+      dp[i][j] = (preNum[i] + k * j) * preCost[i] + query
+    }
+  }
+
+  let ans = inf
+  for (let j = 1; j <= n; j++) {
+    ans = Math.min(ans, dp[n][j])
+  }
+  return ans
+}

From 20c354926a0ab5fdeb06633928c25483eac873d5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Mar 2025 00:04:24 +0800
Subject: [PATCH 3283/3374] Create 3499-maximize-active-section-with-trade-i.js

---
 3499-maximize-active-section-with-trade-i.js | 39 ++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 3499-maximize-active-section-with-trade-i.js

diff --git a/3499-maximize-active-section-with-trade-i.js b/3499-maximize-active-section-with-trade-i.js
new file mode 100644
index 00000000..6db89c42
--- /dev/null
+++ b/3499-maximize-active-section-with-trade-i.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var maxActiveSectionsAfterTrade = function (s) {
+  const n = s.length
+  const c1 = Array.from(s).filter((char) => char === '1').length
+
+  let ans = 0
+  let i = 0
+  while (i < n) {
+    if (s[i] === '1') {
+      const start = i
+      while (i < n && s[i] === '1') {
+        i++
+      }
+      const end = i - 1
+      if (start > 0 && end < n - 1) {
+        let leftZeros = 0
+        let j = start - 1
+        while (j >= 0 && s[j] === '0') {
+          leftZeros++
+          j--
+        }
+        let rightZeros = 0
+        j = end + 1
+        while (j < n && s[j] === '0') {
+          rightZeros++
+          j++
+        }
+        const more = leftZeros + rightZeros
+        ans = Math.max(ans, more)
+      }
+    } else {
+      i++
+    }
+  }
+  return c1 + ans
+}

From b98eab3dcb9ca95801604bb5fca6e8d38550ae2f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 30 Mar 2025 00:04:51 +0800
Subject: [PATCH 3284/3374] Create 3498-reverse-degree-of-a-string.js

---
 3498-reverse-degree-of-a-string.js | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 3498-reverse-degree-of-a-string.js

diff --git a/3498-reverse-degree-of-a-string.js b/3498-reverse-degree-of-a-string.js
new file mode 100644
index 00000000..3d554ea5
--- /dev/null
+++ b/3498-reverse-degree-of-a-string.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var reverseDegree = function(s) {
+    return Array.from(s).reduce((sum, ch, i) => {
+        const pos = 'z'.charCodeAt(0) - ch.charCodeAt(0) + 1
+        return sum + pos * (i + 1)
+    }, 0)
+};

From 0a0476a927069b40066939d171d917ec96e4de7d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Apr 2025 04:52:04 -0700
Subject: [PATCH 3285/3374] Create 3508-implement-router.js

---
 3508-implement-router.js | 96 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 96 insertions(+)
 create mode 100644 3508-implement-router.js

diff --git a/3508-implement-router.js b/3508-implement-router.js
new file mode 100644
index 00000000..37ce3c33
--- /dev/null
+++ b/3508-implement-router.js
@@ -0,0 +1,96 @@
+class Router {
+    constructor(memoryLimit) {
+        this.memoryLimit = memoryLimit;
+        this.storage = [];
+        this.packetSet = new Set();
+        this.destMap = new Map();
+    }
+
+    addPacket(source, destination, timestamp) {
+        const packet = [source, destination, timestamp];
+        if (this.packetSet.has(packet.toString())) {
+            return false;
+        }
+
+        if (this.storage.length >= this.memoryLimit) {
+            this._removeOldest();
+        }
+
+        this.storage.push(packet);
+        this.packetSet.add(packet.toString());
+
+        if (!this.destMap.has(destination)) {
+            this.destMap.set(destination, []);
+        }
+
+        this.destMap.get(destination).push(timestamp);
+        return true;
+    }
+
+    forwardPacket() {
+        if (this.storage.length === 0) {
+            return [];
+        }
+
+        const packet = this.storage.shift();
+        const [source, destination, timestamp] = packet;
+        this.packetSet.delete(packet.toString());
+
+        const tsList = this.destMap.get(destination);
+        const idx = this._binarySearch(tsList, timestamp);
+        if (idx < tsList.length && tsList[idx] === timestamp) {
+            tsList.splice(idx, 1);
+        }
+
+        if (tsList.length === 0) {
+            this.destMap.delete(destination);
+        }
+
+        return [source, destination, timestamp];
+    }
+
+    getCount(destination, startTime, endTime) {
+        if (!this.destMap.has(destination)) {
+            return 0;
+        }
+
+        const tsList = this.destMap.get(destination);
+        const leftIndex = this._binarySearch(tsList, startTime);
+        const rightIndex = this._binarySearch(tsList, endTime, true);
+        return rightIndex - leftIndex;
+    }
+
+    _removeOldest() {
+        if (this.storage.length > 0) {
+            const packet = this.storage.shift();
+            const [source, destination, timestamp] = packet;
+            this.packetSet.delete(packet.toString());
+
+            const tsList = this.destMap.get(destination);
+            const idx = this._binarySearch(tsList, timestamp);
+            if (idx < tsList.length && tsList[idx] === timestamp) {
+                tsList.splice(idx, 1);
+            }
+
+            if (tsList.length === 0) {
+                this.destMap.delete(destination);
+            }
+        }
+    }
+
+    _binarySearch(arr, target, isRight = false) {
+        let left = 0;
+        let right = arr.length;
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (arr[mid] < target || (isRight && arr[mid] === target)) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return left;
+    }
+}

From 31a713916c15cf6e4d1e60265648bcae3c222b96 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Apr 2025 04:52:46 -0700
Subject: [PATCH 3286/3374] Create 3507-minimum-pair-removal-to-sort-array-i.js

---
 3507-minimum-pair-removal-to-sort-array-i.js | 34 ++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 3507-minimum-pair-removal-to-sort-array-i.js

diff --git a/3507-minimum-pair-removal-to-sort-array-i.js b/3507-minimum-pair-removal-to-sort-array-i.js
new file mode 100644
index 00000000..c2196a1c
--- /dev/null
+++ b/3507-minimum-pair-removal-to-sort-array-i.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumPairRemoval = function (nums) {
+  let operations = 0
+
+  while (!isNonDecreasing(nums)) {
+    let minSum = Infinity
+    let idx = -1
+
+    for (let i = 0; i < nums.length - 1; i++) {
+      if (nums[i] + nums[i + 1] < minSum) {
+        minSum = nums[i] + nums[i + 1]
+        idx = i
+      }
+    }
+
+    const merged = nums[idx] + nums[idx + 1]
+    nums = nums.slice(0, idx).concat([merged], nums.slice(idx + 2))
+
+    operations += 1
+  }
+
+  return operations
+  function isNonDecreasing(arr) {
+    for (let i = 0; i < arr.length - 1; i++) {
+      if (arr[i] > arr[i + 1]) {
+        return false
+      }
+    }
+    return true
+  }
+}

From 2b479b78afd1ae5f757ae8f075ad7aef4036862d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 6 Apr 2025 07:43:03 -0700
Subject: [PATCH 3287/3374] Create
 3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js

---
 ...nces-with-an-alternating-sum-equal-to-k.js | 56 +++++++++++++++++++
 1 file changed, 56 insertions(+)
 create mode 100644 3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js

diff --git a/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js b/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js
new file mode 100644
index 00000000..faac4069
--- /dev/null
+++ b/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} limit
+ * @return {number}
+ */
+var maxProduct = function(nums, k, limit) {
+    const MIN = -5000;
+    const dp = new Map();
+        const n = nums.length;
+
+        let sum = 0;
+        for (const x of nums) sum += x;
+
+        if (k > sum || k < -sum) return -1;
+
+ 
+        const ans = recursion(0, 0, 0, 0, k, n, nums, limit);
+        return (ans === MIN) ? -1 : ans;
+    function  recursion(pos, currSum, product, isOdd, k, n, nums, limit) {
+        if (pos === n) {
+            return (currSum === k && isOdd !== 0 && product <= limit ? product : MIN);
+        }
+
+        if (dp.has(pos) && dp.get(pos).has(currSum) && dp.get(pos).get(currSum).has(product) && dp.get(pos).get(currSum).get(product).has(isOdd)) {
+            return dp.get(pos).get(currSum).get(product).get(isOdd);
+        }
+
+        let ans = recursion(pos + 1, currSum, product, isOdd, k, n, nums, limit);
+        if (isOdd === 0) {
+            ans = Math.max(ans, recursion(pos + 1, currSum + nums[pos], nums[pos], 2, k, n, nums, limit));
+        }
+        if (isOdd === 1) {
+            ans = Math.max(ans, recursion(pos + 1, currSum + nums[pos], Math.min(product * nums[pos], limit + 1), 2, k, n, nums, limit));
+        }
+        if (isOdd === 2) {
+            ans = Math.max(ans, recursion(pos + 1, currSum - nums[pos], Math.min(product * nums[pos], limit + 1), 1, k, n, nums, limit));
+        }
+
+        if (!dp.has(pos)) {
+            dp.set(pos, new Map());
+        }
+        if (!dp.get(pos).has(currSum)) {
+            dp.get(pos).set(currSum, new Map());
+        }
+        if (!dp.get(pos).get(currSum).has(product)) {
+            dp.get(pos).get(currSum).set(product, new Map());
+        }
+        dp.get(pos).get(currSum).get(product).set(isOdd, ans);
+
+        return ans;
+    }
+};
+
+
+

From d73e6d97ccca6d469c068507b21ac5212e9c37df Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Apr 2025 04:22:20 -0700
Subject: [PATCH 3288/3374] Update 2416-sum-of-prefix-scores-of-strings.js

---
 2416-sum-of-prefix-scores-of-strings.js | 44 +++++++++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/2416-sum-of-prefix-scores-of-strings.js b/2416-sum-of-prefix-scores-of-strings.js
index 32d5f713..b9b48503 100644
--- a/2416-sum-of-prefix-scores-of-strings.js
+++ b/2416-sum-of-prefix-scores-of-strings.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const sumPrefixScores = function(words) {
+  const root = new Node()
+  const n = words.length
+  for(const w of words) {
+    let cur = root
+    for(const ch of w) {
+        if(!cur.children.has(ch)) cur.children.set(ch, new Node())
+        const node = cur.children.get(ch)
+        node.cnt++
+        cur = node
+    }
+  }
+
+  const res = []
+
+  for(const w of words) {
+    let cur = root
+    let tmp = 0
+    for(const ch of w) {
+        if(cur.children.has(ch)) {
+            const node = cur.children.get(ch)
+            tmp += node.cnt
+            cur = node
+        } else break
+    }
+    res.push(tmp)
+  }
+
+  return res
+};
+
+class Node {
+    constructor() {
+        this.children = new Map()
+        this.cnt = 0
+    }
+}
+
+// another
+
 /**
  * @param {string[]} words
  * @return {number[]}

From e56f5040ca10cb2fa21724c3adffc7a1772bcf16 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 8 Apr 2025 22:03:47 -0700
Subject: [PATCH 3289/3374] Create
 3291-minimum-number-of-valid-strings-to-form-target-i.js

---
 ...umber-of-valid-strings-to-form-target-i.js | 41 +++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 3291-minimum-number-of-valid-strings-to-form-target-i.js

diff --git a/3291-minimum-number-of-valid-strings-to-form-target-i.js b/3291-minimum-number-of-valid-strings-to-form-target-i.js
new file mode 100644
index 00000000..ed0ec089
--- /dev/null
+++ b/3291-minimum-number-of-valid-strings-to-form-target-i.js
@@ -0,0 +1,41 @@
+  class TrieNode {
+    constructor() {
+      this.children = new Array(26).fill(null)
+    }
+  }
+/**
+ * @param {string[]} words
+ * @param {string} target
+ * @return {number}
+ */
+var minValidStrings = function(words, target) {
+  const n = target.length
+  const dp = new Array(n + 1).fill(Infinity)
+  dp[0] = 0
+
+  const a = 'a'.charCodeAt(0)
+  const root = new TrieNode()
+  for (const word of words) {
+    let node = root
+    for (const c of word) {
+      const index = c.charCodeAt(0) - a
+      if (!node.children[index]) {
+        node.children[index] = new TrieNode()
+      }
+      node = node.children[index]
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (dp[i] === Infinity) continue
+    let node = root
+    for (let j = i; j < n; j++) {
+      const index = target[j].charCodeAt(0) - a
+      if (!node.children[index]) break
+      node = node.children[index]
+      dp[j + 1] = Math.min(dp[j + 1], dp[i] + 1)
+    }
+  }
+
+  return dp[n] === Infinity ? -1 : dp[n]
+};

From 830804310ecf7d47efc0e604eae924f54bf7a4eb Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Apr 2025 22:45:17 -0700
Subject: [PATCH 3290/3374] Create 3517-smallest-palindromic-rearrangement-i.js

---
 3517-smallest-palindromic-rearrangement-i.js | 14 ++++++++++++++
 1 file changed, 14 insertions(+)
 create mode 100644 3517-smallest-palindromic-rearrangement-i.js

diff --git a/3517-smallest-palindromic-rearrangement-i.js b/3517-smallest-palindromic-rearrangement-i.js
new file mode 100644
index 00000000..298d0275
--- /dev/null
+++ b/3517-smallest-palindromic-rearrangement-i.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var smallestPalindrome = function(s) {
+    const n = s.length
+    const pre = s.substring(0, Math.floor(n / 2))
+    const left = Array.from(pre).sort().join('')
+    if (n % 2 === 0) {
+        return `${left}${left.split('').reverse().join('')}`
+    } else {
+        return `${left}${s[Math.floor(n / 2)]}${left.split('').reverse().join('')}`
+    }
+};

From fb866466308035c0fae53cd65c4c38a62896d180 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Apr 2025 22:45:55 -0700
Subject: [PATCH 3291/3374] Create 3516-find-closest-person.js

---
 3516-find-closest-person.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3516-find-closest-person.js

diff --git a/3516-find-closest-person.js b/3516-find-closest-person.js
new file mode 100644
index 00000000..7269add4
--- /dev/null
+++ b/3516-find-closest-person.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+var findClosest = function(x, y, z) {
+    const cmp = Math.abs(x - z) - Math.abs(y - z)
+    if (cmp < 0) {
+        return 1
+    } else if (cmp > 0) {
+        return 2
+    } else {
+        return 0
+    }
+};

From 4a63fb3d2c1f5ec577cf48f8e4b88fb9bfd47ab1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 12 Apr 2025 22:46:30 -0700
Subject: [PATCH 3292/3374] Create
 3519-count-numbers-with-non-decreasing-digits.js

---
 ...ount-numbers-with-non-decreasing-digits.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 3519-count-numbers-with-non-decreasing-digits.js

diff --git a/3519-count-numbers-with-non-decreasing-digits.js b/3519-count-numbers-with-non-decreasing-digits.js
new file mode 100644
index 00000000..fd6f780c
--- /dev/null
+++ b/3519-count-numbers-with-non-decreasing-digits.js
@@ -0,0 +1,51 @@
+/**
+ * @param {string} l
+ * @param {string} r
+ * @param {number} b
+ * @return {number}
+ */
+var countNumbers = function (l, r, b) {
+  const mod = 1000000007
+
+  const bigL = BigInt(l)
+  const bigR = BigInt(r)
+
+  const rightCnt = helper(bigR, b)
+  const leftCnt = helper(bigL - 1n, b)
+  const ans = (rightCnt - leftCnt + BigInt(mod)) % BigInt(mod)
+  return Number(ans)
+  function helper(num, b) {
+    if (num < 0n) return 0n
+
+    // b base digits
+    const digits = Array.from(num.toString(b)).map((d) => BigInt(d) - 0n)
+    const n = digits.length
+
+    const seen = new Map()
+
+    function dfs(pos, last, started, tight) {
+      if (pos === n) return 1n
+
+      const key = `${pos}, ${last}, ${started}, ${tight}`
+      if (seen.has(key)) return seen.get(key)
+
+      const limit = tight ? digits[pos] : BigInt(b - 1)
+      let ways = 0n
+
+      for (let d = 0n; d <= limit; d++) {
+        if (started && d < last) continue
+
+        const nextStarted = started || d !== 0n
+        const nextLast = started || d !== 0n ? d : last
+
+        const nextTight = tight && d === limit
+        ways =
+          (ways + dfs(pos + 1, nextLast, nextStarted, nextTight)) % BigInt(mod)
+      }
+      seen.set(key, ways % BigInt(mod))
+      return ways
+    }
+
+    return dfs(0, 0n, false, true)
+  }
+}

From 9655e062fe33c9b287ddb813f2920a24fc9177a0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 7 May 2025 23:10:06 -0700
Subject: [PATCH 3293/3374] Create
 3346-maximum-frequency-of-an-element-after-performing-operations-i.js

---
 ...n-element-after-performing-operations-i.js | 47 +++++++++++++++++++
 1 file changed, 47 insertions(+)
 create mode 100644 3346-maximum-frequency-of-an-element-after-performing-operations-i.js

diff --git a/3346-maximum-frequency-of-an-element-after-performing-operations-i.js b/3346-maximum-frequency-of-an-element-after-performing-operations-i.js
new file mode 100644
index 00000000..4a2cc1bf
--- /dev/null
+++ b/3346-maximum-frequency-of-an-element-after-performing-operations-i.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} numOperations
+ * @return {number}
+ */
+var maxFrequency = function (nums, k, numOperations) {
+  const n = nums.length
+  let ans = 0,
+    left = 0,
+    right = 0
+  nums.sort((a, b) => a - b)
+
+  const count = {}
+  for (const num of nums) {
+    count[num] = (count[num] || 0) + 1
+  }
+  for (let mid = 0; mid < n; mid++) {
+    while (nums[mid] - nums[left] > k) {
+      left++
+    }
+
+    while (right < n - 1 && nums[right + 1] - nums[mid] <= k) {
+      right++
+    }
+
+    const total = right - left + 1
+    ans = Math.max(
+      ans,
+      Math.min(total - (count[nums[mid]] || 0), numOperations) +
+        (count[nums[mid]] || 0),
+    )
+  }
+
+  left = 0
+  for (right = 0; right < n; right++) {
+    let mid = Math.floor((nums[left] + nums[right]) / 2)
+
+    while (mid - nums[left] > k || nums[right] - mid > k) {
+      left++
+      mid = Math.floor((nums[left] + nums[right]) / 2)
+    }
+    ans = Math.max(ans, Math.min(right - left + 1, numOperations))
+  }
+
+  return ans
+}

From 51a9c8e39dc80f13a48405e24172663df3847353 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 10 May 2025 06:49:28 -0700
Subject: [PATCH 3294/3374] Update 3356-zero-array-transformation-ii.js

---
 3356-zero-array-transformation-ii.js | 38 ++++++++++++++++++++++++++++
 1 file changed, 38 insertions(+)

diff --git a/3356-zero-array-transformation-ii.js b/3356-zero-array-transformation-ii.js
index eeefa1d4..4650df6d 100644
--- a/3356-zero-array-transformation-ii.js
+++ b/3356-zero-array-transformation-ii.js
@@ -1,3 +1,40 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  const n = nums.length
+  let sum = 0,
+    k = 0
+  const differenceArray = new Array(n + 1).fill(0)
+
+  for (let index = 0; index < n; index++) {
+    // Iterate through queries while current index of nums cannot equal zero
+    while (sum + differenceArray[index] < nums[index]) {
+      k++
+
+      // Zero array isn't formed after all queries are processed
+      if (k > queries.length) {
+        return -1
+      }
+      const [left, right, val] = queries[k - 1]
+
+      // Process start and end of range
+      if (right >= index) {
+        differenceArray[Math.max(left, index)] += val
+        differenceArray[right + 1] -= val
+      }
+    }
+    // Update prefix sum at current index
+    sum += differenceArray[index]
+  }
+  return k
+}
+
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number[][]} queries
@@ -35,3 +72,4 @@ var minZeroArray = function (nums, queries) {
   }
   return -1
 }
+

From 5ab8f834b4ffb1e9cfa74fea2cf28ee13f45d5b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 May 2025 06:09:39 -0700
Subject: [PATCH 3295/3374] Create 3548-equal-sum-grid-partition-ii.js

---
 3548-equal-sum-grid-partition-ii.js | 107 ++++++++++++++++++++++++++++
 1 file changed, 107 insertions(+)
 create mode 100644 3548-equal-sum-grid-partition-ii.js

diff --git a/3548-equal-sum-grid-partition-ii.js b/3548-equal-sum-grid-partition-ii.js
new file mode 100644
index 00000000..801091f6
--- /dev/null
+++ b/3548-equal-sum-grid-partition-ii.js
@@ -0,0 +1,107 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+var canPartitionGrid = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+
+  let totalRowSum = 0n,
+    totalColSum = 0n
+  const prefixRowWise = new Array(n).fill(0n)
+  const prefixColWise = new Array(m).fill(0n)
+
+  const MAXV = 100000
+  const minRow = new Array(MAXV + 1).fill(null)
+  const maxRow = new Array(MAXV + 1).fill(null)
+  const minCol = new Array(MAXV + 1).fill(null)
+  const maxCol = new Array(MAXV + 1).fill(null)
+
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      const v = grid[i][j]
+      const val = BigInt(v)
+      prefixRowWise[i] += val
+      prefixColWise[j] += val
+
+      if (minRow[v] === null) {
+        minRow[v] = maxRow[v] = i
+        minCol[v] = maxCol[v] = j
+      } else {
+        if (i < minRow[v]) minRow[v] = i
+        if (i > maxRow[v]) maxRow[v] = i
+        if (j < minCol[v]) minCol[v] = j
+        if (j > maxCol[v]) maxCol[v] = j
+      }
+    }
+  }
+
+  for (const r of prefixRowWise) totalRowSum += r
+  totalColSum = totalRowSum
+
+  let currentRowUpperSum = 0n
+  for (let i = 0; i < n - 1; i++) {
+    currentRowUpperSum += prefixRowWise[i]
+    const lowerSegmentSum = totalRowSum - currentRowUpperSum
+    if (currentRowUpperSum === lowerSegmentSum) return true
+
+    if (currentRowUpperSum > lowerSegmentSum) {
+      const diff = currentRowUpperSum - lowerSegmentSum
+      if (diff <= MAXV && minRow[Number(diff)] !== null) {
+        if (i === 0 || m === 1) {
+          if (diff === BigInt(grid[0][0]) || diff === BigInt(grid[0][m - 1]))
+            return true
+        } else if (minRow[Number(diff)] <= i) {
+          return true
+        }
+      }
+    } else {
+      const diff = lowerSegmentSum - currentRowUpperSum
+      if (diff <= MAXV && maxRow[Number(diff)] !== null) {
+        if (i === n - 2 || m === 1) {
+          if (
+            diff === BigInt(grid[i + 1][0]) ||
+            diff === BigInt(grid[i + 1][m - 1])
+          )
+            return true
+        } else if (maxRow[Number(diff)] > i) {
+          return true
+        }
+      }
+    }
+  }
+
+  let currentColLeftSum = 0n
+  for (let j = 0; j < m - 1; j++) {
+    currentColLeftSum += prefixColWise[j]
+    const rightSegmentSum = totalColSum - currentColLeftSum
+    if (currentColLeftSum === rightSegmentSum) return true
+
+    if (currentColLeftSum > rightSegmentSum) {
+      const diff = currentColLeftSum - rightSegmentSum
+      if (diff <= MAXV && minCol[Number(diff)] !== null) {
+        if (j === 0 || n === 1) {
+          if (diff === BigInt(grid[0][0]) || diff === BigInt(grid[n - 1][0]))
+            return true
+        } else if (minCol[Number(diff)] <= j) {
+          return true
+        }
+      }
+    } else {
+      const diff = rightSegmentSum - currentColLeftSum
+      if (diff <= MAXV && maxCol[Number(diff)] !== null) {
+        if (j === m - 2 || n === 1) {
+          if (
+            diff === BigInt(grid[0][j + 1]) ||
+            diff === BigInt(grid[n - 1][j + 1])
+          )
+            return true
+        } else if (maxCol[Number(diff)] > j) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}

From 4302db1478f41c6e044d962e4ab2a36b4c752b02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 May 2025 06:10:14 -0700
Subject: [PATCH 3296/3374] Create
 3547-maximum-sum-of-edge-values-in-a-graph.js

---
 3547-maximum-sum-of-edge-values-in-a-graph.js | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 3547-maximum-sum-of-edge-values-in-a-graph.js

diff --git a/3547-maximum-sum-of-edge-values-in-a-graph.js b/3547-maximum-sum-of-edge-values-in-a-graph.js
new file mode 100644
index 00000000..cf544807
--- /dev/null
+++ b/3547-maximum-sum-of-edge-values-in-a-graph.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var maxScore = function (n, edges) {
+  const G = new Map()
+  edges.forEach(([i, j]) => {
+    if (!G.has(i)) G.set(i, [])
+    if (!G.has(j)) G.set(j, [])
+    G.get(i).push(j)
+    G.get(j).push(i)
+  })
+
+  function get_comp(i) {
+    const bfs = [i]
+    seen[i] = true
+    for (let idx = 0; idx < bfs.length; idx++) {
+      const current = bfs[idx]
+      for (const j of G.get(current) || []) {
+        if (!seen[j]) {
+          seen[j] = true
+          bfs.push(j)
+        }
+      }
+    }
+    return bfs
+  }
+
+  const C = []
+  const L = []
+  const seen = new Array(n).fill(false)
+  for (let i = 0; i < n; i++) {
+    if (!seen[i]) {
+      const comp = get_comp(i)
+      if (comp.every((x) => (G.get(x) || []).length === 2)) {
+        C.push(comp.length)
+      } else if (comp.length > 1) {
+        L.push(comp.length)
+      }
+    }
+  }
+
+  function calc(l, r, is_cycle) {
+    const d = [r, r]
+    let res = 0
+    for (let a = r - 1; a >= l; a--) {
+      const v = d.shift()
+      res += v * a
+      d.push(a)
+    }
+    return res + d[0] * d[1] * is_cycle
+  }
+
+  let res = 0
+  L.sort((a, b) => b - a)
+  for (const k of C) {
+    res += calc(n - k + 1, n, 1)
+    n -= k
+  }
+  for (const k of L) {
+    res += calc(n - k + 1, n, 0)
+    n -= k
+  }
+  return res
+}

From 90e9d31914503fbd25c811ad426de37ba5f7861c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 May 2025 06:10:56 -0700
Subject: [PATCH 3297/3374] Create 3546-equal-sum-grid-partition-i.js

---
 3546-equal-sum-grid-partition-i.js | 40 ++++++++++++++++++++++++++++++
 1 file changed, 40 insertions(+)
 create mode 100644 3546-equal-sum-grid-partition-i.js

diff --git a/3546-equal-sum-grid-partition-i.js b/3546-equal-sum-grid-partition-i.js
new file mode 100644
index 00000000..330bbf51
--- /dev/null
+++ b/3546-equal-sum-grid-partition-i.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+var canPartitionGrid = function (grid) {
+  const m = grid.length,
+    n = grid[0].length
+  let totalSum = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      totalSum += grid[i][j]
+    }
+  }
+
+  if (totalSum % 2 === 1) return false
+  const target = totalSum / 2
+  let sum = 0
+  // row
+  for (let i = 0; i < m; i++) {
+    let tmp = 0
+    for (let j = 0; j < n; j++) {
+      tmp += grid[i][j]
+    }
+    sum += tmp
+    if (i !== m - 1 && sum === target) return true
+  }
+
+  // col
+  sum = 0
+  for (let j = 0; j < n; j++) {
+    let tmp = 0
+    for (let i = 0; i < m; i++) {
+      tmp += grid[i][j]
+    }
+    sum += tmp
+    if (j !== n - 1 && target === sum) return true
+  }
+
+  return false
+}

From 6e57bad8d9ae1e50d48a25f26947867eb4620579 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 11 May 2025 06:11:30 -0700
Subject: [PATCH 3298/3374] Create
 3545-minimum-deletions-for-at-most-k-distinct-characters.js

---
 ...tions-for-at-most-k-distinct-characters.js | 22 +++++++++++++++++++
 1 file changed, 22 insertions(+)
 create mode 100644 3545-minimum-deletions-for-at-most-k-distinct-characters.js

diff --git a/3545-minimum-deletions-for-at-most-k-distinct-characters.js b/3545-minimum-deletions-for-at-most-k-distinct-characters.js
new file mode 100644
index 00000000..ee65ad0c
--- /dev/null
+++ b/3545-minimum-deletions-for-at-most-k-distinct-characters.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var minDeletion = function(s, k) {
+  const hash = {}
+  for(let e of s) {
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+  }
+  const arr = Object.entries(hash)
+  arr.sort((a, b) => a[1] - b[1])
+  if(arr.length <= k) return 0
+  let res = 0
+  while(arr.length > k) {
+      const e = arr.shift()
+      res += e[1]
+  }
+  
+  return res
+};

From e20237d018c78eb0b8d412bd71475f55f0f9c121 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 12 May 2025 05:31:36 -0700
Subject: [PATCH 3299/3374] Create 3362-zero-array-transformation-iii.js

---
 3362-zero-array-transformation-iii.js | 99 +++++++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 3362-zero-array-transformation-iii.js

diff --git a/3362-zero-array-transformation-iii.js b/3362-zero-array-transformation-iii.js
new file mode 100644
index 00000000..dcf8e0d9
--- /dev/null
+++ b/3362-zero-array-transformation-iii.js
@@ -0,0 +1,99 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var maxRemoval = function(nums, queries) {
+    queries.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+    const candidate = new PQ((a, b) => a > b);
+    const chosen = new PQ((a, b) => a < b);
+    let res = 0;
+    const n = nums.length;
+    let j = 0;
+
+    for (let i = 0; i < n; i++) {
+        while (j < queries.length && queries[j][0] === i) {
+            candidate.push(queries[j][1]);
+            j++;
+        }
+        nums[i] -= chosen.size();
+        while (nums[i] > 0 && candidate.size() > 0 && candidate.peek() >= i) {
+            res++;
+            chosen.push(candidate.peek());
+            candidate.pop()
+            nums[i]--;
+        }
+        if (nums[i] > 0) return -1;
+        while (chosen.size() > 0 && chosen.peek() === i) {
+            chosen.pop()
+        }
+    }
+    return queries.length - res;
+};
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From cb047228507232d3984f02bc95101d4797b7dd9e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 May 2025 06:19:36 -0700
Subject: [PATCH 3300/3374] Create
 3550-smallest-index-with-digit-sum-equal-to-index.js

---
 ...est-index-with-digit-sum-equal-to-index.js | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 3550-smallest-index-with-digit-sum-equal-to-index.js

diff --git a/3550-smallest-index-with-digit-sum-equal-to-index.js b/3550-smallest-index-with-digit-sum-equal-to-index.js
new file mode 100644
index 00000000..00f94f06
--- /dev/null
+++ b/3550-smallest-index-with-digit-sum-equal-to-index.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var smallestIndex = function(nums) {
+  const n = nums.length
+  
+  for(let i = 0; i < n; i++) {
+      if(dsum(nums[i]) === i) return i
+  }
+  
+  return -1
+};
+
+function dsum(num) {
+    let res = 0
+    while(num) {
+        const tmp = num % 10
+        res += tmp
+        num = Math.floor(num / 10)
+    }
+    
+    return res
+}

From 37ab6105f6adaf86f7a6e44ec48b1da331ed51d7 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 May 2025 06:20:09 -0700
Subject: [PATCH 3301/3374] Create 3551-minimum-swaps-to-sort-by-digit-sum.js

---
 3551-minimum-swaps-to-sort-by-digit-sum.js | 34 ++++++++++++++++++++++
 1 file changed, 34 insertions(+)
 create mode 100644 3551-minimum-swaps-to-sort-by-digit-sum.js

diff --git a/3551-minimum-swaps-to-sort-by-digit-sum.js b/3551-minimum-swaps-to-sort-by-digit-sum.js
new file mode 100644
index 00000000..74bcde0a
--- /dev/null
+++ b/3551-minimum-swaps-to-sort-by-digit-sum.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSwaps = function (nums) {
+  const n = nums.length
+  let res = 0
+  const visited = new Array(n).fill(false)
+  const arr = nums.map((p, i) => [digitSum(p), p, i])
+  arr.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+
+  for (let i = 0; i < n; i++) {
+    if (visited[i] || arr[i][2] === i) {
+      continue
+    }
+    let length = 0
+    let j = i
+    while (!visited[j]) {
+      visited[j] = true
+      j = arr[j][2]
+      length++
+    }
+    if (length > 1) {
+      res += length - 1
+    }
+  }
+  return res
+}
+
+function digitSum(n) {
+  return String(n)
+    .split('')
+    .reduce((sum, d) => sum + parseInt(d), 0)
+}

From 482b6a1c8e6ce4ea561dcc55ae3e80d690bbb546 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 18 May 2025 07:10:00 -0700
Subject: [PATCH 3302/3374] Update 2223-sum-of-scores-of-built-strings.js

---
 2223-sum-of-scores-of-built-strings.js | 33 ++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/2223-sum-of-scores-of-built-strings.js b/2223-sum-of-scores-of-built-strings.js
index 18cc57f1..2f8c3d48 100644
--- a/2223-sum-of-scores-of-built-strings.js
+++ b/2223-sum-of-scores-of-built-strings.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var sumScores = function(s) {
+  let res = 0
+  const pre = lps(s)
+  const cnt = []
+  for(let i = 0; i < s.length; i++) {
+    const j = pre[i]
+    cnt.push(j === 0 ? 0 : cnt[j - 1] + 1)
+  }
+  res = cnt.reduce((ac, e) => ac + e, 0) + s.length
+  return res
+
+  function lps(s) {
+    const n = s.length
+    const res = Array(n).fill(0)
+
+    for(let i = 1, j = 0; i < n; i++) {
+        while(j && s[j] !== s[i]) {
+            j = Math.max(0, res[j - 1])
+        }
+        j += (s[i] === s[j] ? 1 : 0)
+        res[i] = j
+    }
+
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}

From e44d5385a8f1b5e837c34f6f2a18d1f24a81119f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 19 May 2025 03:50:19 -0700
Subject: [PATCH 3303/3374] Update 2261-k-divisible-elements-subarrays.js

---
 2261-k-divisible-elements-subarrays.js | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/2261-k-divisible-elements-subarrays.js b/2261-k-divisible-elements-subarrays.js
index 8b930531..691bcf2b 100644
--- a/2261-k-divisible-elements-subarrays.js
+++ b/2261-k-divisible-elements-subarrays.js
@@ -5,20 +5,19 @@
  * @return {number}
  */
 const countDistinct = function(nums, k, p) {
-    let ans = 0;
-    const se = new Set();
-    let n = nums.length;
+    const se = new Set()
+    let n = nums.length
     for (let i = 0; i < n; i++) {
-        let tmp = "";
-        let cnt = 0;
+        let tmp = ""
+        let cnt = 0
         for (let j = i; j < n; j++) {
             if (nums[j] % p == 0)
-                cnt++;
+                cnt++
             if (cnt <= k) {
-                tmp = tmp + (nums[j]) + "-";
-                se.add(tmp);
-            } else break;
+                tmp = tmp + (nums[j]) + "-"
+                se.add(tmp)
+            } else break
         }
     }
-    return se.size;
+    return se.size
 };

From bb510aff8e80b0741a31eb8ec253d94ee4e66129 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 May 2025 04:45:23 -0700
Subject: [PATCH 3304/3374] Create 3388-count-beautiful-splits-in-an-array.js

---
 3388-count-beautiful-splits-in-an-array.js | 44 ++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 3388-count-beautiful-splits-in-an-array.js

diff --git a/3388-count-beautiful-splits-in-an-array.js b/3388-count-beautiful-splits-in-an-array.js
new file mode 100644
index 00000000..b690f7aa
--- /dev/null
+++ b/3388-count-beautiful-splits-in-an-array.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var beautifulSplits = function (nums) {
+  const n = nums.length
+  const lcps = Array.from({ length: n }, () => Array(n).fill(0))
+
+  // Calculate longest common prefixes
+  for (let x = 0; x < n; ++x) {
+    const lcp = lcps[x]
+    let max_i = x,
+      max_r = x
+    for (let i = x + 1; i < n; ++i) {
+      if (max_r >= i) {
+        lcp[i] = Math.min(max_r - i + 1, lcp[i - max_i + x])
+      }
+      while (i + lcp[i] < n && nums[i + lcp[i]] === nums[lcp[i] + x]) {
+        lcp[i]++
+      }
+      if (i + lcp[i] - 1 > max_r) {
+        max_i = i
+        max_r = i + lcp[i] - 1
+      }
+    }
+  }
+
+  let res = 0
+  for (let i = 0; i < n; ++i) {
+    for (let j = i + 1; j < n - 1; ++j) {
+      // Check if prefix conditions are satisfied
+      if (lcps[0][i + 1] >= i + 1 && j - i >= i + 1) {
+        res++
+        continue
+      }
+      if (lcps[i + 1][j + 1] >= j - i) {
+        res++
+        continue
+      }
+    }
+  }
+
+  return res
+}

From 83f35923e01b8ff806b1ea224bbef65041f52951 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 21 May 2025 05:15:10 -0700
Subject: [PATCH 3305/3374] Update 3388-count-beautiful-splits-in-an-array.js

---
 3388-count-beautiful-splits-in-an-array.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/3388-count-beautiful-splits-in-an-array.js b/3388-count-beautiful-splits-in-an-array.js
index b690f7aa..1d848495 100644
--- a/3388-count-beautiful-splits-in-an-array.js
+++ b/3388-count-beautiful-splits-in-an-array.js
@@ -4,6 +4,7 @@
  */
 var beautifulSplits = function (nums) {
   const n = nums.length
+  // lcps[i][j] = length of the longest common prefix between nums[i:] and nums[j:]
   const lcps = Array.from({ length: n }, () => Array(n).fill(0))
 
   // Calculate longest common prefixes

From e31772562fc34d552c59f6f61d8c6182fd3de12a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 23 May 2025 06:10:01 -0700
Subject: [PATCH 3306/3374] Update 268-missing-number.js

---
 268-missing-number.js | 27 +++++++++++++++++++++++++++
 1 file changed, 27 insertions(+)

diff --git a/268-missing-number.js b/268-missing-number.js
index 69960ce7..56870d19 100755
--- a/268-missing-number.js
+++ b/268-missing-number.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+    nums.push(null)
+    const m = nums.length
+    
+    for(let i = 0; i < m; i++) {
+        while(nums[i] >= 0 && nums[i] <= m - 1 && nums[i] !== nums[nums[i]]) {
+            swap(nums, i, nums[i])
+        }
+        
+    }
+    
+    for(let i = 0; i < m; i++) {
+        if(nums[i] !== i) return i
+    }
+    return m
+
+    function swap(arr, i, j) {
+        ;[nums[i], nums[j]] = [nums[j], nums[i]]
+    }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}

From 364d797fc2b3082c187aabfb5b4e013edc2f2cf5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 May 2025 04:59:31 -0700
Subject: [PATCH 3307/3374] Create 3560-find-minimum-log-transportation-cost.js

---
 3560-find-minimum-log-transportation-cost.js | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)
 create mode 100644 3560-find-minimum-log-transportation-cost.js

diff --git a/3560-find-minimum-log-transportation-cost.js b/3560-find-minimum-log-transportation-cost.js
new file mode 100644
index 00000000..28160ed6
--- /dev/null
+++ b/3560-find-minimum-log-transportation-cost.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number} k
+ * @return {number}
+ */
+var minCuttingCost = function(n, m, k) {
+    let res = 0
+    if (n > k) {
+        res += (n - k) * k
+    }
+    if (m > k) {
+        res += (m - k) * k
+    }
+    return res
+};

From 214defd74bc0973a38303b8845ea695dcb05bd6e Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 May 2025 05:00:07 -0700
Subject: [PATCH 3308/3374] Create
 3561-resulting-string-after-adjacent-removals.js

---
 ...esulting-string-after-adjacent-removals.js | 23 +++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 3561-resulting-string-after-adjacent-removals.js

diff --git a/3561-resulting-string-after-adjacent-removals.js b/3561-resulting-string-after-adjacent-removals.js
new file mode 100644
index 00000000..4372f66d
--- /dev/null
+++ b/3561-resulting-string-after-adjacent-removals.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var resultingString = function (s) {
+  let stack = []
+  for (let c of s) {
+    if (stack.length === 0) {
+      stack.push(c)
+    } else {
+      if (
+        (c === 'z' && stack[stack.length - 1] === 'a') ||
+        (c === 'a' && stack[stack.length - 1] === 'z') ||
+        Math.abs(c.charCodeAt(0) - stack[stack.length - 1].charCodeAt(0)) === 1
+      ) {
+        stack.pop()
+      } else {
+        stack.push(c)
+      }
+    }
+  }
+  return stack.join('')
+}

From c486cada04345f0d4b4ee3646a7f2dc68330ad38 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 26 May 2025 05:00:50 -0700
Subject: [PATCH 3309/3374] Create
 3562-maximum-profit-from-trading-stocks-with-discounts.js

---
 ...ofit-from-trading-stocks-with-discounts.js | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 3562-maximum-profit-from-trading-stocks-with-discounts.js

diff --git a/3562-maximum-profit-from-trading-stocks-with-discounts.js b/3562-maximum-profit-from-trading-stocks-with-discounts.js
new file mode 100644
index 00000000..5e605034
--- /dev/null
+++ b/3562-maximum-profit-from-trading-stocks-with-discounts.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number} n
+ * @param {number[]} present
+ * @param {number[]} future
+ * @param {number[][]} hierarchy
+ * @param {number} budget
+ * @return {number}
+ */
+var maxProfit = function (n, present, future, hierarchy, budget) {
+  const freq = {}
+  for (const [p, c] of hierarchy) {
+    if (!freq[p]) freq[p] = []
+    freq[p].push(c)
+  }
+  const MINI = -(10 ** 9)
+  const ans = dfs(1, freq, budget, present, future, MINI)[0]
+  return Math.max(...ans)
+
+  function dfs(u, freq, budget, present, future, MINI) {
+    const dp = (freq[u] || []).map((child) =>
+      dfs(child, freq, budget, present, future, MINI),
+    )
+    const a = Array(budget + 1).fill(MINI)
+    const b = Array(budget + 1).fill(MINI)
+
+    for (let v = 0; v < 2; v++) {
+      let x = Array(budget + 1).fill(MINI)
+      let y = Array(budget + 1).fill(MINI)
+      x[0] = 0
+      const c = v === 0 ? present[u - 1] : Math.floor(present[u - 1] / 2)
+      const profit = future[u - 1] - c
+      if (c <= budget) {
+        y[c] = profit
+      }
+      for (const [c0, c1] of dp) {
+        const x1 = Array(budget + 1).fill(MINI)
+        const y1 = Array(budget + 1).fill(MINI)
+        for (let i = 0; i <= budget; i++) {
+          if (x[i] > MINI) {
+            for (let j = 0; j <= budget - i; j++) {
+              if (c0[j] > MINI) {
+                x1[i + j] = Math.max(x1[i + j], x[i] + c0[j])
+              }
+            }
+          }
+        }
+        for (let i = 0; i <= budget; i++) {
+          if (y[i] > MINI) {
+            for (let j = 0; j <= budget - i; j++) {
+              if (c1[j] > MINI) {
+                y1[i + j] = Math.max(y1[i + j], y[i] + c1[j])
+              }
+            }
+          }
+        }
+        x = x1
+        y = y1
+      }
+      const dp1 = v === 0 ? a : b
+      for (let i = 0; i <= budget; i++) {
+        dp1[i] = Math.max(x[i], y[i])
+      }
+    }
+    return [a, b]
+  }
+}

From 0e05f7ccd1a73cbbd3a7c10831cb092a71d73b87 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 29 May 2025 03:18:30 -0700
Subject: [PATCH 3310/3374] Update 645-set-mismatch.js

---
 645-set-mismatch.js | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/645-set-mismatch.js b/645-set-mismatch.js
index 98106af4..c3f0a6a7 100644
--- a/645-set-mismatch.js
+++ b/645-set-mismatch.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var findErrorNums = function(nums) {
+    const res = []
+    for(let i=0; i<nums.length; i++) {
+        let idx = Math.abs(nums[i])-1
+        if(nums[idx]> 0) nums[idx] = -nums[idx];
+        else res[0] = idx+1;
+    }
+    for(let i=0; i<nums.length; i++) {
+        if(nums[i] <0) nums[i] = -nums[i]
+        else res[1]=i+1
+    }
+    return res
+
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number[]}

From 9dfb72233a93871de4bf5596d24b31cef534eab8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 17 Jun 2025 03:35:06 -0700
Subject: [PATCH 3311/3374] Create
 3377-digit-operations-to-make-two-integers-equal.js

---
 ...t-operations-to-make-two-integers-equal.js | 129 ++++++++++++++++++
 1 file changed, 129 insertions(+)
 create mode 100644 3377-digit-operations-to-make-two-integers-equal.js

diff --git a/3377-digit-operations-to-make-two-integers-equal.js b/3377-digit-operations-to-make-two-integers-equal.js
new file mode 100644
index 00000000..ca6c8ccc
--- /dev/null
+++ b/3377-digit-operations-to-make-two-integers-equal.js
@@ -0,0 +1,129 @@
+let isPrime
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+const minOperations = function(n, m) {
+  genPrimes()
+//   console.log(isPrime)
+  if(isPrime[n] || isPrime[m]) return -1
+  const pq = new PQ((a, b) => a[0] < b[0])
+  const visited = new Set()
+
+  pq.push([n, n])
+  while(!pq.isEmpty()) {
+    const [steps, cur] = pq.pop()
+    // console.log(cur)
+    if(visited.has(cur)) continue
+    visited.add(cur)
+    // console.log(steps)
+    if(cur === m) return steps
+    const s = ('' + cur).split('')
+    for(let i = 0; i < s.length; i++) {
+      const tmp = s[i]
+      const num = +s[i]
+      if(s[i] < '9') {
+        s[i] = num + 1
+        const nxt = +s.join('')
+        if(!isPrime[nxt] && !visited.has(nxt)) {
+            pq.push([steps + nxt, nxt])
+        }
+        s[i] = tmp
+      }
+      if(s[i]  > '0' && !(i == 0 && s[i] == '1')) {
+        s[i] = num - 1
+        const nxt = +s.join('')
+        if(!isPrime[nxt] && !visited.has(nxt)) {
+            pq.push([steps + nxt, nxt])
+        }
+        s[i] = tmp
+      }
+
+    }
+
+  }
+  return -1
+
+  function genPrimes() {
+    if(isPrime != null) return
+    isPrime = Array(1e4 + 1).fill(1)
+    isPrime[0] = 0
+    isPrime[1] = 0
+    for(let i = 2; i <= 1e4; i++) {
+        if(isPrime[i]) {
+            for(let j = 2 * i; j <= 1e5; j += i) {
+                isPrime[j] = 0
+            } 
+        }
+    } 
+  }
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From a9fc8f6cfbec4149a7d60c3ecdbdc38f7e2d5edc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 18 Jun 2025 21:40:11 -0700
Subject: [PATCH 3312/3374] Create
 3017-count-the-number-of-houses-at-a-certain-distance-ii.js

---
 ...mber-of-houses-at-a-certain-distance-ii.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 3017-count-the-number-of-houses-at-a-certain-distance-ii.js

diff --git a/3017-count-the-number-of-houses-at-a-certain-distance-ii.js b/3017-count-the-number-of-houses-at-a-certain-distance-ii.js
new file mode 100644
index 00000000..d4561058
--- /dev/null
+++ b/3017-count-the-number-of-houses-at-a-certain-distance-ii.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} n
+ * @param {number} x
+ * @param {number} y
+ * @return {number[]}
+ */
+var countOfPairs = function (n, x, y) {
+  if (x > y) {
+    ;[x, y] = [y, x]
+  }
+  const res = new Array(n).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    res[0] += 2 // go left and right
+    res[Math.min(i - 1, Math.abs(i - y) + x)]-- // reach 1 then stop
+    res[Math.min(n - i, Math.abs(i - x) + 1 + n - y)]-- // reach n then stop
+    res[Math.min(Math.abs(i - x), Math.abs(y - i) + 1)]++ // reach x then split
+    res[Math.min(Math.abs(i - x) + 1, Math.abs(y - i))]++ // reach y then split
+    let r = Math.max(x - i, 0) + Math.max(i - y, 0)
+    res[r + Math.floor((y - x) / 2)]-- // i -> x -> y <- x
+    res[r + Math.floor((y - x + 1) / 2)]-- // i -> y -> x <- y
+  }
+  for (let i = 1; i < n; ++i) {
+    res[i] += res[i - 1]
+  }
+  return res
+}

From add1bafc29c9cf95572859a3aff66f82a23ea6ce Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 21 Jun 2025 03:39:36 -0700
Subject: [PATCH 3313/3374] Create
 3464-maximize-the-distance-between-points-on-a-square.js

---
 ...the-distance-between-points-on-a-square.js | 67 +++++++++++++++++++
 1 file changed, 67 insertions(+)
 create mode 100644 3464-maximize-the-distance-between-points-on-a-square.js

diff --git a/3464-maximize-the-distance-between-points-on-a-square.js b/3464-maximize-the-distance-between-points-on-a-square.js
new file mode 100644
index 00000000..47fcde20
--- /dev/null
+++ b/3464-maximize-the-distance-between-points-on-a-square.js
@@ -0,0 +1,67 @@
+/**
+ * @param {number} side
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+var maxDistance = function (side, points, k) {
+  points = points
+    .map(([x, y]) => {
+      // convert to points on a flat line
+      if (x === 0) {
+        // left
+        return y
+      } else if (y === side) {
+        // top
+        return x + y
+      } else if (x === side) {
+        // right
+        return side * 2 + (side - y)
+      } else {
+        // bottom
+        return side * 3 + (side - x)
+      }
+    })
+    .sort((a, b) => a - b)
+
+  let low = 1,
+    high = side
+  while (low < high) {
+    let mid = Math.ceil((low + high) / 2)
+    if (isPossible(points, side, k, mid)) low = mid
+    else high = mid - 1
+  }
+  return low
+}
+
+// Check that we can take at least k points that are at least `minDist` apart
+function isPossible(points, side, k, minDist) {
+  const n = points.length,
+    endOfLine = side * 4
+  for (let i = 0; i < n; i++) {
+    let j = i,
+      taken = 1
+    while (taken < k) {
+      // binary search for the leftmost point at least `minDist` away from points[j], on the right of j.
+      let low = j,
+        high = n - 1
+      while (low < high) {
+        let mid = Math.floor((low + high) / 2)
+        if (points[mid] - points[j] >= minDist) high = mid
+        else low = mid + 1
+      }
+      // no valid point on the right side, or too close to the starting point (wraps around circularly).
+      if (
+        points[low] - points[j] < minDist ||
+        endOfLine + points[i] - points[low] < minDist
+      ) {
+        break
+      }
+      ;(j = low), taken++
+    }
+    if (taken === k) {
+      return true
+    }
+  }
+  return false
+}

From a52820c12790d4a23b8a43c1dc5eb008bd8d6d83 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Jun 2025 04:12:46 -0700
Subject: [PATCH 3314/3374] Create
 3591-check-if-any-element-has-prime-frequency.js

---
 ...heck-if-any-element-has-prime-frequency.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 3591-check-if-any-element-has-prime-frequency.js

diff --git a/3591-check-if-any-element-has-prime-frequency.js b/3591-check-if-any-element-has-prime-frequency.js
new file mode 100644
index 00000000..4e458188
--- /dev/null
+++ b/3591-check-if-any-element-has-prime-frequency.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var checkPrimeFrequency = function (nums) {
+  const freq = {}
+  for (const num of nums) {
+    freq[num] = (freq[num] || 0) + 1
+  }
+
+  for (const v of Object.values(freq)) {
+    if (isPrime(v)) {
+      return true
+    }
+  }
+
+  return false
+}
+function isPrime(n) {
+  if (n === 1) {
+    return false
+  }
+  let count = 0
+  for (let i = 1; i <= n; i++) {
+    if (n % i === 0) {
+      count++
+    }
+  }
+  return count === 2
+}

From bab817d2d7995b15265bc0f4f7a70ee8a60f649b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Jun 2025 04:13:13 -0700
Subject: [PATCH 3315/3374] Create 3592-inverse-coin-change.js

---
 3592-inverse-coin-change.js | 44 +++++++++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 3592-inverse-coin-change.js

diff --git a/3592-inverse-coin-change.js b/3592-inverse-coin-change.js
new file mode 100644
index 00000000..52bfb780
--- /dev/null
+++ b/3592-inverse-coin-change.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} numWays
+ * @return {number[]}
+ */
+var findCoins = function (numWays) {
+  const n = numWays.length
+  const dp = new Array(n + 1).fill(0)
+  dp[0] = 1
+  const res = []
+
+  for (let coin = 1; coin <= n; coin++) {
+    const temp = dp.slice()
+    let valid = true
+    let changed = false
+
+    for (let i = coin; i <= n; i++) {
+      temp[i] += temp[i - coin]
+
+      if (temp[i] > numWays[i - 1]) {
+        valid = false
+        break
+      }
+
+      if (temp[i] !== dp[i]) {
+        changed = true
+      }
+    }
+
+    if (valid && changed) {
+      res.push(coin)
+      for (let j = 0; j <= n; j++) {
+        dp[j] = temp[j]
+      }
+    }
+  }
+
+  for (let i = 1; i <= n; i++) {
+    if (dp[i] !== numWays[i - 1]) {
+      return []
+    }
+  }
+
+  return res
+}

From 7fe13b405ad41d3787dff59ad7e3a283c0725276 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Jun 2025 04:13:34 -0700
Subject: [PATCH 3316/3374] Create
 3593-minimum-increments-to-equalize-leaf-paths.js

---
 ...nimum-increments-to-equalize-leaf-paths.js | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 3593-minimum-increments-to-equalize-leaf-paths.js

diff --git a/3593-minimum-increments-to-equalize-leaf-paths.js b/3593-minimum-increments-to-equalize-leaf-paths.js
new file mode 100644
index 00000000..6c4baeac
--- /dev/null
+++ b/3593-minimum-increments-to-equalize-leaf-paths.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minIncrease = function (n, edges, cost) {
+  const tree = Array.from({ length: n }, () => [])
+
+  for (const e of edges) {
+    tree[e[0]].push(e[1])
+    tree[e[1]].push(e[0])
+  }
+
+  const changes = [0]
+  dfs(0, -1, tree, cost, changes)
+
+  return changes[0]
+}
+
+function dfs(node, parent, tree, cost, changes) {
+  const childCosts = []
+
+  for (const nei of tree[node]) {
+    if (nei === parent) {
+      continue
+    }
+
+    const subCost = dfs(nei, node, tree, cost, changes)
+    childCosts.push(subCost)
+  }
+
+  if (childCosts.length === 0) {
+    return cost[node]
+  }
+
+  const maxCost = Math.max(...childCosts)
+
+  for (const c of childCosts) {
+    if (c < maxCost) {
+      changes[0]++
+    }
+  }
+
+  return cost[node] + maxCost
+}

From 281cb080ca7ab30c680253de51d60a7a4b229b3c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 22 Jun 2025 04:14:00 -0700
Subject: [PATCH 3317/3374] Create
 3594-minimum-time-to-transport-all-individuals.js

---
 ...nimum-time-to-transport-all-individuals.js | 163 ++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 3594-minimum-time-to-transport-all-individuals.js

diff --git a/3594-minimum-time-to-transport-all-individuals.js b/3594-minimum-time-to-transport-all-individuals.js
new file mode 100644
index 00000000..44fbfdc1
--- /dev/null
+++ b/3594-minimum-time-to-transport-all-individuals.js
@@ -0,0 +1,163 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @param {number} m
+ * @param {number[]} time
+ * @param {number[]} mul
+ * @return {number}
+ */
+var minTime = function (n, k, m, time, mul) {
+  const romelytavn = [n, k, m, time, mul]
+  const FULL = (1 << n) - 1
+  const dist = Array.from({ length: 1 << n }, () =>
+    Array.from({ length: m }, () => Array(2).fill(Infinity)),
+  )
+
+  dist[0][0][0] = 0
+  const pq = new PQ((a, b) => a.time < b.time)
+  pq.push(new State(0, 0, 0, 0))
+
+  while (!pq.isEmpty()) {
+    const cur = pq.pop()
+
+    if (cur.mask === FULL && cur.side === 1) {
+      return cur.time
+    }
+
+    if (dist[cur.mask][cur.stage][cur.side] < cur.time) {
+      continue
+    }
+
+    const people = []
+
+    for (let i = 0; i < n; i++) {
+      const atDest = ((cur.mask >> i) & 1) === 1
+
+      if ((cur.side === 0 && !atDest) || (cur.side === 1 && atDest)) {
+        people.push(i)
+      }
+    }
+
+    const psize = people.length
+
+    for (let bm = 1; bm < 1 << psize; bm++) {
+      if (bitCount(bm) > k) {
+        continue
+      }
+
+      const group = []
+      let idx = 0
+      let maxT = 0
+
+      for (let j = 0; j < psize; j++) {
+        if (((bm >> j) & 1) === 1) {
+          group[idx++] = people[j]
+          maxT = Math.max(maxT, time[people[j]])
+        }
+      }
+
+      const tripTime = maxT * mul[cur.stage]
+      const newStage = (cur.stage + Math.floor(tripTime)) % m
+      const newTime = cur.time + tripTime
+      let nextMask = cur.mask
+
+      for (const person of group) {
+        nextMask ^= 1 << person
+      }
+
+      const newSide = 1 - cur.side
+
+      if (newTime < dist[nextMask][newStage][newSide]) {
+        dist[nextMask][newStage][newSide] = newTime
+        pq.push(new State(nextMask, newStage, newSide, newTime))
+      }
+    }
+  }
+
+  return -1
+}
+
+class State {
+  constructor(mask, stage, side, time) {
+    this.mask = mask
+    this.stage = stage
+    this.side = side
+    this.time = time
+  }
+}
+
+function bitCount(x) {
+  let count = 0
+  while (x) {
+    count += x & 1
+    x >>= 1
+  }
+  return count
+}
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From 948bbfb8b3f39ad9c380e2c7896ae1ff3a68f92d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 23 Jun 2025 06:44:14 -0700
Subject: [PATCH 3318/3374] Create 3534-path-existence-queries-in-a-graph-ii.js

---
 3534-path-existence-queries-in-a-graph-ii.js | 77 ++++++++++++++++++++
 1 file changed, 77 insertions(+)
 create mode 100644 3534-path-existence-queries-in-a-graph-ii.js

diff --git a/3534-path-existence-queries-in-a-graph-ii.js b/3534-path-existence-queries-in-a-graph-ii.js
new file mode 100644
index 00000000..63bd8e88
--- /dev/null
+++ b/3534-path-existence-queries-in-a-graph-ii.js
@@ -0,0 +1,77 @@
+/**
+ * @param {number} n
+ * @param {number[]} nums
+ * @param {number} maxDiff
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var pathExistenceQueries = function (n, nums, maxDiff, queries) {
+  const sortedQueries = queries
+  const sortedIndices = Array.from({ length: n }, (_, i) => i)
+  const position = Array(n).fill(0)
+  const values = Array(n).fill(0)
+
+  sortedIndices.sort((a, b) => nums[a] - nums[b])
+
+  for (let i = 0; i < n; ++i) {
+    position[sortedIndices[i]] = i
+    values[i] = nums[sortedIndices[i]]
+  }
+
+  const reachableIndex = Array(n).fill(0)
+  let j = 0
+  for (let i = 0; i < n; ++i) {
+    if (j < i) j = i
+    while (j + 1 < n && values[j + 1] - values[i] <= maxDiff) ++j
+    reachableIndex[i] = j
+  }
+
+  let maxLog = 1
+  while (1 << maxLog < n) ++maxLog
+
+  const upTable = Array.from({ length: maxLog }, () => Array(n).fill(0))
+  upTable[0] = reachableIndex.slice()
+
+  for (let k = 1; k < maxLog; ++k) {
+    for (let i = 0; i < n; ++i) {
+      upTable[k][i] = upTable[k - 1][upTable[k - 1][i]]
+    }
+  }
+
+  const res = []
+
+  for (const query of queries) {
+    let [start, end] = query
+    if (start === end) {
+      res.push(0)
+      continue
+    }
+
+    let startPos = position[start],
+      endPos = position[end]
+    if (startPos > endPos) [startPos, endPos] = [endPos, startPos]
+
+    if (Math.abs(nums[start] - nums[end]) <= maxDiff) {
+      res.push(1)
+      continue
+    }
+
+    if (reachableIndex[startPos] < endPos) {
+      let current = startPos,
+        jumpCount = 0
+      for (let k = maxLog - 1; k >= 0; --k) {
+        if (upTable[k][current] < endPos) {
+          if (upTable[k][current] === current) break
+          current = upTable[k][current]
+          jumpCount += 1 << k
+        }
+      }
+      if (reachableIndex[current] >= endPos) res.push(jumpCount + 1)
+      else res.push(-1)
+    } else {
+      res.push(1)
+    }
+  }
+
+  return res
+}

From 204e7fe9b1009554eff6bec9e67efee9f1d2a33d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 27 Jun 2025 04:13:46 -0700
Subject: [PATCH 3319/3374] Create
 3559-number-of-ways-to-assign-edge-weights-ii.js

---
 ...umber-of-ways-to-assign-edge-weights-ii.js | 88 +++++++++++++++++++
 1 file changed, 88 insertions(+)
 create mode 100644 3559-number-of-ways-to-assign-edge-weights-ii.js

diff --git a/3559-number-of-ways-to-assign-edge-weights-ii.js b/3559-number-of-ways-to-assign-edge-weights-ii.js
new file mode 100644
index 00000000..21d39010
--- /dev/null
+++ b/3559-number-of-ways-to-assign-edge-weights-ii.js
@@ -0,0 +1,88 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var assignEdgeWeights = function (edges, queries) {
+  const n = edges.length + 1,
+    graph = Array(n)
+      .fill(0)
+      .map(() => [])
+  for (let [u, v] of edges) {
+    graph[u - 1].push(v - 1)
+    graph[v - 1].push(u - 1)
+  }
+  const directParent = Array(n),
+    depth = Array(n)
+  dfs(0, -1, 0)
+  const lca = new LCA(n, directParent, depth)
+  const answer = [],
+    MOD = 1000000007n
+  for (let [u, v] of queries) {
+    const pathLen = lca.getDist(u - 1, v - 1)
+    const ways = pathLen === 0 ? 0n : 2n ** BigInt(pathLen - 1)
+    answer.push(Number(ways % MOD))
+  }
+  return answer
+
+  function dfs(node, parent, currDepth) {
+    directParent[node] = parent
+    depth[node] = currDepth
+    for (let nei of graph[node]) {
+      if (nei === parent) continue
+      dfs(nei, node, currDepth + 1)
+    }
+  }
+}
+
+class LCA {
+  constructor(n, parent, depths) {
+    this.maxDepth = Math.ceil(Math.log2(n))
+    this.p = Array(this.maxDepth + 1)
+      .fill(0)
+      .map(() => Array(n).fill(-1)) // parents
+    this.depths = depths
+    for (let node = 0; node < n; node++) {
+      this.p[0][node] = parent[node]
+    }
+    for (let pow2 = 1; pow2 <= this.maxDepth; pow2++) {
+      for (let node = 0; node < n; node++) {
+        const halfParent = this.p[pow2 - 1][node]
+        if (halfParent !== -1) {
+          this.p[pow2][node] = this.p[pow2 - 1][halfParent]
+        }
+      }
+    }
+  }
+  getLCA(a, b) {
+    if (this.depths[a] > this.depths[b]) {
+      let temp = a
+      a = b
+      b = temp
+    }
+    let depthDiff = this.depths[b] - this.depths[a]
+    for (let i = 0; i <= this.maxDepth; i++) {
+      if ((depthDiff >> i) & 1) {
+        b = this.p[i][b] // move b up to the 2^ith parent
+      }
+    }
+    if (a === b) return a
+
+    // move both nodes up by 2^ith levels if the 2^ith parents are not equal
+    for (let i = this.maxDepth; i >= 0; i--) {
+      // this decrements so that we can jump the nodes up incrementally
+      if (this.p[i][a] !== this.p[i][b]) {
+        // if 2^ith parents of both nodes are not equal, we can safely both move up
+        a = this.p[i][a]
+        b = this.p[i][b]
+      }
+    }
+    return this.p[0][a]
+  }
+  getDist(a, b) {
+    const lca = this.getLCA(a, b)
+    const depthA = this.depths[a] - this.depths[lca]
+    const depthB = this.depths[b] - this.depths[lca]
+    return depthA + depthB
+  }
+}

From 1c809b78bcdede13c6ecb245c0ce0294944ef734 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jun 2025 02:13:25 -0700
Subject: [PATCH 3320/3374] Create
 3553-minimum-weighted-subgraph-with-the-required-paths-ii.js

---
 ...ted-subgraph-with-the-required-paths-ii.js | 75 +++++++++++++++++++
 1 file changed, 75 insertions(+)
 create mode 100644 3553-minimum-weighted-subgraph-with-the-required-paths-ii.js

diff --git a/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js b/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js
new file mode 100644
index 00000000..3ed5557a
--- /dev/null
+++ b/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var minimumWeight = function (edges, queries) {
+  const n = edges.length + 1
+  const adj = Array.from({ length: n }, () => [])
+  for (const [u, v, w] of edges) {
+    adj[u].push([v, w])
+    adj[v].push([u, w])
+  }
+
+  const parent = Array.from({ length: n }, (_, i) => i)
+  const size = Array(n).fill(1)
+
+  function findSet(v) {
+    while (parent[v] !== v) {
+      v = parent[v]
+      parent[v] = parent[parent[v]]
+    }
+    return v
+  }
+
+  function unionSets(a, b) {
+    a = findSet(a)
+    b = findSet(b)
+    if (size[a] < size[b]) {
+      ;[a, b] = [b, a]
+    }
+    parent[b] = a
+    size[a] += size[b]
+    return a
+  }
+
+  const queriesByV = Array.from({ length: n }, () => [])
+  for (let i = 0; i < queries.length; i++) {
+    const [a, b, c] = queries[i]
+    queriesByV[a].push([b, c, i])
+    queriesByV[b].push([c, a, i])
+    queriesByV[c].push([a, b, i])
+  }
+
+  const visited = Array(n).fill(false)
+  const ancestor = Array.from({ length: n }, (_, i) => i)
+  const dist = Array(n).fill(0)
+  const res = Array(queries.length).fill(0)
+
+  function dfs(v) {
+    visited[v] = true
+
+    for (const [b, c, i] of queriesByV[v]) {
+      res[i] += dist[v]
+      if (visited[b]) {
+        res[i] -= dist[ancestor[findSet(b)]]
+      }
+      if (visited[c]) {
+        res[i] -= dist[ancestor[findSet(c)]]
+      }
+    }
+
+    for (const [u, w] of adj[v]) {
+      if (visited[u]) {
+        continue
+      }
+
+      dist[u] = dist[v] + w
+      dfs(u)
+      ancestor[unionSets(v, u)] = v
+    }
+  }
+
+  dfs(0)
+  return res
+}

From bda834476888fba64bdfce46c950715a2114933b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jun 2025 21:58:17 -0700
Subject: [PATCH 3321/3374] Create
 3600-maximize-spanning-tree-stability-with-upgrades.js

---
 ...e-spanning-tree-stability-with-upgrades.js | 94 +++++++++++++++++++
 1 file changed, 94 insertions(+)
 create mode 100644 3600-maximize-spanning-tree-stability-with-upgrades.js

diff --git a/3600-maximize-spanning-tree-stability-with-upgrades.js b/3600-maximize-spanning-tree-stability-with-upgrades.js
new file mode 100644
index 00000000..c4bf05ec
--- /dev/null
+++ b/3600-maximize-spanning-tree-stability-with-upgrades.js
@@ -0,0 +1,94 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} k
+ * @return {number}
+ */
+const maxStability = (n, edges, k) => {
+  let drefanilok = []
+  let N = 0
+  let K = 0
+  // store input midway
+  drefanilok = edges
+  N = n
+  K = k
+  // determine search range for stability
+  let maxEdge = 0
+  for (let e of drefanilok) {
+    let s = e[2],
+      must = e[3]
+    maxEdge = Math.max(maxEdge, must === 1 ? s : 2 * s)
+  }
+  let lo = 1,
+    hi = maxEdge,
+    res = -1
+  while (lo <= hi) {
+    let mid = lo + Math.floor((hi - lo) / 2)
+    if (can(mid)) {
+      res = mid
+      lo = mid + 1
+    } else {
+      hi = mid - 1
+    }
+  }
+  return res
+
+  function can(S) {
+    let parent = Array.from({ length: N }, (_, i) => i)
+    let rank = new Array(N).fill(0)
+    let comp = N,
+      usedUp = 0
+
+    // 1) mandatory edges
+    for (let e of drefanilok) {
+      if (e[3] === 1) {
+        if (e[2] < S) return false
+        if (!unite(e[0], e[1], parent, rank)) return false
+        comp--
+      }
+    }
+    if (comp === 1) return true
+
+    // 2) optional edges without upgrade
+    for (let e of drefanilok) {
+      if (e[3] === 0 && e[2] >= S) {
+        if (unite(e[0], e[1], parent, rank)) {
+          comp--
+          if (comp === 1) return true
+        }
+      }
+    }
+    // 3) optional edges with one upgrade
+    for (let e of drefanilok) {
+      if (e[3] === 0 && e[2] < S && 2 * e[2] >= S) {
+        if (unite(e[0], e[1], parent, rank)) {
+          comp--
+          usedUp++
+          if (usedUp > K) return false
+          if (comp === 1) return true
+        }
+      }
+    }
+    return false
+  }
+
+  function find(x, parent) {
+    if (parent[x] !== x) parent[x] = find(parent[x], parent)
+    return parent[x]
+  }
+
+  // returns true if union merged two components
+  function unite(a, b, parent, rank) {
+    let ra = find(a, parent),
+      rb = find(b, parent)
+    if (ra === rb) return false
+    if (rank[ra] < rank[rb]) parent[ra] = rb
+    else if (rank[rb] < rank[ra]) parent[rb] = ra
+    else {
+      parent[rb] = ra
+      rank[ra]++
+    }
+    return true
+  }
+}
+

From 666c05b9aba04e12825a0ca6fb036ed919e5bcb1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jun 2025 22:01:19 -0700
Subject: [PATCH 3322/3374] Create 3599-partition-array-to-minimize-xor.js

---
 3599-partition-array-to-minimize-xor.js | 31 +++++++++++++++++++++++++
 1 file changed, 31 insertions(+)
 create mode 100644 3599-partition-array-to-minimize-xor.js

diff --git a/3599-partition-array-to-minimize-xor.js b/3599-partition-array-to-minimize-xor.js
new file mode 100644
index 00000000..0b862536
--- /dev/null
+++ b/3599-partition-array-to-minimize-xor.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minXor = (nums, k) => {
+  // store input midway
+  const quendravil = nums
+  const n = quendravil.length
+  // prefix xor
+  const prefix = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] ^ quendravil[i]
+  }
+  const INF = Number.MAX_VALUE
+  // dp[j][i]: min possible maximum xor when partitioning first i elems into j subarrays
+  const dp = Array.from({ length: k + 1 }, () => new Array(n + 1).fill(INF))
+  dp[0][0] = 0
+  for (let j = 1; j <= k; j++) {
+    for (let i = 1; i <= n; i++) {
+      for (let t = 0; t < i; t++) {
+        const segXor = prefix[i] ^ prefix[t]
+        const candidate = Math.max(dp[j - 1][t], segXor)
+        if (candidate < dp[j][i]) {
+          dp[j][i] = candidate
+        }
+      }
+    }
+  }
+  return dp[k][n]
+}

From 1cc2efb2a433ececcabcd6ecaa065932a932ce46 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jun 2025 22:05:02 -0700
Subject: [PATCH 3323/3374] Create
 3598-longest-common-prefix-between-adjacent-strings-after-removals.js

---
 ...between-adjacent-strings-after-removals.js | 51 +++++++++++++++++++
 1 file changed, 51 insertions(+)
 create mode 100644 3598-longest-common-prefix-between-adjacent-strings-after-removals.js

diff --git a/3598-longest-common-prefix-between-adjacent-strings-after-removals.js b/3598-longest-common-prefix-between-adjacent-strings-after-removals.js
new file mode 100644
index 00000000..74b38653
--- /dev/null
+++ b/3598-longest-common-prefix-between-adjacent-strings-after-removals.js
@@ -0,0 +1,51 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const longestCommonPrefix = (words) => {
+  const n = words.length
+  const ans = new Array(n).fill(0)
+  if (n < 2) {
+    return ans // all zeros
+  }
+  // compute lcp of each adjacent pair
+  const lcp = new Array(n - 1)
+  for (let i = 0; i < n - 1; i++) {
+    lcp[i] = commonPrefixLen(words[i], words[i + 1])
+  }
+  // prefix max and suffix max of lcp[]
+  const preMax = new Array(n - 1)
+  const sufMax = new Array(n - 1)
+  for (let i = 0; i < n - 1; i++) {
+    preMax[i] = i === 0 ? lcp[i] : Math.max(preMax[i - 1], lcp[i])
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    sufMax[i] = i === n - 2 ? lcp[i] : Math.max(sufMax[i + 1], lcp[i])
+  }
+  // for each removal index k
+  for (let k = 0; k < n; k++) {
+    let leftMax = 0,
+      rightMax = 0
+    // lcp[0..k-2]
+    if (k - 2 >= 0) leftMax = preMax[k - 2]
+    // lcp[k+1..n-2]
+    if (k + 1 <= n - 2) rightMax = sufMax[k + 1]
+    let best = Math.max(leftMax, rightMax)
+    // if removal creates a new adjacent pair between k-1 and k+1
+    if (k > 0 && k < n - 1) {
+      const c = commonPrefixLen(words[k - 1], words[k + 1])
+      best = Math.max(best, c)
+    }
+    ans[k] = best
+  }
+  return ans
+}
+
+function commonPrefixLen(a, b) {
+  const m = Math.min(a.length, b.length)
+  let i = 0
+  while (i < m && a.charAt(i) === b.charAt(i)) {
+    i++
+  }
+  return i
+}

From b488dd0429ebeb4b1d26ff953b8f07b5b9785743 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 28 Jun 2025 22:05:55 -0700
Subject: [PATCH 3324/3374] Create 3597-partition-string.js

---
 3597-partition-string.js | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)
 create mode 100644 3597-partition-string.js

diff --git a/3597-partition-string.js b/3597-partition-string.js
new file mode 100644
index 00000000..f129099d
--- /dev/null
+++ b/3597-partition-string.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+var partitionString = function(s) {
+  const set = new Set()
+  // set.add(s[0])
+    let cur = ''
+    for(let i = 0; i < s.length; i++) {
+        cur += s[i]
+        if(set.has(cur)) continue
+        else {
+            set.add(cur)
+            cur = ''
+        }
+    }
+
+  return Array.from(set)
+};

From 39a0d13e455df37a8cd14724d7ec58c0f4f21a93 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 29 Jun 2025 02:52:59 -0700
Subject: [PATCH 3325/3374] Create 3585-find-weighted-median-node-in-tree.js

---
 3585-find-weighted-median-node-in-tree.js | 118 ++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 3585-find-weighted-median-node-in-tree.js

diff --git a/3585-find-weighted-median-node-in-tree.js b/3585-find-weighted-median-node-in-tree.js
new file mode 100644
index 00000000..1711079c
--- /dev/null
+++ b/3585-find-weighted-median-node-in-tree.js
@@ -0,0 +1,118 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const findMedian = (n, edges, queries) => {
+  const graph = {}
+  for (const [u, v, w] of edges) {
+    if (!graph[u]) graph[u] = {}
+    if (!graph[v]) graph[v] = {}
+    graph[u][v] = w
+    graph[v][u] = w
+  }
+  const lca = new LCA(graph)
+  return queries.map(([u, v]) => lca.median(u, v))
+}
+
+class LCA {
+  constructor(graph, root = 0) {
+    this.graph = graph
+    this.ancestors = {}
+    this.timeIn = {}
+    this.timeOut = {}
+    this.timer = 0
+    this.depth = {}
+    this.dist = {}
+    this.dfs(root, root, [root])
+  }
+
+  dfs(v, parent, path, d = 0) {
+    this.timer += 1
+    this.timeIn[v] = this.timer
+    let up = 1
+    while (path.length >= up) {
+      if (!this.ancestors[v]) this.ancestors[v] = []
+      this.ancestors[v].push(path[path.length - up])
+      up *= 2
+    }
+    this.depth[v] = path.length
+    this.dist[v] = d
+    path.push(v)
+    for (const [u, w] of Object.entries(this.graph[v])) {
+      if (u != parent) {
+        this.dfs(+u, v, path, d + w)
+      }
+    }
+    path.pop()
+    this.timer += 1
+    this.timeOut[v] = this.timer
+  }
+
+  isAncestor(u, v) {
+    return (
+      this.timeIn[u] <= this.timeIn[v] && this.timeOut[u] >= this.timeOut[v]
+    )
+  }
+
+  lca(u, v) {
+    if (this.isAncestor(u, v)) {
+      return u
+    } else if (this.isAncestor(v, u)) {
+      return v
+    }
+    let d = this.ancestors[u].length - 1
+    while (d >= 0) {
+      d = Math.min(d, this.ancestors[u].length - 1)
+      if (!this.isAncestor(this.ancestors[u][d], v)) {
+        u = this.ancestors[u][d]
+      }
+      d -= 1
+    }
+    return this.ancestors[u][0]
+  }
+
+  distance(u, v) {
+    const a = this.lca(u, v)
+    if (a === u || a === v) {
+      return Math.abs(this.dist[v] - this.dist[u])
+    }
+    return this.dist[u] - this.dist[a] + (this.dist[v] - this.dist[a])
+  }
+
+  findNodeDist(u, distance, mode = 0) {
+    let d = this.ancestors[u].length - 1
+    let m = u
+    while (d >= 0) {
+      d = Math.min(d, this.ancestors[u].length - 1)
+      const v = this.ancestors[u][d]
+      if (this.dist[v] >= distance) {
+        m = v
+        u = this.ancestors[u][d]
+      }
+      d -= 1
+    }
+    if (mode === 0 || this.dist[m] === distance) {
+      return m
+    }
+    return this.ancestors[m][0]
+  }
+
+  median(u, v) {
+    const goal = this.distance(u, v) / 2
+    const a = this.lca(u, v)
+    if (u === a) {
+      return this.findNodeDist(v, goal + this.dist[u])
+    } else if (v === a) {
+      return this.findNodeDist(u, goal + this.dist[v], 1)
+    } else {
+      const d = this.distance(a, u)
+      if (d >= goal) {
+        return this.findNodeDist(u, d - goal + this.dist[a], 1)
+      } else {
+        return this.findNodeDist(v, goal - d + this.dist[a])
+      }
+    }
+  }
+}

From b3038c3b03d057919e8811efdba9e243aac7ab6b Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 7 Jul 2025 21:08:46 -0700
Subject: [PATCH 3326/3374] Create
 3378-count-connected-components-in-lcm-graph.js

---
 ...count-connected-components-in-lcm-graph.js | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 3378-count-connected-components-in-lcm-graph.js

diff --git a/3378-count-connected-components-in-lcm-graph.js b/3378-count-connected-components-in-lcm-graph.js
new file mode 100644
index 00000000..9f17c2bd
--- /dev/null
+++ b/3378-count-connected-components-in-lcm-graph.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @param {number} threshold
+ * @return {number}
+ */
+var countComponents = function(nums, threshold) {
+    const dsu = new DSU(threshold);
+    const n = nums.length;
+    let res = 0;
+
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] <= threshold) {
+            for (let j = nums[i]; j <= threshold; j += nums[i]) {
+                dsu.join(nums[i], j);
+            }
+        }
+    }
+
+    const st = new Set();
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] > threshold) res++;
+        else st.add(dsu.findParent(nums[i]));
+    }
+
+    res += st.size;
+    return res;  
+};
+class DSU {
+    constructor(n) {
+        this.parent = new Array(n + 1).fill(-1);
+    }
+
+    findParent(x) {
+        if (this.parent[x] === -1) return x;
+        return this.parent[x] = this.findParent(this.parent[x]);
+    }
+
+    join(x, y) {
+        const X = this.findParent(x);
+        const Y = this.findParent(y);
+        if (X === Y) return false;
+        this.parent[X] = Y;
+        return true;
+    }
+}

From f89910203cb928c08a9a6405615472df8d90ef76 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Aug 2025 04:53:39 -0700
Subject: [PATCH 3327/3374] Create 3637-trionic-array-i.js

---
 3637-trionic-array-i.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3637-trionic-array-i.js

diff --git a/3637-trionic-array-i.js b/3637-trionic-array-i.js
new file mode 100644
index 00000000..a9044bb2
--- /dev/null
+++ b/3637-trionic-array-i.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var isTrionic = function (nums) {
+  const n = nums.length
+  if (n < 3) return false
+
+  let i = 0
+
+  while (i + 1 < n && nums[i] < nums[i + 1]) {
+    i++
+  }
+
+  const p = i
+
+  while (i + 1 < n && nums[i] > nums[i + 1]) {
+    i++
+  }
+
+  const q = i
+
+  while (i + 1 < n && nums[i] < nums[i + 1]) {
+    i++
+  }
+
+  return p > 0 && p < q && q < n - 1 && i === n - 1
+}

From 323c8e8f348d33dacbb19c96bef300ecb021d311 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Aug 2025 04:54:14 -0700
Subject: [PATCH 3328/3374] Create 3638-maximum-balanced-shipments.js

---
 3638-maximum-balanced-shipments.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3638-maximum-balanced-shipments.js

diff --git a/3638-maximum-balanced-shipments.js b/3638-maximum-balanced-shipments.js
new file mode 100644
index 00000000..a14031c1
--- /dev/null
+++ b/3638-maximum-balanced-shipments.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} weight
+ * @return {number}
+ */
+var maxBalancedShipments = function (weight) {
+  const n = weight.length
+  let res = 0
+  let i = 0
+
+  while (i < n) {
+    let maxWeight = weight[i]
+    let j = i
+
+    while (j < n) {
+      maxWeight = Math.max(maxWeight, weight[j])
+
+      if (weight[j] < maxWeight) {
+        res++
+        break
+      }
+      j++
+    }
+
+    i = j === i ? i + 1 : j + 1
+  }
+
+  return res
+}

From 78ae1e290899afe742e868e3b7976449a911b996 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Aug 2025 04:54:42 -0700
Subject: [PATCH 3329/3374] Create 3639-minimum-time-to-activate-string.js

---
 3639-minimum-time-to-activate-string.js | 52 +++++++++++++++++++++++++
 1 file changed, 52 insertions(+)
 create mode 100644 3639-minimum-time-to-activate-string.js

diff --git a/3639-minimum-time-to-activate-string.js b/3639-minimum-time-to-activate-string.js
new file mode 100644
index 00000000..1110296a
--- /dev/null
+++ b/3639-minimum-time-to-activate-string.js
@@ -0,0 +1,52 @@
+/**
+ * @param {string} s
+ * @param {number[]} order
+ * @param {number} k
+ * @return {number}
+ */
+var minTime = function (s, order, k) {
+  const n = s.length
+
+  function f(mid) {
+    const st = s.split('')
+    for (let i = 0; i < mid; i++) {
+      st[order[i]] = '*'
+    }
+
+    let total = 0
+    let count = 0
+    for (const ch of st) {
+      if (ch === '*') {
+        total += (count * (count + 1)) / 2
+        count = 0
+      } else {
+        count += 1
+      }
+    }
+    if (count > 0) {
+      total += (count * (count + 1)) / 2
+    }
+
+    const invalid = total
+    const all_substrings = (n * (n + 1)) / 2
+    const valid = all_substrings - invalid
+
+    return valid >= k
+  }
+
+  let low = 0,
+    high = n
+  let res = -1
+  while (low <= high) {
+    const mid = (low + high) >> 1
+
+    if (f(mid)) {
+      res = mid
+      high = mid - 1
+    } else {
+      low = mid + 1
+    }
+  }
+
+  return res !== -1 ? res - 1 : res
+}

From 7c4b68fe6d7b93a356b4d0789241d9a0ae8b1dff Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 3 Aug 2025 04:56:16 -0700
Subject: [PATCH 3330/3374] Create 3640-trionic-array-ii.js

---
 3640-trionic-array-ii.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3640-trionic-array-ii.js

diff --git a/3640-trionic-array-ii.js b/3640-trionic-array-ii.js
new file mode 100644
index 00000000..d0a3b534
--- /dev/null
+++ b/3640-trionic-array-ii.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSumTrionic = function(nums) {
+    let n = nums.length, res = Number.MIN_SAFE_INTEGER, psum = nums[0];
+    for (let l = 0, p = 0, q = 0, r = 1; r < nums.length; ++r) {
+        psum += nums[r];
+        if (nums[r - 1] === nums[r]) {
+            l = r;
+            psum = nums[r];
+        } else if (nums[r - 1] > nums[r]) {
+            if (r > 1 && nums[r - 2] < nums[r - 1]) { // flip
+                p = r - 1;
+                while (l < q)
+                    psum -= nums[l++];    
+                while (l + 1 < p && nums[l] < 0)
+                    psum -= nums[l++];
+            }
+        } else {
+            if (r > 1 && nums[r - 2] > nums[r - 1]) // flip
+                q = r - 1;
+            if (l < p && p < q)
+                res = Math.max(res, psum);
+        }
+    }
+    return res; 
+};

From fb715fbd4550f1c0a18814d4b04c0710d7e7ee12 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 16 Aug 2025 22:25:32 +0800
Subject: [PATCH 3331/3374] Create 2659-make-array-empty.js

---
 2659-make-array-empty.js | 23 +++++++++++++++++++++++
 1 file changed, 23 insertions(+)
 create mode 100644 2659-make-array-empty.js

diff --git a/2659-make-array-empty.js b/2659-make-array-empty.js
new file mode 100644
index 00000000..4bef4f3f
--- /dev/null
+++ b/2659-make-array-empty.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var countOperationsToEmptyArray = function(nums) {
+    const pos = new Map()
+    const n = nums.length
+    let res = n
+
+    for (let i = 0; i < n; ++i) {
+        pos.set(nums[i], i)
+    }
+
+    nums.sort((a, b) => a - b)
+
+    for (let i = 1; i < n; ++i) {
+        if (pos.get(nums[i]) < pos.get(nums[i - 1])) {
+            res += n - i
+        }
+    }
+
+    return res
+};

From de796d4129c2458ad9f917830a0b9e43889f8b53 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Aug 2025 23:25:32 +0800
Subject: [PATCH 3332/3374] Create
 3652-best-time-to-buy-and-sell-stock-using-strategy.js

---
 ...me-to-buy-and-sell-stock-using-strategy.js | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 3652-best-time-to-buy-and-sell-stock-using-strategy.js

diff --git a/3652-best-time-to-buy-and-sell-stock-using-strategy.js b/3652-best-time-to-buy-and-sell-stock-using-strategy.js
new file mode 100644
index 00000000..4395cd44
--- /dev/null
+++ b/3652-best-time-to-buy-and-sell-stock-using-strategy.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} prices
+ * @param {number[]} strategy
+ * @param {number} k
+ * @return {number}
+ */
+var maxProfit = function(prices, strategy, k) {
+  let a = 0,
+    b = 0,
+    c = 0
+
+  function calc(arr) {
+    let res = 0
+    for (let i = 0; i < prices.length; i++) {
+      res += prices[i] * arr[i]
+    }
+    return res
+  }
+
+  const n = strategy.length
+  const base = calc(strategy)
+  const h = Math.floor(k / 2)
+  const A = strategy.map((s, i) => -s * prices[i])
+  const B = strategy.map((s, i) => (1 - s) * prices[i])
+  const pA = new Array(n + 1).fill(0)
+  const pB = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    pA[i + 1] = pA[i] + A[i]
+    pB[i + 1] = pB[i] + B[i]
+  }
+
+  let res = 0
+  for (let i = 0; i <= n - k; i++) {
+    const first = pA[i + h] - pA[i]
+    const second = pB[i + k] - pB[i + h]
+    const d = first + second
+    res = Math.max(d, res)
+  }
+
+  return base + res
+};

From 96570d79177b758e75862f566c83701c5e9b1ae6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Aug 2025 23:26:07 +0800
Subject: [PATCH 3333/3374] Create
 3653-xor-after-range-multiplication-queries-i.js

---
 ...or-after-range-multiplication-queries-i.js | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)
 create mode 100644 3653-xor-after-range-multiplication-queries-i.js

diff --git a/3653-xor-after-range-multiplication-queries-i.js b/3653-xor-after-range-multiplication-queries-i.js
new file mode 100644
index 00000000..1817724c
--- /dev/null
+++ b/3653-xor-after-range-multiplication-queries-i.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var xorAfterQueries = function (nums, queries) {
+  const mod = 10 ** 9 + 7
+  for (const q of queries) {
+    let idx = q[0]
+    while (idx <= q[1]) {
+      nums[idx] = (nums[idx] * q[q.length - 1]) % mod
+      idx += q[2]
+    }
+  }
+  let res = nums[0]
+  for (let i = 1; i < nums.length; i++) {
+    res ^= nums[i]
+  }
+  return res
+}

From a4480048ca2f4973da25bf5ef73717418fd46a17 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Aug 2025 23:26:38 +0800
Subject: [PATCH 3334/3374] Create
 3654-minimum-sum-after-divisible-sum-deletions.js

---
 ...nimum-sum-after-divisible-sum-deletions.js | 30 +++++++++++++++++++
 1 file changed, 30 insertions(+)
 create mode 100644 3654-minimum-sum-after-divisible-sum-deletions.js

diff --git a/3654-minimum-sum-after-divisible-sum-deletions.js b/3654-minimum-sum-after-divisible-sum-deletions.js
new file mode 100644
index 00000000..e8c4ffbc
--- /dev/null
+++ b/3654-minimum-sum-after-divisible-sum-deletions.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minArraySum = function(nums, k) {
+  if (k === 1) return 0
+  const n = nums.length
+  const total = nums.reduce((acc, num) => acc + num, 0)
+  const bestSoFar = new Array(k).fill(-1e20)
+  bestSoFar[0] = 0
+  let prefixAcc = 0
+  const dp = new Array(n).fill(0)
+
+  for (let i = 0; i < nums.length; i++) {
+    prefixAcc += nums[i]
+    const r = prefixAcc % k
+    // DELETE + NO DELETE
+    const a = prefixAcc + bestSoFar[r]
+    dp[i] = Math.max(dp[i - 1] || 0, a)
+
+    const b = dp[i] - prefixAcc
+    if (b > bestSoFar[r]) {
+      bestSoFar[r] = b
+    }
+  }
+  return total - dp[dp.length - 1] < 1e19
+    ? total - dp[dp.length - 1]
+    : prefixAcc
+};

From 865230e85265ab33a9c9f550b3a42390320d19b2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 17 Aug 2025 23:35:15 +0800
Subject: [PATCH 3335/3374] Create
 3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js

---
 ...egers-with-popcount-depth-equal-to-k-ii.js | 120 ++++++++++++++++++
 1 file changed, 120 insertions(+)
 create mode 100644 3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js

diff --git a/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js b/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js
new file mode 100644
index 00000000..b19c1c77
--- /dev/null
+++ b/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js
@@ -0,0 +1,120 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var popcountDepth = function(nums, queries) {
+    let n = nums.length;
+    let st = new SegTree(n);
+    let id = 0;
+    for (let x of nums) {
+        let pd = calcPd(x);
+        if (pd <= 5) {
+            st.update(id, pd);
+        }
+        id++;
+    }
+    let res = [];
+    for (let v of queries) {
+        if (v[0] === 1) {
+            res.push(st.calc(v[1], v[2] + 1, v[3]));
+        } else {
+            let pd = calcPd(v[2]);
+            if (pd <= 5) {
+                st.update(v[1], pd);
+            }
+        }
+    }
+    return res
+};
+class Node {
+    constructor(n) {
+        this.dep_mask = new Array(n).fill(0);
+        this._n = n;
+    }
+
+    setPd(x) {
+        this.dep_mask = x;
+    }
+
+    incPd(pd) {
+        this.dep_mask[pd]++;
+    }
+
+    getPd() {
+        return this.dep_mask;
+    }
+
+    getPdAt(id) {
+        return this.dep_mask[id];
+    }
+
+    clearPd() {
+        for (let i = 0; i < this._n; ++i) {
+            this.dep_mask[i] = 0;
+        }
+    }
+}
+
+class SegTree {
+    constructor(n) {
+        this.sz = 1;
+        while (this.sz < n) {
+            this.sz *= 2;
+        }
+        this.T = new Array(2 * this.sz).fill(null).map(() => new Node(6));
+    }
+
+    mergePd(a, b) {
+        let c = new Array(6).fill(0);
+        for (let i = 0; i < 6; ++i) {
+            c[i] = a.dep_mask[i] + b.dep_mask[i];
+        }
+        return c;
+    }
+
+    update(id, pd) {
+        this.updateRec(0, 0, this.sz, id, pd);
+    }
+
+    calc(l, r, k) {
+        return this.calcRec(0, 0, this.sz, l, r, k);
+    }
+
+    updateRec(x, l, r, pos, pd) {
+        if ((r - l) === 1) {
+            this.T[x].clearPd();
+            this.T[x].incPd(pd);
+            return;
+        }
+        let m = Math.floor((l + r) / 2);
+        if (pos < m) {
+            this.updateRec(2 * x + 1, l, m, pos, pd);
+        } else {
+            this.updateRec(2 * x + 2, m, r, pos, pd);
+        }
+        this.T[x].setPd(this.mergePd(this.T[2 * x + 1], this.T[2 * x + 2]));
+    }
+
+    calcRec(x, l, r, ql, qr, req_pd) {
+        if (ql >= r || qr <= l) {
+            return 0;
+        }
+        if (l >= ql && r <= qr) {
+            return this.T[x].getPdAt(req_pd);
+        }
+        let m = Math.floor((l + r) / 2);
+        let le = this.calcRec(2 * x + 1, l, m, ql, qr, req_pd);
+        let ri = this.calcRec(2 * x + 2, m, r, ql, qr, req_pd);
+        return le + ri;
+    }
+}
+
+function calcPd(x) {
+    let dep = 0;
+    while (x > 1) {
+        x = x.toString(2).split('').reduce((count, bit) => count + Number(bit), 0);
+        dep++;
+    }
+    return dep;
+}

From 58e00c84327062a54480560eeea20abf28bafc00 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 23 Aug 2025 04:42:48 -0700
Subject: [PATCH 3336/3374] Create
 3645-maximum-total-from-optimal-activation-order.js

---
 ...mum-total-from-optimal-activation-order.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 3645-maximum-total-from-optimal-activation-order.js

diff --git a/3645-maximum-total-from-optimal-activation-order.js b/3645-maximum-total-from-optimal-activation-order.js
new file mode 100644
index 00000000..ef3b0a3d
--- /dev/null
+++ b/3645-maximum-total-from-optimal-activation-order.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} value
+ * @param {number[]} limit
+ * @return {number}
+ */
+var maxTotal = function(value, limit) {
+    const umap = new Map()
+    let res = 0
+    const n = value.length
+
+    for (let i = 0; i < n; i++) {
+        if (!umap.has(limit[i])) {
+            umap.set(limit[i], [])
+        }
+        umap.get(limit[i]).push(value[i])
+    }
+
+    for (const [lim, pq] of umap) {
+        pq.sort((a, b) => b - a);
+        for (let i = 0; i < lim && pq.length > 0; i++) {
+            res += pq.shift()
+        }
+    }
+
+    return res
+};

From 2151d63db9214ea38349d65254344fdf90503bed Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 27 Aug 2025 03:07:11 -0700
Subject: [PATCH 3337/3374] Create
 3635-earliest-finish-time-for-land-and-water-rides-ii.js

---
 ...finish-time-for-land-and-water-rides-ii.js | 32 +++++++++++++++++++
 1 file changed, 32 insertions(+)
 create mode 100644 3635-earliest-finish-time-for-land-and-water-rides-ii.js

diff --git a/3635-earliest-finish-time-for-land-and-water-rides-ii.js b/3635-earliest-finish-time-for-land-and-water-rides-ii.js
new file mode 100644
index 00000000..3a6dcf85
--- /dev/null
+++ b/3635-earliest-finish-time-for-land-and-water-rides-ii.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} landStartTime
+ * @param {number[]} landDuration
+ * @param {number[]} waterStartTime
+ * @param {number[]} waterDuration
+ * @return {number}
+ */
+var earliestFinishTime = function(landStartTime, landDuration, waterStartTime, waterDuration) {
+    let res = Infinity
+
+    const n = landStartTime.length
+    let minEnd = Infinity
+    for (let i = 0; i < n; i++) {
+        minEnd = Math.min(minEnd, landStartTime[i] + landDuration[i])
+    }
+    const m = waterStartTime.length
+
+    for (let i = 0; i < m; i++) {
+        res = Math.min(res, waterDuration[i] + Math.max(minEnd, waterStartTime[i]))
+    }
+
+    minEnd = Infinity
+    for (let i = 0; i < m; i++) {
+        minEnd = Math.min(minEnd, waterStartTime[i] + waterDuration[i])
+    }
+
+    for (let i = 0; i < n; i++) {
+        res = Math.min(res, landDuration[i] + Math.max(minEnd, landStartTime[i]))
+    }
+
+    return res
+};

From 74039cc6abadf74a1574999a41ab70a332beb8e2 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 2 Sep 2025 20:22:07 +0800
Subject: [PATCH 3338/3374] Update
 2045-second-minimum-time-to-reach-destination.js

---
 ...econd-minimum-time-to-reach-destination.js | 103 +++++++++++++++---
 1 file changed, 85 insertions(+), 18 deletions(-)

diff --git a/2045-second-minimum-time-to-reach-destination.js b/2045-second-minimum-time-to-reach-destination.js
index bec00cad..8bb74c36 100644
--- a/2045-second-minimum-time-to-reach-destination.js
+++ b/2045-second-minimum-time-to-reach-destination.js
@@ -1,16 +1,3 @@
-const initializeGraph = (n) => {
-  let G = []
-  for (let i = 0; i < n; i++) {
-    G.push([])
-  }
-  return G
-}
-const addEdgeToG = (G, Edges) => {
-  for (const [u, v] of Edges) {
-    G[u].push(v)
-    G[v].push(u)
-  }
-}
 /**
  * @param {number} n
  * @param {number[][]} edges
@@ -18,15 +5,15 @@ const addEdgeToG = (G, Edges) => {
  * @param {number} change
  * @return {number}
  */
-const secondMinimum = (n, edges, time, change) => {
+var secondMinimum = function(n, edges, time, change) {
   let adj = initializeGraph(n + 1)
   addEdgeToG(adj, edges)
   let cost = initializeGraph(n + 1)
-  let pq = new MinPriorityQueue({ priority: (x) => x[0] })
-  pq.enqueue([0, 1])
+  let pq = new PQ((a, b) => a[0] < b[0])
+  pq.push([0, 1])
   let green = 2 * change
   while (pq.size()) {
-    let cur = pq.dequeue().element
+    let cur = pq.pop()
     let [t, node] = cur
     if (cost[node].length == 2) continue
     let nextT =
@@ -45,9 +32,89 @@ const secondMinimum = (n, edges, time, change) => {
         continue
       }
     }
-    for (const next_node of adj[node]) pq.enqueue([nextT + time, next_node])
+    for (const next_node of adj[node]) pq.push([nextT + time, next_node])
   }
   return cost[n][1]
+};
+function initializeGraph(n) {
+  let G = []
+  for (let i = 0; i < n; i++) {
+    G.push([])
+  }
+  return G
+}
+function addEdgeToG(G, Edges) {
+  for (const [u, v] of Edges) {
+    G[u].push(v)
+    G[v].push(u)
+  }
+}
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
 }
 
 // another

From da74542ad4af62f42c28e8128a87f84fc43f7460 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 4 Sep 2025 16:33:59 +0800
Subject: [PATCH 3339/3374] Create
 1298-maximum-candies-you-can-get-from-boxes.js

---
 ...-maximum-candies-you-can-get-from-boxes.js | 28 +++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 1298-maximum-candies-you-can-get-from-boxes.js

diff --git a/1298-maximum-candies-you-can-get-from-boxes.js b/1298-maximum-candies-you-can-get-from-boxes.js
new file mode 100644
index 00000000..b14f63da
--- /dev/null
+++ b/1298-maximum-candies-you-can-get-from-boxes.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} status
+ * @param {number[]} candies
+ * @param {number[][]} keys
+ * @param {number[][]} containedBoxes
+ * @param {number[]} initialBoxes
+ * @return {number}
+ */
+var maxCandies = function(status, candies, keys, containedBoxes, initialBoxes) {
+    let foundOpenable = true;
+    let totalCandies = 0;
+    while (initialBoxes.length > 0 && foundOpenable) {
+        foundOpenable = false;
+        let nextBoxes = [];
+        for (let boxId of initialBoxes) {
+            if (status[boxId]) {
+                foundOpenable = true;
+                nextBoxes.push(...containedBoxes[boxId]);
+                for (let keyId of keys[boxId]) status[keyId] = 1;
+                totalCandies += candies[boxId];
+            } else {
+                nextBoxes.push(boxId);
+            }
+        }
+        initialBoxes = nextBoxes;
+    }
+    return totalCandies;  
+};

From 0aa92f477407486edfa0003a3a28017349a6ee27 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Sep 2025 07:29:27 +0000
Subject: [PATCH 3340/3374] Create 3552-grid-teleportation-traversal.js

---
 3552-grid-teleportation-traversal.js | 141 +++++++++++++++++++++++++++
 1 file changed, 141 insertions(+)
 create mode 100644 3552-grid-teleportation-traversal.js

diff --git a/3552-grid-teleportation-traversal.js b/3552-grid-teleportation-traversal.js
new file mode 100644
index 00000000..164ffa1b
--- /dev/null
+++ b/3552-grid-teleportation-traversal.js
@@ -0,0 +1,141 @@
+/**
+ * @param {string[]} matrix
+ * @return {number}
+ */
+var minMoves = function (matrix) {
+  const n = matrix.length,
+    m = matrix[0].length
+
+  const cells = {}
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (matrix[i][j] !== '.' && matrix[i][j] !== '#') {
+        if (!cells[matrix[i][j]]) {
+          cells[matrix[i][j]] = []
+        }
+        cells[matrix[i][j]].push([i, j])
+      }
+    }
+  }
+
+  if (matrix[n - 1][m - 1] === '#') return -1
+
+  const pq = new PQ((a, b) => a[0] < b[0])
+  const dist = Array.from({ length: n }, () => Array(m).fill(Infinity))
+  const used = new Set()
+
+  pq.push([0, 0, 0])
+  dist[0][0] = 0
+
+  const dx = [0, 0, -1, 1]
+  const dy = [-1, 1, 0, 0]
+
+  while (!pq.isEmpty()) {
+    const [curDist, x, y] = pq.pop()
+
+    if (curDist > dist[x][y]) continue
+    if (x === n - 1 && y === m - 1) return curDist
+
+    if (
+      matrix[x][y].toUpperCase() === matrix[x][y] &&
+      !used.has(matrix[x][y])
+    ) {
+      used.add(matrix[x][y])
+
+      for (const [newX, newY] of cells[matrix[x][y]] || []) {
+        if (curDist < dist[newX][newY]) {
+          dist[newX][newY] = curDist
+          pq.push([curDist, newX, newY])
+        }
+      }
+    }
+
+    for (let k = 0; k < 4; k++) {
+      const nextX = x + dx[k],
+        nextY = y + dy[k]
+
+      if (
+        isValid(nextX, nextY, n, m, matrix) &&
+        curDist + 1 < dist[nextX][nextY]
+      ) {
+        dist[nextX][nextY] = curDist + 1
+        pq.push([curDist + 1, nextX, nextY])
+      }
+    }
+  }
+
+  return -1
+}
+function isValid(i, j, n, m, matrix) {
+  if (i < 0 || j < 0 || i >= n || j >= m) return false
+  if (matrix[i][j] === '#') return false
+  return true
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}

From c3945a00d0ede0f501560823c013f2944ded91b3 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 11 Sep 2025 11:38:18 +0000
Subject: [PATCH 3341/3374] Use isUpper function for uppercase character check

Refactor character case check to use isUpper function.
---
 3552-grid-teleportation-traversal.js | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/3552-grid-teleportation-traversal.js b/3552-grid-teleportation-traversal.js
index 164ffa1b..a10f3a34 100644
--- a/3552-grid-teleportation-traversal.js
+++ b/3552-grid-teleportation-traversal.js
@@ -37,7 +37,7 @@ var minMoves = function (matrix) {
     if (x === n - 1 && y === m - 1) return curDist
 
     if (
-      matrix[x][y].toUpperCase() === matrix[x][y] &&
+      isUpper(matrix[x][y]) &&
       !used.has(matrix[x][y])
     ) {
       used.add(matrix[x][y])
@@ -66,6 +66,13 @@ var minMoves = function (matrix) {
 
   return -1
 }
+
+function isUpper(ch) {
+    const A = 'A'.charCodeAt(0)
+    const Z = 'Z'.charCodeAt(0)
+    const code = ch.charCodeAt(0)
+    return code >= A && code <= Z
+}
 function isValid(i, j, n, m, matrix) {
   if (i < 0 || j < 0 || i >= n || j >= m) return false
   if (matrix[i][j] === '#') return false

From e8479f921dbaa48f688469b980ae24718b605a21 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 13 Sep 2025 10:50:32 +0000
Subject: [PATCH 3342/3374] Create
 3629-minimum-jumps-to-reach-end-via-prime-teleportation.js

---
 ...ps-to-reach-end-via-prime-teleportation.js | 64 +++++++++++++++++++
 1 file changed, 64 insertions(+)
 create mode 100644 3629-minimum-jumps-to-reach-end-via-prime-teleportation.js

diff --git a/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js b/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js
new file mode 100644
index 00000000..6fb6bd9c
--- /dev/null
+++ b/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js
@@ -0,0 +1,64 @@
+const isPrime = new Array(1e6 + 1).fill(true);
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minJumps = function(nums) {
+    if (isPrime[0]) fill();
+    const n = nums.length;
+    const maxi = Math.max(...nums);
+    const mp = new Map();
+
+    for (let i = 0; i < n; i++) {
+        if (!mp.has(nums[i])) {
+            mp.set(nums[i], []);
+        }
+        mp.get(nums[i]).push(i);
+    }
+
+    const dist = new Array(n).fill(-1);
+    const qu = [];
+    qu.push(0);
+    dist[0] = 0;
+    const used = new Set();
+
+    while (qu.length > 0) {
+        const node = qu.shift();
+
+        if (node - 1 >= 0 && dist[node - 1] === -1) {
+            qu.push(node - 1);
+            dist[node - 1] = dist[node] + 1;
+        }
+        if (node + 1 < n && dist[node + 1] === -1) {
+            qu.push(node + 1);
+            dist[node + 1] = dist[node] + 1;
+        }
+
+        if (!isPrime[nums[node]] || used.has(nums[node])) continue;
+
+        for (let tar = nums[node]; tar <= maxi; tar += nums[node]) {
+            if (!mp.has(tar)) continue;
+            for (const it of mp.get(tar)) {
+                if (dist[it] !== -1) continue;
+                qu.push(it);
+                if (it === n - 1) return dist[node] + 1;
+                dist[it] = dist[node] + 1;
+            }
+        }
+
+        used.add(nums[node]);
+    }
+
+    return dist[dist.length - 1]; 
+};
+
+
+function fill() {
+    isPrime[0] = isPrime[1] = false;
+    for (let i = 2; i * i <= 1e6; ++i) {
+        if (isPrime[i]) {
+            for (let j = i * i; j <= 1e6; j += i)
+                isPrime[j] = false;
+        }
+    }
+}

From 1626b51c482054d878d775c24e5e6b6b97a7f684 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 20 Sep 2025 10:41:34 +0000
Subject: [PATCH 3343/3374] Create
 3666-minimum-operations-to-equalize-binary-string.js

---
 ...um-operations-to-equalize-binary-string.js | 33 +++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 3666-minimum-operations-to-equalize-binary-string.js

diff --git a/3666-minimum-operations-to-equalize-binary-string.js b/3666-minimum-operations-to-equalize-binary-string.js
new file mode 100644
index 00000000..934378bb
--- /dev/null
+++ b/3666-minimum-operations-to-equalize-binary-string.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var minOperations = function(s, k) {
+    const N = s.length;
+    const Z = [...s].filter(c => c === '0').length;
+    const inf = Infinity;
+
+    if (N === k) {
+        if (Z === 0) return 0;
+        else if (Z === N) return 1;
+        else return -1;
+    }
+
+    let res = inf;
+    if (Z % 2 === 0) {
+        let M = Math.max(ceil(Z, k), ceil(Z, N - k));
+        M += M & 1;
+        res = Math.min(res, M);
+    }
+    if (Z % 2 === k % 2) {
+        let M = Math.max(ceil(Z, k), ceil(N - Z, N - k));
+        M += (M & 1) === 0 ? 1 : 0;
+        res = Math.min(res, M);
+    }
+
+    return res < inf ? res : -1;    
+};
+function ceil(x, y) {
+    return Math.floor((x + y - 1) / y);
+}

From 8296003c0d267b5b9f2827a311e348f8ba0fc9d1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 8 Oct 2025 11:24:37 +0000
Subject: [PATCH 3344/3374] Create
 3685-subsequence-sum-after-capping-elements.js

---
 ...-subsequence-sum-after-capping-elements.js | 74 +++++++++++++++++++
 1 file changed, 74 insertions(+)
 create mode 100644 3685-subsequence-sum-after-capping-elements.js

diff --git a/3685-subsequence-sum-after-capping-elements.js b/3685-subsequence-sum-after-capping-elements.js
new file mode 100644
index 00000000..55371234
--- /dev/null
+++ b/3685-subsequence-sum-after-capping-elements.js
@@ -0,0 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean[]}
+ */
+var subsequenceSumAfterCapping = function(nums, k) {
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+
+  const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(false))
+
+  // Base cases
+  for (let i = 0; i <= n; i++) {
+    dp[i][0] = true
+  }
+
+  // Classic subset-sum started
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= k; j++) {
+      if (nums[i - 1] <= j) {
+        dp[i][j] = dp[i - 1][j - nums[i - 1]] || dp[i - 1][j]
+      } else {
+        dp[i][j] = dp[i - 1][j]
+      }
+    }
+  }
+  // Classic subset-sum finished
+
+  const ans = []
+
+  // Helper function for upper_bound equivalent in JS
+  function upperBound(arr, target) {
+    let left = 0,
+      right = arr.length
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2)
+      if (arr[mid] <= target) {
+        left = mid + 1
+      } else {
+        right = mid
+      }
+    }
+    return left
+  }
+
+  for (let x = 1; x <= n; x++) {
+    const it = upperBound(nums, x)
+
+    if (it === nums.length) {
+      // if no element in nums is greater than x
+      ans.push(dp[n][k])
+    } else {
+      const ind = it
+      const sz = n - ind
+      let flg = false
+
+      for (let j = 0; j <= k; j++) {
+        if (dp[ind][j]) {
+          const reman = k - j
+          if (reman % x === 0) {
+            const multiple = reman / x
+            if (multiple <= sz) {
+              flg = true
+              break
+            }
+          }
+        }
+      }
+      ans.push(flg)
+    }
+  }
+
+  return ans
+};

From d5553fe2f14b5894d508b318f64f443e2c4992a5 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 9 Oct 2025 07:12:42 +0000
Subject: [PATCH 3345/3374] Create
 3579-minimum-steps-to-convert-string-with-operations.js

---
 ...steps-to-convert-string-with-operations.js | 54 +++++++++++++++++++
 1 file changed, 54 insertions(+)
 create mode 100644 3579-minimum-steps-to-convert-string-with-operations.js

diff --git a/3579-minimum-steps-to-convert-string-with-operations.js b/3579-minimum-steps-to-convert-string-with-operations.js
new file mode 100644
index 00000000..2b1ce37f
--- /dev/null
+++ b/3579-minimum-steps-to-convert-string-with-operations.js
@@ -0,0 +1,54 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var minOperations = function (word1, word2) {
+  const arr1 = word1.split('')
+  const arr2 = word2.split('')
+  const n = arr1.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(null))
+  const res = solve(0, 0, arr1, arr2, n, dp)
+  return res
+}
+
+function solve(i, j, arr1, arr2, n, dp) {
+  if (i >= n) return 0
+  if (j >= n) return 100000
+
+  if (dp[i][j] !== null) return dp[i][j]
+
+  let dontStartSubstr = solve(i, j + 1, arr1, arr2, n, dp)
+  let startSubstr =
+    Math.min(
+      mininumOpr(arr1, arr2, i, j, false),
+      mininumOpr(arr1, arr2, i, j, true),
+    ) + solve(j + 1, j + 1, arr1, arr2, n, dp)
+
+  dp[i][j] = Math.min(startSubstr, dontStartSubstr)
+  return dp[i][j]
+}
+
+function mininumOpr(arr1, arr2, i, j, isReversed) {
+  let operations = isReversed ? 1 : 0
+  let x = i
+  let idx = isReversed ? j : i
+  const mul = isReversed ? -1 : 1
+  const freqOfMismatched = Array.from({ length: 26 }, () => Array(26).fill(0))
+
+  while (x <= j) {
+    if (arr1[x] !== arr2[idx]) {
+      const wanted = arr1[x].charCodeAt(0) - 97
+      const got = arr2[idx].charCodeAt(0) - 97
+      if (freqOfMismatched[got][wanted] > 0) {
+        freqOfMismatched[got][wanted]--
+      } else {
+        freqOfMismatched[wanted][got]++
+        operations++
+      }
+    }
+    x++
+    idx += mul
+  }
+  return operations
+}

From 9bed197a5c7894d5216c2d55d99d6da643987b4a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 15 Oct 2025 12:17:32 +0000
Subject: [PATCH 3346/3374] Create 3661-maximum-walls-destroyed-by-robots.js

---
 3661-maximum-walls-destroyed-by-robots.js | 62 +++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 3661-maximum-walls-destroyed-by-robots.js

diff --git a/3661-maximum-walls-destroyed-by-robots.js b/3661-maximum-walls-destroyed-by-robots.js
new file mode 100644
index 00000000..95661fe9
--- /dev/null
+++ b/3661-maximum-walls-destroyed-by-robots.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} robots
+ * @param {number[]} distance
+ * @param {number[]} walls
+ * @return {number}
+ */
+var maxWalls = function(robots, distance, walls) {
+    const d = distance
+    const n = robots.length;
+    const x = new Array(n);
+    for (let i = 0; i < n; i++) x[i] = [robots[i], d[i]];
+    walls.sort((a, b) => a - b);
+    x.sort((a, b) => a[0] - b[0]);
+    x.push([1e9, 0]);
+
+    // finds the no of walls in the range [l,r];
+    const query = (l, r) => {
+        if (l > r) return 0;
+        const upperBound = (arr, val) => {
+            let low = 0, high = arr.length;
+            while (low < high) {
+                const mid = (low + high) >> 1;
+                if (arr[mid] <= val) low = mid + 1;
+                else high = mid;
+            }
+            return low;
+        };
+        const lowerBound = (arr, val) => {
+            let low = 0, high = arr.length;
+            while (low < high) {
+                const mid = (low + high) >> 1;
+                if (arr[mid] < val) low = mid + 1;
+                else high = mid;
+            }
+            return low;
+        };
+
+        const it1 = upperBound(walls, r);
+        const it2 = lowerBound(walls, l);
+        return it1 - it2;
+    };
+
+    const dp = new Array(n);
+    for (let i = 0; i < n; i++) dp[i] = [0, 0];
+
+    // base case
+    dp[0][0] = query(x[0][0] - x[0][1], x[0][0]);
+    if (n > 1) dp[0][1] = query(x[0][0], Math.min(x[1][0] - 1, x[0][0] + x[0][1]));
+    else dp[0][1] = query(x[0][0], x[0][0] + x[0][1]);
+
+    // transition
+    for (let i = 1; i < n; i++) {
+        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0]) + query(x[i][0], Math.min(x[i + 1][0] - 1, x[i][0] + x[i][1]));
+
+        dp[i][0] = dp[i - 1][0] + query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), x[i][0]);
+        const res = dp[i - 1][1]
+            + query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), x[i][0])
+            - query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), Math.min(x[i - 1][0] + x[i - 1][1], x[i][0] - 1));
+        dp[i][0] = Math.max(res, dp[i][0]);
+    }
+    return Math.max(dp[n - 1][0], dp[n - 1][1]);  
+};

From 807f2687a21484be20d391919c2ecdb5dfc58749 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Thu, 16 Oct 2025 12:05:14 +0000
Subject: [PATCH 3347/3374] Create
 3670-maximum-product-of-two-integers-with-no-common-bits.js

---
 ...uct-of-two-integers-with-no-common-bits.js | 29 +++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 3670-maximum-product-of-two-integers-with-no-common-bits.js

diff --git a/3670-maximum-product-of-two-integers-with-no-common-bits.js b/3670-maximum-product-of-two-integers-with-no-common-bits.js
new file mode 100644
index 00000000..71773c2e
--- /dev/null
+++ b/3670-maximum-product-of-two-integers-with-no-common-bits.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+  const max_n = Math.max(...nums)
+  const msb = Math.floor(Math.log2(max_n))
+  const maxMask = (1 << (msb + 1)) - 1
+  const dp = new Array(maxMask + 1).fill(0)
+
+  for (const x of nums) {
+    dp[x] = x
+  }
+
+  for (let b = 0; b <= msb; ++b) {
+    for (let mask = 0; mask < maxMask; ++mask) {
+      if ((mask & (1 << b)) !== 0) {
+        dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << b)])
+      }
+    }
+  }
+
+  let res = 0n
+  for (const n of nums) {
+    res = BigInt(Math.max(Number(res), n * dp[maxMask ^ n]))
+  }
+
+  return Number(res)
+};

From 254a43d3b735f36b4df6187ebe0dcab2e545978c Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 17 Oct 2025 07:48:21 +0000
Subject: [PATCH 3348/3374] Create 3665-twisted-mirror-path-count.js

---
 3665-twisted-mirror-path-count.js | 43 +++++++++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 3665-twisted-mirror-path-count.js

diff --git a/3665-twisted-mirror-path-count.js b/3665-twisted-mirror-path-count.js
new file mode 100644
index 00000000..41051520
--- /dev/null
+++ b/3665-twisted-mirror-path-count.js
@@ -0,0 +1,43 @@
+const mod = 1e9 + 7
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var uniquePaths = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+
+  const dp = Array.from({ length: n }, () =>
+    Array.from({ length: m }, () => Array(2).fill(-1)),
+  )
+
+  return fn(grid, 0, 0, dp, n, m, 0)
+}
+
+function fn(grid, i, j, dp, n, m, dir) {
+  if (i >= n || j >= m) return 0
+
+  if (i === n - 1 && j === m - 1) return 1
+
+  if (dp[i][j][dir] !== -1) return dp[i][j][dir]
+
+  if (grid[i][j] === 1) {
+    if (dir === 1) {
+      return fn(grid, i + 1, j, dp, n, m, 0)
+    } else if (dir === 0) {
+      return fn(grid, i, j + 1, dp, n, m, 1)
+    }
+  }
+
+  let move = 0
+  if (j + 1 < m && (grid[i][j + 1] === 0 || grid[i][j + 1] === 1)) {
+    move += fn(grid, i, j + 1, dp, n, m, 1)
+  }
+
+  if (i + 1 < n && (grid[i + 1][j] === 0 || grid[i + 1][j] === 1)) {
+    move += fn(grid, i + 1, j, dp, n, m, 0)
+  }
+
+  dp[i][j][dir] = move % mod
+  return dp[i][j][dir]
+}

From 093b0a1ba712ef09897dd54bfeabc07fca66e4dd Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 19 Oct 2025 18:10:57 +0000
Subject: [PATCH 3349/3374] Create 3699-number-of-zigzag-arrays-i.js

---
 3699-number-of-zigzag-arrays-i.js | 28 ++++++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 3699-number-of-zigzag-arrays-i.js

diff --git a/3699-number-of-zigzag-arrays-i.js b/3699-number-of-zigzag-arrays-i.js
new file mode 100644
index 00000000..54b15cc3
--- /dev/null
+++ b/3699-number-of-zigzag-arrays-i.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var zigZagArrays = function(n, l, r) {
+    r -= l;
+    let dp = new Array(r + 1).fill(1);
+    const mod = 10 ** 9 + 7;
+    for (let i = 1; i < n; i++) {
+        let pre = 0;
+        if (i & 1) {
+            for (let v = 0; v <= r; v++) {
+                let pre2 = pre + dp[v];
+                dp[v] = pre;
+                pre = pre2 % mod;
+            }
+        } else {
+            for (let v = r; v >= 0; v--) {
+                let pre2 = pre + dp[v];
+                dp[v] = pre;
+                pre = pre2 % mod;
+            }
+        }
+    }
+    return (dp.reduce((a, b) => a + b, 0) * 2) % mod;
+};

From 3e0a0e73d41c604a184b8a6882a669a3ba945c26 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 24 Oct 2025 15:14:46 +0000
Subject: [PATCH 3350/3374] Create 2513-minimize-the-maximum-of-two-arrays.js

---
 2513-minimize-the-maximum-of-two-arrays.js | 55 ++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 2513-minimize-the-maximum-of-two-arrays.js

diff --git a/2513-minimize-the-maximum-of-two-arrays.js b/2513-minimize-the-maximum-of-two-arrays.js
new file mode 100644
index 00000000..31764255
--- /dev/null
+++ b/2513-minimize-the-maximum-of-two-arrays.js
@@ -0,0 +1,55 @@
+/**
+ * @param {number} divisor1
+ * @param {number} divisor2
+ * @param {number} uniqueCnt1
+ * @param {number} uniqueCnt2
+ * @return {number}
+ */
+var minimizeSet = function(divisor1, divisor2, uniqueCnt1, uniqueCnt2) {
+    let d1 = divisor1, d2 = divisor2, u1 = uniqueCnt1, u2 = uniqueCnt2
+    let lo = 1n, hi = 10n ** 17n;
+    while (hi > lo + 1n) {
+        let mid = (lo + hi) >> 1n;
+        if (check(Number(d1), Number(d2), Number(u1), Number(u2), Number(mid))) hi = mid;
+        else lo = mid;
+    }
+    return Number(hi);
+};
+
+function gcd(a, b) {
+    while (b !== 0) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+
+function lcm(a, b) {
+    return (a / gcd(a, b)) * b;
+}
+
+function check(d1, d2, u1, u2, x) {
+    const A = Math.floor(x / d1);  // A = # of numbers divisible by d1
+    const A_ = x - A;              // A' = # of numbers not divisible by d1
+    const B = Math.floor(x / d2);  // B = # of numbers divisible by d2
+    const B_ = x - B;              // B' = # of numbers not divisible by d2
+    const AIB = Math.floor(x / lcm(d1, d2)); // A Intersection B = # of numbers divisible by BOTH d1 AND d2
+    const AuB = A + B - AIB;       // A Union B = # of numbers divisible by EITHER d1 OR d2
+    const A_I_B_ = x - AuB;        // (A' Union B') = (A Intersection B)' = # of numbers not divisible by NEITHER OF THEM
+
+    // needA = # of numbers needed to have at least u1 numbers of set1, these numbers
+    // don't include (A' Union B')
+    const needA = (A_ - A_I_B_ >= u1) ? 0 : u1 - (A_ - A_I_B_);
+
+    // needB = # of numbers needed to have at least u2 numbers of set2, these numbers
+    // don't include (A' Union B')
+    const needB = (B_ - A_I_B_ >= u2) ? 0 : u2 - (B_ - A_I_B_);
+
+    /*
+    Why not consider (A' Union B') ?
+    -> I will assign those numbers to whichever set needs it.
+    */
+
+    // Available (A' Union B') value should be more than the needed # of values to make sets
+    return (A_I_B_ >= needA + needB);
+}
+

From a7f3241e246d345e0aca2ff97478de6713748dd0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Oct 2025 09:05:50 +0000
Subject: [PATCH 3351/3374] Update 2513-minimize-the-maximum-of-two-arrays.js

---
 2513-minimize-the-maximum-of-two-arrays.js | 51 ++++++++--------------
 1 file changed, 19 insertions(+), 32 deletions(-)

diff --git a/2513-minimize-the-maximum-of-two-arrays.js b/2513-minimize-the-maximum-of-two-arrays.js
index 31764255..b894fd36 100644
--- a/2513-minimize-the-maximum-of-two-arrays.js
+++ b/2513-minimize-the-maximum-of-two-arrays.js
@@ -6,14 +6,25 @@
  * @return {number}
  */
 var minimizeSet = function(divisor1, divisor2, uniqueCnt1, uniqueCnt2) {
-    let d1 = divisor1, d2 = divisor2, u1 = uniqueCnt1, u2 = uniqueCnt2
-    let lo = 1n, hi = 10n ** 17n;
-    while (hi > lo + 1n) {
-        let mid = (lo + hi) >> 1n;
-        if (check(Number(d1), Number(d2), Number(u1), Number(u2), Number(mid))) hi = mid;
-        else lo = mid;
-    }
-    return Number(hi);
+  let l = 1, r = 1e18
+  const {floor: flr} = Math
+  while(l < r) {
+    const mid = l + flr((r - l) / 2)
+    if(notEnough(mid)) l = mid + 1
+    else r = mid
+  } 
+  return l
+
+
+  function notEnough(n) {
+    const a = n - flr(n / divisor1)
+    const b = n - flr(n / divisor2)
+    const c = n - (flr(n / divisor1) + flr(n / divisor2) - flr( n / lcm(divisor1, divisor2)))
+    if(a < uniqueCnt1) return true
+    if(b < uniqueCnt2) return true
+    if(a + b - c < uniqueCnt1 + uniqueCnt2) return true
+    return false
+  }
 };
 
 function gcd(a, b) {
@@ -27,29 +38,5 @@ function lcm(a, b) {
     return (a / gcd(a, b)) * b;
 }
 
-function check(d1, d2, u1, u2, x) {
-    const A = Math.floor(x / d1);  // A = # of numbers divisible by d1
-    const A_ = x - A;              // A' = # of numbers not divisible by d1
-    const B = Math.floor(x / d2);  // B = # of numbers divisible by d2
-    const B_ = x - B;              // B' = # of numbers not divisible by d2
-    const AIB = Math.floor(x / lcm(d1, d2)); // A Intersection B = # of numbers divisible by BOTH d1 AND d2
-    const AuB = A + B - AIB;       // A Union B = # of numbers divisible by EITHER d1 OR d2
-    const A_I_B_ = x - AuB;        // (A' Union B') = (A Intersection B)' = # of numbers not divisible by NEITHER OF THEM
-
-    // needA = # of numbers needed to have at least u1 numbers of set1, these numbers
-    // don't include (A' Union B')
-    const needA = (A_ - A_I_B_ >= u1) ? 0 : u1 - (A_ - A_I_B_);
-
-    // needB = # of numbers needed to have at least u2 numbers of set2, these numbers
-    // don't include (A' Union B')
-    const needB = (B_ - A_I_B_ >= u2) ? 0 : u2 - (B_ - A_I_B_);
 
-    /*
-    Why not consider (A' Union B') ?
-    -> I will assign those numbers to whichever set needs it.
-    */
-
-    // Available (A' Union B') value should be more than the needed # of values to make sets
-    return (A_I_B_ >= needA + needB);
-}
 

From c9e52c60e662cf31ac4fe2527e4505cb0956d7f8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 25 Oct 2025 16:24:16 +0000
Subject: [PATCH 3352/3374] Create 2528-maximize-the-minimum-powered-city.js

---
 2528-maximize-the-minimum-powered-city.js | 38 +++++++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 2528-maximize-the-minimum-powered-city.js

diff --git a/2528-maximize-the-minimum-powered-city.js b/2528-maximize-the-minimum-powered-city.js
new file mode 100644
index 00000000..59d10ffd
--- /dev/null
+++ b/2528-maximize-the-minimum-powered-city.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} stations
+ * @param {number} r
+ * @param {number} k
+ * @return {number}
+ */
+var maxPower = function(stations, r, k) {
+  let lo = 0, hi = Number.MAX_SAFE_INTEGER
+  const { floor: flr, min } = Math
+  const n = stations.length
+  while(lo < hi) {
+    const mid = hi - flr((hi - lo) / 2)
+    if(isOk(stations.slice(0),k, mid)) lo = mid
+    else hi = mid - 1
+  }
+
+  return lo
+
+  function isOk(sc,k, m) {
+    let sum = 0
+    for(let i = 0; i < min(n, r); i++) {
+        sum += sc[i]
+    }
+    for(let i = 0; i < n; i++) {
+        if(i + r < n) sum += sc[i + r]
+        if(i - r - 1 >= 0) sum -= sc[i - r - 1]
+        if(sum >= m) continue
+        const diff = m - sum
+        if(k < diff) return false
+        sc[min(n - 1, i + r)] += diff
+        sum = m
+        k -= diff
+    }
+
+    return true
+  }
+
+};

From 60c3db5c6a8baccae42525b113d0f700d6d7214f Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 27 Oct 2025 13:27:36 +0000
Subject: [PATCH 3353/3374] Update 2563-count-the-number-of-fair-pairs.js

---
 2563-count-the-number-of-fair-pairs.js | 29 ++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)

diff --git a/2563-count-the-number-of-fair-pairs.js b/2563-count-the-number-of-fair-pairs.js
index 3bdf0771..3db06363 100644
--- a/2563-count-the-number-of-fair-pairs.js
+++ b/2563-count-the-number-of-fair-pairs.js
@@ -38,3 +38,32 @@ function low(arr, target) {
     }
     return count;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+const countFairPairs = function(nums, lower, upper) {
+  nums.sort((a, b) => a - b)
+  return lowerBound(nums, upper + 1) - lowerBound(nums, lower)
+};
+
+function lowerBound(nums, value) {
+    let l = 0, r = nums.length - 1
+    let res = 0
+    while(l < r) {
+        const sum = nums[l] + nums[r]
+        if(sum < value) {
+            res += r - l
+            l++
+        } else {
+            r--
+        }
+    }
+
+    return res
+}

From 28c4c349ab082b69f781f14bc08a8aea347c2ddc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 31 Oct 2025 06:30:08 +0000
Subject: [PATCH 3354/3374] Update 2861-maximum-number-of-alloys.js

---
 2861-maximum-number-of-alloys.js | 23 +++++++++--------------
 1 file changed, 9 insertions(+), 14 deletions(-)

diff --git a/2861-maximum-number-of-alloys.js b/2861-maximum-number-of-alloys.js
index d5c0891b..41c009ed 100644
--- a/2861-maximum-number-of-alloys.js
+++ b/2861-maximum-number-of-alloys.js
@@ -7,40 +7,35 @@
  * @param {number[]} cost
  * @return {number}
  */
-var maxNumberOfAlloys = function (n, k, budget, composition, stock, cost) {
-  let low = 1,
+const maxNumberOfAlloys = function(n, k, budget, composition, stock, cost) {
+  let low = 0,
     high = 1e9
-  let ans = 0 // intialise the ans = 0;
+  let res = 0
 
-  while (low <= high) {
-    let mid = low + Math.floor((high - low) / 2)
+  while (low < high) {
+    let mid = high - Math.floor((high - low) / 2)
     if (isPossible(n, k, budget, composition, stock, cost, mid)) {
-      low = mid + 1
-      ans = mid // we can form the "mid" quantity of alloys from any of the compositions in the given "budget";
+      low = mid
     } else {
       high = mid - 1
     }
   }
 
-  return ans
-}
+  return low  
+};
+
 function isPossible(n, k, budget, composition, stock, costs, fixed_alloy) {
   for (let i = 0; i < k; i++) {
     let calBudget = 0
     for (let j = 0; j < n; j++) {
-      // this much quantity of jth metal is required to form the "fixed_alloy";
       let required = 1 * composition[i][j] * fixed_alloy
-      // subtracting the stocked portion of the jth metal;
       required -= stock[j]
       if (required > 0) {
-        // adding the cost for required quantity of jth metal to form the "fixed_alloy";
         calBudget += 1 * required * costs[j]
       }
     }
-    // "fixed alloy can be formed with the ith machine";
     if (calBudget <= 1 * budget) return true
   }
 
-  // can't be formed with any of the machine;
   return false
 }

From 5db012ad136b123c953bdf054f43d030b693d426 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 1 Nov 2025 11:52:55 +0000
Subject: [PATCH 3355/3374] Create
 3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js

---
 ...f-the-prices-is-less-than-or-equal-to-k.js | 35 +++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js

diff --git a/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js b/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js
new file mode 100644
index 00000000..11d26787
--- /dev/null
+++ b/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} k
+ * @param {number} x
+ * @return {number}
+ */
+var findMaximumNumber = function(k, x) {
+    let l = 0n;
+    let r = 10n ** 20n;
+
+    while (l + 1n < r) {
+        let m = (l + r) >> 1n;
+
+        if (F(Number(m + 1n)) <= k) l = m;
+        else r = m;
+    }
+
+    return Number(l);
+
+    function F(m) {
+        let count = 0;
+
+        for (let i = 1; i < 80; i++) {
+            let bit = (i * x) - 1;
+            let S = 1n << BigInt(bit);
+            let B = BigInt(m) / S;
+
+            count += Number(S) * Math.floor(Number(B) / 2);
+            if ((Number(B) & 1) === 1) {
+                count += Number(BigInt(m) % S);
+            }
+        }
+
+        return count;
+    }
+};

From befe95a06aa74efe8bbafa06f7f56599f2b26211 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 3 Nov 2025 11:58:22 +0000
Subject: [PATCH 3356/3374] Create
 3399-smallest-substring-with-identical-characters-ii.js

---
 ...-substring-with-identical-characters-ii.js | 48 +++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 3399-smallest-substring-with-identical-characters-ii.js

diff --git a/3399-smallest-substring-with-identical-characters-ii.js b/3399-smallest-substring-with-identical-characters-ii.js
new file mode 100644
index 00000000..ae74d5c5
--- /dev/null
+++ b/3399-smallest-substring-with-identical-characters-ii.js
@@ -0,0 +1,48 @@
+/**
+ * @param {string} s
+ * @param {number} numOps
+ * @return {number}
+ */
+var minLength = function (s, numOps) {
+  const arr = Array.from(s, Number)
+
+  const L = groupLengths(arr)
+
+  let l = 1,
+    r = 100000
+  while (l < r) {
+    const m = Math.floor((l + r) / 2)
+    const need = check(arr, m)
+    if (need <= numOps) {
+      r = m
+    } else {
+      l = m + 1
+    }
+  }
+  return l
+
+  function check(A, k) {
+    if (k === 1) {
+      let res = 0
+      for (let i = 0; i < A.length; i++) {
+        if (A[i] === i % 2) res++
+      }
+      return Math.min(res, A.length - res)
+    }
+    return L.reduce((acc, l) => acc + Math.floor(l / (k + 1)), 0)
+  }
+
+  function groupLengths(arr) {
+    const lengths = []
+    let count = 1
+    for (let i = 1; i <= arr.length; i++) {
+      if (i < arr.length && arr[i] === arr[i - 1]) {
+        count++
+      } else {
+        lengths.push(count)
+        count = 1
+      }
+    }
+    return lengths
+  }
+}

From 770b0249397b9bfc94d555c84ff592cb0775b336 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Nov 2025 09:44:52 +0000
Subject: [PATCH 3357/3374] Create 3449-maximize-the-minimum-game-score.js

---
 3449-maximize-the-minimum-game-score.js | 46 +++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 3449-maximize-the-minimum-game-score.js

diff --git a/3449-maximize-the-minimum-game-score.js b/3449-maximize-the-minimum-game-score.js
new file mode 100644
index 00000000..1477193b
--- /dev/null
+++ b/3449-maximize-the-minimum-game-score.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number[]} points
+ * @param {number} m
+ * @return {number}
+ */
+var maxScore = function (points, m) {
+  const n = points.length
+  if (m < n) return 0
+
+  const can = (val) => {
+    let total = 0,
+      transfer = 0,
+      skipAdd = 0
+    for (let i = 0; i < n && total <= m; i++) {
+      const point = points[i]
+      const necessary = Math.floor((val + point - 1) / point)
+      if (transfer >= necessary) {
+        transfer = 0
+        skipAdd++
+      } else {
+        const p = transfer * point
+        const ops = Math.floor((val - p + point - 1) / point)
+        total += 2 * ops - 1
+        total += skipAdd
+
+        transfer = Math.max(ops - 1, 0)
+        skipAdd = 0
+      }
+    }
+    return total <= m
+  }
+
+  let l = 1n,
+    r = 10n ** 15n,
+    res = 0n
+  while (l <= r) {
+    const mid = l + (r - l) / 2n
+    if (can(Number(mid))) {
+      res = mid
+      l = mid + 1n
+    } else {
+      r = mid - 1n
+    }
+  }
+  return Number(res)
+}

From 1c56b6cf5dd9b2775d18dee5caf408301f1fe108 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 4 Nov 2025 09:52:46 +0000
Subject: [PATCH 3358/3374] Update 3449-maximize-the-minimum-game-score.js

---
 3449-maximize-the-minimum-game-score.js | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/3449-maximize-the-minimum-game-score.js b/3449-maximize-the-minimum-game-score.js
index 1477193b..abd1f14d 100644
--- a/3449-maximize-the-minimum-game-score.js
+++ b/3449-maximize-the-minimum-game-score.js
@@ -31,16 +31,14 @@ var maxScore = function (points, m) {
   }
 
   let l = 1n,
-    r = 10n ** 15n,
-    res = 0n
-  while (l <= r) {
-    const mid = l + (r - l) / 2n
+    r = 10n ** 15n
+  while (l < r) {
+    const mid = r - (r - l) / 2n
     if (can(Number(mid))) {
-      res = mid
-      l = mid + 1n
+      l = mid
     } else {
       r = mid - 1n
     }
   }
-  return Number(res)
+  return Number(l)
 }

From 6a0882fd8304d3c57d08907c63ec2dffdd23338d Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 5 Nov 2025 12:11:46 +0000
Subject: [PATCH 3359/3374] Update
 3464-maximize-the-distance-between-points-on-a-square.js

---
 ...the-distance-between-points-on-a-square.js | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)

diff --git a/3464-maximize-the-distance-between-points-on-a-square.js b/3464-maximize-the-distance-between-points-on-a-square.js
index 47fcde20..57f343dd 100644
--- a/3464-maximize-the-distance-between-points-on-a-square.js
+++ b/3464-maximize-the-distance-between-points-on-a-square.js
@@ -1,3 +1,88 @@
+/**
+ * @param {number} side
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+const maxDistance = function (side, points, k) {
+  const n = points.length
+  const arr = []
+
+  const next = new Array(15000)
+
+  for (const p of points) {
+    if (p[0] === 0) {
+      arr.push(p[1])
+    } else if (p[1] === side) {
+      arr.push(side + p[0])
+    } else if (p[0] === side) {
+      arr.push(2 * side + side - p[1])
+    } else if (p[1] === 0) {
+      arr.push(3 * side + side - p[0])
+    }
+  }
+
+  arr.sort((a, b) => a - b)
+
+  let low = 0,
+    high = side
+  while (low < high) {
+    const mid = high - Math.floor((high - low) / 2)
+    if (isOK(mid, k)) {
+      low = mid
+    } else {
+      high = mid - 1
+    }
+  }
+  return low
+
+  function isOK(dist, k) {
+    let j = 0
+    for (let i = 0; i < n; i++) {
+      while (pos(j) - arr[i] < dist) {
+        j++
+      }
+      next[i] = j
+    }
+
+    for (let i = 0; i < n; i++) {
+      let flag = true
+      let cur = i
+      for (let t = 0; t < k - 1; t++) {
+        if (cur < n) {
+          cur = next[cur]
+        } else {
+          cur = next[cur % n] + n
+        }
+        if (cur >= i + n) {
+          flag = false
+          break
+        }
+      }
+      if (pos(i) - pos(cur % n) < dist) {
+        flag = false
+      }
+      if (flag) {
+        return true
+      }
+    }
+    return false
+  }
+
+  function pos(j) {
+    if (j < n) {
+      return arr[j]
+    } else {
+      return arr[j % n] + side * 4
+    }
+  }
+
+}
+
+
+// another
+
+
 /**
  * @param {number} side
  * @param {number[][]} points

From fb67ea7fc40af17176610795d2f4b393559dd061 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Mon, 10 Nov 2025 06:19:02 +0000
Subject: [PATCH 3360/3374] Create 3696-minimum-time-to-activate-string.js

---
 3696-minimum-time-to-activate-string.js | 43 +++++++++++++++++++++++++
 1 file changed, 43 insertions(+)
 create mode 100644 3696-minimum-time-to-activate-string.js

diff --git a/3696-minimum-time-to-activate-string.js b/3696-minimum-time-to-activate-string.js
new file mode 100644
index 00000000..5430231e
--- /dev/null
+++ b/3696-minimum-time-to-activate-string.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @param {number[]} order
+ * @param {number} k
+ * @return {number}
+ */
+var minTime = function(s, order, k) {
+  const len = order.length
+  let l = 0, r = len
+  const {floor: flr} = Math
+  while(l < r) {
+    const mid = flr((l + r) / 2)
+    if(isOK(mid)) r = mid
+    else l = mid + 1
+  }
+
+  return l >=  len ? -1 : l
+
+  function isOK(t) {
+    const n = s.length
+
+    const isStar = Array(n).fill(false)
+    let inValid = 0, segLen = 0
+
+    for(let i = 0; i <= t; i++) isStar[order[i]] = true 
+
+    for(let i = 0; i < n; i++) {
+      if(isStar[i]) {
+        inValid += segLen * (segLen + 1) / 2
+        segLen = 0
+      } else {
+        segLen++
+      }
+    }
+
+    if(segLen) inValid += segLen * (segLen + 1) / 2
+
+    const all = n * (n + 1) / 2
+
+    const valid = all - inValid
+    return valid >= k
+  }
+};

From 6c5c6b719c7a807501a793817a49b35e35470eb8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Nov 2025 11:48:27 +0000
Subject: [PATCH 3361/3374] Create 3677-count-binary-palindromic-numbers.js

---
 3677-count-binary-palindromic-numbers.js | 62 ++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 3677-count-binary-palindromic-numbers.js

diff --git a/3677-count-binary-palindromic-numbers.js b/3677-count-binary-palindromic-numbers.js
new file mode 100644
index 00000000..5cb7037c
--- /dev/null
+++ b/3677-count-binary-palindromic-numbers.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countBinaryPalindromes = function (n) {
+  let dp = []
+  let built = false
+  n = BigInt(n)
+
+  if (!built) {
+    dp = new Array(56).fill(0)
+    dp[1] = 1
+    dp[2] = 1
+    for (let i = 3; i <= 55; i++) dp[i] = 2 * dp[i - 2]
+    built = true
+  }
+
+  let maxbit = bit(n)
+  if (maxbit === -1) return 1
+  let len = maxbit + 1
+
+  let count = 1
+  for (let i = 1; i < len; i++) count += dp[i]
+
+  let half = Math.floor((len + 1) / 2)
+  let start = 1n << BigInt(half - 1)
+  let end = (1n << BigInt(half)) - 1n
+
+  let lo = start,
+    hi = end,
+    best = start - 1n
+  while (lo <= hi) {
+    let mid = (lo + hi) >> 1n
+    let pal = makePal(mid, len)
+    if (pal <= n) {
+      best = mid
+      lo = mid + 1n
+    } else {
+      hi = mid - 1n
+    }
+  }
+
+  if (best >= start) count += Number(best - start + 1n)
+  return count
+
+  function bit(num) {
+    for (let i = 63; i >= 0; i--) {
+      if ((num & (1n << BigInt(i))) !== 0n) return i
+    }
+    return -1
+  }
+
+  function makePal(p, len) {
+    let pal = p
+    let q = len % 2 === 0 ? p : p >> 1n
+    while (q > 0n) {
+      pal = (pal << 1n) | (q & 1n)
+      q >>= 1n
+    }
+    return pal
+  }
+}

From c834c3aa82eff7bc575af8a4139ba0e5d1165397 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Nov 2025 12:52:41 +0000
Subject: [PATCH 3362/3374] Update 3677-count-binary-palindromic-numbers.js

---
 3677-count-binary-palindromic-numbers.js | 62 ++++++++++++++++++++++++
 1 file changed, 62 insertions(+)

diff --git a/3677-count-binary-palindromic-numbers.js b/3677-count-binary-palindromic-numbers.js
index 5cb7037c..f6b813e1 100644
--- a/3677-count-binary-palindromic-numbers.js
+++ b/3677-count-binary-palindromic-numbers.js
@@ -1,3 +1,65 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countBinaryPalindromes = function (n) {
+  n = BigInt(n)
+  if (n === 0n) return 1
+  const maxLen = Math.floor(Math.log2(Number(n))) + 1
+
+  let ret = 1n
+  for (let L = 1; L < maxLen; L++) {
+    const h = Math.floor((L + 1) / 2)
+    const mn = 1n << BigInt(h - 1)
+    const mx = (1n << BigInt(h)) - 1n
+    ret += mx - mn + 1n
+  }
+
+  {
+    const L = maxLen
+    const h = Math.floor((L + 1) / 2)
+    const mn = 1n << BigInt(h - 1)
+    const mx = (1n << BigInt(h)) - 1n
+    let lo = mn,
+      hi = mx
+    while (lo < hi) {
+      const mid = hi - (hi - lo) / 2n
+      const pal = build(mid, L)
+      if (pal <= n) {
+        lo = mid
+      } else {
+        hi = mid - 1n
+      }
+    }
+    const pal = build(hi, L)
+    if (pal <= n) ret += hi - mn + 1n
+  }
+
+  return Number(ret)
+}
+function reverseBits(x) {
+  let r = 0n
+  while (x > 0n) {
+    r = r * 2n + (x & 1n)
+    x >>= 1n
+  }
+  return r
+}
+
+function build(half, L) {
+  const h = Math.floor((L + 1) / 2)
+  const k = L - h
+  if (L % 2 === 0) {
+    return (half << BigInt(k)) | reverseBits(half)
+  } else {
+    return (half << BigInt(k)) | reverseBits(half >> 1n)
+  }
+}
+
+
+// another
+
+
 /**
  * @param {number} n
  * @return {number}

From e676a1cc71f4f8c513cf1eed3ef73c3ee96c866a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 11 Nov 2025 13:30:55 +0000
Subject: [PATCH 3363/3374] Update 3677-count-binary-palindromic-numbers.js

---
 3677-count-binary-palindromic-numbers.js | 35 ++++++++++++------------
 1 file changed, 18 insertions(+), 17 deletions(-)

diff --git a/3677-count-binary-palindromic-numbers.js b/3677-count-binary-palindromic-numbers.js
index f6b813e1..19d1903c 100644
--- a/3677-count-binary-palindromic-numbers.js
+++ b/3677-count-binary-palindromic-numbers.js
@@ -15,25 +15,25 @@ var countBinaryPalindromes = function (n) {
     ret += mx - mn + 1n
   }
 
-  {
-    const L = maxLen
-    const h = Math.floor((L + 1) / 2)
-    const mn = 1n << BigInt(h - 1)
-    const mx = (1n << BigInt(h)) - 1n
-    let lo = mn,
-      hi = mx
-    while (lo < hi) {
-      const mid = hi - (hi - lo) / 2n
-      const pal = build(mid, L)
-      if (pal <= n) {
-        lo = mid
-      } else {
-        hi = mid - 1n
-      }
+  
+  const L = maxLen
+  const h = Math.floor((L + 1) / 2)
+  const mn = 1n << BigInt(h - 1)
+  const mx = (1n << BigInt(h)) - 1n
+  let lo = mn,
+    hi = mx
+  while (lo < hi) {
+    const mid = hi - (hi - lo) / 2n
+    const pal = build(mid, L)
+    if (pal <= n) {
+      lo = mid
+    } else {
+      hi = mid - 1n
     }
-    const pal = build(hi, L)
-    if (pal <= n) ret += hi - mn + 1n
   }
+  const pal = build(hi, L)
+  if (pal <= n) ret += hi - mn + 1n
+  
 
   return Number(ret)
 }
@@ -57,6 +57,7 @@ function build(half, L) {
 }
 
 
+
 // another
 
 

From 78376f9030fd42b36285d5625c56b2788eb16fd8 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Wed, 12 Nov 2025 15:34:06 +0000
Subject: [PATCH 3364/3374] Create 3691-maximum-total-subarray-value-ii.js

---
 3691-maximum-total-subarray-value-ii.js | 80 +++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 3691-maximum-total-subarray-value-ii.js

diff --git a/3691-maximum-total-subarray-value-ii.js b/3691-maximum-total-subarray-value-ii.js
new file mode 100644
index 00000000..89c56f1d
--- /dev/null
+++ b/3691-maximum-total-subarray-value-ii.js
@@ -0,0 +1,80 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxTotalValue = function (nums, k) {
+  const n = nums.length
+  const K = Math.floor(Math.log2(n)) + 1
+
+  const mn = Array.from({ length: n }, () => Array(K + 1).fill(Infinity))
+  const mx = Array.from({ length: n }, () => Array(K + 1).fill(-Infinity))
+
+  for (let i = 0; i < n; i++) {
+    mn[i][0] = nums[i]
+    mx[i][0] = nums[i]
+  }
+
+  for (let kk = 1; kk <= K; kk++) {
+    for (let i = 0; i + (1 << kk) - 1 < n; i++) {
+      mn[i][kk] = Math.min(mn[i][kk - 1], mn[i + (1 << (kk - 1))][kk - 1])
+      mx[i][kk] = Math.max(mx[i][kk - 1], mx[i + (1 << (kk - 1))][kk - 1])
+    }
+  }
+
+  let lo = 0,
+    hi = 2e9
+  while (lo < hi) {
+    const mid = hi - Math.floor((hi - lo) / 2)
+    if (count_ge(mid) >= k) {
+      lo = mid
+    } else {
+      hi = mid - 1
+    }
+  }
+  const th = lo
+
+  let ret_g = 0n
+  let count_g = 0n
+  for (let i = 0; i < n; i++) {
+    let l = i,
+      r = n - 1
+    while (l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if (GetDiff(i, mid) > th) {
+        r = mid
+      } else {
+        l = mid + 1
+      }
+    }
+    if (GetDiff(i, r) > th) {
+      count_g += BigInt(n - r)
+      for (let j = r; j < n; j++) {
+        ret_g += BigInt(GetDiff(i, j))
+      }
+    }
+  }
+
+  const ret = ret_g + BigInt(th) * (BigInt(k) - count_g)
+
+  return Number(ret)
+
+  function GetDiff(L, R) {
+    const length = R - L + 1
+    const k = Math.floor(Math.log2(length))
+    return (
+      Math.max(mx[L][k], mx[R - (1 << k) + 1][k]) -
+      Math.min(mn[L][k], mn[R - (1 << k) + 1][k])
+    )
+  }
+
+  function count_ge(th) {
+    let count = 0
+    let j = 0
+    for (let i = 0; i < n; i++) {
+      while (j < n && GetDiff(i, j) < th) j++
+      count += n - j
+    }
+    return count
+  }
+}

From 3f365288fcca1df08dcc0ea7fb2b30c320b2eaae Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Nov 2025 05:51:12 +0000
Subject: [PATCH 3365/3374] Create
 3608-minimum-time-for-k-connected-components.js

---
 ...minimum-time-for-k-connected-components.js | 39 +++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 3608-minimum-time-for-k-connected-components.js

diff --git a/3608-minimum-time-for-k-connected-components.js b/3608-minimum-time-for-k-connected-components.js
new file mode 100644
index 00000000..6343a1a3
--- /dev/null
+++ b/3608-minimum-time-for-k-connected-components.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} k
+ * @return {number}
+ */
+var minTime = function (n, edges, k) {
+  let f = Array.from({ length: n }, (_, i) => i)
+
+  edges.sort((a, b) => b[2] - a[2])
+  let count = n
+  for (const [u, v, t] of edges) {
+    if (union(u, v)) {
+      count -= 1
+    }
+    if (count < k) {
+      return t
+    }
+  }
+  return 0
+
+  function find(x) {
+    if (x === f[x]) {
+      return x
+    }
+    f[x] = find(f[x])
+    return f[x]
+  }
+
+  function union(x, y) {
+    x = find(x)
+    y = find(y)
+    if (x === y) {
+      return false
+    }
+    f[x] = y
+    return true
+  }
+}

From 00e43eefa40e61471e9eb08e31f1570e696aeccc Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Fri, 14 Nov 2025 06:26:59 +0000
Subject: [PATCH 3366/3374] Update
 3608-minimum-time-for-k-connected-components.js

---
 ...minimum-time-for-k-connected-components.js | 48 ++++++++++---------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/3608-minimum-time-for-k-connected-components.js b/3608-minimum-time-for-k-connected-components.js
index 6343a1a3..49e51055 100644
--- a/3608-minimum-time-for-k-connected-components.js
+++ b/3608-minimum-time-for-k-connected-components.js
@@ -4,36 +4,38 @@
  * @param {number} k
  * @return {number}
  */
-var minTime = function (n, edges, k) {
-  let f = Array.from({ length: n }, (_, i) => i)
-
+var minTime = function(n, edges, k) {
   edges.sort((a, b) => b[2] - a[2])
-  let count = n
-  for (const [u, v, t] of edges) {
-    if (union(u, v)) {
-      count -= 1
-    }
-    if (count < k) {
-      return t
-    }
+  const uf = new UF(n)
+  let cnt = n
+  
+  for(let i = 0; i < edges.length; i++) {
+    const [u, v, t] = edges[i]
+    if(uf.union(u, v)) cnt--
+    if(cnt < k) return t
   }
   return 0
+};
 
-  function find(x) {
-    if (x === f[x]) {
-      return x
+class UF {
+  constructor(n) {
+    this.root = Array(n).fill(null).map((_, i) => i)
+  }
+  find(x) {
+    if (this.root[x] !== x) {
+      this.root[x] = this.find(this.root[x])
     }
-    f[x] = find(f[x])
-    return f[x]
+    return this.root[x]
   }
-
-  function union(x, y) {
-    x = find(x)
-    y = find(y)
-    if (x === y) {
+  union(x, y) {
+    const xr = this.find(x)
+    const yr = this.find(y)
+    if(xr === yr) {
       return false
+    } else {
+      this.root[yr] = xr
+      return true
     }
-    f[x] = y
-    return true
+
   }
 }

From 7bd98c4e2c0a0672e083338f96d0650150ab4dab Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Nov 2025 09:34:13 +0000
Subject: [PATCH 3367/3374] Create
 3733-minimum-time-to-complete-all-deliveries.js

---
 ...minimum-time-to-complete-all-deliveries.js | 38 +++++++++++++++++++
 1 file changed, 38 insertions(+)
 create mode 100644 3733-minimum-time-to-complete-all-deliveries.js

diff --git a/3733-minimum-time-to-complete-all-deliveries.js b/3733-minimum-time-to-complete-all-deliveries.js
new file mode 100644
index 00000000..8a1cd3dc
--- /dev/null
+++ b/3733-minimum-time-to-complete-all-deliveries.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} d
+ * @param {number[]} r
+ * @return {number}
+ */
+var minimumTime = function (d, r) {
+  let low = d[0] + d[1]
+  let high = 2 * low * 2
+  let res = high
+
+  let lcm = (r[0] * r[1]) / gcd(r[0], r[1])
+
+  while (low < high) {
+    let mid = low + Math.floor((high - low) / 2)
+    if (isOK(mid)) {
+      high = mid
+    } else {
+      low = mid + 1
+    }
+  }
+
+  return low
+
+  function gcd(a, b) {
+    while (b !== 0) {
+      let temp = b
+      b = a % b
+      a = temp
+    }
+    return a
+  }
+  function isOK(time) {
+    let slots1 = time - Math.floor(time / r[0])
+    let slots2 = time - Math.floor(time / r[1])
+    let total_slots = time - Math.floor(time / lcm)
+    return slots1 >= d[0] && slots2 >= d[1] && total_slots >= d[0] + d[1]
+  }
+}

From e8f72e968df41cc99fc9e6e62aa4bc882917cad6 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sat, 15 Nov 2025 11:06:03 +0000
Subject: [PATCH 3368/3374] Update
 3733-minimum-time-to-complete-all-deliveries.js

---
 ...minimum-time-to-complete-all-deliveries.js | 44 +++++++++----------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/3733-minimum-time-to-complete-all-deliveries.js b/3733-minimum-time-to-complete-all-deliveries.js
index 8a1cd3dc..13972da6 100644
--- a/3733-minimum-time-to-complete-all-deliveries.js
+++ b/3733-minimum-time-to-complete-all-deliveries.js
@@ -4,35 +4,31 @@
  * @return {number}
  */
 var minimumTime = function (d, r) {
-  let low = d[0] + d[1]
-  let high = 2 * low * 2
-  let res = high
+  const [d0, d1] = d, [r0, r1] = r
+  let low = d0 + d1, hi = 2 * low * 2
+  const lcm = r0 * r1 / gcd(r0, r1)
+  const {floor: flr} = Math
 
-  let lcm = (r[0] * r[1]) / gcd(r[0], r[1])
-
-  while (low < high) {
-    let mid = low + Math.floor((high - low) / 2)
-    if (isOK(mid)) {
-      high = mid
-    } else {
-      low = mid + 1
-    }
+  while(low < hi) {
+    const mid = low + flr((hi - low) / 2)
+    if(isOK(mid)) {
+      hi = mid
+    } else low = mid + 1
   }
 
   return low
 
-  function gcd(a, b) {
-    while (b !== 0) {
-      let temp = b
-      b = a % b
-      a = temp
+  function isOK(t) {
+    const s0 = t - flr(t / r0), s1 = t - flr(t / r1)
+    const total = t - flr(t / lcm)
+    if(s0 >= d0 && s1 >= d1 && total >= d0 + d1) {
+      return true
     }
-    return a
-  }
-  function isOK(time) {
-    let slots1 = time - Math.floor(time / r[0])
-    let slots2 = time - Math.floor(time / r[1])
-    let total_slots = time - Math.floor(time / lcm)
-    return slots1 >= d[0] && slots2 >= d[1] && total_slots >= d[0] + d[1]
+
+    return false
   }
 }
+
+function gcd(a, b) {
+  return b === 0 ? a : gcd(b, a % b)
+}

From af5e646fdfa3c9ba63fa2a4c3219002e77d96f02 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Nov 2025 05:26:25 +0000
Subject: [PATCH 3369/3374] Create
 3745-maximize-expression-of-three-elements.js

---
 3745-maximize-expression-of-three-elements.js | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)
 create mode 100644 3745-maximize-expression-of-three-elements.js

diff --git a/3745-maximize-expression-of-three-elements.js b/3745-maximize-expression-of-three-elements.js
new file mode 100644
index 00000000..fcc24525
--- /dev/null
+++ b/3745-maximize-expression-of-three-elements.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maximizeExpressionOfThree = function(nums) {
+   const n = nums.length
+   let res = -Infinity
+   for(let i = 0; i < n - 2; i++) {
+     for(let j = i + 1; j < n - 1; j++) {
+       for(let k = j + 1; k < n; k++) {
+         res = Math.max(res, nums[i] + nums[j] - nums[k])
+        res = Math.max(res, nums[i] - nums[j] + nums[k])
+                  res = Math.max(res, -nums[i] + nums[j] + nums[k])
+       }
+     }
+   }
+  return res
+};

From 65fd83ee4aa1fa2c6a059ffaa6ca287d4c5c5cd0 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Nov 2025 05:26:54 +0000
Subject: [PATCH 3370/3374] Create
 3746-minimum-string-length-after-balanced-removals.js

---
 ...m-string-length-after-balanced-removals.js | 21 +++++++++++++++++++
 1 file changed, 21 insertions(+)
 create mode 100644 3746-minimum-string-length-after-balanced-removals.js

diff --git a/3746-minimum-string-length-after-balanced-removals.js b/3746-minimum-string-length-after-balanced-removals.js
new file mode 100644
index 00000000..13524d6f
--- /dev/null
+++ b/3746-minimum-string-length-after-balanced-removals.js
@@ -0,0 +1,21 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var minLengthAfterRemovals = function(s) {
+  let a = 0, b = 0
+  const n = s.length
+  let res = n
+  for(let i = 0; i < n; i++) {
+    const e = s[i]
+    if(e === 'a') a++
+    else if(e === 'b') b++
+    if(a > 0 && b > 0) {
+      const tmp = Math.min(a, b)
+      a -= tmp
+      b -= tmp
+      res -= tmp * 2
+    }
+  }
+  return res
+};

From 7ccba55676022854b27c19197c1e65c70185822a Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Nov 2025 05:27:26 +0000
Subject: [PATCH 3371/3374] Create
 3747-count-distinct-integers-after-removing-zeros.js

---
 ...-distinct-integers-after-removing-zeros.js | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 3747-count-distinct-integers-after-removing-zeros.js

diff --git a/3747-count-distinct-integers-after-removing-zeros.js b/3747-count-distinct-integers-after-removing-zeros.js
new file mode 100644
index 00000000..cb40cc4c
--- /dev/null
+++ b/3747-count-distinct-integers-after-removing-zeros.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countDistinct = function(n) {
+  const s = '' + n
+  const d = s.length
+  const {pow} = Math
+  let total = 0
+  for(let i = 1; i < d; i++) {
+    total += pow(9, i)
+  }
+
+  for(let i = 0; i < d; i++) {
+    const e = +s[i]
+    let remaining = d - i - 1
+
+    if(e > 1) {
+      total += (e - 1) * pow(9, remaining)
+    }
+    if(e === 0) return total
+  }
+
+
+  return total + 1
+};

From 591d896963e83fe6cc8b422c986b40f164383434 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Nov 2025 05:27:56 +0000
Subject: [PATCH 3372/3374] Create 3748-count-stable-subarrays.js

---
 3748-count-stable-subarrays.js | 70 ++++++++++++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 3748-count-stable-subarrays.js

diff --git a/3748-count-stable-subarrays.js b/3748-count-stable-subarrays.js
new file mode 100644
index 00000000..432130cc
--- /dev/null
+++ b/3748-count-stable-subarrays.js
@@ -0,0 +1,70 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var countStableSubarrays = function(nums, queries) {
+  let n = nums.length
+  const {floor: flr} = Math
+  let res = []
+  let segments = [], start = 0
+
+  for(let i = 0; i < n; i++) {
+    if(nums[i] < nums[i - 1]) {
+      segments.push([start, i - 1])
+      start = i
+    }
+  }
+  segments.push([start, n - 1])
+
+  let pc = []
+
+  let total = 0
+  for(const [s, e] of segments) {
+    let length = e - s + 1
+    let count = length * (length + 1) / 2
+    total += count
+    pc.push(total)
+  }
+
+  for(const [l, r] of queries) {
+    let li = bisect(segments, l) - 1
+    let ri = bisect(segments, r) - 1
+    if(li < 0) li = 0
+    if(ri < 0) ri = 0
+    if(li === ri) {
+      let [ss, se] = segments[li]
+      let length = r - l + 1
+      let count = length * (length + 1) / 2
+      res.push(count)
+    } else {
+      let [ss, se] = segments[li]
+      let ll = se - l + 1
+      let lc = ll * (ll + 1) / 2
+
+      let [ssr, ser] = segments[ri]
+      let rl = r - ssr + 1
+      let rc = rl * (rl + 1) / 2
+
+      let mid_count = 0
+      if(ri - li > 1) {
+        mid_count = pc[ri - 1] - pc[li]
+      }
+      res.push(lc + mid_count + rc)
+    }
+
+  }
+  
+  return res
+
+  function bisect(segments, x) {
+    let low = 0, high = segments.length
+    while(low < high) {
+      let mid = flr((low + high) / 2)
+      if(segments[mid][0] <= x) low = mid + 1
+      else high = mid
+    }
+
+    return low
+  }
+};

From 3db61caa3b5169508beb7f8a5ec742f1e3f589a1 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Sun, 16 Nov 2025 10:23:17 +0000
Subject: [PATCH 3373/3374] Create 3709-design-exam-scores-tracker.js

---
 3709-design-exam-scores-tracker.js | 44 ++++++++++++++++++++++++++++++
 1 file changed, 44 insertions(+)
 create mode 100644 3709-design-exam-scores-tracker.js

diff --git a/3709-design-exam-scores-tracker.js b/3709-design-exam-scores-tracker.js
new file mode 100644
index 00000000..ecad3189
--- /dev/null
+++ b/3709-design-exam-scores-tracker.js
@@ -0,0 +1,44 @@
+var ExamTracker = function() {
+  this.time = []
+  this.score = []
+};
+
+/** 
+ * @param {number} time 
+ * @param {number} score
+ * @return {void}
+ */
+ExamTracker.prototype.record = function(time, score) {
+  this.time.push(time)
+  this.score.push(this.score.length ? this.score[this.score.length - 1] + score : score)
+  // console.log(this.score)
+};
+
+/** 
+ * @param {number} startTime 
+ * @param {number} endTime
+ * @return {number}
+ */
+ExamTracker.prototype.totalScore = function(startTime, endTime) {
+  const pre = bs(this.time, startTime - 1), cur = bs(this.time, endTime)
+  if(cur === -1) return 0
+  return this.score[cur] - (pre === -1 ? 0 : this.score[pre])  
+};
+// <=
+function bs(arr, time) {
+  let l = -1, r = arr.length - 1
+  while(l < r) {
+    const mid = r - Math.floor((r - l) / 2)
+    if(arr[mid] <= time) {
+      l = mid
+    } else r = mid - 1
+  }
+  return l
+}
+
+/** 
+ * Your ExamTracker object will be instantiated and called as such:
+ * var obj = new ExamTracker()
+ * obj.record(time,score)
+ * var param_2 = obj.totalScore(startTime,endTime)
+ */

From 23eafe83b5cd7f2a2faf617f9428ac28defb8793 Mon Sep 17 00:00:00 2001
From: Nothing <wwwaap@gmail.com>
Date: Tue, 18 Nov 2025 07:45:17 +0000
Subject: [PATCH 3374/3374] Create 3620-network-recovery-pathways.js

---
 3620-network-recovery-pathways.js | 103 ++++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)
 create mode 100644 3620-network-recovery-pathways.js

diff --git a/3620-network-recovery-pathways.js b/3620-network-recovery-pathways.js
new file mode 100644
index 00000000..49326ce4
--- /dev/null
+++ b/3620-network-recovery-pathways.js
@@ -0,0 +1,103 @@
+/**
+ * @param {number[][]} edges
+ * @param {boolean[]} online
+ * @param {number} k
+ * @return {number}
+ */
+var findMaxPathScore = function (edges, online, k) {
+  const n = online.length
+  let adj_list
+  let in_degree
+  let max_edge_length
+  let topo_sort
+
+  if (edges.length === 0) {
+    return -1
+  }
+
+  ;[adj_list, in_degree, max_edge_length] = create_adj_list()
+  topo_sort = find_toposort_order()
+  const res = binary_search(max_edge_length)
+  return res
+
+
+  function create_adj_list() {
+    const in_degree_original = new Array(n).fill(0)
+    let max_len = 0
+    const adj = Array.from({ length: n }, () => [])
+
+    for (const [u, v, cost] of edges) {
+      if (online[u] && online[v]) {
+        in_degree_original[v] += 1
+        max_len = Math.max(max_len, cost)
+        adj[u].push([v, cost])
+      }
+    }
+    return [adj, in_degree_original, max_len]
+  }
+
+  function find_toposort_order() {
+    const dq = []
+    const local_topo_sort = []
+
+    for (let node = 0; node < n; node++) {
+      if (in_degree[node] === 0) {
+        dq.push(node)
+      }
+    }
+
+    while (dq.length > 0) {
+      const node = dq.shift()
+      local_topo_sort.push(node)
+
+      for (const [adj, cost] of adj_list[node]) {
+        in_degree[adj] -= 1
+        if (in_degree[adj] === 0) {
+          dq.push(adj)
+        }
+      }
+    }
+
+    return local_topo_sort
+  }
+
+  function check_feasibility_with_wt(min_edge_wt) {
+    const distances = new Array(n).fill(Infinity)
+    distances[0] = 0
+
+    for (const node of topo_sort) {
+      for (const [adj, cost] of adj_list[node]) {
+        if (cost < min_edge_wt) {
+          continue
+        }
+
+        if (distances[node] + cost <= k) {
+          distances[adj] = Math.min(distances[adj], distances[node] + cost)
+        }
+      }
+    }
+
+    if (distances[n - 1] <= k) {
+      return true
+    } else {
+      return false
+    }
+  }
+
+  function binary_search(max_edge_length_param) {
+    let low = 0
+    let high = Math.min(k, max_edge_length_param)
+
+    while (low <= high) {
+      const mid = low + Math.floor((high - low) / 2)
+
+      if (check_feasibility_with_wt(mid) === true) {
+        low = mid + 1
+      } else {
+        high = mid - 1
+      }
+    }
+
+    return low - 1
+  }
+}