LeetCode_字符串类

爱被打了一巴掌 2023-03-04 06:58 122阅读 0赞

### 文章目录 ###

*  3.无重复字符的最长子串
 *  415.字符串相加
 *  345.反转字符串中的元音字母
 *  14.最长公共前缀
 *  28.实现strStr()
 *  58.最后一个单词的长度
 *  67.二进制求和
 *  38.外观数列
 *  125.验证回文串
 *  383.赎金信
 *  387.字符串中的第一个唯一字符
 *  434.字符串中的单词数
 *  443.压缩字符串（没懂）
 *  459.重复的子字符串
 *  520.检测大写字母
 *  521.最长特殊序列I
 *  541.反转字符串II
 *  551.学生出勤记录I
 *  557.反转字符串中的单词III
 *  680.验证回文字符串II
 *  686.重复叠加字符串匹配
 *  696.计数二进制子串
 *  面试题 01.09.字符串轮转
 *  面试题 01.06.字符串压缩
 *  788.旋转数字
 *  709.转换成小写字母
 *  剑指Offer 58 - I.翻转单词顺序
 *  819.最常见的单词（不懂 哈希映射）
 *  917.仅仅反转字母
 *  859.亲密字符串
 *  336.回文对（一点不懂）
 *  824，山羊拉丁文（没看）
 *  \---------------------8.8-----------------------------
 *  1071.字符串的最大公因子
 *  1170.比较字符串最小字母出现频次（看不懂啊）
 *  1332.删除回文子序列
 *  1446.连续字符
 *  剑指Offer 58 - II.左旋转字符串（复习）
 *  面试题 01.04. 回文排列
 *  上升下降字符串（没写）
 *  \--------------------8.9-------------------
 *  93.复原IP地址（没看）
 *  43.字符串相乘
 *  \--------------8.13------------
 *  1544.整理字符串
 *  1507.转变日期格式
 *  1455.检查单词是否为居中其他单词的前缀

# 3.无重复字符的最长子串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 2]

class Solution {
        
        public int lengthOfLongestSubstring(String s) {
        
            // 哈希集合，记录每个字符是否出现过
            Set<Character> occ = new HashSet<Character>();
            int n = s.length();
            // 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
            int rk = -1, ans = 0;
            for (int i = 0; i < n; ++i) {
        
                if (i != 0) {
        
                    // 左指针向右移动一格，移除一个字符
                    occ.remove(s.charAt(i - 1));
                }
                while (rk + 1 < n && !occ.contains(s.charAt(rk + 1))) {
        
                    // 不断地移动右指针
                    occ.add(s.charAt(rk + 1));
                    ++rk;
                }
                // 第 i 到 rk 个字符是一个极长的无重复字符子串
                ans = Math.max(ans, rk - i + 1);
            }
            return ans;
        }
    }

#define LEN 128 //ASCII
    
    int lengthOfLongestSubstring(char * s) {
        
        int hset[LEN]; //存储数组下标
        int start = 0, count = 0, max = 0;
        memset(hset, -1, sizeof(hset)); //初始化
    
        for (int i = 0; i < strlen(s); i++) {
         //遍历字符串
            if (hset[s[i]] >= start) {
        
                start = hset[s[i]] + 1; // 更新为重复字符的下一个位置
                count = i - start; // 重置计数器
            }
            hset[s[i]] = i;
            count++;
            if (count > max) {
        
                max = count;
            }
        }
        
        return max;
    }

# 415.字符串相加 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 3]  
**思路：**  
借鉴初学加法时的列竖式计算

char* addStrings(char* num1, char* num2) {
        
        //i,j:两个相加的字符串各自的长度，add:进位
        int i = strlen(num1) - 1, j = strlen(num2) - 1, add = 0;
        //初始化"和"
        char* ans = (char*)malloc(sizeof(char) * (fmax(i, j) + 3));
        //定义"和"的长度
        int len = 0;
    
        while (i >= 0 || j >= 0 || add != 0) {
        
            int x = i >= 0 ? num1[i] - '0' : 0; //对位数较短的数补0
            int y = j >= 0 ? num2[j] - '0' : 0;
    
            int result = x + y + add;
            ans[len++] = '0' + result % 10; //储存每一位计算的结果
            add = result / 10; //储存进位
            i--, j--;
        }
        // 计算完以后的答案需要翻转过来
        for (int i = 0; 2 * i < len; i++) {
        
            int t = ans[i];
            ans[i] = ans[len - i - 1], ans[len - i - 1] = t;
        }
        ans[len++] = 0; //"和"字符串结束的标志
    
        return ans;
    }

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 4]  
**思路:**  
双指针法，遇到元音字母交换

