执行如下代码，会输出 钢琴：叮咚叮咚 和 吉他：咚咚当当 。这体现了面向对象编程的（ ）特性。

class Instrument {
public:
	virtual void play() {
		cout << "乐器在演奏声音" << endl;
	}
	virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
	void play() override {
		cout << "钢琴：叮咚叮咚" << endl;
	}
};
class Guitar : public Instrument {
public:
	void play() override {
		cout << "吉他：咚咚当当" << endl;
	}
};
int main() {
	Instrument* instruments[2];
	instruments[0] = new Piano();
	instruments[1] = new Guitar();
	for (int i = 0; i < 2; ++i) {
		instruments[i]->play();
	}
	for (int i = 0; i < 2; ++i) {
		delete instruments[i];
	}
	return 0;
}

在二叉排序树（Binary Search Tree, BST）中，假设节点值互不相同。给定如下搜索函数，以下说法一定正确的是（ ）。

bool find(Node* root, int x) {
	while (root) {
		if (root->val == x) return true;
		root = (x < root->val) ? root->left : root->right;
	}
	return false;
}

0/1 背包（每件物品最多选一次）问题通常可用一维动态规划求解，核心代码如下。则下面说法正确的是（）。

for each item (w, v):
	for (int j = W; j >= w; --j)
		dp[j] = max(dp[j], dp[j-w] + v);

下面代码实现了哈夫曼编码，则横线处应填写的代码是（ ）。

#include <vector>
#include <string>
#include <algorithm>
using namespace std;

struct Symbol {
    char ch;        //字符
    long long freq; //频率
    string code;    //哈夫曼编码
};

struct Node {
    long long w;    //权值
    int l, r;       //左右孩子（节点下标），-1 表示空
    int sym;        //叶子对应符号下标；内部节点为 -1
    Node(long long _w = 0, int _l = -1, int _r = -1, int _sym = -1)
        : w(_w), l(_l), r(_r), sym(_sym) {}
};

// 从 A(leafIdx) 和 B(internalIdx) 的队首取最小的一个节点下标
static int PopMinNode(const vector<Node>& nodes,
                      const vector<int>& leafIdx, int n, int& pA,
                      const vector<int>& internalIdx, int& pB)
{
    if (pA < n && (pB >= (int)internalIdx.size() ||
        nodes[leafIdx[pA]].w <= nodes[internalIdx[pB]].w))
    {
        return leafIdx[pA++];
    }
    else
    {
        return internalIdx[pB++];
    }
}

// DFS 生成编码（左 0，右 1）
static void DFSBuildCodes(int u, const vector<Node>& nodes, Symbol sym[], string& path)
{
    if (u == -1)
        return;
    if (nodes[u].sym != -1) // 叶子
    {
        sym[nodes[u].sym].code = path;
        return;
    }
    path.push_back('0');
    DFSBuildCodes(nodes[u].l, nodes, sym, path);
    path.pop_back();

    path.push_back('1');
    DFSBuildCodes(nodes[u].r, nodes, sym, path);
    path.pop_back();
}

int BuildHuffmanCodes(Symbol sym[], int n)
{
    for (int i = 0; i < n; i++)
        sym[i].code.clear();

    if (n <= 0)
        return -1;

    // 只有一个字符：约定编码为 "0"
    if (n == 1)
    {
        sym[0].code = "0";
        return 0;
    }

    vector<Node> nodes;
    nodes.reserve(2 * n);

    // 1) 建立叶子节点
    vector<int> leafIdx(n);
    for (int i = 0; i < n; i++)
    {
        leafIdx[i] = (int)nodes.size();
        nodes.push_back(Node(sym[i].freq, -1, -1, i));
    }

    // 2) 叶子按权值排序（A 队列）
    sort(leafIdx.begin(), leafIdx.end(),
         [&](int a, int b)
         {
             if (nodes[a].w != nodes[b].w)
                 return nodes[a].w < nodes[b].w;
             return nodes[a].sym < nodes[b].sym; // 稳定一下
         });

    // B 队列（内部节点下标队列）
    vector<int> internalIdx;
    internalIdx.reserve(n);
    int pA = 0, pB = 0;

    // 3) 合并 n-1 次
    for (int k = 1; k < n; k++)
    {
        int x = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);
        int y = PopMinNode(nodes, leafIdx, n, pA, internalIdx, pB);
        int z = (int)nodes.size();
        // =====================在此处填写代码=====================
    }

    int root = internalIdx.back();
    // 4) DFS 生成编码
    string path;
    DFSBuildCodes(root, nodes, sym, path);

    return root;
}

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
internalIdx.push_back(z);

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, -1));
leafIdx.push_back(z);

internalIdx.push_back(z);
nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));

nodes.push_back(Node(nodes[x].w + nodes[y].w, x, y, x+y));
leafIdx.push_back(z);

关于以下代码，说法正确的是（ ）。

class Instrument {
public:
	void play() {
		cout << "乐器在演奏声音" << endl;
	}
	virtual ~Instrument() {}
};
class Piano : public Instrument {
public:
	void play() override {
		cout << "钢琴：叮咚叮咚" << endl;
	}
};
class Guitar : public Instrument {
public:
	void play() override {
		cout << "吉他：咚咚当当" << endl;
	}
};
int main() {
	Instrument* instruments[2];
	instruments[0] = new Piano();
	instruments[1] = new Guitar();
	for (int i = 0; i < 2; ++i) {
		instruments[i]->play();
	}
	for (int i = 0; i < 2; ++i) {
		delete instruments[i];
	}
	return 0;
}