技術標籤：演算法

0-1揹包問題

#數的階乘理解遞迴
#遞迴函式是先傳遞後迴歸
#例如6的階乘
'''
6*(f(5))---------------\
6*(5*f(4))-------------傳
6*(5*(4*f(3)))----------遞
6*(5*(4*(3*f(2))))--------\
6*(5*(4*(3*(2*f(1)))))-----\
6*(5*(4*(3*(2*1))))--------/
6*(5*(4*(3*2)))-----------/
6*(5*(4*6))-------------回
6*(5*24)---------------歸
6*(120)---------------/
720------------------/
'''
 

#import numpy as np
def f(n):   
    if n==1:       
        return 1
    else:
       return n*f(n-1)
print(f(6))

n=3#物品的數量
c=5#書包能承受的重量
w=[2,2,3,1,5,2]#每個物品的重量
v=[4,3,10,5,4,3]#每個物品的價值
def bag(n,c,w,v):
    #置0，表示初始狀態
    value=[[0 for j in range(c+1)]for i in range(n+1)]
#     value1=[[0 for j in range(c+1)]for i in range(n+1)]
 

#     value2=[[0 for j in range(c+1)]for i in range(n+1)]
    print(value)
    for i in range(1,n+1):#物品數量
        for j in range(1,c+1):#書包能夠承受的重量
#             if j<=w[i-1]:
            value[i][j]=value[i-1][j]
#             value1[i][j]=value[i-1][j]
#             print('-------------------***value1****---------------',value1)
 

            #揹包總容量夠放當前物體，遍歷前一個狀態考慮是否置換
            if j>=w[i-1]and value[i][j]<value[i-1][j-w[i-1]]+v[i-1]:
                value[i][j]=value[i-1][j-w[i-1]]+v[i-1]
#                 value2=value[i-1][j-w[i-1]]+v[i-1]
#                 print('-------------------***value2****---------------',value2)
            print("當前物體是第%d個物體"%i,"當前容量為%d"%j,"前一個物體是第%d個物體"%(i-1),"剩餘容量為%d"%(j-w[i-1]),"前一個重量%d"%(w[i-1]),"前一個個價值%d"%v[i-1])
            print("第i=%d,j=%d的value："%(i,j),value)
#             value[i][j]= max( value[i][j],value[i][j-w[i]]+v[i] )
           
            
#     for x in value:
#         print(x)
    print(value)
    
bag(n,c,w,v)

720
[[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第1個物體 當前容量為1 前一個物體是第0個物體 剩餘容量為-1 前一個重量2 前一個個價值4
第i=1,j=1的value： [[0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第1個物體 當前容量為2 前一個物體是第0個物體 剩餘容量為0 前一個重量2 前一個個價值4
第i=1,j=2的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第1個物體 當前容量為3 前一個物體是第0個物體 剩餘容量為1 前一個重量2 前一個個價值4
第i=1,j=3的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第1個物體 當前容量為4 前一個物體是第0個物體 剩餘容量為2 前一個重量2 前一個個價值4
第i=1,j=4的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第1個物體 當前容量為5 前一個物體是第0個物體 剩餘容量為3 前一個重量2 前一個個價值4
第i=1,j=5的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第2個物體 當前容量為1 前一個物體是第1個物體 剩餘容量為-1 前一個重量2 前一個個價值3
第i=2,j=1的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第2個物體 當前容量為2 前一個物體是第1個物體 剩餘容量為0 前一個重量2 前一個個價值3
第i=2,j=2的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 0, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第2個物體 當前容量為3 前一個物體是第1個物體 剩餘容量為1 前一個重量2 前一個個價值3
第i=2,j=3的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 0, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第2個物體 當前容量為4 前一個物體是第1個物體 剩餘容量為2 前一個重量2 前一個個價值3
第i=2,j=4的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 0], [0, 0, 0, 0, 0, 0]]
當前物體是第2個物體 當前容量為5 前一個物體是第1個物體 剩餘容量為3 前一個重量2 前一個個價值3
第i=2,j=5的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 0, 0, 0, 0]]
當前物體是第3個物體 當前容量為1 前一個物體是第2個物體 剩餘容量為-2 前一個重量3 前一個個價值10
第i=3,j=1的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 0, 0, 0, 0]]
當前物體是第3個物體 當前容量為2 前一個物體是第2個物體 剩餘容量為-1 前一個重量3 前一個個價值10
第i=3,j=2的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 4, 0, 0, 0]]
當前物體是第3個物體 當前容量為3 前一個物體是第2個物體 剩餘容量為0 前一個重量3 前一個個價值10
第i=3,j=3的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 4, 10, 0, 0]]
當前物體是第3個物體 當前容量為4 前一個物體是第2個物體 剩餘容量為1 前一個重量3 前一個個價值10
第i=3,j=4的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 4, 10, 10, 0]]
當前物體是第3個物體 當前容量為5 前一個物體是第2個物體 剩餘容量為2 前一個重量3 前一個個價值10
第i=3,j=5的value： [[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 4, 10, 10, 14]]
[[0, 0, 0, 0, 0, 0], [0, 0, 4, 4, 4, 4], [0, 0, 4, 4, 7, 7], [0, 0, 4, 10, 10, 14]]

