【每日三题】2022-3-23 LeetCode 10-12

10.正则表达式匹配

思路：

1. 从前向后匹配（动态规划）：状态空间大小为s.length() * p.length()，其中dp[i][j]代表s中的前i个字符和p中前j个字符匹配的结果。初始值为dp[0][0]=true，即两个空字符串匹配成功。状态转移方程如下：

   1. 当j=0时，除了i=0的时候两串匹配外，其余情况均不匹配（意味着原串不为空，而匹配串匹配的是空串），dp[1~s.length()][0] = false。

   2. isMatch(String s, String p, int i, int j)函数用来比较s的第i个字符和p的第j个字符是否相等，此时p中的.可以匹配任意字符

   3. 若当前p的字符不为*，则dp[i][j] = 当前两个字符是否相等 && 之前的字符串是否相等

   4. 若当前p的字符为*，则将j-1与j合并起来处理，有两种情况：

      1. 匹配0次，则dp[i][j] = dp[i][j-2]

      2. 匹配1+次，则dp[i][j] = isMatch(s,p,i,j-1) && dp[i-1][j]

   综上，状态转移方程为
   $$dp[i][j]=\{\begin{array}{cc}isMatch(s[i],p[j])\&dp[i-1][j-1],& dp[j]!{=}^{\prime }{\ast }^{\prime }\\ dp[i][j-2]||(isMatch(s[i],p[j])\&dp[i-1][j]),& otherwise\end{array}$$
   此方法有一个问题，就是从前向后匹配时，如果遇到字符+*的组合时，首先将字符作为一个独立个体进行了一次多余匹配。而这个结果不会影响到最终结果，因为当匹配到*时，状态转移方程不会与dp[1~s.length()][j-1]纬度产生联系，而之前的匹配结果则存放在dp[j-1]中，因此这次单独匹配不会对结果状态产生影响。

2. 从后向前匹配（动态规划）：类似与解法1，不再赘述

3. 递归，思路类似，采用递归形式向后/向前判断。会将字符+*作为组合一起判断。

代码：

1. 动态规划（从前向后）

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

   时间复杂度：O(mn)

   空间复杂度：O(mn)

2. 动态规划（从后向前）

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

   时间复杂度：O(mn)

   空间复杂度：O(mn)

3. 递归

   public static boolean isMatch(String s, String p) {
       if (s.equals(p)) {
           return true;
       }
       if (p.length() == 0) {
           return s.length() == 0;
       }
       boolean firstMatch = s.length() != 0 && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');
       if(p.length() > 1 && p.charAt(1) == '*'){
           return isMatch(s, p.substring(2)) || (firstMatch && isMatch(s.substring(1), p));
       }
       else{
           return firstMatch && isMatch(s.substring(1), p.substring(1));
       }
   }
   

   时间复杂度：O(mn)

   空间复杂度：O(mn)

11.盛最多水的容器

思路：装水量取决于两个因素：1.两条垂线之间的距离 2.两条垂线中短的那一条的高度。距离最大值，为数组的长度，而因素二需要我们遍历整个数组后才知道。因此我们对第二个因素进行贪心。初始化时，取最外侧的两条垂线，设定初始值。然后尝试将更短的那条线变长，即向中心搜索，并判断变化后的容器是否有更大的容量。最终搜索完整个数组后，结束。

代码：

public int maxArea(int[] height) {
    if (height.length == 0) {
        return 0;
    }
    int l = 0, r = height.length - 1, result = Math.min(height[l], height[r]) * (r - l);
    while (l < r) {
        if (height[l] > height[r]) {
            r --;

        } else {
            l ++;
        }
        result = Math.max(result, Math.min(height[l], height[r]) * (r - l));
    }
    return result;
}

时间复杂度：O(n)

空间复杂度：O(1)

12. 整数转罗马数字

思路：根据转换规则，可以从高位按位转换，并将结果拼接。

代码：

public String intToRoman(int num) {
    int base = 1000;
    StringBuilder result = new StringBuilder();
    while (num > 0) {
        int bit = num / base;
        num %= base;
        result.append(transfer(bit, base));
        base /= 10;
    }
    return result.toString();
}

private String transfer(int bit, int base) {
    if (bit == 0) {
        return "";
    }
    char one, five, ten;
    if (base == 1000) {
        one = 'M';
        five = ' ';
        ten = ' ';
    } else if (base == 100) {
        one = 'C';
        five = 'D';
        ten = 'M';
    } else if (base == 10) {
        one = 'X';
        five = 'L';
        ten = 'C';
    } else {
        one = 'I';
        five = 'V';
        ten = 'X';
    }
    StringBuilder sb = new StringBuilder();
    if (bit < 4) {
        while (bit-- > 0) {
            sb.append(one);
        }
    } else if (bit == 4) {
        sb.append(one);
        sb.append(five);
    } else if (bit > 4 && bit < 9) {
        sb.append(five);
        while (bit-- > 5) {
            sb.append(one);
        }
    } else {
        sb.append(one);
        sb.append(ten);
    }
    return sb.toString();
}

时间复杂度：O(1)

空间复杂度：O(1)