目录
还好
一.水池
1.题目
1.题目描述
又到了一年一度的的雨季，幻想乡原来也会下雨。 看着本已经干涸的池塘，灵梦想出了一个高(zhi)深(zhang)的问题： 随着雨水落下，池塘中高低不平的地方会积水。 给出一个n∗m大小的池塘的每个地方的高度，求雨水落下后每个地方的剩 余的雨水的高度。
2.输入格式
第一行三个数分别为n,m,L 接下来n行m列共n∗m个范围在[0,L]中的整数，分别表示这个地方的高度 。
3.输出格式
输出包含n行m列，第i行第j列的数表示这个地方的积水的高度。
4.输入样例：
3 3 1
1 1 1
1 0 1
1 1 1
5.输出样例
0 0 0
0 1 0
0 0 0
6.数据范围与提示
• 对于前40%的数据,n,m ≤ 4,L = 1
• 对于100%的数据,n,m ≤ 1000,L ≤ 1000
2.题解
考试时想出了正解但是打错了，哎，我太逊了。
首先很明显最外面的那一层无论如何都是积水为0，所以只要池塘内部的积水能够漫溢到最外面那一层，那么积水深度就不能在增加了。
然后你把这个过程想想成雨水从内走到外。没错，暴力方法：从池塘内部的每一个点开始向外部都做一次spfa，找最短路径。
很明显，暴力只有40分，那满分做法呢？
是这样的：
我们先把池塘最外面的那一层装入优先队列（小根堆），然后依次取出优先队列的每一个元素，以这个点的高度为积水的高度加上点的高度，继续bfs，遇到更高的点就加入队列，直到走完为止。
为什么呢？因为
1.要积水高度越小，那么就要用小根堆；
2.遇到一个比现在的高度更高的点，就说明这个点有可能挡住了水的去路，水要到这个点这么高才能继续走。
3.Code
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
#define M 1005
struct node {
int x, y, h;
node (){};
node (int X, int Y, int H){
x = X;
y = Y;
h = H;
}
bool operator < (node rhs) const{
return h > rhs.h;
}
};
int n, m, L, hei[M][M], val[M][M], vis[M][M];
int dir[4][2] = {{1, 0}, {0, 1}, {-1, 0}, {0, -1}};
priority_queue <node> qf;
inline void Read (int &x){
int f = 1; x = 0; char c = getchar ();
while (c < '0' || c > '9') {if (c == '-') f = -1; c = getchar ();}
while (c >= '0' && c <= '9') {x = x * 10 + c - 48; c = getchar ();}
x *= f;
}
inline bool check (int x, int y){
if (x < 0 || x > n + 1 || y < 0 || y > m + 1 || vis[x][y] >= 1)
return 0;
return 1;
}
inline void bfs (int x, int y, int h){
queue <pair <int, int> > Q;
Q.push (make_pair (x, y));
val[x][y] = h;
vis[x][y] = 2;
while (! Q.empty ()){
pair <int, int> f = Q.front ();
Q.pop ();
for (int i = 0; i < 4; i ++){
int tox = f.first + dir[i][0];
int toy = f.second + dir[i][1];
if (check (tox, toy)){
if (h < hei[tox][toy]){
vis[tox][toy] = 1;
val[tox][toy] = hei[tox][toy];
qf.push (node (tox, toy, hei[tox][toy]));
}
else{
vis[tox][toy] = 2;
val[tox][toy] = h;
Q.push (make_pair (tox, toy));
}
}
}
}
}
int main (){
Read (n), Read (m), Read (L);
for (int i = 1; i <= n; i ++)
for (int j = 1; j <= m; j ++)
Read (hei[i][j]);
bfs (0, 0, 0);
while (! qf.empty ()){
node q = qf.top ();
qf.pop ();
if (vis[q.x][q.y] == 2)
continue;
bfs (q.x, q.y, q.h);
}
for (int i = 1; i <= n; i ++){
for (int j = 1; j < m; j ++)
printf ("%d ", val[i][j] - hei[i][j]);
printf ("%d\n", val[i][m] - hei[i][m]);
}
return 0;
}
二.排列
1.题目
1.题目描述
琪露诺又开始学数学了，”1+1=？“。 众所周知，琪露诺无法解答这个问题，并对提出这个问题的你感到无比 愤怒，于是提出了一个简单的问题，希望得到你的解答 给出一个长度为n的排列，每次的操作定义为：选择一个区间[l,r]，并将 这个区间中的所有数变成这个区间中的最大的数，请问所有的能够通过这样的 操作到达的排列有多少种呢？ 但是聪明的你觉得十分简单于是反问琪露诺，如果我限制总的操作次数 那么答案又是多少呢？ 琪露诺无法回答这个问题，于是你需要给她答案。
2.输入格式
第一行包含一个整数T表示数据的组数。 对于每组数据的第一行两个整数n,K表示排列的大小和操作的次数。 接下来一行n个数构成一个排列。
3.输出格式
输出包含T行，每行输出一个答案， mod 1e9 + 7输出。
4.输入样例：
1
3 1
3 1 2
5.输出样例：
4
6.数据范围与提示
可以到达的排列有312,322,332,333
对于所有的数据满足T ≤ 10
对于前10%的数据,n ≤ 8
对于另外30%的数据,n ≤ 50
对于另外60%的数据,n ≤ 200
2.题解
这道题目是不是看着都没有思路？对的，我当时看到这道题目连暴力都放弃了。
现在，让我来揭晓正解算法：动态规划DP
step1：
预处理出每个点它能通过操作到达的区间。
比如这个序列：1 5 3 2 1 6
3能到达的区间就是3~5
step2：
开始我们的动规操作。
定义dp[i][j][k]表示在第i个位置放第j个数，已经用了k次操作
一共有这些转移：
1.第i个位置直接被第j-1个数覆盖
状态转移方程：dp[i][j][k] = dp[i][j - 1][k]
2.枚举一个t，表示j这个数占了t个位置，i是第t个位置
状态转移方程：
（l[j]是指j这个数能到达区间的左端点）
这里包超时，所以我们用前缀和优化，这道题目就解决了。
具体看代码
3.Code
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define M 205
const int mod = 1e9 + 7;
int T, n, k, a[M], l[M], r[M];
int dp[M][M][M], Sum[M][M][M], ans;
inline void Read (int &x){
int f = 1; x = 0; char c = getchar ();
while (c < '0' || c > '9') {if (c == '-') f = -1; c = getchar ();}
while (c >= '0' && c <= '9') {x = x * 10 + c - 48; c = getchar ();}
x *= f;
}
int main (){
Read (T);
while (T --){
ans = 0;
Read (n), Read (k);
for (int i = 1; i <= n; i ++)
Read (a[i]);
for (int i = 1; i <= n; i ++){
l[i] = r[i] = i;
while (l[i] >= 1 && a[l[i]] <= a[i])
l[i] --;
while (r[i] <= n && a[r[i]] <= a[i])
r[i] ++;
l[i] ++;
r[i] --;
}
for (int i = 0; i <= n; i ++)
dp[0][i][0] = Sum[0][i][0] = 1;
for (int i = 1; i <= n; i ++){
for (int j = 0; j <= n; j ++){
for (int z = 0; z <= k; z ++){
if (j){
dp[i][j][z] = dp[i][j - 1][z];
if (l[j] <= i && i <= r[j]){
if ((z - (i != j)) >= 0)//这里有特殊情况，如果j这个数它本身就在i这个位置，那么就不用耗费一个操作
dp[i][j][z] = (dp[i][j][z] + dp[i - 1][j - 1][z - (i != j)]) % mod;
if (l[j] < i && z){
dp[i][j][z] = (dp[i][j][z] + ((i - 2 >= 0) ? Sum[i - 2][j - 1][z - 1] : 0)) % mod;
dp[i][j][z] = ((dp[i][j][z] - ((l[j] - 2 >= 0) ? Sum[l[j] - 2][j - 1][z - 1] : 0)) % mod + mod) % mod;
}
}
}
Sum[i][j][z] = (Sum[i - 1][j][z] + dp[i][j][z]) % mod;
}
}
}
for (int i = 0; i <= k; i ++)
ans = (ans + dp[n][n][i]) % mod;
printf ("%d\n", ans);
}
return 0;
}