for i in range(10,1,-1):
    print(i)

10
9
8
7
6
5
4
3
2

import numpy as np

def solve(vlist,wlist,totalWeight,totalLength):
    resArr = np.zeros((totalLength+1,totalWeight+1),dtype=np.int32)
    for i in range(1,totalLength+1):
        for j in range(1,totalWeight+1):
            resArr[i,j] = resArr[i-1,j]
            if wlist[i-1] <= j:
                resArr[i,j] = max(resArr[i-1,j-wlist[i-1]]+vlist[i-1],resArr[i-1,j])
#             else:            
    return resArr[-1,-1]

if __name__ == '__main__':
    v = [4,3,10]
    w = [2,2,3]
    weight = 5
    n = 3
    result = solve(v,w,weight,n)
    print(result)

14

爬樓梯問題

題目描述：

有一個n階的臺階，每次只能爬一階或者兩階，如果要爬到頂部，問有幾種爬法？

思路：屬於斐波那楔數列問題。這是一個排列組合問題，可以利用遞迴方式或者非遞迴方式。

如果臺階數目為0：則有0中走法
如果臺階數目為1：每次只能爬一階，共有1中走法
如果臺階數目為2：可以1+1，可以1+2，可以1+3，共3中走法
如果臺階數目為n:假設第一次走1，則剩餘有f(n-1)中走法
假設第一次走2，則剩餘有f(n-2)種走法
兩種方式組合共有：f(n-1)+f(n-2)中走法

