16届蓝桥杯pythonB国赛

ans=0
for i in range(1,2026):
  for j in range(i+1,2026):
      k=j+j-i
      if k<=2025:
          ans+=1
print(ans*2)

3.这道题好像错了

def os(n):
    cnt=0
    is_upper=False
    is_lower=False
    is_digit=False
    for i in n:
        if i in '0Oo':#判断可替换字符
            cnt+=1
            continue
        #判断固定的字符
        if i.isdigit():
            is_digit=True
        if i.isupper():
            is_upper=True
        if i.islower():
            is_lower=True
    miss=0
    if not is_upper:
        miss+=1
    if not is_lower:
        miss+=1
    if not is_digit:
        miss+=1


    if miss==0:
        print(0)
    elif cnt>=miss:
        print(miss)
    else:
        print(-1)
n=int(input())
for _ in range(n):
    key=input().strip()
    os(key)

import sys
data=list(map(int,sys.stdin.read().split()))
n=data[0]
m=data[1]
a=data[2:2+m]
vis=[0]*(n+2)
for x in a:
    vis[x]=1

# dp[i] = 前 i 个灯塔中，最多能点亮几个
# 只保留最近两个值：pre2 = dp[i-2], pre1 = dp[i-1]
pre2,pre1=0,0 #相当于初始dp[0],dp[1](还没算)
for i in range(1,n+1):
    if not vis[i]:
        cur=pre1
    else:
        #点亮i
        a=pre2+1
        #不点亮i
        b=pre1
        cur=max(a,b)
    pre1,pre2=cur,pre1  #滚动更新
print(pre1)

x=int(input())
l=x.bit_length()  #二进制长度
k=bin(x).count('1')   #二进制1的个数
print(x-2**(l-k)+1)

import math
from itertools import permutations

n=int(input())
ans=float('inf')
cur_gcd=-1

# 预计算 10 的幂
pow10 = [1]
for _ in range(10):
    pow10.append(pow10[-1] * 10)
    
for p in permutations(range(1,9)):#从小到大全排列1-8
    num=0
    for i in p:
        num=num*10+i
    #插入
    for j in range(9):  #0=前，8=后
        pre=num//pow10[8-j]
        r=num%pow10[8-j]
        l=pre*pow10[9-j]#左移留出空间
        for k in range(1,9):
            new_num=l+k*pow10[8-j]+r   
            g=math.gcd(n,new_num)
            if g>cur_gcd or (g==cur_gcd and new_num<ans):
                cur_gcd,ans=g,new_num

print(ans)

import sys
import heapq

data = list(map(int, sys.stdin.read().split()))
n, c, b = data[0], data[1], data[2]
s = data[3:3 + n]
a = data[3 + n:3 + 2 * n]

dun=min(b,c)# 初始护盾受上限约束
heap=[]     # 要求大根堆（需用负数模拟）
ans=0

for i in range(n):
    before=dun         #增幅时用
    dun=min(dun+s[i],c)#先不增幅
    
    # 计算实际增幅
    if s[i]>0:
        extra=min(s[i],c-before-s[i])
        if extra>0:
            heapq.heappush(heap,-extra)
    while dun<a[i]:
        if not heap:
            print(-1)
            sys.exit()
        extra=-heapq.heappop(heap)
        dun=min(dun+extra,c)
        ans+=1
    if dun==c:
        heap.clear()# 后续房间无法再从之前的增幅中获益，清空堆
print(ans)

import sys
from math import gcd

data = list(map(int, sys.stdin.read().split()))
n, k = data[0], data[1]
t, c, r = [], [], []  # 工作周期，充电时间，数量
pos = 2
for _ in range(n):
    t.append(data[pos])
    c.append(data[pos + 1])
    pos += 2
for _ in range(n):
    r.append(data[pos])
    pos += 1

# 所有机器人的负载
machine = []
for i in range(n):
    load = c[i] / t[i]
    for _ in range(r[i]):
        machine.append(load)
# 二分法找最小负载率
l = 0
r = 1
while r-l>1e-7:
    mid = (l + r) / 2
    rest = [mid] * k  # 充电站剩余容量
    ok=True
    # 贪心，放机器
    for m in sorted(machine,reverse=True):
        rest.sort()
        if rest[-1] < m - 1e-12:
            ok=False
            break
        rest[-1] -= m
    if ok:  # 全部放下，尝试更小
        r = mid
    else:  # 放不下
        l = mid
print(round(r*100))

贪心没有答对所有样例

import sys

sys.setrecursionlimit(1000000)
data = list(map(int, sys.stdin.read().split()))
n, m = data[0], data[1]
removed = [set() for _ in range(n + 1)]
pos = 2
for _ in range(m):
    u, v = data[pos], data[pos + 1]
    pos += 2
    removed[u].add(v)
    removed[v].add(u)
# 未访问节点信息
unvisited = set(range(1, n + 1))
components = []

for start in range(1, n + 1):
    if start not in unvisited:
        continue

    # bfs
    q = [start]
    unvisited.remove(start)
    comp = []

    for u in q:
        comp.append(u)
        nodes = []  # 之后要拜访的点
        for v in unvisited:
            if v not in removed[u]:
                nodes.append(v)
        for v in nodes:
            unvisited.remove(v)
            q.append(v)  # q追加新元素，还会继续遍历
    comp.sort()
    components.append(comp)
components.sort(key=lambda x: x[0],reverse=False)

print(len(components))
for i in components:
    print(len(i),end=' ')
    print(' '.join(map(str, i)))

跑出了70%样例