程序员面试金典---17

堆箱子

思路：

• 首先进行排序，规则为：

  • 如果宽度不相同，按照宽度从小到大排序。
  • 如果宽度相同，深度不相同，按照深度从大到小排序。
  • 宽度和深度都相同，高度从大到小排序。

• 采用动态规划进行求解：

  计算以当前盒子为顶部盒子时的最大堆叠高度。

  从前往后遍历每一个盒子，对于每一个盒子i，遍历i之后的所有盒子j，如果盒子能够放在盒子i上方，则更新盒子j的堆叠高度为dp[j]=max(dp[j],dp[i] + box[j][2])。最终返回max。

  代码：

  /**
   * @param {number[][]} box
   * @return {number}
   */
  var pileBox = function(box) {
      // 排序
      box.sort((a, b) => a[0] === b[0] ? a[1] === b[1] ? b[2] - a[2] : b[1] - a[1] : a[0] - b[0])
      const len = box.length
      // 初始化
      dp = Array.from({length:len},(_, i) => box[i][2])
  
      let max = 1
      // 循环，每个盒子依次在底
      for(let i = 0;i < len; i++){
          max = Math.max(max, dp[i])
          for(let j = i + 1;j < len; j++){
          	// 更新状态
              if(box[j][1] > box[i][1] && box[j][2] > box[i][2]){
                  dp[j] = Math.max(dp[j], dp[i] + box[j][2])
                  max = Math.max(max, dp[i])
              }
          }
      }
      return max
  };
  

稀疏数组搜索

思路：

二分加特殊的空字符

/**
 * @param {string[]} words
 * @param {string} s
 * @return {number}
 */
var findString = function(words, s) {
    let left = 0
    let right = words.length - 1
    while(left <= right){
        let midTemp = mid = (left + right) >>1

        // 处理空 如果是空，一直往后
        while(mid <= right && !words[mid]){
            mid++
        } 
        // 如果mid大于right，说明超出边界
        if(mid > right){
            right = midTemp - 1 // 压缩有边界至midTemp
            continue
        }

        if(words[mid] > s){
            right = mid - 1
        }
        else if(words[mid] < s){
            left = mid + 1
        }else{
            return mid
        }

    }
    return -1
};