单词拆分/分割等和子集

1.单词拆分

二维dp的思路还是比较复杂（目前看）

java 复制代码

class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        Set<String> dict = new HashSet<>(wordDict);

        int n = s.length();
        //以下标i结尾的是否可以频出
        boolean[][] dp = new boolean[n][n];

        for(int i =0;i<n;i++){
            for(int j = i;j<n;j++){
                if(dict.contains(s.substring(i,j+1))){//左实右虚
                    dp[i][j] = true;
                }
            }
        }

//1.二维dp，先枚举长度
    for(int len = 1;len<=n;len++){

        for(int i = 0;i<=n-len;i++){//2.起始坐标
            int j = i+len-1; //3.终点坐标

            if(dp[i][j]){
                continue;//跳过本次循环，i++

            }
            for(int k =i;k<j;k++){
                //5.选择一种可以把这块，用已有字典切分的方案就行
                if(dp[i][k]&&dp[k+1][j]){
                    dp[i][j] =true;
                    break;//就知道了i，j 可以切分， 跳出循环
                }
            }
        }
    }


        return dp[0][n-1];
    }
}

2.分割等和子集

java 复制代码

class Solution {
    public boolean canPartition(int[] nums) {
        //这里【有点类似背包问题
        //dp[i][j] 选择前i个数，能否和为j

        //
        int sum = 0;
        for(int i = 0;i<nums.length;i++){
            sum+= nums[i];
        }
        if(sum%2 !=0){
            return false;
        }
        int target = sum/2;
        boolean[][] dp = new boolean[nums.length][target+1];
        dp[0][0] = true;
        for(int i =0;i<nums.length;i++){
            dp[i][0] = true;

        }
        for(int i = 1;i<nums.length;i++){
            for(int j = 1;j<=target;j++){
                if(nums[i]>j){
                    dp[i][j] = dp[i-1][j];
                }else{
                    dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]];//选或者不选
                }
            }
        }
        return dp[nums.length-1][target];
    }
}

上述代码需要下面的补充，同时注意选择第0个元素的时候初始化，<= 这样选择是为了可以状态转移递推过去

即使小于在计算的时候，如（1，2）也会被偶数限制条件return;(8,2,2,2)就是无法划分的就是false初始化的时候

java 复制代码

// 初始化第0行
dp[0][0] = true;
if(nums[0] <= target){
    dp[0][nums[0]] = true;  // ⭐ 选第0个元素
}

// 初始化第0列
for(int i = 1; i < nums.length; i++){
    dp[i][0] = true;
}

3.最长有效括号（这个耗得时间长些）

java 复制代码

class Solution {
    public int longestValidParentheses(String s) {
        //dp[i] 表示以i坐标为结尾的最长有效括号字串长度
        int maxLen = 0;
        int pre = 0;
        char[] chars = s.toCharArray();
        int[] dp = new int[s.length()];

        for(int i =1;i<s.length();i++){
            if(chars[i] == ')'){
                //推测上一个'('可能的位置
                pre = i - dp[i-1] -1;

                            if(pre>0 && chars[pre]=='('){
            dp[i] = dp[i-1] + 2 + dp[pre-1];
            }
             if(pre==0 && chars[pre]=='('){
            dp[i] = dp[i-1] + 2 ;
            }

            }


            maxLen =Math.max(maxLen,dp[i]);
        } 
        return maxLen;
    }
}