leetcode --动态规划

题目1 .  字符串正则匹配

https://leetcode.com/problems/wildcard-matching/

题目概述：s是字符串，p是匹配符号。  ？和*是两种匹配模式，？匹配单字符，*匹配任意字符串或空。判断 s和p是否匹配。

题解： 采用动态规划的思想，当两个字符串相等的或者p为'?'的时候，dp[i][j] = dp[i-1][j-1] 表示 p串的i和s串的j的匹配情况。

当p为 *的时候 有三种可能，匹配了0个，匹配了1个，匹配了多个  分别对应于  dp[i][j] = dp[i-1][j-1] || dp[i-1][j] || dp[i][j-1] 。

特别要注意的是 dp[0][0] = true 

class Solution {
    public boolean isMatch(String s, String p) {
        boolean[][] dp = new boolean[p.length()+1][s.length()+1];
        
        dp[0][0] = true;
        for(int i=1;i<=p.length();i++){
            if(p.charAt(i-1) == '*'){
                dp[i][0] = dp[i-1][0];
            }
        }
        for(int i=1;i<=p.length();i++){
            for(int j=1;j<=s.length();j++){
                if(p.charAt(i-1) == s.charAt(j-1) || p.charAt(i-1) == '?'){
                    dp[i][j] = dp[i-1][j-1];
                }else if(p.charAt(i-1) == '*'){
                    dp[i][j] = dp[i-1][j-1] || dp[i-1][j] || dp[i][j-1];
                }else{
                    dp[i][j] = false;
                }
            }
        }
        
        return dp[p.length()][s.length()];
    }
}

---

题目2.买股票利益最大

https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii/submissions/

题目概述： 数组表示每天股票的价格，总共可以买卖多次，但是必须要卖出后才能买入。

题解：比较前一天的利润 和  如果前一天买入今天卖出得到的利润，将最大的存储在今天的利润中

  public int maxProfit(int[] prices) {
         if(prices.length == 0)return 0;
         int[] dp= new int[prices.length];
         
         for(int i=1 ;i<dp.length;i++){
             dp[i] = Math.max(dp[i-1],dp[i-1]+(prices[i]-prices[i-1]));
         }
         return dp[prices.length-1];
    }

或者更简单的方法：

    public int maxProfit(int[] prices) {
        int profit = 0;
        
        for(int i=1;i<prices.length;i++){
            if(prices[i] - prices[i-1] >0){
                profit += prices[i] - prices[i-1] ;
            }
        }
        return profit;
    }

---

题目3. 最长升序序列

https://leetcode.com/problems/longest-increasing-subsequence/

题目概述：找到一组数中最长的上升序列的长度

题解： 动态规划问题，动态规划一般是双循环加一个数组，第一重循环为以该数字为结尾的序列号 i，第二个循环为该子序列最长升序长度j属于 (0-i)。每个位置j和i比较，当子序列中有nums[j] < nums[i]时候  更新 res[i] = max(res[i],res[j]+1)。

class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums.length ==0)return 0;
        
        int n = nums.length;
        int res[] = new int[n];
        int max_cur = 1;
        Arrays.fill(res,1);
        for(int i = 0 ; i<n ; i++){ 
            for(int j= 0; j <= i ;j++){
                if(nums[j] < nums [i])
                    res[i] = Math.max(res[i],res[j]+1);     
            }
            max_cur = Math.max(res[i],max_cur);
        }
        return max_cur;
    }
}