/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function (s) {
  const len = s.length;
  let result = ''
  
  // 遍历，每一个中间点
  for (let i = 0; i < len; i++) {
    let l = i - 1;
    let r = i + 1;
    
	// 往左考虑，第一种情况
    while (l >= 0 && s[l] === s[i]) {
      l--;
    }
    
	// 往右考虑，第一种情况
    while (r < len && s[r] === s[i]) {
      r++;
    }
    
	// 考虑第二种情况
    while (l >= 0 && r < len && s[l] === s[r]) {
      r++;
      l--;
    }
    
	// 遍历每个中心点，获得此中心点的最长回文，然后获得结果
    if (result.length < r - l) {
      result = s.slice(l + 1, r)
    }
  }
  return result
};

/**
 * @param {string} s
 * @return {string}
 */
var longestPalindrome = function (s) {
  const len = s.length;
  let result = ''
  let pre = 0;
  let after = 0;

  // 创建二维数组，用于存储。
  let dp = new Array(len)
  // 这里注意，不能 new Array(len).fill(new Array(len).fill(null))
  // fill里加new Array, 那么填充的数组是一个数组，填充的是引用。会导致改了一个，每个都会改变
  for (let i = 0; i < len; i++) {
    const newArr = new Array(len).fill(null);
    dp[i] = newArr;
  }

  for (let r = 0; r < len; r++) {
    for (let l = 0; l <= r; l++) {
      // 重要在这，递归查询
      const res = handlePalidrom(s, l, r, dp);

      if (res && r - l > after - pre) {
        after = r;
        pre = l;
      }
    }
  }

  return s.slice(pre, after + 1);
};

// [i, j]
function handlePalidrom(s, l, r, dp) {
  const len = r - l + 1;

  // 已经处理过，从缓存中获取
  if (dp[l][r] !== null) return dp[l][r];
  // 仅一个字符串的情况，肯定是回文
  if (len === 1) {
    dp[l][r] = true;
    return true;
  }
  // 两个字符串情况，需要判断两个字符串是否相等，如相等。则是回文
  if (len === 2 && s[l] === s[r]) {
    dp[l][r] = true;
    return true;
  }
  // 大于3的情况，如果两头是回文，则递归查找
  if (s[l] === s[r]) {
    const res = handlePalidrom(s, l + 1, r - 1, dp);
    if (res) {
      dp[l][r] = true;
    }
    return res;
  }
  // 其他情况，都不是回文
  dp[l][r] = false;
  return false;

}

/**
 * @param {number[]} nums
 * @return {number}
 */
var firstMissingPositive = function (nums) {
  let set = new Set(nums);
  let result = nums.length + 1;

  for (let i = 1; i <= nums.length; i++) {
    if (!set.has(i)) {
      result = i;
      return result;
    }
  }
  return result;
};

/**
 * @param {number[]} nums
 * @return {number}
 */
var firstMissingPositive = function (nums) {
  const len = nums.length;

  let tmpArr = nums.slice();
  // 去除负数，统一改为0
  let hasOne = false;
  for (let i = 0; i < len; i++) {
    const val = tmpArr[i];
    if (val === 1) {
      hasOne = true;
    }
    if (val < 1) {
      tmpArr[i] = null	// 清空干扰
    } else {
      tmpArr[i] = val
    }
  }

  // 如果没有1。则结果是1
  if (!hasOne) return 1;

  // 对应下标的值标记为负值，不破坏原来的数字
  for (let i = 0; i < len; i++) {
    // 这里用绝对值，是因为可能被前面遍历的操作变为负值
    let val = Math.abs(tmpArr[i]);
    if (val <= len && val > 0) {
      // 把符合条件的值，对应下标的值改为负数
      tmpArr[val - 1] = -Math.abs(tmpArr[val - 1])
    }
  }

  let result = len + 1;
  // 最后走一遍，如果是负数，则原来存在于数组、非0则不存在，则是要找的结果。如果都是负数，则结果是len
  for (let i = 0; i < len; i++) {
    const val = tmpArr[i];
    // 没被标记
    if (val > 0 || val === null) {
      result = i + 1;
      return result;
    }
  }
  return result;
};

var input = {
  a: {
    a: 'a',
    b: [
      0,
      {
        a: true,
        b: 5
      }
    ]
  },
  b: [
    {
      a: 'a'
    },
    true
  ]
}

var output = {
  'a.a': 'a',
  'a.b[0]': 0,
  'a.b[1].a': true,
  'a.b[1].b': 5,
  'b[0].a': 'a',
  'b[1]': true
}