python算法题

⑴ 用python做一道求数组组成的凹槽能盛水的容积的算法题

classSolution(object):
deftrap(self,height):
"""
:typeheight:List[int]
:rtype:int
"""
iflen(height)<=2:#至少要块板的都可能盛得下水
return0
maxHeight=max(height)
ifmaxHeight<1:#最高的板都只是0高度，不能盛水
return0
maxIndex=height.index(maxHeight)
waterLeft=[]
waterRight=[]
#对目前最高板的左边进行递归
self.leftRecursion(height[:maxIndex],waterLeft)
#对目前最高板的右边进行递归
self.rightRecursion(height[maxIndex+1:],waterRight)
returnsum(waterLeft)+sum(waterRight)

defleftRecursion(self,height,water):
iflen(height)<2:
return
maxHeight=max(height)
ifmaxHeight<1:
return
maxIndex=height.index(maxHeight)
#之前最高板的左边序列的最高板即次高板，这两板之间所能盛下的水
water.append(sum([maxHeight-hforhinheight[maxIndex+1:]]))
#把次高板当做当前最高板，对其左边继续进行递归计算
self.leftRecursion(height[:maxIndex],water)

defrightRecursion(self,height,water):
iflen(height)<2:
return
maxHeight=max(height)
ifmaxHeight<1:
return
maxIndex=height.index(maxHeight)
#之前最高板的右边序列的最高板即次高板，这两板之间所能盛下的水
water.append(sum([maxHeight-hforhinheight[:maxIndex]]))
#把次高板当做当前最高板，对其右边继续进行递归计算
self.rightRecursion(height[maxIndex+1:],water)

⑵ python算法有哪些

算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令，算法代表着用系统的方法描述解决问题的策略机制。也就是说，能够对一定规范的输入，在有限时间内获得所要求的输出。如果一个算法有缺陷，或不适合于某个问题，执行这个算法将不会解决这个问题。不同的算法可能用不同的时间、空间或效率来完成同样的任务。一个算法的优劣可以用空间复杂度与时间复杂度来衡量。

一个算法应该具有以下七个重要的特征：

①有穷性（Finiteness）：算法的有穷性是指算法必须能在执行有限个步骤之后终止；

②确切性(Definiteness)：算法的每一步骤必须有确切的定义；

③输入项(Input)：一个算法有0个或多个输入，以刻画运算对象的初始情况，所谓0个输 入是指算法本身定出了初始条件；

④输出项(Output)：一个算法有一个或多个输出，以反映对输入数据加工后的结果。没 有输出的算法是毫无意义的；

⑤可行性(Effectiveness)：算法中执行的任何计算步骤都是可以被分解为基本的可执行 的操作步，即每个计算步都可以在有限时间内完成（也称之为有效性）；

⑥高效性(High efficiency)：执行速度快，占用资源少；

⑦健壮性(Robustness)：对数据响应正确。

相关推荐：《Python基础教程》

五种常见的Python算法：

1、选择排序

2、快速排序

3、二分查找

4、广度优先搜索

5、贪婪算法

⑶ python用while输出2到100的素数

这个问题我们这也有学生提过，其实挺简单，看我写代码
##python算法题：输出2~100之间的素数
i=2
j=2
##除了1和其本身，其他都不能整除
for j in range(2,101):
for i in range(2,j):
if j%i==0:
break;elif (j-1)==i:
print ('{}是素数'.format(j))

⑷ python递归算法经典实例有哪些

程序调用自身的编程技巧称为递归（ recursion）。递归做为一种算法在程序设计语言中广泛应用。 一个过程或函数在其定义或说明中有直接或间接调用自身的一种方法。

它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大地减少了程序的代码量。

递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时，递归前进；当边界条件满足时，递归返回。

Python

是完全面向对象的语言。函数、模块、数字、字符串都是对象。并且完全支持继承、重载、派生、多继承，有益于增强源代码的复用性。Python支持重载运算符和动态类型。相对于Lisp这种传统的函数式编程语言，Python对函数式设计只提供了有限的支持。有两个标准库(functools, itertools)提供了Haskell和Standard ML中久经考验的函数式程序设计工具。

⑸ python走迷宫算法题怎么解

示例：


#coding:UTF-8
globalm,n,path,minpath,pathnum
m=7
n=7
k=[0,1,2,3,4,5,6,7]#循环变量取值范围向量
a=[[0,0,1,0,0,0,0,0],
	[1,0,1,0,1,1,1,0],
	[0,0,0,0,1,0,0,0],
	[1,1,1,1,1,0,0,0],
	[0,0,0,0,0,1,1,0],
	[0,0,0,0,0,0,0,0],
	[0,0,1,1,1,1,1,1],
	[0,0,0,0,0,0,0,0]]#迷宫矩阵
b=[[1,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0],
	[0,0,0,0,0,0,0,0]]	#状态矩阵
