2022年春华为机试

前言

本博客是2022华为春季实习机试，时间2h。
本人未参与，但是有同学参与。
我参考着他的题目来写的2道题解（第3道题意有点没理解清晰）。
原题链接

题一：新人考试（100分）

题目描述

有10道2分题，10道4分题，5道8分题，满分100分，答对得分，答错不得分，累计错三道则停止作答结算分数

输入:最终作答者获得分数 n

输出:作答可能的情况总数 m

算法思路

递归

1. 不同层之间共享的信息：（当前答的题号,答错的数量,当前的得分）
2. 结束条件：所有的题号遍历完 || 答错的数量达到限制 || 当前得分等于n

代码实现

#include <iostream>
using namespace std;

// 10分钟
int qs[25] = {2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8};
int n;     //最终得分
int m = 0; //答得情况数
//(当前答的题号,答错的数量,当前的得分)
void dfs(int tp, int er, int sc)
{
    if (tp == 25 || er == 3)
    {
        return;
    }
    if (sc == n)
    {
        m++;
        return;
    }
    dfs(tp + 1, er, sc + qs[tp]); //答对了当前的题
    dfs(tp + 1, er + 1, sc);      //没答对当前的题
}

int main()
{
    cin >> n;
    dfs(0, 0, 0);
    cout << m;
    return 0;
}

---

题二：子树替换（200分）

题目描述

输入：
第一行以数组的形式输入一个层次遍历的树，无子节点则以0标识；

第二行输入从根节点到所替换节点的路径；

第三行输入要替换的子树Q，输入方式同第一行；
示例输入：
第一行：输入[1,2,3,0,5,0,4]
第二行：输入/1/3 (实际例题中节点上的序号可能重复，但路径保证唯一)
第三行：输入[6,7,8]
替换子树要求：替换节点的所有子节点清空；子树Q完全存在于得到的新树；原来的树中与替换节点无关的节点完全保留。 例如上述用树6->7,8(6是根节点，7、8分别为左右子节点)替换\1\3，则得到的新树应为[1,2,6,0,5,7,8]

输出：
不输出空节点，即最终输出[1,2,6,5,7,8]

算法思路

字符串处理
首先这个题输入输出是需要特殊处理的，从字符串->数字
完全二叉树的性质
利用完全二叉树的性质，我们很容易用数组来表达一颗树。
因此，整体思路如下：

1. 字符串预处理，将其转为数组（表达树）
2. 确认被替换的位置（bfs）
3. 替换的字符串预处理，将其转为数组（表达替换树）
4. 在原树数组上赋值，完成替换

代码实现

#include <iostream>
#include <vector>
#include <string>
#include <queue>
using namespace std;
// 40分钟
const int N = 10010;
int s2num[N] = {0};   //树
int sub2num[N] = {0}; //替换者
int subSize = 0;      //替换者个数
int subEnd = 0;       //替换结束位置
int subed = 0;        //被替换者的位置

//字符串变为数字
void str2num(string s, bool isOri)
{
    int j = 1;
    string nu = "";
    if (isOri)
    {
        for (auto i : s)
        {
            if (i == '[')
                continue;
            if (i == ',' || i == ']')
            {
                if (nu != "")
                {
                    s2num[j] = stoi(nu);
                    nu = "";
                    j++;
                }
            }
            //数字
            else if (i != ',')
            {
                nu += i;
            }
        }
    }
    else
    {
        for (auto i : s)
        {
            if (i == '[')
                continue;
            if (i == ',' || i == ']')
            {
                if (nu != "")
                {
                    subSize++;
                    sub2num[j] = stoi(nu);
                    nu = "";
                    j++;
                }
            }
            //数字
            else if (i != ',')
            {
                nu += i;
            }
        }
    }
}
//找到被替换的人
void findSub(string path)
{
    queue<int> path2Num; //路径切割为数字
    string nu;
    int j = 0;
    for (auto i : path)
    {
        //数字
        if (i != '/')
        {
            nu += i;
        }
        if (i == '/' || j == path.size() - 1)
        {
            if (nu != "")
            {
                path2Num.push(stoi(nu));
                nu = "";
            }
        }
        j++;
    }
    queue<int> qt; //放下标
    qt.push(1);    //头肯定在队列
    path2Num.pop();
    while (!path2Num.empty())
    {
        if (s2num[qt.front() * 2] == path2Num.front())
        {
            qt.push(qt.front() * 2);
        }
        if (s2num[qt.front() * 2 + 1] == path2Num.front())
        {
            qt.push(qt.front() * 2 + 1);
        }
        path2Num.pop();
        qt.pop();
    }
    subed = qt.front();
}
//替换
void subing()
{
    queue<int> roots;
    roots.push(subed);
    for (int i = 1; i <= subSize; i++)
    {
        int tp = roots.front();
        roots.push(tp * 2);
        roots.push(tp * 2 + 1);
        s2num[tp] = sub2num[i];
        roots.pop();
    }
    subEnd = (roots.back() - 1) / 2;
}
int main()
{
    string s;
    string path; //替换路径
    string af;
    cin >> s;
    cin >> path;
    cin >> af;
    //树的字符串->成数字
    str2num(s, true);
    //确认被替换的位置
    findSub(path);
    //替换后路径字符串->数字
    str2num(af, false);
    //替换
    subing();
    for (int i = 1; i <= subEnd; i++)
    {
        if (s2num[i] == 0)
            continue;
        cout << s2num[i] << " ";
    }
    return 0;
}