网易2018校招内推编程题集合 详解

版权声明：听说这里让写版权声明～～～ https://blog.csdn.net/f_zyj/article/details/79244490

##编程题
###一、彩色的砖块
####描述：
小易有一些彩色的砖块。每种颜色由一个大写字母表示。各个颜色砖块看起来都完全一样。现在有一个给定的字符串 $s$， $s$ 中每个字符代表小易的某个砖块的颜色。小易想把他所有的砖块排成一行。如果最多存在一对不同颜色的相邻砖块,那么这行砖块就很漂亮的。请你帮助小易计算有多少种方式将他所有砖块排成漂亮的一行。(如果两种方式所对应的砖块颜色序列是相同的,那么认为这两种方式是一样的。)
例如: $s = "ABAB"$，那么小易有六种排列的结果：
$"AABB","ABAB","ABBA","BAAB","BABA","BBAA"$
其中只有 $"AABB"$ 和 $"BBAA"$ 满足最多只有一对不同颜色的相邻砖块。
####输入描述：
输入包括一个字符串 $s$，字符串 $s$ 的长度 $length(1 ≤ length ≤ 50)$， $s$ 中的每一个字符都为一个大写字母( $A$ 到 $Z$)。
####输出描述：
输出一个整数,表示小易可以有多少种方式。
####输入样例：
$ABAB$
####输出样例：
$2$

####题解：
题目中说，当至多只有一对不同颜色相邻，那么说明只有当序列中不同字母数小于等于 $2$ 时才有可能是漂亮的，所以我们直接用集合来做，按个插入字母，最后看看有几个不同字母即可。
####代码：

#include <bits/stdc++.h>

using namespace std;

string s;
set<char> v;

int main()
{
    while (cin >> s)
	{
        for (int i = 0; i < s.size(); i++)
		{
            v.insert(s[i]);
        }
        
        int cnt = v.size();
        if (cnt > 2)
        {
            cout << 0 << endl;
        }
        else if (cnt == 2)
        {
            cout << 2 << endl;
        }
        else
        {
            cout << 1 << endl;
        }
    }
    
    return 0;
}

###二、等差数列
####描述：
如果一个数列 $S$ 满足对于所有的合法的 $i$，都有 $S[i + 1] = S[i] + d$，这里的 $d$ 也可以是负数和零，我们就称数列 $S$ 为等差数列。
小易现在有一个长度为 $n$ 的数列 $x$，小易想把 $x$ 变为一个等差数列。小易允许在数列上做交换任意两个位置的数值的操作，并且交换操作允许交换多次。但是有些数列通过交换还是不能变成等差数列，小易需要判别一个数列是否能通过交换操作变成等差数列
####输入描述：
输入包括两行,第一行包含整数 $n(2 ≤ n ≤ 50)$,即数列的长度。
第二行 $n$ 个元素 $x[i](0 ≤ x[i] ≤ 1000)$,即数列中的每个整数。
####输出描述：
如果可以变成等差数列输出 $"Possible"$,否则输出 $"Impossible"$。
####输入样例：
$3$
$3\ 1\ 2$
####输出样例：
$Possible$

####题解：
这个题我们可以直接排序，因为如果是等差数列只有两种序列情况，要么是升序，要么是降序，所以我们先排序，然后求前两者差，然后判断后边相邻数的差是否等于前两者的差即可。
####代码：

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 55;

int n;
int x[MAXN];

string solve()
{
    sort(x, x + n);
    
	int a = x[1] - x[0];
    for (int i = 1; i < n; i++)
	{
        if (a != x[i] - x[i - 1])
		{
			return "Impossible";
        }
    }
    
    return "Possible";
}

int main()
{
    cin >> n;
    for (int i = 0; i < n; i++)
	{
        cin >> x[i];
    }
    
    cout << solve() << endl;
    
    return 0;
}

###三、交错 $01$ 串
####描述：
如果一个 $01$ 串任意两个相邻位置的字符都是不一样的,我们就叫这个 $01$ 串为交错 $01$ 串。例如:$ “1”,“10101”,“0101010”$ 都是交错 $01$ 串。
小易现在有一个 $01$ 串 $s$,小易想找出一个最长的连续子串,并且这个子串是一个交错 $01$ 串。小易需要你帮帮忙求出最长的这样的子串的长度是多少。
####输入描述：
输入包括字符串 $s$, $s$的长度 $length(1 ≤ length ≤ 50)$,字符串中只包含 $'0'$ 和 $'1'$。
####输出描述：
输出一个整数,表示最长的满足要求的子串长度。
####输入样例：
$111101111$
####输出样例：
$3$

####题解：
这个题十分简单，扫描一遍序列，然后计数，当相邻不同时，计数加加，当相邻相同时，重新计数即可。
####代码：

