数据结构和算法习题部分字符串及相关习题

柔情只为你懂 2022-02-14 04:23 251阅读 0赞

一、算法描述部分  
1、字符串匹配算法  
字符串匹配算法分为两种，一种是暴力匹配算法，一种是KMP匹配算法，  
假如有两个字符串，一个字符串叫做目标串t，一个字符串叫做模式串p，则有  
![在这里插入图片描述][20190518200144534.png]  
其中m<<n,那么字符串的匹配就是在目标串t中寻找模式串p的过程，  
（1）暴力匹配算法

*  从左向右逐个字符的匹配。
 *  如果发现不匹配时，转去考虑目标串里的下一个位置是否与模式串匹配  
    **例如：**  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70]  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 1]  
    代码实现

class solution2():
      	#模式匹配
        def match1(self,s,pattern):
            m,n=len(s),len(pattern)
            i,j=0,0
            while i<m and j<n:
                if s[i]==pattern[j]:
                    i,j=i+1,j+1
                else:
                    i,j=0,j-i+1
            #如果子串已经全部寻找结束
            if i==m:
                return True
            #如果非子串寻找结束没有找到
            return False
    print(solution2().match1("aaa","cccssasaa"))

解析：这道题中我设置了两个游标，分别是i和j，如果游标指向的字母相等，则可能两个游标同时加1，如果两个游标指向的字母不相等，则i指针还原到0，j指针还原到两个字符重新开始匹配的下一个位置，即j-i+1.  
2、KMP字符串匹配算法

#kmp匹配算法
    '''
    kmp匹配算法的核心是找到要匹配字符串的公共前后缀
    什么叫公共前后缀呢，
    例如，”Harry”的前缀包括{”H”, ”Ha”, ”Har”, ”Harr”}，我们把所有前缀组成的集合，称为字符串的前缀集合。
    同样可以定义后缀例如，”Potter”的后缀包括{”otter”, ”tter”, ”ter”, ”er”, ”r”}，然后把所有后缀组成的集合，
    称为字符串的后缀集合。要注意的是，字符串本身并不是自己的后缀。
    
    公共前后缀即前缀和后缀集合的交集
    那么我们首先寻找公共前后缀交集
    如：abababca
    a :第一位为0
    ab:前缀：[a,ab],后缀：[ab,b] 公共前后缀：0
    aba:前缀：[a,ab,aba].后缀：[ba,a] 公共前后缀：1
    abab:前缀：[a,ab,aba,abab].后缀：[bab,ab,b] 公共前后缀：2
    ababa:前缀：[a,ab,aba,abab,ababa].后缀：[baba,aba,ba,a] 公共前后缀：3
    ...
    abababca:前缀：[a,ab,aba,abab,ababa,ababab,abababc,abababca].
    后缀：[bababca,ababca,babca,abca,bca,ca,a] 公共前后缀：1
    我们将公共前后缀的记录列表设为pmt，要用的表设为next
    char    a b a b a b c a  
    index   0 1 2 3 4 5 6 7
    pmt     0 0 1 2 3 4 0 1
    next   -1 0 0 1 2 3 4 0 #next即将pmt前面添加一个-1，所有字符串后移
    
    2、寻找next的方法
    方法是以要匹配的字符串自身进行匹配查找（自身字符串串为后缀串，后移一位串为前缀串）
    如寻找aba的最大公共前后缀
    aba 
      aba 匹配为1
    而我们以abababca为例进行连续字串的匹配
    abababca
     abababca pmt[1]=0 [_ 0 _ _ _ _ _ _]
    
    abababca
      abababca pmt[2]=1 pmt[3]=2 pmt[4]=3 pmt[5]=4 
      [_ 0 1 2 3 4 _ _]
    abababca
          abababca pmt[6]=0
    abababca
           abababca pmt[7]=1 [_ 0 1 2 3 4 0 1]
    将第一位补上0 
    pmt=[0 0 1 2 3 4 0 1]  
    
    kmp匹配的方法
    要在主字符串"ababababca"中查找模式字符串"abababca"。如果在 j 处字符不匹配，
    那么由于前边所说的模式字符串 PMT 的性质，主字符串中 i 指针之前的 PMT[j −1] 位就一定与
    模式字符串的第 0 位至第 PMT[j−1] 位是相同的。（不能选取第j位，因为第j位不匹配）这是因为主字符串在 i 位失配，也就意味着主字符串从 i−j 到 i 这一段是与模式字符串的 0 到 j 这一段是完全相同的。从上面的例子来讲
          i
    abababababca
    abababca
    	  j
    这时i和j不匹配，此时模式字符串从 0 到 j−1 ，在这个例子中就是”ababab”，
    其前缀集合与后缀集合的交集的最长元素为”abab”，即以ababab中以abab开头的前缀
    和以abab结尾的后缀长度是一样的，此时我们只需要将字符串从前缀字符串打头的位置
    移动到后缀字符串打头的位置
    '''

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

