week14（矩阵快速幂）

最新推荐文章于 2020-06-11 17:03:23 发布

qq_45697521

最新推荐文章于 2020-06-11 17:03:23 发布

阅读量201

点赞数

文章标签：程序设计

本文链接：https://blog.csdn.net/qq_45697521/article/details/106336799

版权

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

问题描述

每一个大人曾经都是一个小孩，Q老师也一样。

为了回忆童年，Q老师和 Monika 玩起了石头剪刀布的游戏，游戏一共 n 轮。无所不知的 Q老师知道每一轮 Monika 的出招，然而作为限制， Q老师在这 n 轮游戏中必须恰好出 a 次石头，b 次布和 c 次剪刀。

如果 Q老师赢了 Monika n/2(上取整) 次，那么 Q老师就赢得了这场游戏，否则 Q老师就输啦！

Q老师非常想赢，他想知道能否可以赢得这场游戏，如果可以的话，Q老师希望你能告诉他一种可以赢的出招顺序，任意一种都可以

Input

第一行一个整数 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’ 表示剪刀

Output

对于每组数据：

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

Example

Input

2
3
1 1 1
RPS
3
3 0 0
RPS

Output

YES
PSR
NO

解题思路

这个题目较为简单，我们只要根据对手的值进行判断即可；
q赢的所有情况有：q为石头，对手为剪刀；q为剪刀，对手为布；q为布，对手为石头。
因此我们只需要统计赢得次数即可，需要注意的就是剪刀、石头、布的次数，至多减到0。
至于不能赢的情况再从剩余的手型中随机匹配即可（我试过优先匹配相同手型，然后再匹配会输的手型，但是wrong了，随机匹配就AC了）。

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;

char q[200];
int main()
{
	int t, n, a, b, c, num;
	string s;
	cin>>t;
	while(t!=0)
	{
		num = 0;
		memset(q, 0, sizeof(q));
		cin>>n>>a>>b>>c;
		cin>>s;
		for(int i=0;i<n;i++)
		{
			if(s[i]=='S'&&a)
			{
				q[i] = 'R';
				num++, a--;
			}
			else if(s[i]=='R'&&b)
			{
				q[i] = 'P';
				num++, b--;	
			}
			else if(s[i]=='P'&&c)
			{
				q[i] = 'S';
				num++, c--;
			}	
		}
		if(num>=(n+1)/2)
		{
			cout<<"YES"<<endl;
			for(int i=0;i<n;i++)
			{
				if(q[i]!=0)
					cout<<q[i];
				else
				{
					if(a)     
                    {
                        cout<<"R";
                        a--;          
                    }
                    else if(b)
                    {
                        cout<<"P";
                        b--;
                    }
                    else
                    {
                        cout<<"S";
                        c--;
                    }
				}
			}
			cout<<endl;
		}
		else
			cout<<"NO"<<endl;
		t--;
	}
}

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老师每分钟可以选择一个白色的格子并且把它涂黑。现在他想知道要完成这个工作，最少需要几分钟？

Input

第一行包含一个整数 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， n*m 的总和不超过 4 * 10^5

Output

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

Example

Input

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

Output

解题思路

因为我们的数据比较多，开辟一个大数组的方式肯定是行不通的，因此分别记录一下每行每列被染黑的方格数目即可。
我原本的想法是要想求得最短时间，那么行列中的方格数目必然都是行列中的最大值，因此求出最大值看他们的交叉点是否为被染黑的即可。
但是这样其实并不准确，因为最大值可能有多个，而交叉时的情况可能有所不同，因此不能通过求最大值的方式求最短时间。必须通过两个for循环遍历各种情况，以此来找到最短时间。

代码

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

int r[50010], l[50010];
vector<int> num[50010];

