第八章：令人头大的字符串

1、有效的字母异位词

问题：

给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。

注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。

示例 1:

输入: s = "anagram", t = "nagaram"
输出: true
示例 2:

输入: s = "rat", t = "car"
输出: false

package LeetCode.test8_zifuchuan;

import java.util.HashMap;
import java.util.Map;

public class ques_242_有效的字母异位词 {
    public boolean isAnagram(String s, String t) {
        Map<Character, Integer> map_s = new HashMap<>();
        Map<Character, Integer> map_t = new HashMap<>();
        return getMap(map_s, s).equals(getMap(map_t, t));
    }

    public boolean isAnagram2(String s, String t) {
        if (s.length() != t.length()) {
            return false;
        }
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if (map.containsKey(s.charAt(i))) {
                map.put(s.charAt(i), map.get(s.charAt(i)) + 1);
            } else {
                map.put(s.charAt(i), 1);
            }
        }
        for (int i = 0; i < t.length(); i++) {
            if (map.containsKey(t.charAt(i))) {
                map.put(t.charAt(i), map.get(t.charAt(i)) - 1);
                if (map.get(t.charAt(i)) == 0) {
                    map.remove(t.charAt(i));
                }
            }
        }
        return map.size() == 0;
    }

    private Map<Character, Integer> getMap(Map<Character, Integer> map, String str) {
        for (int i = 0; i < str.length(); i++) {
            if (map.containsKey(str.charAt(i))) {
                map.put(str.charAt(i), map.get(str.charAt(i)) + 1);
            } else {
                map.put(str.charAt(i), 1);
            }
        }
        return map;
    }
}

class Test_242 {
    public static void main(String[] args) {
//        String s = "anagram";
//        String t = "nagaram";
        String s = "rat";
        String t = "car";
        ques_242_有效的字母异位词 p = new ques_242_有效的字母异位词();
        System.out.println(p.isAnagram(s, t));
        System.out.println(p.isAnagram2(s, t));
    }
}

2、同构字符串

问题：

给定两个字符串 s 和 t ，判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。

示例 1:

输入：s = "egg", t = "add"
输出：true
示例 2：

输入：s = "foo", t = "bar"
输出：false
示例 3：

输入：s = "paper", t = "title"
输出：true

package LeetCode.test8_zifuchuan;

import java.util.HashMap;
import java.util.Map;

/**
 * 思路：从s到t和t到s两个方向进行map操作。
 */
public class ques_205_同构字符串 {
    public boolean isIsomorphic(String s, String t) {
        int m = s.length();
        int n = t.length();
        if (m != n) {
            return false;
        }
        char[] char_s = s.toCharArray();
        char[] char_t = t.toCharArray();
        return judge(char_s, char_t) && judge(char_t, char_s);
    }

    private boolean judge(char[] s, char[] t) {
        Map<Character, Character> map = new HashMap<>();
        for (int i = 0; i < s.length; i++) {
            map.put(s[i], t[i]);
        }
        for (int i = 0; i < s.length; i++) {
            if (t[i] != map.get(s[i])) {  // map只能判断，不能修改！
                return false;
            }
        }
        return true;
    }
}

class Test_205 {
    public static void main(String[] args) {
        String s = "egg";
        String t = "add";
//        String s = "foo";
//        String t = "bar";
//        String s = "badc";
//        String t = "baba";
        ques_205_同构字符串 p = new ques_205_同构字符串();
        System.out.println(p.isIsomorphic(s, t));
    }
}

3、回文子串

问题：

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"
示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

package LeetCode.test8_zifuchuan;

public class ques_647_回文子串 {
    public int countSubstrings(String s) {
        int num = 0;
        for (int i = 0; i < s.length(); i++) {
            for (int j = i; j < s.length(); j++) {
                if (isPalindrome(s.substring(i, j + 1))) {
                    num++;
                }
            }
        }
        return num;
    }

    private boolean isPalindrome(String str) {
        int len = str.length();
        for (int i = 0; i < len / 2; i++) {
            if (str.charAt(i) != str.charAt(len - i - 1)) {
                return false;
            }
        }
        return true;
    }
}