int vowel(char c)
    {
        
        if(c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
            c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U')
            return 1;
        else
            return 0;
    }
    
    char * reverseVowels(char * s){
        
        int i = 0, j = strlen(s) - 1;
        char t;
        while(i < j){
        
            while(i < j && !vowel(s[i])) //
                i++;
            while(i < j && !vowel(s[j]))
                j--;
            t = s[i];
            s[i] = s[j];
            s[j] = t;
            i++;
            j--;
        }
        return s;
    }

# 14.最长公共前缀 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 5]

class Solution {
        
        public String longestCommonPrefix(String[] strs) {
        
            if(strs.length == 0) 
                return "";
    
            String ans = strs[0];
    
            for(int i =1;i<strs.length;i++) {
        
                int j=0;
                for(; j<ans.length()&&j < strs[i].length(); j++) {
         //ans.length?
                    if(ans.charAt(j) != strs[i].charAt(j)) //charAt()返回指定索引处的字符
                        break;
                }
                ans = ans.substring(0, j); //返回索引0~j-1处的字符
    
                if(ans.equals("")) //如果ans为空
                    return ans;
            }
    
            return ans;
        }
    }

# 28.实现strStr() #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 6]  
**思路：**  
逐一比较

class Solution {
        
      public int strStr(String haystack, String needle) {
        
        int L = needle.length(), n = haystack.length();
    
        for (int start = 0; start < n - L + 1; ++start) {
        
          if (haystack.substring(start, start + L).equals(needle)) {
        
            return start;
          }
        }
        return -1;
      }
    }

# 58.最后一个单词的长度 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 7]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 8]

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;
        }
    }

# 67.二进制求和 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 9]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 10]

class Solution {
        
        public String addBinary(String a, String b) {
        
            StringBuffer ans = new StringBuffer();
    
            int n = Math.max(a.length(), b.length()), carry = 0;
            for (int i = 0; i < n; ++i) {
        
                carry += i < a.length() ? (a.charAt(a.length() - 1 - i) - '0') : 0;
                carry += i < b.length() ? (b.charAt(b.length() - 1 - i) - '0') : 0;
                ans.append((char) (carry % 2 + '0'));
                carry /= 2;
            }
    
            if (carry > 0) {
        
                ans.append('1');
            }
            ans.reverse();
    
            return ans.toString();
        }
    }

**相关知识点:**  
append()：创建了一个新的数组，扩大了长度，将需要添加的字符串给复制到这个新的数组中

JAVA中Stringbuffer有append( )方法：  
而Stringbuffer是动态字符串数组，append( )是往动态字符串数组添加，跟“xxxx”+“yyyy”相当‘+’号。

跟String不同的是Stringbuffer是放一起的，String1+String2和Stringbuffer1.append(“yyyy”)虽然打印效果一样，但在内存中表示却不一样、

String1+String2 存在于不同的两个地址内存，Stringbuffer1.append(Stringbuffer2)放再一起。

StringBuffer是线程安全的，多用于多线程。

# 38.外观数列 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 11]  
**思路：**  
递归，StringBuffer

**Java解法：**

class Solution {
        
        public String countAndSay(int n) {
        
            if (n == 1) {
        
                return "1";
            }
    
            StringBuffer res = new StringBuffer();
            String str = countAndSay(n - 1);  //递归   
            
            int length = str.length();
            int a = 0;
            for (int i = 1; i < length + 1; i++) {
        
                if (i == length) {
        
                    return res.append(i - a).append(str.charAt(a)).toString();
                } else if (str.charAt(i) != str.charAt(a) ) {
        
                    res.append(i - a).append(str.charAt(a));
                    a = i;
                }
            }
    
            return res.toString(); //返回该对象的字符串表示
        }
    }

# 125.验证回文串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 12]

**思路：**  
方法二：  
在原字符串上直接判断  
我们可以对方法一中第二种判断回文串的方法进行优化，就可以得到只使用 O(1)O(1) 空间的算法。

我们直接在原字符串 ss 上使用双指针。在移动任意一个指针时，需要不断地向另一指针的方向移动，直到遇到一个字母或数字字符，或者两指针重合为止。也就是说，我们每次将指针移到下一个字母字符或数字字符，再判断这两个指针指向的字符是否相同。

class Solution {
        
        public boolean isPalindrome(String s) {
        
            int n = s.length();
            int left = 0, right = n - 1;
            while (left < right) {
        
                while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
         //Character.isLetterOrDigit():含有字母。字符串
                    ++left;
                }
                while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
        
                    --right;
                }
                if (left < right) {
        
                //Character.toLowerCase()将大写转换为小写
                    if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) {
        
                        return false;
                    }
                    ++left;
                    --right;
                }
            }
            return true;
        }
    }

# 383.赎金信 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 13]  
**思路：**  
第一次遍历，记录ransonNote中字母出现的次数；  
第二次遍历，记录magazine中字母出现的次数；  
然后保证ransonNote中字母出现的次数 <= magazine中相应字母次数即可。

class Solution {
        
        public boolean canConstruct(String ransomNote, String magazine) {
        
            int[] letter1 = new int[128];
            int[] letter2 = new int[128];
    //第一次遍历，记录ransonNote中字母出现的次数；
            for (int i = 0; i < ransomNote.length(); i++){
        
                letter1[ransomNote.charAt(i)]++;
            }
    //第二次遍历，记录magazine中字母出现的次数
            for (int i = 0; i < magazine.length(); i++){
        
                letter2[magazine.charAt(i)]++;
            }
    //保证ransonNote中字母出现的次数 <= magazine中相应字母次数
            for (int i = 0; i < ransomNote.length(); i++){
        
                if (letter1[ransomNote.charAt(i)] > letter2[ransomNote.charAt(i)]){
        
                    return false;
                }
            }
            return true;
    
        }
    }

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 14]  
**思路**  
两个数组，一个记录字母出现次数，一个记录字母第一次出现的位置，遍历次数数组，次数为1的多个字母中，取最先出现的即索引值最小的

