POJ3732 Paint Me Less

//疯狂TLE,知道了用了不太准确的hash才250ms过了
//发现此题其实对hash的要求并不是太高，因为它只要找到可行解即可。
/*
*State: POJ3732    Accepted    3736K    250MS    G++    3639B
*题目大意：
*        给定一个r*c的矩阵，r跟c均<=4,然后每个方格有[0,19]种颜色，
*        规定可以任选一个方格改变随意的颜色，但是与其相邻的方格的
*        颜色也同时随之改变，上下左右为相邻，求最小步数使矩阵最后
*        均变为0.
*解题思路：
*        直接用IDA*,注意剪枝。
*解题感想；
*        用了IDA*之后一直TLE,因为我自己写挫了的原因吧。之后迫于无奈，
*        用了不太准确的hash，真是麻烦啊。
*/

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <utility>
#include <bitset>
#define FF(i, n) for(int i = 0; i < n; i++)
#define FOR(i, a, n) for(int i = a; i < n; i++)
#define viewPP(a,n,m)    {puts("---");FF(i,n){FF(j,m) cout<<a[i][j] <<' ';puts("");}}
//一维作为试用版
#define viewP(a, n)     {FF(i, n) {cout<<a[i]<<" ";} puts("");}
using namespace std;

const int MAXN = 5;
const int hinf = 0x3f3f3f3f;
const int COR = 20;

typedef struct _map {
    int d[MAXN][MAXN];
}M;
int r, c, deapth, sol;

//颜色0~19
bool judge_bfs(int x, int y) {
    if(x >= 0 && x < r && y >= 0 && y < c)
        return true;
    return false;
}

int dir[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};

//pcol为原来的col
void floorFill(M &gra, int x, int y, int c, int pcol) {
    gra.d[x][y] = c;
    int nx, ny;
    FF(i, 4) {
        nx = x + dir[i][0], ny = y + dir[i][1];
        if(judge_bfs(nx, ny) && gra.d[nx][ny] == pcol) {
            floorFill(gra, nx, ny, c, pcol);
        }
    }
}

bool is_zero(const M &gra) {
    FF(i, r)
        FF(j, c) {
            if(gra.d[i][j])
                return false;
    }
    return true;
}

int get_col(M gra) {
    int tmp[COR] = {0}, cnt = 0;
    FF(i, r)
        FF(j, c) {
            if(!tmp[gra.d[i][j]] && gra.d[i][j] != 0) {
                tmp[gra.d[i][j]] = 1;
                cnt++;
            }
    }
    return cnt;
}

struct _path {
    int x, y, col;
}path[1005];

//相邻颜色
void has_col(const M &gra, int x, int y, bool has[]) {
    FF(i, COR) has[i]=false;
    int nx, ny;
    FF(k, 4) {
        nx = x + dir[k][0];
        ny = y + dir[k][1];
        if(judge_bfs(nx, ny) && !has[gra.d[nx][ny]])
            has[gra.d[nx][ny]] = true;
    }
    return ;
}

bitset<1000024> bvst[25];
int my_zip(const M &gra) {
    unsigned __int64 z = 0;
    FF(i, r)
        FF(j, c) {
        z = gra.d[i][j] + z * 131;
    }
    return (int)(z % 1000007);
}

void dfs(M gra, int step) {
    if(step > deapth)
        return ;
    //viewPP(gra.d, r, c);
    
    if(is_zero(gra)) {
        sol = step;
        printf("%d\n", sol);
        FOR(i, 1, step+1)
            printf("%d %d %d\n", path[i].x, path[i].y, path[i].col);
        return ;
    }

    int recol = get_col(gra);
    if(step + recol > deapth)
        return ;

    FF(i, r) {
        FF(j, c) {
            FF(k, COR) {
                if(sol != -hinf) return ;

                if(k == gra.d[i][j]) continue;
                bool color[COR];
                has_col(gra, i, j, color);//color标志其邻居的颜色
                if(!color[k] && k != 0) continue;//变为相邻颜色，或者0

                M tmp = gra;
                //用广搜
                //3732    Accepted    3768K    4219MS    G++    3709B
                //update(tmp, i, j, k);
                //用深搜
                //3732    Accepted    3736K    250MS    G++    3639B
                floorFill(tmp, i, j, k, gra.d[i][j]);
                int t = my_zip(tmp);
                if(bvst[step+1][t]) continue;
                bvst[step+1][t] = true;
        
                path[step+1].x = i+1;
                path[step+1].y = j+1;
                path[step+1].col = k;
                dfs(tmp, step+1);
            }
        }
    }
}

void solve() {
    sol = -hinf;
    M gra;
    FF(i, r)
        FF(j, c)
            scanf("%d", &gra.d[i][j]);
    for(deapth = 1; ; deapth++) {
        FF(i, deapth+1) bvst[i].reset();
        dfs(gra, 0);
        if(sol != -hinf) break;
    }
}

int main(void) {
#ifndef ONLINE_JUDGE
    freopen("in.txt", "r", stdin);
#endif
    while(scanf("%d %d", &r, &c) == 2) {
        solve();
    }
    return  0;
}