/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function (n) {
  let dp = [];

  dp[1] = 1;
  dp[2] = 2;

  for (let i = 3; i <= n; i++) {
    // 到达第 n 阶的方式
    // 1. 从上一阶的位置跨一步 取dp[i - 1]的到达方式数量
    // 2. 从上两阶的位置跨两步 取dp[i - 2]的到达方式数量
    // 把两种方式数量相加 即可得到到达第n阶方式数量
    dp[i] = dp[i - 2] + dp[i - 1];
  }

  return dp[n];
};

let generateParenthesis = function (n) {
  let dp = []
  // 这里放一个空字符串，不然遍历的时候会跳过
  // dp[0]就是取出一个空的字符串拼接到括号的内部去
  dp[0] = ['']
  dp[1] = ['()']

  for (let i = 2; i <= n; i++) {
    let res = []
    for (let j = 0; j <= i - 1; j++) {
      let inners = dp[j]
      let outers = dp[i - 1 - j]

      for (let inner of inners) {
        for (let outer of outers) {
          res.push(`(${inner})${outer}`)
        }
      }
    }
    dp[i] = res
  }
  return dp[n]
}

/**
 * @param {number} n
 * @return {string[]}
 */
let generateParenthesis = function (n) {
  let res = []

  let helper = (left, right, prev) => {
    if (left < 0 || right < 0 || right < left) {
      return
    }
    if (left === 0 && right === 0) {
      res.push(prev)
      return
    }

    helper(left - 1, right, prev + '(')
    helper(left, right - 1, prev + ')')
  }

  helper(n, n, '')
  return res
}

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
let largestValues = function (root) {
  if (!root) return [];
  let queue = [root];
  let maximums = [];

  while (queue.length) {
    let max = Number.MIN_SAFE_INTEGER;
    // 这里需要先缓存length 这个length代表当前层级的所有节点
    // 在循环开始后 会push新的节点 length就不稳定了
    let len = queue.length;
    for (let i = 0; i < len; i++) {
      let node = queue[i];
      max = Math.max(node.val, max);

      if (node.left) {
        queue.push(node.left);
      }
      if (node.right) {
        queue.push(node.right);
      }
    }

    // 本「层级」处理完毕，截取掉。
    for (let i = 0; i < len; i++) {
      queue.shift();
    }

    // 这个for循环结束后 代表当前层级的节点全部处理完毕
    // 直接把计算出来的最大值push到数组里即可。
    maximums.push(max);
  }

  return maximums;
};

/**
 * @param {number} n
 * @return {number}
 */
let numSquares = function(n) {
  let dp = []

  // 求0就假设为0次
  dp[0] = 0

  for (let i = 1; i <= n; i++) {
    let j = 1
    // 初始化为Infinity 这样后面任意一个小值都可以覆盖它
    let min = Infinity
    while (true) {
      // 用 i 减去不断递增的平方数 j * j
      let prev = i - j * j
      if (prev < 0) {
        break
      }

      // 假设i = 10、j = 1 实际上就是在求dp[10 - 1] + 1
      // 也就是凑成 9 的最小次数 再加上 1（也就是 1 这个平方数的次数）
      min = Math.min(min, dp[prev] + 1)
      j++
    }
    dp[i] = min === Infinity ? 0 : min
  }

  return dp[n]
}

/**
 * @param {string} s
 * @return {number}
 */
let lengthOfLongestSubstring = function (str) {
  let n = str.length
  // 滑动窗口为s[left...right]
  let left = 0
  let right = -1
  let freqMap = {} // 记录当前子串中下标对应的出现频率
  let max = 0 // 找到的满足条件子串的最长长度

  while (left < n) {
    let nextLetter = str[right + 1]
    if (!freqMap[nextLetter] && nextLetter !== undefined) {
      freqMap[nextLetter] = 1
      right++
    } else {
      freqMap[str[left]] = 0
      left++
    }
    max = Math.max(max, right - left + 1)
  }

  return max
}

