TCO 2015 2D

250分题：给一段仅仅有‘0’，‘1’构成的字符串，然后给出串上平衡点的定义：在串上找到某个点（位置是p），这个点将串分成左右两部分（能够为空），左右分别计算字符的值的和，假设左边有字符是‘1’，那么字符值加上当前位置（i）与平衡点位置的距离（p - i），同理计算右边。假设左右的字符值相等，则就是平衡点。举例：100111是一个中第二个1将串分成100和11，左右的值都是3，是平衡点。

问这段’0′, ‘1’字符串中能找到多少个包括平衡点的子串?

串长度 < 2500

解析：看数据量是一个不能超过O(N^3)的题目，所以不能枚举子串的头尾。然后再枚举每个点是否是平衡点。这题有非常多种做法。能够枚举枚举平衡点的位置，也能够枚举子串。再检測子串是不是含有平衡点。

枚举平衡点的做法是先枚举每一个点位置作为平衡点，然后分别扫描左边，记录全部值出现的次数，然后再扫描右边，计算字符值。假设左边出现了同样的字符值，就是一个含有平衡点的子串，所以结果加上左边出现当前字符值的次数。这样计算的复杂度是O(N^2 * logN)，时间没有问题。可是有一个trick，就是枚举的是平衡点。算子串的时候会有反复计算，想一下能够发现，仅仅有全’0’的字符串中的平衡点能够随意移动，其它字符串要么没有平衡点，要么仅有一个平衡点，所以这里要小心处理0的情况，比赛的时候脑袋蒙全，一直没理清楚。

第二种就是枚举子串，一旦确定子串就要在很短的时间内推断子串是否包括平衡点，想一下。’平衡点’假设在串中移动会有什么效果（假定向右）：

• 左边的值 += 左边‘1’的个数
• 右边的值 -= 右边‘1’的个数

结果就是左值 – 右值加上了所有‘1’的个数。反向移动就是减去所有‘1’的个数。考虑另外一个事实:’平衡点’左端点时，左值 – 右值 <= 0;右边,左值 – 右值 >= 0;加上前面的推论，点在串中移动假设存在 左值 – 右值 == 0的情况，左值 – 右值一定是串中’1’个数的倍数。端点处的左右值差用前缀和。’1’个数也用前缀和来求。这样得到复杂度为O(N^2)的算法。

还有另外O(N^2)的算法。也挺优美，不再表述，能够通过右（左）值的单调性。来移动平衡点。

法一代码：

class BalancedSubstrings {
	public:
	int countSubstrings(string s) {
		int res = 0;

		for(int i = 0;i < s.size();i++) {
			int sum = 0;
			map<int, int> sumMap;
			sumMap[0] = 1;
			for(int j = i - 1;j >= 0;j--) {
				if (s[j] == '1') {
					sum += (i - j);
				}
				if (sumMap.find(sum) == sumMap.end()) {
					sumMap[sum] = 1;
				} else {
					sumMap[sum]++;
				}
			}

			sum = 0;
			res += sumMap[0];
			for(int j = i + 1;j < s.size();j++) {
				if (s[j] == '1') {
					sum += (j - i);
				}
				if (sum == 0 && s[i] == '0') {
					continue;
				}

				if (sumMap.find(sum) != sumMap.end()) {
					res += sumMap[sum];
				}
			}
		}
		return res;
	}
};

法二代码：

class BalancedSubstrings {
	public:
	int countSubstrings(string s) {

		int sum[2550], cnt[2550];
		memset(sum, 0, sizeof(sum));
		memset(cnt, 0, sizeof(cnt));
		for(int i = 0;i < s.size();i++) {
			cnt[i + 1] = cnt[i] + (s[i] == '1');
			sum[i + 1] = sum[i] + (s[i] == '1') * i;
		}

		int res = 0;
		for(int i = 0;i < s.size();i++) {
			for(int j = i;j < s.size();j++) {
				if (cnt[j + 1] - cnt[i] == 0 ||
						(sum[j + 1] - sum[i]) % (cnt[j + 1] - cnt[i]) == 0)
					res++;
			}
		}

		return res;
	}
};

500分题：给一个顺序排列的N个箱子。这N个箱子里有连续K个是有东西的箱子，其余的都是空的。某人用最优的方法去确定这K个箱子的位置，问最坏情况下要多少次？

N，K都是long long。

解析：这种关于策略的问题非常烦。假设没有见过类似的题目可能会心理发慌，只是冷静一下。非常多问题都是纸老虎。考虑这样一个问题：假设不知道箱子个数，我们怎样确定有东西箱子的头呢。

想想看能不能用二分呢？答案是否定的，由于假设找到一个空箱子，不能确定有东西箱子是在前面还是后面，那什么时候能够二分呢？知道有K个箱子能够吗？不全然行，由于假设当前二分位置前面有超过K个箱子没有被检測。那我们是不知道前面有没有有东西的箱子的。聪明的读者可能想到，假设箱子数 <= 2K个不就能够了吗？第一次枚举在K处。假设有箱子则向前二分，否则箱子在后面。

最有策略就是这种。至于为什么是二分。由于基于比較的最快的查找就是二分。。

考虑了前面的子问题，怎样处理箱子数超过2K的情况呢，超过2K的箱子，我们是不能用二分的，仅仅能用贪心的方法粗略的确定有东西箱子的位置，就是每隔K个箱子检測一次，假设检測到，能够用二分去找到头部。最坏的情况就是剩下2K时还没有找到箱子的位置。最后2K个箱子用二分来确定。这里另一个小trick，最后K – 1个是不用二分的，他们肯定不是头，直接把这K – 1减去就可以。

代码：

class BallsInBoxes {
	public:
	long long maxTurns(long long N, long long K) {
		if (N <= K) {
			return 0;
		}

		N -= K;
		long long left = N - max((N + K - 1) / K - 2, 0LL) * K;
		long long res = max((N + K - 1) / K - 2, 0LL);

		while(left > 0) {
			left /= 2;
			res++;
		}

		return res;
	}
};