自用python蓝桥杯笔记

明天就考试了，还是觉得自己啥都不会，迷宫那道题真的搞不懂，好痛苦

# count = 0  # 求的是包含2023的个数
# for i in range(12345678, 98765433):
#     i = str(i)
#     if '0' in i and '3' in i and i.count('2') >= 2:  # 先筛选一遍，使运行更快
#         index_2 = i.find('2')
#         index_0 = i.find('0', index_2)
#         index_22 = i.find('2', index_0)
#         index_3 = i.find('3', index_22)
#
#         if index_0 == -1 or index_22 == -1:  # 0和第二个2都不存在就pass
#             pass
#         else:  # 如果0和第二个2都存在
#             if index_3 == -1:  # 3在第二个2后不存在
#                 if i[-1] == '3':  # 在i字符串的最后一个数字中3存在
#                     count += 1  # 则符合要求
#             else:  # 3在第二个2后存在
#                 count += 1
# print(98765433-count-12345678)
# 85959030
"""
Python find() 方法检测字符串中是否包含子字符串 str ，
如果指定 beg（开始） 和 end（结束） 范围，
则检查是否包含在指定范围内，
***如果包含子字符串返回开始的索引值***,
否则返回-1。

Python index() 方法检测字符串中是否包含子字符串 str ，
如果指定 beg（开始） 和 end（结束） 范围，则检查是否包含在指定范围内，
该方法与 python find()方法一样，
只不过如果str不在 string中会  ""报一个异常""。
"""
# 求从12345678到98765432中不完全包含2023的个数
# ans = 0
# for i in range(12345678,98765433):
#     i = str(i)
#     get2 = i.find('2')  # 2要有引号->'2'
#     get0 = i.find('0',get2)
#     get22 = i.find('2',get0)
#     get3 = i.find('3',get22)
#     if get2 == -1 or get0 == -1 or get22 == -1 or get3 == -1:
#         ans += 1
# print(ans)

result = [0 for r in range(4047)]  # 创建一个有4047项的一元列表
for i in range(1, 2024):
    for j in range(i+1, 2024):  # 一个一个遍历，其中因为如果两个金额相同的一起去换钱的话必然会导致金额的损失，所以从i+1开始
        result[i+j]+=i  # result【合成的面值】 += 最小的金额数量（已知第i种有i个，所以个数受小的数限制）
print(max(result))


# 互质指两个值的最大公约数为1
"""
范围1-105
一个子集任意两个数相加与105互质
求该子集和可以包含多少个数字
"""
# import math
# def fun(x):
#     lis = [1]  # 1与任意数都互质
#     for i in range(2,x+1):  # 从2开始遍历到要求数值
#         mark = True  # 默认值为True
#         for j in lis:  # 把lis中的所有值取出来为j，遍历筛选掉任意相加不互质的数
#             if math.gcd(i+j, 105)!=1:
#                 mark = False  # 其实所有的mark对应的真假都是对i的
#                 break
#         if mark:
#             lis.append(i)
#     return lis
# print(fun(105))

import math
lst = [1]
for i in range(2,106):
    mark = True  # 默认值为True是为了在但凡有个False时就pass
    for j in lst:  # 这个的思路是局限在已知的互质数上面一个个测并且加入
        if math.gcd(i+j,105)!=1:
            mark = False
            break
    if mark:
        lst.append(i)
print(len(lst))


"""
积石成山越万重
寻找最小的正整数n使不等式成立
当k为整数的时候式子得出来为0，所以要排除
"""
from math import sqrt  # 平方根
for i in range(3000):  # 估一个大值
    cnt=0
    for j in range(i):
        a  = sqrt(j)  # 对每个3000以内的值求平方根,其中sqrt()求出来的平方根默认为浮点数
        if a == int(a):  # 这一步判断的是a是否为整数，是整数就不行
            continue
        else:  # int(a)取整数是向下取整
            cnt += (int(a)+1)**2-int(a)**2  # 不是整数则符合条件


    if cnt>=10**5:
        print(i-1) # 为什么是i-1啊啊啊啊啊
        break
# 1800




"""
路径之谜
地面n*n个放个  （0<=n<=20）
已知箭靶数目，求行走路径
输入：1、一个整数，n行列
     2、n个整数，空格分开，表示北边箭靶数字（自西向东）
     3、n个整数，空格分开，表示西边箭靶数字（自北向南）
编号从左到右非蛇形0--n**2
输出：一行若干整数表示骑士路径
"""
sys.setrecursionlimit(1500000)
# 请在此输入您的代码
# 回溯DFS+path拔旗。方格表示法为——0,0=1 0,1=1 3,3=15,行数*4+列数好像是。
# 2，1=9
n = int(input())
# 遍历并不是永无止境的。他需要满了则回溯，拔后则加回。
# 起
vis = [[0] * n for _ in range(n)]
lie = list(map(int, input().split()))
hang = list(map(int, input().split()))
tar = (sum(hang) + sum(lie)) // 2  # 目标步数。
dirs = [[0, 1], [1, 0], [-1, 0], [0, -1]]
p = ""


def dfs(x, y, path, bu):
    global p
    vis[x][y] = 1
    hang[x] -= 1
    lie[y] -= 1
    if hang[x] == 0:
        for i in range(x):
            if hang[i] > 0:
                return
    if lie[y] == 0:
        for i in range(y):
            if lie[i] > 0:
                return
    if x == n - 1 and y == n - 1:
        if sum(hang) == 0 and sum(lie) == 0 and bu == tar:

            p = path

            return  # 符合条件啊啊啊啊啊
        else:
            return  # 确实走到终点了，但是此路线没有符合条件。
    for xq, yq in dirs:
        xi, yi = x + xq, y + yq
        if 0 <= xi < n and 0 <= yi < n and vis[xi][yi] != 1 and hang[xi] > 0 and lie[yi] > 0:
            dfs(xi, yi, path + "/" + str(xi * n + yi), bu + 1)
            vis[xi][yi] = 0  # 回溯，
            hang[xi] += 1
            lie[yi] += 1


dfs(0, 0, "0", 1)
for i in p.split("/"):
    print(i, end=" ")



"""
要求p和上一个相减至少大于等于2
输入一串只包含小写字母的字符串1-26与a-z一一对应
输出它的最大价值
"""
# ord()函数时chr（）函数或unichr（）函数的配对函数，它以一个字符作为参数，
# 返回对应的ascll值，或者unicode数值，如果所给的unicode字符超出了你的python定义范围
# 则会引发一个typeerroe的异常
"""
p.s.
print(ord('a'))--->97
print(ord('b'))--->98
print(ord('c'))--->99
"""
def dps(s):
    dp = [0] * len(s)  # 一个和s相等长度的一维列表
    dp[0] = ord(s[0]) - 96  # dp[0]求的是第0个字母的价值
    if len(s) == 1:
        return dp[-1]  # 这里写dp[0]是一样的效果
    dp[1] = max(ord(s[0]) - 96, ord(s[1]) - 96)
    # 比较前两个字母的价值大小并选择大的做后一个字母
    for i in range(2, len(s)):  # 一个一个的遍历
        dp[i] = max(dp[i - 1], dp[i - 2] + (ord(s[i])) - 96)
        # 比较前一个和 前两个+当前这个 的价值，即如果你大的足以我为你少拿一个值，
        # 则更换位置，其中i与i-2其实就是条件：间距差距大于等于2
    return dp[-1]  # 返回的是刚加进来的即倒数第一个
s = input()
print(dps(s))
# 边判断边向后求，类似于105互质那道题