java刷题-动态规划

1.word-break

原题链接：www.nowcoder.com

题目描述：Given a string s and a dictionary of words dict, determine if s can be segmented into a space-separated sequence     of one or more dictionary words.

For example, given
s ="leetcode",
dict =["leet", "code"].

Return true because"leetcode"can be segmented as"leet code".

public boolean wordBreak(String s, Set<String> dict) {
        int len = s.length();
        boolean[]  flag = new boolean[len+1];
        flag[0] = true;
        for (int i = 1; i <=len; i++) {
            for (int j = 0; j < i; j++) {
                if (flag[j]&&dict.contains(s.substring(j,i))){
                    flag[i] = true;
                }
            }
        }
        return flag[len];
    }

2.word-break-ii

原题链接：www.nowcoder.com

题目描述：

Given a string s and a dictionary of words dict, add spaces in s to construct a sentence where each word is a valid dictionary word.Return all such possible sentences.

For example, given
s ="catsanddog",
dict =["cat", "cats", "and", "sand", "dog"].

A solution is["cats and dog", "cat sand dog"].

import java.util.ArrayList;
import java.util.Set;

public class Solution {

    ArrayList<String> list = new ArrayList<>();

     public ArrayList<String> wordBreak(String s, Set<String> dict) {
        dfs(s,s.length(),"",dict);
         return list;
    }
    
    private void dfs(String s,int index,String str,Set<String> set){
        if (index<=0){
            if (str.length()>0){
                list.add(str.substring(0,str.length()-1));
            }
        }
        for (int i = index; i >=0 ; i--) {
            if (set.contains(s.substring(i,index))){
                dfs(s,i,s.substring(i,index)+" "+str,set);
            }
        }
    }
}

3.分发糖果

老师想给孩子们分发糖果，有 N 个孩子站成了一条直线，老师会根据每个孩子的表现，预先给他们评分。

你需要按照以下要求，帮助老师给这些孩子分发糖果：每个孩子至少分配到 1 个糖果。
相邻的孩子中，评分高的孩子必须获得更多的糖果。
那么这样下来，老师至少需要准备多少颗糖果呢？

链接：https://leetcode-cn.com/problems/candy

示例 1:

输入: [1,0,2]
输出: 5
解释: 你可以分别给这三个孩子分发 2、1、2 颗糖果。

    public class Solution {
        
        public int candy(int[] ratings) {
            int n = ratings.length;
            int[] candys = new int[n];
            //先从左往右遍历 如果 ratings[i]>ratings[i-1] 则后面的糖果要比前面的糖果多一个
            for (int i = 1; i < n; i++) {
                if (ratings[i]>ratings[i-1]){
                    candys[i] = candys[i-1]+1;
                }
            }
            /**
             * 从前往后遍历只能确保后面数字大的人分的糖果比前面的多 不能保证 ratings[i]< ratings[i-1] 情况
             * 从后往前遍历 确保党 ratings[i] > ratings[i+1] && candys[i]<=candys[i+1]
             */
            
            for (int i = n-2; i >=0; i--) {
                if (ratings[i]>ratings[i+1]&&candys[i]<=candys[i+1]){
                    candys[i]=candys[i+1]+1;
                }
            }
            int sum = 0;
            for (int i = 0; i < n; i++) {
                sum += candys[i];
            }
            //每个人至少分一个糖果
            return sum+n;
        }
    }
    

4.分割回文串-ii

给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。返回符合要求的最少分割次数。示例:

输入: "aab"
输出: 1
解释: 进行一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
链接：https://leetcode-cn.com/problems/palindrome-partitioning-ii
 

public class Solution {
public int minCut(String s) {
        if (s.length() <2) return 0;
        int len = s.length();
        int[] dp = new int[len];    //转态转移方程
        for (int i = 1; i < len; i++) {
            //如果字符串是回文，则不需要切割 dp[i]=0，否则定义最大切割数dp[i]=1
            dp[i] = ispld(s.substring(0,i+1))?0:i;
            if (dp[i]!=0){
                /** s.substring(0,i+1)不是回文
                 * 此时dp[i] = i ，是最坏的情况
                 * 字符串为左开又闭  所以切割为 j->i+1
                 * 判断  0<=j<=i 内部是否有回文
                 */
                for (int j = i; j >0 ; j--) {
                    if (ispld(s.substring(j,i+1))){
                        // 字符串：0-i+1被分成两部分 dp[j-1]  j->i+1 是回文 1：表示j->i+1是回文 不用切了 dp[i] = dp[j-1]+1
                        dp[i] = Math.min(dp[i],dp[j-1]+1);
                    }
                }
            }
        }
 
        return dp[s.length()-1];
    }
 
    //判断字符串是否是回文
    private static boolean ispld(String s){
        int len = s.length();
        for (int i = 0; i < len/2; i++) {
            if (s.charAt(i)!=s.charAt(len-i-1)){
                return false;
            }
        }
        return true;
    }
 
}