第 210 场周赛

1614. 括号的最大嵌套深度（简单）

题目描述

如果字符串满足一下条件之一，则可以称之为 有效括号字符串（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 是 有效的括号表达式

解题思路

设置当前嵌套深度和最大嵌套深度，遍历字符串，当左括号出现时，当前嵌套深度+1，并更新最大嵌套深度。遍历完成后返回最大嵌套深度。

def maxDepth(self, s: str) -> int:
    cnt = 0
    max_cnt = 0
    for char in s:
        if char == '(':
            cnt += 1
            max_cnt = max(max_cnt,cnt)
        if char == ')':
            cnt -= 1
    return max_cnt

 

1615. 最大网络秩（中等）

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
• 每对城市之间 最多只有一条 道路相连

解题思路

两个城市的最大秩是通往这两个城市的所有道路之和，统计每一座城市连通的道路数，取出道路数最大的两座城市，若这两座城市之间没有道路连通，则最大秩为两座城的道路数之和，否则在求和的基础上-1. 此外，若有多座城市的道路数一样，且最大，则若这些城市之间均有道路连通，秩减一，否则不减。

class Solution:
    def maximalNetworkRank(self, n: int, roads: List[List[int]]) -> int:
        d = {i:0 for i in range(0,n)}
        for road in roads:
            d[road[0]] += 1
            d[road[1]] += 1
        d_order = sorted(d.items(), key=lambda item:item[1], reverse=True) # 把字典按照值排倒序
        # return d_order[0][1]
        if d_order[0][1] == d_order[1][1]:
            # 最大值有多个城市
            cnt_max = d_order[0][1]
            cities = []
            for city, cnt in d_order:
                if cnt == cnt_max:
                    cities.append(city)
                else:
                    break
            # for i in range(len(cities)-1):
            #     for j in range(i+1,len(cities)):
            if all((item in roads or sorted(item) in roads) for item in [[i,j] for i in cities for j in cities if i > j]):
                return 2 * cnt_max - 1
            else:
                return 2 * cnt_max 
        else:
            # 最大值一个城市
            cnt_max = d_order[1][1]
            cities = []
            for city, cnt in d_order[1:]:
                if cnt == cnt_max:
                    cities.append(city)
                else:
                    break     
            if all((sorted([d_order[0][0],i]) in roads or sorted([d_order[0][0],i],reverse=True) in roads) for i in cities):
                return d_order[1][1] + d_order[0][1] - 1
            else:
                return d_order[1][1] + d_order[0][1]

 

1616. 分割两个字符串得到回文串（中等）

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

当你将一个字符串 s 分割成 sprefix 和 ssuffix 时， ssuffix 或者 sprefix 可以为空。比方说， 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 都只包含小写英文字母

解题思路

判断a的第一位与b的最后一位字符是否一样，若一致，继续判断下一位，否则，判断当前位置到对称位置的a和b的子字符串是否为回文串，若是，返回True，否则，交换a，b重复上述过程。最后返回False

class Solution:
    def checkPalindromeFormation(self, a: str, b: str) -> bool:
        def check(s):
            m = len(s)
            for i in range(m//2):
                if s[i] != s[m-i-1]:
                    return False
            return True
        flag = 1
        n = len(a)
        if n == 1:
            return True
        for i in range(n//2):
            if a[i] == b[n-i-1]:
                continue
            else:
                s1 = a[i:n-i]
                s2 = b[i:n-i]
                if check(s1) or check(s2):
                    return True
                flag = 0
                break
        if flag == 1:
            return True
        
        for i in range(n//2):
            if b[i] == a[n-i-1]:
                flag = 1
                continue
            else:
                s1 = a[i:n-i]
                s2 = b[i:n-i]
                if check(s1) or check(s2):
                    return True
                flag = 0 
                break
        if flag == 1:
            return True
        
        return False