算法刷题打卡（三）

5.最长回文子串

5. 最长回文子串 - 力扣（LeetCode） (leetcode-cn.com)
给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

输入：s = “babad”
输出：“bab”
解释：“aba” 同样是符合题意的答案。
示例 2：

输入：s = “cbbd”
输出：“bb”
示例 3：

输入：s = “a”
输出：“a”
示例 4：

输入：s = “ac”
输出：“a”

Manecher

   public static String longestPalindrome(String s) {
        if (s == null || s.length() == 0) {
            return "";
        }
        char[] res = manacherString(s);
        int[] p = new int[res.length];
        int index = -1;
        int R = -1;
        int resLen = Integer.MIN_VALUE; //用来记录最长回文子串的长度
        int resCenter = 0;  //用来记录最长回文子串的中心
        for (int i = 0; i != res.length; i++) {
            p[i] = R > i ? Math.min(p[2 * index - i], R - i) : 1;
            while (i + p[i] < res.length && i - p[i] > -1) {
                if (res[i + p[i]] == res[i - p[i]])
                    p[i]++;
                else {
                    break;
                }
            }
            if (i + p[i] > R) {
                R = i + p[i];
                index = i;
            }
            if (resLen < p[i]) {
                resLen = p[i];
                resCenter = i;
            }
        }
        //为了去掉 #
        resCenter = (resCenter - 1) / 2;    
        resLen = resLen - 1;  //正确的返回个数
        int start = resCenter - resLen / 2;
        // return s.substring((resCenter - 1) % 2 == 0 ? 开始 + 1  : 开始 ， 结束);
        return s.substring((resLen % 2) == 0 ? start + 1 : start, resCenter + (resLen / 2) + 1);
    }

    public static char[] manacherString(String str) {
        char[] chars = str.toCharArray();
        char[] res = new char[str.length() * 2 + 1];
        int index = 0;
        for(int i = 0; i != res.length;i++){
            if(i % 2 == 0){
                res[i] = '#';
            }else{
                res[i] = chars[index++];
            }
        }
        return res;
    }

7.整数反转

7. 整数反转 - 力扣（LeetCode） (leetcode-cn.com)
给你一个 32 位的有符号整数 x ，返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ，就返回 0。

假设环境不允许存储 64 位整数（有符号或无符号）。

示例 1：

输入：x = 123
输出：321
示例 2：

输入：x = -123
输出：-321
示例 3：

输入：x = 120
输出：21
示例 4：

输入：x = 0
输出：0

X %10 =最后一位 然后 X/10 用res =0 1 2 3… 来放在个位十位百位…
最后就能得到 。

    public int reverse(int x) {
        int res = 0;
        while (x != 0) {
            if (res > Integer.MAX_VALUE / 10 || res < Integer.MIN_VALUE / 10) {
                return 0;
            }
            res = res * 10 + x % 10;
            x /= 10;
        }
        return res;
    }

8.字符串转换整数

8. 字符串转换整数 (atoi) - 力扣（LeetCode） (leetcode-cn.com)

请你来实现一个 myAtoi(string s) 函数，使其能将字符串转换成一个 32 位有符号整数（类似 C/C++ 中的 atoi 函数）。

函数 myAtoi(string s) 的算法如下：

读入字符串并丢弃无用的前导空格
检查下一个字符（假设还未到字符末尾）为正还是负号，读取该字符（如果有）。 确定最终结果是负数还是正数。 如果两者都不存在，则假定结果为正。
读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数（即，“123” -> 123， “0032” -> 32）。如果没有读入数字，则整数为 0 。必要时更改符号（从步骤 2 开始）。
如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ，需要截断这个整数，使其保持在这个范围内。具体来说，小于 −231 的整数应该被固定为 −231 ，大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。
注意：

本题中的空白字符只包括空格字符 ’ ’ 。
除前导空格或数字后的其余字符串外，请勿忽略 任何其他字符。

示例 1：

输入：s = “42”
输出：42
解释：加粗的字符串为已经读入的字符，插入符号是当前读取的字符。
第 1 步：“42”（当前没有读入字符，因为没有前导空格）
^
第 2 步：“42”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）
^
第 3 步：“42”（读入 “42”）
^
解析得到整数 42 。
由于 “42” 在范围 [-231, 231 - 1] 内，最终结果为 42 。
示例 2：

输入：s = " -42"
输出：-42
解释：
第 1 步：" -42"（读入前导空格，但忽视掉）
^
第 2 步：" -42"（读入 ‘-’ 字符，所以结果应该是负数）
^
第 3 步：" -42"（读入 “42”）
^
解析得到整数 -42 。
由于 “-42” 在范围 [-231, 231 - 1] 内，最终结果为 -42 。
示例 3：

输入：s = “4193 with words”
输出：4193
解释：
第 1 步：“4193 with words”（当前没有读入字符，因为没有前导空格）
^
第 2 步：“4193 with words”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）
^
第 3 步：“4193 with words”（读入 “4193”；由于下一个字符不是一个数字，所以读入停止）
^
解析得到整数 4193 。
由于 “4193” 在范围 [-231, 231 - 1] 内，最终结果为 4193 。
示例 4：

