leetcode周赛-232

5701. 仅执行一次字符串交换能否使两个字符串相等

AC

题目

给你长度相等的两个字符串 s1 和 s2 。一次 字符串交换 操作的步骤如下：选出某个字符串中的两个下标（不必不同），并交换这两个下标所对应的字符。

如果对 其中一个字符串 执行 最多一次字符串交换 就可以使两个字符串相等，返回 true ；否则，返回 false 。

示例 1：

输入：s1 = "bank", s2 = "kanb"
输出：true
解释：例如，交换 s2 中的第一个和最后一个字符可以得到 "bank"

示例 2：

输入：s1 = "attack", s2 = "defend"
输出：false
解释：一次字符串交换无法使两个字符串相等

示例 3：

输入：s1 = "kelb", s2 = "kelb"
输出：true
解释：两个字符串已经相等，所以不需要进行字符串交换

示例 4：

输入：s1 = "abcd", s2 = "dcba"
输出：false

提示：

1 <= s1.length, s2.length <= 100
s1.length == s2.length
s1 和 s2 仅由小写英文字母组成

解题思路

从左向右遍历，记录出现不同字母的次数以及不同的字母，如果不同的次数==2并且不同的字母相同（可以通过交换一次来变成一样的），或者不同的次数==0，则True

代码

class Solution:
    def areAlmostEqual(self, s1: str, s2: str) -> bool:
        s_len = len(s1)
        cnt = 0
        diff_w1, diff_w2 = set(), set()
        for i in range(s_len):
            if s1[i] != s2[i]:
                cnt += 1
                diff_w1.add(s1[i])
                diff_w2.add(s2[i])
        return (cnt == 2 and diff_w1 == diff_w2) or (cnt == 0)

5702. 找出星型图的中心节点

AC

题目

有一个无向的 星型 图，由 n 个编号从 1 到 n 的节点组成。星型图有一个 中心 节点，并且恰有 n - 1 条边将中心节点与其他每个节点连接起来。

给你一个二维整数数组 edges ，其中 edges[i] = [ui, vi] 表示在节点 ui 和 vi 之间存在一条边。请你找出并返回 edges 所表示星型图的中心节点。

示例 1：

输入：edges = [[1,2],[2,3],[4,2]]
输出：2
解释：如上图所示，节点 2 与其他每个节点都相连，所以节点 2 是中心节点。

示例 2：

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

提示：

3 <= n <= 105
edges.length == n - 1
edges[i].length == 2
1 <= ui, vi <= n
ui != vi

题目数据给出的 edges 表示一个有效的星型图

解题思路

一个很取巧的思路，因为n个节点只有n - 1条边，所以必然不存在环，那么只看前2条边，重复的节点就一定是顶点

代码

class Solution:
    def findCenter(self, edges: List[List[int]]) -> int:
        check = edges[:2]
        e1, e2 = check[0]
        e3, e4 = check[1]
        c = {}
        for e in [e1, e2, e3, e4]:
            c[e] = c.get(e, 0) + 1
        for e, v in c.items():
            if v == 2:
                return e

5703. 最大平均通过率

想偏了，没做出来。。

题目

一所学校里有一些班级，每个班级里有一些学生，现在每个班都会进行一场期末考试。给你一个二维数组 classes ，其中 classes[i] = [pass_i, total_i] ，表示你提前知道了第 i 个班级总共有 total_i 个学生，其中只有 pass_i 个学生可以通过考试。

给你一个整数 extraStudents ，表示额外有 extraStudents 个聪明的学生，他们 一定 能通过任何班级的期末考。你需要给这 extraStudents 个学生每人都安排一个班级，使得 所有 班级的 平均 通过率 最大 。

一个班级的 通过率 等于这个班级通过考试的学生人数除以这个班级的总人数。平均通过率 是所有班级的通过率之和除以班级数目。

请你返回在安排这 extraStudents 个学生去对应班级后的 最大 平均通过率。与标准答案误差范围在 $10^{-5}$ 以内的结果都会视为正确结果。

