NOIP2013提高组day2 - T3:华容道

发布时间:2024年01月12日

题目链接

[NOIP2013 提高组] 华容道

题目描述

小 B 最近迷上了华容道,可是他总是要花很长的时间才能完成一次。于是,他想到用编程来完成华容道:给定一种局面, 华容道是否根本就无法完成,如果能完成, 最少需要多少时间。

小 B 玩的华容道与经典的华容道游戏略有不同,游戏规则是这样的:

  1. 在一个 n × m n \times m n×m 棋盘上有 n × m n \times m n×m 个格子,其中有且只有一个格子是空白的,其余 n × m ? 1 n \times m-1 n×m?1 个格子上每个格子上有一个棋子,每个棋子的大小都是 1 × 1 1 \times 1 1×1 的;
  2. 有些棋子是固定的,有些棋子则是可以移动的;
  3. 任何与空白的格子相邻(有公共的边)的格子上的棋子都可以移动到空白格子上。

游戏的目的是把某个指定位置可以活动的棋子移动到目标位置。

给定一个棋盘,游戏可以玩 q q q 次,当然,每次棋盘上固定的格子是不会变的, 但是棋盘上空白的格子的初始位置、 指定的可移动的棋子的初始位置和目标位置却可能不同。第 i i i 次玩的时候, 空白的格子在第 E X i EX_i EXi? 行第 E Y i EY_i EYi? 列,指定的可移动棋子的初始位置为第 S X i SX_i SXi? 行第 S Y i SY_i SYi?列,目标位置为第 T X i TX_i TXi? 行第 T Y i TY_i TYi? 列。

假设 小 B 每秒钟能进行一次移动棋子的操作,而其他操作的时间都可以忽略不计。请你告诉 小 B 每一次游戏所需要的最少时间,或者告诉他不可能完成游戏。

输入格式

第一行有 3 3 3个整数,每两个整数之间用一个空格隔开,依次表示 n , m , q n,m,q n,m,q

接下来的 n n n 行描述一个 n × m n \times m n×m 的棋盘,每行有 m m m 个整数,每两个整数之间用一个空格隔开,每个整数描述棋盘上一个格子的状态, 0 0 0 表示该格子上的棋子是固定的, 1 1 1 表示该格子上的棋子可以移动或者该格子是空白的。

接下来的 q q q 行,每行包含 6 6 6 个整数依次是 E X i , E Y i , S X i , S Y i , T X i , T Y i EX_i,EY_i,SX_i,SY_i,TX_i,TY_i EXi?,EYi?,SXi?,SYi?,TXi?,TYi?,每两个整数之间用一个空格隔开,表示每次游戏空白格子的位置,指定棋子的初始位置和目标位置。

输出格式

q q q 行,每行包含 1 1 1 个整数,表示每次游戏所需要的最少时间,如果某次游戏无法完成目标则输出 ? 1 ?1 ?1

样例 #1

样例输入 #1

3 4 2
0 1 1 1
0 1 1 0
0 1 0 0
3 2 1 2 2 2
1 2 2 2 3 2

样例输出 #1

2
-1

提示

输入输出样例说明

棋盘上划叉的格子是固定的,红色格子是目标位置,圆圈表示棋子,其中绿色圆圈表示目标棋子。

  1. 第一次游戏,空白格子的初始位置是 ( 3 , 2 ) (3,2) (3,2)(图中空白所示),游戏的目标是将初始位置在 ( 1 , 2 ) (1, 2) (1,2) 上的棋子(图中绿色圆圈所代表的棋子)移动到目标位置 ( 2 , 2 ) (2, 2) (2,2)(图中红色的格子)上。

移动过程如下:

  1. 第二次游戏,空白格子的初始位置是 ( 1 , 2 ) (1, 2) (1,2)(图中空白所示),游戏的目标是将初始位置在 ( 2 , 2 ) (2, 2) (2,2) 上的棋子(图中绿色圆圈所示)移动到目标位置 ( 3 , 2 ) (3, 2) (3,2) 上。

要将指定块移入目标位置,必须先将空白块移入目标位置,空白块要移动到目标位置,必然是从位置 ( 2 , 2 ) (2,2) (2,2) 上与当前图中目标位置上的棋子交换位置,之后能与空白块交换位置的只有当前图中目标位置上的那个棋子,因此目标棋子永远无法走到它的目标位置, 游戏无法完成。