class Test_647 {
    public static void main(String[] args) {
        String s = "aaa";
        ques_647_回文子串 p = new ques_647_回文子串();
        System.out.println(p.countSubstrings(s));
    }
}

4、计数二进制子串

问题：

给定一个字符串 s，统计并返回具有相同数量 0 和 1 的非空（连续）子字符串的数量，并且这些子字符串中的所有 0 和所有 1 都是成组连续的。

重复出现（不同位置）的子串也要统计它们出现的次数。

示例 1：

输入：s = "00110011"
输出：6
解释：6 个子串满足具有相同数量的连续 1 和 0 ："0011"、"01"、"1100"、"10"、"0011" 和 "01" 。
注意，一些重复出现的子串（不同位置）要统计它们出现的次数。
另外，"00110011" 不是有效的子串，因为所有的 0（还有 1 ）没有组合在一起。
示例 2：

输入：s = "10101"
输出：4
解释：有 4 个子串："10"、"01"、"10"、"01" ，具有相同数量的连续 1 和 0 。

package LeetCode.test8_zifuchuan;


/**
 * 思路：从左往右遍历数组，记录和当前位置数字相同且连续的长度，以及其之前连续的不同数字的长度。
 * 若不同数字的连续长度大于等于当前数字的连续长度，则说明存在一个且只存在一个以当前数字结尾的满足条件的子字符串。
 * eg:000111100(pre>=cur)
 * 0001 pre=3 cur=1  count = 1
 * 00011 pre=3 cur=2  count = 2
 * 000111 pre=3 cur=3  count = 3
 * 0001111 pre=3 cur=4  count = 3
 * 000(11110) pre=4 cur=1 count = 4
 * 000(111100) pre=4 cur=2 count = 5
 */
public class ques_696_计数二进制子串 {
    public int countBinarySubstrings(String s) {
        int pre = 0;
        int cur = 1;
        int count = 0;
        for (int i = 1; i < s.length(); i++) {
            if (s.charAt(i) == s.charAt(i - 1)) {
                cur++;
            } else {
                pre = cur;
                cur = 1;
            }
            if (pre >= cur) {
                count++;
            }
        }
        return count;
    }
}

class Test_696 {
    public static void main(String[] args) {
        String s = "000111100";
        ques_696_计数二进制子串 p = new ques_696_计数二进制子串();
        System.out.println(p.countBinarySubstrings(s));
    }
}

5、基本计算器II

基础知识：

