关于dp数组推导过程的确定

一般情况下, 关于推导dp数组, 有两种推导思路

 

1 通过dp数组直接存储目的值的方式, 每一个推导都是为了求出本层的目的值 (这种情况下, 可能待存储属性具有多种状态, 但是我们只考虑其中一种状态, 这种情况之下, 往往dp数组是一维的, 数组的最后一个数据就是我们要求的目的值.

2 通过dp数组存储不同属性的不同的状态值, 这种情况下, 我们往往要考虑带存储属性的不同状态, dp数组往往是多维的, 对于dp数组的每一级的每一种状态值的确定, 都需要根据前级的多种不同状态来确定

 

做题时, 使用第二种思路可能会更加的容易考虑, 但是也好像会超时. 使用第一种思路, 最终获取结果可能会更容易, 不过想到题解的话好像会更难一点, 其实吧, 两种思路很相像, 只不过是自己可能考虑的不够充分或者经验不足, 才导致了一些超时的问题

 

例题: (LeetCode题目1143)

思路一代码: 

 

public class _1143_Solution {

    public int longestCommonSubsequence(String text1, String text2) {

        int size1 = text1.length();
        int size2 = text2.length();
        // 首先确定dp数组的容量来源, 然后确定需要存放属性的对象实体, 然后确定需要存放属性的多种状态
        // 确定dp数组及其下标的含义
        int[][] dp = new int[size1+1][size2+1];
        // dp数组初始化
        for (int i = 0; i <= size1; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= size2; j++) {
            dp[0][j] = 0;
        }

        // 依次为dp数组赋值
        for (int i = 1; i <= size1; i++) {
            for (int j = 1; j <= size2; j++) {

                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
          
                    dp[i][j] = dp[i-1][j-1] + 1;
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
                }
            }

            // 打印dp数组, 查看结果是否符合预期
            System.out.print("这是第" + i + "行的数据: ");
            for (int m = 1; m <= size2; m++) {
                System.out.print(dp[i][m] + "---");
            }
            System.out.println();

        }

        // 找到二维数组中的最大值
        int max = 0;
        for (int i = 0; i <= size1; i++) {
            for (int j = 0; j <= size2; j++) {
                if (dp[i][j] > max) {
                    max = dp[i][j];
                }
            }
        }
        return max;
    }

    public static void main(String[] args) {
        _1143_Solution solution = new _1143_Solution();
        System.out.println(solution.longestCommonSubsequence("abcba", "abcbcba"));
    }
}

 思路二代码:

　

class Solution {
    public int longestCommonSubsequence(String text1, String text2) {

        int size1 = text1.length();
        int size2 = text2.length();
        // 首先确定dp数组的容量来源, 然后确定需要存放属性的对象实体, 然后确定需要存放属性的多种状态
        // 确定dp数组及其下标的含义
        int[][] dp = new int[size1+1][size2+1];
        // dp数组初始化
        for (int i = 0; i <= size1; i++) {
            dp[i][0] = 0;
        }
        for (int j = 0; j <= size2; j++) {
            dp[0][j] = 0;
        }

        // 依次为dp数组赋值
        for (int i = 1; i <= size1; i++) {
            for (int j = 1; j <= size2; j++) {

                if (text1.charAt(i - 1) == text2.charAt(j - 1)) {
                    // 找到这两个之前的最大值, 然后加一
                    int max = 0;
                    for (int m = 0; m < i; m++) {
                        for (int n = 0; n < j; n++) {
                            if (dp[m][n] > max) {
                                max = dp[m][n];
                            }
                        }
                    }
                    dp[i][j] = max+1;
                } else {
                    dp[i][j] = 0;
                }
            }


        }

        // 找到二维数组中的最大值
        int max = 0;
        for (int i = 0; i <= size1; i++) {
            for (int j = 0; j <= size2; j++) {
                if (dp[i][j] > max) {
                    max = dp[i][j];
                }
            }
        }
        return max;
    }
}