10.11 leetcode 第 210 场周赛

5535. 括号的最大嵌套深度

如果字符串满足一下条件之一，则可以称之为 有效括号字符串（valid parentheses string，可以简写为 VPS）：

-字符串是一个空字符串 ""，或者是一个不为 "(" 或 ")" 的单字符。
-字符串可以写为 AB（A 与 B 字符串连接），其中 A 和 B 都是 有效括号字符串 。
-字符串可以写为 (A)，其中 A 是一个 有效括号字符串 。

类似地，可以定义任何有效括号字符串 S 的 嵌套深度 depth(S)：

• depth("") = 0
• depth(A + B) = max(depth(A), depth(B))，其中 A 和 B 都是 有效括号字符串
• depth("(" + A + ")") = 1 + depth(A)，其中 A 是一个 有效括号字符串

例如：""、"()()"、"()(()())" 都是 有效括号字符串（嵌套深度分别为 0、1、2），而 ")(" 、"(()" 都不是 有效括号字符串 。

给你一个 有效括号字符串 s，返回该字符串的 s 嵌套深度 。

示例 1：

输入：s = "(1+(2*3)+((8)/4))+1"
输出：3
解释：数字 8 在嵌套的 3 层括号中。

示例 2：

输入：s = "(1)+((2))+(((3)))"
输出：3

示例 3：

输入：s = "1+(2*3)/(2-1)"
输出：1

示例 4：

输入：s = "1"
输出：0

提示：

• 1 <= s.length <= 100
• s 由数字 0-9 和字符 ‘+’、’-’、’*’、’/’、’(’、’)’ 组成
• 题目数据保证括号表达式 s 是 有效的括号表达式

代码实现

class Solution:
    def maxDepth(self, s: str) -> int:
        re = 0
        cur = 0
        for i in s:
            if i=='(':
                cur+=1
            if i==')':
                cur-=1
            re = max(re, cur)
        return re

5536. 最大网络秩

n 座城市和一些连接这些城市的道路 roads 共同组成一个基础设施网络。每个 roads[i] = [ai, bi] 都表示在城市 ai 和 bi 之间有一条双向道路。

两座不同城市构成的 城市对 的 网络秩 定义为：与这两座城市 直接 相连的道路总数。如果存在一条道路直接连接这两座城市，则这条道路只计算 一次 。

整个基础设施网络的 最大网络秩 是所有不同城市对中的 最大网络秩 。
给你整数 n 和数组 roads，返回整个基础设施网络的 最大网络秩 。

示例 1：

输入：n = 4, roads = [[0,1],[0,3],[1,2],[1,3]]
输出：4
解释：城市 0 和 1 的网络秩是 4，因为共有 4 条道路与城市 0 或 1 相连。位于 0 和 1 之间的道路只计算一次。

示例 2：

输入：n = 5, roads = [[0,1],[0,3],[1,2],[1,3],[2,3],[2,4]]
输出：5
解释：共有 5 条道路与城市 1 或 2 相连。

示例 3：

输入：n = 8, roads = [[0,1],[1,2],[2,3],[2,4],[5,6],[5,7]]
输出：5
解释：2 和 5 的网络秩为 5，注意并非所有的城市都需要连接起来。

提示：

• 2 <= n <= 100
• 0 <= roads.length <= n * (n - 1) / 2
• roads[i].length == 2
• 0 <= ai, bi <= n-1
• ai != bi
• 每对城市之间 最多只有一条 道路相连

代码实现

class Solution:
    def maximalNetworkRank(self, n: int, roads: List[List[int]]) -> int:
        from collections import defaultdict
        sums = defaultdict(int)
        t = defaultdict(int)
        for a,b in roads:
            a,b = max(a,b),min(a,b)
            t[(a,b)]=1
            sums[a] += 1
            sums[b] += 1
        re = 0
        for i in range(n-1):
            for j in range(i+1,n):
                temp = sums[i]+sums[j]
                if t[(j,i)]==1:
                    temp-=1
                re = max(re, temp)
        return re

1616. 分割两个字符串得到回文串

给你两个字符串 a 和 b ，它们长度相同。请你选择一个下标，将两个字符串都在 相同的下标 分割开。由 a 可以得到两个字符串： $a_{prefix}$ 和 $a_{suffix}$ ，满足 a = $a_{prefix}$ + $a_{suffix}$ ，同理，由 b 可以得到两个字符串 $b_{prefix}$和 $b_{suffix}$，满足 b = $b_{prefix}$ + $b_{suffix}$。请你判断 $a_{prefix}$ + $b_{suffix}$或者 $b_{prefix}$ + $a_{suffix}$ 能否构成回文串。

