力扣 第471场周赛(A~D)

A:出现次数能被 K 整除的元素总和

签到题，给一个整数数组nums和一个数k，计算nums中出现次数能被k整除的数之和。

解法，做一个cnt，再遍历一遍就行了。

class Solution:
    def sumDivisibleByK(self, nums: List[int], k: int) -> int:
        d=defaultdict()
        for x in nums:
            if x in d:
                d[x]+=1
            else:
                d[x]=1
        res=0
        for x,v in d.items():
            if v%k==0:
                res+=x*v
        return res

B:最长的平衡子串 I

给定一个字符串s，求平衡子串的个数。平衡子串为串内出现的字母的出现次数都是相等的。

解法，因为s的长度最多为1000，那么可以直接枚举l和r，然后再做一个26的判定。时间复杂度为O(26*n^2)。

class Solution:
    def longestBalanced(self, s: str) -> int:
        n=len(s)
        res=0
        for i in range(n):
            cnt=[0]*26
            for j in range(i,n):
                cnt[ord(s[j])-ord('a')]+=1
                minn,maxx=1010,0
                for k in range(26):
                    if cnt[k]!=0:
                        minn=min(minn,cnt[k])
                        maxx=max(maxx,cnt[k])
                if minn==maxx and maxx!=0:
                    res=max(res,j-i+1)
        return res

C:最长的平衡子串 II

题意整体同B，但是s中只有'a','b','c'三种字符，且字符串长度到了1e5。

解法，那么如此就不能用平方级的解法了，因为字符种类变少了，那么合法的字符串只有可能是以下几种形式。全部由"a"、"b"、"c"、"a""b"、"a""c"、"b""c"、"a""b""c"组成。

单个字符的话，我们直接用最长连续就能计算。

现在我们考虑a,b,c都出现的情况，s的L~R的a,b,c三个字符出现次数相等，也就意味着suma[r]-suma[l-1]==sumb[r]-sumb[l-1]==sumc[r]-sumc[l-1]，推导一下，能将后面的三种情况统一起来。

s表示sum，sa[r]-sb[r]==sa[l-1]-sb[l-1] && sa[r]-sc[r]==sa[l-1]-sc[l-1]。便于在遍历时维护，同时用上枚举右、维护左的方法。

class Solution:
    def longestBalanced(self, s: str) -> int:
        res=0
        for key,group in groupby(s):
            res=max(res,len(list(group)))
        d_ABC=defaultdict()
        d_AB_C=defaultdict()
        d_AC_B=defaultdict()
        d_BC_A=defaultdict()
        d_ABC[(0,0)]=-1
        d_AB_C[(0,0)]=-1
        d_AC_B[(0,0)]=-1
        d_BC_A[(0,0)]=-1
        A,B,C=0,0,0
        for i,c in enumerate(s):
            if c=='a':
                A+=1
            elif c=='b':
                B+=1
            else:
                C+=1
            # abc都有
            if (A-B,A-C) in d_ABC:
                res=max(res,i-d_ABC[(A-B,A-C)])
            else:
                d_ABC[(A-B,A-C)]=i
            # 只有ab
            if (A-B,C) in d_AB_C:
                res=max(res,i-d_AB_C[(A-B,C)])
            else:
                d_AB_C[(A-B,C)]=i

            if (A-C,B) in d_AC_B:
                res=max(res,i-d_AC_B[(A-C,B)])
            else:
                d_AC_B[(A-C,B)]=i

            if (B-C,A) in d_BC_A:
                res=max(res,i-d_BC_A[(B-C,A)])
            else:
                d_BC_A[(B-C,A)]=i
        return res

D:完全平方数的祖先个数总和

给一棵数，节点上有值，当前节点和祖先相乘得到的数如果是完全平方数，则匹配，问有多少匹配的对数。

解法，两个数相乘是否是完全平方数，取决于他们去除冗余之后是否相等。去除冗余:x=360=2^3*3^2*5，去除冗余即为去除平方的项，x_kernel=2*5=10，那么如果y_kernel==10，那么他们就匹配。

所以，我们把nums去除冗余之后，再做一遍dfs的同时维护走过的节点的值出现次数即可。

class Solution:
    def sumOfAncestors(self, n: int, edges: List[List[int]], nums: List[int]) -> int:
        def fun(x):
            res=1
            for i in range(2,isqrt(x)+1):
                s=0
                while x%i==0:
                    x//=i
                    s+=1
                if s%2==1:
                    res*=i
            if x>1:
                res*=x
            return res
        # 将偶数次幂去掉
        for i in range(n):
            nums[i]=fun(nums[i])
        # print(nums)
        g=[[] for i in range(n)]
        for [u,v] in edges:
            g[u].append(v)
            g[v].append(u)
        cnt=defaultdict()
        res=0
        def dfs(fa,u):
            nonlocal res
            if nums[u] in cnt:
                res+=cnt[nums[u]]
                cnt[nums[u]]+=1
            else:
                cnt[nums[u]]=1
            for v in g[u]:
                if v==fa:
                    continue
                dfs(u,v)
            cnt[nums[u]]-=1
        dfs(-1,0)
        return res