測試地址：四子連棋

做法：這道題目要求最優解，然而裸的BFS所消耗的空間巨大，用DFS的話深度又深不可測，很容易在沒用的分支上浪費很多時間。這時，就要用到迭代加深搜尋。迭代加深搜尋就是在DFS時給定一個深度上限，當搜尋深度超過上限時就不再拓展。從1開始列舉深度上限，如果能找到解，這個上限就是最優解，否則就加大上限繼續搜尋。

給出了迭代加深搜尋的思想，這道題目就應該不是太難了，剩下的唯一需要注意的一點是：黑白兩色需要輪流動棋，因此在搜尋時還要記錄上一手是哪個顏色的棋移動，判斷時也要注意這一點，開始搜尋時也要考慮黑先手和白先手兩種情況。至此，這道題已經沒什麼難點了。

所以，DFS時需要儲存的狀態有：兩個空格的座標，上一手棋的顏色和當前的深度。然後只要想到棋的移動等於空格的移動這一點即可。

以下是本人程式碼：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define inf 1000000000
using namespace std;
char a[5][5];
int ans,Ox1=0,Oy1,Ox2,Oy2,move[4][2]={{-1,0},{1,0},{0,-1},{0,1}};

bool check() //檢查當前棋盤是否構成四子連棋
{
  for(int i=1;i<=4;i++)
  {
    if (a[i][1]==a[i][2]&&a[i][1]==a[i][3]&&a[i][1]==a[i][4]) return 1;
	if (a[1][i]==a[2][i]&&a[1][i]==a[3][i]&&a[1][i]==a[4][i]) return 1;
  }
  if (a[1][1]==a[2][2]&&a[1][1]==a[3][3]&&a[1][1]==a[4][4]) return 1;
  if (a[1][4]==a[2][3]&&a[1][4]==a[3][2]&&a[1][4]==a[4][1]) return 1;
  return 0;
}

bool can(int x,int y,char p)
{
  return x>=1&&x<=4&&y>=1&&y<=4&&a[x][y]!=p;
}

bool dfs(int x1,int y1,int x2,int y2,char pre,int step)
{
  if (step==ans) //搜尋深度達到上限，停止
  {
    if (check()) return 1;
	else return 0;
  }
  for(int i=0;i<4;i++)
  {
    int nx1,ny1,nx2,ny2;
	nx1=x1+move[i][0];
	ny1=y1+move[i][1];
	nx2=x2+move[i][0];
	ny2=y2+move[i][1];
	if (can(nx1,ny1,pre))
	{
	  swap(a[x1][y1],a[nx1][ny1]);
	  if (dfs(nx1,ny1,x2,y2,(pre=='B'?'W':'B'),step+1)) return 1;
	  swap(a[x1][y1],a[nx1][ny1]);
	}
	if (can(nx2,ny2,pre))
	{
	  swap(a[x2][y2],a[nx2][ny2]);
	  if (dfs(x1,y1,nx2,ny2,(pre=='B'?'W':'B'),step+1)) return 1;
	  swap(a[x2][y2],a[nx2][ny2]);
	}
  }
  return 0;
}

int main()
{
  for(int i=1;i<=4;i++)
  {
    char s[5];
    scanf("%s",s);
	for(int j=1;j<=4;j++)
	{
	  a[i][j]=s[j-1];
      if (a[i][j]=='O')
	  {
	    if (Ox1==0) Ox1=i,Oy1=j;
		else Ox2=i,Oy2=j;
	  }
	}
  }
  
  for(ans=1;ans<=inf;ans++) //ans列舉深度上限
  {
    if (dfs(Ox1,Oy1,Ox2,Oy2,'W',0)) break; //黑先手
	if (dfs(Ox1,Oy1,Ox2,Oy2,'B',0)) break; //白先手
  }
  
  printf("%d",ans);
  
  return 0;
}