LeetCode 字符串（简单题）

答案摘抄自：
https://leetcode-cn.com/tag/string/

13. 罗马数字转整数

罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。

字符 数值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：

I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。

示例 1:
输入: “III”
输出: 3
示例 2:
输入: “IV”
输出: 4
示例 3:
输入: “IX”
输出: 9
示例 4:
输入: “LVIII”
输出: 58
解释: L = 50, V= 5, III = 3.
示例 5:
输入: “MCMXCIV”
输出: 1994
解释: M = 1000, CM = 900, XC = 90, IV = 4.

方法：
按照题目的描述，可以总结如下规则：

罗马数字由 I,V,X,L,C,D,M 构成；
当小值在大值的左边，则减小值，如 IV=5-1=4；
当小值在大值的右边，则加小值，如 VI=5+1=6；
由上可知，右值永远为正，因此最后一位必然为正。
一言蔽之，把一个小值放在大值的左边，就是做减法，否则为加法。

在代码实现上，可以往后看多一位，对比当前位与后一位的大小关系，从而确定当前位是加还是减法。当没有下一位时，做加法即可。

也可保留当前位的值，当遍历到下一位的时，对比保留值与遍历位的大小关系，再确定保留值为加还是减。最后一位做加法即可。

import java.util.*;

class Solution {
    public int romanToInt(String s) {
        int sum = 0;
        int preNum = getValue(s.charAt(0));
        for(int i = 1;i < s.length(); i ++) {
            int num = getValue(s.charAt(i));
            if(preNum < num) {
                sum -= preNum;
            } else {
                sum += preNum;
            }
            preNum = num;
        }
        sum += preNum;
        return sum;
    }
    
    private int getValue(char ch) {
        switch(ch) {
            case 'I': return 1;
            case 'V': return 5;
            case 'X': return 10;
            case 'L': return 50;
            case 'C': return 100;
            case 'D': return 500;
            case 'M': return 1000;
            default: return 0;
        }
    }
}

14. 最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀，返回空字符串 “”。

示例 1:
输入: [“flower”,“flow”,“flight”]
输出: “fl”
示例 2:
输入: [“dog”,“racecar”,“car”]
输出: “”
解释: 输入不存在公共前缀。

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs == null || strs.length == 0) return "";
        for (int i = 0; i < strs[0].length() ; i++){
            char c = strs[0].charAt(i);
            for (int j = 1; j < strs.length; j ++) {
                if (i == strs[j].length() || strs[j].charAt(i) != c)
                    return strs[0].substring(0, i);             
            }
        }
        return strs[0];
    }
}
/*
if(strs.length == 0) {
        return "";
    }
    for(int i=0; i<strs[0].length(); i++) {
        char c = (char) strs[0].charAt(i);
        for(int j=1; j<strs.length; j++) {
            if( c!=strs[j].charAt(i) || i==strs[j].length() ) {
                return strs[0].substring(0, i);
            }
        }
    }

    return strs[0];
    */

20. 有效的括号

给定一个只包括 ‘(’，’)’，’{’，’}’，’[’，’]’ 的字符串，判断字符串是否有效。

有效字符串需满足：

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

示例 1:
输入: “()”
输出: true
示例 2:
输入: “()[]{}”
输出: true
示例 3:
输入: “(]”
输出: false
示例 4:
输入: “([)]”
输出: false
示例 5:
输入: “{[]}”
输出: true

class Solution {

  // Hash table that takes care of the mappings.
  private HashMap<Character, Character> mappings;

  // Initialize hash map with mappings. This simply makes the code easier to read.
  public Solution() {
    this.mappings = new HashMap<Character, Character>();
    this.mappings.put(')', '(');
    this.mappings.put('}', '{');
    this.mappings.put(']', '[');
  }

  public boolean isValid(String s) {

    // Initialize a stack to be used in the algorithm.
    Stack<Character> stack = new Stack<Character>();

    for (int i = 0; i < s.length(); i++) {
      char c = s.charAt(i);

      // If the current character is a closing bracket.
      if (this.mappings.containsKey(c)) {

        // Get the top element of the stack. If the stack is empty, set a dummy value of '#'
        char topElement = stack.empty() ? '#' : stack.pop();

        // If the mapping for this bracket doesn't match the stack's top element, return false.
        if (topElement != this.mappings.get(c)) {
          return false;
        }
      } else {
        // If it was an opening bracket, push to the stack.
        stack.push(c);
      }
    }

    // If the stack still contains elements, then it is an invalid expression.
    return stack.isEmpty();
  }
}

28. 实现 strStr()

实现 strStr() 函数。

给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始)。如果不存在，则返回 -1。
示例 1:
输入: haystack = “hello”, needle = “ll”
输出: 2
示例 2:
输入: haystack = “aaaaa”, needle = “bba”
输出: -1

说明:
当 needle 是空字符串时，我们应当返回什么值呢？这是一个在面试中很好的问题。
对于本题而言，当 needle 是空字符串时我们应当返回 0 。这与C语言的 strstr() 以及 Java的 indexOf() 定义相符。

38. 外观数列

「外观数列」是一个整数序列，从数字 1 开始，序列中的每一项都是对前一项的描述。前五项如下：

1. 1
   

2. 11
   

3. 21
   

4. 1211
   

5. 111221
   

1 被读作 “one 1” (“一个一”) , 即 11。
11 被读作 “two 1s” (“两个一”）, 即 21。
21 被读作 “one 2”, “one 1” （“一个二” , “一个一”) , 即 1211。

给定一个正整数 n（1 ≤ n ≤ 30），输出外观数列的第 n 项。

注意：整数序列中的每一项将表示为一个字符串。

示例 1:
输入: 1
输出: “1”
解释：这是一个基本样例。
示例 2:
输入: 4
输出: “1211”
解释：当 n = 3 时，序列是 “21”，其中我们有 “2” 和 “1” 两组，“2” 可以读作 “12”，也就是出现频次 = 1 而 值 = 2；类似 “1” 可以读作 “11”。所以答案是 “12” 和 “11” 组合在一起，也就是 “1211”。

58. 最后一个单词的长度

给定一个仅包含大小写字母和空格 ’ ’ 的字符串 s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。
如果不存在最后一个单词，请返回 0 。
说明：一个单词是指仅由字母组成、不包含任何空格字符的 最大子字符串。

示例:
输入: “Hello World”
输出: 5

class Solution {
    public int lengthOfLastWord(String s) {
        /*
        int end = s.length() - 1;
        while(end >= 0 && s.charAt(end) == ' ') end--;
        //if(end < 0) return 0;
        int start = end;
        while(start >= 0 && s.charAt(start) != ' ') start--;
        return end - start;     
        */
        s=s.trim();
        return s.length()-1-s.lastIndexOf(" ");
    }
}

67. 二进制求和

给定两个二进制字符串，返回他们的和（用二进制表示）。
输入为非空字符串且只包含数字 1 和 0。
示例 1:
输入: a = “11”, b = “1”
输出: “100”
示例 2:
输入: a = “1010”, b = “1011”
输出: “10101”

class Solution {
    public String addBinary(String a, String b) {
        StringBuilder sb=new StringBuilder();
        int m=a.length();
        int n=b.length();
        //两个String形式二进制数相加，大的在前，小的在后
        if(m<n) return addBinary(b,a);

        int carry=0;
        int j=n-1;
        for(int i=m-1;i>=0;i--){
            if(a.charAt(i)=='1') carry++;
            if(j>=0 && b.charAt(j--)=='1') carry++;
            //如果carry值为1，sb加入元素1
            if(carry%2==1)  {
                sb.append('1');
            }else{
                sb.append('0');
            }
            //0/2=0；1/2=0；2/2=1（1为进位值，下一步要将此带入运算）
            carry/=2;
        }
        if(carry==1) sb.append('1');
        sb.reverse();
        return sb.toString();
    }
}

125. 验证回文串

给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。

说明：本题中，我们将空字符串定义为有效的回文串。

