LeetCode 91. 解码方法 120. 三角形最小路径和 97. 交错字符串 131. 分割回文串 132. 分割回文串 II

最新推荐文章于 2023-12-04 10:53:16 发布

茶色岛^

最新推荐文章于 2023-12-04 10:53:16 发布

阅读量326

点赞数

分类专栏： LeetCode 文章标签： leetcode 算法职场和发展

本文链接：https://blog.csdn.net/weixin_62275996/article/details/128773755

版权

LeetCode 专栏收录该内容

92 篇文章 0 订阅

订阅专栏

🌈🌈😄😄

欢迎来到茶色岛岛屿，本文带来的是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];
    }
}

茶色岛^

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
LeetCode 91. 解码方法 120. 三角形最小路径和 97. 交错字符串 131. 分割回文串 132. 分割回文串 II

欢迎来到茶色岛岛屿，本文带来的是LeetCode 91. 解码方法 120. 三角形最小路径和 97. 交错字符串 131. 分割回文串 132. 分割回文串 II
复制链接

扫一扫