杭电OJ第4255题 A Famous Grid

　　杭电OJ第4255题，A Famous Grid（题目链接）。

A Famous Grid

Problem Description
Mr. B has recently discovered the grid named "spiral grid".

Construct the grid like the following figure. (The grid is actually infinite. The figure is only a small part of it.)



Considering traveling in it, you are free to any cell containing a composite number or 1, but traveling to any cell containing a prime number is disallowed. You can travel up, down, left or right, but not diagonally. Write a program to find the length of the shortest path between pairs of nonprime numbers, or report it's impossible.



Input
Each test case is described by a line of input containing two nonprime integer 1 ≤ x, y ≤ 10,000.
Output
For each test case, display its case number followed by the length of the shortest path or "impossible" (without quotes) in one line.
Sample Input
1 4

9 32

10 12
Sample Output
Case 1: 1

Case 2: 7

Case 3: impossible
Source
Fudan Local Programming Contest 2012

　　解题思路：广度优先搜索（BFS）。把相邻的遍历一遍。如果不是质数，则入队。我的队列用的是STL中的queue来实现的。
　　C++语言源代码如下：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cassert>
#include <queue>

using namespace std;

#define MAX_LENGTH 150

typedef int COUNT;
typedef struct { int x, y; } Point;
typedef enum { LEFT, RIGHT, UP, DOWN } DIRECTION;

bool isPrime[MAX_LENGTH * MAX_LENGTH + 1];

inline void getprime (void)
{
COUNT i, j;
const int max_number = MAX_LENGTH * MAX_LENGTH;
memset( isPrime, true, sizeof(isPrime) );
isPrime[0] = false;
isPrime[1] = false;
for ( i = 2; i <= max_number ; i ++ )
{
if ( isPrime[i] )
{
for ( j = ( i << 1 ) ; j <= max_number ; j += i )
isPrime[j] = false;
}
}
}

void init_mat( int mat[MAX_LENGTH][MAX_LENGTH] )
{
COUNT i, j, max_steps_count;
DIRECTION direction;
const int max_number = MAX_LENGTH * MAX_LENGTH;
Point current_postition;

memset( mat, 0, max_number * sizeof(int) );
if ( (MAX_LENGTH & 1) ) // odd number
current_postition.x = current_postition.y = (MAX_LENGTH >> 1);
else
{
current_postition.x = (MAX_LENGTH >> 1);
current_postition.y = current_postition.x - 1;
}

max_steps_count = 1;
j = 0;
direction = RIGHT;
for ( i = 1 ; i <= max_number ; i ++ )
{
if ( isPrime[i] )
mat[current_postition.x][current_postition.y] = 0;
else
mat[current_postition.x][current_postition.y] = i;
j ++;
switch ( direction )
{
case LEFT:
current_postition.y --;
break;
case RIGHT:
current_postition.y ++;
break;
case UP:
current_postition.x --;
break;
case DOWN:
current_postition.x ++;
break;
default:
assert(false);
}
if ( j >= max_steps_count )
{
j = 0;
switch ( direction )
{
case LEFT:
direction = DOWN;
break;
case RIGHT:
direction = UP;
break;
case UP:
max_steps_count ++;
direction = LEFT;
break;
case DOWN:
max_steps_count ++;
direction = RIGHT;
break;
default:
assert(false);
}
}
}
}

inline Point find_position( const int mat[MAX_LENGTH][MAX_LENGTH], const int number )
{
Point result = {-1, -1};
COUNT i, j;
for ( i = 0 ; i < MAX_LENGTH ; i ++ )
{
for ( j = 0 ; j < MAX_LENGTH ; j ++ )
{
if ( mat[i][j] == number )
{
result.x = i;
result.y = j;
return result;
}
}
}
return result;
}

inline void visit( queue <Point> & Q, const int mat[MAX_LENGTH][MAX_LENGTH], int mat_step[MAX_LENGTH][MAX_LENGTH], const Point & position, const int step )
{
if ( position.x < 0 )
return;
if ( position.y < 0 )
return;
if ( position.x >= MAX_LENGTH )
return;
if ( position.y >= MAX_LENGTH )
return;
if ( mat[position.x][position.y] != 0 )
{
if ( mat_step[position.x][position.y] == -1 )
{
mat_step[position.x][position.y] = step;
Q.push(position);
}
else if ( step < mat_step[position.x][position.y] )
{
mat_step[position.x][position.y] = step;
Q.push(position);
}
}
}

int BFS( const int mat[MAX_LENGTH][MAX_LENGTH], const int start, const int end )
{
static int mat_step[MAX_LENGTH][MAX_LENGTH];
Point current_postition, next_position, end_position;
int current_step, next_step;
queue <Point> Q;

end_position = find_position( mat, end );
if ( end_position.x == -1 )
return -1;

memset( mat_step, 0xff, sizeof( mat_step ) );

current_postition = find_position( mat, start );
Q.push( current_postition );
mat_step[current_postition.x][current_postition.y] = 0;

while ( !Q.empty() )
{
current_postition = Q.front();
Q.pop();
current_step = mat_step[current_postition.x][current_postition.y];
next_step = current_step + 1;

// up
next_position.x = current_postition.x - 1;
next_position.y = current_postition.y;
visit( Q, mat, mat_step, next_position, next_step );

// down
next_position.x = current_postition.x + 1;
next_position.y = current_postition.y;
visit( Q, mat, mat_step, next_position, next_step );

// left
next_position.x = current_postition.x;
next_position.y = current_postition.y - 1;
visit( Q, mat, mat_step, next_position, next_step );

// right
next_position.x = current_postition.x;
next_position.y = current_postition.y + 1;
visit( Q, mat, mat_step, next_position, next_step );
}
return mat_step[end_position.x][end_position.y];
}

int main (void)
{
int test_case = 0;
int start, end;
int steps;
static int mat[MAX_LENGTH][MAX_LENGTH];
getprime( );
init_mat( mat );
while ( scanf( "%d%d", &start, &end ) != EOF )
{
test_case ++;
steps = BFS( mat, start, end );
if ( steps < 0 )
printf( "Case %d: impossible\n", test_case );
else
printf( "Case %d: %d\n", test_case, steps );
}
return EXIT_SUCCESS;
}