示例 1:
输入: “A man, a plan, a canal: Panama”
输出: true
示例 2:
输入: “race a car”
输出: false

class Solution {
    public boolean isPalindrome(String s) {
        int left=0;int right=s.length()-1;
        while(left<right){
            while(left<right && !Character.isLetterOrDigit(s.charAt(left))) left++;
            while(left<right && !Character.isLetterOrDigit(s.charAt(right))) right--;
            if(Character.toLowerCase(s.charAt(left))==Character.toLowerCase(s.charAt(right))){
                left++;
                right--;
            }else{
                return false;
            }
        }
        return true;
    }
}

344. 反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。

示例 1：
输入：[“h”,“e”,“l”,“l”,“o”]
输出：[“o”,“l”,“l”,“e”,“h”]
示例 2：
输入：[“H”,“a”,“n”,“n”,“a”,“h”]
输出：[“h”,“a”,“n”,“n”,“a”,“H”]

class Solution {
    public void reverseString(char[] s) {
        int left=0;
        int right=s.length-1;
        while(left<right){
            char tmp=s[left];
            s[left++]=s[right];
            s[right--]=tmp;
        }
    }
}

345. 反转字符串中的元音字母

编写一个函数，以字符串作为输入，反转该字符串中的元音字母。

示例 1:
输入: “hello”
输出: “holle”
示例 2:
输入: “leetcode”
输出: “leotcede”
说明:
元音字母不包含字母"y"。

class Solution {
    public String reverseVowels(String s) {
        char[] array=s.toCharArray();
        int left=0;
        int right=s.length()-1;
        while(left<right){
            while(left<right && judge(array[left])) left++;
            while(left<right && judge(array[right])) right--;
            char tmp=array[left];
            array[left++]=array[right];
            array[right--]=tmp;
        }   
        String str=new String(array);
        return str;
    }
    public boolean judge(char c){
        if(c!='a' && c!='e' && c!='i' && c!='o'&& c!='u' && c!='A' && c!='E' && c!='I' && c!='O' & c!='U'){
            return true;
        }else{
            return false;
        }
    }
}

383. 赎金信

给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。

(题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)

注意：

你可以假设两个字符串均只含有小写字母。

canConstruct(“a”, “b”) -> false
canConstruct(“aa”, “ab”) -> false
canConstruct(“aa”, “aab”) -> true

class Solution {
    public boolean canConstruct(String ransomNote, String magazine) {
        int[ ] buckets=new int[26];
        for(int i=0;i<magazine.length();i++){
            buckets[magazine.charAt(i)-'a']++;
        }
        for(int j=0;j<ransomNote.length();j++){
            if(--buckets[ransomNote.charAt(j)-'a']<0){
                return false;
            }
        }
        return true;
    }
}

387. 字符串中的第一个唯一字符

给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。

案例:
s = “leetcode”
返回 0.
s = “loveleetcode”,
返回 2.

方法： 线性时间复杂度解法
这道题最优的解法就是线性复杂度了，为了保证每个元素是唯一的，至少得把每个字符都遍历一遍。

算法的思路就是遍历一遍字符串，然后把字符串中每个字符出现的次数保存在一个散列表中。这个过程的时间复杂度为 O(N)，其中 N 为字符串的长度。

接下来需要再遍历一次字符串，这一次利用散列表来检查遍历的每个字符是不是唯一的。如果当前字符唯一，直接返回当前下标就可以了。第二次遍历的时间复杂度也是 O(N)。

class Solution {
    public int firstUniqChar(String s) {
        HashMap<Character,Integer> map=new HashMap<>();
        for(int i=0;i<s.length();i++){
            char c=s.charAt(i);
            map.put(c,map.getOrDefault(c,0)+1);
        }

        for(int i=0;i<s.length();i++){
            if(map.get(s.charAt(i))==1){
                return i;
            }
        }
        return -1;
    }
}

415. 字符串相加

给定两个字符串形式的非负整数 num1 和num2 ，计算它们的和。

注意：
num1 和num2 的长度都小于 5100.
num1 和num2 都只包含数字 0-9.
num1 和num2 都不包含任何前导零。
你不能使用任何內建 BigInteger 库， 也不能直接将输入的字符串转换为整数形式。

class Solution {
    public String addStrings(String num1, String num2) {
        StringBuilder sb=new StringBuilder();
        //进位处理
        int carry=0;
        for(int i=num1.length()-1,j=num2.length()-1;i>=0 || j>=0;i--,j--){
            int x= i>=0 ? num1.charAt(i)-'0' : 0;
            int y= j>=0 ? num2.charAt(j)-'0' : 0;
            int sum=x+y+carry;
            sb.append(sum%10);
            carry=sum/10;
        }
        if(carry == 1){
            sb.append("1");
        }
        return sb.reverse().toString();
    }
}

434. 字符串中的单词数

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:
输入: “Hello, my name is John”
输出: 5

class Solution {
    public int countSegments(String s) {
        /*
        int count=0;
        String[] array=s.split(" ");
        for(String arr:array){
            if(!"".equals(arr))
            count++;
        }
        return count;
        */
        int count=0,i=0,j=0;
        while(i<s.length()){
            while(i<s.length() && s.charAt(i)==' '){
                i++;
            }
            j=i;
            if(j<s.length()){
                while(j<s.length() && s.charAt(j)!=' '){
                    j++;
                }
            count++;
            i=j;
            }
        }
        return count;
    }
}

443. 压缩字符串

给定一组字符，使用原地算法将其压缩。
压缩后的长度必须始终小于或等于原数组长度。
数组的每个元素应该是长度为1 的字符（不是 int 整数类型）。
在完成原地修改输入数组后，返回数组的新长度。

进阶：
你能否仅使用O(1) 空间解决问题？

示例 1：
输入：
[“a”,“a”,“b”,“b”,“c”,“c”,“c”]
输出：
返回6，输入数组的前6个字符应该是：[“a”,“2”,“b”,“2”,“c”,“3”]
说明：
"aa"被"a2"替代。"bb"被"b2"替代。"ccc"被"c3"替代。
示例 2：
输入：
[“a”]
输出：
返回1，输入数组的前1个字符应该是：[“a”]
说明：
没有任何字符串被替代。
示例 3：
输入：
[“a”,“b”,“b”,“b”,“b”,“b”,“b”,“b”,“b”,“b”,“b”,“b”,“b”]
输出：
返回4，输入数组的前4个字符应该是：[“a”,“b”,“1”,“2”]。
说明：
由于字符"a"不重复，所以不会被压缩。"bbbbbbbbbbbb"被“b12”替代。
注意每个数字在数组中都有它自己的位置。

class Solution {
    public int compress(char[] chars) {
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<chars.length;i++){
            int count=1;
            while(i<chars.length-1 && chars[i]==chars[i+1]){
                count++;
                i++;
            }
            if(count==1){
                sb.append(chars[i]);
            }else{
                sb.append(chars[i]).append(count);
            }
        }
        for(int i=0;i<sb.length();i++){
            chars[i]=sb.charAt(i);
        }
        return sb.length();
    }
}

459. 重复的子字符串

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

示例 1:
输入: “abab”
输出: True
解释: 可由子字符串 “ab” 重复两次构成。
示例 2:
输入: “aba”
输出: False
示例 3:
输入: “abcabcabcabc”
输出: True
解释: 可由子字符串 “abc” 重复四次构成。 (或者子字符串 “abcabc” 重复两次构成。)

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        String str=s+s;
        return str.substring(1,str.length()-1).contains(s);
    }
}

520. 检测大写字母

给定一个单词，你需要判断单词的大写使用是否正确。
我们定义，在以下情况时，单词的大写用法是正确的：
全部字母都是大写，比如"USA"。
单词中所有字母都不是大写，比如"leetcode"。
如果单词不只含有一个字母，只有首字母大写， 比如 “Google”。
否则，我们定义这个单词没有正确使用大写字母。

