小杨的握手问题
时间限制：1.0 s
内存限制：128.0 MB
问题描述
小杨的班级里共有N名同学，学号从0至N-1。
某节课上，老师安排全班同学进行一次握手游戏，具体规则如下：老师安排了一个顺序，让全班N名同学依次进入教室。每位同学进入教室时，需要和已经在教室内且学号小于自己的同学握手。
现在，小杨想知道，整个班级总共会进行多少次握手。
提示：可以考虑使用归并排序进行降序排序，并在此过程中求解。
输入描述
输入包含2行。第一行一个整数N，表示同学的个数；第二行N个用单个空格隔开的整数，依次描述同学们进入教室的顺序，每个整数在0~N-1之间，表示该同学的学号。
保证每位同学会且只会进入教室一次。
输出描述
输出一行一个整数，表示全班握手的总次数。
特别提醒
在常规程序中，输入、输出时提供提示是好习惯。但在本场考试中，由于系统限定，请不要在输入、输出中附带任何提示信息。
样例输入 1
4
2 1 3 0
样例输出 1
2
样例解释 1
2号同学进入教室，此时教室里没有其他同学。
1号同学进入教室，此时教室里有2号同学。1号同学的学号小于2号同学，因此他们之间不需要握手。
3号同学进入教室，此时教室里有1,2号同学。3号同学的学号比他们都大，因此3号同学需要分别和另外两位同学握手。
0号同学进入教室，此时教室里有1,2,3号同学。0号同学的学号比他们都小，因此0号同学不需要与其他同学握手。
综上所述全班一共握手0+0+2+0=2次。
样例输入 2
6
0 1 2 3 4 5
样例输出 2
15
样例解释 2
全班所有同学之间都会进行握手，因为每位同学来到教室时，都会发现他的学号是当前教室里最大的，所以他需要和教室里的每位其他同学进行握手。
数据规模
对于30%的测试点，保证N≤100。
对于所有测试点，保证2≤N≤3×105。
相似题推荐
下面代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。
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
数据范围
