poj3735(矩阵快速幂)

本文介绍了一种使用矩阵快速幂算法来模拟多只猫咪进行特定训练序列的问题。通过构建矩阵并利用快速幂运算,可以高效地计算出经过多次重复训练后每只猫咪所拥有的花生数量。

Training little cats
Time Limit: 2000MS Memory Limit: 65536K
Total Submissions: 14625 Accepted: 3619

Description

Facer's pet cat just gave birth to a brood of little cats. Having considered the health of those lovely cats, Facer decides to make the cats to do some exercises. Facer has well designed a set of moves for his cats. He is now asking you to supervise the cats to do his exercises. Facer's great exercise for cats contains three different moves:
g i : Let the ith cat take a peanut.
e i : Let the ith cat eat all peanuts it have.
s i j : Let the ith cat and jth cat exchange their peanuts.
All the cats perform a sequence of these moves and must repeat it m times! Poor cats! Only Facer can come up with such embarrassing idea. 
You have to determine the final number of peanuts each cat have, and directly give them the exact quantity in order to save them.

Input

The input file consists of multiple test cases, ending with three zeroes "0 0 0". For each test case, three integers nm and k are given firstly, where n is the number of cats and k is the length of the move sequence. The following k lines describe the sequence.
(m≤1,000,000,000, n≤100, k≤100)

Output

For each test case, output n numbers in a single line, representing the numbers of peanuts the cats have.

Sample Input

3 1 6
g 1
g 2
g 2
s 1 2
g 3
e 2
0 0 0

Sample Output

2 0 1

题意:有n只猫一开始他们的值都是0,有三种操作,第i只猫值加1,第i只猫值变为0,dii只猫和第j只猫值交换,这样的操作选择几组,重复m次,求出最后每只猫的值。

思路:矩阵快速幂,就是建矩阵比较难,参考:http://blog.youkuaiyun.com/u013068502/article/details/38355621


#include<iostream>
#include<stdio.h>
#include<string.h>
using namespace std;
#define ll long long
int n,m,k;
struct mat
{
	ll a[105][105];     //a[i][n]存放第i只猫有的豆子数 
};
mat mat_mul(mat x,mat y)  //矩阵相乘 
{  
    mat res;  
    memset(res.a,0,sizeof(res.a));  
    for(int i=0;i<=n;i++)  
        for(int j=0;j<=n;j++)  
        {
        	if(x.a[i][j])       //优化,判断这个点是否为0 
        	{
        		for(int k=0;k<=n;k++)
        		{
        			res.a[i][k]+=(x.a[i][j]*y.a[j][k]);
				}
			}
		}
    return res;  
}  
void solve()
{
	mat op,op0;
	memset(op.a,0,sizeof(op.a));
	for(int i=0;i<=n;i++)op.a[i][i]=1;
	op0=op;
	char s[2];
	int x,y;
	//先把做一次后的结果矩阵找出来 
	for(int i=0;i<k;i++)
	{
		scanf("%s",s);
		mat op1=op;
		if(s[0]=='g')
		{
			scanf("%d",&x);
			op1.a[x-1][n]=1;
		}
		else if(s[0]=='e')
		{
			scanf("%d",&x);
			op1.a[x-1][x-1]=0;
		}
		else if(s[0]=='s')
		{
			scanf("%d%d",&x,&y);
			op1.a[x-1][x-1]=0;
			op1.a[x-1][y-1]=1;
			op1.a[y-1][y-1]=0;
			op1.a[y-1][x-1]=1;
		}
		op0=mat_mul(op1,op0);
	}
	//矩阵快速幂 
	while(m)
	{
		if(m&1)op=mat_mul(op0,op);
		op0=mat_mul(op0,op0);
		m>>=1;
	}
	for(int i=0;i<n-1;i++)printf("%lld ",op.a[i][n]);
	printf("%lld\n",op.a[n-1][n]);
}
int main()
{
	while(~scanf("%d%d%d",&n,&m,&k)&&(n||m||k))
	{
		solve();
	}
} 


### 关于POJ 1995问题的快速幂C++实现 对于POJ 1995问题,其核心在于通过矩阵快速幂算法高效解决大规模数据下的指数运算。以下是基于引用材料中的相关内容构建的一个完整的解决方案。 #### 矩阵快速幂的核心逻辑 矩阵快速幂是一种高效的计算方式,在处理线性递推关系时尤为有效。例如斐波那契数列可以通过构造特定的转移矩阵来加速计算[^4]。具体来说,给定一个初始状态向量和一个转移矩阵,经过若干次幂运算后可获得目标状态。 以下是一个通用的矩阵快速幂模板: ```cpp #include <iostream> using namespace std; const int N = 2; // 定义矩阵大小 struct Matrix { long long m[N][N]; }; // 矩阵乘法函数 Matrix multiply(const Matrix& a, const Matrix& b) { Matrix c; for (int i = 0; i < N; ++i) { for (int j = 0; j < N; ++j) { c.m[i][j] = 0; for (int k = 0; k < N; ++k) { c.m[i][j] += a.m[i][k] * b.m[k][j]; c.m[i][j] %= 10000; // 取模操作 } } } return c; } // 快速幂函数 Matrix fastPower(Matrix base, long long exp) { Matrix result; for (int i = 0; i < N; ++i) { for (int j = 0; j < N; ++j) { result.m[i][j] = (i == j); } } while (exp > 0) { if (exp % 2 == 1) { result = multiply(result, base); } base = multiply(base, base); exp /= 2; } return result; } int main() { long long n; cin >> n; // 初始化转移矩阵 Matrix trans; trans.m[0][0] = 0; trans.m[0][1] = 1; trans.m[1][0] = 1; trans.m[1][1] = 1; // 计算结果矩阵 if (n == 0 || n == 1) { cout << 1 << endl; } else { Matrix res = fastPower(trans, n - 1); // 初始状态向量 long long fib_prev = 1; long long fib_curr = 1; // 输出结果 cout << (res.m[0][0] * fib_prev + res.m[0][1] * fib_curr) % 10000 << endl; } return 0; } ``` 此代码实现了针对斐波那契数列的大规模项求解功能,并采用了取模`%10000`的操作以满足题目需求。其中的关键部分包括矩阵乘法、快速幂以及状态转移的设计[^3]。 #### 特殊注意点 在实际提交过程中需要注意以下几个方面: - **大数组定义**:如果涉及更大的矩阵或者更复杂的动态规划表,则需特别留意内存分配的位置及其范围限制[^2]。 - **时间复杂度控制**:尽管快速幂本身具有较低的时间复杂度O(log n),但在极端情况下仍需验证是否存在进一步优化空间。 - **边界条件处理**:如输入为较小数值时直接返回已知答案而非进入循环计算流程。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值