文章目录
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
*.**
....
*.**
*.**
样例输出
0
0
0
0
0
4
1
1
2
思路
并不难的小思维题;
找出行里面的黑点最多的行号设为集合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老师 可以获得的最大快乐值。
样例输入
3 2
0 1
1 0
4 3
1 2 3
1 2 3
1 2 3
样例输出
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需要优化
矩阵快速幂优化
a
n
s
[
i
]
=
[
f
[
i
]
[
1
]
.
.
.
f
[
i
]
[
M
]
]
=
[
H
[
1
]
[
1
]
.
.
.
H
[
M
]
[
1
]
.
.
.
.
.
.
.
.
.
H
[
1
]
[
M
]
.
.
.
H
[
M
]
[
M
]
]
∗
[
f
[
i
−
1
]
[
1
]
.
.
.
f
[
i
−
1
]
[
M
]
]
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]
ans[i]=⎣⎢⎢⎢⎢⎡f[i][1]...f[i][M]⎦⎥⎥⎥⎥⎤=⎣⎢⎢⎢⎢⎡H[1][1]...H[1][M].........H[M][1]...H[M][M]⎦⎥⎥⎥⎥⎤∗⎣⎢⎢⎢⎢⎡f[i−1][1]...f[i−1][M]⎦⎥⎥⎥⎥⎤
这里的乘号\‘*’和数学里面的矩阵的乘法不同,这里是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);
}
}