'''
    具体的做法是，
    i+1，然后将j指针指向模式字符串的PMT[j −1]+1位即可。
          i  
    ababababca
    abababca
          j
    所以i+1,j从第4位的后一位开始比较
          i                 
    ababababca
      abababca          
          j
    '''
    具体什么意思呢，咱们来看看比较的过程
    def find_pub_list(str1):
        count=0 #记录公共字串的长度
        list1=[]
        str2=str1
        cursor1=1
        cursor2=0
        n1=len(str1)
        while True:
            if cursor1==n1:
                break
            if str1[cursor1]!=str2[cursor2]:
                cursor1+=1
                cursor2=0
                count=0
                list1.append(count)
            else:
                count+=1
                cursor1+=1
                cursor2+=1
                list1.append(count)
           
        list1.insert(0,0)
        list1.insert(0,-1)
        return list1[:-1]
    find_pub_list('abababca')            
    def kmp_match(str1,str2):
        #str1:为原字符串
        #str2:为匹配字符串
        n1,n2=len(str1),len(str2)
        list1=find_pub_list(str2)
        i,j=0,0
        while i<n1 and j<n2:
            if j==n2:
                break
            if str1[i]==str2[j]:
                i+=1
                j+=1
            else:
                j=list1[j]+1
                i+=1         
        if j==n2:
            return True
        else:
            return False
    kmp_match('ababababca','abababcad')                   
    print(kmp_match("abababcabc","abcabc"))
    print(kmp_match("abababcabca","abcabca"))
    print(kmp_match("aaaaaaaaaaaaab","a"))
    print(kmp_match("aaaaaaaaaaaaab","ab"))
    print(kmp_match("aaaaaaaaaaaaab","abc"))

解析：  
<1>其中前缀表的书写，通过i和j两个指针来进行书写。i从第0个字符出发，j从第1个，当s\[i\]==s\[j\]时在prelist的j位置存入count+1，当s\[i\]!=s\[j\]时，存入count=0,只要不等重置count,直到所有循环结束。

题目2：  
题目描述  
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution:
        # s 源字符串
        def replaceSpace(self, s):
            # write code here
            s_lis=list(s)
            for i in range(len(s_lis)):
                if s_lis[i]==" ":
                    s_lis[i]="%20"
            return "".join(s_lis)

思路1：将字符串转化为list，遍历整个list将里面的空格成“%20”，然后拼接。

# -*- coding:utf-8 -*-
    class Solution:
        # s 源字符串
        def replaceSpace(self, s):
            # write code here
            s=s.replace(" ","%20")
            return s

思路2：利用python中replace函数进行替换，并将其返回给s，但是注意：用replace替换时，python会将字符串自动向后填充（空格为1格，%20为三格）  
两种方法最后的时间差不多。  
**题目3：**(考的可能不大，主要看思路，如何分类考虑多种情况)  
题目描述  
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。例如，字符串"+100",“5e2”,"-123",“3.1416"和”-1E-16"都表示数值。 但是"12e",“1a3.14”,“1.2.3”,"±5"和"12e+4.3"都不是。

