刷完15道js版dp题，面试再也不怕了

最新推荐文章于 2023-02-21 14:10:44 发布
最新推荐文章于 2023-02-21 14:10:44 发布
阅读量600 收藏
点赞数
文章标签： leetcode javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67615103/article/details/129122234
版权

前言

某个男人 动态规划,而我作为一个致力称为厨师界最会写算法的前端，总得刷上一部分题，有那么一点发现吧，现在我们就来聊聊，菜鸡如我，发现了什么。

正文

汇总这周学习的现在，我脑壳疼的慌，啥东西都想不到，但是为了不破自己每周都总结一下下的目标，只能水几句了；

dp 好像是所有初级菜鸟的一个瓶颈，反正每次说到算法难在哪里，第一个想到的就是 dp， 去吹牛皮说面试别人装逼，就说随手甩几道 dp 去难为面试者的老哥层出不穷，所以 dp 有一种绝望之巅的赶脚，只要翻过它，就能进阶了；

其实学习算法到面试遇到的算法，用到 dp 的时候其实没有，树，链表这些反而是超火的热题，所以 dp 对于前端以面试为目的的算法学习，属于一种积累吧，就是经典题型学一学，遇到了原题搞一搞，遇到难题直接 pass ，就是高考数学倒数两题的感觉，所以呢，所以把最经典的复习一遍，然后。。我就一菜鸡，我也不知道, 反正后续应该会继续编吧，会学更深的 dp，毕竟这个东西是真的有意思，有兴趣的可以到这里学习一下大神的总结

以上，实在吹不下去了，下线，睡觉；下周做，位运算吧；加油呀

题目汇总

股票买卖

    1. 买卖股票的最佳时机
    1. 买卖股票的最佳时机 II
    1. 买卖股票的最佳时机 III
    1. 买卖股票的最佳时机 IV
    1. 最佳买卖股票时机含冷冻期
    1. 买卖股票的最佳时机含手续费

打家劫舍

    1. 打家劫舍
    1. 打家劫舍 II
    1. 打家劫舍 III

记忆化递归

    1. 杨辉三角
    1. 爬楼梯
  • 面试题 08.06. 汉诺塔问题

其他

    1. 零钱兑换
    1. 零钱兑换 II – 凑方案
    1. 最长回文子串

题目

121. 买卖股票的最佳时机

分析：

  1. 买卖 1 次， 不需要间隔, 不收手续费
  2. dp_0 表示没有持有的状态的最大利润，dp_1 表示持有状态下的最小成本
    2.5. 由于只进行一次交易，所以 dp_1要尽可能大的取，确保买入的成本最小，而 dp_0 也要保持最高，保证卖出最大
  3. 状态转移方程 dp_0 = Math.max(dp_0,dp_1+nums[i]), dp_1 = Math.max(dp_1,-nums[i])
  4. base case dp_0 =0 dp_1 = -nums[i]
var maxProfit = function(prices) {

    let dp_0 = 0,dp_1 = prices[0]
    for(let i = 0;i<prices.length;i++){
        dp_0 = Math.max(dp_0,dp_1+prices[i])
        dp_1 = Math.max(dp_1,-prices[i]) // 因为只会买卖一次，这里
    }
    return dp_0
}

122. 买卖股票的最佳时机 II

分析

  1. 买卖 n 次， 不需要间隔, 不收手续费
  2. dp[i][j] 表示在第 i+1 天（i 是下标值，对应的天数要+1），状态为 j 时，最大利润，其中 i 就是 [0,len-1]， j 为 0 表示没有持有，为 1 表示持有
  3. 状态转移方程: dp[i][0] = Math.max(dp[i-1][1]+temp, dp[i-1][0]), dp[i][1] =Math.max( dp[i-1][1], dp[i-1][0]-temp)
  4. base case: dp[0][0] = 0, dp[0][1] = -temp
  5. 时间复杂度 O(n),空间复杂度 O(n)
var maxProfit = function(prices) {
    const dp = new Array(prices).map(() => [])
    dp[0][0] = 0,dp[0][1] =prices[0]
    for (let i = 1; i < prices.length; i++) {
        dp[i][0] = Math.max(dp[i-1][1]+prices[i], dp[i-1][0])
        dp[i][1] =Math.max( dp[i-1][1], dp[i-1][0]-prices[i])
    }
    return dp[prices.length-1][0]
};

