有效的括号+重复的子字符串

目录

1. 有效的括号

2. 重复的子字符串

---

1. 有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
注意空字符串可被认为是有效字符串。

示例 1: 输入: "()"输出: true

思路：利用栈数据结构，先push，后来的字符匹配，匹配成功pop，匹配失败push，最终栈为空返回true

注意的点：奇数必定不匹配；栈peek比较时，要注意栈是否为空

class Solution {
    public boolean isValid(String s) {
        int n = s.length();
        if(n <= 0){
            return true;
        }
        if (n % 2 == 1) {
            return false;
        }

        Stack<Character> stack = new Stack<>();
        char[] ch = s.toCharArray();
        stack.push(s.charAt(0));
        for (int i = 1; i < n; i++) {
            if (!stack.empty() && judgeMatch(stack.peek(), ch[i])) {
                stack.pop();
            } else {
                stack.push(ch[i]);
            }
        }
        return stack.empty();
    }

    private boolean judgeMatch(char stackPeek, char ch){
        if(stackPeek == '(' && ch == ')'){
            return true;
        }
        if(stackPeek == '{' && ch == '}'){
            return true;
        }
        if(stackPeek == '[' && ch == ']'){
            return true;
        }
        return false;
    }
}

2. 重复的子字符串

给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。

示例 1: 输入: "abab"  输出: True  解释: 可由子字符串 "ab" 重复两次构成。
示例 2: 输入: "aba"   输出: False

思路：以字符串第一个字符开始，循环；如果当前字符等于第一个字符，则认为是可重复构成的子串，进一步使用subStringPattern判断是否为子串，不是则更新子串append，是则返回true（初步想法）

注意的点：

字符串的长度必定是子串长度的倍数（s.length() % i == 0）;

子串的长度必定小于等于字符串长度的一半（i <= s.length() / 2）

public boolean repeatedSubstringPattern(String s) {
    if (s.length() <= 1) {
        return false;
    }

    StringBuilder subString = new StringBuilder();
    subString.append(s.charAt(0));
    for (int i = 1; i <= s.length() / 2; ++i) {
        if (s.length() % i == 0 && subString.charAt(0) == s.charAt(i)) {
            if (subStringPattern(subString.toString(), s)) {
                return true;
            }
        }
        subString.append(s.charAt(i));
    }
    return false;
}

private boolean subStringPattern(String sub, String s) {
    String tmp = s.replaceAll(sub, "");
    return tmp.length() <= 0;
}

思路2：双倍字符串，跳过第0个字符，从第一个字符开始找下一个s的起点，如果下一个s的起点不是s的长度，则说明有子串可重复组成

字符串有两种情况：一种是不满足题目要求的，即没有子串可重复组成，如图一；

一种是满足题目要求的，如图二

例如：s = aacbaacb; 双倍s: aacbaacbaacbaacb; 从第一个位置开始找，下一个s的位置就是aacbaacbaacbaacb，下图有点问题，下一个s的起点应该是1，字符串比较特殊。

代码如下：

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        return (s + s).indexOf(s, 1) != s.length();
    }
}

3. 正则表达式

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 '.' 和 '*' 的正则表达式匹配。'.' 匹配任意单个字符；'*' 匹配零个或多个前面的那一个元素。所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。说明:s 可能为空，且只包含从 a-z 的小写字母。p 可能为空，且只包含从 a-z 的小写字母，以及字符 . 和 *。

示例1: 输入: s = "aa"    p = "a"   输出: false   解释: "a" 无法匹配 "aa" 整个字符串。

示例2: 输入: s = "aab" p = "c*a*b" 输出: true  解释: 因为 '*' 表示零个或多个，这里 'c' 为 0 个, 'a' 被重复一次。因此可以匹配字符串 "aab"。

思路：回溯算法：一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。"*"这个特殊字符需要特殊处理，当p的第i个元素的下一个元素是星号时会有两种情况：

• i元素需要出现0次，我们就保持s不变，将p的减掉两个元素，调用isMatch。例如s：bc、p：a*bc，我们就保持s不变，减掉p的"a*"，调用isMatch(s:bc,p:bc)。
• i元素需要出现一次或更多次，先比较i元素和s首元素，相等则保持p不变，s减掉首元素，调用isMatch。例如s：aabb、p：a*bb，就保持p不变，减掉s的首元素，调用isMatch(s:abb,p:a*bb)。

例如：s=abb、p=a*abb，会用两种方式处理：

• 按照上述第二种情况比较i元素和s首元素，发现相等就会减掉s的首字符，调用isMatch(s:bb,p:a*abb)。在按照上述第一种情况减去p的两个元素，调用isMatch(s:bb,p:abb)，最终导致false。
• 直接按照上述第一种情况减去p的两个元素，调用isMatch(s:abb,p:abb)，最终导致true。

public boolean isMatch(String s, String p) {
    //如果正则串p为空字符串s也为空这匹配成功，如果正则串p为空但是s不是空则说明匹配失败
    if (p.isEmpty()){
        return s.isEmpty();
    }
    //判断s和p的首字符是否匹配，注意要先判断s不为空
    boolean headMatched = !s.isEmpty() && (s.charAt(0) == p.charAt(0) || p.charAt(0) == '.');

    if (p.length() >= 2 && p.charAt(1) == '*') {//如果p的第一个元素的下一个元素是*
        //则分别对两种情况进行判断
        return (headMatched && isMatch(s.substring(1), p)) || isMatch(s, p.substring(2));

    } else if (headMatched) {//否则，如果s和p的首字符相等
        return isMatch(s.substring(1), p.substring(1));

    } else {
        return false;
    }
}