168场周赛

1.子串的最大出现次数

给你一个字符串 s ，请你返回满足以下条件且出现次数最大的 任意 子串的出现次数：

子串中不同字母的数目必须小于等于 maxLetters 。
子串的长度必须大于等于 minSize 且小于等于 maxSize 。
 

示例 1：

输入：s = "aababcaab", maxLetters = 2, minSize = 3, maxSize = 4
输出：2
解释：子串 "aab" 在原字符串中出现了 2 次。
它满足所有的要求：2 个不同的字母，长度为 3 （在 minSize 和 maxSize 范围内）。
示例 2：

输入：s = "aaaa", maxLetters = 1, minSize = 3, maxSize = 3
输出：2
解释：子串 "aaa" 在原字符串中出现了 2 次，且它们有重叠部分。
示例 3：

输入：s = "aabcabcab", maxLetters = 2, minSize = 2, maxSize = 3
输出：3
示例 4：

输入：s = "abcde", maxLetters = 2, minSize = 3, maxSize = 3
输出：0
 

提示：

1 <= s.length <= 10^5
1 <= maxLetters <= 26
1 <= minSize <= maxSize <= min(26, s.length)
s 只包含小写英文字母。

/**
 * @param {string} s
 * @param {number} maxLetters
 * @param {number} minSize
 * @param {number} maxSize
 * @return {number}
 */
// maxSize 根本没有用
var maxFreq = function(s, maxLetters, minSize, maxSize) {
  let lenMap = {};
  let ans = 0;
  for (let i = 0; i < s.length - minSize + 1; i++) {
    const str = s.substr(i, minSize);
    if (new Set(str.split('')).size <= maxLetters) {
      if (lenMap[str]) {
        lenMap[str]++;
      } else {
        lenMap[str] = 1;
      }
      if (lenMap[str] > ans) {
        ans = lenMap[str];
      }
    }
  }
  return ans;
};

/**
 * @param {string} s
 * @param {number} maxLetters
 * @param {number} minSize
 * @param {number} maxSize
 * @return {number}
 */
var maxFreq = function(s, maxLetters, minSize, maxSize) {
  function check(ss) {
      const sss = new Set(ss.split(''))
      if (sss.size <= maxLetters) {
          return true
      }
      return false
  }
  function count(ss) {
      let cnt = 0
      let temps = s
      let index = temps.indexOf(ss)
      while(index !== -1) {
          cnt++
          temps = temps.slice(index + 1)
          index = temps.indexOf(ss)
      }
      return cnt
  }
  let ans = 0
  const arr = []
  for(let i = 0; i < s.length - minSize + 1; i++) {
      let ss = ''
      for(let j = 0; j < minSize; j++) {
          ss += s[i + j]
      }
      let x = minSize + i
      while(check(ss) && ss.length <= maxSize) {
          // console.log(ss)
          arr.push(ss)
          if (x >= s.length) {
              break
          }
          ss += s[x++]
      }
  }
  arr.sort()
  const map = {}
  for(let i = 0; i < arr.length ;i++) {
    if (map[arr[i]]) map[arr[i]] ++
    else map[arr[i]]  = 1
  }
  const unq = [...new Set(arr)]
  for(let i = 0; i < unq.length; i++) {
    ans = Math.max(ans, map[unq[i]])
  }
  // console.log(ans)
  return ans
};

 

 

 

 

2.分数组为连续数字的集合

给你一个整数数组 nums 和一个正整数 k，请你判断是否可以把这个数组划分成一些由 k 个连续数字组成的集合。
如果可以，请返回 True；否则，返回 False。

示例 1：

输入：nums = [1,2,3,3,4,4,5,6], k = 4
输出：true
解释：数组可以分成 [1,2,3,4] 和 [3,4,5,6]。
示例 2：

输入：nums = [3,2,1,2,3,4,3,4,5,9,10,11], k = 3
输出：true
解释：数组可以分成 [1,2,3] , [2,3,4] , [3,4,5] 和 [9,10,11]。
示例 3：