var moveZeroes = function (nums) {
  let zeros = []
  for (let i = 0; i < nums.length; i++) {
    if (nums[i] === 0) {
      zeros.push(i)
    }
  }
  for (let j = zeros.length - 1; j >= 0; j--) {
    nums.splice(zeros[j], 1)
  }
  for (let j = 0; j < zeros.length; j++) {
    nums.push(0)
  }
  return nums
}

var moveZeroes = function (nums) {
  let j = 0

  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      nums[j] = nums[i]
      j++
    }
  }

  while (j < nums.length) {
    nums[j] = 0
    j++
  }
}

var moveZeroes = function (nums) {
  let j = 0

  for (let i = 0; i < nums.length; i++) {
    if (nums[i] !== 0) {
      swap(nums, i, j)
      j++
    }
  }
}

function swap(nums, i, j) {
  let temp = nums[i]
  nums[i] = nums[j]
  nums[j] = temp
}

let integerBreak = function (n) {
  let memo = [];
  memo[1] = 1;

  for (let i = 2; i <= n; i++) {
    let max = 0;
    // 对于每一个 i 来说，都要从 1 开始拆分成 j 和 i - j 两个正整数
    // 比如 3 需要拆分成 1,2 和 2,1 
    // 4需要拆分成 1,3、2,2、3,1
    // 然后再进一步决定最大值
    for (let j = 1; j < i; j++) {
      max = Math.max(
        max,
        // 不继续拆分 i - j,直接对比一次
        // 比如 1 和 2，不光要对比 1 * (2 拆分后的结果)
        // 也要直接对比 1 * 2
        j * (i - j),
        // 和拆分后的最大乘积相乘
        j * memo[i - j]
      );
    }
    memo[i] = max
  }

  return memo[n]
};

let maxArea = function(height) {
  let i = 0
  let j = height.length - 1

  let max = 0

  while (i !== j) {
    let leftHeight = height[i]
    let rightHeight = height[j]

    let x = j - i
    let area
    if (leftHeight > rightHeight) {
      area = rightHeight * x
      j--
    } else {
      area = leftHeight * x
      i++
    }
    max = area > max ? area : max
  }

  return max
}

/**
 * @param {ListNode} head
 * @param {number} n
 * @return {ListNode}
 */
let removeNthFromEnd = function (head, n) {
  let node = head
  let nodes = []
  do {
    nodes.push(node)
    node = node.next
  } while (node)

  const l = nodes.length
  const index = l - n
  const targetNode = nodes[index]
  const prevNode = nodes[index - 1]
  if (prevNode) {
    prevNode.next = targetNode.next
  }

  const tempNext = targetNode.next
  targetNode.next = null

  if (targetNode === head) {
    return tempNext
  }
  return head
}

function partition(arr, left, right) {
  // 取一个基准值 取第一项
  let pivot = arr[left]

  // arr[left+1...index] < pivot, arr[index+1...i) > pivot
  let index = left
  for (let i = left + 1; i <= right; i++) {
    let num = arr[i]
    if (num < pivot) {
      swap(arr, index + 1, i)
      index++
    }
  }

  swap(arr, left, index)
  return index
}

function partition(arr, left, right) {
  // 取一个基准值 取随机值
  let rand = random(left, right)
  swap(arr, left, rand)
  let pivot = arr[left]

  // arr[left+1...index] < pivot, arr[index+1...i) > pivot
  let index = left
  for (let i = left + 1; i <= right; i++) {
    let num = arr[i]
    if (num < pivot) {
      // 如果当前值小于基准值的话，就交换到index + 1的位置去。
      // 扩充了index的范围 [index...], pivot, [...right]
      swap(arr, index + 1, i)
      index++
    }
  }

  swap(arr, left, index)
  return index
}

function sortArray(arr) {
  _quickSort(arr, 0, arr.length - 1)
  return arr
}

/**
 * 对 arr[l...r] 部分进行快速排序
 * @param {number[]} arr
 * @param {number} l 左边界
 * @param {number} r 右边界
 */