###遞迴方式
def f(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    elif n==2:
        return 2
    else:
        return f(n-1)+f(n-2)
        
print(f(12))

###非遞迴方式
def f(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    elif n==2:
        return 2
    else:
        res=[0,1,2]#儲存結果
        while len(res)<=n:
            res.append(res[-1]+res[-2])
        return res[n]
print(f(12))        

233
233

乘積最大連續子序列問題

題目描述：

有一個整數型別的列表nums，找出一個序列中乘積最大的連續子序列（該序列中至少包含一個數）？

案例：

data=[1,2,-2,-1,5,-4]
輸出20，子序列：[-1,5,-4]

思路：屬於xx問題。這是一個查詢已知條件問題，可以利用xx方式或者xx方式。

首先看題目，條件是要找連續子序列乘積且要求其最大。
首先要確定子序列的位置：i:起始位置；j:終止位置
例項中《i=3,j=5》我們要求的就是3和5
我們要求mul(i,j)中最大的那個子序列不大好求，轉化下思路
mul(i,j)=mul(0,j)/mul(0,i)
如果乘積為0：需要重新開始
如果乘積<0:應該找到前面最大的負數（即絕對值最小的整數），這樣才能保證從i-j最大
如果乘積>0:應該找到前面最小的正數，這樣才能保證從i-j最大

def maxMul(nums):
    if not nums:return
    #起始變數
    #目前的累成
    cur_mul=1
    #前面最小的正數
    min_pose=1
    #前面最大的負數
    max_neg=float("-inf")
    #結果
    result=float('-inf')
    for num in nums:
        cur_mul*=num
        if cur_mul>0:
            result=max(result,cur_mul//min_pose)
            min_pose=min(min_pose,cur_mul)
            print("cur_mul>0","當前結果",result,"當前乘積",cur_mul,"minpose為",min_pose)
        elif cur_mul<0:
            if max_neg!=float("-inf"):
                result=max(result,cur_mul//max_neg)
                #如果是-inf,結果更新為當前值和結果的最大值
            else:
                result=max(result,num)
            print("cur_mul<0","當前結果",result,"當前乘積",cur_mul,"max_neg",max_neg)
        else:
            cur_mul=1
            min_pose=1
            max_neg=float('-inf')
            result=max(result,num)
    return result

data=[1,2,-2,0,5,-4]
print(maxMul(data))
data=[1,2,-2,-1,5,-4]
print(maxMul(data))

cur_mul>0 當前結果 1 當前乘積 1 minpose為 1
cur_mul>0 當前結果 2 當前乘積 2 minpose為 1
cur_mul<0 當前結果 2 當前乘積 -4 max_neg -inf
cur_mul>0 當前結果 5 當前乘積 5 minpose為 1
cur_mul<0 當前結果 5 當前乘積 -20 max_neg -inf
5
cur_mul>0 當前結果 1 當前乘積 1 minpose為 1
cur_mul>0 當前結果 2 當前乘積 2 minpose為 1
cur_mul<0 當前結果 2 當前乘積 -4 max_neg -inf
cur_mul>0 當前結果 4 當前乘積 4 minpose為 1
cur_mul>0 當前結果 20 當前乘積 20 minpose為 1
cur_mul<0 當前結果 20 當前乘積 -80 max_neg -inf
20

n=1
m=2
print("nihao",n,m)

nihao 1 2

二進位制中統計1的個數

將一個整數轉化為二進位制形式，統計二進位制中1的個數，如果是負數，按補碼統計1的個數。

def f(n):
#     binNum=
    print(bin(n))#檢視原始碼
    if n<0:
        n=(n&0xffffffff)#轉化為補碼
    print(bin(n))
    binLen=len(bin(n))-2
    count=0
    for i in range(0,binLen):
        if (n)&2**i !=0:
            count+=1
    return count
f(-1)        

-0b1
0b11111111111111111111111111111111





32

翻轉單向列表

考察單向連結串列中節點的斷開和連線

有一個單向列表，請編寫一個函式，將這個單向連結串列反轉，並返回反轉後的頭節點。

【1】-【2】-【3】-【NULL】
【3】-【2】-【1】-【NULL】

class LinkNode:
    def __init__(self,x):
        self.val=x
        self.next=None
def reverseLinked(header):
    if not header or not header.next:
        return header
    '''
    [1][2][3]
    temp=2
    [2]=[NULL]
    pre=[1]
    curNode=2
    下一個節點給當前
    前一個節點給下一個
    當前給前一個
    '''
    pre=None #前一個節點
    curNode=header #當前節點
    while curNode:
        temp=curNode.next  #臨時儲存下一個節點
        curNode.next=pre #將前一個節點賦給當前節點的next
        pre=curNode #繼續往後倒
        curNode=temp
    return pre
header=LinkNode(0)
node1=LinkNode(1)
header.next=node1
node2=LinkNode(2)
node1.next=node2
node3=LinkNode(3)
node2.next=node3

def printLinked(header):
    p=header
    while p:
        print(p.val,end=' ')
        p=p.next
    print()
printLinked(header)
header=reverseLinked(header)
printLinked(header)

0 1 2 3 
3 2 1 0 

#定義一個單向列表
class singleNode:
    def __init__(self,x):
        self.val=x
        self.next=None
#定義反轉單向列表
def reverseSingleNode(header):
    if not header or not header.next:
        return header
    pre=None
    curNode=header
#     [1][2][3]
    while curNode:
        temp=curNode.next;
        curNode.next=pre
        pre=curNode
        curNode=temp
    return pre

#定義輸出單向列表
header=singleNode(0)
node1=singleNode(1)
header.next=node1
node2=singleNode(2)
node1.next=node2
node3=singleNode(3)
node2.next=node3
def printSingleNode(header):
    p=header
    while p:
        print(p.val,end=' ')
        p=p.next
    print()
printSingleNode(header)  
header=reverseSingleNode(header)
printSingleNode(header)  

0 1 2 3 
3 2 1 0 

#知識點1：二叉搜尋樹d的定義
#知識點2：二叉搜尋樹的遍歷
#題目1;有一個整數列表，判斷該列表是否為對應二叉搜尋樹的後序遍歷結果
#二叉搜尋樹##二叉排序樹##二叉查詢樹
#二叉搜尋樹 左子樹上的所有的節點均小於根節點，右子樹所有的節點均大於根節點
#前序遍歷/中序遍歷/後續遍歷
#                   8
#             3          10
#         1       6          14
#              4     7    13
#根節點
#後續：左 右 根 後訪問根
# 1 4 7 6 3 13 14 10 8
# #前序 根 左 右 先訪問根
# 8 3 1 6 4 7 10 14 13
#中序 左 根 右 中間訪問根
#演算法：
# 1、找到根節點 8
# 2、遍歷序列，找到第一個大於等於根節點的元素i,則i左側為左子樹，右側為右子樹
# 3、判斷i右側的節點是否都比根節點大，如果有比根節點值大的節點，直接返回False
# 4、否則用遞迴的方式繼續處理i左側和右側的節點
def verifyBst(sequence):
    if not sequence:
        return False
    root=sequence[-1]
    i=0
    for node in sequence[i:-1]:#從前往後掃碼
        if node>root:
            break
        i+=1
    for node in sequence[i:-1]:
        if node <root:
            return False
    left=True
    if i>0:
        left=verifyBst(sequence[:i])
    right=True
    if i<len(sequence)-2 and left:
        right=verifyBst(sequence[i+1:])
    return left and right
print(verifyBst([1,4,7,6,3,13,14,10,8]))
print(verifyBst([8 ,3 ,1 ,6, 4, 7, 10, 14, 13]))    

True
False

#全排列：回溯法
#優點：容易理解
#缺點：耗費記憶體
num=[1,2,3]
for i in range(len(num)):   
    print(i,num[:i]+num[i+1:],num[i])

0 [2, 3] 1
1 [1, 3] 2
2 [1, 2] 3

nums=[1,2,3]
res=[]
def backtrack(nums, tmp):
    print(nums, tmp)
    if not nums:
        res.append(tmp)
        return 
    b=len(nums)
#     print(b)  
    for i in range(b):
        backtrack(nums[:i] + nums[i+1:], tmp + [nums[i]])       
    return res
print(backtrack(nums, []))

[1, 2, 3] []
[2, 3] [1]
[3] [1, 2]
[] [1, 2, 3]
[2] [1, 3]
[] [1, 3, 2]
[1, 3] [2]
[3] [2, 1]
[] [2, 1, 3]
[1] [2, 3]
[] [2, 3, 1]
[1, 2] [3]
[2] [3, 1]
[] [3, 1, 2]
[1] [3, 2]
[] [3, 2, 1]
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]]

nums=[1,2,3]
def backtrack(first = 0):
    # 所有數都填完了
   
    if first == n:  
        res.append(nums[:])
    for i in range(first, n): 
        print(first,i)
        # 動態維護陣列
        nums[first], nums[i] = nums[i], nums[first]
        # 繼續遞迴填下一個數
        backtrack(first + 1)
        # 撤銷操作
        print("=>",first,i)
        nums[first], nums[i] = nums[i], nums[first]       
n = len(nums)
res = []
backtrack()
print(res)

0 0
1 1
2 2
=> 2 2
=> 1 1
1 2
2 2
=> 2 2
=> 1 2
=> 0 0
0 1
1 1
2 2
=> 2 2
=> 1 1
1 2
2 2
=> 2 2
=> 1 2
=> 0 1
0 2
1 1
2 2
=> 2 2
=> 1 1
1 2
2 2
=> 2 2
=> 1 2
=> 0 2
[[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2]]

#螺旋矩陣
n=3
num=[[ 0 for i in range(n)]for j in range(n)]
print(num)
val=[i for i in range(1,n**2+1)]
print(val)
index=0
for row in range(n):
    for col in range(n):
        if(col<n-1):num[row][col]=val[col]
        if(col=n-1:)num[col]

[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

def generateMatrix(n):
    list0 = [j for j in range(1,n**2 + 1)]                          # 生成長列表
    x = y = 0
    dx = [0,1,0,-1]                                                 # 方向座標
    dy = [1,0,-1,0]
    di = 0
    visited = set()                                                 # 初始化集合，用於記錄已走過座標
    list1 = [[None for k in range(n)] for k in range(n)]            # 生成空矩陣
    for i in range(n**2):
        list1[x][y] = list0[i]  
#         print(list0[i])
#         print(list1)
#         print(x,y)
        
        visited.add((x,y))
#         print(visited)
        nx,ny = x + dx[di],y+dy[di]                                 # 記錄下一步操作
#         print(nx,ny)
        if 0<=nx<n and 0<=ny<n and (nx,ny) not in visited:          # 判斷是否越界，未曾走過的路
            x,y = nx,ny
            print('未越界',x,y,dx[di],dy[di])
        else:
            di = (di+1)%4  
#             print(x,y)
#             print(dx[di],dy[di])        
            x,y= x+dx[di],y+dy[di]
            print('已越界',x,y,dx[di],dy[di])
            
    return list1
generateMatrix(3)

未越界 0 1 0 1
未越界 0 2 0 1
已越界 1 2 1 0
未越界 2 2 1 0
已越界 2 1 0 -1
未越界 2 0 0 -1
已越界 1 0 -1 0
已越界 1 1 0 1
已越界 2 1 1 0





[[1, 2, 3], [8, 9, 4], [7, 6, 5]]

def snake(n):
    arr = [[0] * n for i in range(n)]
    flag = 1  
    for k in range(int(n/2)):
        for up in range(k, n-1-k):
            arr[k][up] = flag
            flag += 1
            print("up",flag)
        for right in range(k, n-1-k):
            arr[right][n-1-k] = flag
            flag += 1
            print("right",flag)
        for down in range(n-1-k, k, -1):
            arr[n-1-k][down] = flag
            flag += 1
            print("down",flag)
        for left in range(n-1-k, k, -1):
            arr[left][k] = flag
            flag += 1
            print("left",flag)
    if n%2 != 0:
        arr[int((n-1)/2)][int((n-1)/2)] = flag
    return arr
snake(4)

up 2
up 3
up 4
right 5
right 6
right 7
down 8
down 9
down 10
left 11
left 12
left 13
up 14
right 15
down 16
left 17





[[1, 2, 3, 4], [12, 13, 14, 5], [11, 16, 15, 6], [10, 9, 8, 7]]

#python單例模式
#常用的軟體設計模式。在應用這個模式時，單例物件的類必須保證只有一個例項存在
#定義：
'''
定義:單例即單個例項;每次建立類例項時，只建立一個類例項
優勢:避免消耗過多的記憶體或CPU資源
例如：
①、資料庫類，我們希望每次都使用同一個資料庫物件來對資料庫進行操作，以維護資料的一致性。
②、模組的匯入，如果沒有匯入該模組，則匯入該模組並例項化，如果已經匯入，則返回該模組的物件
'''
#使用new方法，new方法為python例項化建立物件自動執行的函式，通過重寫這個函式，
#使之先判斷該類中是否有instance屬性（利用反射），
#若沒有則為建立一個物件併為該屬性賦值，最後返回instance中的物件。
#通過這種方式我們實現了每次建立例項返回的都是類中的instance的值。
class Singleton():
    def __new__(cls, *args, **kwargs):#cls建立的例項物件
        if not hasattr(cls,'instance'):
            cls.instance=super(Singleton,cls).__new__(cls)
        return cls.instance

a=Singleton()
b=Singleton()
print(a)#<__main__.Singleton object at 0x00000220866EF400>
print(b)#<__main__.Singleton object at 0x00000220866EF400>

<__main__.Singleton object at 0x00000000049CA748>
<__main__.Singleton object at 0x00000000049CA748>

#
n=3
a=[i for i in range(1,n**2+1)]
print(a)
'''
1   2   3   4
12  13  14  5
11  16  15  6
10   9   8  7
'''
#(0,0) (0,1) (0,2)（0,3）
#(1,3)（2,3）（3,3）
#（3,2）（3,1） （3,0）
#（2,0）（1,0）

#（1,1）（1,2）
#（2,2）（2,1）
visit=[[None for i in range(n)]for j in range(n)]
value=[[None for i in range(n)]for j in range(n)]
print(visit)
count=0
# for i in range(n):
#     for j in range(n):
#         if visit[i][j] !=True:
#             value[i][j]=a[j]
#             visit[i][j]=True
# print(value)
# row=0
# col=3
# for j in range(col):
#     v[row][j]=a[j]
index=(j%3)
flag=1
col=3
if(flag==1):
    row=0
    for j in range(col):
        value[row][j]=a[count]
    count=
        

    
   
        

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[[None, None, None], [None, None, None], [None, None, None]]
[[1, 2, 3], [1, 2, 3], [1, 2, 3]]

import numpy as np
n=5
a=[i for i in range(1,n**2+1)]
#1 1 2 3 5 8 13 21 34
c=[]
def f(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    else:
        return f(n-1)+f(n-2)
for i in range(n**2):
    c.append(f(i))
a=c[::-1]
print(a)  
# a=np.array(a)
# a=a.reshape((n,n))
print(a)
count=0
b=[[None for i in range(n)]for j in range(n)]
for k in range(n//2):
    for up in range(k,n-1-k):
        b[k][up]=a[count]
#         b.append(a[k][up])
        count+=1
        print(b[k][up],end=" ")
    for right in range(k,n-1-k):
        b[right][n-1-k]=a[count]
#         b.append(a[right][n-1-k])
        count+=1
        print(b[right][n-1-k],end=" ")
    for down in range(n-1-k,k,-1):
        b[n-1-k][down]=a[count]
#         b.append(a[n-1-k][down])
        count+=1
        print(b[n-1-k][down],end=" ")
    for left in range(n-1-k,k,-1):
        b[left][k]=a[count]
#         b.append(a[left][k])
        count+=1
        print(b[left][k],end=" ")
print(b)
print(np.array(b))

[46368, 28657, 17711, 10946, 6765, 4181, 2584, 1597, 987, 610, 377, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1, 1, 0]
[46368, 28657, 17711, 10946, 6765, 4181, 2584, 1597, 987, 610, 377, 233, 144, 89, 55, 34, 21, 13, 8, 5, 3, 2, 1, 1, 0]
46368 28657 17711 10946 6765 4181 2584 1597 987 610 377 233 144 89 55 34 21 13 8 5 3 2 1 1 [[46368, 28657, 17711, 10946, 6765], [34, 21, 13, 8, 4181], [55, 1, None, 5, 2584], [89, 1, 2, 3, 1597], [144, 233, 377, 610, 987]]
[[46368 28657 17711 10946 6765]
 [34 21 13 8 4181]
 [55 1 None 5 2584]
 [89 1 2 3 1597]
 [144 233 377 610 987]]

#字串查詢
board = [
  ['A','B','C','E'],
  ['S','F','C','S'],
  ['A','D','E','E']
]
# word1='ASAD'
word1='SEE'
ori_search=[(0,1),(0,-1),(1,0),(-1,0)]
def DFS(board,word,index,visit,startx,starty,m,n):
#     print(visit)
#     print(startx,starty)
    if index==len(word)-1:
        return word[index]==board[startx][starty]
    if word[index]==board[startx][starty]:
        visit[startx][starty]=True
        print("1",visit)
        for ori in ori_search:
            start_x=startx+ori[0]
            start_y=starty+ori[1]
            if 0<=start_x<m and 0<=start_y<n :
                if not visit[start_x][start_y]and DFS(board,word,index+1,visit,start_x,start_y,m,n):                   
                    return True
        print("2",visit)
        visit[startx][starty]=False
    return False
def func1(board,word):
    if not board:#如果board為空返回
        return False
    row=len(board)
    col=len(board[0])
    visit=[[None for i in range(col)]for j in range(row)]
    print(visit)
    print("行",row,"列",col)   
    for i in range(row):
        for j in range(col):
            if DFS(board,word,0,visit,i,j,row,col):
                return True
    return False
#     for i in range
# func1(board,word)    
func1(board,word1)    

[[None, None, None, None], [None, None, None, None], [None, None, None, None]]
行 3 列 4
1 [[None, None, None, None], [True, None, None, None], [None, None, None, None]]
2 [[None, None, None, None], [True, None, None, None], [None, None, None, None]]
1 [[None, None, None, None], [False, None, None, True], [None, None, None, None]]
1 [[None, None, None, None], [False, None, None, True], [None, None, None, True]]





True

class Solution:
    orientation = [(0, -1), (-1, 0), (1, 0), (0, 1)]

    def exist(self, board, word):
        m = len(board)
        if m == 0: return False
        n = len(board[0])
        mark = [[False for _ in range(n)] for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if self.DFS(board, word, 0, i, j, mark, m, n):
                    return True
        return False

    def DFS(self, board, word, index, start1, start2, mark, m, n):
        if index == len(word)-1:
            return word[index] == board[start1][start2] 
        if board[start1][start2] == word[index]:
            mark[start1][start2] = True
            for k in self.orientation:
                start_x = start1+k[0]
                start_y = start2+k[1]
                if 0 <= start_x < m and 0 <= start_y < n:
                    if not mark[start_x][start_y] and self.DFS(
                        board, word, index+1, start_x, start_y, mark, m, n):
                        return True
            mark[start1][start2] = False
        return False

#島嶼數量
#參考：https://www.cnblogs.com/Lin-Yi/p/9720787.html
import numpy as np
grid=[["1","1","1","1","0"],["1","1","0","1","0"],["1","1","0","0","0"],["0","0","0","0","0"]]

print(np.array(grid))
grid1=[
['1','1','0','0','0'],
['1','1','0','0','0'],
['0','0','1','0','0'],
['0','0','0','1','1']
]
print(np.array(grid1))
def numIslands(grid):
    if not grid: return 0
    row, col = len(grid), len(grid[0]) 
    def dfs(x,y):
        if x < 0 or y < 0 or x >= row or y >= col or grid[x][y] == '0':
            return
        grid[x][y] = '0'
        dfs(x + 1, y)
        dfs(x - 1 , y)
        dfs(x , y + 1)
        dfs(x, y - 1)
    ori_dir=[(0,1),(0,-1),(1,0),(-1,0)]
    def dfs1(grid,x1,y1):
        print(grid)
        #對某個座標的四個方向進行搜尋，如果有陸地，則標記為0表示已經被訪問，
        #當四個方向都訪問完畢後，返回重新搜尋座標
        for ori in ori_dir:
            x=x1+ori[0]
            y=y1+ori[1]
            if x>=0 and x<len(grid) and y>=0 and y<len(grid[0]) and grid[x][y]=="1":
                grid[x][y]="0"
                dfs1(grid,x,y)
    count = 0
    for x in range(row):
        for y in range(col):
#             print(x,y)
            if grid[x][y] == '1':#如果是陸地，就進入深度遍歷
                count += 1
                dfs1(grid,x,y)
    return count
print(numIslands(grid1))

[['1' '1' '1' '1' '0']
 ['1' '1' '0' '1' '0']
 ['1' '1' '0' '0' '0']
 ['0' '0' '0' '0' '0']]
[['1' '1' '0' '0' '0']
 ['1' '1' '0' '0' '0']
 ['0' '0' '1' '0' '0']
 ['0' '0' '0' '1' '1']]
[['1', '1', '0', '0', '0'], ['1', '1', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['1', '0', '0', '0', '0'], ['1', '1', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['1', '1', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['0', '1', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['0', '0', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['0', '0', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['0', '0', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '1']]
[['0', '0', '0', '0', '0'], ['0', '0', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '1', '0']]
[['0', '0', '0', '0', '0'], ['0', '0', '0', '0', '0'], ['0', '0', '1', '0', '0'], ['0', '0', '0', '0', '0']]
3

#36進位制轉換為10進位制
#思路：36進位制就是0-9表示10，a-z標註11-36
'''
法一：使用庫
'''
import sys
import os
line = sys.stdin.readline()
a=int(line,36)
if a>9223372036854775807:
    print(9223372036854775807)
elif a< -9223372036854775807:
    print(-9223372036854775807)
elif a> -9223372036854775807 and a<9223372036854775807:
    print(a)
else:
    print(0)
'''zzzzzzzzzzzzz
'''
'''
法二：自己實現（非庫）
'''
def  _36to10(n):
    a="0123456789abcdefghijklmnopqrstuvwxyz"
    num=0
    power=len(n)-1
    for i in range(len(n)):#a.find(n[i])
        num=a.find(n[i])*pow(36,power)+num
        power -=1
    return num
print(_36to10('zzzzzzzzzzzz'))

#詞雲顯示
!pip install wordcloud

Collecting wordcloud
  Downloading https://files.pythonhosted.org/packages/27/62/392187e519c7c39905fb47814a3d79a5fedf1f5c398759fef156d2bd18d3/wordcloud-1.8.0-cp37-cp37m-win_amd64.whl (157kB)
Requirement already satisfied: matplotlib in c:\programdata\anaconda3\lib\site-packages (from wordcloud) (3.1.1)
Requirement already satisfied: pillow in c:\programdata\anaconda3\lib\site-packages (from wordcloud) (5.3.0)
Requirement already satisfied: numpy>=1.6.1 in c:\programdata\anaconda3\lib\site-packages (from wordcloud) (1.17.2)
Requirement already satisfied: kiwisolver>=1.0.1 in c:\programdata\anaconda3\lib\site-packages (from matplotlib->wordcloud) (1.0.1)
Requirement already satisfied: cycler>=0.10 in c:\programdata\anaconda3\lib\site-packages (from matplotlib->wordcloud) (0.10.0)
Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in c:\programdata\anaconda3\lib\site-packages (from matplotlib->wordcloud) (2.3.0)
Requirement already satisfied: python-dateutil>=2.1 in c:\programdata\anaconda3\lib\site-packages (from matplotlib->wordcloud) (2.7.5)
Requirement already satisfied: setuptools in c:\programdata\anaconda3\lib\site-packages (from kiwisolver>=1.0.1->matplotlib->wordcloud) (41.2.0)
Requirement already satisfied: six in c:\programdata\anaconda3\lib\site-packages (from cycler>=0.10->matplotlib->wordcloud) (1.12.0)
Installing collected packages: wordcloud
Successfully installed wordcloud-1.8.0

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from wordcloud import WordCloud,STOPWORDS
stop_words=set(STOPWORDS)
text="lvjunjie,lvjunjie,lvjunjie,lvjunjie,lvjunjie,lvjunjie,lvjunjie,lvjunjie"
word_cloud=WordCloud(background_color='white',max_words=200,stopwords=stop_words)
word_cloud.generate(text)
plt.imshow(word_cloud,interpolation='bilinear')
plt.axis("off")

(-0.5, 399.5, 199.5, -0.5)