数据范围

对于 30 % 30\% 30% 的数据, 1 ≤ n , m ≤ 10 , q = 1 1 ≤ n, m ≤ 10,q = 1 1n,m10,q=1

对于 60 % 60\% 60% 的数据, 1 ≤ n , m ≤ 30 , q ≤ 10 1 ≤ n, m ≤ 30,q ≤ 10 1n,m30,q10

对于 100 % 100\% 100% 的数据, 1 ≤ n , m ≤ 30 , q ≤ 500 1 ≤ n, m ≤ 30,q ≤ 500 1n,m30,q500

算法思想

根据题目描述,要通过一个空白格子,将指定棋子(绿色),移动到目标位置(黄色)。由于每次移动,都要借助空白格子,因此不妨将空白格子当成一颗“特殊”棋子,通过移动这颗空白棋子来完成要求,如下图所示。
在这里插入图片描述
可以把移动过程分成两部分:

  • 首先,将空白棋子移动到绿色棋子相邻的 4 4 4个格子上,这样才能移动绿色棋子,如下图所示。
    在这里插入图片描述

由于每秒钟能进行一次移动棋子,因此可以用bfs处理将空白棋子移动到绿色棋子相邻 4 4 4个格子上的移动步数。这样就可以建立从空白格子 ( E X , E Y ) (EX,EY) (EX,EY)指向绿色棋子 4 4 4个相邻的点的边, ( E X , E Y ) → ( s x , s y , k ) (EX,EY)\to(sx,sy,k) (EX,EY)(sx,sy,k),其边权就是最小移动次数。

  • 其次,在有解的情况下,只需要调整空白棋子和绿色棋子的相对位置,就能将绿色棋子移动目标位置。对于绿色棋子每个相邻位置上的空白棋子都有 4 4 4种选择,以左侧相邻的空白棋子为例,如下图所示
    • 和绿色棋子进行交换
    • 走到绿色棋子上边相邻位置
    • 走到绿色棋子右边相邻位置
    • 走到绿色棋子下边相邻位置

在这里插入图片描述

