蓝桥杯第21天（Python）（疯狂刷题第4天）

题型：

1.思维题/杂题：数学公式，分析题意，找规律

2.BFS/DFS：广搜（递归实现），深搜（deque实现）

3.简单数论：模，素数（只需要判断到 int（sqrt（n））+1），gcd，lcm，快速幂（位运算移位操作），大数分解（分解为质数的乘积）

4.简单图论：最短路（一对多（Dijstra，临接表，矩阵实现），多对多（Floyd，矩阵实现）），最小生成树（并查集实现）

5.简单字符串处理：最好转为列表操作

6.DP：线性DP，最长公共子序列，0/1背包问题，最长连续字符串，最大递增子串

7.基本算法：二分，贪心，组合，排列，前缀和，差分

8.基本数据结构：队列，集合，字典，字符串，列表，栈，树

9.常用模块：math，datetime，sys中的设置最大递归深度（sys.setrecursionlimit(3000000)），collections.deque（队列），itertools.combinations（list,n）（组合），itertools.permutations（list,n）（排列） heapq（小顶堆）

刷题：

1.双向排序（暴力，内置函数）

import sys  #设置递归深度
import collections  #队列
import itertools  # 排列组合
import heapq  #小顶堆
import math
sys.setrecursionlimit(300000)

# 暴力过60%
n,m=map(int,input().split())
a=[i for i in range(1,n+1)]
for i in range(m):
   p,q=map(int,input().split())
   if p==0:
      a=sorted(a[:q],reverse=True)+a[q:]
   if p==1:
      a=a[:q-1]+sorted(a[q-1::])
print(*a)

使用内置函数就行了，直接暴力，过60%数据就行了，注意切片操作不能取到最后那个，还有sorted可以部分排序，返回一个新序列。

2.瑞士轮（暴力，手写排序函数）

import sys  #设置递归深度
import collections  #队列
import itertools  # 排列组合
import heapq  #小顶堆
import math
sys.setrecursionlimit(300000)
import functools   # 自定义比较函数

def cmp(a,b):  # 降序，优先比大小，再比序号 1表示交换，-1不变
   if a[1]!=b[1]:  # 总分
      return -1 if a[1]>b[1] else 1
   if a[1]==b[1]:  # 序号
      return -1 if a[0]<b[0] else 1

n,r,q=map(int,input().split())
score =[0]+ list(map(int,input().split()))  # 存储初始分
power =[0]+list(map(int,input().split()))   # 存储实力值

# 给得分和实力值添加编号
for i in range(1,len(score)):
   score[i]=[i,score[i]]
for i in range(1,len(power)):
   power[i]=[i,power[i]]

for i in range(r):  # r轮比赛
   #print(score)  #打印比赛前
   for j in range(1,n+1):   # 赢的加分
         ''' 这里有问题，应该按照当前排序后得分的索引来排序'''
##      if power[2*j-1][1]>power[2*j][1]:
##         score[2*j-1][1]+=1
##      elif power[2*j-1][1]<power[2*j][1]:
##         score[2*j][1]+=1
         # 获得两个分值的序号，查他们的实力值
         index1=score[2*j-1][0]
         index2=score[2*j][0]
         if power[index1][1]>power[index2][1]:
            score[2*j-1][1]+=1
         elif power[index1][1]<power[index2][1]:
            score[2*j][1]+=1
   #print(score)  # 比赛后
   score=[0]+sorted(score[1::],key=functools.cmp_to_key(cmp))  # 拼接，升序
   #print(score)  # 排序后
   #print("-"*50) # 分隔线

print(score[q][0])  # 排名第Q

2 4 2
7 6 6 7
10 5 20 15
[0, [1, 7], [2, 6], [3, 6], [4, 7]]
[0, [1, 8], [2, 6], [3, 7], [4, 7]]
[0, [1, 8], [3, 7], [4, 7], [2, 6]]
--------------------------------------------------
[0, [1, 8], [3, 7], [4, 7], [2, 6]]
[0, [1, 8], [3, 8], [4, 8], [2, 6]]
[0, [1, 8], [3, 8], [4, 8], [2, 6]]
--------------------------------------------------
[0, [1, 8], [3, 8], [4, 8], [2, 6]]
[0, [1, 8], [3, 9], [4, 9], [2, 6]]
[0, [3, 9], [4, 9], [1, 8], [2, 6]]
--------------------------------------------------
[0, [3, 9], [4, 9], [1, 8], [2, 6]]
[0, [3, 10], [4, 9], [1, 9], [2, 6]]
[0, [3, 10], [1, 9], [4, 9], [2, 6]]
--------------------------------------------------
1

手写排序函数，通过functools，排序函数使用functools.cmp_to_key(cmp)，

def cmp（）记住-1不变，1交换位置

3.数位排序（自定义排序规则）

注意以下性质

n=123
print(str(n))
print(list(str(n)))
print(list(map(int,str(n))))

"""
123
['1', '2', '3']
[1, 2, 3]

"""

所以代码可以写为

import sys  #设置递归深度
import collections  #队列
import itertools  # 排列组合
import heapq  #小顶堆
import math
sys.setrecursionlimit(300000)
import functools   # 自定义比较函数

def cmp(a,b):  #自定义排序规则 1表示交换，-1不变
   sum1=sum(map(int,list(a)))
   sum2=sum(map(int,list(b)))
   if sum1!=sum2 :   # 和从小到大
      return -1 if sum1<sum2 else 1
   else:    # 字典序排序
      return -1 if a>b else 1

n=int(input())
m=int(input())
save=[str(i) for i in range(1,n+1)]
save.sort(key=functools.cmp_to_key(cmp))
save=[0]+save   # 也可以不拼接，索引取m-1
print(save[m])  # 打印第m个元素

送分吧，熟悉一下自定义排序规则写法，注意数字拆分，转为str类型，然后直接转为列表就可以了。

4.数列求值（取余加循环）

import sys  #设置递归深度
import collections  #队列
import itertools  # 排列组合
import heapq  #小顶堆
import math
sys.setrecursionlimit(300000)
import functools   # 自定义比较函数  -1不变，1交换

a=1
b=1
c=1
d=3
for i in range(4,20190325):
   d=(a+b+c)%10000
   a,b,c=b,c,d
print(d)

就单纯取余循环就可以了，注意要取余，否则数太大了会内存错误。

5.杨辉三角（暴力，列表拼接）

import os
import sys
 
# 骗分写法
n=int(input())
a=[[1],[1,1]]
for i in range(1,500): # 50-1+2行
  b=[]
  temp=0
  for j in range(i): # 根据上一行i计算
    temp=a[i][j]+a[i][j+1]
    b.append(temp)
  a.append([1]+b+[1])
# print(a)
b=[]
for i in range(501):  #进行队列拼接
    b=b+a[i]
print(b.index(n)+1)  # 直接通过队列值找索引

暴力将前面500个杨慧三角形算出来然后拼接，拼成1行，然后求索引值即可。

6.组合数问题（暴力）

import os
import sys
 
# 请在此输入您的代码
def f(i,j):  # 5 3  5*4*3/3*2*1
  a,b=1,1
  for z in range(i,i-j,-1):  # 5,2
    a*=z
  for z in range(1,j+1):
    b*=z
  return a//b
 
 
t,k = map(int,input().split())
ans=0
for _ in range(t):
  n,m=map(int,input().split())
  for i in range(1,n+1):
    for j in range(0,min(i,m)+1):
      if f(i,j)%k==0:
        print(i,j)
        ans+=1
print(ans%(10**9+7))

按照题意直接暴力跑就行了