小杨买饮料
时间限制：1.0 s
内存限制：128.0 MB
问题描述
小杨来到了一家商店，打算购买一些饮料。这家商店总共出售N种饮料，编号从0至N-1，其中编号为i的饮料售价ci元，容量li毫升。
小杨的需求有如下几点：
1. 小杨想要尽可能尝试不同种类的饮料，因此他希望每种饮料至多购买 1 瓶；
2. 小杨很渴，所以他想要购买总容量不低于L的饮料；
3. 小杨勤俭节约，所以在 1 和 2 的前提下，他希望使用尽可能少的费用。
方便起见，你只需要输出最少花费的费用即可。特别地，如果不能满足小杨的要求，则输出 no solution 。
输入描述
第一行两个整数N,L。
接下来N行，依次描述第i=0,1,...,N-1种饮料：每行两个整数ci,li。
输出描述
输出一行一个整数，表示最少需要花费多少钱，才能满足小杨的要求。特别地，如果不能满足要求，则输出 no
solution 。
特别提醒
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
样例输入 1
5 100
100 2000
2 50
4 40
5 30
3 20
样例输出 1
9
样例解释 1
小杨可以购买1,2,4号饮料，总计获得50+40+20=110毫升饮料，花费2+4+3=9元。
如果只考虑前两项需求，小杨也可以购买1,2,4号饮料，它们的容量总和为50+30+20=100毫升，恰好可以满足需求。但遗憾的是，这个方案需要花费2+5+3=10元。
样例输入 2
5 141
100 2000
2 50
4 40
5 30
3 20
样例输出 2
100
样例解释 2
1,2,3,4号饮料总计140毫升，如每种饮料至多购买 1 瓶，则恰好无法满足需求，因此只能花费100元购买0号饮料。
样例输入 3
4 141
2 50
4 40
5 30
3 20
样例输出 3
no solution
数据规模
对于40%的测试点，保证N≤20 ；1≤L≤100 ；li≤100。
对于70%的测试点，保证li≤100。
对于所有测试点，保证1≤N≤500 ；1≤L≤2000 ；1≤ci,li≤106。
相似题推荐
下面代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。
class Symbol:
def __init__(self, ch='', freq=0, code=''):
self.ch = ch
self.freq = freq
self.code = code
class Node:
def __init__(self, w=0, l=-1, r=-1, sym=-1):
self.w = w
self.l = l
self.r = r
self.sym = sym
def pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB):
if pA[0] < n and (pB[0] >= len(internal_idx) or nodes[leaf_idx[pA[0]]].w <= nodes[internal_idx[pB[0]]].w):
res = leaf_idx[pA[0]]
pA[0] += 1
return res
else:
res = internal_idx[pB[0]]
pB[0] += 1
return res
def dfs_build_codes(u, nodes, sym_list, path):
if u == -1:
return
if nodes[u].sym != -1:
sym_list[nodes[u].sym].code = ''.join(path)
return
path.append('0')
dfs_build_codes(nodes[u].l, nodes, sym_list, path)
path.pop()
path.append('1')
dfs_build_codes(nodes[u].r, nodes, sym_list, path)
path.pop()
def build_huffman_codes(sym_list):
n = len(sym_list)
for sym in sym_list:
sym.code = ''
if n <= 0:
return -1
if n == 1:
sym_list[0].code = '0'
return 0
nodes = []
leaf_idx = []
for i in range(n):
leaf_idx.append(len(nodes))
nodes.append(Node(sym_list[i].freq, -1, -1, i))
leaf_idx.sort(key=lambda x: (nodes[x].w, nodes[x].sym))
internal_idx = []
pA = [0]
pB = [0]
for k in range(1, n):
x = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
y = pop_min_node(nodes, leaf_idx, n, pA, internal_idx, pB)
z = len(nodes)
# 补全缺失的构建内部节点代码（原代码空白处）
nodes.append(Node(w=nodes[x].w + nodes[y].w, l=x, r=y, sym=-1))
internal_idx.append(z)
root = internal_idx[-1] if internal_idx else -1
path = []
dfs_build_codes(root, nodes, sym_list, path)
return root
if __name__ == "__main__":
syms = [
Symbol('A', 5),
Symbol('B', 9),
Symbol('C', 12),
Symbol('D', 13),
Symbol('E', 16),
Symbol('F', 45)
]
root = build_huffman_codes(syms)
print(f"哈夫曼树根节点下标：{root}")
for sym in syms:
print(f"字符 '{sym.ch}' (频率 {sym.freq})：编码 {sym.code}") A．nodes.append(Node(nodes[x].w + nodes[y].w, x, y, -1)) internal_idx.append(z) |
B．nodes.append(Node(nodes[x].w + nodes[y].w, x, y, 1)) internal_idx.append(z) |
C．nodes.append(Node(nodes[x-1].w + nodes[y].w, x, y, 1)) internal_idx.append(z) |
D．nodes.append(Node(nodes[x+1].w + nodes[y].w, x, y, 1)) internal_idx.append(z) |
以下代码中，构造函数被调用的次数是1次。
class Test:
init_count = 0
def __init__(self):
Test.init_count += 1
print("T ", end="")
def __copy__(self):
print("（拷贝构造，不触发__init__）", end="")
new_obj = Test.__new__(Test)
return new_obj
if __name__ == "__main__":
a = Test()
import copy
b = copy.copy(a) | A．正确 | B．错误 |
在二叉排序树（Binary Search Tree, BST）中，假设节点值互不相同。给定如下搜索函数，以下说法 一定正确的是（ ）。
class Node: def __init__(self, val=0, left=None, right=None): self.val = val self.left = left self.right = right def find(root, x): while root: if root.val == x: return True if x < root.val: root = root.left else: root = root.right return False
| A． 最坏情况下，访问结点数是 O(log n) |
B． 最坏情况下 ，访问结点数是O(n) |
| C． 无论如何 ，访问结点数都不超过树高的一半 |
D． 一定比在普通二叉树中搜索快 |
路径覆盖
时间限制：3.0 s
内存限制：512.0 MB
题目描述
给定一棵有 n 个结点的有根树 T ，结点依次以 1 , 2, . , n 编号 ，根结点编号为 1 。方便起见 ，编号为 i 的结点称为结点 i。
初始时 T 中的结点均为白色。你需要将 T 中的若干个结点染为黑色，使得所有叶子到根的路径上至少有一个黑色结
点。将结点 i 染为黑色需要代价 c，你需要在满足以上条件的情况下，最小化染色代价之和。
叶子是指 T 中没有子结点的结点。
输入格式
第一行，一个正整数 n，表示结点数量。
输出格式
一行，一个整数，表示在满足所有叶子到根的路径上至少有一个黑色结点的前提下，染色代价之和的最小值。
输入样例 1
4 1 2 3 5 6 2 3
输出样例 1
2
输入样例 2
7 1 1 2 2 3 3 64 16 15 4 3 2 1
输出样例 2
10
数据范围