int firstUniqChar(char * s) {
        
        int count[26]={
        0};
        int firstIndex[26]={
        0};
    
        for(int i=0;s[i];++i){
        
            int c = s[i]-'a';
            count[c]++;
            if(firstIndex[c]==0){
         //第一个不重复的字符的索引
                firstIndex[c]=i;
            }
        }
    
        int index = INT_MAX;
        for(int i=0;i<26;++i){
        
            if(count[i]==1&&firstIndex[i]<index){
        
                index = firstIndex[i];
            }
        }
        return index==INT_MAX?-1:index;
    }

# 434.字符串中的单词数 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 15]  
**思路：**  
简单说，要设立个flag来判断当前遇到的空格是否就是一个单词的分割符号。条件就是在这之前已经出现过非空格的单词了，flag置1。遇到空格就先判断flag是不是1， 是1就算一个单词，然后将flag置零。反之亦然。

int countSegments(char * s)
    {
        
        int count = 0;
        char *p = s;
        int flag = 0; //判断当前空格是否就是一个单词的分隔符
    
        while (*p != '\0') {
        
            if (*p != ' ') {
         //在这之前是否出现非空格的单词
                flag = 1;
            }
            if (*p == ' ' && flag == 1) {
         //遇到空格就判断falg是否为1，是1就是一个单词，然后将falg清零
                count += 1;
                flag = 0; 
            }
            p++;
        }
        return count + (flag == 1);
    }

# 443.压缩字符串（没懂） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 16]![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 17]![在这里插入图片描述][20200804174737483.png]  
**思路：**  
用指针anchor指向连续块的起始位置，用指针read指向不同于该连续块字符的第一个位置，用write指针更新字符数组。  
read-anchor即为连续块长度，若为1，则不写入，一趟完成后让anchor指向read，即继续扫描下一连续块。

int compress(char* chars, int charsSize){
        
        int write = 0;
        char buf[1000];
    
        //anchor：连续块的起始位置，read:不同于该连续块字符的第一个位置,write：更新字符数组
        for(int read=0,anchor=0; read<charsSize; anchor=read)
        {
        
            while(read<charsSize && chars[read]==chars[anchor]){
        
                read++; //记录多少个相同的连续字符
            }
            chars[write++] = chars[anchor];
    
            //若连续长度为1则不写入
            if(read-anchor==1){
         
                continue;
            }
    
            sprintf(buf,"%d",read-anchor); //将buf作为字符串输出
    
            //strnlen()计算给定字符串的长度
            for(int i=0; i<strlen(buf); i++){
         
                chars[write++] = buf[i];
            }
        }
        return write;
    }

# 459.重复的子字符串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 18]  
**思路：**  
如果您的字符串S包含一个重复的子字符串，那么这意味着您可以多次“移位和换行”您的字符串，并使其与原始字符串匹配。  
例如:abcabc  
移位一次:cabcab  
移位两次:bcabca  
移位三次:abcabc

现在字符串和原字符串匹配了，所以可以得出结论存在重复的子串

基于这个思想，可以每次移动k个字符，直到匹配移动length - 1次。但是这样对于重复字符串很长的字符串，效率会非常低。在LeetCode中执行时间超时了。

为了避免这种无用的环绕，可以创建一个新的字符串str,它等于原来的字符串S再加上S自身，这样其实就包含了所有移动的字符串。

比如字符串：S = acd，那么str = S + S = acdacd

acd移动的可能：dac、cda。其实都包含在了str中了。就像一个滑动窗口

一开始acd (acd) ，移动一次ac(dac)d,移动两次a(cda)cd。循环结束

所以可以直接判断str中去除首尾元素之后，是否包含自身元素。如果包含。则表明存在重复子串。

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

暴力代码如下：（没看）（超出时间限制）

class Solution {
        
       //暴力代码
    public  boolean repeatedSubstringPattern(String s) {
        
            for(int i = 1; i < s.length(); i++) {
        
                String str = rotate(s.toCharArray(),i);
                if(s.equals(str)) return true;
            }
            return false;
        }
    
    
        public  String rotate(char[] nums, int k) {
        
            k = k % nums.length;
            reverse(nums, 0, nums.length - 1);
            reverse(nums, 0, k - 1);
            reverse(nums, k, nums.length - 1);
            return String.valueOf(nums);
        }
    
        public  void reverse(char[] nums, int begin, int end) {
        
            int i = begin, j = end;
            while(i < j) {
        
                char temp = nums[i];
                nums[i++] = nums[j];
                nums[j--] = temp;
            }
        }
    
    }

# 520.检测大写字母 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 19]  
**思路：**  
首先把字符串转变为我们熟悉的字符数组  
1.分析：题目中给的三种情况我们可以转化一下思路  
（1）全是大写字母：大写字母的个数 = 字符数组长度  
（2）首字母大写：大写字母个数为1，并且下标为0  
（3）全是小写字母：大写字母个数为0  
其他情况均返回false  
2.问题就转化为了遍历数组，并统计大写字母位置和下标位置（其中只有大写字母个数为1的时候需要用到下标的判断）  
3.进行判断  
**Java：**

class Solution {
        
        public boolean detectCapitalUse(String word) {
        
            char[] chars = word.toCharArray();
            int index = 0,count = 0;
            for(int i = 0;i < chars.length;i++){
        
                if('A' <= chars[i] && chars[i] <= 'Z'){
        
                    count++;
                    index = i;
                }
            }
            if(count == chars.length || (count == 1 && index == 0))
            return true;
            else if(count == 0)
            return true;
            else
            return false; 
        }
    }