# -*- coding:utf-8 -*-
    class Solution:
        # s字符串
        def isNumeric(self, s):
            # write code here
            val1=self.ispoint(s)
            if val1:#有小数点
                beforepoint=s[:val1]
                afterpoint=s[val1+1:]
                #print(beforepoint,afterpoint)
                if self.isrightbeforepoint(beforepoint) and self.isrightafterpoint(afterpoint): #小数点两边都很规整
                    return True
                else:#有一边不规整
                    return False
            else:
                if self.isnum(s): #判断没有小数点的数字是否规整
                    return True
                else:
                    return False
        def ispoint(self,s):
            for i in range(len(s)):
                if s[i] == ".":
                    return i
            return False
        def isrightbeforepoint(self,s):
            if len(s)==1 and s[0]==" ":#小数点前面为空值
                return True
            if s[0] in ["+", "-"]:
                return True
                s=s[1:]
            judge=[False for z in range(len(s))]
            for j in range(len(s)):
                if s[j] in ["0","1","2","3","4","5","6","7","8","9"]:
                    judge[j]=True
            if sum(judge)==len(s):
                return True
            else:
                return False
        def isrightafterpoint(self,s):
            for i in range(len(s)):
                if s[i]=="E" or s[i]=="e":
                    break
            if i==len(s)-1:
                #"e"在最后一位
                if s[i]=="E" or s[i]=="e":
                    return False
                else:#没有包含e/E
                    judge = [False for z in range(len(s))]
                    for j in range(len(s)):
                        if s[j] in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
                            judge[j] = True
                    # 只包含0-9这9个数
                    if sum(judge)==len(s):
                        return True
                    else:
                        return False
            else: #包含"E/e",且不会在最后一个
                s_before_e=s[:i]
                s_after_e=s[i+1:]
                if self.before_e(s_before_e) and self.after_e(s_after_e):
                    return True
        def before_e(self,s):
            if len(s)==0:
                return False
            else:
                if s[0] in ["+", "-"]:
                    s = s[1:]
                if len(s)==0:
                    return False
                # 只包含0-9这9个数
                judge = [False for z in range(len(s))]
                for j in range(len(s)):
                    if s[j] in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
                        judge[j] = True
                if sum(judge) == len(s):
                    return True
                else:
                    return False
        def after_e(self,s):
            if s[0]=="+" or s[0]=="-":
                s=s[1:]
            if len(s)==0:
                return False
            else:
                #e后面除了+，-还有别的
                # 只包含0-9这9个数
                judge = [False for z in range(len(s))]
                for j in range(len(s)):
                    if s[j] in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
                        judge[j] = True
                if sum(judge) == len(s):
                    return True
                else:
                    return False
        def isnum(self,s):
            for i in range(len(s)):
                if s[i]=="E" or s[i]=="e":
                    break
            if i==len(s)-1:
                #"e"在最后一位
                if s[i]=="E" or s[i]=="e":
                    return False
                else:#没有包含e/E
                    if s[0] in ["+","-"]:
                        s=s[1:]
                    judge = [False for z in range(len(s))]
                    for j in range(len(s)):
                        if s[j] in ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]:
                            judge[j] = True
                    if sum(judge) == len(s):
                        return True
                    else:
                        return False
            else:
                if s[0]=="E" or s[0]=="e":
                    return False
                else:
                    #e不在第一位也不在末尾
                    before_e=s[:i]
                    after_e=s[i+1:]
                    if self.before_e(before_e) and self.after_e(after_e):
                        return True
                    else:
                        return False
    
    print(Solution().isNumeric("5E2"))
    print(Solution().isrightbeforepoint("3"))
    print(Solution().isrightafterpoint("123231"))
    print(Solution().ispoint("3.123231"))
    print(Solution().isNumeric("3.123231"))
    print(Solution().isrightafterpoint("45e+6"))
    print(Solution().isNumeric("123.45e+6"))
    print(Solution().isNumeric("+500"))
    print(Solution().isNumeric("-.123"))
    print(Solution().before_e("-1"))
    print(Solution().before_e("-16"))
    print(Solution().isNumeric("-1E-16"))

解析：这道题主要要分为是否包含小数点，是否包含正负号，正负号的位置，只能位于第一位或者E后面的位置，是否包含E\\e,如果包含小数点和E/e必须将字符串拆成两部分进行分析拆开进行分析。  
注字符串截取，如i代表字符串的第i个字符  
那么a\[:i\]表示截取i以前的所有字符，a\[i:\]表示截取字符串本身及以后的所有字符。  
**习题2：求字符串的所有排列**  
设计一个程序，当输出字符串的所有排列。例如输入“abc”,输出abc、acb、bac、bca、cba、cab

class Solution:
        def Permution_transe(self,str):
        	if len(str)==):
        		return []
            str1=list(str)
            self.result=[]
            self.Permutation(str1,0)
            return self.result
        def swap(self,str,i,j):
            str[j],str[i]=str[i],str[j]
        def Permutation(self,str1,start):
            if start==len(str1)-1:
                #print("".join(str1))
                self.result.append("".join(str1))
            else:
                i=start
                while i<len(str1):
                    #print(start,i)
                    self.swap(str1,start,i)
                    self.Permutation(str1,start+1)
                    self.swap(str1,start,i)
                    i+=1
    str="abcd"
    print(Solution().Permution_transe(str))
    str="abdd"
    print(Solution().Permution_transe(str))

解析：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 2]  
全排列怎么实现呢，可以利用递归。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 3]  
解法2：加入去重函数，比如abb,进行全排列时，b和b重复了，只进行第一个和第三个的交换，这样就不会出现重复的排列组合