#include <bits/stdc++.h>

using namespace std;

string s;

int main()
{
    while (cin >> s)
	{
        int ans = 1, cnt = 1;
        for (int i = 1; i < s.size(); i++) 
		{
            if (s[i] != s[i - 1])
			{
                cnt++;
            }
			else 
			{
				ans = max(ans, cnt);
                cnt = 1;
            }
        }
        ans = max(ans, cnt);
        
        cout << ans << endl;
    }
    
    return 0;
}

###四、操作序列
####描述：
小易有一个长度为 $n$ 的整数序列, $a_1,...,a_n$。然后考虑在一个空序列 $b$ 上进行 $n$ 次以下操作:
1、将 $a_i$ 放入 $b$ 序列的末尾
2、逆置 $b$ 序列
小易需要你计算输出操作 $n$ 次之后的 $b$ 序列。
####输入描述：
输入包括两行,第一行包括一个整数 $n(2 ≤ n ≤ 2*10^5)$,即序列的长度。
第二行包括 $n$ 个整数 $a_i(1 ≤ a_i ≤ 10^9)$,即序列 $a$ 中的每个整数,以空格分割。
####输出描述：
在一行中输出操作 $n$ 次之后的 $b$ 序列,以空格分割,行末无空格。
####输入样例：
$4$
$1\ 2\ 3\ 4$
####输出样例：
$4\ 2\ 1\ 3$
####题解：
这个题看着挺唬人，但是实际上就是一个规律题，自己手写几组数据就能很容易发现规律，比方说 $6\ 1\ 2\ 3\ 4\ 5\ 6$，结果便是 $6\ 4\ 2\ 1\ 3\ 5$，前半部分是递减，后半部分是递增，每次增（减） $2$；再比方说 $5\ 1\ 2\ 3\ 4\ 5$，结果便是 $5\ 3\ 1\ 2\ 4$，前 $\frac{n + 1}{2}$ 个是递减，后部分是递增，每次依然是增（减） $2$，如此这般，规律便十分清楚了，直接输出即可，当然，我们这个题序列并不是按照 $1 \sim n$ 的自然序列，但是道理是一样的，我们将这个规律看作是序列下标的规律即可。
####代码：

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 2e5 + 10;

int n;
int a[MAXN];

int main()
{
    cin >> n;
    
    for (int i = 1; i <= n; i++)
	{
        cin >> a[i];
    }
    
    if (n & 1)
	{
        for (int i = n; i >= 1; i -= 2)
	    {
			printf("%d ", a[i]); 
		}
        for (int i = 2; i < n; i += 2)
		{
			printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
        } 
    }
	else
	{
        for (int i = n; i > 1; i -= 2)
		{
			printf("%d ", a[i]);
		}
        for (int i = 1; i < n; i += 2)
        {
        	printf("%d%c", a[i], i == n - 1 ? '\n' : ' ');
		}
    }
    
    return 0;
}

###五、独立的小易
####描述：
小易为了向他的父母表现他已经长大独立了,他决定搬出去自己居住一段时间。一个人生活增加了许多花费: 小易每天必须吃一个水果并且需要每天支付 $x$ 元的房屋租金。当前小易手中已经有 $f$ 个水果和 $d$ 元钱,小易也能去商店购买一些水果,商店每个水果售卖 $p$ 元。小易为了表现他独立生活的能力,希望能独立生活的时间越长越好,小易希望你来帮他计算一下他最多能独立生活多少天。
####输入描述：
输入包括一行,四个整数 $x, f, d, p(1 ≤ x,f,d,p ≤ 2 * 10^9)$,以空格分割。
####输出描述：
输出一个整数, 表示小易最多能独立生活多少天。
####输入样例：
$3\ 5\ 100\ 10$
####输出样例：
$11$

####题解：
简单的数学题，分两种情况考虑，一，已有水果大于现有的钱除以房钱；二，已有的水果小于现有的钱除以房钱。

对于第一种情况，我们可以直接用现有的钱除以房钱来算；对于第二种情况，则可以先将水果换算成钱，然后用换算后的总钱数除以房钱和水果钱的和来算。
####代码：

#include <bits/stdc++.h>

using namespace std;

long long x, f, d, p;

int main()
{    
    cin >> x >> f >> d >> p;
    
	if (d > x * f)
	{
        d += f * p;
        cout << d / (x + p) << endl;
    }
    else
	{
       cout << d / x << endl;
    }
    
    return 0;
}