示例 1:
输入: “USA”
输出: True
示例 2:
输入: “FlaG”
输出: False
注意: 输入是由大写和小写拉丁字母组成的非空单词。

class Solution {
    public boolean detectCapitalUse(String word) {
        int count=0;
        for(int i=0;i<word.length();i++){
            if(isUpperCase(word.charAt(i))){
                count++;
            }
        }
        if(count==0 || count==word.length()){
            return true;
        }else if(isUpperCase(word.charAt(0)) && count==1){
            return true;
        }else{
            return false;
        }
    }
    public boolean isUpperCase(char c){
        if(c>='A' && c<='Z'){
            return true;
        }
        return false;
    }
}

521. 最长特殊序列 Ⅰ

给定两个字符串，你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
子序列可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。

示例 :
输入: “aba”, “cdc”
输出: 3
解析: 最长特殊序列可为 “aba” (或 “cdc”)
说明:
两个字符串长度均小于100。
字符串中的字符仅含有 ‘a’~‘z’。

class Solution {
    public int findLUSlength(String a, String b) {
        if(a.equals(b)){
            return -1;
        }
        return Math.max(a.length(),b.length());
    }
}

541. 反转字符串 II

给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。

示例:
输入: s = “abcdefg”, k = 2
输出: “bacdfeg”
要求:
该字符串只包含小写的英文字母。
给定字符串的长度和 k 在[1, 10000]范围内。

class Solution {
    public String reverseStr(String s, int k) {
        char[] a = s.toCharArray();
        for (int start = 0; start < a.length; start += 2 * k) {
            int i = start, j = Math.min(start + k - 1, a.length - 1);
            while (i < j) {
                char tmp = a[i];
                a[i++] = a[j];
                a[j--] = tmp;
            }
        }
        return new String(a);
    }
}

551. 学生出勤记录 I

给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：

‘A’ : Absent，缺勤
‘L’ : Late，迟到
‘P’ : Present，到场
如果一个学生的出勤记录中不超过一个’A’(缺勤)并且不超过两个连续的’L’(迟到),那么这个学生会被奖赏。

你需要根据这个学生的出勤记录判断他是否会被奖赏。

示例 1:
输入: “PPALLP”
输出: True
示例 2:
输入: “PPALLL”
输出: False

class Solution {
    public boolean checkRecord(String s) {
        int count=0;
        for(int i=0;i<s.length() && count<2;i++){
            if(s.charAt(i)=='A'){
                count++;
            }
        }
        return count<2 && s.indexOf("LLL")<0;
    }
}

557. 反转字符串中的单词 III

给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。

示例 1:
输入: “Let’s take LeetCode contest”
输出: “s’teL ekat edoCteeL tsetnoc”
注意：在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。

class Solution {
    public String reverseWords(String s) {
        StringBuilder sb=new StringBuilder();
        Stack<Character> stack=new Stack<>();
        for(char c:s.toCharArray()){
            if(c!=' '){
                stack.push(c);
            }else{
                while(!stack.empty()){
                    sb.append(stack.pop());
                }
                sb.append(' ');
            }
        }
        while(!stack.empty()){
            sb.append(stack.pop());
        }
        return sb.toString();
    }
}
/*
方法 3：使用 StringBuilder 和 reverse 方法 [Accepted]
算法

这一方法中，我们不使用 split 方法，我们创建临时字符串 wordword 保存单词，我们在遍历过程中将字符逐一连接在 wordword 后面，直到我们遇到 ' '（空格） 字符。当我们遇到 ' ' 字符时，我们将 wordword 反转后连接在结果字符串 resultresult 后面。在遍历完成以后，我们返回结果字符串 resultresult 。

Java
public class Solution {
    public String reverseWords(String input) {
        final StringBuilder result = new StringBuilder();
        final StringBuilder word = new StringBuilder();
        for (int i = 0; i < input.length(); i++) {
            if (input.charAt(i) != ' ') {
                word.append(input.charAt(i));
            } else {
                result.append(word.reverse());
                result.append(" ");
                word.setLength(0);
            }
        }
        result.append(word.reverse());
        return result.toString();
    }
}
*/

606. 根据二叉树创建字符串

你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。

空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

示例 1:
输入: 二叉树: [1,2,3,4]
1
/
2 3
/
4

输出: “1(2(4))(3)”
解释: 原本将是“1(2(4)())(3())”，
在你省略所有不必要的空括号对之后，
它将是“1(2(4))(3)”。
示例 2:
输入: 二叉树: [1,2,3,null,4]
1
/
2 3
\
4

输出: “1(2()(4))(3)”
解释: 和第一个示例相似，
除了我们不能省略第一个对括号来中断输入和输出之间的一对一映射关系。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public String tree2str(TreeNode t) {
        if (t == null)
            return "";
        Stack < TreeNode > stack = new Stack < > ();
        stack.push(t);
        Set < TreeNode > visited = new HashSet < > ();
        StringBuilder s = new StringBuilder();
        while (!stack.isEmpty()) {
            t = stack.peek();
            if (visited.contains(t)) {
                stack.pop();
                s.append(")");
            } else {
                visited.add(t);
                s.append("(" + t.val);
                if (t.left == null && t.right != null)
                    s.append("()");
                if (t.right != null)
                    stack.push(t.right);
                if (t.left != null)
                    stack.push(t.left);
            }
        }
        return s.substring(1, s.length() - 1);
    }
}
/*
方法一：递归
我们可以使用递归的方法得到二叉树的前序遍历。在递归时，根据题目描述，我们需要加上额外的括号，会有以下 4 种情况：

如果当前节点有两个孩子，那我们在递归时，需要在两个孩子的结果外都加上一层括号；

如果当前节点没有孩子，那我们不需要在节点后面加上任何括号；



如果当前节点只有左孩子，那我们在递归时，只需要在左孩子的结果外加上一层括号，而不需要给右孩子加上任何括号；


如果当前节点只有右孩子，那我们在递归时，需要先加上一层空的括号 () 表示左孩子为空，再对右孩子进行递归，并在结果外加上一层括号。


考虑完上面的 4 种情况，我们就可以得到最终的字符串。

public class Solution {
    public String tree2str(TreeNode t) {
        if(t==null)
            return "";
        if(t.left==null && t.right==null)
            return t.val+"";
        if(t.right==null)
            return t.val+"("+tree2str(t.left)+")";
        return t.val+"("+tree2str(t.left)+")("+tree2str(t.right)+")";   
    }
}
复杂度分析

时间复杂度：O(N)O(N)，其中 NN 是二叉树中的节点数目。

空间复杂度：O(N)O(N)，在最坏情况下，会递归 NN 层，需要 O(N)O(N) 的栈空间。

方法二：迭代
我们也可以用迭代的方法解决这个问题。

我们用一个栈来存储树中的一些节点，其中栈顶的元素为当前遍历到的节点，从栈底到栈顶的元素在树上即为从根到当前节点的唯一路径。和迭代得到前序遍历的方法略有不同，由于这里需要输出额外的括号，因此我们还需要用一个集合存储所有遍历过的节点，具体的原因在接下来会说明。

首先我们把根节点入栈。对于当前栈顶的元素，如果它没有遍历过，那么就把它加入到集合中，并开始对以它为根的子树进行前序遍历。我们先在答案末尾添加一个 (，表示一个节点的开始，然后判断该节点的子节点个数。和方法一相同，这里会出现四种情况：如果它没有子节点，我们什么都不做；如果它有两个子节点，那么我们先将右孩子入栈，再将左孩子入栈，这样就保证了前序遍历的顺序；如果它只有左孩子，那么我们将左孩子入栈；如果它只有右孩子，那么我们在答案末尾添加一个 () 表示空的左孩子，再将右孩子入栈。注意这四种情况中，我们都不会将当前节点出栈，原因是我们一开始添加了 ( 表示节点的开始，在以当前节点为根的子树中所有节点遍历完成之后，我们才会在答案末尾添加 ) 表示节点的结束。因此我们需要用上面提到的集合来存储遍历过的节点，如果当前栈顶的元素遍历过，那么我们就知道需要在答案末尾添加 )，并将这个节点出栈。

在迭代完成之后，我们得到的答案字符串的前后会有一对括号，我们把它去除后就可以得到最终的答案。


1 / 13

Java
public class Solution {
    public String tree2str(TreeNode t) {
        if (t == null)
            return "";
        Stack < TreeNode > stack = new Stack < > ();
        stack.push(t);
        Set < TreeNode > visited = new HashSet < > ();
        StringBuilder s = new StringBuilder();
        while (!stack.isEmpty()) {
            t = stack.peek();
            if (visited.contains(t)) {
                stack.pop();
                s.append(")");
            } else {
                visited.add(t);
                s.append("(" + t.val);
                if (t.left == null && t.right != null)
                    s.append("()");
                if (t.right != null)
                    stack.push(t.right);
                if (t.left != null)
                    stack.push(t.left);
            }
        }
        return s.substring(1, s.length() - 1);
    }
}
复杂度分析

时间复杂度：O(N)，其中 N 是二叉树中的节点数目。

空间复杂度：O(N)，在最坏情况下，栈中会存放 N 个节点。

*/

