腾讯2017暑期实习生编程题之我见

1.

第一题如上所示,我的解决思路是首先将原字符串反转，然后利用回文串的特点-对称性，求出反转后的字符串与原字符串的最长公共子串的长度，最后用原字符串的长度减去最长公共子串的长度，即是最少要删除的字符串个数。（LCS算法）

     以下是我在牛客网中提交的代码：

      

#include<iostream>
#include<cstring>
using namespace std;
int LCS(char* p, char* q) 
{
	//int lable = 0;//用于判断是否要存储子序列字符的标记
	int m = strlen(q);
	int n = strlen(p);
	//构造存放最长lcs的二位数组
	int** c = new int*[m+1];
	for (int k = 0; k < m + 1; ++k)
	{
		c[k] = new int[n + 1];
	}
	//初始化二维数组，将第一行和第一列都置0
	for (int i = 0; i < n + 1; ++i)
	{
		c[0][i] = 0;
	}
	for (int j = 0; j < m + 1; ++j)
	{
		c[j][0] = 0;
	}
	//给二维数组赋值
	for (int i = 1; i < m+1; ++i)
	{
		for (int j = 1; j < n+1; ++j)
		{
			if (*(q + i - 1) == *(p + j - 1))
			{
				c[i][j] = c[i - 1][j - 1] + 1;
			}
			else
			{
				c[i ][j ] = c[i - 1][j]>=c[i][j - 1] ? c[i - 1][j] : c[i][j - 1];
			}
		}
	}
	return c[m][n];
}

int main()
{
	char Dest[1001];
	char Reverse[1001];
	while (cin >> Dest)
	{
		int len = strlen(Dest);
		for (int i = len - 1; i >= 0; --i)
			Reverse[len - 1 - i] = Dest[i];
		Reverse[len] = '\0';
		int lcs = LCS(Dest, Reverse);
		int outcome = len - lcs;
		cout << outcome << endl;
		memset(Dest, 0, sizeof(Dest));
		memset(Reverse, 0, sizeof(Reverse));
	}
	return 0;
}

2.

   第二题如上所示，我的解决思路是先获取字符串的长度，然后从尾部向头扫描，遇到大写字母时首先将该大写字母保存到临时变量中，然后将该大写字母与尾部方向的前一个大写字母之间的小写字母依次向头部方向前移一位，最后将保存在临时变量中的该大写字母放到正确的位置。依照此方法依次处理每一个大写字母即可。

以下是我在牛客网中提交的代码：

<span style="font-size:18px;">#include<iostream>
#include<cstring>
using namespace std;
char* CapitalPostposition(char* a)
{
	int capitalCount = 0;
	char tmp;
	int n = strlen(a);
	int size = n;
	while(n>0)
	{
		if('A'<=a[n-1]&&a[n-1]<='Z')
		{
			++capitalCount;
			tmp = a[n-1];
			for(int i=n;i<=size-capitalCount;++i)
			{
				a[i-1] = a[i];
			}
			a[size-capitalCount] = tmp;
			--n;
		}
		else
			--n;
	}
	return a;
}
int main()
{
	char test[1001];
	char* result;
	memset(test,0,sizeof(test));
	while(cin>>test)
	{
		result = CapitalPostposition(test);
		cout<<result<<endl;
	}
	return 0;
}</span>

3.

第三题如上所示，我的解决思路是，首先对原始序列排序，然后扫描原始序列，获得原始序列每一个元素重复的次数构成的向量repeat_vector。根据判断该数组的最大值是否大于1来分两种情况处理。当最大值大于1时，说明原始序列中有重复的元素，差值最大的对数等于repeat_vector的首尾两个元素的积。差值最小的对数用公式n*(n-1)/2对repeat_vector累加即可获得。当最大值为1时，即原始序列没有重复的元素，差值最大的对数等于1。要获取差值最小对数，需进一步获得相邻两个元素差值构成的向量adjacent,差值最小对数等于adjacent中最小元素出现的次数。

以下是我在牛客网中提交的代码：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> GetRepeat(vector<int>source_sorted)
{
	vector<int>::iterator p = source_sorted.begin();
	vector<int>::iterator q;
	vector<int> repeat;
	while (p != source_sorted.end())
	{
		int k = 0;
		q = p;
		while (*q == *p)
		{
			if (p == source_sorted.end() - 1)
			{
				++p;
				++k;
				break;
			}
			else
			{
				++p;
				++k;
			}
		}
		repeat.push_back(k);
	}
	return repeat;
}

int GetMinGapPairs_NoRepeat(vector<int>source)
{
	int MinGapPairs = 0;
	vector<int>adjacent;
	//扫描source获取相邻差值构成的vector
	vector<int>::iterator it_src = source.begin();
	for (; it_src != source.end()-1; ++it_src)
	{
		adjacent.push_back(*(it_src+1) - *it_src);
	}
	//相邻差值构成的vector中最小值出现的次数即最小差值的对数
	int minInGap = *min_element(adjacent.begin(), adjacent.end());
	vector<int>::iterator it_adj = adjacent.begin();
	for (; it_adj != adjacent.end(); ++it_adj)
	{
		if (*it_adj == minInGap)
			++MinGapPairs;
	}
	return MinGapPairs;
}

void PairsOfMinMaxGap(vector<int>source)
{
	vector<int> repeat_sorted;
	int maxGapPairs, minGapPairs;
	maxGapPairs = minGapPairs = 0;
	sort(source.begin(), source.end());
	repeat_sorted = GetRepeat(source);
	//判断有无差值为0的情况
	int maxInRepeat = *max_element(repeat_sorted.begin(), repeat_sorted.end());
	if (maxInRepeat > 1)//有差值为0的情况
	{
		maxGapPairs = repeat_sorted.front() * repeat_sorted.back();
		vector<int>::iterator it = repeat_sorted.begin();
		for (; it != repeat_sorted.end(); ++it)
		{
			minGapPairs += (*it) * (*it - 1) / 2;
		}
	}
	else
	{
		maxGapPairs = 1;
		minGapPairs = GetMinGapPairs_NoRepeat(source);
	}
	cout << minGapPairs << " " << maxGapPairs << endl;
}

int main()
{
	int n;
	while (cin >> n)
	{
		vector<int>source(n);
		for (int i = 0; i < n; ++i)
			cin >> source[i];
		PairsOfMinMaxGap(source);
	}
	return 0;
}