###六、堆棋子
####描述：
小易将 $n$ 个棋子摆放在一张无限大的棋盘上。第 $i$ 个棋子放在第 $x[i]$ 行 $y[i]$ 列。同一个格子允许放置多个棋子。每一次操作小易可以把一个棋子拿起并将其移动到原格子的上、下、左、右的任意一个格子中。小易想知道要让棋盘上出现有一个格子中至少有 $i(1 ≤ i ≤ n)$ 个棋子所需要的最少操作次数。
####输入描述：
输入包括三行,第一行一个整数 $n(1 ≤ n ≤ 50)$,表示棋子的个数；
第二行为 $n$ 个棋子的横坐标 $x[i](1 ≤ x[i] ≤ 10^9)$；
第三行为 $n$ 个棋子的纵坐标 $y[i](1 ≤ y[i] ≤ 10^9)$。
####输出描述：
输出 $n$ 个整数,第 $i$ 个表示棋盘上有一个格子至少有 $i$ 个棋子所需要的操作数,以空格分割。行末无空格。

如样例所示:
对于 $1$ 个棋子: 不需要操作，
对于 $2$ 个棋子: 将前两个棋子放在 $(1, 1)$ 中，
对于 $3$ 个棋子: 将前三个棋子放在 $(2, 1)$ 中，
对于 $4$ 个棋子: 将所有棋子都放在 $(3, 1)$ 中。
####输入样例：
$4$
$1\ 2\ 4\ 9$
$1\ 1\ 1\ 1$
####输出样例：
$0\ 1\ 3\ 10$

####题解：
这个题大致题意是求 $i$ 个点汇聚到某一个点的最小操作次数。

对于这种题，我们应该尝试枚举所有的棋子到每一个聚点的最小曼哈顿距离（因为操作次数等于曼哈顿距离），然后针对每一个聚点所对应的 $n$ 个点的曼哈顿距离进行排序，然后选择曼哈顿距离最小的 $i$ 个点汇聚到这个点，求和即可。

当然，这里到达某一个聚点 $i$ 个点的最小曼哈顿距离之和并不一定是全局的最小，因为聚点不唯一，可能存在最小曼哈顿距离之和更小聚点，那么问题来了，聚点都是哪些？

一开始可能会以为聚点一定是棋子已占有的一个点，但是这是不对的；
也可能会想，聚点是所有棋子的最小最大横坐标纵坐标之间围成的矩形，但是这样做明显会 $TLE$，我们需要进一步缩小聚点的范围；
对于这个题，实际上很容易想明白的是，聚点其实是所有棋子已占有的横坐标与纵坐标之间的组合，所以实际上我们需要考虑的聚点个数不超过 $50 * 50$ 个，这样这个题也就变得很简单了。
####代码：

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 55;
const int INF = 0x3f3f3f3f;

int n;
int x[MAXN], y[MAXN];
int dis[MAXN], ans[MAXN]; 

void solve()
{
	int tmp;
    for (int i = 0; i < n; i++)
	{
        for (int j = 0; j < n; j++)
		{
			//	每个棋子到聚点的曼哈顿距离 
            for (int k = 0; k < n; k++)
			{
				dis[k] = abs(x[i] - x[k]) + abs(y[j] - y[k]);
			}
            sort(dis, dis + n);
			
			tmp = 0; 
            for (int k = 0; k < n; k++)
			{
                tmp += dis[k];
                ans[k] = min(ans[k], tmp);
            } 
        }
    }
}

int main()
{
    cin >> n;

    for (int i = 0; i < n; i++)
	{
		cin >> x[i];
	}
    for (int i = 0; i < n; i++)
	{
		cin >> y[i];
	}
	 
    memset(ans, 0x3f, sizeof(ans));
	
    solve();

    for (int i = 0; i < n; i++)
	{
		printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
    }

    return 0;
}

###七、疯狂队列
####描述：
小易老师是非常严厉的,它会要求所有学生在进入教室前都排成一列,并且他要求学生按照身高不递减的顺序排列。有一次, $n$ 个学生在列队的时候,小易老师正好去卫生间了。学生们终于有机会反击了,于是学生们决定来一次疯狂的队列,他们定义一个队列的疯狂值为每对相邻排列学生身高差的绝对值总和。由于按照身高顺序排列的队列的疯狂值是最小的,他们当然决定按照疯狂值最大的顺序来进行列队。现在给出 $n$ 个学生的身高,请计算出这些学生列队的最大可能的疯狂值。小易老师回来一定会气得半死。
####输入描述：
输入包括两行,第一行一个整数 $n(1 ≤ n ≤ 50)$,表示学生的人数
第二行为n个整数 $h[i](1 ≤ h[i] ≤ 1000)$,表示每个学生的身高
####输出描述：
输出一个整数,表示 $n$ 个学生列队可以获得的最大的疯狂值。

如样例所示:
当队列排列顺序是: $25-10-40-5-25$, 身高差绝对值的总和为 $15+30+35+20=100$。
这是最大的疯狂值了。
####输入样例：
5
5 10 25 40 25
####输出样例：
100

####题解：
这是一个贪心问题。

