树上游走
时间限制：1.0 s
内存限制：512.0 MB
题面描述
小杨有一棵包含无穷节点的二叉树（即每个节点都有左儿子节点和右儿子节点；除根节点外，每个节点都有父节点），其中根节点的编号为 1 ，对于节点 i ，其左儿子的编号为 2×i，右儿子的编号为 2×i+1。
小杨会从节点 s 开始在二叉树上移动，每次移动为以下三种移动方式的任意一种：
第1种移动方式： 如果当前节点存在父亲节点，向上移动到当前节点的父亲节点，否则不移动；
第2种移动方式： 移动到当前节点的左儿子；
第3种移动方式： 移动到当前节点的右儿子。
小杨想知道移动 n 次后自己所处的节点编号。数据保证最后的所处的节点编号不超过1012。
输入格式
第一行包含一个正整数 n,s，代表移动次数和初始节点编号。
第二行包含一个长度为 n 且仅包含大写字母 U,L,R 的字符串，代表每次移动的方式，其中U 代表第1种移动方式，L 代表第2种移动方式，R 代表第3种移动方式。
输出格式
输出一个正整数，代表最后所处的节点编号。
输入样例
3 2 URR
输出样例
7
样例解释
小杨的移动路线为 2-1-3-7。
对于全部数据，保证有1≤n≤106,1≤s≤1012。
相似题推荐
下面代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。
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
数据范围