path=[]	
minpath=[]
min=10000
step=0
pathnum=0
#print(a)
#print(b)
defnextone(x,y):
	globalpath,minpath,m,n,min,step,pathnum
	if(x==0)and(y==0):
		path=[]
		step=0
	if(x==m)and(y==n):
		pathnum+=1
		print("step=",step)
		print("path=",path)
		ifstep<min:
			min=step
			minpath=path[:]
	else:
		if(x+1ink)and(yink):
			if(b[x+1][y]==0)and(a[x+1][y]==0):
				b[x+1][y]=1
				path.append([x+1,y])
				step+=1
				nextone(x+1,y)
				step-=1
				path.remove([x+1,y])
				b[x+1][y]=0#回溯
		if(xink)and(y+1ink):
			if(b[x][y+1]==0)and(a[x][y+1]==0):
				b[x][y+1]=1
				path.append([x,y+1])
				step+=1
				nextone(x,y+1)
				step-=1
				path.remove([x,y+1])
				b[x][y+1]=0#回溯	
		if(x-1ink)and(yink):
			if(b[x-1][y]==0)and(a[x-1][y]==0):
				b[x-1][y]=1
				path.append([x-1,y])
				step+=1
				nextone(x-1,y)
				step-=1
				path.remove([x-1,y])
				b[x-1][y]=0#回溯
		if(xink)and(y-1ink):
			if(b[x][y-1]==0)and(a[x][y-1]==0):
				b[x][y-1]=1
				path.append([x,y-1])
				step+=1
				nextone(x,y-1)
				step-=1
				path.remove([x,y-1])
				b[x][y-1]=0#回溯					
				
nextone(0,0)
print()
print("min=",min)
print("minpath=",minpath)
print("pathnum=",pathnum)
		

	

⑹ python求质数的算法

很早 的一个 函数

⑺ python算法题

摘要 for a in range( 1, 5):

⑻ python习题（算法）

这个就是循环2n次呀。先是让x=x+c,在把c更新一下c=c+b，最后让b=b+a，这就完成一次循环了。
不过你给的程序不完整。

⑼ python算法问题

你好，答案如下所示。

如图所示

希望你能够详细查看。

如果你有不会的，你可以提问

我有时间就会帮你解答。
希望你好好学习。
每一天都过得充实。

⑽ 一道算法题，用python初始化一颗二叉树并求解其最短路径的值

二叉树算法，可能按照你的需求不是很多：
下面是我用的一个，不过你可以借鉴一下的：
# -*- coding: cp936 -*-
import os
class Node(object):
"""docstring for Node"""
def __init__(self, v = None, left = None, right=None, parent=None):
self.value = v
self.left = left
self.right = right
self.parent = parent
class BTree(object):
"""docstring for BtTee """
def __init__(self):
self.root = None
self.size = 0
def insert(self, node):
n = self.root
if n == None:
self.root = node
return
while True:
if node.value <= n.value:
if n.left == None:
node.parent = n
n.left = node
break
else:
n = n.left
if node.value > n.value:
if n.right == None:
n.parent = n
n.right = node
break
else:
n = n.right
def find(self, v):
n = self.root # http://yige.org
while True:
if n == None:
return None
if v == n.value:
return n
if v < n.value:
n = n.left
continue
if v > n.value:
n = n.right
def find_successor(node):
'''查找后继结点'''
assert node != None and node.right != None
n = node.right
while n.left != None:
n = n.left
return n
def delete(self, v):
n = self.find(v)
print "delete:",n.value
del_parent = n.parent
if del_parent == None:
self.root = None;
return
if n != None:
if n.left != None and n.right != None:
succ_node = find_successor(n)
parent = succ_node.parent
if succ_node == parent.left:
#if succ_node is left sub tree
parent.left = None
if succ_node == parent.right:
#if succ_node is right sub tree
parent.right = None
if del_parent.left == n:
del_parent.left = succ_node
if del_parent.right == n:
del_parent.right = succ_node
succ_node.parent = n.parent
succ_node.left = n.left
succ_node.right = n.right
del n
elif n.left != None or n.right != None:
if n.left != None:
node = n.left
else:
node = n.right
node.parent = n.parent
if del_parent.left == n:
del_parent.left = node
if del_parent.right == n:
del_parent.right = node
del n
else:
if del_parent.left == n:
del_parent.left = None
if del_parent.right == n:
del_parent.right = None
def tranverse(self):
def pnode(node):
if node == None:
return
if node.left != None:
pnode(node.left)
print node.value
if node.right != None:
pnode(node.right)
pnode(self.root)
def getopts():
import optparse, locale
parser = optparse.OptionParser()
parser.add_option("-i", "--input", dest="input", help=u"help name", metavar="INPUT")
(options, args) = parser.parse_args()
#print options.input
return (options.input)
if __name__ == '__main__':
al = [23, 45, 67, 12, 78,90, 11, 33, 55, 66, 89, 88 ,5,6,7,8,9,0,1,2,678]
bt = BTree()
for x in al :
bt.insert(Node(x))
bt.delete(12)
bt.tranverse()
n = bt.find(12)
if n != None:
print "find valud:",n.value