657. 机器人能否返回原点

在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在 (0, 0) 处结束。
移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 R（右），L（左），U（上）和 D（下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。

注意：机器人“面朝”的方向无关紧要。 “R” 将始终使机器人向右移动一次，“L” 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。

示例 1:
输入: “UD”
输出: true
解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。
示例 2:
输入: “LL”
输出: false
解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 “移动” 的距离。我们返回 false，因为它在移动结束时没有返回原点。

class Solution {
    public boolean judgeCircle(String moves) {
        int x=0,y=0;
        for(char move:moves.toCharArray()){
            if(move=='U') y--;
            else if(move=='D') y++;
            else if(move=='L') x--;
            else if(move=='R') x++;
        }
        return x==0 && y==0;
    }
}

680. 验证回文字符串 Ⅱ

给定一个非空字符串 s，最多删除一个字符。判断是否能成为回文字符串。

示例 1:
输入: “aba”
输出: True
示例 2:
输入: “abca”
输出: True
解释: 你可以删除c字符。

class Solution {
    public boolean validPalindrome(String s) {
        for(int i=0,j=s.length()-1;i<j;i++,j--){
            if(s.charAt(i)!=s.charAt(j)){
                return judge(s,i+1,j) || judge(s,i,j-1);
            }
        }
        return true;
    }
    public boolean judge(String s,int i,int j){
        while(i<j){
            if(s.charAt(i++)!=s.charAt(j--)){
                return false;
            }
        }
        return true;
    }
}

686. 重复叠加字符串匹配

给定两个字符串 A 和 B, 寻找重复叠加字符串A的最小次数，使得字符串B成为叠加后的字符串A的子串，如果不存在则返回 -1。

举个例子，A = “abcd”，B = “cdabcdab”。

答案为 3， 因为 A 重复叠加三遍后为 “abcdabcdabcd”，此时 B 是其子串；A 重复叠加两遍后为"abcdabcd"，B 并不是其子串。

注意:

A 与 B 字符串的长度在1和10000区间范围内。

696. 计数二进制子串

给定一个字符串 s，计算具有相同数量0和1的非空(连续)子字符串的数量，并且这些子字符串中的所有0和所有1都是组合在一起的。

重复出现的子串要计算它们出现的次数。

示例 1 :
输入: “00110011”
输出: 6
解释: 有6个子串具有相同数量的连续1和0：“0011”，“01”，“1100”，“10”，“0011” 和 “01”。
请注意，一些重复出现的子串要计算它们出现的次数。
另外，“00110011”不是有效的子串，因为所有的0（和1）没有组合在一起。
示例 2 :
输入: “10101”
输出: 4
解释: 有4个子串：“10”，“01”，“10”，“01”，它们具有相同数量的连续1和0。

709. 转换成小写字母

实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
示例 1：
输入: “Hello”
输出: “hello”
示例 2:
输入: “here”
输出: “here”
示例 3：
输入: “LOVELY”
输出: “lovely”

class Solution {
    public String toLowerCase(String str) {
        /*
        if(str==null){
            return null;
        }
        return str.toLowerCase();
        */
        if(str==null){
            return null;
        }
        char[] array=str.toCharArray();
        int length=array.length;
        for(int i=0;i<length;i++){
            if(array[i]>='A'&&array[i]<='Z'){
                array[i]+=32;
            }
        }
        //return String.valueOf(array);
        String s=new String(array);
        return s;
    }
}

788. 旋转数字

我们称一个数 X 为好数, 如果它的每位数字逐个地被旋转 180 度后，我们仍可以得到一个有效的，且和 X 不同的数。要求每位数字都要被旋转。

如果一个数的每位数字被旋转以后仍然还是一个数字， 则这个数是有效的。0, 1, 和 8 被旋转后仍然是它们自己；2 和 5 可以互相旋转成对方；6 和 9 同理，除了这些以外其他的数字旋转以后都不再是有效的数字。

现在我们有一个正整数 N, 计算从 1 到 N 中有多少个数 X 是好数？

示例:
输入: 10
输出: 4
解释:
在[1, 10]中有四个好数： 2, 5, 6, 9。
注意 1 和 10 不是好数, 因为他们在旋转之后不变。

class Solution {
    public int rotatedDigits(int N) {
         // Count how many n in [1, N] are good.
        int ans = 0;
        for (int n = 1; n <= N; ++n)
            if (good(n, false)) ans++;
        return ans;
    }


    // Return true if n is good.
    // The flag is true iff we have an occurrence of 2, 5, 6, 9.
    public boolean good(int n, boolean flag) {
        if (n == 0) return flag;

        int d = n % 10;
        if (d == 3 || d == 4 || d == 7) return false;
        if (d == 0 || d == 1 || d == 8) return good(n / 10, flag);
        return good(n / 10, true);
    }
}

804. 唯一摩尔斯密码词

国际摩尔斯密码定义一种标准编码方式，将每个字母对应于一个由一系列点和短线组成的字符串， 比如: “a” 对应 “.-”, “b” 对应 “-…”, “c” 对应 “-.-.”, 等等。

为了方便，所有26个英文字母对应摩尔斯密码表如下：

[".-","-…","-.-.","-…",".","…-.","–.","…","…",".—","-.-",".-…","–","-.","—",".–.","–.-",".-.","…","-","…-","…-",".–","-…-","-.–","–…"]
给定一个单词列表，每个单词可以写成每个字母对应摩尔斯密码的组合。例如，“cab” 可以写成 “-.-…–…”，(即 “-.-.” + “-…” + ".-"字符串的结合)。我们将这样一个连接过程称作单词翻译。

返回我们可以获得所有词不同单词翻译的数量。

例如:
输入: words = [“gin”, “zen”, “gig”, “msg”]
输出: 2
解释:
各单词翻译如下:
“gin” -> “–…-.”
“zen” -> “–…-.”
“gig” -> “–…--.”
“msg” -> “–…--.”

共有 2 种不同翻译, “–…-.” 和 “–…--.”.

class Solution {
    public int uniqueMorseRepresentations(String[] words) {
        String[] MORSE = new String[]{".-","-...","-.-.","-..",".","..-.","--.",
                         "....","..",".---","-.-",".-..","--","-.",
                         "---",".--.","--.-",".-.","...","-","..-",
                         "...-",".--","-..-","-.--","--.."};

        Set<String> seen = new HashSet();
        for (String word: words) {
            StringBuilder code = new StringBuilder();
            for (char c: word.toCharArray())
                code.append(MORSE[c - 'a']);
            seen.add(code.toString());
        }

        return seen.size();
    }
}

819. 最常见的单词

给定一个段落 (paragraph) 和一个禁用单词列表 (banned)。返回出现次数最多，同时不在禁用列表中的单词。题目保证至少有一个词不在禁用列表中，而且答案唯一。