eg:
中缀：9*8+(14-8/2)*3
前缀：+ * 9 8 * - 14 / 8 2 3
后缀：9 8 * 14 8 2 / - 3 * +
1、中缀表达式转前缀表达式
①初始化两个栈S1,S2，从右往左扫描中缀式。
②遇到操作数：将其压入S2栈。
③遇到括号时：
若是右括号‘）’，将其压入S1栈；
若是左括号‘（’，则依次弹出S1栈的元素，并将其压入S2栈，直至S1栈栈顶元素为右括号‘）’，弹出这个右括号。
④遇到运算符时：
若S1栈为空或者其栈顶元素为右括号‘）’，将其压入S1。
否则，比较运算符和S1栈顶运算符（一定是运算符）的优先级：
若其优先级≥S1栈顶运算符，则将其压入S1；
若小于，则将S1栈顶运算符弹出并压入S2，重新进行步骤④。
⑤重复②③④直到到达中缀式最左边，将S1剩余元素压入S2。最后依次取出S2元素即为前缀表达式。
2、求前缀表达式的值
①初始化一个栈S，从右往左扫描前缀式。
②遇到操作数时，则将其压入栈S。
③遇到运算符时，取出栈S的栈顶元素和次顶元素，运行运算。栈顶元素 运算符 次顶元素 = 结果。将结果压入栈S。
④重复②③直到到达前缀式最左边，此时栈S栈顶元素即为计算结果。
3、中缀表达式转后缀表达式
①初始化两个栈S1,S2，从右往左扫描中缀式。
②遇到操作数：将其压入S2栈。
③遇到括号时：
若是左括号‘（’，将其压入S1栈；
若是右括号‘）’，则依次弹出S1栈的元素，并将其压入S2栈，直至S1栈栈顶元素为左括号‘（’，弹出这个左括号。
④遇到运算符时：
若S1栈为空或者其栈顶元素为左括号‘（’，将其压入S1。
否则，比较运算符和S1栈顶运算符（一定是运算符）的优先级：
若其优先级>S1栈顶运算符，则将其压入S1；
若其优先级≤S1栈顶运算符，则将S1栈顶运算符弹出并压入S2，重新进行步骤④。
⑤重复②③④直到到达中缀式最右边。将S1剩余元素压入S2。最后依次取出S2元素进行倒序即为后缀表达式。
注意：
（1）开始： s1[* +]  s2[9 8]
（2）遇左括号： s1[+ ( - /]  s2[9 8 * 14 8 2]
（3）遇右括号： s1[+]  s2[9 8 * 14 8 2 / - C],其中(弹出
（4）接着： s1[+ *] s2[9 8 * 14 8 2 / - 3]
（5）最后： s1[] s2[9 8 * 14 8 2 / - 3 * +]
4、求后缀表达式的值
①初始化一个栈S，扫描后缀式。
②遇到操作数时，则将其压入栈S。
③遇到运算符时，取出栈S的栈顶元素和次顶元素，运行运算。次顶元素 运算符 栈顶元素 = 结果。将结果压入栈S。
④重复②③直到到达前缀式最右边，此时栈S栈顶元素即为计算结果。
注意：
（1）s[9 8] 9*8=72
（2）s[72 14 8 2] 8/2=4
（3）s[72 14 4] 14-4=10
（4）s[72 10 3] 10*3=30
（5）s[72 30] 72+30=102
（6）s[102]

问题：

给你一个字符串表达式 s ，请你实现一个基本计算器来计算并返回它的值。

整数除法仅保留整数部分。

你可以假设给定的表达式总是有效的。所有中间结果将在 [-231, 231 - 1] 的范围内。

注意：不允许使用任何将字符串作为数学表达式计算的内置函数，比如 eval() 。

示例 1：

输入：s = "3+2*2"
输出：7
示例 2：

输入：s = " 3/2 "
输出：1
示例 3：

输入：s = " 3+5 / 2 "
输出：5

package LeetCode.test8_zifuchuan;

import java.util.HashMap;
import java.util.Map;
import java.util.Stack;

/**
 * 注意：此题通过772.Basic Calculator III (Hard)进行了拓展，通用！！！
 */
public class ques_227_基本计算器II {
    Stack<String> s1;
    Stack<String> s2;
    Map<String, Integer> map;

    public int calculate(String s) {
        char[] chars = s.toCharArray();
        StringBuilder sb = new StringBuilder();
        for (char c : chars) {
            if (c != ' ') {
                sb.append(c);
            }
        }
        String newS = sb.toString();
        s1 = new Stack<>();
        s2 = new Stack<>();
        map = new HashMap<>();
        map.put("+", 1);
        map.put("-", 1);
        map.put("*", 2);
        map.put("/", 2);
        // 计算后缀表达式
        Stack<String> stack = getChange(newS);
        return cal(stack);
    }

    private Stack<String> getChange(String newS) {  // "9*8+(14-8/2)*3"
        for (int i = 0; i < newS.length(); ) {
            if (newS.charAt(i) >= '0' && newS.charAt(i) <= '9') { // 注意多位数的处理
                int num = newS.charAt(i) - '0';
                i++;
                while (i < newS.length() && newS.charAt(i) >= '0' && newS.charAt(i) <= '9') {
                    num = num * 10 + (newS.charAt(i) - '0');
                    i++;
                }
                s2.push(String.valueOf(num));
                // 这里做处理

            } else if (newS.charAt(i) == '(') {
                s1.push(String.valueOf(newS.charAt(i)));
                i++;
            } else if (newS.charAt(i) == ')') {
                while (!s1.empty()) {
                    String top = s1.pop();
                    if (top.equals("(")) {
                        break;
                    }
                    s2.push(top);
                }
                i++;
            } else {
                if (s1.empty() || s1.peek().equals("(")) {
                    s1.push(String.valueOf(newS.charAt(i)));
                    i++;
                } else {
                    if (map.get(String.valueOf(newS.charAt(i))) > map.get(s1.peek())) {
                        s1.push(String.valueOf(newS.charAt(i)));
                        i++;
                    } else {
                        String top = s1.pop();
                        s2.push(top); // 依旧是当前的i重新判断
                    }
                }
            }
        }
        while (!s1.empty()) {
            String top = s1.pop();
            s2.push(top);
        }
        Stack<String> stack = new Stack<>();  //倒序
        while (!s2.empty()) {
            stack.push(s2.pop());
        }
        return stack;
    }

    private int cal(Stack<String> stack) {
        Stack<Integer> newStack = new Stack<>();
        while (!stack.empty()) {
            String pop = stack.pop();
            if (pop.equals("+") || pop.equals("-") || pop.equals("*") || pop.equals("/")) {
                int temp1 = newStack.pop();
                int temp2 = newStack.pop();
                int temp;
                if (pop.equals("+")) {
                    temp = temp2 + temp1;
                } else if (pop.equals("-")) {
                    temp = temp2 - temp1;
                } else if (pop.equals("*")) {
                    temp = temp2 * temp1;
                } else {
                    temp = temp2 / temp1;
                }
                newStack.push(temp);
            } else {
                newStack.push(Integer.valueOf(pop));
            }
        }
        return newStack.pop();
    }
}

class Test_227 {
    public static void main(String[] args) {
        String s = "9*8+(14-8/2)*3";
        ques_227_基本计算器II p = new ques_227_基本计算器II();
        System.out.println(p.calculate(s));
    }
}

6、实现strStr

问题：

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串出现的第一个位置（下标从 0 开始）。如果不存在，则返回  -1 。

说明：

当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。

对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1：

输入：haystack = "hello", needle = "ll"
输出：2
示例 2：

输入：haystack = "aaaaa", needle = "bba"
输出：-1
示例 3：

输入：haystack = "", needle = ""
输出：0

package LeetCode.test8_zifuchuan;

/**
 * 思路：KMP算法（https://www.xdull.cn/kmp.html）
 * 不太好理解，直接记住就完事了！！！
 */
public class ques_28_实现strStr {
    public int strStr(String haystack, String needle) {
        int[] next = getNext(needle);
        int m = haystack.length();
        int n = needle.length();
        if (n == 0) {
            return 0;
        }
        int i = 0, j = 0;
        while (i < m) {
            if (haystack.charAt(i) == needle.charAt(j)) {
                i++;
                j++;
            } else {
                if (j > 0) {
                    j = next[j - 1];
                } else {
                    i++;
                }
            }
            if (j == n) {
                return i - n;
            }
        }
        return -1;
    }

    private int[] getNext(String needle) { //ababc
        int j = 0;
        int i = 1;
        int len = needle.length();
        int[] next = new int[len];
        while (i < len) {
            if (needle.charAt(i) == needle.charAt(j)) {
                next[i] = j + 1;
                i++;
                j++;
            } else {
                if (j > 0) {
                    j = next[j - 1];
                } else {
                    next[i] = 0;
                    i++;
                }
            }
        }
        return next;
    }
}

class Test_28 {
    public static void main(String[] args) {
        String haystack = "hello";
        String needle = "ll";
        ques_28_实现strStr s = new ques_28_实现strStr();
        System.out.println(s.strStr(haystack, needle));
    }
}

7、最长回文串

问题：

给定一个包含大写字母和小写字母的字符串 s ，返回 通过这些字母构造成的 最长的回文串 。

在构造过程中，请注意 区分大小写 。比如 "Aa" 不能当做一个回文字符串。

示例 1:

输入:s = "abccccdd"
输出:7
解释:
我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
示例 2:

输入:s = "a"
输入:1
示例 3:

输入:s = "bb"
输入: 2

package LeetCode.test8_zifuchuan;

import java.util.HashMap;
import java.util.Map;

public class ques_409_最长回文串 {
    public int longestPalindrome(String s) {
        Map<Character, Integer> map = new HashMap<>();
        for (int i = 0; i < s.length(); i++) {
            if (!map.containsKey(s.charAt(i))) {
                map.put(s.charAt(i), 1);
            } else {
                map.put(s.charAt(i), map.get(s.charAt(i)) + 1);
            }
        }
        System.out.println(map);
        int num = 0;
        for (Character c : map.keySet()) {
            if (map.get(c) % 2 == 0) {
                num += map.get(c);
            } else {
                num += (map.get(c) - 1);
                map.put(c, 1);
            }
        }
        if (map.containsValue(1)){
            num++;
        }
        return num;
    }
}

class Test_409 {
    public static void main(String[] args) {
//        String s = "ccc";
//        String s = "abccccdd";
        String s = "ababababa";
        ques_409_最长回文串 p = new ques_409_最长回文串();
        System.out.println(p.longestPalindrome(s));
    }
}

8、无重复字符的最长子串

问题：

给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: s = "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
  请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

package LeetCode.test8_zifuchuan;

import java.util.HashMap;
import java.util.Map;

/**
 * 思路：滑动窗口  abcabcbb
 * 进入这个窗口为abc，满足题目要求，当再进入a时，队列变成了abca，这时候不满足要求，要把队列的左边的元素移出。
 */
public class ques_3_无重复字符的最长子串 {
    public int lengthOfLongestSubstring(String s) {
        if (s.length() == 0) {
            return 0;
        }
        Map<Character, Integer> map = new HashMap<>();
        int max = 0;
        int left = 0;
        for (int i = 0; i < s.length(); i++) {
            if (map.containsKey(s.charAt(i))) {
                left = Math.max(left, map.get(s.charAt(i)) + 1);
                // eg:abba  没有max的时候(i=2,left=2)  (i=3,left=1)
            }
            map.put(s.charAt(i), i);
            max = Math.max(max, i - left + 1);
        }
        return max;
    }
}

class Test_3 {
    public static void main(String[] args) {
//        String s = "pwwkew";
        String s = "abba";
        ques_3_无重复字符的最长子串 p = new ques_3_无重复字符的最长子串();
        System.out.println(p.lengthOfLongestSubstring(s));
    }
}

9、最长回文子串

问题：

给你一个字符串 s，找到 s 中最长的回文子串。

示例 1：

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

输入：s = "cbbd"
输出："bb"

package LeetCode.test8_zifuchuan;

/**
 * 思路：对于字符串“ababa”，如果已经知道“bab”是回文串，那么“ababa” 一定是回文串，这是因为它的首尾两个字母都是“a”。
 * P(i,j)=P(i+1,j−1)∧(S[i]=S[j])(子串长度大于2)
 * 对于长度为1的子串，它显然是个回文串；对于长度为2的子串，只要它的两个字母相同，它就是一个回文串。
 */
public class ques_5_最长回文子串 {
    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        boolean[][] dp = new boolean[len][len];
        int maxLength = 1;
        int maxLeft = 0;
        for (int i = 0; i < len; i++) {  // a这种情况
            dp[i][i] = true;
        }
        char[] chars = s.toCharArray();
        for (int i = 1; i <= len; i++) {
            //定义左边界
            for (int left = 0; left < len; left++) {
                //定义右边界
                int right = i + left;
                if (right >= len) {
                    break;
                }
                if (chars[left] != chars[right]) {
                    dp[left][right] = false;
                } else {
                    if (right - left < 3) {
                        dp[left][right] = true;  // aa这种情况
                    } else {
                        dp[left][right] = dp[left + 1][right - 1];
                    }
                }
                if (dp[left][right] && right - left + 1 > maxLength) {  // 记录最大长度和此时的左边界
                    maxLength = right - left + 1;
                    maxLeft = left;
                }
            }
        }
        return s.substring(maxLeft, maxLeft + maxLength);
    }
}

class Test_5 {
    public static void main(String[] args) {
//        String s = "babad";
        String s = "cbbd";
        ques_5_最长回文子串 p = new ques_5_最长回文子串();
        System.out.println(p.longestPalindrome(s));
    }
}