python-常用算法

穷举法-暴力破解法：

对所有的可能性进行验证，直到找到正确答案

例题：一百元买100只鸡，公鸡5元一只，母鸡3元一只，小姐1元三只。

for x in range(20):     #公鸡用100元最多20只for y in range(33): #母鸡yong100元最多33只z=100-x-y       #若是可以买到，那么小鸡数量满足这个式子if 5*x+3*y+z//3 ==100 and z%3==0:  print(x,y,z)

上面代码就是把公鸡母鸡最多用100元买多少只列举出来，若可以买则有结果。

列题2：5个人，捕鱼，后，上岸，睡觉，一个人，先醒，把鱼分为5份，剩一条，扔掉。拿走自己的一份，第二人醒了，也分五份，剩一条，拿走自己的一份。其他人都是如此。问他们至少捕鱼多少条。

##考虑最少。最后一个人将y条鱼分5份剩一条，那最小的y=6，
y = 6
while True:total = yenough = Truefor _ in range(5):if (total - 1) % 5 == 0:     ##按照题意 判断total = (total - 1) // 5 * 4  ##题意，一人分完后 鱼的数量else:enough = Falsebreakif enough:print(y)breaky += 5

贪婪法：

把问题求解时，总是做出在当前看来最好的选择，不追求最优解，快速找到满意解、

贪婪法例子：在对问题求解时，总是做出在当前看来最好的选择，不追求最优解，快速找到满意解。
# 假设小偷有一个背包，最多能装20公斤赃物,c闯入，必须确定拿走哪些物品，留下哪些物品。
#电脑200$  20kg
#收音机 20$ 4kg
#钟 175$ 10kg
#花瓶 50$ 2kg
#书 10$ 1kg
#油画 90$ 9kg
# class Thing(object):
#     """物品"""
#     def __init__(self, name, price, weight):
#         self.name = name
#         self.price = price
#         self.weight = weight
#     @property
#     def value(self):
#         """价格重量比"""
#         return self.price / self.weight
# def input_thing():
#     """输入物品信息"""
#     name_str, price_str, weight_str = input().split()
#     # input().split()  结合使用 .split()默认以空格拆分，对字符串进行切片，经过这一步后变为一个列表 接收多个数据
#     return name_str, int(price_str), int(weight_str)
#
# def main():
#     """主函数"""
#     # 输入两个数，分别赋值给max_weight和num_of_things
#     max_weight, num_of_things = map(int, input().split())  #输入总重量、总物品数
#     all_things = []   ##定义一个空列表
#     for _ in range(num_of_things):             ##循环 为了将物品信息输入。
#         all_things.append(Thing(*input_thing()))  ##列表追加元素
#     all_things.sort(key=lambda x: x.value, reverse=True)   #以价格重量比排序
#     total_weight = 0
#     total_price = 0
#     for thing in all_things:          ## 就开始装。
#         if total_weight + thing.weight <= max_weight:
#             print(f'小偷拿走了{thing.name}')
#             total_weight += thing.weight
#             total_price += thing.price
#     print(f'总价值: {total_price}美元')
# if __name__ == '__main__':
#     main()

分治法(快速排序)：

把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题，直到可以直接求解的程度，最后将子问题的解进行合并得到原问题的解。

def quick_sort(items, comp=lambda x, y: x <= y):  ##方法，传入数据items = list(items)[:]      ##列表 遍历_quick_sort(items, 0, len(items) - 1, comp)  #调用函数return itemsdef _quick_sort(items, start, end, comp):  #print(start)if start < end:pos = _partition(items, start, end, comp)  #调用函数_quick_sort(items, start, pos - 1, comp)  ##_quick_sort(items, pos + 1, end, comp)def _partition(items, start, end, comp):  #pivot = items[end]               ##取最后的元素i = start - 1#print("哈哈哈 %d"%i)for j in range(start, end):     ##在列表元素数 间 循环。 如果有n个比他大的，那么就把它移到那个位置。if comp(items[j], pivot):   #与最后元素比较,最后元素大于他们 进入循环。i += 1                  ##靠他来定位置。有个一比最后一个元素大 i 不加，#print("i= %d"%i)#print("(j= %d)"%j)items[i], items[j] = items[j], items[i]  ##咋相同位置的元素换位置呢。#print("1.i= %d" % i)#print("(2.j= %d)" % j)items[i + 1], items[end] = items[end], items[i + 1]#print("！！！！！！！哈哈哈 %d" % i)return i + 1if __name__=='__main__':it=[1,3,2,5,4,7,6,9,8,0]i=quick_sort(it)print(i)

