BNU29139——PvZ once again——————【矩阵快速幂】

PvZ once again

Time Limit: 2000ms

Memory Limit: 65536KB

64-bit integer IO format: %lld      Java class name: Main

Prev 

Submit Status Statistics Discuss

 Next

Type: 

None

 

  None   Graph Theory       2-SAT       Articulation/Bridge/Biconnected Component       Cycles/Topological Sorting/Strongly Connected Component       Shortest Path           Bellman Ford           Dijkstra/Floyd Warshall       Euler Trail/Circuit       Heavy-Light Decomposition       Minimum Spanning Tree       Stable Marriage Problem       Trees       Directed Minimum Spanning Tree       Flow/Matching           Graph Matching               Bipartite Matching               Hopcroft–Karp Bipartite Matching               Weighted Bipartite Matching/Hungarian Algorithm           Flow               Max Flow/Min Cut               Min Cost Max Flow   DFS-like       Backtracking with Pruning/Branch and Bound       Basic Recursion       IDA* Search       Parsing/Grammar       Breadth First Search/Depth First Search       Advanced Search Techniques           Binary Search/Bisection           Ternary Search   Geometry       Basic Geometry       Computational Geometry       Convex Hull       Pick's Theorem   Game Theory       Green Hackenbush/Colon Principle/Fusion Principle       Nim       Sprague-Grundy Number   Matrix       Gaussian Elimination       Matrix Exponentiation   Data Structures       Basic Data Structures       Binary Indexed Tree       Binary Search Tree       Hashing       Orthogonal Range Search       Range Minimum Query/Lowest Common Ancestor       Segment Tree/Interval Tree       Trie Tree       Sorting       Disjoint Set   String       Aho Corasick       Knuth-Morris-Pratt       Suffix Array/Suffix Tree   Math       Basic Math       Big Integer Arithmetic       Number Theory           Chinese Remainder Theorem           Extended Euclid           Inclusion/Exclusion           Modular Arithmetic       Combinatorics           Group Theory/Burnside's lemma           Counting       Probability/Expected Value   Others       Tricky       Hardest       Unusual       Brute Force       Implementation       Constructive Algorithms       Two Pointer       Bitmask       Beginner       Discrete Logarithm/Shank's Baby-step Giant-step Algorithm       Greedy       Divide and Conquer   Dynamic Programming                   Tag it!

植物大战僵尸算个out的游戏了，原谅被出题逼疯了的跑来挖坟了。

会玩的请无视这一段直接看题目{

游戏中僵尸向你的房子进发，吃掉沿途遇到的植物进入你的房子 你就死翘了

你在土地上种植各种植物来攻击阻挡僵尸

手推车：放置在终点，僵尸走到面前会启动推倒一整行的僵尸

大蒜：可种植的一种植物，发出恶心的气味，僵尸咬了一口就会换到邻近的另一行（如果有相邻两行，那么移动到另外两行概率是相等的）

南瓜：单纯的肉盾 被僵尸啃的

耐久度K： 植物被咬了K口后被僵尸吃掉

如有其他对游戏的不理解请clarify

}

问题是这样的：

我们的院子变成了N行M列的，而且种满了大蒜（耐久度K）（图是我盗了 我不会这么无聊的）coming的僵尸只有一只（然而这只僵尸貌似发生了变异，它每啃一口植物，同一列相同种类的植物也被啃掉一口，一口一排的样子恩恩），初始位置在第S行，因为没有放置攻击性的植物，所以僵尸就一路吃了，于是出题者很想知道僵尸死在自上而下1-N号手推车的概率各是多少

（无视掉图中的南瓜，实际上对僵尸行走没有影响。。）

 

Input

一个整数T（表示T组数据）

接下来的T组数据

每组给定四个整数 N M K S

数据范围

T<=1000

0<N<=20

0<M<=1000

0<K<=1000

1<=S<=N

 

Output

对于每组数据输出一行N个4位小数 用空格隔开 表示僵尸死在相应行的概率 行末没有空格

 

Sample Input

1
5 9 5 3

Sample Output

0.0000 0.5000 0.0000 0.5000 0.0000

Source

第十一届北京师范大学程序设计竞赛决赛

 

 

