Week 14

最新推荐文章于 2024-06-03 08:30:00 发布

L&&S

最新推荐文章于 2024-06-03 08:30:00 发布

阅读量169

点赞数

分类专栏： SDU程序设计

本文链接：https://blog.csdn.net/weixin_44552961/article/details/106697268

版权

SDU程序设计专栏收录该内容

44 篇文章 0 订阅

订阅专栏

A - Q老师与石头剪刀布（必做）

每一个大人曾经都是一个小孩，Q老师也一样。
为了回忆童年，Q老师和 Monika 玩起了石头剪刀布的游戏，游戏一共 n 轮。无所不知的 Q老师知道每一轮 Monika 的出招，然而作为限制， Q老师在这 n 轮游戏中必须恰好出 a 次石头，b 次布和 c 次剪刀。
如果 Q老师赢了 Monika n/2(上取整) 次，那么 Q老师就赢得了这场游戏，否则 Q老师就输啦！
Q老师非常想赢，他想知道能否可以赢得这场游戏，如果可以的话，Q老师希望你能告诉他一种可以赢的出招顺序，任意一种都可以。

输入

第一行一个整数 t(1 ≤ t ≤ 100)表示测试数据组数。然后接下来的 t 组数据，每一组都有三个整数：
第一行一个整数 n(1 ≤ n ≤ 100)
第二行包含三个整数 a, b, c(0 ≤ a, b, c ≤ n)。保证 a+b+c=n
第三行包含一个长度为 n 的字符串 s，字符串 s 由且仅由 ‘R’, ‘P’, ‘S’ 这三个字母组成。第 i 个字母 s[i] 表示 Monika 在第 i 轮的出招。字母 ‘R’ 表示石头，字母 ‘P’ 表示布，字母 ‘S’ 表示剪刀

输出

对于每组数据：
如果 Q老师不能赢，则在第一行输出 “NO”(不含引号)
否则在第一行输出 “YES”(不含引号)，在第二行输出 Q老师的出招序列 t。要求 t 的长度为 n 且仅由 ‘R’, ‘P’, ‘S’ 这三个字母构成。t 中需要正好包含 a 个 ‘R’，b 个 ‘P’ 和 c 个 ‘S’
“YES”/"NO"是大小写不敏感的，但是 ‘R’, ‘P’, ‘S’ 是大小写敏感的。

样例输入

2
3
1 1 1
RPS
3
3 0 0
RPS

样例输出

YES
PSR
NO

思路

挺简单的思维题；
只计算Q老师能够赢的场次就行，不用考虑平局或者输局；
假设两个人出石头剪刀布的次数分别是a、b、c和a1、b1、c1
则Q老师赢的场次就等于 = min(a,b1)+min(b,c1)+min(c,a1);
写博客突然想到上面的小公式，哎，当时还模拟了一大堆。。。。

代码

#include <iostream>
#include <cstring>
#include <vector>

using namespace std;

int a,b,c;
int t,n;
string Monika;
string Q;
int winnum;
int needwin;

void init(){
	needwin=0;
	winnum=0;
	Monika.clear();
	Q.clear();
}

void work(){
	for(int i=0;i<Monika.size();i++){
		if(Monika[i]=='R'){//
			if(b>0){
				b--;
				winnum++;
				Q.push_back('P');
			}else{
				Q.push_back('*');
			}
		}else if(Monika[i]=='P'){
			if(c>0){
				c--;
				winnum++;
				Q.push_back('S');
			}else{
				Q.push_back('*');
			}
		}else if(Monika[i]=='S'){
			if(a>0){
				a--;
				winnum++;
				Q.push_back('R');
			}else{
				Q.push_back('*');
			}
		}
	}
	//RPS**SS
	if(winnum<needwin){
		cout<<"NO"<<endl;
		return;
	}else{
		cout<<"YES"<<endl;
		for(int i=0;i<Q.size();i++){
			if(Q[i]!='*')continue;
			if(a!=0){Q[i]='R';a--;continue;}
			if(b!=0){Q[i]='P';b--;continue;}
			if(c!=0){Q[i]='S';c--;continue;}
		}
		cout<<Q<<endl;
	}
	
}