int main()
{
	int t, n, m, num1, num2, x, y, sum, ans;
	char c;
	cin>>t;
	while(t!=0)
	{
		cin>>n>>m;
		num1 = 0, num2 = 0, ans = 10000000;
		for(int i=0;i<n;i++)
		{
			r[i] = 0;
			num[i].clear();
		}	
		for(int i=0;i<m;i++)
			l[i] = 0;
		for(int i=0;i<n;i++)
			for(int j=0;j<m;j++)
			{
				cin>>c;
				if(c=='*')
				{
					r[i]++, l[j]++;
					num[i].push_back(j);
				}				
			}
		for( int i = 0 ; i < n ; i++ )  
            for( int j = 0 ; j < m ; j++ )
            {
                sum = m + n - ( r[i] + l[j] ); 
                if( find(num[i].begin(), num[i].end(), j) == num[i].end() )
                    sum--;   
                if(sum == 0)
                {
                    ans = 0;
                    break;
                }
                ans = min(ans, sum);        //取最小值 
            }
        cout<<ans<<endl;
		t--;
	}
}

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老师的考验吗？

Input

输出文件包含多组测试用例，每组测试用例格式如下：

第一行给定两个正整数 k m。（k < 2e9, m < 1e5）

第二行给定十个整数，分别表示 a0～a9。

Output

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

Example

Input

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

Output

45
104

解题思路

矩阵快速幂的应用
在这里插入图片描述
求出转移矩阵和初始矩阵，使用矩阵快速幂求k-9次幂，然后输出最终矩阵的f[0][0]即可。

代码

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

int a[20], k, M;

struct Matrix
{
    int m[10][10];

    void set(int *a)
    {
        memset(m, 0, sizeof(m));
        for(int i=0;i<10;i++)
        	m[0][i] = a[i];
        for(int i=1;i<10;i++)
        	m[i][i-1] = 1;
    }
    Matrix() {}

    Matrix(const Matrix &t)
    {  //复制构造
        memcpy(m, t.m, sizeof(m));
    }
    Matrix operator*(const Matrix &t) const
    {
        Matrix res;
        for (int i = 0; i < 10; i++)
            for (int j = 0; j < 10; j++)
            {
                res.m[i][j] = 0;
                for (int k = 0; k < 10; k++)
                {
                    res.m[i][j] += m[i][k] * t.m[k][j] % M;
                    res.m[i][j] %= M;
                }
            }
        return res;
    }
};
Matrix quick_pow(Matrix a,int x)
{//矩阵快速幂
    Matrix ret;
    memset(ret.m, 0, sizeof(ret.m));
    for(int i=0;i<10;i++)
    	ret.m[i][0] = 9-i;
    while(x)
    {
        if (x & 1)
        	ret = a * ret;              
        a = a * a;
        x >>= 1;
    }
    return ret;
}

Matrix A, f;

int main()
{
    while (~scanf("%d %d", &k, &M))
    {
        for (int i = 0; i < 10; i++)
            scanf("%d", &a[i]);
        A.set(a);
        f = quick_pow(A, k-9);
        printf("%d\n", f.m[0][0]);
    }
    return 0;
}

D - Q老师染砖（选做）

问题描述

衣食无忧的 Q老师有一天突发奇想，想要去感受一下劳动人民的艰苦生活。

具体工作是这样的，有 N 块砖排成一排染色，每一块砖需要涂上红、蓝、绿、黄这 4 种颜色中的其中 1 种。且当这 N 块砖中红色和绿色的块数均为偶数时，染色效果最佳。

为了使工作效率更高，Q老师想要知道一共有多少种方案可以使染色效果最佳，你能帮帮他吗？

Input

第一行为 T，代表数据组数。(1 ≤ T ≤ 100)

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

Output

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

Example

Input

2
1
2

Output

2
6

解题思路

与上一题思路几乎一致，就是转移矩阵和初始矩阵的构造不同；
• 令 A[i] 表示 i 个格子，红绿均为偶数的染色方案数
• 令B[i] 表示 i 个格子，红绿均为奇数的染色方案数
• 令C[i] 表示 i 个格子，红绿有一个为偶数的染色方案数
DP 转移方程
• 根据 DP 状态，仔细思考转移情况即可得到
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]
所以矩阵快速幂为：
在这里插入图片描述

代码

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

int k, M;

struct Matrix
{
    int m[3][3];

    void set(int a[3][3])
    {
    	for(int i=0;i<3;i++)
    		for(int j=0;j<3;j++)
        		m[i][j] = a[i][j];
    }
    Matrix() {}