禁用列表中的单词用小写字母表示，不含标点符号。段落中的单词不区分大小写。答案都是小写字母。

示例：
输入:
paragraph = “Bob hit a ball, the hit BALL flew far after it was hit.”
banned = [“hit”]
输出: “ball”
解释:
“hit” 出现了3次，但它是一个禁用的单词。
“ball” 出现了2次 (同时没有其他单词出现2次)，所以它是段落里出现次数最多的，且不在禁用列表中的单词。
注意，所有这些单词在段落里不区分大小写，标点符号需要忽略（即使是紧挨着单词也忽略， 比如 “ball,”），
"hit"不是最终的答案，虽然它出现次数更多，但它在禁用单词列表中。

方法：简单计数：
我们统计出每个单词出现的次数，忽略所有的标点符号和大小写，答案即为出现次数最多且不在禁用列表中的那个单词。

统计单词的方法有两种。在第一种方法中，我们首先对整个段落按照空格进行分词（split），然后对于分出的每个单词，我们移除标点符号并忽略大小写。在第二种方法中，我们逐字符扫描整个段落，如果遇到一个非字母的符号，那就把之前遇到的字母作为一个单词。

对于每一个单词，我们会放入哈希映射（Java 中的 HashMap 或者 Python 中的 Counter）中进行计数。在每次放入单词之后，如果这个单词不在禁用列表中，我们就可以更新一次答案。

class Solution {
    public String mostCommonWord(String paragraph, String[] banned) {
        paragraph += ".";

        Set<String> banset = new HashSet();
        for (String word: banned) banset.add(word);
        Map<String, Integer> count = new HashMap();

        String ans = "";
        int ansfreq = 0;

        StringBuilder word = new StringBuilder();
        for (char c: paragraph.toCharArray()) {
            if (Character.isLetter(c)) {
                word.append(Character.toLowerCase(c));
            } else if (word.length() > 0) {
                String finalword = word.toString();
                if (!banset.contains(finalword)) {
                    count.put(finalword, count.getOrDefault(finalword, 0) + 1);
                    if (count.get(finalword) > ansfreq) {
                        ans = finalword;
                        ansfreq = count.get(finalword);
                    }
                }
                word = new StringBuilder();
            }
        }

        return ans;
    }
}

824. 山羊拉丁文

给定一个由空格分割单词的句子 S。每个单词只包含大写或小写字母。

我们要将句子转换为 “Goat Latin”（一种类似于 猪拉丁文 - Pig Latin 的虚构语言）。

山羊拉丁文的规则如下：

如果单词以元音开头（a, e, i, o, u），在单词后添加"ma"。
例如，单词"apple"变为"applema"。

如果单词以辅音字母开头（即非元音字母），移除第一个字符并将它放到末尾，之后再添加"ma"。
例如，单词"goat"变为"oatgma"。

根据单词在句子中的索引，在单词最后添加与索引相同数量的字母’a’，索引从1开始。
例如，在第一个单词后添加"a"，在第二个单词后添加"aa"，以此类推。
返回将 S 转换为山羊拉丁文后的句子。

示例 1:
输入: “I speak Goat Latin”
输出: “Imaa peaksmaaa oatGmaaaa atinLmaaaaa”
示例 2:
输入: “The quick brown fox jumped over the lazy dog”
输出: “heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa”

方法：
对于句子中的每个 word，如果是元音字母，就不变；如果是辅音字母，就旋转这个单词（在 Python 中是 word[1:] + word[:1]，在 Java 中是 word.substring(1) + word.substring(0, 1)。

然后，我们加入 “ma” 和期望数量的 “a” 以及一个空格。

class Solution {
    public String toGoatLatin(String S) {
        Set<Character> vowel = new HashSet();
        for (char c: new char[]{'a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U'})
            vowel.add(c);

        int t = 1;
        StringBuilder sb = new StringBuilder();
        for (String word: S.split(" ")) {
            char first = word.charAt(0);
            if (vowel.contains(first)) {
                sb.append(word);
            } else {
                sb.append(word.substring(1));
                sb.append(word.substring(0, 1));
            }
            sb.append("ma");
            for (int i = 0; i < t; i++)
                sb.append("a");
            t++;
            sb.append(" ");
        }

        sb.deleteCharAt(sb.length() - 1);
        return sb.toString();
    }
}

859. 亲密字符串

给定两个由小写字母构成的字符串 A 和 B ，只要我们可以通过交换 A 中的两个字母得到与 B 相等的结果，就返回 true ；否则返回 false 。

示例 1：
输入： A = “ab”, B = “ba”
输出： true
示例 2：
输入： A = “ab”, B = “ab”
输出： false
示例 3:
输入： A = “aa”, B = “aa”
输出： true
示例 4：
输入： A = “aaaaaaabc”, B = “aaaaaaacb”
输出： true
示例 5：
输入： A = “”, B = “aa”
输出： false

方法：情况列举
思路：
如果 A[i] == B[i]，我们就说 i 是匹配的，否则称 i 是不匹配的。亲密字符串几乎是完全匹配的，因为一次交换只会影响到两个索引。
如果交换 A[i] 和 A[j] 可以证明 A 和 B 是亲密字符串，那么就有 A[i] == B[j] 以及 A[j] == B[i]。 这意味着在 A[i], A[j], B[i], B[j] 这四个自由变量中，只存在两种情况：A[i] == A[j] 或 A[i] != A[j]

算法：
让我们来看看这些情况。
在 A[i] == A[j] == B[i] == B[j] 的情况下，字符串 A 与 B 相等。因此，如果 A == B，我们应当检查每个索引 i 以寻找具有相同值的两个匹配。

在 A[i] == B[j], A[j] == B[i], (A[i] != A[j]) 的情况下，其余索引是相匹配的。所以如果 A 和 B 只有两个不匹配的索引（记作 i 和 j），我们应该检查并确保等式 A[i] == B[j] 和 A[j] == B[i] 成立。

class Solution {
    public boolean buddyStrings(String A, String B) {
        if (A.length() != B.length()) return false;
        if (A.equals(B)) {
            int[] count = new int[26];
            for (int i = 0; i < A.length(); ++i)
                count[A.charAt(i) - 'a']++;

            for (int c: count)
                if (c > 1) return true;
            return false;
        } else {
            int first = -1, second = -1;
            for (int i = 0; i < A.length(); ++i) {
                if (A.charAt(i) != B.charAt(i)) {
                    if (first == -1)
                        first = i;
                    else if (second == -1)
                        second = i;
                    else
                        return false;
                }
            }

            return (second != -1 && A.charAt(first) == B.charAt(second) &&
                    A.charAt(second) == B.charAt(first));
        }
    }
}

893. 特殊等价字符串组

你将得到一个字符串数组 A。

如果经过任意次数的移动，S == T，那么两个字符串 S 和 T 是特殊等价的。

一次移动包括选择两个索引 i 和 j，且 i ％ 2 == j ％ 2，交换 S[j] 和 S [i]。

现在规定，A 中的特殊等价字符串组是 A 的非空子集 S，这样不在 S 中的任何字符串与 S 中的任何字符串都不是特殊等价的。

返回 A 中特殊等价字符串组的数量。

示例 1：
输入：[“a”,“b”,“c”,“a”,“c”,“c”]
输出：3
解释：3 组 [“a”,“a”]，[“b”]，[“c”,“c”,“c”]
示例 2：
输入：[“aa”,“bb”,“ab”,“ba”]
输出：4
解释：4 组 [“aa”]，[“bb”]，[“ab”]，[“ba”]
示例 3：
输入：[“abc”,“acb”,“bac”,“bca”,“cab”,“cba”]
输出：3
解释：3 组 [“abc”,“cba”]，[“acb”,“bca”]，[“bac”,“cab”]
示例 4：
输入：[“abcd”,“cdab”,“adcb”,“cbad”]
输出：1
解释：1 组 [“abcd”,“cdab”,“adcb”,“cbad”]