int main(){
	cin>>t;
	for(int i=0;i<t;i++){
		init();
		cin>>n;
		cin>>a>>b>>c;
		cin>>Monika;
		
		if(n%2==0)needwin=n/2;
		else needwin = n/2+1;
		
		work();
	}	
}

B - Q老师与十字叉（必做）

Q老师得到一张 n 行 m 列的网格图，上面每一个格子要么是白色的要么是黑色的。
Q老师认为失去了十字叉的网格图莫得灵魂. 一个十字叉可以用一个数对 x 和 y 来表示, 其中 1 ≤ x ≤ n 并且 1 ≤ y ≤ m, 满足在第 x 行中的所有格子以及在第 y 列的所有格子都是黑色的
例如下面这5个网格图里都包含十字叉

第四个图有四个十字叉，分别在 (1, 3), (1, 5), (3, 3) 和 (3, 5).
下面的图里没有十字叉

Q老师得到了一桶黑颜料，他想为这个网格图注入灵魂。 Q老师每分钟可以选择一个白色的格子并且把它涂黑。现在他想知道要完成这个工作，最少需要几分钟？

输入

第一行包含一个整数 q (1 ≤ q ≤ 5 * 10^4) — 表示测试组数
对于每组数据：
第一行有两个整数 n 和 m (1 ≤ n, m ≤ 5 * 10^4, n * m ≤ 4 * 10^5) — 表示网格图的行数和列数
接下来的 n 行中每一行包含 m 个字符 — ‘.’ 表示这个格子是白色的， '’ 表示这个格子是黑色的
保证 q 组数据中 n 的总和不超过 5 * 10^4， nm 的总和不超过 4 * 10^5

输出

答案输出 q 行, 第 i 行包含一个整数 — 表示第 i 组数据的答案

样例输入

9
5 5
..*..
..*..
*****
..*..
..*..
3 4
****
.*..
.*..
4 3
***
*..
*..
*..
5 5
*****
*.*.*
*****
..*.*
..***
1 4
****
5 5
.....
..*..
.***.
..*..
.....
5 3
...
.*.
.*.
***
.*.
3 3
.*.
*.*
.*.
4 4
*.**
....
*.**
*.**

样例输出

思路

并不难的小思维题；
找出行里面的黑点最多的行号设为集合S，设此时白点共a个
找出列里面的黑点最多的列号设为集合E，设此时白点共b个
如果某行和某列的交集是白点则最小值是a+b-1;
否则是a+b;

坑点

行和列如果交叉的地方是白点，则只需要染色一个即可；
在这里插入图片描述

代码

#include <iostream>
#include <cstring>
#include <vector>
#define inf 1e8
using namespace std;
const int maxn=5e4+50;
char *road[maxn];
int q;
int n,m;

vector<int> row;
vector<int> col;

vector<int> row_num,col_num;

void init(){
	row_num.clear();
	col_num.clear();
	
	row.clear();
	col.clear();
	
	row_num.resize(n+10);
	col_num.resize(m+10);
	for(int i=0;i<n+10;i++)row_num[i]=0;
	for(int i=0;i<m+10;i++)col_num[i]=0;
}

void work(){

	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(road[i][j]=='.'){
				row_num[i]++;
				col_num[j]++;
			}else if(road[i][j]=='*'){
				continue;
			}
		}
	}
	
	int row_min = inf;
	int col_min = inf;
	
	for(int i=0;i<n;i++){
		if(row_min > row_num[i]){
			row_min = row_num[i];
		}
	}
	for(int i=0;i<m;i++){
		if(col_min > col_num[i]){
			col_min = col_num[i];
		}
	}	
	
	for(int i=0;i<n;i++){
		if(row_min == row_num[i]){
			row.push_back(i);
		}
	}
	for(int i=0;i<m;i++){
		if(col_min == col_num[i]){
			col.push_back(i);
		}
	}	
	
	bool flag = false;
	for(int i=0;i<row.size();i++){
		for(int j=0;j<col.size();j++){
			if(road[row[i]][col[j]]=='.'){
				flag = true;
				break;
			}
		}
	}
	
	int number = col_min+row_min;
	if(flag)number--;
	cout<<number<<endl;
	
}

