2022-09-13-百度笔试-80

21号约了9月24号一面

105 min
1、8、9、10、11、12、14

30选择 * 2' 38min

哪个不是抽样方法 A
A. 跳跃抽样、B. 渐进抽样 C. 分层抽样 D. 简单随机抽样
ABCD哪个方向的特征值最大？

图片说明

“aaab” Next数组是 D（1231）？
A1123
B0123
C1211
D1231
python 哪个错 A？
A. 定义对象的私有变量时如果与公有变量相同，那也算是新的私有变量
B. 公有变量在 __init__ 方法中声明，每个对象都有
C. 私有变量在创建后声明，只有当前对象有此变量
D. None表示...
文字有局部一致性，这是文本检测的难点 ( )
```
 对
```
查看已安装了与ssh相关的所有软件包的命令:

A. rpm -qa | grep ssh
B. rpm -qa ssh
C. rpm -qa
D. rpm -q ssh
```
  6A
```
10位电话忘了一位，随机打，超过3次才打对的概率是 0.7
不属于基于回归的文本检测方法的是哪个 D
EAST CTPN TextBox MSR
H(k)=k513 链地址法，长16，存储 1、14、27、79、68、55、27、6、84、7、10、23、24 顺序忘了，做不出来了
平均查找次数 2.75、1.5、1.75、2.5 没算出来
多元线性回归分析，which are true ？
A. F检验时F值越大随机误差的影响越大
B. F检验表明线性关系显著，则至少有一个自变量与因变量线性关系显著
C. F值越大，因变量与自变量线性关系越显著
D. F值越大，相关系数值越小

BC？

TCP流量控制机制 C
控制访问链表、端口限制、滑动窗口、策略
S=(D,R), a,b,c,d,e 的顺序栈关系集合（这是第一题。。。）可能为 (?)

A. {(a,b),(b,c),(c,d),(d,e),(e,a)}
B. {(a,b),(b,c),(c,,d)}
C. {(e,b),(b,c),(c,a),(a,d)}
D. {(a,b),(c,d),(e,a),(b,c)}

搜集数据，map reduce任务包括
数据导入、统一化、压缩、备份

        abcd

多层感知机 MLP 10个输入神经元，5个隐藏神经元，1个输出神经元，输入隐藏层与隐藏输出层的权重矩阵分别为
A 1*5，5*10
B 10*5，5*1
C 5*1，10*5
D 5*10，1*5
```
    B
```
在类A的成员函数里可以通过 A::b来访问类的静态成员 ( )
```
        对
```

2编程 * 20' 100% 40min

1. 40min

图片说明

// 输入三个整数n, m, t，输入n个数表示第一个数组，m个数表示第二个数组
// 从两个数组的第一个数开始连续地分别拿 k1 和 k2 个数，使得这些数的和小于等于 t
// 求 max(k1+k2)
// 输入
// 5 3 15
// 1 3 2 9 1
// 4 6 1
// 输出
// 5
// 注：1+3 + 4+6+1 = 15<=15 拿到5个数

// 1 ≤ n, m ≤ 30000, 1 ≤ t, ai, bi ≤ 1e9

// 20' 100% 40min
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main()
{
    int n, m;
    unsigned long long int t, a, b, r;
    cin >> n >> m >> t;
    vector<unsigned long long> sa(n + 1, 0), sb(m + 1, 0);
    for (int i = 1; i <= n; i++)
    {
        cin >> sa[i];
        sa[i] += sa[i - 1];
    }
    for (int i = 1; i <= m; i++)
    {
        cin >> sb[i];
        sb[i] += sb[i - 1];
    }
    // sb[m]+=t;
    int maxq = 0;
    for (int i = 0; i <= n; i++)
    {
        if (sa[i] >= t)
        {
            if (sa[i] == t && maxq < i)
                maxq = i;
            break;
        }
        r = t - sa[i];

        // 18、55%
        // if(sb[m]<=r){
        //     maxq=max(maxq,i+m);
        // }else{
        //     // upper要用algorithm!!! lower_bound 不需要
        //     int bi = upper_bound(sb.begin(),sb.end(),r)-sb.begin();
        //     maxq=max(maxq,i+bi);
        // }
        // cout<<"i= "<<i<<", "<<it-sb.begin()<<", r= "<<r<<", sa[i]="<<sa[i]<<"\n";

        int li = 0, ri = m;
        while (li < ri)
        {
            int mid = (li + ri) / 2;
            // cout<<"mid= "<<mid<<", sb[mid]= "<<sb[mid]<<", li= "<<li<<", ri= "<<ri<<"\n";
            if (sb[mid] < r)
            {
                li = mid;
                // cout<<"sb[mid+1]= "<<sb[mid+1]<<", mid+1="<<mid+1<<"\n";
                if (mid < ri && sb[mid + 1] < r)
                    li++;
                else if (sb[mid + 1] == r)
                {
                    li++;
                    break;
                }
                else if (sb[mid + 1] > r)
                    break;
                // cout<<"li= "<<li<<", sb[li]= "<<sb[li]<<"\n";
            }
            else if (sb[mid] == r)
            {
                li = mid;
                break;
            }
            else
            {
                ri = mid - 1;
            }
        }
        maxq = max(maxq, i + li);
        // // cout<<"i= "<<i<<", "<<li<<", r= "<<r<<", sa[i]="<<sa[i]<<"\n";
    }
    cout << maxq;
    return 0;
}

2. 27min 100% 20'

图片说明

// 给数组排m次序
// 输入一 n 个数组成的数组，进行了m次操作
// 每次操作由 a b 两个数定义
// a==1 表示把数组的前 b 个数从小到大排序
// a==2 表示把数组的前 b 个数从大到小排序。
// 输出m次操作后的数组
// 1≤n,m≤2x1e5
// n个整数属于 [-1e9,1e9]范围
// 1≤a≤2，1≤b≤n
// 输出描述
//
// 输入
// 4 2  （n、m）
// 1 2 4 3 （n个数）
// 2 3 （第一次操作，得到 4 2 1 3）
// 1 2 （第二次操作）
// 输出
// 2 4 1 3

// 20' 27min 100%
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
using namespace std;

void f(vector<int> &a, const vector<vector<int>> &o, const vector<int> &maxO, int i)
{
    if (maxO[i] != i)
    {
        f(a, o, maxO, maxO[i]); // maxO[i] 表示 i 前面最近的其 b 比 i 处的 b 要大的位置的下标，由单调栈求出来
    }
    if (o[i][0] == 1)
        sort(a.begin(), a.begin() + o[i][1]);
    else
        sort(a.begin(), a.begin() + o[i][1], greater<int>());
    return;
}

int main()
{
    int n, m;
    cin >> n >> m;
    vector<int> a(n);
    vector<vector<int>> o(m, vector<int>(2, 0));
    for (int i = 0; i < n; i++)
        cin >> a[i];
    for (int i = 0; i < m; i++)
        cin >> o[i][0] >> o[i][1];
    vector<int> maxO(m, 0); // 表示 i 前面最近的其 b 比 i 处的 b 要大的位置的下标，如果没有，则是本身 i
    stack<int> st;
    st.push(0);
    for (int i = 1; i < m; i++)
    { // the only bug: it is 'm' not 'n' !!!
        while (st.empty() == false && o[st.top()][1] < o[i][1])
            st.pop();
        if (st.empty())
            maxO[i] = i;
        else
            maxO[i] = st.top();
        st.push(i);
    }
    f(a, o, maxO, m - 1);
    for (auto &i : a)
        cout << i << " ";
    return 0;
}

#百度笔试##23秋招##23届##百度##23届秋招笔面经#