917. 仅仅反转字母

给定一个字符串 S，返回 “反转后的” 字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。

示例 1：
输入：“ab-cd”
输出：“dc-ba”
示例 2：
输入：“a-bC-dEf-ghIj”
输出：“j-Ih-gfE-dCba”
示例 3：
输入：“Test1ng-Leet=code-Q!”
输出：“Qedo1ct-eeLg=ntse-T!”

class Solution {
    public String reverseOnlyLetters(String S) {
        char[] array=S.toCharArray();
        Stack<Character> letters = new Stack();
        for (char c: array)
            if (Character.isLetter(c))
                letters.push(c);

        StringBuilder ans = new StringBuilder();
        for (char c: array) {
            if (Character.isLetter(c))
                ans.append(letters.pop());
            else
                ans.append(c);
        }

        return ans.toString();
        //StringBuilder叫字符串缓存区对象,使用时可以不断添加字符、字符串等已有内容。
        //需要使用时调用toString()获得对象里的所有字符串
    }
}

925. 长按键入

你的朋友正在使用键盘输入他的名字 name。偶尔，在键入字符 c 时，按键可能会被长按，而字符可能被输入 1 次或多次。

你将会检查键盘输入的字符 typed。如果它对应的可能是你的朋友的名字（其中一些字符可能被长按），那么就返回 True。

示例 1：
输入：name = “alex”, typed = “aaleex”
输出：true
解释：‘alex’ 中的 ‘a’ 和 ‘e’ 被长按。
示例 2：
输入：name = “saeed”, typed = “ssaaedd”
输出：false
解释：‘e’ 一定需要被键入两次，但在 typed 的输出中不是这样。
示例 3：
输入：name = “leelee”, typed = “lleeelee”
输出：true
示例 4：
输入：name = “laiden”, typed = “laiden”
输出：true
解释：长按名字中的字符并不是必要的。

class Solution {
    public boolean isLongPressedName(String name, String typed) {
        char[] array1=name.toCharArray();
        char[] array2=typed.toCharArray();
        char p=0;
        char q=0;
        while(p<array1.length && q<array2.length){
            if(array1[p]==array2[q]){
                p++;
                q++;
            }else{
                q++;
            }
        }
        return p==array1.length;
    }
}

929. 独特的电子邮件地址

每封电子邮件都由一个本地名称和一个域名组成，以 @ 符号分隔。

例如，在 alice@leetcode.com中， alice 是本地名称，而 leetcode.com 是域名。

除了小写字母，这些电子邮件还可能包含 ‘.’ 或 ‘+’。

如果在电子邮件地址的本地名称部分中的某些字符之间添加句点（’.’），则发往那里的邮件将会转发到本地名称中没有点的同一地址。例如，"alice.z@leetcode.com” 和 “alicez@leetcode.com” 会转发到同一电子邮件地址。 （请注意，此规则不适用于域名。）

如果在本地名称中添加加号（’+’），则会忽略第一个加号后面的所有内容。这允许过滤某些电子邮件，例如 m.y+name@email.com 将转发到 my@email.com。 （同样，此规则不适用于域名。）

可以同时使用这两个规则。

给定电子邮件列表 emails，我们会向列表中的每个地址发送一封电子邮件。实际收到邮件的不同地址有多少？

示例：
输入：[“test.email+alex@leetcode.com”,“test.e.mail+bob.cathy@leetcode.com”,“testemail+david@lee.tcode.com”]
输出：2
解释：实际收到邮件的是 “testemail@leetcode.com” 和 “testemail@lee.tcode.com”。

提示：
1 <= emails[i].length <= 100
1 <= emails.length <= 100
每封 emails[i] 都包含有且仅有一个 ‘@’ 字符。

class Solution {
    public int numUniqueEmails(String[] emails) {/*
        对于每个电子邮件地址，我们求出它的规范化表示（即根据 '.' 和 '+' 的规则进行处理后得到的，本地名称中仅包含小写字母的电子邮件地址）。我们对每一个地址依次进行如下的操作：

将电子邮件地址根据 '@' 分成本地名称和域名两部分，其中域名部分包含 '@'，且不需要进行额外的处理；

如果本地名称中有 '+'，那么移除 '+' 以及它后面出现的所有字符；

移除本地名称中的所有 '.'；

处理完成的本地名称和域名进行连接，得到电子邮件地址的规范化表示。

在得到了所有电子邮件地址的规范化表示后，我们将它们放入集合（set）中，就可以获知不同地址的数目。
*/
    Set<String> seen = new HashSet();
        for (String email: emails) {
            int i = email.indexOf('@');
            String local = email.substring(0, i);
            String rest = email.substring(i);
            if (local.contains("+")) {
                local = local.substring(0, local.indexOf('+'));
            }
            local = local.replace(".", "");
            seen.add(local + rest);
        }

        return seen.size(); 
    }
}

937. 重新排列日志文件

你有一个日志数组 logs。每条日志都是以空格分隔的字串。

对于每条日志，其第一个字为字母数字标识符。然后，要么：

标识符后面的每个字将仅由小写字母组成，或；
标识符后面的每个字将仅由数字组成。
我们将这两种日志分别称为字母日志和数字日志。保证每个日志在其标识符后面至少有一个字。

将日志重新排序，使得所有字母日志都排在数字日志之前。字母日志按内容字母顺序排序，忽略标识符；在内容相同时，按标识符排序。数字日志应该按原来的顺序排列。

返回日志的最终顺序。
示例 ：
输入：[“a1 9 2 3 1”,“g1 act car”,“zo4 4 7”,“ab1 off key dog”,“a8 act zoo”]
输出：[“g1 act car”,“a8 act zoo”,“ab1 off key dog”,“a1 9 2 3 1”,“zo4 4 7”]

1071. 字符串的最大公因子

对于字符串 S 和 T，只有在 S = T + … + T（T 与自身连接 1 次或多次）时，我们才认定 “T 能除尽 S”。

返回最长字符串 X，要求满足 X 能除尽 str1 且 X 能除尽 str2。

示例 1：
输入：str1 = “ABCABC”, str2 = “ABC”
输出：“ABC”
示例 2：
输入：str1 = “ABABAB”, str2 = “ABAB”
输出：“AB”
示例 3：
输入：str1 = “LEET”, str2 = “CODE”
输出：""

class Solution {
    public String gcdOfStrings(String str1, String str2) {
        // 假设str1是N个x，str2是M个x，那么str1+str2肯定是等于str2+str1的。
        if (!(str1 + str2).equals(str2 + str1)) {
            return "";
        }
        // 辗转相除法求gcd。
        return str1.substring(0, gcd(str1.length(), str2.length()));
    }

    private int gcd(int a, int b) {
        return b == 0? a: gcd(b, a % b);
    }
}

1108. IP 地址无效化

给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。

所谓无效化 IP 地址，其实就是用 “[.]” 代替了每个 “.”。

示例 1：
输入：address = “1.1.1.1”
输出：“1[.]1[.]1[.]1”
示例 2：
输入：address = “255.100.50.0”
输出：“255[.]100[.]50[.]0”

class Solution {
    public String defangIPaddr(String address) {
        StringBuilder sb=new StringBuilder();
        for(int i=0;i<address.length();i++){
            if(address.charAt(i)=='.'){
                sb.append("[.]");
            }else{
                sb.append(address.charAt(i));
            }
        }
        return sb.toString();
    }
}

1170. 比较字符串最小字母出现频次

我们来定义一个函数 f(s)，其中传入参数 s 是一个非空字符串；该函数的功能是统计 s 中（按字典序比较）最小字母的出现频次。

例如，若 s = “dcce”，那么 f(s) = 2，因为最小的字母是 “c”，它出现了 2 次。

现在，给你两个字符串数组待查表 queries 和词汇表 words，请你返回一个整数数组 answer 作为答案，其中每个 answer[i] 是满足 f(queries[i]) < f(W) 的词的数目，W 是词汇表 words 中的词。