int main(){
	cin>>q;
	for(int i=0;i<q;i++){
		
		cin>>n>>m;
		init();
		for(int j=0;j<=n;j++){
			road[j] = new char[m+1];
		}
		
		for(int j=0;j<n;j++){
			scanf("%s",road[j]);
//			cout<<"here"<<road[j]<<endl;
		}
		
		work();
		
		
		for(int j=0;j<=n;j++){
			delete []road[j];
		}
	}
}

C - Q老师的考验（必做）

Q老师对数列有一种非同一般的热爱，尤其是优美的斐波那契数列。
这一天，Q老师为了增强大家对于斐波那契数列的理解，决定在斐波那契的基础上创建一个新的数列 f(x) 来考一考大家。数列 f(x) 定义如下：
当 x < 10 时，f(x) = x；
当 x ≥ 10 时，f(x) = a0 * f(x-1) + a1 * f(x-2) + a2 * f(x-3) + …… + a9 * f(x-10)，ai 只能为 0 或 1。
Q老师将给定 a0～a9，以及两个正整数 k m，询问 f(k) % m 的数值大小。
聪明的你能通过 Q老师的考验吗？

输入

输出文件包含多组测试用例，每组测试用例格式如下：
第一行给定两个正整数 k m。（k < 2e9, m < 1e5）
第二行给定十个整数，分别表示 a0～a9。

输出

对于每一组测试用例输出一行，表示 f(k) % m 的数值大小。

样例输入

10 9999
1 1 1 1 1 1 1 1 1 1
20 500
1 0 1 0 1 0 1 0 1 0

样例输出

45
104

思路

综述

并不难，是一个矩阵快速幂的初探。
首先要构造矩阵的递推式，从而找到常数矩阵。矩阵递推式如下
在这里插入图片描述

注意点：

初始化的问题.如下代码所示：
也就是mx第一个矩阵的初始化问题。

	for(int i=0;i<N;i++)mx.x[0][i] = a[i];
	for(int i=1;i<N;i++){
		mx.x[i][i-1]=1;
	}

总结

矩阵快速幂

模板如下所示，根普通的快速幂十分类似，只不过操作的元素需要重载一下乘法；

Matrix quick_pow(Matrix a,int x){
    Matrix ret;
    /*
        以2*2的矩阵为例
        1 0
        0 1
    */
   ret.x[0][1] = ret.x[1][0] = 0;
   ret.x[0][0] = ret.x[1][1] = 1;
   while(x){
       if(x & 1) ret = ret * a;
       a = a * a;
       x >>= 1;
   }
   return ret;
}

坑点

注意在矩阵快速幂里面单位矩阵注意和相乘的举着的行数一样！！！

代码

//long long问题
 
#include <iostream>
#include <vector>
#include <cstdio>
#include <cstdlib>
#include <cstring>
using namespace std;

const int N=10;
int K,M;
int a[10];
struct Matrix{
	int x[N][N];
	Matrix operator *(const Matrix & t)const{
		Matrix ret;
		for(int i=0;i<N;i++){
			for(int j=0;j<N;j++){
				ret.x[i][j] = 0;
				for(int k=0;k<N;k++){
					ret.x[i][j] += x[i][k] * t.x[k][j] % M;
					ret.x[i][j] %= M;
				}
			}
		}
		return ret;
	}
	Matrix(){memset(x,0,sizeof(x));}
	Matrix(const Matrix &t){memcpy(x,t.x,sizeof(x));}
}; 

Matrix quick_pow(Matrix t, int x){
	Matrix ret;
	for(int i=0;i<N;i++)ret.x[i][i]=1;
	
	while(x){
		if(x & 1) ret = ret * t;
		t = t * t;
		x >>= 1;
	}
	return ret;
}


int main(){
	while(~scanf("%d%d",&K,&M)){
		for(int i=0;i<N;i++){
			scanf("%d",&a[i]);
		}
		if(K<10)printf("%d\n",K);
		else{
			Matrix mx;
			
			for(int i=0;i<N;i++)mx.x[0][i] = a[i];
			for(int i=1;i<N;i++){
				mx.x[i][i-1]=1;
			}
			mx = quick_pow(mx,K-9);
			int ans = 0;
			for(int i=0;i<=9;i++){
				ans += mx.x[0][i]*(9-i);	
			}
			printf("%d\n",ans%M);
		}
	} 
}

