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