    Matrix(const Matrix &t)
    {  //复制构造
        memcpy(m, t.m, sizeof(m));
    }
    Matrix operator*(const Matrix &t) const
    {
        Matrix res;
        for (int i = 0; i < 3; i++)
            for (int j = 0; j < 3; j++)
            {
                res.m[i][j] = 0;
                for (int k = 0; k < 3; k++)
                {
                    res.m[i][j] += m[i][k] * t.m[k][j] % M;
                    res.m[i][j] %= M;
                }
            }
        return res;
    }
};
Matrix quick_pow(Matrix a,int x)
{//矩阵快速幂
    Matrix ret;
    memset(ret.m, 0, sizeof(ret.m));
    ret.m[0][0] = 1;
    while(x)
    {
        if (x & 1)	
        	ret = a * ret;         
        a = a * a;
        x >>= 1;
    }
    return ret;
}

Matrix A, f;

int main()
{
    int t, n;
    cin>>t;
    M = 10007;
    int a[3][3] = {2, 1, 0, 2, 2 ,2 , 0, 1, 2};
    while(t!=0)
    {
    	cin>>n;
    	A.set(a);
    	f = quick_pow(A, n);
    	cout<<f.m[0][0]<<endl;
    	t--;
	}
    return 0;
}

E - Q老师度假（选做）

问题描述

忙碌了一个学期的 Q老师决定奖励自己 N 天假期。

假期中不同的穿衣方式会有不同的快乐值。

已知 Q老师一共有 M 件衬衫，且如果昨天穿的是衬衫 A，今天穿的是衬衫 B，则 Q老师今天可以获得 f[A][B] 快乐值。

在 N 天假期结束后，Q老师最多可以获得多少快乐值？

Input

输入文件包含多组测试样例，每组测试样例格式描述如下：

第一行给出两个整数 N M，分别代表假期长度与 Q老师的衬衫总数。（2 ≤ N ≤ 100000, 1 ≤ M ≤ 100）

接下来 M 行，每行给出 M 个整数，其中第 i 行的第 j 个整数，表示 f[i][j]。（1 ≤ f[i][j] ≤ 1000000）

测试样例组数不会超过 10。

Output

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

Example

Input

Output

2
9

解题思路

依然是矩阵快速幂的使用。
状态定义：f[i][j] 表示第i天传第j件衣服所获得的快乐值的最大总和。
状态转移方程:f[i][j]=max(f[i−1][k]+H[k][j]),1≤k≤M 。
类比矩阵乘法定义，c[i][j]=∑(A[i][k]∗B[k][j]) ，因此将*改成了+，将∑改成了max 。
其他的跟前两题思路基本一致，就是初始矩阵和转移矩阵的值不相同而已。
需要注意的是由于数据较大，数据类型需要使用long long int;

代码

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

int f[110][110];
int N, M;

struct Matrix
{
    long long int m[110][110];

    void set()
    {
    	for(int i=0;i<M;i++)
    		for(int j=0;j<M;j++)
        		m[i][j] = f[i][j];
    }
    Matrix() {}

    Matrix(const Matrix &t)
    {  //复制构造
        memcpy(m, t.m, sizeof(m));
    }
    Matrix operator*(const Matrix &t) const
    {
        Matrix res;
        for (int i = 0; i < M; i++)
            for (int j = 0; j < M; j++)
            {
                res.m[i][j] = 0;
                for (int k = 0; k < M; k++)
                    res.m[i][j] = max(m[i][k] + t.m[k][j], res.m[i][j]);
            }
        return res;
    }
};
Matrix quick_pow(Matrix a,int x)
{//矩阵快速幂
    Matrix ret;
    memset(ret.m, 0, sizeof(ret.m));
    while(x)
    {
        if (x & 1)	
        	ret = a * ret;         
        a = a * a;
        x >>= 1;
    }
    return ret;
}

Matrix A, F;

int main()
{
    while(~scanf("%d %d", &N, &M))
    {
    	for(int i=0;i<M;i++)
    		for(int j=0;j<M;j++)
    			cin>>f[j][i];
    	A.set();
		F = quick_pow(A, N-1);
		long long int sum = 0;
		for(int i=0;i<M;i++)
			sum = max(sum, F.m[i][0]);
		cout<<sum<<endl;			
	}
    return 0;
}

qq_45697521

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
week14（矩阵快速幂）

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

扫一扫