ZOJ 3497 Mistwald（矩阵快速幂）

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=4320

Mistwald

Time Limit: 2 Seconds Memory Limit: 65536 KB

In chapter 4 of the game Trails in the Sky SC, Estelle Bright and her friends are crossing Mistwald to meet their final enemy, Lucciola.
Mistwald is a mysterious place. It consists of M * N scenes, named Scene (1, 1) to Scene (M, N). Estelle Bright and her friends are initially
at Scene (1, 1), the entering scene. They should leave Mistwald from Scene (M, N), the exiting scene. Note that once they reach the exiting scene, they leave Mistwald and cannot come back. A scene in Mistwald has four exits, north, west,
south, and east ones. These exits are controlled by Lucciola. They may not lead to adjacent scenes. However, an exit can and must lead to one scene in Mistwald.



Estelle Bright and her friends walk very fast. It only takes them 1 second to cross an exit, leaving a scene and entering a new scene. Other time such as staying and resting can be ignored.
It is obvious that the quicker they leave Mistwald, the better.
Now you are competing with your roommate for who uses less time to leave Mistwald. Your roommate says that he only uses P seconds. It is known that he lies from time to time.
Thus, you may want to code and find out whether it is a lie.

Input

There are multiple test cases. The first line of input is an integer T ≈ 10 indicating the number of test cases.
Each test case begins with a line of two integers M and N (1 ≤ M, N ≤ 5), separated by a single space, indicating the size of Mistwald. In
the next M lines, the ith line contains N pieces of scene information, separated by spaces, describing Scene (i, 1) to Scene (i, N). A scene description has the form "((x1,y1),(x2,y2),(x3,y3),(x4,y4))"
(1 ≤ xk ≤ M; 1 ≤ yk ≤ N; 1 ≤ k ≤ 4) indicating the locations of new scenes the four exits lead to. The following line contains an integer Q (1 ≤ Q ≤ 100). In
the next Q lines, each line contains an integer P (0 ≤ P ≤ 100,000,000), which is the time your roommate tells you.
Test cases are separated by a blank line.

Output

For each P, output one of the following strings in one line: "True" if it cannot be a lie; "Maybe" if it can be a lie; "False" if it must be a lie.
Print a blank line after each case.

Sample Input

2
3 2
((3,1),(3,2),(1,2),(2,1)) ((3,1),(3,1),(3,1),(3,1))
((2,1),(2,1),(2,1),(2,2)) ((3,2),(3,2),(3,2),(3,2))
((3,1),(3,1),(3,1),(3,1)) ((3,2),(3,2),(3,2),(1,1))
3
1
2
10

2 1
((2,1),(2,1),(2,1),(2,1))
((2,1),(2,1),(2,1),(2,1))
2
1
2

Sample Output

Maybe
False
Maybe

True
False

Author: WU, Jun

Contest: The 8th Zhejiang Provincial Collegiate Programming Contest

摘自：

PS:http://blog.csdn.net/sdjzujxc/article/details/8720573

题意：

有一个n*m的矩阵，矩阵上每一个格子有四个传送门，分别通向四个格子，题目给出了每个格子的四个传送门所能到达的地方。起点在(1，1)，终点是(n，m)，当走到终点的时候就不能再走了，也就是说一旦你到达了终点，就会直接离开这个矩阵。问说从起点开始走P(0 ≤ P ≤ 100,000,000)步能不能到达终点。

输出的情况是True，Maybe和False。Ture对应的就是走了P步以后只能到达一个点，就是终点。Maybe对应的是走了P步之后还可以到达除了终点以外的其他点。False对应的是P步以后无法到达终点。
-------------------------------------------------------------------------------------------------------------------

给定一个有向图（最多25个节点，每个节点的出度最多为4），给定起点和终点，然后从起点开始走，走到终点就停止，否则一直往下走，问能不能P步到达终点。也就是说从起点出发，走一条长度为P的路径，路径中间点不能经过终点（但可以反复经过其他点）。如果从起点出发P步后，不能到达终点，就是False，如果可以到达终点也可以到其他别的点，就是Maybe，如果P步后只能到达终点（到别的点没有长度为P的路径），则是Yes。

样例输入意思：四个坐标分别为，m*n矩阵中的坐标，通过次计算出每个节点对应的出口，然后见图。

思路：显然的矩阵乘法。图的临接矩阵A的 p次方Ap中为1的元素(i,j)表示节点i到节点j有一条长度为p的路径（经历的节点可能重复）。要理解矩阵的含义，两个矩阵相乘如果(x,y)元素为1，而(y,z)元素为1,则结果(x,z)元素为1，这表明通过y把x和z连起来了。而题目要求经过终点就不能走了，所以在做矩阵乘法时，需要把（x,n-1） (n-1,y)这样决定的(x,y)去掉。（n-1表示终点）。做乘法时，中间点小心一点就好了。矩阵乘法和floyd在本质上是一样的……

矩阵的P次方运用的是经典的log(P)的算法。最后看一下结果矩阵的首行（0行）里面有几个1，以及(0,n-1)是不是1，来决定结果。

代码如下：

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

struct Matrix
{
    LL  m[50][50];
} I, A, B;
int ssize;
Matrix Mul(Matrix a,Matrix b)
{
    int i, j, k;
    Matrix c;
    for(i = 1; i <= ssize; i++)
    {
        for(j = 1; j <= ssize; j++)
        {
            c.m[i][j]=0;
            for(k = 1; k <= ssize; k++)
            {
                c.m[i][j]+=(a.m[i][k]*b.m[k][j]);
                //c.m[i][j]%=mod;
            }
        }
    }
    return c;
}

Matrix quickpagow(LL n)
{
    Matrix m = A, b = I;
    while(n)
    {
        if(n & 1)
            b = Mul(b,m);
        n = n >> 1;
        m = Mul(m,m);
    }
    return b;
}

int main()
{
    int t;
    int N, M;
    scanf("%d",&t);
    while(t--)
    {
        memset(I.m,0,sizeof(I.m));
        memset(A.m,0,sizeof(A.m));
        memset(B.m,0,sizeof(B.m));
        scanf("%d%d",&N,&M);
        getchar();

        int T = N*M;
        for(int i = 1; i <= T; i++)
        {
            I.m[i][i] = 1;
        }
        int x1, y1, x2, y2, x3, y3, x4, y4;
        for(int i = 1; i <= N; i++)
            for(int j = 1; j <= M; j++)
            {
                scanf("((%d,%d),(%d,%d),(%d,%d),(%d,%d))",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4);
                getchar();
                if(i==N && j==M)//图中路径不能经过终点
                    continue;
                int sta = (i-1)*M+j;
                A.m[sta][(x1-1)*M+y1]=1;
                A.m[sta][(x2-1)*M+y2]=1;
                A.m[sta][(x3-1)*M+y3]=1;
                A.m[sta][(x4-1)*M+y4]=1;
            }
        ssize = T;
        int q, p;
        scanf("%d",&q);
        while(q--)
        {
            scanf("%d",&p);
            B = quickpagow(p);
            if(B.m[1][T]==0)
                printf("False\n");
            else
            {
                int flag = 0;
                for(int i = 1; i < T; i++)
                {
                    if(B.m[1][i])
                    {
                        flag = 1;
                        break;
                    }
                }
                if(!flag)
                    printf("True\n");
                else//  恰好P步 既能到达终点又能到达其他点
                    printf("Maybe\n");
            }
        }
        printf("\n");
    }
    return 0;
}