class Solution:
        def Permution_transe(self,str):
            str1=list(str)
            self.result=[]
            self.Permutation(str1,0)
            return self.result
        def swap(self,str,i,j):
            str[j],str[i]=str[i],str[j]
        def duplicated(self,str1,i,j):
            #寻找[i,j)的字符串中是否有与str1[j]相等的字符
            #如果有返回True
            #否则返回False
            start=i
            while start<j:
                if str1[start]==str1[j]:
                    return True
                start+=1
            return False
        def Permutation(self,str1,start):
            if str1==[] or start<0:
                return []
            if start==len(str1)-1:
                #print("".join(str1))
                self.result.append("".join(str1))
            else:
                i=start
                while i<len(str1):
                    #print(start,i)
                    if self.duplicated(str1,start,i):
                        i+=1
                        continue
                    self.swap(str1,start,i)
                    self.Permutation(str1,start+1)
                    self.swap(str1,start,i)
                    i+=1
    str="abcd"
    print(Solution().Permution_transe(str))
    str="abddssssdsdasfsa"
    print(Solution().Permution_transe(str))
    str="baa"
    print(Solution().Permution_transe(str))

习题3：求解两个字符串的最长公共子串

class Solution:
        def getMaxSubStr(self,str1,str2):
            n1=len(str1)
            n2=len(str2)
            if n1==0 or n2==0:
                return
            matrix=[[0 for i in range(n2+1)] for j in range(n1+1)]
            i=1
            maxI=0
            maxend=0
            while i<n1+1:
                j = 1
                while j<n2+1:
                    print(str1[i-1],str2[j-1])
                    if str1[i-1]==str2[j-1]:
                        #print(str1[i-1],str2[j-1])
                        matrix[i][j]=matrix[i-1][j-1]+1
                        if maxI<matrix[i][j]:
                            maxI=matrix[i][j]
                            maxend=j
                            print(maxI,maxend)
                    else:
                        matrix[i][j]=0
                    j+=1
                i+=1
            print(i,j)
            print(matrix)
            return str2[maxend-maxI:maxend]
    str1="abccade"
    str2="dgcadde"
    
    print(Solution().getMaxSubStr(str1,str2))

题目 5：  
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。  
输入：  
合法坐标为A(或者D或者W或者S) + 数字（两位以内）  
坐标之间以;分隔。  
非法坐标点需要进行丢弃。如AA10; A1A;  % ; YAD; 等。  
下面是一个简单的例子 如：  
A10;S20;W10;D30;X;A1A;B10A11;;A10;  
处理过程：  
起点（0,0）

*  A10 = （-10,0）
 *  S20 = (-10,-20)
 *  W10 = (-10,-10)
 *  D30 = (20,-10)
 *  x = 无效
 *  A1A = 无效
 *  B10A11 = 无效
 *  一个空 不影响
 *  A10 = (10,-10)  
    结果 （10， -10）

输入描述:  
一行字符串

输出描述:  
最终坐标，以,分隔

示例1  
输入  
复制  
A10;S20;W10;D30;X;A1A;B10A11;;A10;  
输出  
复制  
10,-10

str1=input().split(";")
    list1=[]
    los=[0,0]
    ori=str1[:1]
    num=str1[1:]
    for i in str1:
        if len(i)!=0:
            ori=i[:1]
            num=i[1:]
            if (ori=="A" or ori=="W" or ori=="S" or ori=="D") and num.isdigit():
                num=int(num)
                list1.append([ori,num])
    for i in list1:
        if i[0]=="A":
            los[0]=los[0]-i[1]
        elif i[0]=="D":
            los[0]=los[0]+i[1]
        elif i[0]=="W":
            los[1]=los[1]+i[1]
        else:
            los[1]=los[1]-i[1]
        #print(i)
        #print(los)
    for i in los:
        if i==los[-1]:
            print(str(i))
        else:
            print(str(i),end=",")str1=input().split(";")
    list1=[]
    los=[0,0]
    ori=str1[:1]
    num=str1[1:]
    for i in str1:
        if len(i)!=0:
            ori=i[:1]
            num=i[1:]
            if (ori=="A" or ori=="W" or ori=="S" or ori=="D") and num.isdigit():
                num=int(num)
                list1.append([ori,num])
    for i in list1:
        if i[0]=="A":
            los[0]=los[0]-i[1]
        elif i[0]=="D":
            los[0]=los[0]+i[1]
        elif i[0]=="W":
            los[1]=los[1]+i[1]
        else:
            los[1]=los[1]-i[1]
        #print(i)
        #print(los)
    for i in los:
        if i==los[-1]:
            print(str(i))
        else:
            print(str(i),end=",")

四、哈希表及常用解法  
题目1：求解字符串中第一次只出现一次的字符  
在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）