D - Q老师染砖（选做）

衣食无忧的 Q老师有一天突发奇想，想要去感受一下劳动人民的艰苦生活。
具体工作是这样的，有 N 块砖排成一排染色，每一块砖需要涂上红、蓝、绿、黄这 4 种颜色中的其中 1 种。且当这 N 块砖中红色和绿色的块数均为偶数时，染色效果最佳。
为了使工作效率更高，Q老师想要知道一共有多少种方案可以使染色效果最佳，你能帮帮他吗？

输入

第一行为 T，代表数据组数。(1 ≤ T ≤ 100)
接下来 T 行每行包括一个数字 N，代表有 N 块砖。(1 ≤ N ≤ 1e9)

输出

输出满足条件的方案数，答案模 10007。

样例输入

2
1
2

样例输出

2
6

思路

综述

这是一道用矩阵快速幂来优化DP的问题。
与上一道题的矩阵快速幂优化普通递推过程不同，这里是和DP问题结合，所以首先按照DP问题一般求解思路做。

状态定义

A[i]：表示 i 个格子，红绿均为偶数的染色方案数
B[i]：表示 i 个格子，红绿均为奇数的染色方案数
C[i]：表示 i 个格子，红绿有一个为偶数的染色方案数

状态转移

A[i] = 2 * A[i-1] + C[i-1]
B[i] = 2 * B[i-1] + C[i-1]
C[i] = 2 * A[i-1] + 2 * B[i-1] + 2 * C[i-1]

矩阵快速幂优化

在这里插入图片描述

总结

什么时候需要优化DP

转移方程需要是线性递推式
转移次数很多，如本题是1e9

容易忽略的点

DP问题状态定义，转移方程定义，如何转移
三个基本问题是解决DP的关键。
状态的定义可能会有多个，转移过程也可能是多个。

代码

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
using namespace std;

const long long N = 3;
const long long MOD = 10007;
long long T;

struct Matrix{
	long long x[N][N];
	Matrix operator * (const Matrix & t)const{
		Matrix ret;
		for(int i=0;i<N;i++){
			for(int j=0;j<N;j++){
				ret.x[i][j] = 0;
				for(int k=0;k<N;k++){
					ret.x[i][j] += x[i][k] * t.x[k][j] % MOD;
					ret.x[i][j] %= MOD;
				}
			}
		}
		return ret;
	}
	Matrix(){memset(x,0,sizeof(x));}
	Matrix(const Matrix & t){memcpy(x,t.x,sizeof(x));}
};

Matrix quick_pow(Matrix t,long long x){
	Matrix ret;
	for(int i=0;i<N;i++)ret.x[i][i]=1;
	while(x){
		if(x & 1)ret = ret * t;
		t = t * t;
		x >>= 1;
	}
	return ret;
}

int n;

int main(){
	scanf("%d",&T);
	Matrix mx;
	
	while(T--){
		mx.x[0][0]=2;mx.x[0][1]=0;mx.x[0][2]=1;
		mx.x[1][0]=0;mx.x[1][1]=2;mx.x[1][2]=1;
		mx.x[2][0]=2;mx.x[2][1]=2;mx.x[2][2]=2;	
		
		scanf("%d",&n);
		if(n==1)printf("2\n");
		else{
			mx = quick_pow(mx,n-1);
			printf("%lld\n",(mx.x[0][0]*2+mx.x[0][2]*2)%MOD);
		}
		
	}
}

E - Q老师度假（选做）

忙碌了一个学期的 Q老师决定奖励自己 N 天假期。
假期中不同的穿衣方式会有不同的快乐值。
已知 Q老师一共有 M 件衬衫，且如果昨天穿的是衬衫 A，今天穿的是衬衫 B，则 Q老师今天可以获得 f[A][B] 快乐值。
在 N 天假期结束后，Q老师最多可以获得多少快乐值？

输入

输入文件包含多组测试样例，每组测试样例格式描述如下：
第一行给出两个整数 N M，分别代表假期长度与 Q老师的衬衫总数。（2 ≤ N ≤ 100000, 1 ≤ M ≤ 100）
接下来 M 行，每行给出 M 个整数，其中第 i 行的第 j 个整数，表示 f[i][j]。（1 ≤ f[i][j] ≤ 1000000）
测试样例组数不会超过 10。

