Codeforces 193 Div 2

 ProA:

对于所有主人公选择的动作进行判断，如果前面三个的动作相同进行统计，因为n>=4,所以这三个动作不可能是主人公做的，所以主人公的动作决策相对来说是独立的，因此累加所有的连续三个相同的序列就可以了。

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

int main()
{
	int n;
	std::cin >> n;
	string s;
	std::cin >> s;
	int len = s.length();
	int s1, s2, s3;
	int ans = 0;
	for (int i = 0; i < len; i++)
	{
		if (i % n==0 && i != 0)
		{
			s1 = i - 1;
			s2 = s1 - 1;
			s3 = s2 - 1;
			if (s[s1]==s[s2] &&  s[s2]==s[s3])
			{
				ans++;
			}
		}
	}
	std::cout << ans << std::endl;
	return 0;
}

ProB:
题目的要求是让我们从n个数组成的正数序列中挑出两个长度为k的子串，这两段不能够重复，求这种选法对应的最大值。
我们可以看出题目有一个很明显的单调性：如果我们对前面序列的起点进行枚举，并且从后向前枚举，我们发现后面的序列段的选择越来越多，并且每次都比以前的选择多一个：
例如： 1 2 3 4 5 选择序列长度为2的两端不重复的子串
如果我们第一段的起点设定为2,那么第一段为(2,3)，第二段的选择只有(4,5)
如果我们第一段的起点设定为1，那么第一段为(1,2)，第二段的选择就有(3,4),(4,5)两种。
我们设定第一段的起点为a，第二段的起点为b。

有了上面那个性质，我们就可以从后向前进行枚举第一段的起点，同时记录当前最好的b（因为这时候所有的b都会是之后的备选b，因此有意义的就只有当前的最好b），每次对于这个最好的b进行更新，这样可以在线性的时间复杂度内成功解决这个问题。

#include <iostream>
using namespace std;
const int maxn = 200010;
int a[maxn];
long long sum[maxn];
int main()
{
	int n, k;
	std::cin >> n >> k;
	for (int i = 1; i <= n; i++)
		std::cin >> a[i];
	sum[0] = 0;
	for (int i = 1; i <=n; i++)
		sum[i] = sum[i-1]+a[i];

	long long maxb, maxa, ans;
	ans = -1;
	int tmpb;
	int numb, numa;
	tmpb = n - k + 1;
	maxb = sum[n] - sum[n-k];
	int b = n - k + 1;
	for (int a = n - 2 * k + 1; a>=1; a--)
	{
		maxa = sum[a+k-1]-sum[a-1];
		if (maxa + maxb>=ans)
		{
			ans = maxa + maxb;
			numa = a;
			numb = tmpb;
		}
		b--;
		long long tmp = sum[b+k-1]-sum[b-1];
		if (tmp>=maxb)
		{
			maxb = tmp;
			tmpb = b;
		}
	}
	std::cout << numa << " " << numb << std::endl;
	return 0;
}

ProC:
题目的要求有些复杂，首先进行总结：有n个数对，每个数对有两个元素a,b。现在要求你选择出p个数对，然后由另一个人进行选择，他会对选出的数对进行先按照b从大到小排序，相同的b按照a从小到大排序，选择前面k个的a和后p-k的b进行累加。你的目的是首先使得这个a的和最大，在有多个解使得a相同时使得b的和最大。
我们的解决方式是贪心算法：由于敌人（chair student）的特殊排序方式，我们按照这个规定进行排序，对于这n个数中的最后p-k个，他们的a是不可能最后被chair student选中的，所以刨除掉这些数对，将前面的数对首先按照a从大到小排序，相同的a按照b从大到小进行排序，选择最大的k个数对，这些数对就是chair student最后选定的a,接下来记录选出的这k个数对里面在chair student 排序方法中最靠后的一个的位置，设定为max_pos,然后将max_pos之后的p-k个（chair student 排序方式下）选出，作为最大的b。

#include <iostream>
#include <vector>
using namespace std;
const int maxn = 100010;
int a[maxn], b[maxn], number[maxn];
int tmp[maxn], tmpp[maxn], tmp1[maxn];
int len;
void qsort(int l, int r)
{
	int xa, xb, i, j, mid, tmp;
	i = l;j = r;
	mid = (i + j) / 2;
	xa = a[mid];xb = b[mid];
	while (i<=j)
	{
		while ((xb < b[i])||(xb==b[i] && xa > a[i])) i++;
		while ((xb > b[j])||(xb==b[j] && xa < a[j])) j--;
		if (i<=j)
		{
			tmp = a[i];a[i] = a[j];a[j] = tmp;
			tmp = b[i];b[i] = b[j];b[j] = tmp;
			tmp = number[i];number[i] = number[j];number[j] = tmp;
			i++;j--;
		}
	} 
	if (l < j) qsort(l , j);
	if (i < r) qsort(i , r);
}
void qsort1(int l, int r)
{
	int x, i, j, mid, tt, y;
	i = l; j = r;
	mid = (i + j) / 2;
	x = tmp[mid];
	y = tmpp[mid];
	while (i<=j)
	{
		while ((x < tmp[i])||(x==tmp[i] && y < tmpp[i])) i++;
		while ((x > tmp[j])||(x==tmp[j] && y > tmpp[j])) j--;
		if (i<=j)
		{
			tt = tmp[i];tmp[i] = tmp[j];tmp[j] = tt;
			tt = tmp1[i];tmp1[i] = tmp1[j];tmp1[j] = tt;
			tt = tmpp[i];tmpp[i] = tmpp[j];tmpp[j] = tt;
			i++;
			j--;
		}
	}
	if (l < j) qsort1(l, j);
	if (i < r) qsort1(i, r);
}
int main()
{
	int n, p, k;
	std::cin >> n >> p >> k;
	for (int i = 1; i <= n; i++) number[i] = i;
	for (int i = 1; i <= n; i++)
		std::cin >> a[i] >> b[i];
	qsort(1, n);
	len = n - p + k;
	for (int i = 1; i<=len; i++)
	{
		tmp[i] = a[i];
		tmp1[i] = i;
		tmpp[i] = b[i];
	}
	qsort1(1, len);
	//get first k
	//for (int i = 1; i <=len; i++)
	//{
	//	std::cout << tmp[i] << " " << tmpp[i] << std::endl;
	//}
	int maxpos = -1;
	vector<int> ans;
	ans.clear();
	for (int i = 1; i <= k; i++)
	{
		if (maxpos<tmp1[i]) maxpos = tmp1[i];
		ans.push_back(number[tmp1[i]]);
	}
	for (int i = maxpos+1; i<= maxpos+1+p-k-1; i++)
		ans.push_back(number[i]);
	for (int i = 0; i < ans.size(); i++)
		std::cout << ans[i] << " ";
	std::cout << std::endl;
	return 0;
}