特殊的测试（贝壳找房2020校招笔试题）解答

题目描述：

小C在做一种特殊的服务器负载测试，对于一个请求队列中的请求，每一个请求都有一个负荷值，为了保持服务器稳定，请求队列中的请求负荷必须按照先递增后递减的规律（仅递增，仅递减也可以），比如[1, 2, 8, 4, 3], [1, 3, 5] 和 [10] 这些是满足规律的，还有一些不满足的，比如 [1 2 2 1], [2 1 2],  [10, 10]。现在给你一个请求队列，你可以对请求的负荷值进行增加， 要求你调整队列中请求的负荷值， 使数组满足条件。 最后输出使队列满足条件的最小的增加总和。

输入：

输入有两行，第一行是N ，代表请求队列中的请求数量。

第二行有N个数字  。 是第i个请求的负荷值。

输出：

输出这个最小增加总和。

 

思路：

对于输入用一个数组进行存储（以下称原数组）。保留原数组第一个元素不变，生成递增数组，要求递增数组每个元素大于等于原数组对应元素，并且严格单调递增；保留原数组最后一个元素不变，从后往前生成递减数组，要求递减数组每个元素大于等于原数组，并且严格单调递减。

如果这两个数组能够在中途“相遇”，那么原数组最终能够生成一个先递增后递减的序列，并且拐点就是在那个相遇的点。如果两个数组不能相遇，那么最终只能生成一个仅递增或仅递减的序列，此时需要判断哪个序列增加的总和更小。

例1：1 4 8 7 6 5 3 4

递增序列：1    4     8    9    10    11    12    13

递减序列：11  10   9    8     7      6      5      4

可以看到两个序列在8 和9 这两个位置“相遇”， 所谓“相遇”， 要求两个数组的同一个位置元素相等，或在相邻的位置元素相等（如例1）。在例1中，最后的生成序列是 1 4 8 9 7 6 5 4  或者 1 4 9 8 7 6 5 4，可以看出这两个序列增加总和是相同的。

例2: 15      10      27      28      3       28

递增序列：15      16      27      28      29      30
递减序列：33      32      31      30      29      28

 

此时两个序列在29这个位置相遇。最后生成序列是15 16 27 28 29 28

贴上代码：

#include<iostream>

using namespace std;
int main()
{
	int n, point = 0;
	int count = 0, count_1 = 0, count_2 = 0;
	int i = 0;
	
	cin >> n;//输入数组长度 
	
	int input[n], a[n], b[n], c[n] = {0};
	//输出初始数组 
	for(i = 0; i < n; i++)
	{
		cin>>input[i];
		a[i] = b[i] = input[i];
		cout << input[i] <<"\t";
	}
	//保留数组开头，从前向后生成严格递增子序列
	for(i = 0; i < n-1; i++)
	{
		if(a[i] >= a[i+1])
		{
			a[i+1] = a[i] + 1;
		}
	}
	//保留数组结尾，从后向前生成严格递减子序列
	for(i = n-1; i > 0; i--)
	{
		if(b[i] >= b[i-1])
		{
			b[i-1] = b[i] + 1;
		}
	}
	
	cout<<endl<<endl;
	for(i = 0; i < n; i++)
	{
		cout<<a[i]<<"\t";
	}
	cout<<endl;
	for(i = 0; i < n; i++)
	{
		cout<<b[i]<<"\t";
	}
	cout<<endl<<endl;
	
	//确定拐点位置，进行合并
	for(i = 0; i < n; i++)
	{
		if(a[i] == b[i])
		{
			point = i;
			break;
		}
	}
	for(i = 0; i < n-1; i++)
	{
		if((a[i+1] == b[i]) || (a[i] == b[i+1]))
		{
			point = i+1;
			break;
		}
	}
	//判断是否存在拐点，若存在则输出先递增后递减序列 
	if(point != 0)
	{
		for(i = 0; i < n; i++)
		{
			c[i] = (i <= point)? a[i] : b[i];
			cout<< c[i] <<"\t";
		}
	}
	else//若无拐点，目标数组只能是严格递增或严格递减，计算增加负载较少的数组并输出 
	{
		for(i = 0; i < n; i++)
		{
			count_1 += (a[i] - input[i]);
			count_2 += (b[i] - input[i]);
		}
		for(i = 0; i < n; i++)
		{
			c[i] = (count_1 <= count_2)? a[i] : b[i];
			cout <<c[i] <<"\t";
		}
	}
	cout<<endl<<endl; 
	//计算负载增加值
	for(i = 0; i < n; i++)
	{
		count += (c[i] - input[i]);
	} 
	cout << count <<endl;
	 
	
	
	return 0;
}