版本说明
当前版本号[20231120]。
版本 | 修改说明 |
---|---|
20231120 | 初版 |
目录
N皇后 II
题目
n 皇后问题 研究的是如何将 n 个皇后放置在 n×n 的棋盘上,并且使皇后彼此之间不能相互攻击。
给你一个整数 n ,返回 n 皇后问题 不同的解决方案的数量。
示例 1:
输入:n = 4
输出:2
解释:如上图所示,4 皇后问题存在两个不同的解法。
示例 2:
输入:n = 1
输出:1
提示:
1 <= n <= 9
皇后彼此不能相互攻击,也就是说:任何两个皇后都不能处于同一条横行、纵行或斜线上。
以下程序实现了这一功能,请你填补空白处内容:
class Solution(object):
def __init__(self):
self.count = 0
def totalNQueens(self, n):
self.dfs(0, n, 0, 0, 0)
return self.count
def dfs(self, row, n, column, diag, antiDiag):
if row == n:
self.count += 1
return
for index in range(n):
isColSafe = (1 << index) & column == 0
isDigSafe = (1 << (n - 1 + row - index)) & diag == 0
isAntiDiagSafe = (1 << (row + index)) & antiDiag == 0
if isAntiDiagSafe and isColSafe and isDigSafe:
_________________________;
if __name__ == '__main__':
s = Solution()
print (s.totalNQueens(4))
解题思路
- 初始化一个计数器 count,用于记录解决方案的数量。
- 定义一个深度优先搜索函数 dfs,用于寻找 n 皇后问题的解决方案。
- 在 dfs 函数中,使用递归的方式进行深度优先搜索。
- 对于每一行,遍历每一列,检查当前位置是否安全(即没有其他皇后在同一行、同一列或同一对角线上)。
- 如果当前位置安全,继续搜索下一行,并更新 column、diag 和 antiDiag 的值。
- 如果已经放置了 n 个皇后,找到一个解决方案,增加计数器 count 的值。
- 返回计数器 count 的值作为解决方案数量。
代码思路
-
定义一个名为Solution的类,包含一个初始化方法__init__和一个计算解决方案数量的方法totalNQueens。
-
在初始化方法中,将计数器count初始化为0。
class Solution(object): def __init__(self): self.count = 0 # 初始化计数器为0
-
在totalNQueens方法中,调用深度优先搜索函数dfs,传入初始参数row=0, n=棋盘大小, column=0, diag=0, antiDiag=0。
def totalNQueens(self, n): """ 计算n皇后问题的解决方案数量 :param n: 棋盘大小 :return: 解决方案数量 """ self.dfs(0, n, 0, 0, 0) # 从第0行开始深度优先搜索 return self.count # 返回解决方案数量
-
在dfs函数中,使用递归的方式进行深度优先搜索。
def dfs(self, row, n, column, diag, antiDiag): """ 深度优先搜索函数,用于寻找n皇后问题的解决方案 :param row: 当前行数 :param n: 棋盘大小 :param column: 列掩码,表示已经放置的皇后所在的列 :param diag: 主对角线掩码,表示已经放置的皇后所在的主对角线 :param antiDiag: 副对角线掩码,表示已经放置的皇后所在的副对角线 """
-
如果已经放置了n个皇后,找到一个解决方案,增加计数器self.count的值。
if row == n: # 如果已经放置了n个皇后,找到一个解决方案 self.count += 1 # 增加解决方案计数器 return
-
遍历每一列,检查当前位置是否安全(即没有其他皇后在同一行、同一列或同一对角线上)。
for index in range(n): # 遍历每一列
-
如果当前位置安全,继续搜索下一行,更新column、diag和antiDiag的值。
-
最后,返回计数器self.count的值作为解决方案的数量。
isColSafe = (1 << index) & column == 0 # 检查当前列是否安全 isDigSafe = (1 << (n - 1 + row - index)) & diag == 0 # 检查主对角线是否安全 isAntiDiagSafe = (1 << (row + index)) & antiDiag == 0 # 检查副对角线是否安全 if isAntiDiagSafe and isColSafe and isDigSafe: # 如果当前位置安全,继续搜索下一行 self.dfs(row + 1, n, (1 << index) | column, (1 << (n - 1 + row - index)) | diag, (1 << (row + index)) | antiDiag)
-
在主程序中,创建一个Solution对象s,并调用totalNQueens方法,传入棋盘大小n=4,输出4皇后问题的解决方案数量。
if __name__ == '__main__':
s = Solution() # 创建Solution对象
print(s.totalNQueens(4)) # 输出4皇后问题的解决方案数量
参考代码
这段代码是使用深度优先搜索算法来寻找所有可能的解决方案,并返回解决方案的数量。
self.dfs(row + 1, n, (1 << index) | column,
(1 << (n - 1 + row - index)) | diag,
(1 << (row + index)) | antiDiag)
买卖股票的最佳时机 II
题目
给定一个数组 prices ,其中 prices[i] 是一支给定股票第 i 天的价格。
设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易(多次买卖一支股票)。
注意:你不能同时参与多笔交易(你必须在再次购买前出售掉之前的股票)。
示例 1:
输入: prices = [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天(股票价格 = 1)的时候买入,在第 3 天(股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
随后,在第 4 天(股票价格 = 3)的时候买入,在第 5 天(股票价格 = 6)的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。
示例 2:
输入: prices = [1,2,3,4,5]
输出: 4
解释: 在第 1 天(股票价格 = 1)的时候买入,在第 5 天 (股票价格 = 5)的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
注意你不能在第 1 天和第 2 天接连购买股票,之后再将它们卖出。因为这样属于同时参与了多笔交易,你必须在再次购买前出售掉之前的股票。
示例 3:
输入: prices = [7,6,4,3,1]
输出: 0
解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。
提示:
1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104
解题思路
- 初始化两个变量,hold表示持有股票的标志,0表示不持有,1表示持有;pric用于记录买入和卖出的价格;temp用于记录每次交易的利润;flag表示买入价格的索引;msum表示最大利润。
- 如果价格列表长度小于等于2,直接计算最大利润。如果价格列表为空,返回0;如果只有一个价格,返回0;如果第一个价格大于第二个价格,返回0;如果第一个价格小于第二个价格,返回第二个价格减去第一个价格。
- 遍历价格列表,找到买入和卖出的价格。如果下一个价格大于当前价格且不持有股票,将持有标志设为1,记录买入价格的索引,继续遍历;如果下一个价格小于当前价格且持有股票,将买入和卖出的价格分别添加到pric列表中,将持有标志设为0,继续遍历;否则,继续遍历。
- 计算每次交易的利润,并更新最大利润。遍历pric列表,每次取相邻的两个元素作为买入和卖出价格,计算利润,并将利润添加到temp列表中。然后更新最大利润msum为temp列表中所有元素的和。
- 如果最后还持有股票,将最后一天的价格加入最大利润。计算最后一天与买入价格之间的差值,加到最大利润msum上。
- 返回最大利润msum。
代码思路
-
定义一个类
Solution
,包含一个方法maxProfit
,接收一个参数prices
,表示股票价格的列表。 -
初始化变量
hold
为0,表示持有股票的标志;pric
为空列表,用于记录买入和卖出的价格;temp
为空列表,用于记录每次交易的利润;flag
为0,表示买入价格的索引;msum
为0,表示最大利润。hold = 0 # 持有股票的标志,0表示不持有,1表示持有 pric = [] # 记录买入和卖出的价格 temp = [] # 记录每次交易的利润 flag = 0 # 记录买入价格的索引 msum = 0 # 记录最大利润
-
如果价格列表长度小于等于2,直接计算最大利润。如果价格列表为空,返回0;如果只有一个价格,返回0;如果第一个价格大于第二个价格,返回0;如果第一个价格小于第二个价格,返回第二个价格减去第一个价格。
# 如果价格列表长度小于等于2,直接计算最大利润 if len(prices) <= 2: if not prices: return 0 if len(prices) == 1: return 0 if prices[0] > prices[1]: return 0 if prices[0] < prices[1]: return prices[1] - prices[0]
-
遍历价格列表,找到买入和卖出的价格。如果下一个价格大于当前价格且不持有股票,将持有标志设为1,记录买入价格的索引;如果下一个价格小于当前价格且持有股票,将买入和卖出的价格分别添加到
pric
列表中,并将持有标志设为0。# 遍历价格列表,找到买入和卖出的价格 for i in range(len(prices) - 1): if prices[i + 1] > prices[i] and hold != 1: hold = 1 flag = i continue if prices[i + 1] < prices[i] and hold == 1: pric.append(prices[flag]) pric.append(prices[i]) hold = 0 else: continue
-
计算每次交易的利润,将每次交易的利润添加到
temp
列表中,并更新最大利润。# 计算每次交易的利润,并更新最大利润 for i in range(0, len(pric), 2): temp.append(pric[i + 1] - pric[i]) msum = sum(temp)
-
如果最后还持有股票,将最后一天的价格加入最大利润。
# 如果最后还持有股票,将最后一天的价格加入最大利润 if hold == 1: msum = msum + prices[-1] - prices[flag]
-
返回最大利润。
参考代码
这段代码是一个股票交易问题的解法,通过遍历价格列表来找到买入和卖出的价格,并计算每次交易的利润。
class Solution(object):
def maxProfit(self, prices):
"""
:type prices: List[int]
:rtype: int
"""
hold = 0
pric = []
temp = []
flag = 0
msum = 0
if len(prices) <= 2:
if not prices:
return 0
if len(prices) == 1:
return 0
if prices[0] > prices[1]:
return 0
if prices[0] < prices[1]:
return prices[1] - prices[0]
for i in range(len(prices) - 1):
if prices[i + 1] > prices[i] and hold != 1:
hold = 1
flag = i
continue
if prices[i + 1] < prices[i] and hold == 1:
pric.append(prices[flag])
pric.append(prices[i])
hold = 0
else:
continue
for i in range(0, len(pric), 2):
temp.append(pric[i + 1] - pric[i])
msum = sum(temp)
if hold == 1:
msum = msum + prices[-1] - prices[flag]
return msum
编程通过键盘输入每一位运动员
题目
体操比赛成绩统计。多名运动员,多个评委打分,去掉一个最高分和去掉一个最低分,对其余分数求平均分作为一个运动员成绩。 编程通过键盘输入每位运动员编号和每个评委的成绩,求出运动员的最终成绩,并将运动员编号和最终成绩保存在一个字典中,形如{编号1:最终成绩1,学号2:最终成绩2…,并将结果输出。
解题思路
- 首先,我们需要获取评委人数和学生人数,确保评委人数不少于3人,学生人数不少于1人。
- 然后,我们需要初始化一个空的学生列表,用于存储每个学生的相关信息。
- 接下来,我们需要遍历学生人数,对于每个学生,我们需要初始化一个包含评分列表、学号、最低分、最高分和平均分的字典。
- 在每个学生字典中,我们需要输入学生的学号,并遍历评委人数,获取每个评委的评分,并将其添加到评分列表中。
- 对评分列表进行排序,然后去掉最低分和最高分,计算剩余分数的平均分,并将结果更新到学生字典中。
- 将学生字典添加到学生列表中。
- 使用字典推导式生成学生学号和最终成绩的字典。
- 最后,输出结果。
代码思路
-
首先,通过输入获取评委人数和学生人数。
-
然后,初始化一个空的学生列表。
# 输入评委人数,不得少于3人 t = int(input('请输入评委人数(不得少于3人):')) # 输入学生人数,不得少于1人 s = int(input('请输入学生人数(不得少于1人):')) # 初始化学生列表 stus = []
-
接着,遍历学生人数,对于每个学生,初始化一个包含评分列表、学号、最低分、最高分和平均分的字典。
# 遍历学生人数 for i in range(s): # 初始化学生字典,包含评分列表、学号、最低分、最高分和平均分 stu = {'score':[]}
-
在每个学生字典中,通过输入获取学生的学号,并遍历评委人数,获取每个评委的评分,并将其添加到评分列表中。
# 输入学生学号 stu.update({'sn':str(input('----\n请输入学生学号:'))}) # 遍历评委人数 for j in range(t): # 输入评委的评分 stu['score'].append(input('请输入评委'+str(j+1)+'的评分:'))
-
对评分列表进行排序,然后获取最低分和最高分,并计算平均分。
# 对评分列表进行排序 stu['score'].sort() # 获取最低分 stu.update({'min':stu['score'].pop(0)}) # 获取最高分 stu.update({'max':stu['score'].pop()}) # 计算平均分并更新字典 stu.update({'avg':sum(stu['score'])/len(stu['score'])})
-
将学生字典添加到学生列表中。
# 将学生字典添加到学生列表中 stus.append(stu)
-
最后,使用字典推导式生成学生学号和平均分的字典,并输出结果。
# 使用字典推导式生成学生学号和平均分的字典
r = {n['sn']:n['avg'] for n in stus}
参考代码
t = int(input('请输入评委人数(不得少于3人):'))
s = int(input('请输入学生人数(不得少于1人):'))
stus = []
for i in range(s):
stu = {'score':[]}
stu.update({'sn':str(input('----\n请输入学生学号:'))})
for j in range(t):
stu['score'].append(input('请输入评委'+str(j+1)+'的评分:'))
stu['score'].sort()
stu.update({'min':stu['score'].pop(0)})
stu.update({'max':stu['score'].pop()})
stu.update({'avg':eval('+'.join(stu['score']))/len(stu['score'])})
stus.append(stu)
r = {n['sn']:n['avg'] for n in stus}
print(r)