LeetCode刷题记录（持续更新

最近女票作为C++大神沉迷刷题，我也凑凑热闹学习一下，在此记录一下刷过的题 及 解题思路

299 猜数字游戏：

思路：

本题需要找到两个字符串中对应位置数字相同的次数，以及在两个字符串中出现过但是位置不对应的字符出现的次数。
因此，本题分两步：

1. 遍历寻找字符对应相等的次数
2. 同时，对于不相等的字符串，使用两个大小为10的数组s_num和g_num分别记录出现的次数。即类似桶排序中使用的容器。两个数组将记录数字0–9在不对应相等时出现的次数。
3. 然后将s_num和g_num中非零项的最小的数字相加，即求出数字都在两个字符串中出现的次数。

python 解法：

class Solution:
    def getHint(self, secret: str, guess: str) -> str:
        A, B = 0, 0
        s_num = [0 for i in range(10)]
        g_num = [0 for i in range(10)]
        num = [0 for i in range(10)]
        for i in range(len(secret)):
            if secret[i]==guess[i]:
                A+=1
            else:
                s_num[int(secret[i])] += 1
                g_num[int(guess[i])] += 1
        ans_a = A
        for i in range(10):
            if s_num[i] != 0 and g_num[i] != 0:
                num[i] = min(s_num[i], g_num[i])
        ans_b = sum(num)
        
        return str(ans_a)+'A'+str(ans_b)+'B'

C++解法：

class Solution {
public:
    string getHint(string secret, string guess) {
        int num[11],a[11],b[11],len,i,ans1,ans2;
        string res;
        len=secret.size();
        ans1=0;
        ans2=0;
        for(i=0;i<len;i++){
            if(secret[i]==guess[i]){
                num[secret[i]-'0']++;
                ans1++;
            }
        }
        for(i=0;i<len;i++){
            a[secret[i]-'0']++;
        }
        for(i=0;i<len;i++){
            b[guess[i]-'0']++;
        }
        for(i=0;i<10;i++){
            num[i]=min(a[i],b[i])-num[i];
            ans2+=num[i];
        }
        res=to_string(ans1)+'A'+to_string(ans2)+'B';
        return res;
    }
};

5. 最长回文子串

暴力解法：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        i_d = 0
        mx_r = 1   # 右边最大的索引
        max_len = 1 # 最大的长度
        temp_len = 1 # 最大长度缓存
        ss = '%#'
        for k in range(len(s)):
            ss = ss + s[k] + '#'    # ss = %#1#2#a#e#a#2#s#s#2#e#a#d#
        ss = ss + '#'
        print(ss)
        for im in range(2, len(ss)-2):   # im: middle index of substr
            i = 1
            r = 1
            temp_len =1
            if ss[im-1] != '%':
                while ss[im-i] == ss[im+i]:
                    r = i    # 如果左右相等
                    i += 1
                    temp_len = r*2
                if max_len <= temp_len:
                    max_len = temp_len
                    mx_r = im+i-1
                    
        print(max_len)
        print(mx_r)
        print((mx_r-max_len)//2)
        print((mx_r)//2)
        return s[int(mx_r-max_len)//2:int((mx_r)//2)]

马拉车算法：

class Solution:
    def longestPalindrome(self, s: str) -> str:
        ss = '%#'
        for k in range(len(s)):
            ss += s[k]+'#'
        ss = ss+'^'
        
        # variable
        length = [0]
        max_len = 1
        max_r = 1  # 最大的右端点
        max_m = 1  # 最大的中心点
        
        for im in range(1,len(ss)-1):
            # im在最大的右端点左边，即im子串被已知的最大回文串包含时
            if imlength[2*max_m-im]//2: # 2*max_m-im:当前点关于最大中心点的对称点
                    i = length[2*max_m-im]//2+1
                    while ss[im-i]==ss[im+i]:
                        i+=1
                    length.append(i*2-1)
                    if length[im]>max_len:
                        max_len=length[im]
                        max_m = im
                        max_r = max_m + max_len//2
                else:
                    i = max_r-im+1
                    while ss[im-i]==ss[im+i]:
                        i+=1
                    length.append(i*2-1)
                    if length[im]>max_len:
                        max_len=length[im]
                        max_m = im
                        max_r = max_m + max_len//2
                
            # else im超出最大回文串范围
            else:
                i = 1
                while ss[im-i]==ss[im+i]:
                    i+=1
                length.append(i*2-1)
                if length[im]>max_len:
                    max_len=length[im]
                    max_m = im
                    max_r = max_m + max_len//2
        print(ss)
        print('max_r is%d'%max_r)
        print('max_len is%d'%max_len)
        print(length)
        return s[(max_r-max_len)//2:max_r//2]