输入：nums = [3,3,2,2,1,1], k = 3
输出：true
示例 4：

输入：nums = [1,2,3,4], k = 3
输出：false
解释：数组不能分成几个大小为 3 的子数组。
 

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 10^9
1 <= k <= nums.length

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {boolean}
 */
var isPossibleDivide = function(nums, k) {
    let judge =(nums, k)=>{
       if(nums.length % k ===0 && nums.length!==0){
           let min = Math.min(...nums);
           let k1 = k;
           while(k1--){
               let index = nums.indexOf(min);
               if(index!==-1){
                   // splice(index, replace nums, replace params)
                   nums.splice(index, 1)
               } else {
                   return;
               }
               min++;
           }
           judge(nums, k)
       } else {
           return
       }     
    };
      
    judge(nums, k);
    
    return !nums.length;
};

 

 

3.你能从盒子里获得的最大糖果数

给你 n 个盒子，每个盒子的格式为 [status, candies, keys, containedBoxes] ，其中：

状态字 status[i]：整数，如果 box[i] 是开的，那么是 1 ，否则是 0 。
糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。
给你一个 initialBoxes 数组，表示你现在得到的盒子，你可以获得里面的糖果，也可以用盒子里的钥匙打开新的盒子，还可以继续探索从这个盒子里找到的其他盒子。

请你按照上述规则，返回可以获得糖果的 最大数目 。

 

示例 1：

输入：status = [1,0,1,0], candies = [7,5,4,100], keys = [[],[],[1],[]], containedBoxes = [[1,2],[3],[],[]], initialBoxes = [0]
输出：16
解释：
一开始你有盒子 0 。你将获得它里面的 7 个糖果和盒子 1 和 2。
盒子 1 目前状态是关闭的，而且你还没有对应它的钥匙。所以你将会打开盒子 2 ，并得到里面的 4 个糖果和盒子 1 的钥匙。
在盒子 1 中，你会获得 5 个糖果和盒子 3 ，但是你没法获得盒子 3 的钥匙所以盒子 3 会保持关闭状态。
你总共可以获得的糖果数目 = 7 + 4 + 5 = 16 个。
示例 2：

输入：status = [1,0,0,0,0,0], candies = [1,1,1,1,1,1], keys = [[1,2,3,4,5],[],[],[],[],[]], containedBoxes = [[1,2,3,4,5],[],[],[],[],[]], initialBoxes = [0]
输出：6
解释：
你一开始拥有盒子 0 。打开它你可以找到盒子 1,2,3,4,5 和它们对应的钥匙。
打开这些盒子，你将获得所有盒子的糖果，所以总糖果数为 6 个。
示例 3：

输入：status = [1,1,1], candies = [100,1,100], keys = [[],[0,2],[]], containedBoxes = [[],[],[]], initialBoxes = [1]
输出：1
示例 4：

输入：status = [1], candies = [100], keys = [[]], containedBoxes = [[]], initialBoxes = []
输出：0
示例 5：

输入：status = [1,1,1], candies = [2,3,2], keys = [[],[],[]], containedBoxes = [[],[],[]], initialBoxes = [2,1,0]
输出：7
 

提示：

1 <= status.length <= 1000
status.length == candies.length == keys.length == containedBoxes.length == n
status[i] 要么是 0 要么是 1 。
1 <= candies[i] <= 1000
0 <= keys[i].length <= status.length
0 <= keys[i][j] < status.length
keys[i] 中的值都是互不相同的。
0 <= containedBoxes[i].length <= status.length
0 <= containedBoxes[i][j] < status.length
containedBoxes[i] 中的值都是互不相同的。
每个盒子最多被一个盒子包含。
0 <= initialBoxes.length <= status.length
0 <= initialBoxes[i] < status.length

/**
 * @param {number[]} status
 * @param {number[]} candies
 * @param {number[][]} keys
 * @param {number[][]} containedBoxes
 * @param {number[]} initialBoxes
 * @return {number}
 */
