网易2017年秋招编程题之暗黑的字符串解析

题目：

一个只包含'A'、'B'和'C'的字符串，如果存在某一段长度为3的连续子串中恰好'A'、'B'和'C'各有一个，那么这个字符串就是纯净的，否则这个字符串就是暗黑的。例如：
BAACAACCBAAA 连续子串"CBA"中包含了'A','B','C'各一个，所以是纯净的字符串
AABBCCAABB 不存在一个长度为3的连续子串包含'A','B','C',所以是暗黑的字符串
你的任务就是计算出长度为n的字符串(只包含'A'、'B'和'C')，有多少个是暗黑的字符串。

输入描述:

输入一个整数n，表示字符串长度(1 ≤ n ≤ 30)

输出描述:

输出一个整数表示有多少个暗黑字符串

输入例子:

2
3

输出例子:

9
21

解析：

假设现在字符串中有i个字符，并且满足条件，那么第i+1个字符的选取情况与第i-1和第i个字符的状态（用S表示）有关：若S='AA'，那么第i+1个字符可以选取'A','B','C'中任意一个；若S=‘AB’，那么第i+1个字符只能取'A'或'B'，如果选取'C'，就会产生纯净的字符串；若S='AC'，那么第i+1个字符只能取'A'或'C'。由题意可知S有9种状态，其他6中状态的转移情况同理。这样，我们就可以在状态转移过程中统计暗黑的字符串的个数。此处有些类似于动态规划，不过动态规划是在每一步状态转移的时候选取最优方案，从而使最终方案最优；而此处是在状态转移过程中避免产生纯净字符串，同时统计暗黑的字符串的个数。

状态转移方程：

dp[i+1][0]=dp[i][0]+dp[i][3]+dp[i][6]

dp[i+1][1]=dp[i][0]+dp[i][3]

dp[i+1][2]=dp[i][0]+dp[i][6]

dp[i+1][3]=dp[i][1]+dp[i][4]

dp[i+1][4]=dp[i][1]+dp[i][4]+dp[i][7]

dp[i+1][5]=dp[i][4]+dp[i][7]

dp[i+1][6]=dp[i][2]+dp[i][8]

dp[i+1][7]=dp[i][5]+dp[i][8]

dp[i+1][8]=dp[i][2]+dp[i][5]+dp[i][8]

其中dp数组的第一维表示字符串长度，第二维的9个值分别表示字符串最后两个字符的9中状态，对应关系如下：

0->AA  1->AB  2->AC  3->BA  4->BB  5->BC  6->CA  7->CB  8->CC

那么dp[i][0]就表示长度为i并且最后两位字符为AA的暗黑的字符串的个数，其他同理。

上述状态转移方程中第一个式子表达的意思就是：

长度为i+1并且最后两个字符为AA的字符串来源有三类：长度为i并且最后两个字符为AA或BA或CA的字符串，添加字符A即可；其它式子同理；

源代码：

#include <iostream>
#include <vector>
using namespace std;

long long Cal(int n)
{
	if (n == 1) return 3;
	else if (n == 2) return 9;
	vector<long long> Record(9, 1), temp;
	for (int i = 3; i <= n; i++)
	{
		temp = Record;
		Record[0] = temp[0] + temp[3] + temp[6];
		Record[1] = temp[0] + temp[3];
		Record[2] = temp[0] + temp[6];
		Record[3] = temp[1] + temp[4];
		Record[4] = temp[1] + temp[4] + temp[7];
		Record[5] = temp[4] + temp[7];
		Record[6] = temp[2] + temp[8];
		Record[7] = temp[5] + temp[8];
		Record[8] = temp[2] + temp[5] + temp[8];
	}
	long long ans = 0;
	for (int i = 0; i < 9; i++) ans += Record[i];
	return ans;
}
int main()
{
	int n;
	cin >> n;
	cout << Cal(n) << endl;
    
	return 0;
}

*******************************************************************************************************************************************************************************************************

上述是我的解题思路，接下来的部分是我参考了别人的解题思路，加上自己的理解。

*******************************************************************************************************************************************************************************************************

上述解题思路最大的问题是状态转移方程太过复杂，究其原因，是因为对状态划分的太过细致。分析可知，我们可以将状态分为两种：一种是字符串的最后两个字符相同（用S(n)表示），另一种是最后两个字符不同（用D(n)表示）。这样划分使状态转移更加抽象，但好处是状态转移方程更加精简，处理起来更加方便。

两种状态的转移情况如下：S(i)状态添加的字符与最后两字符相等时，转化为S(i+1)状态，否则转化为D(i+1)状态；D(i)状态添加的字符与其最后字符相等时，转化为S(i)状态，与其倒数第二个字符相等时，转化为D(i+1)状态。状态转移方程如下：

S(n+1)=S(n)+D(n)

D(n+1)=2*S(n)+D(n)

源代码：

#include <iostream>
using namespace std;

long long Cal(int n)
{
	if (n == 1) return 3;
	else if (n == 2) return 9;
	long long S = 3, D = 6, s, d;
	for (int k = 3; k <= n; k++)
	{
		s = S, d = D;
		S = s + d;
		D = 2 * s + d;
	}
	return S + D;
}

int main()
{
	int n;
	cin >> n;
	cout << Cal(n) << endl;

	return 0;
}

*******************************************************************************************************************************************************************************************************

接下来，我们可以通过上述状态转移方程式来推出该问题的递推式。我们知道，递推式描述一个问题的时候，非常精简清晰，但递推式并不是凭空产生的，一些简单问题递推式可以直接归纳出来，但一些复杂点的问题，可以通过状态转移方程来推到出来。这种思维模式在算法中很常见。

我们用F(n)表示长度为n的暗黑字符串的个数，则：

F(n)=S(n)+D(n)

      =3*S(n-1)+2*D(n-1)

      =2*F(n-1)+S(n-1)

      =2*F(n-1)+S(n-2)+D(n-2)

      =2*F(n-1)+F(n-2)

故得到递推式F(n)=2*F(n-1)+F(n-2)。