# 521.最长特殊序列I #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 21]

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

# 541.反转字符串II #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 22]

class Solution {
        
        public String reverseStr(String s, int k) {
        
        	//将字符串中的字符转换为一个字符数组
            char[] a = s.toCharArray(); 
    
            //每个块开始于2k的倍数，也就是0,2k,4k,6k,...。
            //注：如果没有足够的字符，则并不需要翻转这个块    
            for (int start = 0; start < a.length; start += 2 * k) {
        
                int i = start, j = Math.min(start + k - 1, a.length - 1);
                //为了翻转从i到j的字符块，我们可以交换位于i++和j--的字符
                while (i < j) {
         
                    char tmp = a[i];
                    a[i++] = a[j];
                    a[j--] = tmp;
                }
            }
            return new String(a);
        }
    }

# 551.学生出勤记录I #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 23]

**方法 1**：  
简单的解法 \[Accepted\]  
解决这个问题最简单的方法就是同济字符串中 AA 的数目并检查 LLLLLL 是否是给定字符串的一个子串。如果 AA 的数目比 22 少且 LLLLLL 不是给定字符串的一个子串，那么返回 truetrue，否则返回 falsefalse。

Java 中indexOfindexOf 方法可以用来检查一个串是否是另一个串的子串。如果找不到子串，那么返回 -1，否则返回这个字符串第一次出现的位置。  
**Java：**

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

**方法 2**：  
优化的解法 \[Accepted\]  
算法：  
上述方法的一个优化是当 AA 的数目有 22 个的时候就中断循环。

public 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 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 24]  
**思路：**  
1、找出空格并将空格前的单词翻转  
2、最后一位的时候，将前面单词翻转

void swap(int left,int right,char *s){
         //翻转函数
        char temp;
        while(left<right){
        
            temp=s[left];
            s[left]=s[right];
            s[right]=temp;
            left++;
            right--;
        }
    }
    
    char * reverseWords(char * s){
         //主
        int i=0,num=0;
        int len =strlen(s);
        
        for(;i<len;i++){
        
            if(s[i]==' '){
        
                swap(num,i-1,s);
                num=i+1;
            }
            if(i==len-1)swap(num,i,s);
    
        }
        return s;
    }

# 680.验证回文字符串II #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 25]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 26]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 27]

class Solution {
        
        public boolean validPalindrome(String s) {
        
            int low = 0, high = s.length() - 1;
    
            while (low < high) {
        
                char c1 = s.charAt(low), c2 = s.charAt(high);
    
                if (c1 == c2) {
        
                    low++;
                    high--;
                } else {
        
                    boolean flag1 = true, flag2 = true;
                    //删除右边的
                    for (int i = low, j = high - 1; i < j; i++, j--) {
        
                        char c3 = s.charAt(i), c4 = s.charAt(j);
                        if (c3 != c4) {
        
                            flag1 = false;
                            break;
                        }
                    }
                    //删除左边的
                    for (int i = low + 1, j = high; i < j; i++, j--) {
        
                        char c3 = s.charAt(i), c4 = s.charAt(j);
                        if (c3 != c4) {
        
                            flag2 = false;
                            break;
                        }
                    }
                    //只有满足其中一个为真则返回真
                    return flag1 || flag2;
                }
            }
    
            return true;
        }
    }

# 686.重复叠加字符串匹配 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 28]

class Solution {
        
        public int repeatedStringMatch(String A, String B) {
        
            int sum=A.length();
            for(int i=0;i<10000;i++){
        
                A=A+A.charAt(i);
            }
            int number;
            //B中字符第一次出现的索引
            int num=A.indexOf(B); 
            if(num==-1)
            return -1;
            //number:B最后一个字符在A中的索引
            number=num+B.length();
            if(number%sum==0) //！！！！
            return number/sum;
            else
            return number/sum+1;
        }
    }

# 696.计数二进制子串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 29]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 30]

class Solution {
        
        public int countBinarySubstrings(String s) {
        
            int[] groups = new int[s.length()];
            int t = 0;
            groups[0] = 1;
            for (int i = 1; i < s.length(); i++) {
        
                if (s.charAt(i-1) != s.charAt(i)) {
        
                    groups[++t] = 1;
                } else {
        
                    groups[t]++;
                }
            }
    
            int ans = 0;
            for (int i = 1; i <= t; i++) {
        
                ans += Math.min(groups[i-1], groups[i]);
            }
            return ans;
        }
    }

# 面试题 01.09.字符串轮转 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 31]

**思路：**  
长度相等时，若s2是s1旋转而成的，那么把s2和自身拼接一次，s1就会出现在其中  
“erbottlewat” + “erbottlewat” = erbottle waterbottle wat  
如果s2不是s1旋转而成的，那么那么把s2和自身拼接一次，s1就肯定不会出现在其中

class Solution {
        
        public boolean isFlipedString(String s1, String s2) {
        
            // 长度不相等，肯定不符合要求
            if (s1.length() != s2.length()) {
        
                return false;
            }
    
            // 长度相等时，若s2是s1旋转而成的，那么把s2和自身拼接一次，s1就会出现在其中
            // "erbottlewat" + "erbottlewat" = erbottle waterbottle wat
        	// 如果s2不是s1旋转而成的，那么那么把s2和自身拼接一次，s1就肯定不会出现在其中
            return (s2 + s2).indexOf(s1) != -1;
        }
    }

