🌈🌈😄😄
欢迎来到茶色岛岛屿，本文带来的是LeetCode 91. 解码方法 120. 三角形最小路径和 97. 交错字符串 131. 分割回文串 132. 分割回文串 II
🌲🌲🐴🐴
91. 解码方法
一、力扣示例
91. 解码方法 - 力扣（LeetCode）
https://leetcode.cn/problems/decode-ways/
二、解决办法
动态规划
对于给定的字符串 s，设它的长度为 n，其中的字符从左到右依次为 s[1],s[2],⋯,s[n]。我们可以使用动态规划的方法计算出字符串 s 的解码方法数。
具体地，设 fi 表示字符串 s 的前 i 个字符 [1..]s[1..i] 的解码方法数。
状态转移方程：
第一种情况 fi=fi−1,其中 s[i]=0
第二种情况 fi=fi−2,其中 s[i−1]=0 并且 10⋅s[i−1]+s[i]≤26
三、代码实现
class Solution {
public int numDecodings(String s) {
int n = s.length();
int[] f = new int[n + 1];
f[0] = 1;
for (int i = 1; i <= n; ++i) {
if (s.charAt(i - 1) != '0') {
f[i] += f[i - 1];
}
if (i > 1 && s.charAt(i - 2) != '0' && ((s.charAt(i - 2) - '0') * 10 + (s.charAt(i - 1) - '0') <= 26)) {
f[i] += f[i - 2];
}
}
return f[n];
}
}
注意到在状态转移方程中，f i的值仅与 f i−1和 f i−2有关，因此我们可以使用三个变量进行状态转移，省去数组的空间。
class Solution {
public int numDecodings(String s) {
int n = s.length();
// a = f[i-2], b = f[i-1], c=f[i]
int a = 0, b = 1, c = 0;
for (int i = 1; i <= n; ++i) {
c = 0;
if (s.charAt(i - 1) != '0') {
c += b;
}
if (i > 1 && s.charAt(i - 2) != '0' && ((s.charAt(i - 2) - '0') * 10 + (s.charAt(i - 1) - '0') <= 26)) {
c += a;
}
a = b;
b = c;
}
return c;
}
}
120. 三角形最小路径和
一、力扣示例
120. 三角形最小路径和 - 力扣（LeetCode）https://leetcode.cn/problems/triangle/
二、解决办法
动态规划
定义了一个 N 行 N 列 的 dp 数组
但是在实际递推中我们发现，计算 dp[i][j] 时，只用到了下一行的 dp[i+1][j] 和 dp[i+1][j+1]。
因此 dp 数组不需要定义 N 行，只要定义 1 行就可以了，每行中只会选择 dp[i+1][j] 或 dp[i+1][j+1]中的一个，故定义一维数组[] dp即可。
三、代码实现
class Solution {
public int minimumTotal(List<List<Integer>> triangle) {
int n = triangle.size();
int[] dp = new int[n + 1];
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= i; j++) {
dp[j] = Math.min(dp[j], dp[j + 1]) + triangle.get(i).get(j);
}
}
return dp[0];
}
}
时间复杂度：O(N2)，N 为三角形的行数。
空间复杂度：O(N)，N 为三角形的行数。
97. 交错字符串
一、力扣示例
97. 交错字符串 - 力扣（LeetCode）https://leetcode.cn/problems/interleaving-string/
二、解决办法
动态规划
三、代码实现
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
int n = s1.length(), m = s2.length(), t = s3.length();
if (n + m != t) {
return false;
}
boolean[] f = new boolean[m + 1];
f[0] = true;
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
int p = i + j - 1;
if (i > 0) {
f[j] = f[j] && s1.charAt(i - 1) == s3.charAt(p);
}
if (j > 0) {
f[j] = f[j] || (f[j - 1] && s2.charAt(j - 1) == s3.charAt(p));
}
}
}
return f[m];
}
}
class Solution {
public boolean isInterleave(String s1, String s2, String s3) {
int n = s1.length(), m = s2.length(), t = s3.length();
if (n + m != t) {
return false;
}
boolean[][] f = new boolean[n + 1][m + 1];
f[0][0] = true;
for (int i = 1; i <= n ; i++) {
if(s1.charAt(i-1) == s3.charAt(i-1))
f[i][0] = true;
else
break;
}
for (int j = 1; j <= m ; j++) {
if(s2.charAt(j-1) == s3.charAt(j-1))
f[0][j] = true;
else
break;
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
f[i][j] = (f[i - 1][j] && s3.charAt(i + j - 1) == s1.charAt(i - 1))
|| (f[i][j - 1] && s3.charAt(i + j - 1) == s2.charAt(j - 1));
}
}
return f[n][m];
}
}
131. 分割回文串
一、力扣示例
131. 分割回文串 - 力扣（LeetCode）https://leetcode.cn/problems/palindrome-partitioning/
二、解决办法
回溯 + 动态规划预处理
这段代码的作用是初始化f数组，因为f数组在后面的代码中用于存储子串s[i, j]是否为回文串的信息。在这里将所有元素都初始化为true，表示所有子串都是回文串，这样在后面的代码中才能继续进行搜索。
这里使用了一种较为巧妙的DP解法，就是预处理出所有子串是否是回文串，这样在之后的代码中就可以在O(1)的时间复杂度内判断子串是否是回文串了。
这段代码中，变量i表示当前遍历到的子串的起始位置,j为右指针。在这个循环中，使用变量j来遍历该子串的终止位置，从i到n-1。如果f[i][j]为true，表示s.substring(i, j+1)是一个回文串。因此，将它加入答案中，并继续遍历s.substring(j+1)。最后在回溯时，将s.substring(i, j+1)从答案中删除。
三、代码实现
class Solution {
boolean[][] f;
List<List<String>> ret = new ArrayList<List<String>>();
List<String> ans = new ArrayList<String>();
int n;
public List<List<String>> partition(String s) {
n = s.length();
f = new boolean[n][n];
for (int i = 0; i < n; ++i) {
Arrays.fill(f[i], true);
}
for (int i = n - 1; i >= 0; --i) {
for (int j = i + 1; j < n; ++j) {
f[i][j] = (s.charAt(i) == s.charAt(j)) && f[i + 1][j - 1];
}
}
dfs(s, 0);
return ret;
}
public void dfs(String s, int i) {
if (i == n) {
ret.add(new ArrayList<String>(ans));
return;
}
for (int j = i; j < n; ++j) {
if (f[i][j]) {
ans.add(s.substring(i, j + 1));
dfs(s, j + 1);
ans.remove(ans.size() - 1);
}
}
}
}
132. 分割回文串 II
一、力扣示例
132. 分割回文串 II - 力扣（LeetCode）https://leetcode.cn/problems/palindrome-partitioning-ii/
二、解决办法
动态规划
- g数组是用来存储子串是否为回文串的二维数组。g[0][i]表示从0到i的子串是否为回文串。
- 所以这一行的作用是如果从0到i的子串是回文串，那么到i这个位置的最小分割数就应该是0，因为回文串本身就是回文串，不需要再进行分割。
- Arrays.fill(f, Integer.MAX_VALUE); 这一行的作用是使用 Integer.MAX_VALUE 填充整个 f 数组。在这里，Integer.MAX_VALUE 是 int 类型的最大值，它的值为 2147483647。使用这个值来初始化 f 数组是因为在程序中，f 数组用来存储到当前位置的最小分割数，而最小分割数不可能是无限大，所以使用 int 类型最大值来初始化，以保证在程序中能找到真正的最小值。
三、代码实现
class Solution {
public int minCut(String s) {
int n = s.length();
boolean[][] g = new boolean[n][n];
for (int i = 0; i < n; ++i) {
Arrays.fill(g[i], true);
}
for (int i = n - 1; i >= 0; --i) {
for (int j = i + 1; j < n; ++j) {
g[i][j] = s.charAt(i) == s.charAt(j) && g[i + 1][j - 1];
}
}
int[] f = new int[n];
Arrays.fill(f, Integer.MAX_VALUE);
for (int i = 0; i < n; ++i) {
if (g[0][i]) {
f[i] = 0;
} else {
for (int j = 0; j < i; ++j) {
if (g[j + 1][i]) {
f[i] = Math.min(f[i], f[j] + 1);
}
}
}
}
return f[n - 1];
}
}