示例 1：
输入：queries = [“cbd”], words = [“zaaaz”]
输出：[1]
解释：查询 f(“cbd”) = 1，而 f(“zaaaz”) = 3 所以 f(“cbd”) < f(“zaaaz”)。
示例 2：
输入：queries = [“bbb”,“cc”], words = [“a”,“aa”,“aaa”,“aaaa”]
输出：[1,2]
解释：第一个查询 f(“bbb”) < f(“aaaa”)，第二个查询 f(“aaa”) 和 f(“aaaa”) 都 > f(“cc”)。

提示：
1 <= queries.length <= 2000
1 <= words.length <= 2000
1 <= queries[i].length, words[i].length <= 10
queries[i][j], words[i][j] 都是小写英文字母

class Solution {
    public int[] numSmallerByFrequency(String[] queries, String[] words) {
        int[] result = new int[queries.length];
        for (int i = 0; i < queries.length; i++) {
            int countMinQuery = countMinCode(queries[i]);
            for (String word : words) {
                if (countMinQuery < countMinCode(word)) {
                    result[i] ++;
                }
            }
        }
        return result;
    }
     /**
     * 统计最小出现频次
     * @param s
     * @return
     */
    public static int countMinCode(String s) {
        char min = s.charAt(0);
        int  count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) < min) {
                min = s.charAt(i);
                count = 0;
            }
            if (s.charAt(i) == min) {
                count++;
            }
        }
        return count;
    }
}

1189. “气球” 的最大数量

给你一个字符串 text，你需要使用 text 中的字母来拼凑尽可能多的单词 “balloon”（气球）。

字符串 text 中的每个字母最多只能被使用一次。请你返回最多可以拼凑出多少个单词 “balloon”。

示例 1：
输入：text = “nlaebolko”
输出：1
示例 2：
输入：text = “loonbalxballpoon”
输出：2
示例 3：
输入：text = “leetcode”
输出：0

class Solution {
    public int maxNumberOfBalloons(String text) {
        int[] array=new int[5];
        for(char c:text.toCharArray()){
            switch(c){
                case 'b': array[0]++;
                break;
                case 'a': array[1]++;
                break;
                case 'l': array[2]++;
                break;
                case 'o': array[3]++;
                break;
                case 'n': array[4]++;
                break;
            }
        }
        array[2]/=2;
        array[3]/=2;
        Arrays.sort(array);
        return array[0];
    }
}

1221. 分割平衡字符串

在一个「平衡字符串」中，‘L’ 和 ‘R’ 字符的数量是相同的。

给出一个平衡字符串 s，请你将它分割成尽可能多的平衡字符串。

返回可以通过分割得到的平衡字符串的最大数量。

示例 1：
输入：s = “RLRRLLRLRL”
输出：4
解释：s 可以分割为 “RL”, “RRLL”, “RL”, “RL”, 每个子字符串中都包含相同数量的 ‘L’ 和 ‘R’。
示例 2：
输入：s = “RLLLLRRRLR”
输出：3
解释：s 可以分割为 “RL”, “LLLRRR”, “LR”, 每个子字符串中都包含相同数量的 ‘L’ 和 ‘R’。
示例 3：
输入：s = “LLLLRRRR”
输出：1
解释：s 只能保持原样 “LLLLRRRR”.

class Solution {
    public int balancedStringSplit(String s) {
        int countR=0;
        int count=0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)=='R'){
                countR++;
            }else{
                countR--;
            }
            if(countR==0){
                count++;
            }
        }
        return count;
    }
}

1309. 解码字母到整数映射

给你一个字符串 s，它由数字（‘0’ - ‘9’）和 ‘#’ 组成。我们希望按下述规则将 s 映射为一些小写英文字符：

字符（‘a’ - ‘i’）分别用（‘1’ - ‘9’）表示。
字符（‘j’ - ‘z’）分别用（‘10#’ - ‘26#’）表示。
返回映射之后形成的新字符串。

题目数据保证映射始终唯一。

示例 1：
输入：s = “10#11#12”
输出：“jkab”
解释：“j” -> “10#” , “k” -> “11#” , “a” -> “1” , “b” -> “2”.
示例 2：
输入：s = “1326#”
输出：“acz”
示例 3：
输入：s = “25#”
输出：“y”
示例 4：
输入：s = “12345678910#11#12#13#14#15#16#17#18#19#20#21#22#23#24#25#26#”
输出：“abcdefghijklmnopqrstuvwxyz”

1332. 删除回文子序列

给你一个字符串 s，它仅由字母 ‘a’ 和 ‘b’ 组成。每一次删除操作都可以从 s 中删除一个回文 子序列。

返回删除给定字符串中所有字符（字符串为空）的最小删除次数。

「子序列」定义：如果一个字符串可以通过删除原字符串某些字符而不改变原字符顺序得到，那么这个字符串就是原字符串的一个子序列。

「回文」定义：如果一个字符串向后和向前读是一致的，那么这个字符串就是一个回文。

示例 1：
输入：s = “ababa”
输出：1
解释：字符串本身就是回文序列，只需要删除一次。
示例 2：
输入：s = “abb”
输出：2
解释：“abb” -> “bb” -> “”.
先删除回文子序列 “a”，然后再删除 “bb”。
示例 3：
输入：s = “baabb”
输出：2
解释：“baabb” -> “b” -> “”.
先删除回文子序列 “baab”，然后再删除 “b”。
示例 4：
输入：s = “”
输出：0

class Solution {
    public int removePalindromeSub(String s) {
        if(s.length()==0){
            return 0;
        }
        boolean equals=new StringBuilder(s).reverse().toString().equals(s);
        if(equals){
            return 1;
        }else{
            return 2;
        }
    }
}

1370. 上升下降字符串

给你一个字符串 s ，请你根据下面的算法重新构造字符串：

从 s 中选出 最小 的字符，将它 接在 结果字符串的后面。
从 s 剩余字符中选出 最小 的字符，且该字符比上一个添加的字符大，将它 接在 结果字符串后面。
重复步骤 2 ，直到你没法从 s 中选择字符。
从 s 中选出 最大 的字符，将它 接在 结果字符串的后面。
从 s 剩余字符中选出 最大 的字符，且该字符比上一个添加的字符小，将它 接在 结果字符串后面。
重复步骤 5 ，直到你没法从 s 中选择字符。
重复步骤 1 到 6 ，直到 s 中所有字符都已经被选过。
在任何一步中，如果最小或者最大字符不止一个 ，你可以选择其中任意一个，并将其添加到结果字符串。

请你返回将 s 中字符重新排序后的 结果字符串 。

示例 1：
输入：s = “aaaabbbbcccc”
输出：“abccbaabccba”
解释：第一轮的步骤 1，2，3 后，结果字符串为 result = “abc”
第一轮的步骤 4，5，6 后，结果字符串为 result = “abccba”
第一轮结束，现在 s = “aabbcc” ，我们再次回到步骤 1
第二轮的步骤 1，2，3 后，结果字符串为 result = “abccbaabc”
第二轮的步骤 4，5，6 后，结果字符串为 result = “abccbaabccba”
示例 2：
输入：s = “rat”
输出：“art”
解释：单词 “rat” 在上述算法重排序以后变成 “art”
示例 3：
输入：s = “leetcode”
输出：“cdelotee”
示例 4：
输入：s = “ggggggg”
输出：“ggggggg”
示例 5：
输入：s = “spo”
输出：“ops”

1374. 生成每种字符都是奇数个的字符串

给你一个整数 n，请你返回一个含 n 个字符的字符串，其中每种字符在该字符串中都恰好出现 奇数次 。

返回的字符串必须只含小写英文字母。如果存在多个满足题目要求的字符串，则返回其中任意一个即可。