# 面试题 01.06.字符串压缩 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 32]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 33]

class Solution {
        
    
    /**
    *前后双指针
    *O(n)
    *O(1)
    */
    public String compressString(String S) {
        
        int len =S.length();
        if(S==null||len<=1) return S;
    
        //StringBuilder：一个可变的字符序列
        StringBuilder sb = new StringBuilder();  
        //快慢前后双指针
        int l=0,r=1;
        while(r<len){
        
            if(S.charAt(r)!=S.charAt(l)){
        
                //append()创建了一个新的数组，扩大了长度，将需要添加的字符串添加到这个新的数组中
                sb.append(S.charAt(l));
                sb.append((r-l)+"");
                l=r;
                r+=1;
            }else{
        
                r++;
            }
        }
        
        //最后一个相同的字符
        sb.append(S.charAt(l));
        sb.append((r-l)+"");
    
        //和原字符串比较长度
        return sb.length()>=len?S:sb.toString();
    }
    
    }

# 788.旋转数字 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 34]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 35]

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);
        }
    }

# 709.转换成小写字母 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 36]  
**思路1：**

char * toLowerCase(char * str){
        
        char *returned=calloc(strlen(str)+1,sizeof(char));
    
        int i;
        for(i=0;i<strlen(str);i++){
        
            if(64<str[i]&&str[i]<97)
                returned[i]=str[i]+32;
            else
                returned[i]=str[i];
        }
        
        return returned;
    }

**思路2：**  
学习使用isupper和tolower函数，提高程序可读性

char *toLowerCase(char *str)
    {
        
        int len = strlen(str);
        if (len < 1) {
        
            return NULL;
        }
        for (int i = 0; i < len; i++) {
        
            //isupper:检查所传字符是否为大写字母
            //tolower:把字母字符转换为小写字母，非字母字符不做处理
            isupper(str[i]) ? str[i] = tolower(str[i]) : ' ';
        }
        return str;
    }

# 剑指Offer 58 - I.翻转单词顺序 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 37]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 38]  
PS:strim(),StringBuilder,append(),toString(),charAt()

class Solution {
        
        public String reverseWords(String s) {
        
            s = s.trim(); // 删除首尾空格
            int j = s.length() - 1, i = j;
            
            StringBuilder res = new StringBuilder();
            while(i >= 0) {
        
                while(i >= 0 && s.charAt(i) != ' ') i--; // 搜索首个空格
                //substring:返回字符串的子字符串
                res.append(s.substring(i + 1, j + 1) + " "); // 添加单词
    
                while(i >= 0 && s.charAt(i) == ' ') i--; // 跳过单词间空格
    
                j = i; // j 指向下个单词的尾字符
            }
    
            return res.toString().trim(); // 转化为字符串并返回
        }
    }

# 819.最常见的单词（不懂 哈希映射） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 39]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 40]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 41]

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;
        }
    }

# 917.仅仅反转字母 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 42]  
![在这里插入图片描述][20200806170647327.png]  
\*\*方法 1：\*\*字母栈  
想法和算法

将 s 中的所有字母单独存入栈中，所以出栈等价于对字母反序操作。（或者，可以用数组存储字母并反序数组。）

然后，遍历 s 的所有字符，如果是字母我们就选择栈顶元素输出

class Solution {
        
        public String reverseOnlyLetters(String S) {
        
            Stack<Character> letters = new Stack();
            for (char c: S.toCharArray()){
        
                //isLetter():判定自定字符是否为字母
                //push()：把对象压入堆栈的顶部
                if (Character.isLetter(c))
                    letters.push(c);
            }
    
            StringBuilder ans = new StringBuilder();
            for (char c: S.toCharArray()) {
        
                if (Character.isLetter(c))
                    //pop:从集合中把最后一个元素删除，并返回这个元素的值
                    ans.append(letters.pop());
                else
                    ans.append(c);
            }
    
            return ans.toString();
        }
    }

# 859.亲密字符串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 43]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 44]

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));
            }
    
        }
    
    }

# 336.回文对（一点不懂） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 45]  
**涉及知识：**  
字典树，哈希表

# 824，山羊拉丁文（没看） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 46]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 47]

# \---------------------8.8----------------------------- #

# 1071.字符串的最大公因子 #

[图片解释][Link 1]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 48]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 49]

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);
        }
    }

# 1170.比较字符串最小字母出现频次（看不懂啊） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 50]

# 1332.删除回文子序列 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 51]  
![在这里插入图片描述][20200807172711561.png]  
**思路：**  
只有三种情况：  
1.空字符串：删除0次  
2.回文字符串：删除1次  
3.非回文串 删除2次（一次全部删除a，一次全部删除b）

int removePalindromeSub(char * s){
        
        int len = strlen(s);
    
        if(len==0){
        
            return 0;
        }
    
        int low,hight = len - 1;
        for(low=0; hight; low++,hight--){
        
            if(s[low]!=s[hight]){
        
                return 2;
            }
        }
    
        return 1;
    }

# 1446.连续字符 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 52]  
**注：**  
子串：指的是串中任意个连续的字符组成的子序列，称为改串的子串  
子序列：可以是不连续的

