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!