Mistwald（ ZOJ - 3497，这也能用矩阵快速幂？！）

一.题目链接：

ZOJ-3497

二.题目大意：

m × n 的图.

起点为 (1, 1)，终点为（m，n）.

给出每个点的四个去处.

然后 Q 次询问

每次有一个整数 p 代表移动次数.

p 次移动后

if 不能到达终点，则输出 "False".

else if 只能移动到终点，则输出"True"

else 输出"Maybe"

三.分析：

本以为是个暴搜，结果是只披着搜索的矩阵快速幂. wsl

矩阵存图，若第 i 个点 与 第 j 个点相通，则D[i][j] == 1.

设 P = D × D.

由  

可得：若点 i 通过 2 个点到达 j 点，则 P[i][j] 非 0.

于是乎，就可以用矩阵快速幂了...

注意：题目中说，到达终点后，不可以再继续移动了，所以不可以记录终点的连接！

四.代码实现：

#include <set>
#include <map>
#include <ctime>
#include <queue>
#include <cmath>
#include <stack>
#include <vector>
#include <cstdio>
#include <sstream>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#define eps 1e-6
#define pi acos(-1.0)
#define ll long long int
using namespace std;

struct node
{
    int D[30][30];
};

int Size;

void init(node &T)
{
    for(int i = 1; i <= Size; ++i)
    {
        for(int j = 1; j <= Size; ++j)
            T.D[i][j] = 0;
    }
}

node juzhen(node a, node b)
{
    node c;
    init(c);
    for(int i = 1; i <= Size; ++i)
    {
        for(int j = 1; j <= Size; ++j)
        {
            for(int k = 1; k <= Size; ++k)
                c.D[i][j] += a.D[i][k] * b.D[k][j];
        }
    }
    return c;
}

node quick(node T, int p)
{
    node sum;
    for(int i = 1; i <= Size; ++i)
    {
        for(int j = 1; j <= Size; ++j)
        {
            if(i == j)
                sum.D[i][j] = 1;
            else
                sum.D[i][j] = 0;
        }
    }
    while(p)
    {
        if(p & 1)
            sum = juzhen(sum, T);
        T = juzhen(T, T);
        p >>= 1;
    }
    return sum;
}

int main()
{
    int T;
    scanf("%d", &T);
    while(T--)
    {
        int m, n;
        scanf("%d %d", &m, &n);
        Size = m * n;
        node T;
        init(T);
        getchar();
        for(int i = 1; i <= m; ++i)
        {
            for(int j = 1; j <= n; ++j)
            {
                int x1, y1, x2, y2, x3, y3, x4, y4;
                scanf("((%d,%d),(%d,%d),(%d,%d),(%d,%d))", &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4);
                getchar();
                if(i == m && j == n)
                    continue;
                T.D[(i - 1) * n + j][(x1 - 1) * n + y1] = 1;
                T.D[(i - 1) * n + j][(x2 - 1) * n + y2] = 1;
                T.D[(i - 1) * n + j][(x3 - 1) * n + y3] = 1;
                T.D[(i - 1) * n + j][(x4 - 1) * n + y4] = 1;
            }
        }
        int q;
        scanf("%d", &q);
        while((q--) > 0)
        {
            int p;
            scanf("%d", &p);
            node T2 = quick(T, p);
            if(!T2.D[1][Size])
                printf("False\n");
            else
            {
                bool flag = 0;
                for(int i = 1; i < Size; ++i)
                {
                    if(T2.D[1][i])
                        flag = 1;
                }
                if(flag)
                    printf("Maybe\n");
                else
                    printf("True\n");
            }
        }
        printf("\n");
    }
    return 0;
}