贪心算法是一种在每一步选择中都采取当前状态下最优决策的算法范式。

其核心思想是选择每一步的最佳解决方案#xff0c;以期望达到最终的全局最优解。

这种算法特点在于只考虑局部最优解通常在解决最优化问题中使用。

贪心算法是一种在每一步选择中都采取当前状态下最优决策的算法范式。

其核心思想是选择每一步的最佳解决方案以期望达到最终的全局最优解。

这种算法特点在于只考虑局部最优解而不会回溯或重新考虑已经做出的决策也不保证能够解决所有问题。

尽管贪心算法并非适用于所有问题但对于某些特定类型的问题贪心算法的思路简单、高效。

1.区间调度

按照作业的结束时间对作业列表进行排序确保作业按照结束时间的升序排列。

初始化一个空的最大互相兼容作业子集max_jobs_subset。

从排序后的作业列表中选择第一个作业并将其添加到max_jobs_subset中。

遍历剩余的作业对于每个作业

检查该作业的起始时间是否晚于max_jobs_subset中最后一个作业的结束时间。

如果是则将该作业添加到max_jobs_subset中。

python代码

find_max_compatible_jobs(jobs):#

使用sort函数对jobs列表进行排序

这里按照结束时间升序排列jobs.sort(keylambda

[]last_time

last_time:max_jobs_subset.append(job)last_time

job.finsh_time#

int(input(请输入第{}个作业的起始时间:.format(i

1)))finsh_time

int(input(请输入第{}个作业的结束时间:.format(i

1)))if

ValueError:print(结束时间必须晚于开始时间)job

Job(start_time,finsh_time)jobs.append(job)

调用函数找到最大互相兼容作业子集

max_compatible_jobs:print(作业开始时间:{},作业结束时间:{}.format(job.start_time,job.finsh_time))2.区间划分

题目描述

参数设置为讲座的结束时间。

这样可以保证在贪心算法中我们首先处理最早结束的讲座。

创建一个空的教室列表用于存储已经安排的讲座。

遍历排序后的讲座列表。

对于每一个讲座我们需要检查是否存在一个教室可以容纳它。

对于每个讲座我们遍历已经安排的教室并检查当前讲座是否可以安排在某个教室中。

我们可以通过比较当前讲座的开始时间和已安排讲座的结束时间来判断是否可以安排在同一个教室中。

如果存在一个教室可以容纳当前讲座则将该讲座添加到教室的列表中。

如果不存在可以容纳当前讲座的教室则创建一个新的教室并将当前讲座添加到新的教室中。

遍历完所有的讲座后返回教室列表的长度即为需要的最小教室数量。

python代码

ValueError(f讲座{i1}的开始时间必须是正数)if

end_time

ValueError(f讲座{i1}的结束时间必须是正数)lecture

Lecture(start_time,

end_time)lectures.append(lecture)breakexcept

ValueError

minimum_classrooms(lectures):sorted_lectures

sorted(lectures,

sorted_lectures:found_classroom

Falsefor

classroom[-1].end_time:classroom.append(lecture)found_classroom

Truebreakif

found_classroom:classrooms.append([lecture])return

len(classrooms)#

minimum_classrooms(valid_lectures)

题目描述

进行排序以确保优先处理截止时间最早的任务。

创建一个空闲时间变量

current_time并初始化为

minimum_lateness(jobs):jobs.sort(keylambda

x.deadline)

isinstance(job.processing_time,

int)

deadline)jobs.append(job)try:max_lateness

minimum_lateness(jobs)print(The

maximum

分治算法是一种重要的算法范式它将一个大问题分解成几个小问题分别解决这些小问题然后将其合并以得到原始问题的解。

其核心思想是递归地把问题分解成更小的子问题并将这些子问题独立地解决。

分解将原问题分解为若干个子问题。

解决递归地解决这些子问题。

合并将子问题的解合并成原问题的解。

分治算法常用于解决递归性质的问题例如归并排序、快速排序、二叉树相关问题等。

虽然它的效率通常较高但并非适用于所有问题。

1.最近配对问题

最近配对问题。

给定平面上的n个点找一对点使得它们之间的欧几里得距离最小。

解题思路分析

分治法是一种解决问题的方法将问题划分为更小的子问题然后将子问题的解合并起来得到原问题的解。

下面是使用分治法解决最近配对问题的详细步骤

将所有点按照

math.sqrt((p1.x-p2.x)**2(p1.y-p2.y)**2)

使用分治法求解最近配对问题

points[j])#函数直接返回最短距离点对和最小距离return

closest_points,

首先对点集按照x升序排列points.sort(keylambda

p.x)

closest_pair(left_points)closest_right,

d_right

(points[mid-1].xpoints[mid].x)/2mid_points

for

然后把这些点按照y值排序mid_points.sort(keylambda

p.y)min_distance

ValueError:print(输入的坐标不合法请重新输入)#

closest_pair()

首先我们需要选择一个合适的基准元素。

可以使用各种方法选择基准元素例如选择第一个元素、最后一个元素或随机选择一个元素。

选择一个好的基准元素可以提高算法的效率。

将数组划分为两个子数组一个包含小于等于基准元素的元素另一个包含大于基准元素的元素。

这可以通过遍历数组并将小于等于基准元素的元素放在一个子数组中大于基准元素的元素放在另一个子数组中来实现。

这个过程通常被称为分区partition。

然后我们需要确定基准元素在整个数组中的位置。

这可以通过分区的过程中记录基准元素的位置来实现。

假设基准元素的位置是

pivot_index

ValueError:print(输入无效请重新输入整数数组。

)else:print(输入数组不能为空。

)#

校验数据有效性

Trueelse:print(输入的值超出了数组范围请重新输入。

)else:print(输入无效请重新输入一个整数。

)kth_smallest_element

kth_smallest(arr,

{kth_smallest_element})3.医院医生算法

题目描述

医院-医生算法是一种解决问题的方法旨在以最佳方式将医生分配给医院。

该算法确保每个医院都有足够数量的医生并根据特定的标准将每个医生分配到合适的医院。

解题思路分析

初始化医生和医院的偏好列表并将所有医生和医院都标记为未匹配状态。

对于每个医生按照其对医院的偏好将医生依次提议给最喜欢的医院。

每个医生只能向一个医院提议。

对于每个医院收到的提议根据医院的偏好列表进行选择。

如果医院尚未被匹配将医生分配给该医院。

如果医院已经有医生比较当前医生和已匹配医生对医院的偏好并选择更受欢迎的医生。

如果医生被匹配到医院医生和医院都将标记为已匹配状态。

如果有医生被拒绝或医院已经达到容量上限则该医生将继续向下一个偏好医院提议。

重复步骤2和步骤3直到所有医生都被匹配到医院为止。

最终得到的医生-医院匹配结果即为最优的医院-医生分配方案。

python代码

doctors:doctor_preferences[doctor]

doctors[doctor]for

hospitals:hospital_preferences[hospital]

hospitals[hospital]#

hospitals:hospital_matches[hospital]

Nonewhile

hospitalhospital_matches[hospital]

hospital_preferences[hospital].index(doctor)

hospital_preferences[hospital].index(current_match):doctor_matches[doctor]

hospitaldoctor_matches[current_match]

doctorbreakreturn

input(f请输入第{i1}位医生的姓名)doctor_preferences

input(f请输入{doctor_name}医生对医院的偏好以空格分隔).split()doctors[doctor_name]

range(n_hospitals):hospital_name

input(f请输入第{i1}家医院的名称)hospital_preferences

input(f请输入{hospital_name}医院对医生的偏好以空格分隔).split()hospitals[hospital_name]

调用稳定婚姻算法

matches.items():print(f{doctor}

匹配到

Programming是一种优化问题求解的算法思想适用于具有重叠子问题和最优子结构性质的问题。

它将问题分解为一系列重叠的子问题并通过保存子问题的解来避免重复计算从而实现对整个问题的高效求解。

定义状态转移方程通过递推关系式来描述子问题之间的关系即如何通过已知的子问题的解来计算当前问题的解。

确定计算顺序根据子问题之间的依赖关系确定计算的顺序通常采用自底向上的方式进行计算。

计算最优解依据状态转移方程按照确定的计算顺序通过递推计算出问题的最优解。

构造最优解根据计算得到的最优解和保存的状态信息构造出原问题的最优解。

动态规划算法的核心思想是利用子问题的解来求解更大规模的问题通过保存子问题的解避免了重复计算从而显著提高了算法的效率。

动态规划常用于求解最优化问题如最短路径问题、背包问题、序列比对等。

经典动态规划算法:接缝雕刻文本相似和不同比较样条曲线的赋值等。

Fibonacci

Problem在给定容量的背包中选择一些物品放入背包使得物品的总价值最大化同时不超过背包的容量。

最长公共子序列Longest

Common

Subsequence给定两个字符串找到它们的最长公共子序列的长度。

最长递增子序列Longest

Increasing

Subsequence给定一个序列找到一个最长的子序列使得子序列中的元素按顺序递增。

矩阵链乘法Matrix

Chain

Multiplication给定一系列矩阵通过合理地加括号使得矩阵相乘的次数最少。

最短路径问题Shortest

Path

Problem在带有权重的有向图中找到从起点到终点的最短路径。

最大子数组和Maximum

Subarray

Sum给定一个整数数组找到一个具有最大和的连续子数组。

最长回文子串Longest

Palindromic

Substring给定一个字符串找到一个最长的回文子串。

编辑距离Edit

Distance计算将一个字符串转换为另一个字符串所需的最少编辑操作次数。

切割钢条Cutting

Rod将一根长度为

当解决加权区间调度问题时我们希望找到一组相容的区间使得它们的总权重和最大。

动态规划是一种常用的解决最优化问题的方法。

在解决加权区间调度问题时我们可以利用动态规划的思想来逐步计算出最优解。

首先我们将所有的区间按照结束时间从小到大进行排序。

这是因为结束时间早的区间有更大的潜力可以和后面的区间相容。

接下来我们定义一个dp数组dp[i]表示以第i个区间为最后一个区间时的最大权重和。

我们需要逐个计算dp数组的值。

对于每个区间i我们需要考虑两种情况

区间i不被选中此时dp[i]等于dp[i-1]即前一个区间为最后一个区间时的最大权重和。

区间i被选中此时我们需要找到前面结束时间小于等于区间i开始时间的区间j使得dp[j]区间i的权重最大。

因此我们需要遍历前面的区间j找到这样的区间并计算dp[j]区间i的权重。

max(dp[i-1],

通过这样的状态转移我们可以逐个计算dp数组的值。

最终dp数组的最后一个元素即为最大权重和。

将所有区间按照结束时间从小到大进行排序。

定义dp数组长度为区间个数初始化为0。

遍历每个区间i计算dp[i]的值

如果区间i被选中找到前面结束时间小于等于区间i开始时间的区间j计算dp[j]区间i的权重。

将dp[i]更新为上述两种情况中的较大值。

返回dp数组的最后一个元素即为最大权重和。

希望这样的解题思路能够帮助你更好地理解动态规划解决加权区间调度问题的思路。

python代码实现

weighted_interval_scheduling(jobs):jobs.sort(keylambda

x.end)

print(weighted_interval_scheduling(jobs))2.最大子数组问题

问题描述

最大子数组问题是指在一个数组中找到一个连续子数组使得该子数组的和最大。

思路分析

定义一个dp数组长度与原数组相同用于存储以当前位置为结尾的最大子数组和。

初始化dp数组的第一个元素为原数组的第一个元素即dp[0]

nums[0]。

从位置1开始遍历原数组计算以当前位置为结尾的最大子数组和。

如果dp[i-1]大于0说明以前一个位置为结尾的最大子数组和对于当前位置的子数组和是有贡献的因此dp[i]

dp[i-1]

nums[i]。

如果dp[i-1]小于等于0说明以前一个位置为结尾的最大子数组和对于当前位置的子数组和没有贡献因此dp[i]

python代码实现

input(请输入一个整数数组数字之间用空格分隔).split()]breakexcept

ValueError:print(输入无效请重新输入整数数组)#

输出最大子数组和

print(max_subarray(nums))在这个题的基础上引申出一个新的题目

goal:given

数组的第一行和第一列为矩阵的第一行和第一列元素。

从第二行和第二列开始遍历矩阵中的每个位置

(i,

dp[i][j]dp[i−1][j]dp[i][j−1]−dp[i−1][j−1]matrix[i][j]。

python代码实现

print(max_rectangle_sum(matrix))3.背包问题

问题描述

背包问题是一个经典的组合优化问题旨在从一组物品中选择适合放入背包以最大化总价值同时要求背包的容量不超过给定的限制。

实现思路

减去该物品的重量继续向前搜索。

重复上述步骤直到搜索到第一个位置

python代码实现

将浮点数转换为整数乘以一个大的倍数以保留小数点后的精度multiplier

100weight

个物品的价值))weight.append(w)value.append(v)

capacity