示例 1：

输入：classes = [[1,2],[3,5],[2,2]], extraStudents = 2
输出：0.78333
解释：你可以将额外的两个学生都安排到第一个班级，平均通过率为 (3/4 + 3/5 + 2/2) / 3 = 0.78333 。

示例 2：

输入：classes = [[2,4],[3,9],[4,5],[2,10]], extraStudents = 4
输出：0.53485

提示：

1 <= classes.length <= 10^5
classes[i].length == 2
1 <= pass_i <= total_i <= 10^5
1 <= extraStudents <= 10^5

解题思路

贪心的思想，每次把extraStudent分配到班级通过率增益最大的班级即可，用一个大根堆来记录每个班级如果分配一个extraStudent的通过率增益

整体的时间复杂度为$o(classes.length)+o(extraStudents\ast lo{g}_{2}classes.length)=o(nlogn)$，其中n = 10^5

代码

class Solution:
    def maxAverageRatio(self, classes: List[List[int]], extraStudents: int) -> float:
        heap = []
        ans, n = 0, len(classes)
        for p, t in classes:
            heapq.heappush(heap, (p / t - (p + 1) / (t + 1), p, t))
            ans += p / t
        while extraStudents:
            _, p, t = heapq.heappop(heap)
            ans -= p / t
            ans += (p + 1) / (t + 1)
            p += 1
            t += 1
            heapq.heappush(heap, (p / t - (p + 1) / (t + 1), p, t))
            extraStudents -= 1
        return ans / n

5704. 好子数组的最大分数

题目

给你一个整数数组 nums （下标从 0 开始）和一个整数 k 。

一个子数组 (i, j) 的 分数 定义为 min(nums[i], nums[i+1], …, nums[j]) * (j - i + 1) 。一个 好 子数组的两个端点下标需要满足 i <= k <= j 。

请你返回 好 子数组的最大可能 分数 。

示例 1：

输入：nums = [1,4,3,7,4,5], k = 3
输出：15
解释：最优子数组的左右端点下标是 (1, 5) ，分数为 min(4,3,7,4,5) * (5-1+1) = 3 * 5 = 15 。

示例 2：

输入：nums = [5,5,4,5,4,1,1,1], k = 0
输出：20
解释：最优子数组的左右端点下标是 (0, 4) ，分数为 min(5,5,4,5,4) * (4-0+1) = 4 * 5 = 20 。

提示：

1 <= nums.length <= 10^5
1 <= nums[i] <= 2 * 10^4
0 <= k < nums.length

解题思路

dp超时了

代码

dp版：

class Solution:
    def maximumScore(self, nums: List[int], k: int) -> int:
        n, m = len(nums), len(nums)
        dp = [[0] * m for _ in range(n)]
        # init
        for i in range(n):
            dp[i][i] = nums[i]
        # dp
        ans = 0
        for i in range(n - 1, -1, -1):
            for j in range(i + 1, m):
                dp[i][j] = min(min(nums[i], dp[i + 1][j]), min(nums[j], dp[i][j - 1]))
                if i <= k <= j:
                    ans = max(ans, dp[i][j] * (j - i + 1))
        return ans

中心扩展版：

class Solution:
    def maximumScore(self, nums: List[int], k: int) -> int:
        ans, n = 0, len(nums)
        lindex, rindex = k, k
        min_v = nums[k]
        while True:
            while rindex < n and nums[rindex] >= min_v:
                rindex += 1
            while lindex >= 0 and nums[lindex] >= min_v:
                lindex -= 1
            # min_v * (rindex - lindex + 1 - 2) = min_v * (rindex - lindex - 1)
            ans = max(ans, min_v * (rindex - lindex - 1))
            if lindex >= 0 and rindex < n:
                min_v = max(nums[lindex], nums[rindex])
            elif lindex >= 0:
                min_v = nums[lindex]
            elif rindex < n:
                min_v = nums[rindex]
            else:
                break
        return ans