function _quickSort(arr, l, r) {
  if (l >= r) {
    return
  }
  let [p, q] = partition(arr, l, r)
  _quickSort(arr, l, p)
  _quickSort(arr, q, r)
}
function random(low, high) {
  return Math.round(Math.random() * (high - low)) + low
}
function swap(arr, i, j) {
  let temp = arr[i]
  arr[i] = arr[j]
  arr[j] = temp
}

/**
 * 对 arr[l...r] 部分进行快速排序
 * @param {number[]} arr
 * @param {number} l 左边界
 * @param {number} r 右边界
 * @returns {number} 返回索引值p，使得arr[l...p-1] < arr[p] < arr[p+1...r]
 */
function partition(arr, left, right) {
  // 取一个基准值 取随机值
  let rand = random(left, right)
  swap(arr, left, rand)
  let pivot = arr[left]

  // 三路 注意看注释里的区间
  let lt = left // arr[left + 1...lt] < v
  let gt = right + 1 // arr[gt...r] > v
  let index = left + 1 // arr[lt + 1...index) === v

  while (index < gt) {
    let num = arr[index]
    if (num < pivot) {
      swap(arr, index, lt + 1)
      lt++
      index++
    } else if (num > pivot) {
      swap(arr, index, gt - 1)
      gt--
    } else if (num === pivot) {
      index++
    }
  }
  swap(arr, left, lt)

  return [lt - 1, gt]
}

/**
 * @param {string} s
 * @return {boolean}
 */
let isValid = function (s) {
  let sl = s.length
  if (sl % 2 !== 0) return false
  let leftToRight = {
    "{": "}",
    "[": "]",
    "(": ")",
  }
  // 建立一个反向的 value -> key 映射表
  let rightToLeft = createReversedMap(leftToRight)
  // 用来匹配左右括号的栈
  let stack = []

  for (let i = 0; i < s.length; i++) {
    let bracket = s[i]
    // 左括号 放进栈中
    if (leftToRight[bracket]) {
      stack.push(bracket)
    } else {
      let needLeftBracket = rightToLeft[bracket]
      // 左右括号都不是 直接失败
      if (!needLeftBracket) {
        return false
      }

      // 栈中取出最后一个括号 如果不是需要的那个左括号 就失败
      let lastBracket = stack.pop()
      if (needLeftBracket !== lastBracket) {
        return false
      }
    }
  }

  if (stack.length) {
    return false
  }
  return true
}

function createReversedMap(map) {
  return Object.keys(map).reduce((prev, key) => {
    const value = map[key]
    prev[value] = key
    return prev
  }, {})
}

let pathSum = function (root, sum) {
  let res = [];
  let search = function (node, paths) {
    if (isInvalid(node)) return;
    paths.push(node.val);
    if (node.left) {
      search(node.left, paths);
    }
    if (node.right) {
      search(node.right, paths);
    }
    if (!node.left && !node.right) {
      if (sumVals(paths) === sum) {
        res.push(paths.slice());
      }
    }
    paths.pop();
  };
  search(root, []);
  return res;
};

function sumVals(nodes) {
  return nodes.reduce((prev, val) => {
    prev += val;
    return prev;
  }, 0);
}

function isInvalid(node) {
  return !node || node.val === undefined || node.val === null;
}

/**
 * @param {number[]} cost
 * @return {number}
 */
