TZOJ 3709:Number Maze(广搜记录前驱)

描述

You are playing one game called "Number Maze". The map of an example is shown in the following figure.

In the map, there are N*N+2 cells. When the game starts, you stay the top-left cell and you target is to reach the bottom-right cell with fewest number of moves. At the first step, you must move to the right of the start cell. After that, you can move to any cell (left, right, up or down, but can not move diagonally) if the target cell can be divided by the sum of the previous two numbers. However, you should never move backwards. For example, at first, you stay at the "2" cell, and you must move to the "6" cell, then have two selections "8" or "4" because (2+6)/8=1 and (2+6)/4=2, you can not move back to the "2" cell at this step although (2+6)/2=4. One possilbe solution is 2->6->8->7->5->3->4->7->11->2->13, and the total number of moves is 10.
Another solution is also legal but has longer moves:2->6->8->7->5->3->4->7->5->3->4->7->11->2->13

输入

Thare are at most 20 cases. The first line of each case has three integers N<=10, S and T, which N indicates the dimension of the map, S and T indicate the number in the start and target cell. Then follows N lines and each line has N positive integers which indicate each number in the N*N cells.
There has one blank line after each case and you can assume that the total number of all cells is no larger than 1000000.

The inputs are ended with End of File. If you have some questions, please visit the help page.

输出

Each case outputs the fewest number of moves or "Impossible" if you can not reach the target cell per line.

样例输入

3 2 13
6 4 3
8 7 5
2 11 2

样例输出

10

题意

由图可得，从图中S点出发到E点，第一步一定走到右边一格，第二步满足前两步和可以被当前值整除，不可以往回走

题解

首先我们得考虑怎么记录前驱，可以在结构体里新加pre，prex，prey，每次走的时候更新

然后我们还得考虑死循环的问题

例如

2 2 2

2 2

2 2

我们可以把每个点设一个设定值，如果一个点走的次数超过设定值，标记为不可走

写完一交，wa了？？原因不明，后来发现没有考虑往回走的问题(t.prex!=h.x||t.prey!=h.y)

代码

#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int N=15;
int n,G[N][N],in[N][N],vis[N][N];
int dx[]={0,0,1,-1};
int dy[]={1,-1,0,0};
struct p
{
    int x,y,step,pre,prex,prey;
}t,h;
int bfs(int s)
{
    memset(in,0,sizeof(in));
    memset(vis,0,sizeof(vis));
    queue<p>q;
    t.x=1,t.y=1,t.step=1,t.pre=s,t.prex=1,t.prey=0;
    q.push(t);
    while(!q.empty())
    {
        t=q.front();q.pop();
        if(++in[t.x][t.y]>=100)vis[t.x][t.y]=1;//一个点入队次数>设定值就标记为不可走
        if(t.x==n&&t.y==n+1)return t.step;
        for(int i=0;i<4;i++)
        {
            h.x=t.x+dx[i],h.y=t.y+dy[i];
            h.step=t.step+1;
            h.pre=G[t.x][t.y];//前驱
            h.prex=t.x,h.prey=t.y;//前驱的x和y
            int sum=h.pre+G[t.prex][t.prey];
            if(!vis[h.x][h.y]&&h.x>=1&&h.x<=n&&h.y>=1&&h.y<=n+1&&(t.prex!=h.x||t.prey!=h.y)&&G[h.x][h.y]&&sum%G[h.x][h.y]==0)
                q.push(h);
        }
    }
    return -1;
}
int main()
{
    int s,e;
    while(scanf("%d%d%d",&n,&s,&e)!=EOF)
    {
        memset(G,0,sizeof(G));
        G[1][0]=s;
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
                scanf("%d",&G[i][j]);
            G[i][n+1]=0;
        }
        G[n][n+1]=e;
        int k=bfs(s);
        if(k==-1)printf("Impossible
");
        else printf("%d
",k);
    }
    return 0;
}