zoukankan      html  css  js  c++  java
  • 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
    著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

  • 相关阅读:
    60个Redis面试题
    Linux服务器安全加固
    Linux安全加固手册
    mysql赋权限
    cut命令的使用实例
    超详细的Tomcat性能监控及调优教程
    Linux面试题(系统管理类——Raid)
    https://www.cnblogs.com/diantong/p/10745372.html
    CentOS6启动流程(含详细流程图)
    Oracle ROWNUM用法和分页查询总结
  • 原文地址:https://www.cnblogs.com/zhangzs000/p/12079465.html
Copyright © 2011-2022 走看看