输出

每组测试样例输出一行，表示 Q老师可以获得的最大快乐值。

样例输入

样例输出

2
9

思路

综述

这是一道矩阵快速幂和普通的动态规划问题的结合。
首先按照动态规划的思路思考：

构建状态

f[i][j]表示第i天穿j号衣服所获得的最大快乐值

初始化

f[1][k] = 0(1<=k<=M)

转移

f[i][j] = max{f[i-1][k]+M[k][j]}(1<=k<=M)

很显然，复杂度是O(N*M*M)大约是1e10需要优化

矩阵快速幂优化

$ans[i]=\left[ \begin{matrix} f[i][1]\\ .\\ .\\ .\\ f[i][M] \end{matrix} \right]=\left[ \begin{matrix} H[1][1] & ... & H[M][1] \\ . & . & .\\ . & . & .\\ . & . & .\\ H[1][M] & ... & H[M][M] \end{matrix} \right] * \left[ \begin{matrix} f[i-1][1]\\ .\\ .\\ .\\ f[i-1][M] \end{matrix} \right]$
这里的乘号\‘*’和数学里面的矩阵的乘法不同，这里是max运算，也就是

c[i][j] = max{a[i][k] + b[k][j]}(1<=k<=M)

注意下面矩阵乘法中的for循环中间的运算是max

		for(int i=0;i<maxn;i++){
			for(int j=0;j<maxn;j++){
				ret.x[i][j] = 0;
				for(int k=0;k<maxn;k++){
					ret.x[i][j] = max(ret.x[i][j],(x[i][k] + t.x[k][j]));
				}
			}
		}

总结

矩阵快速幂中的矩阵运算，只需要满足结合律就行，并不一定非得是乘法
这里的矩阵快速幂里面的矩阵和给定的快乐值矩阵不一样，需要转置

代码

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;
const long long maxn = 105;
long long max2d[105];

struct Matrix{
	long long x[maxn][maxn];
	Matrix operator * (const Matrix &t )const{
		Matrix ret;
		for(int i=0;i<maxn;i++){
			for(int j=0;j<maxn;j++){
				ret.x[i][j] = 0;
				for(int k=0;k<maxn;k++){
					ret.x[i][j] = max(ret.x[i][j],(x[i][k] + t.x[k][j]));
				}
			}
		}
		return ret;
	}
	Matrix(){memset(x,0,sizeof(x));}
	Matrix(const Matrix &t){memcpy(x,t.x,sizeof(x));}
};
Matrix quick_pow(Matrix &t,long long x){
	Matrix ret;
	while(x){
		if(x & 1)ret = ret * t;
		t = t * t;
		x >>= 1;
	}
	return ret;
}
void init(){
	for(int i=0;i<maxn;i++)max2d[i] = 0;
}
int N,M;
int main(){
	while(~scanf("%d%d",&N,&M)){
		init();
		Matrix mx;
		
		for(int i=0;i<M;i++){
			for(int j=0;j<M;j++){
				scanf("%lld",&mx.x[i][j]);
			}
		}
		for(int i=0;i<M;i++){
			for(int j=0;j<M;j++){
				max2d[i] = max(max2d[i],mx.x[i][j]);
			}
		}
		mx = quick_pow(mx , N-2);
		long long ans=-1;
		for(int i=0;i<M;i++){
			for(int j=0;j<M;j++)
			ans = max(ans,(mx.x[i][j]+max2d[j]));
		}
		printf("%lld\n",ans);
	}
}

L&&S

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Week 14

文章目录A - Q老师与石头剪刀布（必做）输入输出样例输入样例输出思路代码B - Q老师与十字叉（必做）输入输出样例输入样例输出思路坑点代码C - Q老师的考验（必做）输入输出样例输入样例输出思路综述总结代码输入输出样例输入样例输出思路综述总结代码输入输出样例输入样例输出思路综述总结代码A - Q老师与石头剪刀布（必做）每一个大人曾经都是一个小孩，Q老师也一样。为了回忆童年，Q老师和 Monika 玩起了石头剪刀布的游戏，游戏一共 n 轮。无所不知的 Q老师知道每一轮 Monika 的出招，然
复制链接

扫一扫