算法| 动态规划dp

• 221.最大正方形
• 1143.最长公共子序列—1

221.最大正方形

/**
 * @param {character[][]} matrix
 * @return {number}
 */
// 思路
// dp初始化
// dp[i][j] 含义： 左 上  左上取 最小值  最后再加1
var maximalSquare = function (matrix) {
  const m = matrix.length;
  const n = matrix[0].length;
  const dp = Array(m)
    .fill(0)
    .map(() => Array(n).fill(0));

  let maxLen = 0;
  for (let i = 0; i < m; i++) {
    for (let j = 0; j < n; j++) {
      if (matrix[i][j] === "1") {
        if (i === 0 || j == 0) {
          dp[i][j] = 1;
        } else {
          dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]) + 1;
        }
        maxLen = Math.max(maxLen, dp[i][j]);
      }
    }
  }
  //   console.log(maxLen * maxLen);
  return maxLen * maxLen;
};

maximalSquare([
  ["1", "0", "1", "0", "0"],
  ["1", "0", "1", "1", "1"],
  ["1", "1", "1", "1", "1"],
  ["1", "0", "0", "1", "0"],
]);

1143.最长公共子序列—1

/**
 * @param {string} text1
 * @param {string} text2
 * @return {number}
 */
// 思路
// 构建dp 好像字符串比较是否相同 都是m+1 n+1 ，多一个，
// 双for循环时 s1取在第一个for之后取值 s2在第二个for里取值 ，都取前一个i-1 或者j-1
// dp[i][j]取值：相等时取左上角  不相等时取左或者上的最大值
// 返回结果
var longestCommonSubsequence = function (text1, text2) {
  const m = text1.length;
  const n = text2.length;

  const dp = Array(m + 1)
    .fill(0)
    .map(() => Array(n + 1).fill(0));

  for (let i = 1; i <= m; i++) {
    const s1 = text1[i - 1];
    for (let j = 1; j <= n; j++) {
      const s2 = text2[j - 1];
      if (s1 === s2) {
        dp[i][j] = dp[i - 1][j - 1] + 1;
      } else {
        dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
      }
    }
  }
  //   console.table(dp);
  return dp[m][n];
};

longestCommonSubsequence("abcde", "ace");
// ┌─────────┬───┬───┬───┬───┐
// │ (index) │ 0 │ 1 │ 2 │ 3 │
// ├─────────┼───┼───┼───┼───┤
// │    0    │ 0 │ 0 │ 0 │ 0 │
// │    1    │ 0 │ 1 │ 1 │ 1 │
// │    2    │ 0 │ 1 │ 1 │ 1 │
// │    3    │ 0 │ 1 │ 2 │ 2 │
// │    4    │ 0 │ 1 │ 2 │ 2 │
// │    5    │ 0 │ 1 │ 2 │ 3 │
// └─────────┴───┴───┴───┴───┘