当你将一个字符串 s 分割成 $s_{prefix}$ 和 $s_{suffix}$ 时， $s_{suffix}$ 或者 $s_{prefix}$ 可以为空。比方说， s = "abc" 那么 "" + "abc" ， "a" + "bc" ， "ab" + "c" 和 "abc" + "" 都是合法分割。

如果 能构成回文字符串 ，那么请返回 true，否则返回 false 。

请注意， x + y 表示连接字符串 x 和 y 。

示例 1：

输入：a = "x", b = "y"
输出：true
解释：如果 a 或者 b 是回文串，那么答案一定为 true ，因为你可以如下分割：
aprefix = "", asuffix = "x"
bprefix = "", bsuffix = "y"
那么 aprefix + bsuffix = "" + "y" = "y" 是回文串。

示例 2：

输入：a = "ulacfd", b = "jizalu"
输出：true
解释：在下标为 3 处分割：
aprefix = "ula", asuffix = "cfd"
bprefix = "jiz", bsuffix = "alu"
那么 aprefix + bsuffix = "ula" + "alu" = "ulaalu" 是回文串。

提示：

• 1 <= a.length, b.length <= 105
• a.length == b.length
• a 和 b 都只包含小写英文字母

代码实现

class Solution:  
    def checkPalindromeFormation(self, a: str, b: str) -> bool:
        if len(a)==1:
            return True
        if a==a[::-1] or b==b[::-1]:
            return True
        l = len(a)
        def max_pad(a):
            if l%2==0:
                left,right = l//2-1,l//2
            else:
                left,right = l//2,l//2
            while a[left]==a[right]:
                left-=1
                right+=1
            return left+1, right
        la,ra = max_pad(a)
        #print(la,ra)
        #print(a[:la],b[ra:], b[:la], a[ra:])
        if a[:la]==b[ra:][::-1] or b[:la]==a[ra:][::-1]: 
            return True
        la,ra = max_pad(b)
        #print(la,ra)
        #print(a[:la],b[ra:], b[:la], a[ra:])
        if a[:la]==b[ra:][::-1] or b[:la]==a[ra:][::-1]: 
            return True
        return False

5538. 统计子树中城市之间最大距离

给你 n 个城市，编号为从 1 到 n。同时给你一个大小为 n-1 的数组 edges，其中 edges[i] = [ui, vi]表示城市 ui 和 vi之间有一条双向边。题目保证任意城市之间只有唯一的一条路径。换句话说，所有城市形成了一棵 树 。

一棵 子树 是城市的一个子集，且子集中任意城市之间可以通过子集中的其他城市和边到达。两个子树被认为不一样的条件是至少有一个城市在其中一棵子树中存在，但在另一棵子树中不存在。

对于 d从1 到 n-1，请你找到城市间 最大距离 恰好为d的所有子树数目。

请你返回一个大小为 n-1的数组，其中第 d 个元素（下标从 1开始）是城市间 **最大距离 **恰好等于 d的子树数目。

请注意，两个城市间距离定义为它们之间需要经过的边的数目。

示例 1：

输入：n = 4, edges = [[1,2],[2,3],[2,4]]
输出：[3,4,0]
解释：
子树 {1,2}, {2,3} 和 {2,4} 最大距离都是 1 。
子树 {1,2,3}, {1,2,4}, {2,3,4} 和 {1,2,3,4} 最大距离都为 2 。
不存在城市间最大距离为 3 的子树。

示例 2：

输入：n = 2, edges = [[1,2]]
输出：[1]

示例 3：

输入：n = 3, edges = [[1,2],[2,3]]
输出：[2,1]

提示：

• 2 <= n <= 15
• edges.length == n-1
• edges[i].length == 2
• 1 <= ui, vi <= n
• 题目保证 (ui, vi) 所表示的边互不相同。

代码实现

# author : @richenyunqi from leetcode
class Solution:
    def countSubgraphsForEachDiameter(self, n: int, edges: List[List[int]]) -> List[int]:
        a=[0]*(n-1)
        tree=[[] for i in range(n+1)]
        for i,j in edges:
            tree[i].append(j)
            tree[j].append(i)
        def f(c):
            nonlocal a
            def dfs(i,visit):
                ans1,ans2=i,0
                visit[i]=True
                for j in tree[i]:
                    if j in c and not visit[j]:
                        
                        k1,k2=dfs(j,visit)
                        if k2+1>ans2:
                            ans1,ans2=k1,k2+1
                return ans1,ans2
            visit=[False]*(n+1)
            v=c[0]
            c=set(c)
            k1,k2=dfs(v,visit)
            if not all(visit[t] for t in c):
                return
            visit=[False]*(n+1)
            k1,k2=dfs(k1,visit)
            a[k2-1]+=1
        for j in range(2,n+1):
            for i in combinations(range(1,n+1), j):
                # print(i)
                f(i)
        return a