华为0419暑期实习笔试C++参考

第一道是 1、服务器能耗统计
代码如下

int main()
{
	int n;
	cin >> n;
	int start = 1000001;
	int end = 0;
	vector<int> diff(10005, 0);
	for (int i = 0; i < n; i++) //计算差分数组
	{
		int a, b;
		cin >> a >> b;
		start = min(start, a);
		end = max(end, b);
		diff[a]++;
		diff[b + 1]--;
	}

	vector<int> res(end + 1, 0);
	res[0] = diff[0];
	for (int i = start; i <= end; i++)//计算差分数组的前缀和数组。这样就得到了每个时间片的状态
	{
		res[i] = res[i - 1] + diff[i];
	}

	int result = 0;
	for (int i = start; i <= end; i++) //根据前缀和数组的值，判断当前服务器的状态
	{
		if (res[i] == 0) result += 1;
		else if (res[i] == 1) result += 3;
		else
		{
			result += 4;
		}
	}

	cout << result << endl;
	return 0;
}

思路 是差分数组和前缀和解决

第二题是 2.树上逃离
代码如下：

#include <iostream>
#include <deque>
#include <unordered_set>
#include <unordered_map>
#include <vector>
#include <string>

using namespace std;

int main() {
    // 读入节点数量
    int n;
    cin >> n;

    // 存储节点之间的边
    unordered_map<int, vector<int>> nxs;
    // 读入边的数量并添加到邻接表中
    int edge;
    cin >> edge;
    for (int i = 0; i < edge; i++) {
        int u, v;
        cin >> u >> v;
        // 如果该节点不存在，先将其添加到邻接表中
        if (nxs.find(u) == nxs.end()) {
            nxs[u] = vector<int>();
        }
        if (nxs.find(v) == nxs.end()) {
            nxs[v] = vector<int>();
        }
        // 添加双向边
        nxs[u].push_back(v);
        nxs[v].push_back(u);
    }

    // 存储需要避开的节点
    unordered_set<int> blocks;
    // 读入需要避开的节点
    int block;
    cin >> block;
    for (int i = 0; i < block; i++) {
        int b;
        cin >> b;
        blocks.insert(b);
    }

    // 使用双端队列作为广度优先搜索的队列
    deque<vector<int>> q;
    // 如果起点不需要避开，则将其加入队列中
    if (blocks.find(0) == blocks.end()) {
        q.push_back({0, 0, {0}});
    }
    // 存储已经访问过的节点
    unordered_set<int> vst;
    vst.insert(0);
    while (!q.empty()) {
        // 从队列中取出一个节点
        int node = q.front()[0];
        int w = q.front()[1];
        vector<int> path = q.front()[2];
        q.pop_front();
        // 如果该节点是叶子节点，则输出路径并结束程序
        if (node != 0 && nxs[node].size() == 1) {
            string res;
            for (int i = 0; i < path.size(); i++) {
                res += to_string(path[i]);
                if (i != path.size() - 1) {
                    res += "->";
                }
            }
            cout << res << endl;
            return 0;
        }
        // 遍历当前节点的邻居节点
        for (int i = 0; i < nxs[node].size(); i++) {
            int nx = nxs[node][i];
            // 如果邻居节点没有被访问过且不需要避开，则将其加入队列中
            if (vst.find(nx) == vst.end() && blocks.find(nx) == blocks.end()) {
                vst.insert(nx);
                vector<int> new_path = path;
                new_path.push_back(nx);
                q.push_back({nx, w + 1, new_path});
            }
        }
    }
    // 如果没有找到叶子节点，则输出NULL
    cout << "NULL" << endl;
    return 0;
}

思路是最短路径，层序遍历找到最短的路径输出。