华为笔试2021.9.11

牛客帖子汇总的

求神经网络的最短执行时间

给出N个节点，每个节点的信息包含该节点执行时间、下一个节点列表。
有向无环图求一个拓扑排序

#include <bits/stdc++.h>
using namespace std;
//邻接表建图
vector<vector<int>> g;
//构建cost
vector<int> cost;
//记录指向每个节点的次数，入度矩阵
vector<int> cnt; 
//记录是否被访问
vector<bool> visit;
int sum;
void process(int idx, string s)
{
    int i = 0;
    while (s[i] == ' ')
        i++;
    string f;
    //不要最开始的name
    while (i < s.size() && s[i] == ' ') i++;
    while (i < s.size() && s[i] != ' ')
        f += s[i++]; //获取第一个cost
    int c = stoi(f);
    cost[idx] = c;
    //获取指向的id
    while (i < s.size())
    {
        while (i < s.size() && s[i] == ' ')
            i++; //跳过空格
        f = "";
        while (i < s.size() && s[i] != ' ')
            f += s[i++]; //获取指向的节点
        int to = stoi(f);
        g[idx].push_back(to);
        cnt[to]++;
    }
}

void print()
{
    for (int i = 0; i < g.size(); ++i)
    {
        for (int j = 0; j < g[i].size(); ++j)
        {
            cout << g[i][j] << ' ';
        }
        cout << endl;
    }
    cout << "the cost is  " << endl;
    for (int i = 0; i < cost.size(); ++i)
    {
        cout << cost[i] << " ";
    }
    cout << endl;
    cout << "the cnt is: ";
    for (int i = 0; i < cnt.size(); ++i)
    {
        cout << cnt[i] << " ";
    }
    cout << endl;
}
int dfs(int idx)
{
    // cout<<"the cur idx is: "<<idx<<endl;
    int ans = 0;
    visit[idx] = true;
    for (int i = 0; i < g[idx].size(); ++i)
    {
        int nxt = g[idx][i];
        if (!visit[nxt])
            ans = max(ans, dfs(g[idx][i]));
    }
    visit[idx] = false;
    return ans + cost[idx];
}

int main()
{
    int n;
    sum = 0;
    cin >> n;//多少节点
    g = vector<vector<int>>(n);
    cost = vector<int>(n);
    cnt = vector<int>(n);
    visit = vector<bool>(n, false);
    string s;
    for (int i = 0; i < n; ++i)
    {
        cin >> s;
        string ss;
        //处理输入
        getline(cin, ss);
        process(i, ss);
    }
    // print();
    //要是这个网络中的点是孤点 既不 也不 那就单独算
    int ans = 0;
    queue<int> q;
    for (int i = 0; i < n; ++i)
    {
        if (cnt[i] == 0)
            q.push(i);
    }
    while (!q.empty())
    {
        int i = q.front();
        ans = max(ans, dfs(i));
        q.pop();
    }
    cout << ans;
    return 0;
}

内存管理

剩余的最大内存块。给N个内存块，M个申请列表，求最后最多能剩下多少没被使用的内存块。

#include <iostream>
using namespace std;
int n, m;
int num[55], need[20], sum[40000];
int f[55][40000];
int rec[55][40000];
int top, stop;
//x位当前第几块内存块，y记录使用了的need
int search(int x, int y)
{
    if (x == top + 1)
    {
        if (y != stop)
            return -0x7fffffff / 3;
        return 0;
    }
    if (rec[x][y])
        return f[x][y];
    //f和rec记忆化数组，f代表当前值，rec标识使用过
    int &ans = f[x][y];
    rec[x][y] = 1;
    ans = search(x + 1, y) + num[x];//交给下一个块处理，当前块不用
    int s = stop - y;//初始s是全选，哪位是1表示剩哪个need没有被使用

    for (int i = s; i; i = (i - 1) & s)
    {
        //如果此类need合并方法小于当前内存块
        if (sum[i] <= num[x])
        {
            //当前块被使用，y|i标记使用过的need
            ans = max(ans, search(x + 1, y | i));
        }
    }
    return ans;
}
//
int main()
{
    //输入有多少种内存块
    cin >> n;
    for (int i = 0; i < n; i++)
    {
        int a, b;
        cin >> a >> b;
        //记录有多少块
        for (int j = 0; j < a; j++)
            num[++top] = b;
    }
    //输入需要多少块
    cin >> m;
    for (int i = 1; i <= m; i++)
        cin >> need[i];
    //1向左位移m位，2^m次方-1
    // 11111 m个1
    //need所有得排列组合方式
    stop = (1 << (m)) - 1;
    for (int i = 1; i <= stop; i++){
        for (int j = m; j >= 1; j--){
            if (i & (1 << (j - 1))){
                sum[i] = sum[i - (1 << (j - 1))] + need[j];
                break;
            }
        }
    }
    int ans = search(1, 0);
    if (ans < 0)
        printf("-1\n");
    else
        printf("%d\n", ans);
    return 0;
}

2个数组里相同公差的最长等差数列

#include<iostream>
#include<map>
#include<vector>
#include<sstream>
using namespace std;
/*
1 2 3 4 5
2 4 6 8
输出：
3
*/
int get_max_seq(vector<int>& s1, vector<int>& s2){
    map<int,int> cnt_s1;
    map<int,int> cnt_s2;
    vector<int> nums;
    for(int i=0;i<s1.size();++i){
        for(int j=i+1;j<s1.size();++j){
            cnt_s1[s1[j]-s1[i]]+=1;
        }
    }
    for(int i=0;i<s2.size();++i){
        for(int j=i+1;j<s2.size();++j){
            cnt_s2[s2[j]-s2[i]]+=1;
        }
    }
    int ans=0;
    for(auto iter:cnt_s1){
        map<int,int>::iterator iter2=cnt_s2.find(iter.first);
        if(iter2!=cnt_s2.end()){
            ans=max(ans,min(iter.second,iter2->second));
        }
    }

    cout<<"s1"<<endl;
    for(auto iter:cnt_s1){
        cout<<iter.first<<" "<<iter.second<<endl;
    }
    cout<<"s2"<<endl;

    for(auto iter:cnt_s2){
        cout<<iter.first<<" "<<iter.second<<endl;
    }
    return ans;
}
int main(){
    vector<int> s1;
    vector<int> s2;
    string tmp;
    int tmp_i;
    getline(cin,tmp);
    istringstream input1(tmp);
    // cout<<tmp<<endl;

    while(input1>>tmp_i){
        s1.emplace_back(tmp_i);
    }
    getline(cin,tmp);
    // cout<<tmp<<endl;
    istringstream input2(tmp);

    while(input2>>tmp_i){
        s2.emplace_back(tmp_i);
    }
    int ans=0;
    ans=get_max_seq(s1,s2);
    cout<<ans<<endl;
    // for(auto x:s1){
    //     cout<<x<<" ";
    // }
    // cout<<endl;
    // for(auto x:s2){
    //     cout<<x<<" ";
    // }
    // cout<<endl;

    return 0;
}