SRM 586 div2

今天的题目感觉挺水， 还剩25min时我就提交了三题。。。。

250pt:水，直接模拟即可。

500pt:给出一个线性分段函数查询一些平行于x轴的直线与该函数有几个交点，也差不多是模拟吧将原函数分段和直线

判相交，感觉怎么搞都可以的。。

1000pt:定义一个字符串的value为所有出现的字母过的最右出现减去最左出现下标的差值的和， 要求长度为L(L <= 1000)

的value最小的不同字符串个数。

可以这样考虑，如果一个字母只出现一次则它贡献的value为0， 为了使value尽可能小所以要让相同的字母尽可能少

出现， 如果必须出现相同的字母则要相同的字母都连在一起这样才能使这个字母贡献的value最小， 不难得到下

面两种情况：

1. L <= 26这种情况的答案为P(26, L)， P(n, k)表示n个元素选k个的全排列。

2.L > 26这种情况的字符串可以看成26个段组成的， 每个段都是相同的字母， 所以如果确定每个段的字母个数那么

答案即为26！现在考虑所有段的的字母的情况， 不难想到那个经典的组合数学例题， x1 + x2 + ... x26 = n有多少个

非负整数解这里的n应该等于L - 26最后的答案就是C(n + 25, n) * 26 !

250pt:

#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <cstring>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

class TeamsSelection {
public:
	string simulate(vector <int>, vector <int>);
};

const int N = 55;
bool flag[N];
char str[N << 1];

string TeamsSelection::simulate(vector <int> p1, vector <int> p2) {
	memset(flag, 0, sizeof(flag));
	int cur = 0;
	int c = 0;
	int n = p1.size();

	while (c < n) {
		if (cur) {
			for (int i = 0; i < n; i++) {
				if (!flag[p2[i]]) {
					flag[p2[i]] = 1;
					str[p2[i] - 1] = '2';
					break;
				}
			}		
		}
		else {
			for (int i = 0; i < n; i++) {
				if (!flag[p1[i]]) {	
					flag[p1[i]] = 1;
					str[p1[i] - 1] = '1';
					break;
				}
			}
		}
		cur ^= 1;
		c++;	
	}
	str[n] = '\0';
	return string(str);
}


//Powered by [KawigiEdit] 2.0!

500pt:

#include <vector>
#include <cstring>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

class PiecewiseLinearFunctionDiv2 {
public:
	vector <int> countSolutions(vector <int>, vector <int>);
};

vector<int> PiecewiseLinearFunctionDiv2::countSolutions(vector <int> Y, vector <int> q) {
	int n = Y.size();
	int m = q.size();
	vector<int> vec(m);
	for (int i = 0; i < m; i++) {
		bool flag = 0;
		int tmp = 0;
		for (int j = 1; j < n; j++) {
			int a = max(Y[j], Y[j - 1]);
			int b = min(Y[j], Y[j - 1]);
			if (a == b && a == q[i]) {
				flag = 1;
				break;
			}
			if (b < q[i] && q[i] < a) {
				tmp++;	
			}				
		}

		for (int j = 0; j < n; j++)
			if (Y[j] == q[i])
				tmp++;

		if (flag) {
			vec[i] = -1;
		}
		else {
			vec[i] = tmp;
		}	
	}
	return vec;
}


//Powered by [KawigiEdit] 2.0!

1000 pt:

#include <vector>
#include <cstring>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

class StringWeightDiv2 {
public:
	int countMinimums(int);
};

typedef long long LL;

const int N = 1105;
const int mod = 1000000009;

LL C[N][N];

void init() {
	for (int i = 0; i < N; i++) {
		C[i][0] = 1;
		C[i][i] = 1;
		for (int j = 1; j < i; j++) {
			C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
			if (C[i][j] >= mod)
				C[i][j] %= mod;
		}
	}
}

int StringWeightDiv2::countMinimums(int L) {
	init();
	if (L <= 26) {
		LL tmp = 1;
		for (int i = 26; i >= 26 - L + 1; i--) {
			tmp *= i;
			if (tmp >= mod)
				tmp %= mod;
		}
		return tmp;		
	}
	else {
		LL tmp = 1;
		for (int i = 26; i >= 1; i--) {
			tmp *= i;
			if (tmp >= mod)
				tmp %= mod;
		}
		int n = L - 26;
		LL res = tmp * C[n + 25][n] % mod;
		return res;
	}
}


//Powered by [KawigiEdit] 2.0!