输入：s = “words and 987”
输出：0
解释：
第 1 步：“words and 987”（当前没有读入字符，因为没有前导空格）
^
第 2 步：“words and 987”（当前没有读入字符，因为这里不存在 ‘-’ 或者 ‘+’）
^
第 3 步：“words and 987”（由于当前字符 ‘w’ 不是一个数字，所以读入停止）
^
解析得到整数 0 ，因为没有读入任何数字。
由于 0 在范围 [-231, 231 - 1] 内，最终结果为 0 。
示例 5：

输入：s = “-91283472332”
输出：-2147483648
解释：
第 1 步："-91283472332"（当前没有读入字符，因为没有前导空格）
^
第 2 步："-91283472332"（读入 ‘-’ 字符，所以结果应该是负数）
^
第 3 步："-91283472332"（读入 “91283472332”）
^
解析得到整数 -91283472332 。
由于 -91283472332 小于范围 [-231, 231 - 1] 的下界，最终结果被截断为 -231 = -2147483648 。

和上一题整数转差不多，要注意题目给的条件 和 范围 ±符号， 最大值最小值范围。

 	public int myAtoi(String s) {
        if (s == null || s.equals("")) {
            return 0;
        }
        char[] str = s.toCharArray();
        int strlen = str.length;
        int index = 0;
        while (index < strlen && str[index] == ' ') {
            index++;
        }
        //符号 这个没有符号的时候不能++..
        //int symbol = str[index] == '+' ? 1 : (str[index] == '-' ? -1 : 1);
        //index++;
        if(index == strlen){
            return 0 ;
        }
        int symbol = 1;
        if(str[index] == '+'){
            index++;
        }else if(str[index] == '-'){
            symbol = -1;
            index++;
        }
        int res = 0;
        final int max = Integer.MAX_VALUE;
        final int min = Integer.MIN_VALUE;
        for (; index < strlen; index++) {
            char take = str[index];
            if (take < '0' || take > '9') {
                break;
            }
            if (res > max / 10 || (res == max / 10 && (take - '0') > max % 10)) {
                return max;
            }
            if (res < min / 10 || (res == min / 10 && (-(take - '0')) < min % 10)) {
                return min;
            }
            res = res * 10 + symbol * (take - '0');
        }
        return res;
    }

10正则表达式匹配

10. 正则表达式匹配 - 力扣（LeetCode） (leetcode-cn.com)

给你一个字符串 s 和一个字符规律 p，请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配，是要涵盖 整个 字符串 s的，而不是部分字符串。

示例 1：

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

输入：s = “aa” p = “a*”
输出：true
解释：因为 ‘*’ 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 ‘a’。因此，字符串 “aa” 可被视为 ‘a’ 重复了一次。
示例 3：

输入：s = “ab” p = “."
输出：true
解释：".” 表示可匹配零个或多个（’*’）任意字符（’.’）。
示例 4：

输入：s = “aab” p = “cab”
输出：true
解释：因为 ‘*’ 表示零个或多个，这里 ‘c’ 为 0 个, ‘a’ 被重复一次。因此可以匹配字符串 “aab”。
示例 5：

输入：s = “mississippi” p = “misisp*.”
输出：false

**.**表示单个， * 表示 0 或多个 * * 不能挨着， . *不能挨着 * 不能开头

	public static boolean isMatch(String s, String p) {
        if (s == null || p == null) {
            return false;
        }
        char[] str = s.toCharArray();
        char[] pattern = p.toCharArray();
        int[][] dp = new int[str.length + 1][pattern.length + 1];
        for (int si = 0; si <= str.length; si++) {//初始值 设置成 -1
            for (int pi = 0; pi <= pattern.length; pi++) {
                dp[si][pi] = -1;
            }
        }

        return  process(str, pattern, 0, 0, dp);
    }

    public static boolean process(char[] str, char[] pattern, int si, int pi, int[][] dp) {
        	if (dp[si][pi] != -1) {
			return dp[si][pi] == 1;
		}
		// si pi 这个参数组合第一次算
		if (si == str.length) { // si越界了
			if (pi == pattern.length) {
				dp[si][pi] = 1;
				return true;
			}
			// (pi pi+1) pi+2 ....
			if (pi + 1 < pattern.length && pattern[pi + 1] == '*') {
				boolean ans = process(str, pattern, si, pi + 2, dp);
				dp[si][pi] = ans ? 1 : 0;
				return ans;
			}
			dp[si][pi] = 0;
			return false;
		}
		// si 没越界
		if (pi == pattern.length) {
			boolean ans = si == str.length;
			dp[si][pi] = ans ? 1 : 0;
			return ans;
		}
		// si 没越界 pi 没越界
		if (pi + 1 >= pattern.length || pattern[pi + 1] != '*') {
			boolean ans = ((str[si] == pattern[pi]) || (pattern[pi] == '.'))
					&& process(str, pattern, si + 1, pi + 1, dp);
			dp[si][pi] = ans ? 1 : 0;
			return ans;
		}
		// si 没越界 pi 没越界 pi+1 *
		if (pattern[pi] != '.' && str[si] != pattern[pi]) {
			boolean ans = process(str, pattern, si, pi + 2, dp);
			dp[si][pi] = ans ? 1 : 0;
			return ans;
		}
		if (process(str, pattern, si, pi + 2, dp)) {
			dp[si][pi] = 1;
			return true;
		}
		while (si < str.length && (str[si] == pattern[pi] || pattern[pi] == '.')) {
			if (process(str, pattern, si + 1, pi + 2, dp)) {
				dp[si][pi] = 1;
				return true;
			}
			si++;
		}
		dp[si][pi] = 0;
		return false;
    }