递归回溯法：叫称为试探法：

按选优条件向前搜索，当搜索到某一步，发现原先选择并不优或达不到目标时，就退回一步重新选择，

# #递归回溯法：叫称为试探法，按选优条件向前搜索，当搜索到某一步，发现原先选择并不优或达不到目标时，就退回一步重新选择，
import sys
import timeSIZE = 5
total = 0def print_board(board):for row in board:for col in row:print(str(col).center(4), end='')print()def patrol(board, row, col, step=1):if row >= 0 and row < SIZE and \col >= 0 and col < SIZE and \board[row][col] == 0:board[row][col] = stepif step == SIZE * SIZE:global totaltotal += 1print(f'第{total}种走法: ')print_board(board)patrol(board, row - 2, col - 1, step + 1)patrol(board, row - 1, col - 2, step + 1)patrol(board, row + 1, col - 2, step + 1)patrol(board, row + 2, col - 1, step + 1)patrol(board, row + 2, col + 1, step + 1)patrol(board, row + 1, col + 2, step + 1)patrol(board, row - 1, col + 2, step + 1)patrol(board, row - 2, col + 1, step + 1)board[row][col] = 0def main():board = [[0] * SIZE for _ in range(SIZE)]patrol(board, SIZE - 1, SIZE - 1)if __name__ == '__main__':main()

动态规划例子：

列表中索引（下标）连续的元素构成的列表的元素之和的最大值。

def main():items = list(map(int, input().split()))overall = partial = items[0]for i in range(1, len(items)):partial = max(items[i], partial + items[i])overall = max(partial, overall)print(overall)if __name__ == '__main__':main()

python-常用算法相关推荐

第四百一十四节，python常用算法学习
本节内容算法定义时间复杂度空间复杂度常用算法实例 1.算法定义算法(Algorithm)是指解题方案的准确而完整的描述,是一系列解决问题的清晰指令,算法代表着用系统的方法描述解决问题的策略机 ...
python常用算法有哪些_python常见的排序算法有哪些?
大家都知道,关于python的算法有很多,其中最为复杂的就是python的排序算法,因为它并不是单一的,而是复杂的,关于排序算法就有好几种不同的方式,大家可以根据以下内容,结合自己的项目需求,选择一个 ...
python 常用算法学习（1）
算法就是为了解决某一个问题而采取的具体有效的操作步骤算法的复杂度,表示代码的运行效率,用一个大写的O加括号来表示,比如O(1),O(n) 认为算法的复杂度是渐进的,即对于一个大小为n的输入,如果他的 ...
python常用算法包_Python中常用的包--sklearn
sklearn 线性回归LinearRegression()参数介绍 LinearRegression(fit_intercept=True,normalize=False,copy_X=True,n ...
python常用算法有哪些_python常见排序算法基础教程
前言:前两天腾讯笔试受到1万点暴击,感觉浪费我两天时间去牛客网做题--这篇博客介绍几种简单/常见的排序算法,算是整理下. 时间复杂度 (1)时间频度一个算法执行所耗费的时间,从理论上是不能算出来的,必 ...
python快乐编程—基础入门-python常用算法题
一: #计算平均数,中位数和众数 #coding:utf-8 #计算平均数,中位数和众数 import random lst = [random.randint(0,10) for i in rang ...
python基本算法语句_Python中基本且又常用的算法
这篇文章主要学习Python常用算法,Python常用排序算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下本节内容算法定义时间复杂度空间复杂度常用算法实例 1.算法定义算法(Algo ...
python算法程序_浅谈python常用程序算法
一.冒泡排序: 1.冒泡排序是将无序的数字排列成从小到大的有序组合: 过程:对相邻的两个元素进行比较,对不符合要求的数据进行交换,最后达到数据有序的过程. 规律: 1.冒泡排序的趟数时固定的:n-1 ...
python常用代码入门-入门十大Python机器学习算法（附代码）
入门十大Python机器学习算法(附代码) 今天,给大家推荐最常用的10种机器学习算法,它们几乎可以用在所有的数据问题上: 1.线性回归线性回归通常用于根据连续变量估计实际数值(房价.呼叫次数.总销 ...
python常用代码入门-最全Python算法实现资源汇总！
原标题:最全Python算法实现资源汇总! 整理 | Rachel 责编 | Jane 出品 | Python大本营(ID:pythonnews) [导语]数据结构与算法是所有人都要学习的基础课程,自 ...