首先，我们将原序列排好序，然后每次取未使用的最大最小值加入到疯狂队列中，加入的准则是从中间向两边扩展，并且最大值或者最小值交替加入到左边和右边，直到没有或者剩余最后一个数时，放大差大的一边即可。

####代码：

#include <bits/stdc++.h>

using namespace std;

const int MAXN = 55;

int n;
int a[MAXN];
deque<int> d;

int main()
{
    cin >> n;
    
    for (int i = 0; i < n; i++)
    {
        cin >> a[i];
    }
    sort(a, a + n);
    
    int l = 0, r = n - 1, flag = 1;
    d.push_front(a[r--]);
    d.push_back(a[l++]);
    
    while (r > l)
    {
    	if (flag)
    	{
    		d.push_front(a[l++]);
    		d.push_back(a[r--]);
		}
		else
		{
			d.push_front(a[r--]);
    		d.push_back(a[l++]);
		}
		flag = !flag;
    }
    
    int ans = abs(d[1] - d[0]);
    int len = (n & 1) ? n - 1 : n;
    for (int i = 2; i < len; i++)
    {
    	ans += abs(d[i] - d[i - 1]);
	}
    if (r == l)
    {
    	if (abs(d[0] - a[l]) > abs(d[len - 1] - a[l]))
    	{
    		ans += abs(d[0] - a[l]);
		}
		else
		{
			ans += abs(d[len - 1] - a[l]);
		}
	}
    
    cout << ans << endl;
	
	return 0;        
}

###八、小易喜欢的数列
####描述：
小易非常喜欢拥有以下性质的数列:
1、数列的长度为 $n$
2、数列中的每个数都在 $1$ 到 $k$ 之间(包括 $1$ 和 $k$)
3、对于位置相邻的两个数 $A$ 和 $B$( $A$ 在 $B$ 前),都满足( $A <= B$)或( $A\ mod\ B != 0$)(满足其一即可)

例如,当 $n = 4, k = 7$
那么 ${1,7,7,2}$,它的长度是 $4$,所有数字也在 $1$ 到 $7$ 范围内,并且满足第三条性质,所以小易是喜欢这个数列的
但是小易不喜欢 ${4,4,4,2}$ 这个数列。小易给出 $n$ 和 $k$,希望你能帮他求出有多少个是他会喜欢的数列。
####输入描述：
输入包括两个整数 $n$ 和 $k(1 ≤ n ≤ 10, 1 ≤ k ≤ 10^5)$
####输出描述：
输出一个整数,即满足要求的数列个数,因为答案可能很大,输出对 $1,000,000,007$ 取模的结果。
####输入样例：
$2\ 2$
####输出样例：
$3$

####题解：
典型的动态规划问题，我们可以设 $dp[i][j]$ 表示前 $j$ 个数最后一个数以 $i$ 结尾的序列个数， 那么最后的结果便是 $(\sum_{i = 1}^{k} dp[i][n]) \% MOD$。

不过问题来了，我们如何求 $dp[i][j]$ 呢，根据题目我们知道，相邻两个数前者不能是后者的倍数（除去一倍），所以我们可以先求 $(\sum_{i = 1}^{k} dp[i][j - 1]) \% MOD$ 表示前 $j - 1$ 个数的所有合法序列个数，然后呢？对于 $dp[i][j]$ 我们应该用前 $j - 1$ 个数的所有合法序列个数减去前 $j - 1$ 个数所有以 $j$ 的倍数（除去一倍）结尾的合法序列个数，这样剩下的便是 $dp[i][j]$ 的值。
####代码：

#include <bits/stdc++.h>

using namespace std;

const int MOD = 1e9 + 7;
const int MAXK = 1e5 + 5;
const int MAXN = 15;

int n, k;
int dp[MAXK][MAXN];	//	dp[i][j] 前 j 个数以 i 结尾的个数 

int main()
 {
    cin >> n >> k;
    
    int sum;
	dp[1][0] = 1;	
    for (int i = 1; i <= n; i++) 
	{
        sum = 0;
        //	前 i - 1 个数的序列个数 
        for (int j = 1; j <= k; j++) 
		{
            sum += dp[j][i - 1];
            sum %= MOD;
        }
        
        int sum2; 
        for (int j = 1; j <= k; j++) 
		{
            sum2 = 0;
            //	前 i - 1 个数以 j 的倍数结尾的序列个数 
            for (int z = j + j; z <= k; z += j) 
			{
                sum2 += dp[z][i - 1];
                sum2 %= MOD;
            }
            dp[j][i] = (sum - sum2 + MOD) % MOD;
        }
    }
    
    int ans = 0;
    for (int j = 1; j <= k; j++)
	{
        ans += dp[j][n];
        ans %= MOD;
    }
    cout << ans << endl;
    
    return 0;
}