网易2019秋季校园招聘编程题真题集合

1.[编程题] 俄罗斯方块
时间限制：1秒
空间限制：262144K
小易有一个古老的游戏机，上面有着经典的游戏俄罗斯方块。因为它比较古老，所以规则和一般的俄罗斯方块不同。
荧幕上一共有 n 列，每次都会有一个 1 x 1 的方块随机落下，在同一列中，后落下的方块会叠在先前的方块之上，当一整行方块都被占满时，这一行会被消去，并得到1分。
有一天，小易又开了一局游戏，当玩到第 m 个方块落下时他觉得太无聊就关掉了，小易希望你告诉他这局游戏他获得的分数。

输入描述:
第一行两个数 n, m
第二行 m 个数，c1, c2, … , cm ， ci 表示第 i 个方块落在第几列
其中 1 <= n, m <= 1000, 1 <= ci <= n

输出描述:
小易这局游戏获得的分数

输入例子1:
3 9
1 1 2 2 2 3 1 2 3
输出例子1:
2
分析：只要求全部列的最小值就行了。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n,m,ci;
    cin>>n>>m;
    vector<int>data(n);
    for(int i=0;i<m;++i)
    {
        cin>>ci;
        data[ci-1]+=1;//ci从1开始的
    }
    cout<<*min_element(data.begin(),data.end())<<endl;;
    return 0;
}

2.[编程题] 瞌睡
时间限制：1秒
空间限制：262144K
小易觉得高数课太无聊了，决定睡觉。不过他对课上的一些内容挺感兴趣，所以希望你在老师讲到有趣的部分的时候叫醒他一下。你知道了小易对一堂课每分钟知识点的感兴趣程度，并以分数量化，以及他在这堂课上每分钟是否会睡着，你可以叫醒他一次，这会使得他在接下来的k分钟内保持清醒。你需要选择一种方案最大化小易这堂课听到的知识点分值。
输入描述:
第一行 n, k (1 <= n, k <= 105) ，表示这堂课持续多少分钟，以及叫醒小易一次使他能够保持清醒的时间。
第二行 n 个数，a1, a2, … , an(1 <= ai <= 104) 表示小易对每分钟知识点的感兴趣评分。
第三行 n 个数，t1, t2, … , tn 表示每分钟小易是否清醒, 1表示清醒。

输出描述:
小易这堂课听到的知识点的最大兴趣值。

输入例子1:
6 3
1 3 5 2 5 4
1 1 0 1 0 0

输出例子1:
16
分析：其实就是找连续k个数的最大值
1 3 5 2 5 4
0 0 5 0 5 4
1+3+2这是清醒时的值=6.然后找连续k个最大值，5 0 5=10，也就是16；

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n, k, ti;
    cin >> n >> k;
    vector<int>data(n);
    for (int i = 0; i<n; ++i)
        cin >> data[i];
    int sum_1 = 0;
    vector<int>temp_data(n + 1);
    for (int i = 1; i<n + 1; ++i)
    {
        cin >> ti;
        if (ti == 1)
            sum_1 += data[i - 1];
        else
            temp_data[i] = data[i - 1];
        temp_data[i] += temp_data[i - 1];//累加
    }
    int sum_0 = 0;
    for (int i = k; i<n + 1; ++i)
        sum_0 = max(sum_0, temp_data[i] - temp_data[i - k]);//k区间内取最大
    cout << sum_0 + sum_1 << endl;
    return 0;
}

3.[编程题] 丰收
时间限制：1秒
空间限制：262144K
又到了丰收的季节，恰逢小易去牛牛的果园里游玩。
牛牛常说他对整个果园的每个地方都了如指掌，小易不太相信，所以他想考考牛牛。
在果园里有N堆苹果，每堆苹果的数量为ai，小易希望知道从左往右数第x个苹果是属于哪一堆的。
牛牛觉得这个问题太简单，所以希望你来替他回答。

输入描述:
第一行一个数n(1 <= n <= 105)。
第二行n个数ai(1 <= ai <= 1000)，表示从左往右数第i堆有多少苹果
第三行一个数m(1 <= m <= 105)，表示有m次询问。
第四行m个数qi，表示小易希望知道第qi个苹果属于哪一堆。