let minCostClimbingStairs = function (cost) {
  let dp = [];

  for (let i = cost.length - 1; i >= 0; i--) {
    let oneStep = cost[i] + (dp[i + 1] || 0);
    let twoStep = cost[i] + (dp[i + 2] || 0);

    dp[i] = Math.min(oneStep, twoStep);
  }

  return Math.min(dp[0], dp[1]);
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */

/**
 * @param {ListNode} head
 * @param {number} m
 * @param {number} n
 * @return {ListNode}
 */

let reverseBetween = function (head, m, n) {
  let i = 1
  let sliceStartPrev = null
  let sliceStart = null
  let sliceEnd = null
  let cur = head

  // 记录切分起点的前一个节点，和切分终点的后一个节点
  while (i <= n) {
    if (i === m - 1) {
      sliceStartPrev = cur
    }
    if (i === m) {
      sliceStart = cur
    }
    if (i === n) {
      sliceEnd = cur
    }
    cur = cur.next
    i++
  }

  let sliceEndNext = sliceEnd.next
  // 切断切分终点的next 防止反转的时候反转过头
  sliceEnd.next = null

  const { head: slicedHead, tail: slicedTail } = reverse(sliceStart)
  if (sliceStartPrev) {
    // 如果需要反转的部分有前一个节点 那么只需要在中间动手脚 原样返回head节点即可
    sliceStartPrev.next = slicedHead
  } else {
    // 这里需要注意的是 如果没有sliceStartPrev 说明是从第一个节点就开始反转的
    // 那么我们需要手动调整head为反转后的head
    head = slicedHead
  }
  slicedTail.next = sliceEndNext

  return head
}

function reverse(head) {
  let prev = null
  let cur = head
  while (cur) {
    let next = cur.next
    cur.next = prev

    prev = cur
    cur = next
  }
  // 返回反转后的头尾节点
  return { head: prev, tail: head }
}

/**
 * @param {number} x
 * @return {number}
 */
let mySqrt = function (x) {
  let left = 0;
  let right = x;

  let ans = -1;
  while (left <= right) {
    let mid = Math.round((left + right) / 2);
    let product = mid * mid;
    if (product <= x) {
      ans = mid;
      left = mid + 1;
    } else if (product > x) {
      right = mid - 1;
    } else {
      return mid;
    }
  }

  return ans;
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} val
 * @return {ListNode}
 */
var deleteNode = function (head, val) {
  let virtual = {
    next: head,
  }
  let cur = virtual
  while (cur) {
    if (cur.next) {
      if (cur.next.val === val) {
        cur.next = cur.next.next
      }
    }
    cur = cur.next
  }
  return virtual.next
}

/**
 * @param {number[]} nums
 * @return {boolean}
 */
let canPartition = function (nums) {
  let n = nums.length

  let sum = nums.reduce((a, b) => a + b);

  let target = sum / 2;

  // 数据不是整数 直接return
  if (Math.ceil(target) !== target) {
    return false;
  }

  let dp = new Array(n);
  for (let i = 0; i < dp.length; i++) {
    dp[i] = new Array(target + 1).fill(false);
  }

  // 列代表可以选择去凑数的数值
  for (let i = 0; i < dp.length; i++) {
    // 行代表是否可以凑到这个数字j
    for (let j = 0; j <= target; j++) {
      // 不用当前数，直接选择前一行的结果
      let pickPrev = (dp[i - 1] ? dp[i - 1][j]: false) || false

      // 拿出当前数，并且从前一行里找其他的值能否凑成剩下的值
      let pickCurrentAndPrev = (dp[i - 1] ? dp[i - 1][j - nums[i]]: false) || false

      // 只拿的值直接去凑目标值
      let pickCurrent = j === nums[i]

      // 任意一者满足 即可理解成 「i下标的值」配合「i下标之前的数值」 可以一起凑成目标值
      let can = (
        pickPrev ||
        pickCurrent||
        pickCurrentAndPrev
      )

      dp[i][j] = can

      // 只要任意一行的 target 列满足条件 即可认为有「子数组」可以凑成目标值 直接返回 true
      if ((j === target) && can) {
        return true
      }
    }
  }
  return dp[n - 1][target]
};

/**
 * @param {number[]} numbers
 * @param {number} target
 * @return {number[]}
 */
let twoSum = function(numbers, target) {
  let i = 0;
  let j = numbers.length - 1;

  while (i !== j) {
    let sum = numbers[i] + numbers[j];
    if (sum > target) {
      j--;
    } else if (sum < target) {
      i++;
    } else {
      return [i + 1, j + 1];
    }
  }
};

/**
 * @param {string} path
 * @return {string}
 */
let simplifyPath = function (path) {
  let tokens = path.split("/")
  let stack = []

  for (let index = 0; index < tokens.length; index++) {
    let token = tokens[index]
    if (token === "..") {
      if (stack.length > 0) {
        stack.pop()
      }
    } else if (!(token === "") && !(token === ".")) {
      stack.push(token)
    }
  }

  let res = "/"

  for (let token of stack) {
    res += `${token}/`
  }

  if (res !== "/") {
    res = res.substr(0, res.length - 1)
  }

  return res
}

/**
 * @param {number[]} nums1
 * @param {number[]} nums2
 * @return {number[]}
 */
let intersect = function (nums1, nums2) {
  let map1 = makeCountMap(nums1)
  let map2 = makeCountMap(nums2)
  let res = []
  for (let num of map1.keys()) {
    const count1 = map1.get(num)
    const count2 = map2.get(num)

    if (count2) {
      const pushCount = Math.min(count1, count2)
      for (let i = 0; i < pushCount; i++) {
        res.push(num)
      }
    }
  }
  return res
}

function makeCountMap(nums) {
  let map = new Map()
  for (let i = 0; i < nums.length; i++) {
    let num = nums[i]
    let count = map.get(num)
    if (count) {
      map.set(num, count + 1)
    } else {
      map.set(num, 1)
    }
  }
  return map
}

/**
 * @param {number[][]} grid
 * @return {number}
 */
let minPathSum = function (grid) {
    let y = grid.length
    if (!y) {
        return 0
    }
    let x = grid[0].length

    let dp = []
    for (let i = 0; i < y; i++) {
        dp[i] = []
    }

    dp[0][0] = grid[0][0]
    
    // 第一行的基础状态 记得加上左边格子的值
    for (let j = 1; j < x; j++) {
        dp[0][j] = grid[0][j] + dp[0][j - 1]
    }

    // 第一列的基础状态 加上上方格子的最优解即可
    for (let i = 1; i < y; i++) {
        dp[i][0] = grid[i][0] + dp[i - 1][0]
    }

    // 开始求左上往右下求解
    for (let i = 1; i < grid.length; i++) {
        for (let j = 1; j < grid[i].length; j++) {
            let cur = grid[i][j]
            let fromUp = cur + (dp[i - 1][j] !== undefined ? dp[i - 1][j]: Infinity)
            let fromLeft = cur + (dp[i][j - 1] !== undefined ? dp[i][j - 1]: Infinity)

            dp[i][j] = Math.min(
                fromUp,
                fromLeft
            )
        }
    }
    return dp[y - 1][x - 1]
};

class DoubleNode {
  constructor(key, val) {
    this.key = key
    this.val = val

    this.prev = null
    this.next = null
  }
}

// key -> DoubleNode
this.map = new Map()

class DoubleNode {
  constructor(key, val) {
    this.key = key
    this.val = val

    this.prev = null
    this.next = null
  }
}

class LRUCache {
  constructor(max) {
    this.max = max
    this.map = new Map()

    this.head = null
    this.tail = null
  }

  get(key) {
    const node = this.map.get(key)
    if (!node) {
      return -1
    } else {
      const res = node.val
      this.remove(node)
      this.appendHead(node)
      return res
    }
  }

  put(key, value) {
    let node = this.map.get(key)
    // 有这个缓存
    if (node) {
      node.val = value
      // 新加入的 放在最前面
      this.remove(node)
      this.appendHead(node)
    } else {
      // 没有这个缓存
      node = new DoubleNode(key, value)
      // 如果超出容量了 删除最后一个 再放到头部
      if (this.map.size >= this.max) {
        this.map.delete(this.tail.key)
        this.remove(this.tail)
        this.appendHead(node)
        this.map.set(key, node)
      } else {
        // 未超出容量 就直接放到头部
        this.appendHead(node)
        this.map.set(key, node)
      }
    }
  }

  /**
   * 把头部指针的改变成新的node
   * @param {DoubleNode} node
   */
  appendHead(node) {
    if (this.head === null) {
      this.head = this.tail = node
    } else {
      node.next = this.head
      this.head.prev = node
      this.head = node
    }
  }

  /**
   * 删除某个节点
   * @param {DoubleNode} node
   */
  remove(node) {
    if (this.head === this.tail) {
      this.head = this.tail = null
    } else {
      // 删除头部
      if (this.head === node) {
        this.head = this.head.next
        node.next = null
      } else if (this.tail === node) {
        this.tail = this.tail.prev
        this.tail.next = null
        node.prev = null
      } else {
        node.prev.next = node.next
        node.next.prev = node.prev
        node.prev = node.next = null
      }
    }
  }
}

/**
 * @param {number[]} nums
 * @return {number}
 */
let removeDuplicates = function (nums) {
  // 快指针
  let i = 0;
  // 慢指针
  let j = 0;

  while (i < nums.length) {
    let fast = nums[i];
    let slot = nums[j];

    // 快慢不相等，说明找到了一个新的值
    // 把慢指针的位置更新，并且赋值成新的值，继续等待下一个新值。
    if (fast !== slot) {
      j++;
      nums[j] = num;
    }
    i++;
  }

  return j + 1;
};

/**
 * @param {string} s
 * @return {boolean}
 */
let isPalindrome = function(s) {
    s = s.replace(/[^0-9a-zA-Z]/g, '').toLowerCase()
    let i = 0
    let j = s.length - 1

    while(i < j) {
        let head = s[i]
        let tail = s[j]

        if (head !== tail) {
            return false
        }else {
            i++
            j--
        }
    }
    return true
};

/**
 * @param {string[]} tokens
 * @return {number}
 */
let opMap = {
  "+": (a, b) => b + a,
  "-": (a, b) => b - a,
  "*": (a, b) => b * a,
  "/": (a, b) => parseInt(b / a, 10),
}

let evalRPN = function (tokens) {
  let stack = []
  for (let token of tokens) {
    let op = opMap[token]
    if (op) {
      let a = parseInt(stack.pop())
      let b = parseInt(stack.pop())
      let res = op(a, b)
      stack.push(res)
    } else {
      stack.push(token)
    }
  }
  return stack[0]
}

let maxProfit = function(prices) {
  let max = 0;
  for (let i = 0; i < prices.length - 1; i++) {
    let current = prices[i];
    let next = prices[i + 1];
    if (current < next) {
      max += next - current;
    }
  }
  return max;
};

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
let preorderTraversal = function (root) {
  let res = []
  let stack = [
    {
      type: "go",
      node: root,
    },
  ]

  while (stack.length) {
    let { type, node } = stack.pop()

    if (!node) continue

    if (type === "print") {
      res.push(node.val)
    }

    if (type === "go") {
      // 先右
      if (node.right) {
        stack.push({ type: "go", node: node.right })
      }
      // 再左
      if (node.left) {
        stack.push({ type: "go", node: node.left })
      }
      // 最后打印
      stack.push({ type: "print", node })
    }
  }

  return res
}

let preorderTraversal = function (root) {
    let res = []

    let stack = [() => { visit(root) }]

    const visit = (node) => {
        if (!node) return
        stack.push(() => {
            if (node.right) {
                visit(node.right)
            }
        })
        stack.push(() => {
            if (node.left) {
                visit(node.left)
            }
        })
        stack.push(() => res.push(node.val))
    }


    while (stack.length) {
        stack.pop()()
    }

    return res
};

let TrieNode = function () {
  this.next = new Map();
  this.isEnd = false;
};

let TrieNode = function () {
  this.next = new Map();
  this.isEnd = false;
};

/**
 * Initialize your data structure here.
 */
let Trie = function () {
  this.root = new TrieNode();
};

/**
 * Inserts a word into the trie.
 * @param {string} word
 * @return {void}
 */
Trie.prototype.insert = function (word) {
  let node = this.root;

  for (let i = 0; i < word.length; i++) {
    let { next } = node;
    let trieNode = next.get(word[i]);
    if (!trieNode) {
      trieNode = new TrieNode();
      next.set(word[i], trieNode);
    }
    node = trieNode;

    if (i === word.length - 1) {
      node.isEnd = true;
    }
  }
};

/**
 * Returns if the word is in the trie.
 * @param {string} word
 * @return {boolean}
 */
Trie.prototype.search = function (word) {
  let node = this.root;

  for (let i = 0; i < word.length; i++) {
    let { next } = node;
    let trieNode = next.get(word[i]);
    if (!trieNode) {
      return false;
    }
    node = trieNode;
  }
  return node.isEnd;
};

/**
 * 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 node = this.root;

  for (let i = 0; i < prefix.length; i++) {
    let { next } = node;
    let trieNode = next.get(prefix[i]);
    if (!trieNode) {
      return false;
    }
    node = trieNode;
  }
  return true;
};

/**
 * Your Trie object will be instantiated and called as such:
 * let obj = new Trie()
 * obj.insert(word)
 * let param_2 = obj.search(word)
 * let param_3 = obj.startsWith(prefix)
 */

/**
 * @param {number} x
 * @param {number} n
 * @return {number}
 */
var myPow = function (x, n) {
  if (n === 0) return 1;
  if (n === 1) return x;
  let abs = Math.abs(n);
  let isMinus = abs !== n;

  let res = abs % 2 === 0 ? myPow(x * x, abs / 2) : x * myPow(x, abs - 1);
  return isMinus ? 1 / res : res;
};

let maxProduct = function (nums) {
  let dp = [];
  let n = nums.length;

  let last = nums[n - 1];
  dp[n - 1] = {
    max: last,
    min: last,
  };

  for (i = nums.length - 2; i >= 0; i--) {
    let num = nums[i];
    let withNextMin = num * dp[i + 1].min;
    let withNextMax = num * dp[i + 1].max;
    let withoutNext = num;
    dp[i] = {
      max: Math.max(withoutNext, withNextMin, withNextMax),
      min: Math.min(withoutNext, withNextMin, withNextMax),
    };
  }

  return Math.max(...dp.map(({ max }) => max));
};

maxProduct([2, 3, -2, 4]);

let maxProduct = function (nums) {
    let n = nums.length

    let last = nums[n - 1]

    let prevMax = last
    let prevMin = last
    let allMax = last
    let allMin = last

    for (i = nums.length - 2; i >= 0; i--) {
        let num = nums[i]
        let withNextMin = (num * prevMin)
        let withNextMax = (num * prevMax)
        let withoutNext = num

        prevMax = Math.max(withoutNext, withNextMin, withNextMax)
        prevMin = Math.min(withoutNext, withNextMin, withNextMax)

        allMax = Math.max(allMax, prevMax)
        allMin = Math.min(allMin, prevMin)
    }

    return allMax
};

/**
 * @param {string} s
 * @param {string} p
 * @return {number[]}
 */
let findAnagrams = function (s, p) {
  let targetMap = makeCountMap(p)
  let sl = s.length
  let pl = p.length
  // [left,...right] 滑动窗口
  let left = 0
  let right = pl - 1
  let windowMap = makeCountMap(s.substring(left, right + 1))
  let res = []

  while (left <= sl - pl && right < sl) {
    if (isAnagrams(windowMap, targetMap)) {
      res.push(left)
    }
    windowMap[s[left]]--
    right++
    left++
    addCountToMap(windowMap, s[right])
  }

  return res
}

let isAnagrams = function (windowMap, targetMap) {
  let targetKeys = Object.keys(targetMap)
  for (let targetKey of targetKeys) {
    if (
      !windowMap[targetKey] ||
      windowMap[targetKey] !== targetMap[targetKey]
    ) {
      return false
    }
  }
  return true
}

function addCountToMap(map, str) {
  if (!map[str]) {
    map[str] = 1
  } else {
    map[str]++
  }
}

function makeCountMap(strs) {
  let map = {}
  for (let i = 0; i < strs.length; i++) {
    let letter = strs[i]
    addCountToMap(map, letter)
  }
  return map
}

let maxSlidingWindow = function (nums, k) {
  if (k === 0 || !nums.length) {
    return []
  }
  let left = 0
  let right = k - 1
  let res = [findMax(nums, left, right)]

  while (right < nums.length - 1) {
    right++
    left++
    res.push(findMax(nums, left, right))
  }

  return res
}

function findMax(nums, left, right) {
  let max = -Infinity
  for (let i = left; i <= right; i++) {
    max = Math.max(max, nums[i])
  }
  return max
}

let memo = new WeakMap()
let rob = function (root) {
  if (!root) {
    return 0
  }

  let memorized = memo.get(root)
  if (memorized) {
    return memorized
  }

  let notRob = rob(root.left) + rob(root.right)
  let robNow =
    (root.val || 0) +
    (root.left ? rob(root.left.left) + rob(root.left.right) : 0) +
    (root.right ? rob(root.right.left) + rob(root.right.right) : 0)

  let max = Math.max(notRob, robNow)
  memo.set(root, max)
  return max
}

/**
 * @param {TreeNode} root
 * @return {number}
 */
let rob = function (root) {
  if (!root) return 0
  let dp = new Map()
  dp.set(null, 0)

  let bfs = (nodes) => {
    if (!nodes.length) {
      return
    }

    let subs = []
    for (let node of nodes) {
      if (node.left) {
        subs.push(node.left)
      }
      if (node.right) {
        subs.push(node.right)
      }
    }

    bfs(subs)

    // 到达最底层后 最底层先开始 dp
    // 再一层层回溯
    for (let node of nodes) {
      // 打劫这个节点
      let robNow = node.val
      if (node.left) {
        robNow += dp.get(node.left.left)
        robNow += dp.get(node.left.right)
      }
      if (node.right) {
        robNow += dp.get(node.right.left)
        robNow += dp.get(node.right.right)
      }

      // 不打劫这个节点 打劫下一层
      let robNext = dp.get(node.left) + dp.get(node.right)
      dp.set(node, Math.max(robNow, robNext))
    }
  }

  bfs([root])

  return dp.get(root)
}

var solve = function (board) {
  if (board.length == 0) return null;

  for (var y = 0; y < board.length; y++) {
    for (var x = 0; x < board[0].length; x++) {
      if (board[y][x] == "O" && (y == 0 || y == board.length - 1 || x == 0 || x == board[0].length - 1)) {
        dfs(board, y, x);
      }
    }
  }

  for (var y = 0; y < board.length; y++) {
    for (var x = 0; x < board[0].length; x++) {
      if (board[y][x] == "W") {
        board[y][x] = "O";
      } else {
        board[y][x] = "X";
      }
    }
  }

  return board;
};

function dfs(board, y, x) {
  if (y < 0 || x < 0 || y >= board.length || x >= board[0].length || board[y][x] == "X" || board[y][x] == "W") {
    return;
  }
  board[y][x] = "W";
  dfs(board, y + 1, x);
  dfs(board, y - 1, x);
  dfs(board, y, x + 1);
  dfs(board, y, x - 1);
  return;
}

let sortColors = function(nums) {
    let colors = [0, 0, 0]

    for (let i = 0; i < nums.length; i++) {
        colors[nums[i]] ++
    }

    nums.length = 0
    for (let i = 0; i < colors.length; i++) {
        for(let j = 0; j < colors[i]; j++) {
            nums.push(i)
        }
    }
};

/**
 * @param {number[]} nums1
 * @param {number} m
 * @param {number[]} nums2
 * @param {number} n
 * @return {void} Do not return anything, modify nums1 in-place instead.
 */
let merge = function (arr1, m, arr2, n) {
  // 两个指针指向数组非空位置的末尾
  let i = m - 1;
  let j = n - 1;
  // 第三个指针指向第一个数组的末尾 填充数据
  let k = arr1.length - 1;

  while (i >= 0 && j >= 0) {
    let num1 = arr1[i];
    let num2 = arr2[j];

    if (num1 > num2) {
      arr1[k] = num1;
      i--;
    } else {
      arr1[k] = num2;
      j--;
    }
    k--;
  }

  while (j >= 0) {
    arr1[k] = arr2[j];
    j--;
    k--;
  }
};

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {ListNode}
 */
let reverseList = function (head) {
  let prev = null
  let cur = head

  while (cur) {
    let next = cur.next
    cur.next = prev
    prev = cur
    cur = next
  }

  return prev
}