class Solution:
        def FirstNotRepeatingChar(self, s):
            if len(s)==0:
                return -1
            dict={
        }
            for i in s:
                if i not in dict:
                    dict[i]=1
                else:
                    dict[i]+=1
            #print(dict)
            sum=0
            for i in dict:
                if dict[i]==1:
                    count=0
                    for j in s:
                        if j==i:
                            return count
                        count+=1
                            
            return -1
                
    #测试
    print(Solution().FirstNotRepeatingChar("google"))  
    print(Solution().FirstNotRepeatingChar("aabbcc"))    
    print(Solution().FirstNotRepeatingChar("abbcc"))    
    print(Solution().FirstNotRepeatingChar("abc"))
    print(Solution().FirstNotRepeatingChar("abaccdeff"))    
    print(Solution().FirstNotRepeatingChar("aabbccdde"))    
    print(Solution().FirstNotRepeatingChar("google"))     
    print(Solution().FirstNotRepeatingChar("NXWtnzyoHoBhUJaPauJaAitLWNMlkKwDYbbigdMMaYfkVPhGZcrEwp"))
    #结果：
    4
    -1
    0
    0
    1
    8
    4
    1

解析 ：这里采用哈希表的方式记录每一个出现字母的次数，然后遍历整个哈希表，找出只出现一次的字母，并在字符串中搜索字母所在的位置并返回。如果遍历完哈希表发现没有字母出现一次，返回-1.

题目6：计算字符串之间的编辑距离

'''
    最小编辑距离
    你可以对一个字符串进行如下的三种操作
    1、插入一个字符
    2、删除一个字符
    3、替换一个字符
    例1：
    输入：s1='house',s2='ros'
    输出：三
    horse->rorse('h'替换为'r')
    rorse->rose(删除'r')
    rose->ros(删除'e')
    例2：
    输入：
    s1='intention' s2='execution'
    输出：5
    intention->inention(删除‘t’)
    inention->enention(i 替换为 e)
    enention->exention(n 替换为 x)
    exention->exection(n 替换为c)
    exection->execution(插入 u)
    编辑距离问题就是给我们两个字符串s1和s2，只能用三种操作，让我们把s1变成s2，
    求最少的操作数。需要明确的是，不管是把s1变成s2还是反过来，
    结果都是一样的，所以后文就以s1变成s2举例。
    ，解决两个字符串的动态规划问题，一般都是用两个指针i,j分别指向两个字符串的最后，
    然后一步步往前走，缩小问题的规模。
    即 coff->caf 可以由三个状态决定
    cof->ca if f=f 两者状态相等
    coff->ca 再ca后面插入f =coff->ca +1
    cof->ca 再coff->ca状态减1=caf->ca+1
    '''
    class solution:
        def minDistance(self,s1,s2) -> int:
            #s1='coffee'
            #s2='cafe'
            m=len(s1)+1
            n=len(s2)+1
            matrix=[[0 for i in range(n)] for j in range(m)]
            for i in range(n):
                matrix[0][i]=i
            for i in range(m):
                matrix[i][0]=i
            #构建dp矩阵
            for i in range(1,m):
                for j in range(1,n):
                    if s1[i-1]==s2[j-1]:
                        matrix[i][j]=matrix[i-1][j-1]
                    else:
                        matrix[i][j]=min(
                        matrix[i-1][j-1]+1,
                        matrix[i-1][j]+1,
                        matrix[i][j-1]+1)
            return matrix[m-1][n-1]
    solution().minDistance('intention','execution')
    solution().minDistance('r','red')
    solution().minDistance('re','red')
    solution().minDistance('','')
    
    min(1,2,3)

这道题的状态转译矩阵可以写成  
![在这里插入图片描述][20190908174046383.png]  
![在这里插入图片描述][20190908175015314.png]  
其中edit\[i\]\[j\]代表从str1\[i\]到str\[j\]所需要的最小编辑距离

[20190518200144534.png]: /images/20220214/ad7cb470f33343538d69a88938e15029.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70]: /images/20220214/19a899176be041ea9ea5167c25c2463f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 1]: /images/20220214/371752183d9847e58bcaa7e26dd43f04.png
[20200215105742737.png]: /images/20220214/db3af400a4914c80b540e3cde13cc717.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 2]: /images/20220214/1c95d3c591c444a0b5dd9921085af485.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTYxMTA0NQ_size_16_color_FFFFFF_t_70 3]: /images/20220214/1223f94637e94dbb984401b5872926eb.png
[20190908174046383.png]: /images/20220214/ce3048dcc3254966b2dfe0a9b2dd4ecb.png
[20190908175015314.png]: /images/20220214/b5cf07185d5a41529d3c7e045c877563.png