示例 1：
输入：n = 4
输出：“pppz”
解释：“pppz” 是一个满足题目要求的字符串，因为 ‘p’ 出现 3 次，且 ‘z’ 出现 1 次。当然，还有很多其他字符串也满足题目要求，比如：“ohhh” 和 “love”。
示例 2：
输入：n = 2
输出：“xy”
解释：“xy” 是一个满足题目要求的字符串，因为 ‘x’ 和 ‘y’ 各出现 1 次。当然，还有很多其他字符串也满足题目要求，比如：“ag” 和 “ur”。
示例 3：
输入：n = 7
输出：“holasss”

class Solution {
    public String generateTheString(int n) {
        if (n == 0) {
            return "";
        }
        StringBuilder stringBuilder = new StringBuilder(n);
        if (n % 2 == 0) {
            int m = n - 1;
            for (int i = 0; i < m; i++) {
                stringBuilder.append('a');
            }
            stringBuilder.append('b');
        } else {
            for (int i = 0; i < n; i++) {
                stringBuilder.append('a');
            }
        }
        return stringBuilder.toString();
    }
}

1408. 数组中的字符串匹配

给你一个字符串数组 words ，数组中的每个字符串都可以看作是一个单词。请你按 任意 顺序返回 words 中是其他单词的子字符串的所有单词。

如果你可以删除 words[j] 最左侧和/或最右侧的若干字符得到 word[i] ，那么字符串 words[i] 就是 words[j] 的一个子字符串。

示例 1：
输入：words = [“mass”,“as”,“hero”,“superhero”]
输出：[“as”,“hero”]
解释：“as” 是 “mass” 的子字符串，“hero” 是 “superhero” 的子字符串。
[“hero”,“as”] 也是有效的答案。

示例 2：
输入：words = [“leetcode”,“et”,“code”]
输出：[“et”,“code”]
解释：“et” 和 “code” 都是 “leetcode” 的子字符串。

示例 3：
输入：words = [“blue”,“green”,“bu”]
输出：[]

class Solution {
    public List<String> stringMatching(String[] words) {
         //排序，短的在前面 
        Arrays.sort(words, new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length()-o2.length();
            }
        });
        List<String> res = new ArrayList<>();
        for(int i=0; i<words.length; i++)
            for(int j=i+1; j<words.length; j++){
                if(words[j].length() == words[i].length())
                    continue;
                if(words[j].contains(words[i])){
                    res.add(words[i]);
                    break;
                }                
            }
        return res;   
    }
}

1417. 重新格式化字符串

给你一个混合了数字和字母的字符串 s，其中的字母均为小写英文字母。

请你将该字符串重新格式化，使得任意两个相邻字符的类型都不同。也就是说，字母后面应该跟着数字，而数字后面应该跟着字母。

请你返回 重新格式化后 的字符串；如果无法按要求重新格式化，则返回一个 空字符串 。

示例 1：
输入：s = “a0b1c2”
输出：“0a1b2c”
解释：“0a1b2c” 中任意两个相邻字符的类型都不同。 “a0b1c2”, “0a1b2c”, “0c2a1b” 也是满足题目要求的答案。

示例 2：
输入：s = “leetcode”
输出：""
解释：“leetcode” 中只有字母，所以无法满足重新格式化的条件。

示例 3：
输入：s = “1229857369”
输出：""
解释：“1229857369” 中只有数字，所以无法满足重新格式化的条件。

示例 4：
输入：s = “covid2019”
输出：“c2o0v1i9d”

示例 5：
输入：s = “ab123”
输出：“1a2b3”

class Solution {
    public String reformat(String s) {
        int num1=0,num2=0;
        char[] chars = s.toCharArray();
        for(char c:chars){
            if(c >= '0'&&c <= '9'){num1++;}
            else{num2++;}
        }//看数字字符比较多还是字母字符比较多
        if( num1-num2<-1 || num1-num2>1){return "";}
        if(num1>num2){
            num1 = 0;num2 = 1;
        }else{
            num1 = 1;num2 = 0;
        }
        for(char c:s.toCharArray()){
            if(c >= '0'&&c <= '9'){chars[num1] = c; num1 += 2;}
            else{chars[num2] = c; num2 += 2;}
        }
        return new String(chars);
    }
}
/*1.定义两个变量，对数字字符和字母字符计数，如果数量相差2及以上，直接溜溜球（你呵护不了我，我也呵护不了你，直接music“可惜不是你”）
2.为了节省空间计数的两个变量拿来复用，哪个数大，哪个从零开始，每次加2，自己走自己的，互不干涉
反正数字字符和字母字符最终都要放进去
3.通过num1和num2双指针，将字符放入到字符数组中，返回字符串

链接：https://leetcode-cn.com/problems/reformat-the-string/solution/java-shuang-100zuo-fa-jian-dan-yi-dong-nei-fu-jie-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。*/

1422. 分割字符串的最大得分

给你一个由若干 0 和 1 组成的字符串 s ，请你计算并返回将该字符串分割成两个 非空 子字符串（即 左 子字符串和 右 子字符串）所能获得的最大得分。

「分割字符串的得分」为 左 子字符串中 0 的数量加上 右 子字符串中 1 的数量。

示例 1：
输入：s = “011101”
输出：5
解释：
将字符串 s 划分为两个非空子字符串的可行方案有：
左子字符串 = “0” 且 右子字符串 = “11101”，得分 = 1 + 4 = 5
左子字符串 = “01” 且 右子字符串 = “1101”，得分 = 1 + 3 = 4
左子字符串 = “011” 且 右子字符串 = “101”，得分 = 1 + 2 = 3
左子字符串 = “0111” 且 右子字符串 = “01”，得分 = 1 + 1 = 2
左子字符串 = “01110” 且 右子字符串 = “1”，得分 = 2 + 1 = 3

示例 2：
输入：s = “00111”
输出：5
解释：当 左子字符串 = “00” 且 右子字符串 = “111” 时，我们得到最大得分 = 2 + 3 = 5

示例 3：
输入：s = “1111”
输出：3

class Solution {
    public int maxScore(String s) {
        int res = 0, cnt1 = 0, cnt0 = 0;        //cnt1统计右边1的个数，同理cnt0左边0的个数
        for(int i = 0; i < s.length(); i++){
            cnt1 += s.charAt(i)-'0';            //先统计1的个数
        }                                       //由于左右区域的数至少为1，所以i不能等于len-1
        for(int i = 0; i < s.length()-1; i++){  //点i分为左右两个区域        
            if(s.charAt(i) == '0') cnt0++;      //遇到01就统计，动态更新左右区域01个数
            else cnt1--;
            res = Math.max(res, cnt0+cnt1);
        }
        return res;
    }
}

1436. 旅行终点站

给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。

题目数据保证线路图会形成一条不存在循环的线路，因此只会有一个旅行终点站。

示例 1：
输入：paths = [[“London”,“New York”],[“New York”,“Lima”],[“Lima”,“Sao Paulo”]]
输出：“Sao Paulo”
解释：从 “London” 出发，最后抵达终点站 “Sao Paulo” 。本次旅行的路线是 “London” -> “New York” -> “Lima” -> “Sao Paulo” 。

示例 2：
输入：paths = [[“B”,“C”],[“D”,“B”],[“C”,“A”]]
输出：“A”
解释：所有可能的线路是：
“D” -> “B” -> “C” -> “A”.
“B” -> “C” -> “A”.
“C” -> “A”.
“A”.
显然，旅行终点站是 “A” 。

示例 3：
输入：paths = [[“A”,“Z”]]
输出：“Z”

class Solution {
    public String destCity(List<List<String>> paths) {
        Map<String,Boolean> map = new HashMap<>();

        for (List<String> path : paths) {
            if (map.containsKey(path.get(0))) map.remove(path.get(0));
            else map.put(path.get(0),false);
            if (map.containsKey(path.get(1))) map.remove(path.get(1));
            else map.put(path.get(1),true);
        }

        for (Map.Entry<String, Boolean> entry : map.entrySet()) {
            if (entry.getValue()) return entry.getKey();
        }
        return null;
    }
}
//哈希表key代表只出现一次的城市，value代表城市出现的位置。