【POJ 4007】 Flood-it！

【题目链接】

http://poj.org/problem?id=4007

【算法】

IDA*

【代码】

#include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
#include <stack>
#include <limits.h>
using namespace std;
const int dx[] = {,,-,};
const int dy[] = {-,,,};

int i,j,n,step;
int v[][],a[][];

inline bool valid(int x,int y)
{
        return x >  && x <= n && y >  && y <= n;
}
inline void dfs(int x,int y,int c)
{
        int i,tx,ty;
        v[x][y] = ;
        for (i = ; i < ; i++)
        {
                tx = x + dx[i];
                ty = y + dy[i];
                if (valid(tx,ty) && v[tx][ty] != )
                {
                        if (a[tx][ty] == c) dfs(tx,ty,c);
                        else v[tx][ty] = ;
                }
        }
}
inline int f()
{
        int i,j,s = ;
        bool h[];
        memset(h,,sizeof(h));
        for (i = ; i <= n; i++)
        {
                for (j = ; j <= n; j++)
                {
                        if (!h[a[i][j]] && v[i][j] != )
                        {
                                h[a[i][j]] = true;
                                s++;
                        }
                }
        }
        return s;
}
inline bool fill(int c)
{
        int i,j,s = ;
        for (i = ; i <= n; i++)
        {
                for (j = ; j <= n; j++)
                {
                        if (a[i][j] == c && v[i][j] == )
                        {
                                s++;
                                dfs(i,j,c);
                        }
                }
        }
        return s != ;
}
inline bool IDDFS(int dep)
{
        int i,t;
        int tmp[][];
        t = f();
        if (dep + t > step) return false;
        if (!t) return true;
        for (i = ; i <= ; i++)
        {
                memcpy(tmp,v,sizeof(v));
                if (fill(i) && IDDFS(dep+))
                        return true;
                memcpy(v,tmp,sizeof(v));
        }
        return false;
}
int main()
{

        while (scanf("%d",&n) != EOF && n)
        {
                memset(v,,sizeof(v));
                for (i = ; i <= n; i++)
                {
                        for (j = ; j <= n; j++)
                        {
                                scanf("%d",&a[i][j]);
                        }
                }
                dfs(,,a[][]);
                for (i = ; i <= n * n; i++)
                {
                        step = i;
                        if (IDDFS())
                                break;
                }
                printf("%d\n",step);
        }

        return ;

}