hihoCoder #1052 : 基因工程

题目：

时间限制:1000ms 单点时限:1000ms 内存限制:256MB 描述
小Hi和小Ho正在进行一项基因工程实验。他们要修改一段长度为N的DNA序列，使得这段DNA上最前面的K个碱基组成的序列与最后面的K个碱基组成的序列完全一致。

例如对于序列"ATCGATAC"和K=2,可以通过将第二个碱基修改为"C"使得最前面2个碱基与最后面两个碱基都为"AC"。当然还存在其他修改方法，例如将最后一个碱基改为"T"，或者直接将最前面两个和最后面两个碱基都修改为"GG"。

小Hi和小Ho希望知道在所有方法中，修改碱基最少的方法需要修改多少个碱基。

输入 第一行包含一个整数T(1 <= T <= 10)，代表测试数据的数量。

每组测试数据包含2行，第一行是一个由"ATCG"4个大写字母组成的长度为N(1 <= N <= 1000)的字符串。第二行是一个整数K(1
<= K <= N)。

输出 对于每组数据输出最少需要修改的碱基数量。

样例输入

2
ATCGATAC
2
ATACGTCT 6

样例输出

1
3

思路

一开始想复杂了。这题其实通过一定的找规律就可以以一个很简单的形式解出。在这里同时介绍一开始想复杂的方法和简单方法。

递归（笨方法）：

对于每个长度为N的字符串，使其前K个字符与后K个字符组成的子串相等，可以化为N-（N-K）长度的字符串，使其前K-（N-K）个字符与后K-（N-K）个字符组成的子串相等的问题。其中，对于第n次操作，若n为奇数，取N个字符中的前N-（N-K）个字符作为子串；若n为偶数，取N个字符中后N-（N-K）个字符作为子串。
一直递归到2*K<=N时，字符串需要相同的部分没有重叠，对这个没有重叠的字符串按位进行标记，并在回退过程中对每次被去除掉的N-K个字符进行赋值，记录N个字符中哪些需要相等。最后对于所有需要相等的字符位，找出出现频率最高的，总个数-频率最高字母出现字数即当前情况下需要改变的次数。累加所有情况的次数，得到结果。
这个方法太复杂了，现在看起来觉得自己当时很蠢，但当时还是觉得自己很聪明的。。。

找规律法：

找找规律可以发现，这道题按要求修改完后的最终结果其实是一个长度为N-K的循环的子串，就像人类的本质是复读机一样。
从第0位开始，按顺序每N-K位标上相同的记号。比如，假设N=10,K=7，那么对第0,1,2位分别标上记号1,2,3，对第3,4,5位分别标上记号1,2,3，以此类推，记号相同的位代表修改完后所对应的字符应该一样。标记完记号后执行上面递归方法最后一步统计次数即可。

相关函数：

memset(起始地址,0,size)：将从地址开始的size个空间值设置为0，用于初始化数组。头文件#include<memory.h>

三目运算符：优先级与等号相同，在算式中使用时需加括号。

可能出现的问题：

1、递归时MLE或普通方法TLE：没有考虑K=N的特例，会进入死循环，加入一个K=N的特判即可。

2、RE：数组大小开得不够，虽然题目说长度1000即可，但实际貌似需要开到2000才行。

AC代码

递归法：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<string>
#include<memory.h>

using namespace std;
int name[10000];
int num;
string str;

void
digui(int begin, int end, int K, int flag) {
	int shorter = end - begin + 1 - K;
	if ((end - begin + 1) / 2 >= K) {
		int i = 0;
		for (; i < K; i++) {
			name[begin + i] = i + 1;
			name[end - K + 1 + i] = i + 1;
		}
		for (; i <= end - begin - K; i++) {
			name[begin + i] = i + 1;
		}
		num = i;
		return;
	}
	else {
		flag == 1 ? end -= shorter : begin += shorter;
		digui(begin, end, K - shorter, -flag);
		if (flag == 1) {
			for (int i = 0; i < shorter; i++) {
				name[end - i + shorter] = name[end - i];
			}
		}
		else {
			for (int i = 0; i < shorter; i++) {
				name[begin + i - shorter] = name[begin + i];
			}
		}
		return;
	}
}

int main() {
	int T;
	cin >> T;
	while (T--) {
		memset(name, 0, 10000);
		cin >> str;
		int K;
		cin >> K;
		int count = 0;
		if (K == str.size()) {
			cout << 0 << endl;
			continue;
		}
		digui(0, str.size() - 1, K, 1);

		//统计次数
		for (int i = 1; i < num + 1; i++) {
			int a, t, c, g;
			a = t = c = g = 0;
			for (int j = 0; j < str.size(); j++) {
				if (name[j] == i) {
					switch (str[j]) {
					case 'A':a++; break;
					case 'T':t++; break;
					case 'C':c++; break;
					case 'G':g++; break;
					}
				}
			}
			int max1 = c > g ? c : g;
			int max2 = a > t ? a : t;
			count += a + t + c + g - (max1 > max2 ? max1 : max2);
		}
		cout << count << endl;
	}
	return 0;
}

找规律法：

#include<iostream>
#include<algorithm>
#include<cmath>
#include<string>
#include<memory.h>

using namespace std;

int main() {
	int T;
	cin >> T;
	while (T--) {
		int name[10000];
		memset(name, 0, 10000);
		int num;
		string str;
		cin >> str;
		int K;
		cin >> K;
		int count = 0;
		if (K == str.size()) {
			cout << 0 << endl;
			continue;
		}
		//哪些位置应该一样
		int begin = 0, end = str.size() - 1;
		int flag = 1;
		int shorter = str.size() - K;
		for (int i = 0; i < str.size(); i++) {
			name[i] = i % shorter + 1;
		}
		num = shorter;
		//统计次数
		for (int i = 1; i < num + 1; i++) {
			int a, t, c, g;
			a = t = c = g = 0;
			for (int j = 0; j < str.size(); j++) {
				if (name[j] == i) {
					switch (str[j]) {
					case 'A':a++; break;
					case 'T':t++; break;
					case 'C':c++; break;
					case 'G':g++; break;
					}
				}
			}
			int max1 = c > g ? c : g;
			int max2 = a > t ? a : t;
			count += a + t + c + g - (max1 > max2 ? max1 : max2);
		}
		cout << count << endl;
	}
	return 0;
}