Python算法精粹-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_44568633/article/details/107308978

文章目录

python多属性排序（第一个降序，当一个相同用第二个降序）
固定步长走地砖（二叉树广度优先）
是否能正确找零钱
撤销恢复
游戏角色扮演
滑动窗口最大值
自然数之和
打印两个降序链表公共节点的值

python多属性排序（第一个降序，当一个相同用第二个降序）

在这里插入图片描述

def attr_sort(n,L,G):
    list2=L.split()
    list3=G.split()
    slist=list(zip(list2,list3))#py3中zip()返回的是对象，需要手动返回list()
    # slist=zip(list1,list2,list3)#py2
    slist.sort(key=lambda x:(x[0],x[1]),reverse=True)
    for i in slist:
        print(i[0],i[1])

re=attr_sort(4,'87 98 98 41','55 22 66 99')
print(re)

# 98 66
# 98 22
# 87 55
# 41 99

固定步长走地砖（二叉树广度优先）

'''
题目：
固定步长通过一个矩形路面，只有部分铺设地砖，判断能否按照固定步长N通过改区域。

思想：二叉树的广度优先。
遍历队列中的节点，每次弹出第一个节点，并把该节点可能的所有情况追加道队列后面。
循环跳出的条件是：当弹出的节点(x,y)为(M-1,N-1)时
'''
def walkfloor(s,M,N,region):
    pos=[[0,0]]
    flag=False
    while pos:
        for n in range(len(pos)):
            x,y=pos.pop(0)
            if x==M-1 and y==N-1:
                flag=True
                break
            for nx,ny in [[x+s,y],[x,y+s]]:
                if nx<M and ny<N:
                    if region[nx][ny]==1:
                        pos.append([nx,ny])
        if flag:
            break
    if flag:
        return 1
    else:
        return 0
if __name__ == '__main__':
    s=int(input())
    rowl=list(map(int,input().split()))
    M=rowl[0]
    N=rowl[1]
    region=[]
    for i in range(M):
        line=list(map(int,input().split()))
        region.append(line)
    print(walkfloor(s,M,N,region))

是否能正确找零钱

'''
题目：
每杯咖啡5元，用面值5，10，20元去买，若能正确找零，返回最后一个顾客的序号，若不能正确找零，返回当前顾客的序号。

思路：
分别把5，10，20的面值作为key以及对应的张数作为值存储在字典中，遍历顾客给的面值，如果对应的面值在字典中，值+1；如果不在，就存入字典，值为1.正确找零返回true，以及当前顾客的长度。不正确，返回false以及当前的编号
当面值为5时不存在找零；
当面值为10时，就需要找零，如果存在面值5并且值》=1，则正常找零。如果不存在面值5，那么返回false以及当前的编号。
当面值为20时，就需要找零，如果存在面值5并且值》=1，则正常找零。如果不存在面值5，那么返回false以及当前的编号。

'''
def backchange(buyers):
    sum={}
    i=0
    # 遍历顾客给的钱的面值
    for b in buyers:
        i+=1 #因为顾客数是从1开始的
       
        if b==5:
            if '5' in sum.keys():
                sum['5']+=1
            else:
                sum['5']=1
        elif b==10:
        #满足下面条件就可以找零
            if '5' in sum.keys() and sum['5']>=1:
                sum['5']-=1
                if '10' in sum.keys():
                    sum['10']+=1
                else:
                    sum['10']=1
            else:
                print('false,%s'%i)
                return
        else:
        #'5' in sum.keys() and sum['5']>=3
            if '5' in sum.keys() and sum['5']>=1 and '10' in sum.keys() and sum['10']>=1:
                sum['5']-=1
                sum['10']-=1
                if '20' in sum.keys():
                    sum['20']+=1
                else:
                    sum['20']=1
            else:
                print('false,%s' % i)
                return
    print('true,%s'%len(buyers))

if __name__ == '__main__':
    buyers=list(map(int,input().split(',')))
    print(backchange(buyers))

撤销恢复

'''
题目：
输入一行以空格隔开的字符串，如果遇到undo 则撤销前一个字符串，redo则恢复，最后输出字符串
思想：
遍历输入字符串，放到一个新的列表res里面，如果=undo 并且下一个字符不是redo or undo是最后一个字符，
那么删除res里的最后一个字符。
'''
def back(s):
    res=[]
    for i in range(len(s)):
        if s[i]!='undo' and s[i]!='redo':
            res.append(s[i])
        if s[i]=='undo' and (s[i+1]!='redo' or i==len(s)-1):
            res.pop(-1)
    return ' '.join(res)