**思路：**  
连续相同的字符确定一个区间\[left,i)。  
left是区间左边界。  
i是当前遍历的字符。  
当A\[i\] != A\[left\]时，表示区间\[left,i)结束。i-left就是区间长度，就是可能的解之一。

容易错的地方在于最后一个区间\[left,A.length)，没有处理。  
当i == A.length时，循环结束。忘记统计此区间的长度，丢失解。

int maxPower(char *s)
    {
        
        int i;
        int start;
        int max_len = 1;
        int temp_len = 1;
    
        start = 0;
        for (i = 1; i < strlen(s); i++) {
        
            if (s[i] == s[start]) {
        
                temp_len++;
            } else {
        
                start = i;
                if (temp_len > max_len) {
        
                    max_len = temp_len;
                }
                temp_len = 1;
            }
        }
    
        // 最后一句很关键，把最后start直到末尾算出的temp_len和max_len比较一下
        // 例如“eettt”，计算出的max_len为2，但最后start直到末尾算出的temp_len为3
        return max_len > temp_len ? max_len : temp_len;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 53]

# 剑指Offer 58 - II.左旋转字符串（复习） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 54]

class Solution {
        
        public String reverseLeftWords(String s, int n) {
        
            return s.substring(n, s.length()) + s.substring(0, n);
        }
    }

**注：**  
收藏夹里 多种解法很有意义 还没有仔细看

# 面试题 01.04. 回文排列 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 55]  
**思路：**  
构成回文的字符串，相同字符的个数中，最多有一个是奇数。超过一个，则不是回文串

bool canPermutePalindrome(char* s){
        
        int ascii[128] = {
        0};
        int oddSum = 0;
    
        for(int i=0;i<strlen(s);i++)
        {
        
            ascii[s[i]]++;
        }
    
        for(int i=0;i<128;i++)
        {
        
            //相同字符的个数中，最多有一个是奇数
            if(ascii[i]%2 != 0) 
            {
        
                oddSum++;
            }
            if(oddSum>1)
            {
        
                return false;
            }
        }
        
        return true;
    }

# 上升下降字符串（没写） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 56]

![在这里插入图片描述][2020080801513710.png]

# \--------------------8.9------------------- #

# 93.复原IP地址（没看） #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 57]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 58]

#define SEG_COUNT 4
    int segments[SEG_COUNT];
    char** ans;
    int ans_len;
    
    void dfs(char* s, int segId, int segStart) {
        
        // 如果找到了 4 段 IP 地址并且遍历完了字符串，那么就是一种答案
        int len_s = strlen(s);
        if (segId == SEG_COUNT) {
        
            if (segStart == len_s) {
        
                char* ipAddr = (char*)malloc(sizeof(char) * (len_s + 4));
                int add = 0;
                for (int i = 0; i < SEG_COUNT; ++i) {
        
                    int number = segments[i];
                    if (number >= 100) {
        
                        ipAddr[add++] = number / 100 + '0';
                    }
                    if (number >= 10) {
        
                        ipAddr[add++] = number % 100 / 10 + '0';
                    }
                    ipAddr[add++] = number % 10 + '0';
                    if (i != SEG_COUNT - 1) {
        
                        ipAddr[add++] = '.';
                    }
                }
                ipAddr[add] = 0;
                ans = realloc(ans, sizeof(char*) * (ans_len + 1));
                ans[ans_len++] = ipAddr;
            }
            return;
        }
    
        // 如果还没有找到 4 段 IP 地址就已经遍历完了字符串，那么提前回溯
        if (segStart == len_s) {
        
            return;
        }
    
        // 由于不能有前导零，如果当前数字为 0，那么这一段 IP 地址只能为 0
        if (s[segStart] == '0') {
        
            segments[segId] = 0;
            dfs(s, segId + 1, segStart + 1);
        }
    
        // 一般情况，枚举每一种可能性并递归
        int addr = 0;
        for (int segEnd = segStart; segEnd < len_s; ++segEnd) {
        
            addr = addr * 10 + (s[segEnd] - '0');
            if (addr > 0 && addr <= 0xFF) {
        
                segments[segId] = addr;
                dfs(s, segId + 1, segEnd + 1);
            } else {
        
                break;
            }
        }
    }
    
    char** restoreIpAddresses(char* s, int* returnSize) {
        
        ans = (char**)malloc(0);
        ans_len = 0;
        dfs(s, 0, 0);
        (*returnSize) = ans_len;
        return ans;
    }

# 43.字符串相乘 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 1]

class Solution {
        
        public String multiply(String num1, String num2) {
          //主
            //两个字符串都为0
            if (num1.equals("0") || num2.equals("0")) {
        
                return "0";
            }
    
            String ans = "0";
            int m = num1.length(), n = num2.length();
    
            for (int i = n - 1; i >= 0; i--) {
        
                //存储和操作可扩充、修改的字符串
                StringBuffer curr = new StringBuffer();
                int add = 0;
                for (int j = n - 1; j > i; j--) {
        
                    //创建一个新的数组，扩大了长度，将需要添加的字符串复制到这个新的数组中
                    curr.append(0);
                }
                int y = num2.charAt(i) - '0';
                for (int j = m - 1; j >= 0; j--) {
        
                    //返回索引中的字符
                    int x = num1.charAt(j) - '0';
                    int product = x * y + add;
                    curr.append(product % 10);
                    add = product / 10;
                }
                if (add != 0) {
        
                    curr.append(add % 10);
                }
                ans = addStrings(ans, curr.reverse().toString());
            }
            return ans;
        }
    
