1 问题描述
       小蓝要到店里买铅笔。
       铅笔必须—整盒—整盒买，—整盒12支，价格p 元。小蓝至少要买t支铅笔，请问他最少花多           少钱?
输入格式
       输入一行包含两个整数p、t，用一个空格分隔。
输出格式
       输出一行包含一个整数，表示答案。
样例输入    5 30
样例输出   15

import math
p,t=map(int,input().split())
x=math.ceil(t/12)
print(p*x)

没啥说的，向上取整就OK

2 问题描述
       给定一个三角形的三条边的长度a, b, c，请问这个三角形是不是一个直角三角形。
输入格式
       输入—行包含三个整数a, b, c，表示三角形三边的长度，相邻整数之间用一个空格分隔。
输出格式
       如果是直角三角形，输出“YES”(全大写)，否则输出"NO”(全大写)。
样例输入 3 4 5
样例输出 YES
 

a,b,c=map(int,input().split())
list=[a,b,c]
list.sort()
if list[0]*list[0]+list[1]*list[1]==list[2]*list[2]:
    print("YES")
else:
    print("NO")

 排个序，over

3 问题描述
n个小朋友正在做一个游戏，每个人要分享一个自己的小秘密。
每个小朋友都有一个1到n的编号，编号不重复。
为了让这个游戏更有趣，老师给每个小朋友发了一张卡片，上面有一个1到n 的数字，每个数字正好出现一次。
每个小朋友都将自己的秘密写在纸上，然后根据老师发的卡片上的数字将秘密传递给对应编号的小朋友。如果老师发给自己的数字正好是自己的编号，这个秘密就留在自己手里。
小朋友们拿到其他人的秘密后会记下这个秘密，老师会再指挥所有小朋友将手中的秘密继续传递，仍然根据老师发的卡片上的数字将秘密传递给对应编号的小朋友。
这样不断重复n次。
现在，每个小朋友都记下了很多个秘密。
老师现在想找一些小朋友，能说出所有秘密，请问老师最少要找几个小朋友?
输入格式
       输入的第一行包含一个整数n。
       第二行包含n个整数a[1], a[2], ...， a[n]，相邻的整数间用空格分隔，分别表示编号1到n的小朋友收到的数字。
输出格式
       输出一行包含一个整数，表示答案。
样例输入
6
2 1 3 5 6 4
样例输出  3
样例说明
最终小朋友1,2互相知道了对方的秘密，小朋友3只知道自己的秘密，小朋友4,5,6互相知道了对方的秘密。
至少要找3个小朋友才能说出所有秘密。

n=int(input())
a=list(map(int,input().split()))
book=[0]*n
count=0
path=[0]*n
for i in range(n):
    path[i]=a[i]-1
for i in range(n):
    if book[i]==0:
        book[i]=1
        j=path[i]
        while book[j]==0:
            book[j]=1
            j=path[j]
        count+=1
print(count)

不难发现，共享秘密的人会形成一个闭环（每个人卡片上的数字是不重复的）那么我们只需要看有多少个闭环就可以了。

用一个path数组来存储每个人传给下一个人的索引，遍历每个人时就沿着path的路径进行访问，并用book数组标记，下一次遍历时从未标记的人开始，最后遍历的次数就是闭环的个数，即答案

问题描述
一个1到n的排列被称为半递增序列，是指排列中的奇数位置上的值单调递增，偶数位置上的值也单调递增。
例如:(1，2，4，3，5，7，6，8，9)是一个半递增序列，因为它的奇数位置上的值是1，4，5，6，9，单调递增，偶数位置上的值是2，3，7，8，也是单调递增。
请问，1到n的排列中有多少个半递增序列?
输入格式
输入一行包含一个正整数n。
输出格式
输出一行包含一个整数，表示答案，答案可能很大，请输出答案除以1000000007的余数。
样例输入
5
样例输出                                                                                                                                            10
 

def f(i):
    if i==0 or i==1:
        return 1
    else:
        return i*f(i-1)
n=int(input())
a=n//2
b=n-a
print(f(n)//(f(a)*f(b))%1000000007)

这道题不知道大家用什么办法做的，我是直接用高中排列组合的思想得出结果是C(n,n//2)（组合数）然后就写了个阶乘函数投机取巧了，但是感觉这道题应该不是想考这个

5 问题描述
小蓝住在LQ城，今天他要去小乔家玩。
LQ城可以看成是一个n行m列的一个方格图。
小蓝家住在第1行第1列，小乔家住在第n行第m列。小蓝可以在方格图内走，他不愿意走到方格图外。
城市中有的地方是风景优美的公园，有的地方是熙熙攘攘的街道。小蓝很喜欢公园，不喜欢街道。他把方格图中的每一格都标注了一个属性，或者是喜欢的公园，标为1，或者是不喜欢的街道标为2。小蓝和小乔住的地方都标为了1。
小蓝每次只能从一个方格走到同一行或同—列的相邻方格。他想找到一条路径，使得不连续走两次标为2的街道，请问在此前提下他最少要经过几次街道?
输入格式
输入的第一行包含两个整数n, m，用一个空格分隔。
接下来n行，每行一个长度为m第数字串，表示城市的标注。
输出格式
输出一行包含一个整数，表示答案。如果没有满足条件的方案，输出-1。
样例输入
34
1121                                                                                                                                            1211                                                                                                                                                    2211
样例输出
2
 

def dfs(x, y, cross):
    global min_cross, book, count
    if x == n - 1 and y == m - 1:
        if cross < min_cross:
            min_cross = cross
        return
    if graph[x][y] == 2:
        count = 1
        cross += 1
    else:
        count = 0
    for i in range(4):
        tx = x + ward[i][0]
        ty = y + ward[i][1]
        if tx < 0 or tx >= n or ty < 0 or ty >= m or (count == 1 and graph[tx][ty] == 2):  # 越界or上一次是街道，这一次也是街道
            continue
        if book[tx][ty] == 0:  # 下一个节点未访问过
            book[tx][ty] = 1
            dfs(tx, ty, cross)  # 访问该节点
            book[tx][ty] = 0  # 重置节点的访问状态


n, m = map(int, input().split())
graph = [[0] * m] * n
min_cross = n * m
book = [[0 for _ in range(m)] for _ in range(n)]
ward = [[0, 1], [1, 0], [0, -1], [-1, 0]]
for i in range(n):
    graph[i] = list(map(int, input().split()[0]))
book[0][0] = 1
count = 0
dfs(0, 0, 0)
if min_cross != m * n:
    print(min_cross)
else:
    print(-1)

DFS一下