2021-05-27LC “阿里题库” 10.正则表达式匹配 56.合并区间

/*动态规划 时间复杂度O(mn)  空间复杂度(mn)
q去匹配s，当两个一个为空，都是false，然后写边界
dp[i][j]代表p的前j个字符匹配s的前s个
边界：dp[0][j]匹配空字符串，只有x*x*X*X*这样的情况才是true
转移方程：先考虑当前
s.charAt(i-1)和p.charAt(j-1)相等的时候 dp[i][j]=dp[i-1][j-1]    这是相等的情况  （还有字符不相等的时候）
字符不相等有三种情况：
p.chgarAt(j-1)属于a~z，但是p.charAt(j-1)!=s.charAt(i-1)  这时候dp[i][j]=false；不需要考虑
p.charAt(j-1)='.' , dp[i][j] = dp[i-1][j-1]  
p.charAt(j-1)='*' 这时候要考虑'*'如何匹配，0个或者多个   
0个：*取0，例子：ab abc* --->判断 ab是否等于ab即可，即dp[i][j]=dp[i][j-2]，
1个：*取1，例子：abb abb*  ----->这时候如果s.charAt(i-1)=p.charAt(j-2),这时候*取1，则dp[i][j]=dp[i-1][j]  
多个：*取多个 例子：abbbbbbb ab*------>这时候看p的前j个字符匹配s的前i-1个即可，
也就是dp[i][j] =dp[i-1][j],比如这种情况*取了3，那dp[i-1][j] = dp[i-2][j]这种*取了2，直到*取了0，也就是上一种情况,因此没必要单独写

还有p.charAt(j-1) ='*'的情况下如果p.charAt(j-2)='.'例子：ab ab.*,  
.*可以匹配任何字符串，因此p的前j个字符能匹配s的前i-1个即可 dp[i][j] = dp[i-1][j]
dp[i][j] = dp[i-1][j]
*/
class Solution {
    public boolean isMatch(String s, String p) {
        if(s == null || p == null)
            return false;
        int m = s.length();
        int n = p.length();
        boolean[][] dp = new boolean[m+1][n+1];
        //边界
        dp[0][0] = true;
        for(int j=2 ; j<=n ; j+=2){
            if(p.charAt(j-1)=='*'){    //这种情况才能为true
                dp[0][j] = dp[0][j-2];   
            }
        }
        //写转移方程
        for(int i=1 ; i<=m ; i++){
            for(int j=1 ; j<=n ; j++){
                char sc = s.charAt(i-1);
                char pc = p.charAt(j-1);
                if(sc == pc || pc=='.'){
                    dp[i][j] = dp[i-1][j-1];
                }else if(pc=='*'){
                    if(dp[i][j-2]){
                        dp[i][j]=true;
                    }else if(sc == p.charAt(j-2) || p.charAt(j-2)=='.'){
                        dp[i][j]=dp[i-1][j];
                    }
                }
            }
        }
        return dp[m][n];
    }
}

//时间复杂度，主要是排序造成的O(nlogn),线性遍历O(n)，则时间复杂度O(nlogn)
//空间复杂度,O(logn)，这是除去了额外的返回数组，排序用的
class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals.length == 0)
            return new int[0][2];
        //排序
        Arrays.sort(intervals , new Comparator<int[]>(){
            public int compare(int[] interval1 , int[] interval2){
                return interval1[0]-interval2[0];  //升序
            }
        });
        //升序完进行合并，然后找返回的数组
        List<int[]> merged = new ArrayList<int[]>();
        for(int i=0 ; i<intervals.length; i++){
            int L = intervals[i][0] , R = intervals[i][1];                //写出当前数组的左右边界值
            //先写不能合并，直接添加
            if(merged.size() == 0 || merged.get(merged.size()-1)[1] < L){
                merged.add(new int[]{L,R});
            }else{
                //这时候就能合并
                merged.get(merged.size()-1)[1] = Math.max(R , merged.get(merged.size()-1)[1]); 
            }
        }
        return merged.toArray(new int[merged.size()][]);
    }
}