蓝桥杯十五届-解题

import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from PIL import Image
from tqdm import tqdm
import torchvision.transforms as transforms
import os
import random

import model.model as module_arch
from parse_config import ConfigParser


# 定义归一化的线性层
class NormedLinear(nn.Module):
    def __init__(self, in_features, out_features):
        super(NormedLinear, self).__init__()
        self.weight = nn.Parameter(torch.Tensor(in_features, out_features))
        self.weight.data.uniform_(-1, 1).renorm_(2, 1, 1e-5).mul_(1e5)

    def forward(self, x):
        out = F.normalize(x, dim=1).mm(F.normalize(self.weight, dim=0))
        return out


# 简单的 MLP 网络
class MLP(nn.Module):
    def __init__(self, n_i, n_h, n_o):
        super(MLP, self).__init__()
        self.linear1 = NormedLinear(n_i, n_h)
        self.linear2 = NormedLinear(n_h, n_o)
        self.ac = nn.ReLU()

    def forward(self, input):
        return self.linear2(self.ac(self.linear1(input)))


# 图像预处理
transform = transforms.Compose([
    transforms.Resize((32, 32)),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.5071, 0.4867, 0.4408], std=[0.2675, 0.2565, 0.2761])
])


def load_image(image_path):
    image = Image.open(image_path).convert('RGB')
    return transform(image).unsqueeze(0)


def get_topk_softmax(logits, k=5):
    probs = torch.softmax(logits, dim=-1)
    topk_probs, topk_idxs = torch.topk(probs, k)
    return topk_probs.cpu().numpy()[0], topk_idxs.cpu().numpy()[0]


def run_model_on_image(config_path, resume_path, image_tensor, device):
    # ✅ 修改点：直接构造参数 dict 传入
    config = ConfigParser.from_args({
        'config': config_path,
        'resume': resume_path,
        'device': None
    })

    model = config.init_obj('arch', module_arch, allow_override=True, returns_feat=True)

    checkpoint = torch.load(resume_path, map_location=device)
    model.load_state_dict(checkpoint['state_dict'])
    model.to(device).eval()

    with torch.no_grad():
        output = model(image_tensor)
        logits = output['logits']
        if isinstance(logits, list) or logits.ndim == 3:
            logits = sum(logits.transpose(0, 1)) / logits.shape[1]
        return get_topk_softmax(logits, k=5)


def main():
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')

    # 随机选择一张图像
    image_dir = 'utils/input/f67_ray_鳐'
    all_images = [os.path.join(image_dir, img) for img in os.listdir(image_dir) if img.endswith('.png')]
    selected_image = random.choice(all_images)
    print(f'选中的图像: {selected_image}')

    image_tensor = load_image(selected_image).to(device)

    # 模型路径（可按需改成你的路径）
    ce_config = 'saved/cifar100/ir100/.../config.json'
    ce_resume = 'saved/cifar100/ir100/.../checkpoint-epoch200.pth'

    glmec_config = 'saved/cifar100/ir100/.../config.json'
    glmec_resume = 'saved/cifar100/ir100/.../checkpoint-epoch200.pth'

    # 获取两个模型的 top-5
    top5_ce_probs, top5_ce_idxs = run_model_on_image(ce_config, ce_resume, image_tensor, device)
    top5_glmec_probs, top5_glmec_idxs = run_model_on_image(glmec_config, glmec_resume, image_tensor, device)

    print("\n🎯 [CE模型] Top-5 预测:")
    for i in range(5):
        print(f"类 {top5_ce_idxs[i]}: 概率 = {top5_ce_probs[i]:.4f}")

    print("\n🎯 [GL-MEC模型] Top-5 预测:")
    for i in range(5):
        print(f"类 {top5_glmec_idxs[i]}: 概率 = {top5_glmec_probs[i]:.4f}")

    # 对比相同预测类别
    common_classes = set(top5_ce_idxs).intersection(set(top5_glmec_idxs))
    if common_classes:
        print("\n✅ 两个模型 Top-5 中相同的类别:")
        for cls in common_classes:
            ce_prob = top5_ce_probs[list(top5_ce_idxs).index(cls)]
            glmec_prob = top5_glmec_probs[list(top5_glmec_idxs).index(cls)]
            print(f"类 {cls} - CE 概率: {ce_prob:.4f} | GL-MEC 概率: {glmec_prob:.4f}")
    else:
        print("\n❌ 两个模型 Top-5 没有共同类别")


if __name__ == '__main__':
    main()

1.问题描述

小蓝最近迷上了一款名为 “劲舞团” 的游戏，具体来说，只要按照游戏中给出的键位提示依次按出对应的键位，游戏人物便可以跟随节奏跳舞。对于连续的K次正确敲击，如果任意连续的两次敲击间间隔时间都小于等于 1s，那么我们称这是一次 K 连击。现在给出一局小蓝的游戏记录文件，log.txt 中记录了 N 条记录，每条记录有三个字段，依次为正确的敲击字符、小蓝打出的字符、 打出字符的时间对应的毫秒时间戳。现在请你计算下最长的 K 连击是多少，你只需要输出 K 的值。

import sys