每种选择对应的移动次数不同,为了能够快速计算出最小步数,可以预处理出从第 i i i j j j列棋子的相邻 k k k方向上的格子出发,移动到该棋子其它相邻 3 3 3个方向上的最小步数。
据此,可以建立一条边从 ( i , j , k ) → ( i , j , k ′ ) (i,j,k)\to(i,j,k') (i,j,k)(i,j,k),其中 ( i , j ) (i,j) (i,j)表示绿色棋子所在行列, k k k k ′ k' k表示相邻的不同方向,其权值就是就是移动步数。

例如:
在这里插入图片描述
基于上述分析,可以构建一个出一个图,将绿色棋子从初始位置移动到目标位置的最小步数,就是求图的最短路,可以使用spfa算法求解。

时间复杂度

  • 预处理第 i i i j j j列的绿色棋子上在其相邻 k k k方向上的格子,移动到该棋子其它相邻 3 3 3个方向上的最小步数,需要枚举每个格子时间复杂度为 n × m n\times m n×m,bfs算法处理的状态数为 n × m × 4 n\times m \times 4 n×m×4。总的时间复杂度为 O ( n 2 m 2 × 4 ) = 90 0 2 × 4 = 3 , 240 , 000 O(n^2m^2\times4)=900^2\times4=3,240,000 O(n2m2×4)=9002×4=3,240,000
  • spfa的时间复杂度最好情况为 O ( E ) O(E) O(E),最坏情况是 O ( E V ) O(EV) O(EV),其中 E E E表示边数, V V V表示点数,一共有 30 × 30 × 4 = 3 , 600 30\times 30\times4=3,600 30×30×4=3,600个点,每个点有 4 4 4条边,边数为 3600 t i m e s 4 = 14 , 400 3600times4=14,400 3600times4=14,400

代码实现

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 35, M = 3605, K = M * 4, INF = 0x3f3f3f3f;
int n, m, Q;
int g[N][N], dis1[N][N], dis2[M];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int h[M], e[K], ne[K], w[K], idx;
bool st[M];
void add(int a, int b, int c)  // 添加一条边a->b,边权为c
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
//根据行列和方向,获取点的编号
int get(int x, int y, int z)
{
    return ((x - 1) * m + y - 1) * 4 + z;
}
//(bx,by)表示空白格子,(gx,gy)表示绿色格子,d表示方向
void bfs(int bx, int by, int gx, int gy, int d)
{
    queue<PII> q;
    memset(dis1, 0x3f, sizeof dis1);
    dis1[bx][by] = dis1[gx][gy] = 0; //不能走到绿色格子,将其设为0不更新
    q.push({bx, by});
    while(q.size())
    {
        PII t = q.front(); q.pop();
        int x = t.first, y = t.second;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + dx[i], b = y + dy[i];
            if(g[a][b] && dis1[a][b] > dis1[x][y] + 1)
            {
                dis1[a][b] = dis1[x][y] + 1;
                q.push({a, b});
            }
        }
    }
    if(d == -1) return; //不建边 
    //建边(gx,gy,d)->(gx,gx,其它方向)
    int id = get(gx, gy, d);
    for(int i = 0; i < 4; i ++)
    {
        if(i != d) //其它方向
        {
            int x = gx + dx[i], y = gy + dy[i];
            if(dis1[x][y] < INF) //可以到达
                add(id, get(gx, gy, i), dis1[x][y]);
        }
    }
    //将空白格子和绿色格子交换的权值为1,方向^2可以将0->2,2->0,1->3,3->1
    add(id, get(bx, by, d ^ 2), 1);
}
int spfa(int sx, int sy, int tx, int ty)
{
    queue<int> q;
    memset(dis2, 0x3f, sizeof dis2);
    //将指定绿色格子相邻4个方向的格子作为多起点加入队列
    for(int i = 0; i < 4; i ++)
    {
        int x = sx + dx[i], y = sy + dy[i];
        if(dis1[x][y] < INF) //能够到达(x, y)
        {
            int id = get(sx, sy, i);
            dis2[id] = dis1[x][y]; //权值为到达该点的最小步数
            q.push(id);
            st[id] = true;
        }
    }
    while(q.size())
    {
        int u = q.front(); q.pop();
        st[u] = false;
        for(int i = h[u]; ~ i; i = ne[i])
        {
            int v = e[i];
            if(dis2[v] > dis2[u] + w[i])
            {
                dis2[v] = dis2[u] + w[i];
                if(!st[v])
                {
                    q.push(v);
                    st[v] = true;
                }
            }
        }
    }
    int res = INF;
    //最终答案为指定绿色棋子走到目标位置,空白格子在相邻方向上的最小值
    for(int i = 0; i < 4; i ++)
        res = min(res, dis2[get(tx, ty, i)]);
    if(res == INF) res = -1;
    return res;
}
int main()
{
    scanf("%d%d%d", &n, &m, &Q);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &g[i][j]);
    memset(h, -1, sizeof h); //链式前向星初始化头指针
    //预处理出从第i行j列相邻k方向上的格子移动到其它相邻格子的最小步数
    for(int i = 1; i <= n; i ++)//枚举中心的格子
        for(int j = 1; j <= m; j ++)
            if(g[i][j]) //棋子不是固定的
            {
                for(int k = 0; k < 4; k ++) //枚举相邻的4个格子
                {
                    int x = i + dx[k], y = j + dy[k];
                    if(g[x][y]) bfs(x, y, i, j, k);
                }
            }
            
    while(Q --)
    {
        int ex, ey, sx, sy, tx, ty;
        scanf("%d%d%d%d%d%d", &ex, &ey, &sx, &sy, &tx, &ty);
        //特殊处理,绿色棋子在目标位置
        if(sx == tx && sy == ty) puts("0");
        else
        {
            //先处理将空白格子移动到指定棋子周围4个相邻格子上的最短距离
            bfs(ex, ey, sx, sy, -1); //方向设为-1,不用建边
            int ans = spfa(sx, sy, tx, ty);
            printf("%d\n", ans);
        }
    }
    return 0;
}
文章来源:https://blog.csdn.net/qiaoxinwei/article/details/135552863
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。