输出描述:
m行，第i行输出第qi个苹果属于哪一堆。

输入例子1:
5
2 7 3 4 9
3
1 25 11

输出例子1:
1
5
3
分析：其实就是找第一个大于qi的苹果堆。

#include<iostream>
#include<map>
using namespace std;
int main()
{
    int n,ai,m,qi;
    cin>>n;
    map<int,int>data;
    int temp=0;
    for(int i=1;i<n+1;++i)
    {
        cin>>ai;
        temp+=ai;
        data[temp]=i;
    }
    cin>>m;
    for(int i=0;i<m;++i)
    {
        cin>>qi;
        cout<<data.lower_bound(qi)->second<<endl;
    }
    return 0;
}

4.[编程题] 整理房间
时间限制：1秒
空间限制：262144K
又到了周末，小易的房间乱得一团糟。
他希望将地上的杂物稍微整理下，使每团杂物看起来都紧凑一些，没有那么乱。
地上一共有n团杂物，每团杂物都包含4个物品。第i物品的坐标用(ai,bi)表示，小易每次都可以将它绕着(xi,yi)逆时针旋转，这将消耗他的一次移动次数。如果一团杂物的4个点构成了一个面积不为0的正方形，我们说它是紧凑的。
因为小易很懒，所以他希望你帮助他计算一下每团杂物最少需要多少步移动能使它变得紧凑。

输入描述:
第一行一个数n(1 <= n <= 100)，表示杂物的团数。
接下来4n行，每4行表示一团杂物，每行4个数ai, bi，xi, yi, (-104 <= xi, yi, ai, bi <= 104)，表示第i个物品旋转的它本身的坐标和中心点坐标。

输出描述:
n行，每行1个数，表示最少移动次数。

输入例子1:
4
1 1 0 0
-1 1 0 0
-1 1 0 0
1 -1 0 0
1 1 0 0
-2 1 0 0
-1 1 0 0
1 -1 0 0
1 1 0 0
-1 1 0 0
-1 1 0 0
-1 1 0 0
2 2 0 1
-1 0 0 -2
3 0 0 -2
-1 1 -2 0

输出例子1:
1
-1
3
3

例子说明1:
对于第一团杂物，我们可以旋转第二个或者第三个物品1次。

5.[编程题] 表达式求值
时间限制：1秒
空间限制：262144K
今天上课，老师教了小易怎么计算加法和乘法，乘法的优先级大于加法，但是如果一个运算加了括号，那么它的优先级是最高的。例如：
1
2
3
4
1+2*3=7
1*(2+3)=5
1*2*3=6
(1+2)*3=9
现在小易希望你帮他计算给定3个数a，b，c，在它们中间添加”+”， “*”， “(“， “)”符号，能够获得的最大值。

输入描述:
一行三个数a，b，c (1 <= a, b, c <= 10)

输出描述:
能够获得的最大值

输入例子1:
1 2 3

输出例子1:
9
分析：含有1的，就要与次小值相加，然后与后面的值乘。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
    int n=3;
    vector<int>data(n);
    for(int i=0;i<n;++i)
        cin>>data[i];
    sort(data.begin(),data.end());
    int sum=data[0];
    for(int i=1;i<n;++i)
    {
        if(data[i]==1 ||sum==1)
            sum+=data[i];
        else
            sum=sum*data[i];
    }
    cout<<sum<<endl;
    return 0;
}

6.[编程题] 塔
时间限制：1秒
空间限制：262144K
小易有一些立方体，每个立方体的边长为1，他用这些立方体搭了一些塔。
现在小易定义：这些塔的不稳定值为它们之中最高的塔与最低的塔的高度差。
小易想让这些塔尽量稳定，所以他进行了如下操作：每次从某座塔上取下一块立方体，并把它放到另一座塔上。
注意，小易不会把立方体放到它原本的那座塔上，因为他认为这样毫无意义。
现在小易想要知道，他进行了不超过k次操作之后，不稳定值最小是多少。

输入描述:
第一行两个数n,k (1 <= n <= 100, 0 <= k <= 1000)表示塔的数量以及最多操作的次数。
第二行n个数，ai(1 <= ai <= 104)表示第i座塔的初始高度。

