文章目录
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 个学生去对应班级后的 最大 平均通过率。与标准答案误差范围在 1 0 − 5 10^{-5} 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
(
c
l
a
s
s
e
s
.
l
e
n
g
t
h
)
+
o
(
e
x
t
r
a
S
t
u
d
e
n
t
s
∗
l
o
g
2
c
l
a
s
s
e
s
.
l
e
n
g
t
h
)
=
o
(
n
l
o
g
n
)
o(classes.length) + o(extraStudents * log_2classes.length) = o(nlogn)
o(classes.length)+o(extraStudents∗log2classes.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