分析 – 压缩空间变量

  1. 压缩一下，将二维数组转成两个变量dp_0,dp_1
  2. 时间复杂度 O(n),空间复杂度 O(1)
var maxProfit = function(prices) {
    let dp_0 = 0,dp_1 = -prices[0]
    for (let i = 1; i < prices.length; i++) {
        const temp_0 = dp_0
        dp_0 = Math.max(dp_0,dp_1+prices[i])
        dp_1 = Math.max(temp_0-prices[i],dp_1)
    }
    return dp_0
}

123. 买卖股票的最佳时机 III

分析

  1. 买卖 2 次， 不需要间隔, 不收手续费
  2. dp[i][j][k] 表示在第 i+1 天（i 是下标值，对应的天数要+1），持有状态为 j , 买卖次数为 k 次时的最大利润，其中 i 就是 [0,len-1]， j 为 0 表示没有持有，为 1 表示持有
  3. 买入记作 1 次，卖出不记作一次交易
  4. 状态转移方程: dp[i][0][k] = Math.max(dp[i-1][0][k],dp[i-1][1][k]+prices[i]), dp[i][1][k] = Math.max(dp[i-1][1][k],dp[i-1][0][k-1]-prices[i])
  5. base case 1 – 交易次数为 0 次时的全部状态，如果此时是持有1，即和交易次数为 0 产生冲突，只要交易次数没涨上去，任何交易都是耍流氓，所以相当于没有交易 0 ；如果是没有持有0，那么初始化状态就是 0 了；
  6. base case 2 – 由于交易次数为 0 的状态已经处理完了，这里交易次数最少为 1 次，也就是说持有属于正常操作，不持有属于异常，给个 0 占个位置；
  7. 这里最难的地方是 base case 的确定，总之如果交易次数和持有状态发生异常，则代表交易失败，只有用了交易次数，持有状态同步更新，才算是一次正常的交易；

参考视频：传送门

var maxProfit = function (prices) {
    const dp = Array.from(prices).map(() => Array.from({length:2}).map(() => new Array(3)))
    const len = prices.length

    for(let i = 0;i<len;i++){
        for(let k = 1;k<=2;k++){
            // base case 1 -- 当 k 为 0 时
            dp[i][0][0]  = 0
            dp[i][1][0] = 0 // 只要交易次数没涨上去，任何交易都是耍流氓
            if(i === 0){
                // base case 2 -- 第一天时的状态 
                dp[0][0][k]  = 0 // 
                dp[0][1][k] = -prices[0]
                continue
            }
            dp[i][0][k] = Math.max(dp[i-1][0][k],dp[i-1][1][k]+prices[i])
            dp[i][1][k] = Math.max(dp[i-1][1][k],dp[i-1][0][k-1]-prices[i])
        }
    }
    return dp[len-1][0][2]
}