输出描述:
第一行两个数s, m，表示最小的不稳定值和操作次数(m <= k)
接下来m行，每行两个数x,y表示从第x座塔上取下一块立方体放到第y座塔上。

输入例子1:
3 2
5 8 5

输出例子1:
0 2
2 1
2 3
分析：最高的与最低的计算风险，等于0则直接返回，否则高的给低的

#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
using namespace std;
int index(vector<int>data, int target)
{
    for (int i = 0; i < data.size(); ++i)
        if (target == data[i])
            return i;
    return 0;
}
int main()
{
    int n = 0, k = 0;
    cin >> n >> k;
    vector<int>high;
    for (int i = 0; i < n; ++i)
    {
        int ai = 0;
        cin >> ai;
        high.push_back(ai);
    }
    int risk = 0;
    int kk = k;
    vector<int>step;
    for (int i = 0; i < k+1; ++i)
    {
        int max_index = index(high, *max_element(high.begin(), high.end()));
        int min_index = index(high, *min_element(high.begin(), high.end()));
        risk = high[max_index] - high[min_index];
        if (risk == 0)
        {
            kk = i;
            break;
        }
        high[max_index] -= 1;
        high[min_index] += 1;
        step.push_back(max_index);
        step.push_back(min_index);
    }
    cout << risk << " " << kk << endl;
    for (int i = 0; i < step.size(); i=i+2)
    {
        cout << step[i]+1 << " " << step[i+1]+1<<endl;
    }
    return 0;

}

7.[编程题] 小易的字典
时间限制：1秒
空间限制：262144K
小易在学校中学习了关于字符串的理论, 于是他基于此完成了一个字典的项目。
小易的这个字典很奇特, 字典内的每个单词都包含n个’a’和m个’z’, 并且所有单词按照字典序排列。
小易现在希望你能帮他找出第k个单词是什么。

输入描述:
输入包括一行三个整数n, m, k(1 <= n, m <= 100, 1 <= k <= 109), 以空格分割。

输出描述:
输出第k个字典中的字符串，如果无解，输出-1。

输入例子1:
2 2 6

输出例子1:
zzaa

例子说明1:
字典中的字符串依次为aazz azaz azza zaaz zaza zzaa
分析：排列组合，n个’a’和m个’z’，只能组成$C_{n+m}^n$，记为count(n+m,n) 个单词。
思路：
假设第一个字符为a，则剩下n-1个’a’和m个’z’组成的子序列只能构成count(n-1+m,n-1)个单词，且是字典中前count(n-1+m,n-1)个单词。
比较k和count(n-1+m,n-1)，若k小，说明k是前count(n-1+m,n-1)个单词，则第一个字符必为’a’。子问题化为在子序列(n-1个’a’和m个’z’)找到第k个单词
若k大，则说明第一个字符必为’z’,单词是以’z’开头的单词中的第k-count(n-1+m,n-1)个。子问题化为在子序列(n个’a’和m-1个’z’)找到第k-count(n+m-1,m-1)个单词。
eg:n=2,m=2,k=5
假设第一个字符为a,则剩下1个a,2个z只能构成3个单词，且是字典中前3个单词(aamm,amam,amma)
k>3，则第一个字符必为z。原问题化为在n=2,m=1,k=2，即在剩下2个a，1个z中找到第2个单词

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
void process(int n, int m, long long k)
{
    vector<char>data;
    while (n&&m)
    {
        long long count = 1;
        for (int i = 0; i <n - 1; ++i)
        {
            count *= n - 1 + m - i;
            count /= i + 1;
            if (count > k)break;//累乘溢出
        }
        if (k <= count)
        {
            data.push_back('a');
            --n;
        }
        else
        {
            data.push_back('z');
            --m;
            k = k - count;
        }
    }
    if (k != 1)
    {
        cout << -1;
        return;
    }
    while (n--)data.push_back('a');
    while (m--)data.push_back('z');
    for(auto i:data)
        cout<<i;
    cout<<endl;
}
int main()
{
    int n, m;
    long long k;
    cin >> n >> m >> k;
    process(n, m, k);
    system("pause");
    return 0;
}