Shuttle Puzzle

题意：不想写，摘抄NOCOW翻译（http://www.nocow.cn/index.php/Translate:USACO/shuttle）

描述

大小为3的棋盘游戏里有3个白色棋子，3个黑色棋子，和一个有7个格子一线排开的木盒子。3个白棋子被放在一头，3个黑棋子被放在另一头，中间的格子空着。

初始状态: WWW_BBB 
目标状态: BBB_WWW

在这个游戏里有两种移动方法是允许的：

1. 你可以把一个棋子移到与它相邻的空格；
2. 你可以把一个棋子跳过一个(仅一个)与它不同色的棋子到达空格。

大小为N的棋盘游戏包括N个白棋子，N个黑棋子，还有有2N+1个格子的木盒子。

这里是3-棋盘游戏的解，包括初始状态，中间状态和目标状态：

 WWW BBB
 WW WBBB
 WWBW BB
 WWBWB B
 WWB BWB
 W BWBWB
  WBWBWB
 BW WBWB
 BWBW WB
 BWBWBW 
 BWBWB W
 BWB BWW
 B BWBWW
 BB WBWW
 BBBW WW
 BBB WWW

请编一个程序解大小为N的棋盘游戏(1 <= N <= 12)。要求用最少的移动步数实现。

[编辑]格式

PROGRAM NAME: shuttle

INPUT FORMAT:

(file shuttle.in)

一个整数N。

OUTPUT FORMAT:

(file shuttle.out)

输出用移动的棋子在棋盘的位置(位置从左到右依次为1, 2, ..., 2N+1)表示的变换序列，每个数字之间以空格分隔，每行20个数(除了最后一行)。

输出的解还应当有最小的字典顺序(即如果有多组移动步数最小的解，输出第一个数最小的解；如果还有多组，输出第二个数最小的解；...)。

[编辑]SAMPLE INPUT

3

[编辑]SAMPLE OUTPUT

3 5 6 4 2 1 3 5 7 6 4 2 3 5 4

解题思路：

1. 根据空格两端半径2个字符的情况判断下一次移动的是哪个字符，然后移动，直到达到目标状态（对N = 1特殊处理一下即可）

代码：

/*
ID: zc.rene1
LANG: C
PROG: shuttle
 */

#include<stdio.h>
#include<stdlib.h>
#include<string.h> 

int N;
int seq[1000];

int board[25];
int l1, l2, r1, r2;

int GetNextMove(int space_index)
{
    l1 = (space_index - 2 >= 0) ? board[space_index - 2] : 0;
    l2 = (space_index - 1 >= 0) ? board[space_index - 1] : 0;
    r1 = (space_index + 1 <= 2 * N) ? board[space_index + 1] : 0;
    r2 = (space_index + 2 <= 2 * N) ? board[space_index + 2] : 0;
    //BB WW ===> end
    if (l1 == 2 && l2 == 2 && r1 == 1 && r2 == 1)
    {
	return -2;
    }
    //WB **
    if (l1 == 1 && l2 == 2)
    {
	return space_index - 2;
    }
    //** WB
    if (r1 == 1 && r2 == 2)
    {
	return space_index + 2;
    }
    //WW B*
    if (l1 == 1 && l2 == 1 && r1 == 2)
    {
	return space_index - 1;
    }
    //BW BB
    if (l1 == 2 && l2 == 1 && r1 == 2 && r2 == 2)
    {
	return space_index + 1;
    }
    //BW B
    if (l1 == 2 && l2 == 1 && r1 == 2 && r2 == 0)
    {
	return space_index + 1;
    }
    // W BW
    if (l1 == 0 && l2 == 1 && r1 == 2 && r2 == 1)
    {
	return space_index - 1;
    }
    //  BW  
    if (l1 == 0 && l2 == 0 && r1 == 2 && r2 == 1)
    {
	return space_index + 1;
    }
    //BW  
    if (l1 == 2 && l2 == 1 && r1 == 0 && r2 == 0)
    {
	return space_index - 1;
    }
    // B BW  
    if (l1 == 0 && l2 == 2 && r1 == 2 && r2 == 1)
    {
	return space_index + 1;
    }
    //BW WW 
    if (l1 == 2 && l2 == 1 && r1 == 1 && r2 == 1)
    {
	return space_index - 1;
    }
    //BW W 
    if (l1 == 2 && l2 == 1 && r1 == 1 && r2 == 0)
    {
	return space_index - 1;
    }
    //BB BW
    if (l1 == 2 && l2 == 2 && r1 == 2 && r2 == 1)
    {
	return space_index + 1;
    }
    
    return -1;
}

int Move(int next_move, int space_index)
{
    int temp;
    temp = board[next_move];
    board[next_move] = board[space_index];
    board[space_index] = temp;
    return next_move;
}

int main(void)
{ 
    FILE *fin, *fout;
    int i, space_index, next_move;

    fin = fopen("shuttle.in", "r"); 
    fout = fopen("shuttle.out", "w"); 

    fscanf(fin, "%d", &N);
    for (i=0; i<N; i++)
    {
	board[i] = 1;
    }
    board[i] = 0;
    space_index = i;
    for (i=N+1; i<=2*N; i++)
    {
	board[i] = 2;
    }

    if (N == 1)
    {
	fprintf(fout, "1 3 2\n");
	return 0;
    }

    i = 0;
    while (1)
    {
	next_move = GetNextMove(space_index);
	if (next_move == -2)
	{
	    break;
	}
	space_index = Move(next_move, space_index);

	i++;
	if (i % 20 == 1)
	{
	    fprintf(fout, "%d", next_move + 1);
	}
	else if (i % 20 == 0)
	{
	    fprintf(fout, " %d\n", next_move + 1);
	}
	else
	{
	    fprintf(fout, " %d", next_move + 1);
	}
    }
    if (i % 20 != 0)
    {
	fprintf(fout, "\n");
    }

    return 0;
}