// 在sublime 中 status 不知为何变成关键字，默认是字符串类型，不是数组
var maxCandies = function(status, candies, keys, containedBoxes, initialBoxes) {
    let boxs = [];
    let mykeys = [];
   
    initialBoxes.forEach(b=>{
        boxs.push(b);
        
       let getboxs = (cboxes)=>{
            cboxes.length && cboxes.forEach(b1=>{
            boxs.push(b1);
            getboxs(containedBoxes[b1])
        })
      }
      getboxs(containedBoxes[b])
        
    });
   
    boxs.forEach(b=>{
        mykeys.push(...keys[b])
    })
    let res = candies.reduce((init, val, i)=>{
        if(boxs.indexOf(i)!==-1 && (Number(status[i]) || (!status[i] && mykeys.indexOf(i) !==-1))){
          return init + val;
        } else {
            return init; 
        }
    }, 0)
    return res
};

/**
 * @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) {
    const myBox = initialBoxes
    const usedBox = []
    let ans = 0
    const myKeys = []
    let flag = true
    while(flag) {
        let open = 0
        // console.log(myBox, myKeys, usedBox)
        for(let i = 0; i < myBox.length; i++) {
            const index = myBox[i]
            if (usedBox.includes(index)) continue
            if (status[index] === 1 || status[index] === 0 && myKeys.includes(index)) {
                open++
                usedBox.push(index)
                myKeys.push(...keys[index])
                ans += candies[index]
                myBox.push(...containedBoxes[index])
            }
        }
        if (open === 0) {
            flag = false
        }
    }
    return ans
};

/**
 * @param {number[]} status
 * @param {number[]} candies
 * @param {number[][]} keys
 * @param {number[][]} containedBoxes
 * @param {number[]} initialBoxes
 * @return {number}
 */
/*
状态字 status[i]：整数，如果 box[i] 是开的，那么是 1 ，否则是 0 。
糖果数 candies[i]: 整数，表示 box[i] 中糖果的数目。
钥匙 keys[i]：数组，表示你打开 box[i] 后，可以得到一些盒子的钥匙，每个元素分别为该钥匙对应盒子的下标。
内含的盒子 containedBoxes[i]：整数，表示放在 box[i] 里的盒子所对应的下标。
*/
var maxCandies = function(status, candies, keys, containedBoxes, initialBoxes) {
  let ans = 0;
  let canAccess = [...initialBoxes];
  let visited = [];
  while (canAccess.length) {
    let cur = canAccess.pop();
    ans += candies[cur];
    visited.push(cur);
    const haveKeysMap = {};
    visited
      .map(item => keys[item])
      .forEach(keyArr => {
        keyArr.forEach(key => {
          haveKeysMap[key] = true;
        });
      });
    visited
      .map(item => containedBoxes[item])
      .forEach(boxArr => {
        boxArr.forEach(box => {
          if ((haveKeysMap[box] || status[box]) && visited.indexOf(box) < 0 && canAccess.indexOf(box) < 0) {
            canAccess.push(box);
          }
        });
      });
  }
  return ans;
};

 

复盘：

  中等题 2 是我写的，花费 20 几分钟，之所以花费这么长时间，又一个原因就是 splice 的api 由于长时间不用，又忘记了，疑惑了一小会，如果不出现这个问题，应该能提高1分钟吧。

困难题 3 是我写的，不过在12：08分才提交，超时，这次前2道特别顺利，也不知是休息得好，状态好还是能力提升，光凭借前2题就达到300多名，如果这个正常提交可以达到200多名。

这道题本身不难，题目叙述啰嗦，提示也啰嗦，并且感觉还有毛病，并且在sublime调试时，出现个问题，疑惑了一段时间，就是 status 似乎是个关键字，我写成数组，待提示还是字符串，并且里面
代码运行时也是字符串，很是尴尬。

 最后，还有

做到这么顺利不建议看时间，容易想别的，直接往下做就好，看时间反而会产生懈怠的心理。反正把目标订到做 4 道题。

 

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/maximum-candies-you-can-get-from-boxes
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。