        public String addStrings(String num1, String num2) {
        
            int i = num1.length() - 1, j = num2.length() - 1, add = 0;
            StringBuffer ans = new StringBuffer();
            while (i >= 0 || j >= 0 || add != 0) {
        
                int x = i >= 0 ? num1.charAt(i) - '0' : 0;
                int y = j >= 0 ? num2.charAt(j) - '0' : 0;
                int result = x + y + add;
                ans.append(result % 10);
                add = result / 10;
                i--;
                j--;
            }
            ans.reverse();
            return ans.toString();
        }
    }

# \--------------8.13------------ #

# 1544.整理字符串 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 2]  
Java：  
思路一：从头遍历，依次将字符串s的字符入栈，如果当前字符使栈顶字符对应的大小写，则将栈顶元素弹出即可

class Solution {
        
        public String makeGood(String s) {
        
            if(s.length() == 0 || s.length() == 1) return s;
            Stack<Character> stack = new Stack<>();
            //遍历s
            for(int i = 0; i < s.length(); i++){
        
                char cur = s.charAt(i);
                //若栈为空，则直接压栈即可
                if(stack.isEmpty()){
        
                    stack.push(s.charAt(i));
                    continue;
                }
                //栈顶元素
                char tmp = stack.peek();
                //如果当前字母是栈顶元素对应的大写或小写，则弹出栈顶元素
                if(cur-tmp == 32 || cur-tmp == -32){
        
                    stack.pop();
                }else{
        
                    stack.push(cur);
                }
            }
            //将栈中元素依次弹出反转即可
            String res = "";
            while(!stack.isEmpty()){
        
                res += String.valueOf(stack.peek());
                stack.pop();
            }
            StringBuilder sb = new StringBuilder(res);
            return sb.reverse().toString();
        }
    }

C：  
![在这里插入图片描述][20200813222455118.png_pic_center]

// 判断是否满足题意的重叠，如果是并记录重叠开始的位置
    bool is_overlap(char *s, int *index)
    {
        
        if (strlen(s) == 0) {
        
            return false;
        }
        
        for (int i = 0; i < strlen(s) - 1; i++) {
        
            if (abs(s[i] - s[i + 1]) == 'a' - 'A') {
        
                *index = i;
                return true;
            }
        }
    
        return false;
    }
    
    char *makeGood(char *s) //主
    {
        
        int index;
    
        // 如果重叠,则删除重叠元素并进行下一次递归；如果最终精简为空串，则判断不重叠，直接返回空串
        if (is_overlap(s, &index)) {
        
            memmove(&s[index], &s[index + 2], (strlen(s) + 1) - (index + 2)); // 长度strlen(s) + 1表示把字符串结尾的'\0'也拷贝进来
            makeGood(s);
        }
    
        return s;
    }

# 1507.转变日期格式 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 3]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 4]

class Solution {
        
        public String reformatDate(String date) {
        
            String[] months = {
        "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
            Map<String, Integer> s2month = new HashMap<String, Integer>();
            //字典映射的方式把月份的英文缩写转换成对应的数字
            for (int i = 1; i <= 12; i++) {
        
                s2month.put(months[i - 1], i);
            }
    
            String[] array = date.split(" ");
    
            int year = Integer.parseInt(array[2]);
            int month = s2month.get(array[1]);
            int day = Integer.parseInt(array[0].substring(0, array[0].length() - 2));
            return String.format("%d-%02d-%02d", year, month, day);
        }
    }

# 1455.检查单词是否为居中其他单词的前缀 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 5]

int isPrefixOfWord(char * sentence, char * searchWord){
        
        int i=0;
        if(*sentence==*searchWord)      //这个的作用是判断第一个是否符合要求，因为我是以空格为标志的
        {
                                       //而第一个单词前面是没有空格的
            while(searchWord[i])
            {
        
                if(searchWord[i]!=sentence[i])
                {
        
                    break;
                }
                i++;
            }
            if(searchWord[i]==NULL)
                return 1;
        }
        
        int j=0;
        int count=1;                //count是计算的是第几个单词
        while(sentence[i])                //遇到空格就对后续进行判断
        {
                                             
            if(sentence[i]==' ')
            {
        
                i++;
                count++;
                while(searchWord[j])
                {
        
                    if(searchWord[j]!=sentence[i+j])
                    {
        
                        break;
                    }
                    j++;
                }
                if(searchWord[j]==NULL)
                {
        
                    return count;
                }
                j=0;
            }
            i++;
        }
    
        return -1;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70]: /images/20230208/e9d48068631c41cbb937f0d702ed98d6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 1]: /images/20230208/996ffa2056514aceaf96e28040623bb7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 2]: /images/20230208/d8bebe3d43084f6f8d83621dd6aae407.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 3]: /images/20230208/3e4a6c26752740169304550c60fd06f6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 4]: /images/20230208/5dea87476bee4bf291dc8e2aa7f564d1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 5]: /images/20230208/95859a753ae04667935a4e6489938b1b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 6]: /images/20230208/6fdf5bfac30f4ac581a4223c7b09d2f0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 7]: /images/20230208/ea5e2e7efe1b44289d4be559c729e344.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 8]: /images/20230208/5f02f70982f54bdb82719b4c1e94df08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 9]: /images/20230208/8a4036ab0bdb4b4091c7bc763ee9c928.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 10]: /images/20230208/d07b7741c63a4394be87c8c7631ad613.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 11]: /images/20230208/69a4f36034ac42169df905f89d4b3b7d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 12]: /images/20230208/297a96a87d32415a9ba159702dbd42c4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 13]: /images/20230208/5ef5093c8cb14319a7a308c7c112ab86.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 14]: /images/20230208/cd7d7b1c191a472e91bfa32c712a0ce2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 15]: /images/20230208/b0ab866dbc2d4b569dc74a811974f3f7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20200804173253443.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20200804173920704.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2,size_16,color_FFFFFF,t_70
