leetcode双周赛134 周赛405比赛写的

双周赛：

leetcode3206

3206. 交替组 I - 力扣（LeetCode）

比赛时因为只需要找3个，所以就直接找就行

class Solution:
    def numberOfAlternatingGroups(self, colors: List[int]) -> int:
        cnt = 0
        n = len(colors)
        for i in range(0,n):
            if colors[i] != colors[i - 1]:
                if colors[i - 1] == colors[(i + 1) % n]:
                    cnt += 1
        return cnt

leetcode3207

3207. 与敌人战斗后的最大分数 - 力扣（LeetCode）

贪心，不断加最大的，除以最小的

class Solution:
    def maximumPoints(self, en: List[int], cu: int) -> int:
        en.sort()
        n = len(en)
        a = en[0]
        al = cu // a
        cu = cu % a
        j = n - 1
        def defen(cu,a):
            if a <= cu:
                fen = cu // a
                cu = cu % a
            else:
                fen = 0
            return fen,cu
        while j > 0:
            if al > 0:
                cu += en[j]
                j -= 1
                fen,cu = defen(cu,a)
                al += fen
            else:
                return al
        return al

周赛405

leetcode3210

3210. 找出加密后的字符串 - 力扣（LeetCode）

直接一个一个加，到那个字符的时候就加上，然后后面的也继续加

class Solution:
    def getEncryptedString(self, s: str, k: int) -> str:
        n = len(s)
        ans = ''
        for i in range(n):
            ans += s[(i + k) % n]
        return ans

leetcode3211

3211. 生成不含相邻零的二进制字符串 - 力扣（LeetCode）

这道题就很无语，本来以为n就是1-10，然后就一个一个写if和elif，然后竟然告诉我n是18，无奈只好继续写了。

思路就是在前后+1还有就是在前面和后面加一个不一样的数。

class Solution:
    def validStrings(self, n: int) -> List[str]:
        if n == 1:
            return ["0","1"]
        elif n == 2:
            return ["10","11",'01']
        elif n == 3:
            return ["010","011","101","110","111"]
        ans = ["010","011","101","110","111"]
        def jisuan(ans):
            arr = []
            for i in ans:
                arr.append('1' + i)
                arr.append(i + '1')
            for i in ans:
                if i[-1] == '1':
                    arr.append(i + '0')
                elif i[0] == '1':
                    arr.append('0' + i)
            arr = list(set(arr))
            return arr
        arr4 = jisuan(ans)
        arr5 = jisuan(arr4)
        arr6 = jisuan(arr5)
        arr7 = jisuan(arr6)
        arr8 = jisuan(arr7)
        arr9 = jisuan(arr8)
        arr10 = jisuan(arr9)
        arr11 = jisuan(arr10)
        arr12 = jisuan(arr11)
        arr13 = jisuan(arr12)
        arr14 = jisuan(arr13)
        arr15 = jisuan(arr14)
        arr16 = jisuan(arr15)
        arr17 = jisuan(arr16)
        arr18 = jisuan(arr17)
        if n == 4:
            return arr4
        elif n == 5:
            return arr5
        elif n == 6:
            return arr6
        elif n == 7:
            return arr7
        elif n == 8:
            return arr8
        elif n == 9:
            return arr9
        elif n == 10:
            return arr10
        elif n == 11:
            return arr11
        elif n == 12:
            return arr12
        elif n == 13:
            return arr13
        elif n == 14:
            return arr14
        elif n == 15:
            return arr15
        elif n == 16:
            return arr16
        elif n == 17:
            return arr17
        elif n == 18:
            return arr18

leetcode3212

3212. 统计 X 和 Y 频数相等的子矩阵数量 - 力扣（LeetCode）

一个二维前缀和，直接得吃了

class Solution:
    def numberOfSubmatrices(self, grid: List[List[str]]) -> int:
        n,m = len(grid),len(grid[0])
        arr = [[[0,0] for _ in range(m + 1)] for _ in range(n + 1)]
        for i in range(1,n + 1):
            for j in range(1,m + 1):
                if grid[i - 1][j - 1] == 'X':
                    arr[i][j] = [arr[i][j - 1][0] + 1,arr[i][j - 1][1]]
                elif grid[i - 1][j - 1] == 'Y':
                    arr[i][j] = [arr[i][j - 1][0],arr[i][j - 1][1] + 1]
                else:
                    arr[i][j] = arr[i][j - 1]
        for j in range(1,m + 1):
            for i in range(1,n + 1):
                arr[i][j] = [arr[i - 1][j][0] + arr[i][j][0],arr[i - 1][j][1] + arr[i][j][1]]
        cnt = 0
        for i in range(n + 1):
            for j in range(m + 1):
                if arr[i][j][0] == arr[i][j][1] and arr[i][j][0] >= 1:
                    cnt += 1
        return cnt