解题思路：求出概率转移矩阵，因为要转移m*k次，即（原始概率矩阵B）*（概率转移矩阵A）^m*k，所以根据矩阵相乘的结合律，所以可以让概率转移矩阵A先乘m*k次，因为B矩阵为所以最后只需用B矩阵乘以转移矩阵，输出乘以后的矩阵的第一行。

 

 

 

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <math.h>
#include <string>
#include <stdlib.h>
#include <time.h>
using namespace std;
const int maxn = 1e5+300;
int n;
struct Matrix{
	double mat[25][25];
	Matrix(){
		for(int i = 1; i < 25; i++){
			for(int j = 1; j < 25; j++){
				mat[i][j] = 0.0;
			}
		}
	}
	void mem(){
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= n; j++){
				mat[i][j] = 0.0;
			}
		}
	}
	void unit(){
		for(int i = 1; i < 25; i++)
			mat[i][i] = 1.0;
	}
	Matrix operator *(const Matrix &rhs)const{
		Matrix ret;
		for(int i = 1; i <= n; i++){
			for(int j = 1; j <= n; j++){
				ret.mat[i][j] = 0.0;
				for(int k = 1; k <= n; k++){
					ret.mat[i][j] += mat[i][k]*rhs.mat[k][j];
				}

			}
		}
		return ret;
	}
};
void deg(const Matrix &rhs){
	for(int i = 1; i <= n; i++){
		for(int j = 1; j <= n; j++){
			printf("%.4lf ",rhs.mat[i][j]);
		}puts("");
	}
}

Matrix & Quick( Matrix &p, int k){
	Matrix ret;
	ret.unit();
	while( k ){
		if(k&1){
			ret = ret*p;
		}
		k >>= 1;
		p = p*p;
	}
	p = ret;
	return p;
} 
int main(){
	int T, m, k, s;
	scanf("%d",&T);
	while(T--){
		scanf("%d%d%d%d",&n,&m,&k,&s);
		Matrix ans, trans;
		ans.mem();
		trans.mem();
		for(int i = 1; i <= n; i++){
			if( i == 1 ){
				trans.mat[i][2] = 1.0;
			}else if( i == n ){
				trans.mat[i][n-1] = 1.0;
			}else{
				trans.mat[i][i-1] = 0.5;
				trans.mat[i][i+1] = 0.5;
			}
		}
		if(n == 1){
			puts("1.0000"); continue;
		}
		trans = Quick(trans,m*k);
//		deg(trans);
		ans.mat[1][s] = 1.0;
		ans = ans*trans;
		printf("%.4lf",ans.mat[1][1]);
		for(int i = 2; i <= n; i++)
			printf(" %.4lf",ans.mat[1][i]);
		puts("");
	}
}

　　

图文详解：

假设以n,m,k,s分别为5，9,9,3为例。P、PP、PPP分别代表咬1、2、3口后的概率，只是对于耐久度为9时，他们是在同一列的，只不过为了表示，所以这样给出，不要误解。PP₁=0*  P₁+0.5*  P₂+0*   P₃+0*  P₄+  0 * P₅

　　　　　　　　　　　　　　　　PP₂=1*  P₁+0 *    P₂+0.5*P₃+0*  P₄+0*    P₅

　　　　　　　　　　　　　　　　PP₃=0*  P₁+0.5*  P₂+0*   P₃+0.5*P₄+0*   P₅

　　　　　　　　　　　　　　　　PP₄=0*  P₁+0*    P₂+0.5* P₃+0*　P₄+1*   P₅

　　　　　　　　　　　　　　　　PP₅=0*  P₁+0*    P₂+0*    P₃+0.5*P₄+0*   P₅

由上表可以看出，后一个列概率矩阵PP由前一个概率矩阵P乘以某一个矩阵得到。我们假设该某矩阵为A即：

0	1	0	0	0
0.5	0	0.5	0	0
0	0.5	0	0.5	0
0	0	0.5	0	0.5
0	0	0	1	0

将列概率矩阵转为行概率矩阵B：

P1

P2

P3

P4

P5

用B*A得到下一个行概率矩阵B‘。同时由于矩相乘具有结合律，所以我们可以用矩阵快速幂来先求出转移m次的转移矩阵A^m*k，然后用原始矩阵B*A^m*k即可求得。