poj_2286 IDA*

题目大意

给定一个由数字组成的#字型网格，和一定的移动规则，问最少需要多少次移动才能达到要求的结果。

题目分析

要求最少需要几步到达结果，可以考虑广度优先搜索算法，或者迭代加深深度优先搜索（IDA*)，这里使用IDA*算法。
在剪枝的时候：
1. 考虑估价函数H()，表示当前中间八个格子中最少需要移动多少次才能相同（即8 -
相同数字最多的个数)；
2. 前后两次移动不同为逆操作（即同一列，但不同方向）
3. 不能连续7次进行移动同一列，且同一方向
详细见 CanCut 函数。

实现(c++)

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#define MAX(a, b) a>b? a :b
#define MAX_STEP 1000
int gOrderMoved[MAX_STEP];
int gIrreleventQueuee[4] = { 1, 0, 3, 2 };

int gCell[25];
int gCellIndexInQueue[4][7];
int gMoveOrder[4][2] = { { 0, 5 }, { 1, 4 }, { 7, 2 }, { 6, 3 } };
int gMoveQueue[8] = {0, 1, 2, 3, 1, 0, 3, 2};
int gMoveDir[8] = {0, 0, 1, 1, 1, 1, 0, 0};
int gCenterCellIndex[8] = { 6, 7, 8, 11, 12, 15, 16, 17 };
int gMinStep;
void Init(){
gCellIndexInQueue[0][0] = 0;
gCellIndexInQueue[0][1] = 2;
gCellIndexInQueue[0][2] = 6;
gCellIndexInQueue[0][3] = 11;
gCellIndexInQueue[0][4] = 15;
gCellIndexInQueue[0][5] = 20;
gCellIndexInQueue[0][6] = 22;

gCellIndexInQueue[1][0] = 1;
gCellIndexInQueue[1][1] = 3;
gCellIndexInQueue[1][2] = 8;
gCellIndexInQueue[1][3] = 12;
gCellIndexInQueue[1][4] = 17;
gCellIndexInQueue[1][5] = 21;
gCellIndexInQueue[1][6] = 23;

for (int i = 0; i < 7; i++){
gCellIndexInQueue[2][i] = 4 + i;
}

for (int i = 0; i < 7; i++){
gCellIndexInQueue[3][i] = 13 + i;
}
}

bool IsCenterSame(){
int num = gCell[6];
for (int i = 0; i < 8; i++){
if (gCell[gCenterCellIndex[i]] != num){
return false;
}
}
return true;
}

void Rotate(int order){
int move_queue = gMoveQueue[order];
int move_dir = gMoveDir[order];
int tmp;
if (move_dir == 0){
tmp = gCell[gCellIndexInQueue[move_queue][0]];
for (int i = 0; i < 6; i++)
gCell[gCellIndexInQueue[move_queue][i]] = gCell[gCellIndexInQueue[move_queue][i + 1]];
gCell[gCellIndexInQueue[move_queue][6]] = tmp;
}
else{
tmp = gCell[gCellIndexInQueue[move_queue][6]];
for (int i = 6; i > 0; i--)
gCell[gCellIndexInQueue[move_queue][i]] = gCell[gCellIndexInQueue[move_queue][i - 1]];
gCell[gCellIndexInQueue[move_queue][0]] = tmp;
}
}

int GetH(){
int count[4] = { 0, 0, 0, 0 };
for (int i = 0; i < 8; i++){
count[gCell[gCenterCellIndex[i]]] ++;
}
int max = MAX(count[1], count[2]);
max = MAX(max, count[3]);
return 8 - max;
}

bool CanCut(int moved_step, int next_order){
if (moved_step == 0){
return false;
}
int k = moved_step - 1;
int next_queue = gMoveQueue[next_order];
int next_dir = gMoveDir[next_order];

int irrelevent_queue = gIrreleventQueuee[next_queue];
int same_order_count = 0;
while (k >= 0){

if (same_order_count >= 6)
return true;

while (k >= 0 && gMoveQueue[gOrderMoved[k]] == irrelevent_queue){
k--;
}
if (k < 0){
return false;
}
int queue = gMoveQueue[gOrderMoved[k]];
int dir = gMoveDir[gOrderMoved[k]];
if (queue == next_queue){
if (dir != next_dir){
return true;
}
else{
same_order_count++;
}
}
else{
return false;
}

k--;
}

return false;
}
void MoveToCenterSame(int moved_step,  bool *moved_same){
if (*moved_same){
return;
}
if (IsCenterSame()){
for (int i = 0; i < gMinStep; i++){
printf("%c", 'A' + gOrderMoved[i]);
}
if (gMinStep == 0){
printf("No moves needed");
}
printf("\n");
printf("%d\n", gCell[6]);
*moved_same = true;
return;
}
if (moved_step + GetH() > gMinStep){
return;
}
for (int next_order = 0; next_order < 8; next_order++){
if (CanCut(moved_step, next_order)){
continue;
}
if (*moved_same){
return;
}
gOrderMoved[moved_step] = next_order;
Rotate(next_order);
MoveToCenterSame(moved_step + 1, moved_same);
int reback_order = gMoveOrder[gMoveQueue[next_order]][! gMoveDir[next_order]];
Rotate(reback_order);
}

}

void Solve(){
gMinStep = 0;
while (true){
bool moved_same = false;
MoveToCenterSame(0, &moved_same);
if (moved_same){
break;
}
gMinStep++;
}
}

int main(){
Init();
while (true){
scanf("%d", gCell);
if (gCell[0] == 0){
break;
}
for (int i = 1; i < 24; i++){
scanf("%d", gCell + i);
}
Solve();

}
return 0;
}