[20200804174737483.png]: /images/20230208/5063f61337a24d33aecf7ed960e45548.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 18]: /images/20230208/69ecc5ca7bac4b4bbffa41da320261a2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 19]: /images/20230208/cb567edcce9148fe9c1cf27d531b95e1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 20]: /images/20230208/f8c4979137e047978faf440fd5764590.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 21]: /images/20230208/eb60ff3902da45589e34cc9d7589c4c8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 22]: /images/20230208/f31e2acff7de4c9b831bb017f9b139ec.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 23]: /images/20230208/c7953fe058094146b7fb46c20379b032.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 24]: /images/20230208/41aa2d081c7f4041bc90a9ea202b7bf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 25]: /images/20230208/d8a97e57edbc492cbca56e52da99db02.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 26]: /images/20230208/d17f74b556b84b289cc075f8056c2a90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 27]: /images/20230208/049e0ce7a7484eadb2bcfea3042234d2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 28]: /images/20230208/7cc2c6e4191c48948e4e3189c55a8134.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 29]: /images/20230208/486ef16b14ed4719a7179521131349f1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 30]: /images/20230208/c7f90f5f8a7444ac8a13a7e07d1cad78.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 31]: /images/20230208/0deac8b93a4247a8b665567a0c8ff6ed.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 32]: /images/20230208/824cd4a0f45042869f320afe3780f44f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 33]: /images/20230208/f08d593c52cf459f833f02be3df1dc0b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 34]: /images/20230208/c575e7fb5abc4b9b85590d55b82d58a3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 35]: /images/20230208/5264e3cd52c24668bd98695c5b2a01fe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 36]: /images/20230208/f621e4b3e0f8419a8d0dc1f7456271c3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 37]: /images/20230208/40e3f67d499b464eaca07b46c287a68b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 38]: /images/20230208/5de6d17e2548422eba6aef33171c57a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 39]: /images/20230208/a17ec41023ac4581a7b49ce1366cd065.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 40]: /images/20230208/5b1a76a7dc074483b92a14b48d884c50.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 41]: /images/20230208/62a7d72e8f514376b809a8044c75d4bf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 42]: /images/20230208/47681449e81046c1836fbe3c056128db.png
[20200806170647327.png]: /images/20230208/b33f1fa5ccb74d0f9ff4a6412df82d06.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 43]: /images/20230208/4293e14b3f8b446c99122de49278510e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 44]: /images/20230208/8f02a59ec62e4416a5636f1ec4d1d523.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 45]: /images/20230208/7c412b089fba404a9ea51f3db0fc03a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 46]: /images/20230208/1b9eab24ee2d41f3a41c440eb02bcbd7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 47]: /images/20230208/bf42f53d7ef04029b9cd14df4be6635f.png
[Link 1]: https://leetcode-cn.com/problems/greatest-common-divisor-of-strings/solution/java-hen-jian-ji-yi-yan-jiu-neng-kan-ming-bai-by-s/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 48]: /images/20230208/7ed5b7a2f1744e6a8680b1212495173d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 49]: /images/20230208/95a95b5b365d47af844545aa501898a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 50]: /images/20230208/e5ca101640314317bf51242bbc879de3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 51]: /images/20230208/d28a4c53984041d2a497cd0900e65edc.png
[20200807172711561.png]: /images/20230208/8ad634015b924389a8898d8ace63410c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 52]: /images/20230208/3fcdec4fd53b43a689ab5e9223dfc639.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 53]: /images/20230208/149dd08e452542b09e149d3c8333b11b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 54]: /images/20230208/3e2417cdc72a4961bf50b7f049fb7b3a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 55]: /images/20230208/26a4dc7d2853492aa5eea17c56552b91.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 56]: /images/20230208/c7ea20693363439da71538965f55f52b.png
[2020080801513710.png]: /images/20230208/4a7186e0416549548064eceac5a7b0ac.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 57]: /images/20230208/ecaefbc80f3a45efb69fcc05e3cdcd68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70 58]: /images/20230208/6b6de70c33e145149681eed82485e3be.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center]: /images/20230208/675ca7765fb74a37bc11c437f547428b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20230208/c978a049f2ae44b38c014d8fd3a80d6d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20230208/4700a6972edc4a0e8dd5f80aab2272be.png
[20200813222455118.png_pic_center]: /images/20230208/bc5e77c405e54b4a9b5c089730052558.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20230208/e824ad8f5873404a84c221ad1133b44c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20230208/260eb488c4994e2487a6194965f5177d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2NjcyNzQ2_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20230208/4540cce956fa4fa29e8cdbeacae3d08c.png