if __name__=="__main__":
    s=input().split()
    print(back(s))

游戏角色扮演

def max_demage(ns,mp,hp,skills):
    skill_rate=[t[0]/t[1] for t in skills]
    demage=0 #伤害
    while True:
        if sum(skill_rate)==0:
            break
        max_rate=skill_rate.index(max(skill_rate))
        skill_rate[max_rate]=0
        t_hp=hp
        while mp>=0 and t_hp>0:
            if mp<skills[max_rate][1]:
                break
            demage+=skills[max_rate][0]
            mp-=skills[max_rate][1]
            t_hp-=skills[max_rate][2]
    return demage
if __name__ == '__main__':
    first_input=input("input:").split()
    input1=[]
    for i in first_input:
        input1.append(int(i))
    ns=input1[0]
    mp=input1[1]
    hp=input1[2]
    skills=[]
    for i in range(input1[0]):
        inp=[]
        oth_input=input().split()
        for num in  oth_input:
            inp.append(int(num))
        skills.append(inp)

    print(max_demage(ns,mp,hp,skills))

滑动窗口最大值

'''
思路：
循环遍历列表，把列表对应的索引入队，即将入队元素和队尾的元素比较，队尾元素小则出队，当前元素对应的索引入队，
当形成滑块后，把队列中首元素（最大的元素）加入结果列表，q[0]<i-k+2控制滑块的大小为k。
'''
import collections

class Solution:
    def maxSlidingWindow(self, nums, k):
        res=[]
        n=len(nums)
        q=collections.deque()
        for i in range(n):
            while q and nums[q[-1]]<=nums[i]:
                q.pop()
            q.append(i)
            if i>=k-1:  # i-k+1>0是滑动窗口的左边界，窗口边界：（i-k+1，i）
                res.append(nums[q[0]])
                if q[0]<i-k+2: #这里i-k+2指：滑动窗口的左边界，[i-k+1,i]-->[i-k+2,i+1]
                    q.popleft()# 保证了队列种只有k个值
        return res

s1=Solution()
# re=s1.maxSlidingWindow([12,5,66,3,2,8,9,4],3)
re=s1.maxSlidingWindow([4,6,-3,5,-2,8,15,-52],4)
print(re)

自然数之和

（可能不对）

'''
题目：
老板发工资n元，可以一次发1元、2元、3元。。。。n元，有多少种方法？
思路：
自然数之和有多少种加法？
'''

class Solution:
    def CalulateMethodCount(self, num_money):
        # write code here
        sum = []
        for i in range(num_money):
            temp = 0
            for j in range(len(sum)):
                temp += sum[j]
            temp += 1
            sum.append(temp)
        print(sum[num_money - 1])

if __name__ == "__main__":
    s1 = Solution()
    re = s1.CalulateMethodCount(5)

打印两个降序链表公共节点的值

在这里插入图片描述

#coding=utf-8

class Nodes(object):
    """单向链表的结点"""
    def __init__(self,elem):
        self.elem=elem
        self.next=None

class SingleLinkList(object):
    """单链表"""
    def __init__(self,node=None):
        """构造函数"""
        self.__head=node    #头节点
    def is_empty(self):
        return self.__head==None
    def getHead(self):
        return self.__head
    def append(self,item): #item是一个具体的数据元素
        node=Nodes(item)
        if self.is_empty():
            self.__head=node
        else:
            cur=self.__head #如何是空链表，cur此时为None，无法进入循环体
            while cur.next != None: #游标指向最后一个元素但是不进入循环体
                cur=cur.next
            cur.next=node
def printCommonPart(head1,head2):
    while head1 and head2:
        if head1.elem<head2.elem:
            head2=head2.next
        elif head1.elem>head2.elem:
            head1=head1.next
        else:
            print(head1.elem,end=" ")
            head1=head1.next
            head2=head2.next
    print("")
if __name__=="__main__":
    le1=int(input())
    list1=list(map(int,input().split()))
    le2=int(input())
    list2=list(map(int,input().split()))
    
    s1 = SingleLinkList()
    for i in list1:
        s1.append(i)
        #s1.travel()
    s2=SingleLinkList()
    for n in list2:
        s2.append(n)
        #s2.travel()
    printCommonPart(s1.getHead(),s2.getHead())