188. 买卖股票的最佳时机 IV

  1. 和123. 买卖股票的最佳时机 III是一样的操作和分析
  2. 值得注意的是，这题的入参， prices.length 的范围是 0,1000]， 所以需要进行判空处理；而 [123. 买卖股票的最佳时机 III 中的 prices.length 的范围是 [1,pow(10,5)], 所以可以直接使用
var maxProfit = function(k, prices) {
    const len = prices.length
    if(len<2) return 0
    // dp[i][j][k] -- i 为 [0,len-1] j:0,1 ; k 为 [0,k]
    const dp =Array.from(prices).map(() => Array.from({length:2}).map(() => new Array(k+1).fill(0)))
    for (let i = 0; i < prices.length; i++) {
        // base case1 -- 交易次数为 0 的时候
        dp[i][0][0] = 0
        dp[i][1][0] = 0
        for (let j = 1; j <= k; j++) {
            if(i === 0){
                // base case2 -- 第一天交易
                dp[0][0][j] = 0
                dp[0][1][j] = -prices[0]
                continue
            }
            dp[i][0][j] = Math.max(dp[i-1][0][j],dp[i-1][1][j]+prices[i])          
            dp[i][1][j] = Math.max(dp[i-1][1][j],dp[i-1][0][j-1]-prices[i])          
        }
    }
    return dp[prices.length-1][0][k]
};

309. 最佳买卖股票时机含冷冻期

分析

  1. 买卖 n 次， 需要间隔 1 天, 不收手续费
  2. dp_0_0 表示没有持有，不处于冷却期，dp_0_1 表示没有持有，处于冷却期, dp_1_0 正常情况，持有的时候没有冷却期， dp_1_1 属于矛盾的状态，忽略
  3. 状态转移方程:
    • dp_0_0 = Math.max(dp_0_0, dp_0_1);
    • dp_0_1 = dp_1_0 + prices[i];
    • dp_1_0 = Math.max(dp_1_0,temp - prices[i]);
  4. base case: dp_0_0 = 0, dp_0_1 = 0, dp_1_0 = -prices[0];
  5. 主要注意有冷却期的是没有持有才会触发，所以总共只有三种状态,dp_0_0 = 0, dp_0_1, dp_1_0； 所以可以直接将空间复杂度压缩到 O(1)
var maxProfit = function (prices) {
  const len = prices.length;
  if (len < 2) return 0;
  let dp_0_0 = 0,
    dp_0_1 = 0,
    dp_1_0 = -prices[0];

  for (let i = 1; i < len; i++) {
    const temp = dp_0_0;
    // 不在冷却中的没持有状态，证明上一次只可能是没有持有的状态
    dp_0_0 = Math.max(dp_0_0, dp_0_1);
    dp_0_1 = dp_1_0 + prices[i];
    dp_1_0 = Math.max(dp_1_0,temp - prices[i]);
  }
  return Math.max(dp_0_0, dp_0_1);
};

console.log(maxProfit([1, 2, 4]));

714. 买卖股票的最佳时机含手续费

分析

  1. 买卖 n 次， 无间隔, 收手续费
  2. 由于要收手续费，那么就不是怎么买卖都是好的了，必须将成本算上去，之前都是无本例如，只需要低买高卖就成，现在必须考虑可能会亏的可能
  3. 整体分析和 122. 买卖股票的最佳时机 II 一样，只是在卖出的时候，加上 fee 即可
 var maxProfit = function(prices, fee) {
    let dp_0 = 0, dp_1 = -prices[0]
    for (let i = 1; i < prices.length; i++) {
        const temp =dp_0
        dp_0 = Math.max(dp_0,dp_1 + prices[i] - fee)
        dp_1 = Math.max(dp_1,temp - prices[i])
    }
    return dp_0
};

198. 打家劫舍

分析

  1. dp[i][0] 表示在第 i 个房子没有偷东西时的最高金额， dp[i][1] 表示偷东西了的最高金额
  2. 状态转移方程: dp[i][0] = Math.max(dp[i-1][1],dp[i-1][0]) dp[i][1] = dp[i-1][0]+nums[i]
  3. base case dp[0][0] = 0 dp[0][1]= numns[0]
  4. 时间复杂度 O(n),空间复杂度 O(n)
var rob = function (nums) {
  const len = nums.length;
  const dp = new Array(len).fill(null).map(() => new Array(2));
  dp[0][0] = 0;
  dp[0][1] = nums[0];
  for (let i = 1; i < len; i++) {
    dp[i][0] = Math.max(dp[i - 1][1], dp[i - 1][0]);
    dp[i][1] = dp[i - 1][0] + nums[i];
  }

  return Math.max(dp[len - 1][0], dp[len - 1][1]);
};

分析

  1. 降维，每次的值只和前一个有关，且状态值只有两个，所以可以直接用两个变量 dp_0,dp_1 表示
  2. 时间复杂度 O(n),空间复杂度 O(n)
var rob = function (nums) {
    let dp_0 = 0,dp_1 = nums[0]
  for (let i = 1; i < len; i++) {
        const temp = dp_0 // 保存一下上一个 dp_0
        dp_0 = Math.max(dp_0,dp_1)
        dp_1 = temp+nums[i]
    }
    return Math.max(dp_0,dp_1)
}

213. 打家劫舍 II

分析

  1. dp[i][j][k] 其中 i 表示第 i 个值， j 表示第一个房子是否偷了，k 表示当前这个房子有没有偷
  2. 状态转移方程: dp[i][j][k] = dp[i-1][j][k]
  3. base case: dp[0][0][0] = 0, dp[0][1][1] = nums[0],dp[0][0][1] = -1,dp[0][1][0] = -1
  4. 时间复杂度 O(n) 空间复杂度 O(n)
 var rob = function (nums) {
  const len = nums.length;
  const dp = new Array(len)
    .fill(0)
    .map(() => new Array(2).fill(0).map(() => new Array(2).fill(-1)));
  (dp[0][0][0] = 0), (dp[0][1][1] = nums[0]);
  for (let i = 1; i < len; i++) {
    dp[i][0][0] = Math.max(dp[i - 1][0][0], dp[i - 1][0][1]);
    dp[i][0][1] = dp[i - 1][0][0] + nums[i];
    dp[i][1][0] = Math.max(dp[i - 1][1][0], dp[i - 1][1][1]);
    dp[i][1][1] = i === len - 1 ? dp[i - 1][1][1] : dp[i - 1][1][0] + nums[i];
  }
  return Math.max(dp[len - 1][0][0], dp[len - 1][0][1], dp[len - 1][1][0],dp[len - 1][1][1]);
};

分析

  1. 降维，每次的值只和前一个有关，且两个状态值分别只有两个item，所以可以直接用四个变量 dp_0_0,dp_1_1,dp_1_0,dp_0_1 保持迭代过程中的状态
  2. 时间复杂度 O(n),空间复杂度 O(n)
var rob = function (nums) {
  let dp_0_0 = 0, dp_1_1 = nums[0], dp_1_0 = -1,dp_0_1 = -1  
  for (let i = 1; i < nums.length; i++) {
    const temp_0_0 =  dp_0_0
    const temp_1_0 =  dp_1_0
    dp_0_0 = Math.max(dp_0_0,dp_0_1)
    dp_0_1 = temp_0_0 + nums[i]
    dp_1_0 = Math.max(dp_1_0,dp_1_1)
    dp_1_1 = i === nums.length - 1 ?  dp_1_1 : temp_1_0+nums[i]

  }
  return Math.max(dp_0_0,dp_1_1,dp_1_0,dp_0_1);
};

337. 打家劫舍 III

分析

  1. 自低向上求最大的状态值，每一个节点都返回两个状态值[dp_0,dp_1] , 其中 dp_0 表示没有取挡墙 root.val 的值，dp_1 表示取了当前val 的最大值
  2. 最开始也尝试使用自顶向下保持状态去取，但是可以取得单条路径的最大状态值，累加的话需要找出重复的状态节点，所以不太合适
  3. 自底向上取可以保证所有连线上的节点的状态都一一进行处理，最后汇总到根节点上，得到最大值，而自顶向下，最后其实是分散的，最大值在哪里不好确定，这里也不行一般的 dp 用数组保存所有状态值，所以为了就一个聚合值，也应该考虑是自底向上，求根节点的状态值
  4. 时间复杂度 O(n), 空间复杂度 O(1)
var rob = function (root) {
  const recursion = (root) => {
    if (!root) return [0, 0];
    const [ldp_0, ldp_1] = recursion(root.left);
    const [rdp_0, rdp_1] = recursion(root.right);

    const dp_0 = Math.max(
      ldp_0 + rdp_0,
      ldp_0 + rdp_1,
      ldp_1 + rdp_0,
      ldp_1 + rdp_1
    );
    const dp_1 = ldp_0 + rdp_0 + root.val;
    return [dp_0, dp_1];
  };
  const [dp_0, dp_1] = recursion(root);
  return Math.max(dp_0, dp_1);
};

118. 杨辉三角

分析

  1. 杨辉三角中，两条边都是 1
  2. 三角里的值 num[row][col] = num[row-1][col-1]+num[row-1][col]
  3. 只需要设置好边界，可以直接用 dp 缓存自顶向下遍历过的 num[row][col]
var generate = function(numRows) {
    const dp = new Array(numRows)
    for (let i = 0; i < numRows; i++) {
        dp[i] = new Array() ;
        for(let j = 0;j<=i;j++){
            // 杨辉三角的两边都是 1
            if(j ===  0  || j === i) {
                dp[i][j] = 1
                continue
            }
            dp[i][j] = dp[i-1][j-1]+dp[i-1][j]
        }      
    }
    return dp
};

console.log(generate(1))
console.log(generate(2))
console.log(generate(5))

70. 爬楼梯

分析 – 记忆化递归 – 自顶向下缓存对应的值

  1. 用 map 存储递归过程中存储不同楼梯长度 key, 对应的走法 value
  2. 每一次递归都先查 map 是否已经有答案，没有的时候再递归往下继续走
  3. base case，[0->1,1->1], 使用 map 缓存值，可以减少重复的中间操作，降低时间复杂度
  4. 时间复杂度 O(n),空间复杂度 O(n)
var climbStairs = function(n) {
    const map = new Map()
    map.set(1,1)
    map.set(0,1)
    const recursion= (n) => {
        if(map.has(n)) return map.get(n)
        const sum =  recursion(n-1)+recursion(n-2)
        map.set(n,sum)
        return sum
    }
    return recursion(n)
};

@分析 – dp

  1. 使用 dp[i] 表示楼梯为 i 时，有多少种走法
  2. 状态转移方程: dp[i] = dp[i-1]+dp[i-2]
  3. base case: dp[0] + dp[1] = 1 – 啥也不走也是一种走法
  4. 时间复杂度 O(n),空间复杂度 O(n)
var climbStairs = function(n) {
    const dp = []
    dp[1] = 1
    dp[0] = 1
    for (let i = 2; i <= n; i++) {
        dp[i] = dp[i-1]+dp[i-2]
    }
    return dp[n]
}

面试题 08.06. 汉诺塔问题

分析

  1. 这个一个典型的递归问题,每一次都要将 n 个值从 first启动，经过 second，最后到达 end
  2. 拆解一下，如果 n === 1，直接从 first -> end 即可
  3. 如果有 n > 1, 那么需要先将 n-1 个值从 first -> end -> second 存储起来，将剩下的一个直接从 first -> end
  4. 经过步骤3，当前first 是空的,second 有 n-1 个值， end 有 1个最大值，现在这种情况等价于将 n-1 个值从 second -> first -> end ， 这样最后就能在 end 中找到一个完整的 n 个值的数组了
  5. 时间复杂度O(n2)
var hanota = function(A, B, C) {
    const len = A.length;
    const recursion = (n,first,second,end) => {
        if(n === 1) {
            const a = first.pop()
            end.push(a)
            return
        }
        // 将 n-1 个值从 first -> end -> second, 然后将最后的值从 first 移动到 end
        recursion(n-1,first,end,second)
        end.push(first.pop())
        // 现在 end 有一个值， second 有 n-1 个值 ， first 为空
        // 再将 n-1 个值从 second -> first -> end
        recursion(n-1,second,first,end)
    }
    recursion(len,A,B,C)
};

322. 零钱兑换

分析 – 硬币数无限

  1. 状态定义：dp[i] 表示凑成总金额为 i 时所需的最少的硬币数
  2. 状态转移方程: dp[i] = Math.min(dp[i-coins[x]])+1 – 分别计算出上一次取一枚硬币时，最小的数，然后+1即可
  3. base case: dp[0] = 0
  4. 时间复杂度 O(n∗m) 其中 n 是硬币数量，m 是金额总数，空间复杂度为 O(m)
var coinChange = function (coins, amount) {
  const dp = new Array(amount + 1)
  // base case
  dp[0] = 0; // 如果总金额为0，则不需要取了
  for (let i = 1; i <= amount; i++) {
    dp[i] = Infinity //初始化
    for (coin of coins) {
      if (i >= coin) {
        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
      }
    }
  }
  return dp[amount] === Infinity ? -1 : dp[amount];
};

// 两层遍历是无所谓 的，排列组合都 ok，因为求的是一个极值
var coinChange = function (coins, amount) {
  const dp = new Array(amount + 1).fill(Infinity);
  // base case
  dp[0] = 0; // 如果总金额为0，则不需要取了
  for (coin of coins) {
    for (let i = 1; i <= amount; i++) {
      if (i >= coin) {
        dp[i] = Math.min(dp[i], dp[i - coin] + 1);
      }
    }
  }
  return dp[amount] === Infinity ? -1 : dp[amount];
};

518. 零钱兑换 II – 凑方案

分析

  1. 一直不理解为什么必须是外层写 coins 的循环，内层写 amount 循环，因为这个 322. 零钱兑换 还是有点类似的，都是凑钱，一个是凑最小的数，而我这里凑的方案
  2. 也正因为凑的是方案数，所以 1-2-1 和 1-1-2 是一样的方案，这里要的只是组合，而不需要排列；
  3. 所以如果外层是 amount，就考虑到了每一次取硬币的顺序，得到的是一个排列数，与本题不符合，所以把 coins 放外层，那么整个方案设计就只和硬币的类型有关，和取的顺序无关了 – 有感于此，在上面那题加一个 coins 外层嵌套的写法也是 ok 的；
  4. 状态定义：dp[i] 表示凑成总金额为 i 时存在的方案 – 给定 amount 硬币数组，硬币种类不一样，得到的方案数不一样
  5. 状态转移方程: dp[i] = sum(dp[i-coin]) – 分别计算出取走一枚硬币时，能够凑出的方案数
  6. base case: dp[0] = 1 //不取也是一种方案
  7. 时间复杂度 O(n∗m) 其中 n 是硬币数量，m 是金额总数，空间复杂度为 O(m)
var change = function (amount, coins) {
  const dp = new Array(amount + 1).fill(0); //凑不齐就是 0 个方案了
  dp[0] = 1; //不取也是一种方案

    // 相当于背包问题中，背包里的东西有哪些，每多一样东西，就可以更新方案
  for (coin of coins) {
    for (let i = coin; i <= amount; i++) {
        // 只有比当前币值高的，才需要更新方案数
      dp[i] = dp[i] + dp[i - coin];
    }
  }
  return dp[amount];
};

5. 最长回文子串

分析

  1. 状态定义 – dp[i][j] 表示 在[i,j]的子串是一个回文子串
  2. 状态转移方程: dp[i][j] = s[i] === s[j] && dp[i+1][j-1]
  3. base case: j-i<1 && s[i] === s[j] 时，dp[i][j] = true, 他们就是回文子串
  4. dp 是根据已知值去推断无后续性的值，所以要求 dp[i][j] 的时候，要不 dp[i+1][j-1] 已经知道，要不就是一个 base case
  5. 所以外层包裹的是一个终点值，然后 i 处于内层向前扩展
 var longestPalindrome = function(s) {
    const dp =Array.from(s).map(() => new Array()) 
    let ret = ''
    for(let j = 0;j <s.length;j++){
        for(let i =j;i>=0;i--){
            if( j-i<2 && s[i] === s[j]){
                // base case : 单个字符
                dp[i][j] = true
            }else if(s[i] === s[j] && dp[i+1][j-1]){
                dp[i][j] = true
            }
            if(dp[i][j] && j-i+1>ret.length){
                ret = s.slice(i,j+1)
            }
        }   
    }
    return ret
};
hellocoder2028
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何在jsp/html中使用dp单位
百度一下 猎人社区
06-19 1202
在 JSP/HTML 中，通常使用 px、em 等单位描述页面元素尺寸，但是有时候我们也需要使用更加灵活的单位，例如 dp。需要注意的是，使用 DP 单位虽然可以提高页面元素在不同分辨率设备上的适配能力，但由于 Web 开发中的屏幕适配与 Android 开发有所不同，因此使用 DP 单位时需要结合实际情况进行灵活运用。首先，我们需要导入相关的样式库，以便在样式表中使用 DP 单位。在上面的代码中，我们使用 toPx() 函数将使用 DP 单位描述的页面元素尺寸转换成像素单位，并应用到 .box 元素上。
【算法】JS DP 二分 力扣6346. 打家劫舍 IV
qq_53512708的博客
02-05 154
力扣周赛6346. 打家劫舍 IV 通过DP+二分解决
js dp动态规划例题
喜大普奔
02-21 311
dp动态规划题目 2023-2-21
程序员面试金典 – 面试题 17.24. 最大子矩阵（转成一维最大子序和 DP）
12-21
文章目录1. 题目2. 解题2.1 前缀和（超时）2.2 动态规划 1. 题目 给定一个正整数和负整数组成的 N × M 矩阵，编写代码找出元素总和最大的子矩阵。 返回一个数组 [r1, c1, r2, c2]，其中 r1, c1 分别代表子矩阵左上...
程序员面试金典 – 面试题 17.16. 理发师（动态规划DP）
12-22
注意：本题相对原题稍作改动 示例 1： 输入： [1,2,3,1] 输出： 4 解释： 选择 1 号预约和 3 号预约，总时长 = 1 + 3 = 4。 示例 2： 输入： [2,7,9,3,1] 输出： 12 解释： 选择 1 号预约、 3 号预约和 5 号预约，总...
Azure DP-203考试题
05-15
Azure DP-203的考试题，包括参考答案和答案解释，文档详细介绍
（剑指offer）面试题14- I. 剪绳子
12-21
题目 给你一根长度为 n 的绳子，请把绳子剪...最优解的结构为：dp[i] = max(i-j,dp[i-j] ) * max(j,dp[j]) 数学法：根据数学定理，当所有绳段长度相等时，乘积最大。并且最优的绳段长度为 3 。 代码 /** * 动态规划法
前端单位换算
pick_ears的博客
01-04 804
1dp = 1.5px=3rpx 1px = 2rpx 1.5px = 3rpx计算
jSDP-开源
05-13
IETF协议SDP为描述多媒体会话的信息提供了标准表示。 此信息作为有效负载包含在其他协议消息中。 jSDP是一个Java库，使用户能够操纵SDP消息
【算法】JS DP 力扣6299拆分数组的最小代价
qq_53512708的博客
01-22 125
力扣329周赛6299拆分数组的最小代价，JS+DP解题
前端基础知识概述 -- 移动端开发的屏幕、图像、字体与布局的兼容适配
油墨香^-^的博客
09-05 1060
首先先聊聊响应式设计，这个与移动端开发有着密切的联系。响应式设计即是 RWD，Responsive Web Design。这里百度或者谷歌一下会有各种各样的答案。这里一段摘自知乎上我觉得很棒的一个答案：什么是响应式布局设计？（地址：https://www.zhihu.com/question/20976405）根据维基百科及其参考文献，理论上，响应式界面能够适应不同的设备。
CSS中那些px、em、pt、rem、%、dp（android）单位
热门推荐
ime33的博客
01-14 1万+
未经允许，不得转载！！ 水平有限，写的不周之处欢迎指正、交流！ 在前端开发中，遇到单位的时候会有几种选择，那到底用哪种单位才是最合适的呢？ 在国内的一些美工设计大师，在设计的时候多偏向于px单位，而在国外呢，大多喜欢使用em和rem作为单位。 一、px单位（pixel相对长度单位）相对于用户的设备分辨率而定，推荐使用。 特点： 1.低版本 IE无法调整那些使用px作为单
dpi 、 dip 、分辨率、屏幕尺寸、px、density 关系以及换算
07-14 1427
一、基本概念 dip ： Densityindependent pixels ，设备无关像素。 dp ：就是dip px ： 像素 dpi ：dots per inch ， 直接来说就是一英寸多少个像素点。常见取值 120，160，240。我一般称作像素密度，简称密度 density ： 直接翻译的话貌似叫 密度。常见...
dp与px的转换
大啊大前端
11-16 498
今天使用LayoutParams设置LinearLayout大小的时候遇到了这个问题，在xml布局中长和宽都是100dp,想要 改变为80dp,80dp,直接设置时出现了问题，和预期不一样。然后想到了屏幕密度的问题。 LayoutParams params = new LayoutParams(80,80); ll.setLayoutParams(params); 在new
搞懂移动端网页中viewport、retina、高清图、dp单位等
laokdidiao的专栏
11-20 2186
一直以来，web移动端都有这么几个问题困扰着我： 单位太多，除了px、rem，其他单位到底啥意思？ 设计师经常会问前端，我到底按照什么尺寸出设计稿？ 高清图怎么做出来的？ 边框1px，为什么在不同手机中粗细完全不同？ 妈蛋，为何移动端总要在meta中width=device-width, initial-scale=1…写这么一句 什么是viewport？ 我相信我的问题也困扰着你，且听我娓娓道来
编辑距离DP算法
漏れた玩具博客
06-30 1266
偶然看到这道经典题，顺便复习下DP， 由于懒得做图，所以，需要图片或者其他讲法，请参考这篇https://blog.csdn.net/chichoxian/article/details/53944188。 可能你需要配合这位作者的图片才能更好理解有两个字符串str1跟str2， 设他们的最短距离为str1变为str2的操作最小次数，有以下三种操作1. 插入字符，如abc  -&gt; abcd2...
数塔——DP算法
JSASL的博客
03-28 1104
在讲述DP算法的时候，一个经典的例子就是数塔问题，它是这样描述的： 有如下所示的数塔，要求从顶层走到底层，若每一步只能走到相邻的结点，则经过的结点的数字之和最大是多少？ 已经告诉你了，这是个DP的题目，你能AC吗? Input 输入数据首先包括一个整数C,表示测试实例的个数，每个测试实例的第一行是一个整数N(1 <= N <= 100)，表示数塔的高度，接下来用N行数字表示数塔，其中...
python算法面试题
最新发布
05-16
Python算法面试题比较多，常见的考点有数据结构、动态规划、贪心算法、递归与分治、字符串处理与正则表达式等等。以下以具体题目进行分析： 1. “用Python实现斐波那契数列”： 斐波那契数列是一个经典的算法问题...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值