SRM 605

我觉得这道题不错！

我们先不要操作几次（因为最后多加一维就行）

然后dp[i][j]，表示覆盖完前i个了，最后一段使用j位置的数覆盖的

那么dp[i][j]是由那些转移过来的呢？

1) 首先i到j之间的最大值是a[j]，不然i的位置不可能由j的位置的数覆盖。

2) 他可以是任何数覆盖i-1之前的位置转移过来，但是：

     假设他前面第一个比他大的数的位置是r，他不能由某个数覆盖r之前的位置转移过来（因为j位置的数不能覆盖之前位置到r这一段）

于是你会发现这其实两个矩阵，维护一下矩阵前缀和就行了

然后注意的一点是，如果只是自己位置覆盖自己位置是不需要操作数的，i==j的时候特殊处理一下就行了。

#include <vector>
#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>
#include <cstring>

using namespace std;

class AlienAndPermutation {
public:
	int getNumber(vector<int> , int);
};
long long pmod = 1000000007;
long long dp[205][205][205];
int a[205];
int nt[205], pre[205];
long long sum[205][205][205];
int AlienAndPermutation::getNumber(vector<int> A, int m) {
	int i, j, k, n;
	memset(dp, 0, sizeof(dp));
	n = A.size();
	for (i = 0; i < n; ++i) {
		a[i + 1] = A[i];
	}
	a[0] = n + 1;
	n++;
	for (i = 1; i < n; ++i) {
		for (j = i; j >= 0; --j)
			if (a[j] > a[i])
				break;
		pre[i] = j;
		for (j = i; j < n; ++j)
			if (a[j] > a[i])
				break;
		nt[i] = j;
	}
	memset(sum, 0, sizeof(sum));
	memset(dp, 0, sizeof(dp));
	for (i = 0; i < n; ++i)
		dp[0][i][i] = 1;
	for (i = 0; i < n; ++i) {
		for (j = 0; j < n; ++j) {
			if (i == 0 && j == 0)
				sum[0][i][j] = dp[0][i][j];
			else if (i == 0)
				sum[0][i][j] = sum[0][i][j - 1] + dp[0][i][j];
			else if (j == 0)
				sum[0][i][j] = sum[0][i - 1][j] + dp[0][i][j];
			else
				sum[0][i][j] = sum[0][i - 1][j] + sum[0][i][j - 1]
						+ dp[0][i][j] - sum[0][i - 1][j - 1];
		}
	}

	for (k = 1; k <= m; ++k) {
		for (i = 1; i < n; ++i) {
			for (j = 1; j < n; ++j) {
				if (pre[j] >= i || nt[j] <= i)
					dp[k][i][j] = 0;
				else if (j == i) {
					dp[k][i][j] = sum[k][i - 1][i - 1] - ((i - 2 < 0) ? 0
							: sum[k][i - 2][i - 1]);
					if (a[i - 1] < a[i]) {
						dp[k][i][j] += sum[k - 1][i - 2][i - 1]
								- ((pre[j] == 0) ? 0
										: sum[k - 1][pre[j] - 1][pre[j]]);
					}
					dp[k][i][j] %= pmod;
				} else {
					dp[k][i][j] = sum[k - 1][i - 1][j - 1] - ((pre[j] == 0) ? 0
							: sum[k - 1][pre[j] - 1][pre[j]]);
					dp[k][i][j] %= pmod;
				}
				sum[k][i][j] = dp[k][i][j] + sum[k][i - 1][j]
						+ sum[k][i][j - 1] - sum[k][i - 1][j - 1];
				sum[k][i][j] %= pmod;
			}
		}
	}
	long long ans = 0;
	for (k = 0; k <= m; ++k)
		for (j = 1; j < n; ++j) {
			ans += dp[k][n - 1][j];
			ans %= pmod;
		}
	return (ans + pmod) % pmod;
}