def main():

  times=[]
  num=0
  cunum=0
  for line in sys.stdin:
    line =line.strip()
    if not line:
      continue
    
    parts = line.split()
    if len(parts)==3 and parts[0]==parts[1]:
      times.append(int(parts[2]))
    else:
      times.append(-100000)

  
  
  for i in range(1,len(times)):
    if times[i]-times[i-1]<=1000:
      num +=1
      cunum = max(num,cunum)
    else:
      num=2
  
  print(num)



if __name__ == "__main__":
  main()

2.问题描述

数学家们发现了两种用于召唤强大的数学精灵的仪式，这两种仪式分别被称为累加法仪式 A(n) 和累乘法仪式 B(n)。

累加法仪式 A(n) 是将从 1 到 n 的所有数字进行累加求和，即：A(n)=1+2+⋯+n
累乘法仪式 B(n) 则是将从 1 到 n 的所有数字进行累乘求积，即：B(n)=1×2×⋯×n
据说，当某个数字 i 满足 A(i)−B(i) 能被 100 整除时，数学精灵就会被召唤出来。

现在，请你寻找在 1 到 2024041331404202 之间有多少个数字 i，能够成功召唤出强大的数学精灵。

import os
import sys

# 请在此输入您的代码
def main():
  num1, num2 = divmod(2024041331404202, 200)
  print(num1*4+2)


if __name__ == "__main__":
  main()

3.问题描述

在蓝桥王国，数字的大小不仅仅取决于它们的数值大小，还取决于它们所形成的“封闭图形”的个数。
封闭图形是指数字中完全封闭的空间，例如数字1、2、3、5、7都没有形成封闭图形，而数字0、4、6、9分别形成了 1 个封闭图形，数字 8 则形成了 2 个封闭图形。值得注意的是，封闭图形的个数是可以累加的。例如，对于数字 68，由于 6 形成了 1 个封闭图形，而 8 形成了 2 个，所以 68 形成的封闭图形的个数总共为 3。

在比较两个数的大小时，如果它们的封闭图形个数不同，那么封闭图形个数较多的数更大。例如，数字 41 和数字 18，它们对应的封闭图形的个数分别为 1 和 2，因此数字 41 小于数字 18。如果两个数的封闭图形个数相同，那么数值较大的数更大。例如，数字 14 和数字 41，它们的封闭图形的个数都是 1，但 14<41，所以数字 14 小于数字 41。 如果两个数字的封闭图形个数和数值都相同，那么这两个数字被认为是相等的。

小蓝对蓝桥王国的数字大小规则十分感兴趣。现在，他将给定你 n 个数 a1、a2、a3、、、an，请你按照蓝桥王国的数字大小规则，将这 n 数从小到大排序，并输出排序后结果。

import os
import sys


def main():
  n = int(input())
  feng = [0] * n
  numbers = list(map(int,input().split()))
  for i in range(n):
    feng[i]=chu(numbers[i])
  
  paris = list(zip(feng,numbers))
  paris.sort(key=lambda x:(x[0],x[1]))
  num=[num for (feng,num)in paris]
  print(' '.join(map(str, num)))


def chu(num):
  value=0
  while num>0:
    num1,num2= divmod(num,10)
    value=value+fengbi(num2)
    num=num1
  return value

def fengbi(val):
  if val==1 or val==2 or val==3 or val==5 or val==7:
    return 0
  elif val==0 or val==4 or val==6 or val==9:
    return 1
  elif val==8:
    return 2

if __name__ == "__main__":
  main()

4.问题描述

在库存管理系统中，跟踪和调节商品库存量是关键任务之一。小蓝经营的仓库中存有多种商品，这些商品根据类别和规格被有序地分类并编号，编号范围从 1 至 n。初始时，每种商品的库存量均为0.
为了高效地监控和调整库存量，小蓝的管理团队设计了 m 个操作，每个操作涉及到一个特定的商品区间，即一段连续的商品编号范围（例如区间 [L,R]）。执行这些操作时，区间内每种商品的库存量都将增加 1。然而，在某些情况下，管理团队可能会决定不执行某些操作，使得这些操作涉及的商品区间内的库存量不会发生改变，维持原有的状态。现在，管理团队需要一个评估机制，来确定如果某个操作未被执行，那么最终会有多少种商品的库存量为0。对此，请你为管理团队计算出，每个操作未执行时，库存量为 0 的商品的种类数。

import os
import sys

# 请在此输入您的代码
def main():
  first_line = sys.stdin.readline()
  n, m = map(int, first_line.strip().split())

  kucun = [1]*(n+1)
  temp = [0]*(n+1)
  num=0
  l=[0]*(m)
  r=[0]*(m)

  for i in range(n):
    kucun[i]=0

  for i in range(m):
    line = sys.stdin.readline()
    lnum, rnum = map(int, line.strip().split())
    l[i]=lnum
    r[i]=rnum


  for i in range(m):
    for j in range(l[i]-1,r[i]):
      kucun[j]+=1
    # print(kucun)
  
  for i in range(m):
    num=0
    temp = kucun.copy()
    for j in range(l[i]-1,r[i]):
      temp[j]-=1

    for z in range(n):
      if temp[z]==0:
        num+=1
    print(num)



main()