GJYDAY1 NOIP+ 模拟赛——2019暑假篇

#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.输出样例：

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;
}