KreanXie
获得徽章 0
赞了这篇文章
赞了这篇文章
赞了这篇文章
赞了这篇文章
赞了这篇文章
赞了这篇文章
一、题目链接
leetcode.cn
二、题目简介
会议室问题，给定 n 个会议的开始时间和结束时间，同一时间内一间会议室只能开一场会，问开完所有会议最少需要多少个会议室
三、涉及知识点
排序
四、算法分析
解法一：排序
我们首先对intervals的首项也就是开始时间排序，然后枚举所有时刻，也就是从 1 到最后一个会议结束的时刻，如果当前时刻有一个会议开始了，我们将cur+1，如果有一个会议结束了，我们将cur-1，然后每个时刻都更新ret即可
时间复杂度O(m)，m为最后一个会议开完的时刻
五、源码解析
Golang
func minMeetingRooms(intervals [][]int) int {
n := len(intervals)
sort.Slice(intervals, func(i, j int) bool {
if intervals[i][0] == intervals[j][0] {
return intervals[i][1] < intervals[j][1]
}
return intervals[i][0] < intervals[j][0]
})
maxt := intervals[n-1][1]
idx := 0
ret := 0
cur := 0
end := make(map[int]int)
for i := 0; i <= maxt; i++ {
if _, ok := end[i]; ok {
cur -= end[i]
}
for idx < n && intervals[idx][0] <= i {
cur++
ret = max(ret, cur)
end[intervals[idx][1]]++
idx++
}
}
return ret
}
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
六、FAQ
leetcode.cn二、题目简介
会议室问题，给定 n 个会议的开始时间和结束时间，同一时间内一间会议室只能开一场会，问开完所有会议最少需要多少个会议室
三、涉及知识点
排序
四、算法分析
解法一：排序
我们首先对intervals的首项也就是开始时间排序，然后枚举所有时刻，也就是从 1 到最后一个会议结束的时刻，如果当前时刻有一个会议开始了，我们将cur+1，如果有一个会议结束了，我们将cur-1，然后每个时刻都更新ret即可
时间复杂度O(m)，m为最后一个会议开完的时刻
五、源码解析
Golang
func minMeetingRooms(intervals [][]int) int {
n := len(intervals)
sort.Slice(intervals, func(i, j int) bool {
if intervals[i][0] == intervals[j][0] {
return intervals[i][1] < intervals[j][1]
}
return intervals[i][0] < intervals[j][0]
})
maxt := intervals[n-1][1]
idx := 0
ret := 0
cur := 0
end := make(map[int]int)
for i := 0; i <= maxt; i++ {
if _, ok := end[i]; ok {
cur -= end[i]
}
for idx < n && intervals[idx][0] <= i {
cur++
ret = max(ret, cur)
end[intervals[idx][1]]++
idx++
}
}
return ret
}
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
六、FAQ
展开
评论
点赞
每日题解
给定一个金字塔的底层bottom和一个字符串数组allowed，要求你还原金字塔，还原原则为金字塔中出现的三角形必须在allowed中，金字塔每高一层，长度便减一
解法一：深度优先搜索
我们根据题目要求进行暴力搜索，即在每一层把allowed中每一个组合试一次，如果搜索到了塔顶，返回true
时间复杂度O(a^n)
五、源码解析
Golang
func pyramidTransition(bottom string, allowed []string) bool {
n := len(bottom)
hash := make(map[string][]string)
for _, s := range allowed {
hash[s[:2]] = append(hash[s[:2]], s[2:])
}
var dfs func(level, idx int, tower []string) bool
dfs = func(level, idx int, tower []string) bool {
//fmt.Println(level, idx, tower)
if level == n {
return true
}
if idx == n-level-1 {
return dfs(level+1, 0, tower)
}
ret := false
for _, s := range hash[tower[level][idx:idx+2]] {
tower[level+1] += s
ret = ret || dfs(level, idx+1, tower)
tower[level+1] = tower[level+1][:len(tower[level+1])-1]
}
return ret
}
tower := make([]string, n)
tower[0] = bottom
return dfs(0, 0, tower)
}
ps：由于这个只能发一千个字，代码必须压缩一下
给定一个金字塔的底层bottom和一个字符串数组allowed，要求你还原金字塔，还原原则为金字塔中出现的三角形必须在allowed中，金字塔每高一层，长度便减一
解法一：深度优先搜索
我们根据题目要求进行暴力搜索，即在每一层把allowed中每一个组合试一次，如果搜索到了塔顶，返回true
时间复杂度O(a^n)
五、源码解析
Golang
func pyramidTransition(bottom string, allowed []string) bool {
n := len(bottom)
hash := make(map[string][]string)
for _, s := range allowed {
hash[s[:2]] = append(hash[s[:2]], s[2:])
}
var dfs func(level, idx int, tower []string) bool
dfs = func(level, idx int, tower []string) bool {
//fmt.Println(level, idx, tower)
if level == n {
return true
}
if idx == n-level-1 {
return dfs(level+1, 0, tower)
}
ret := false
for _, s := range hash[tower[level][idx:idx+2]] {
tower[level+1] += s
ret = ret || dfs(level, idx+1, tower)
tower[level+1] = tower[level+1][:len(tower[level+1])-1]
}
return ret
}
tower := make([]string, n)
tower[0] = bottom
return dfs(0, 0, tower)
}
ps：由于这个只能发一千个字，代码必须压缩一下
展开
评论
点赞
#每天一个知识点#
昨天力扣周赛的题，颇有意思，写一写我自己的理解
一、题目链接
2790. 长度递增组的最大数目 - 力扣（LeetCode）
二、题目简介
给定一个长度为 n 的整数数组limit，limt[i]表示数字 i 的可使用次数，你需要用有限的数字来填充组，每一组不能有重复的数字，且后一组的长度要大于前一组，问最多能填充多少组
三、涉及知识点
数学
四、算法分析
解法一：数学
首先明确一点，填什么数组并没有要求，所以可以先对原数组排序
其次，每组的长度一定是1,2,3,4...这样最优，所用的数字最少
那么，问题就是如何给每个组分配数字了，我们可以先剥离数字本身的属性，只保留它们的不同性
首先对数组排序，然后给每个组分配数字，使用一个cur变量表示能用的数字，和一个ans变量表示当前的组数，如果cur大于ans，说明能够填满当前组，ans+1，cur减去ans，最后的ans就是答案
时间复杂度O(n)
五、源码解析
Golang
func maxIncreasingGroups(usageLimits []int) int {
sort.Ints(usageLimits)
curr, ans := 0, 0
for _, n := range usageLimits {
curr += n
if curr > ans {
ans += 1
curr -= ans
}
}
return ans
}
六、FAQ
昨天力扣周赛的题，颇有意思，写一写我自己的理解
一、题目链接
2790. 长度递增组的最大数目 - 力扣（LeetCode）
二、题目简介
给定一个长度为 n 的整数数组limit，limt[i]表示数字 i 的可使用次数，你需要用有限的数字来填充组，每一组不能有重复的数字，且后一组的长度要大于前一组，问最多能填充多少组
三、涉及知识点
数学
四、算法分析
解法一：数学
首先明确一点，填什么数组并没有要求，所以可以先对原数组排序
其次，每组的长度一定是1,2,3,4...这样最优，所用的数字最少
那么，问题就是如何给每个组分配数字了，我们可以先剥离数字本身的属性，只保留它们的不同性
首先对数组排序，然后给每个组分配数字，使用一个cur变量表示能用的数字，和一个ans变量表示当前的组数，如果cur大于ans，说明能够填满当前组，ans+1，cur减去ans，最后的ans就是答案
时间复杂度O(n)
五、源码解析
Golang
func maxIncreasingGroups(usageLimits []int) int {
sort.Ints(usageLimits)
curr, ans := 0, 0
for _, n := range usageLimits {
curr += n
if curr > ans {
ans += 1
curr -= ans
}
}
return ans
}
六、FAQ
展开
评论
点赞