#include <iostream>
#include <time.h>
#include "map"
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "array"
using namespace std;
#define NULL (0)
#define OUT_X (0b1111)
#define OUT_POS (0b11111111)
#define OUT_BLK (0b11111111111111111111111111111111)
#define get_x_from_pos(pos) (((pos)>>4)&0b1111)
#define get_y_from_pos(pos) ((pos)&0b1111)
#define get_pos_from_xy(x,y) (((x)<<4)|(y))
#define get_u_pos_from_blk(stBlk) (((stBlk)>>24)&0b11111111)
#define get_d_pos_from_blk(stBlk) (((stBlk)>>16)&0b11111111)
#define get_l_pos_from_blk(stBlk) (((stBlk)>>8)&0b11111111)
#define get_r_pos_from_blk(stBlk) ((stBlk)&0b11111111)
#define get_blk_from_pos_u_d_l_r(u,d,l,r) (((u)<<24)|((d)<<16)|((l)<<8)|(r))
#define set_u_pos_in_blk(stBlk,pos) ((stBlk)=(((stBlk)&0b00000000111111111111111111111111)|(pos<<24)))
#define set_d_pos_in_blk(stBlk,pos) ((stBlk)=(((stBlk)&0b11111111000000001111111111111111)|(pos<<16)))
#define set_l_pos_in_blk(stBlk,pos) ((stBlk)=(((stBlk)&0b11111111111111110000000011111111)|(pos<<8)))
#define set_r_pos_in_blk(stBlk,pos) ((stBlk)=(((stBlk)&0b11111111111111111111111100000000)|(pos)))
typedef unsigned char pos;
typedef unsigned int stBlk;
typedef unsigned int color;
// global
array<array<color, 10>, 10> g_initColorMap;
array<array<stBlk, 10>, 10> g_initStateMap;
pos g_initHeadPos;
map<array<array<stBlk, 10>, 10>, int> g_SCORE;
int g_BEST_SCORE;
int g_mapSize, g_mapSize_old;
void globalInit()
{
for (int i=1;i<=10;++i) g_initColorMap[i].fill(0);
for (int i=1;i<=10;++i) g_initStateMap[i].fill(0);
g_initHeadPos = 0;
g_SCORE.clear();
g_BEST_SCORE = 1;
g_mapSize = 0;
g_mapSize_old = 0;
}
void readInitMap()
{
/*
2441353511
2122511244
3444543422
2131423443
4241445212
1122411534
1251131145
2441444415
4254453131
3321521455
*/
string x = "2441353511212251124434445434222131423443424144521211224115341251131145244144441542544531313321521455";
// read color map
for (int i=0; i<=9; ++i) {
for (int j=0; j<=9; ++j) {
g_initColorMap[i][j] = x[i+10*(9-j)]-'0';
}
}
// init state map
for (int i=0; i<=9; ++i) {
for (int j=0; j<=9; ++j) {
pos up, down, left, right;
if (j==9) up = OUT_POS; else up = get_pos_from_xy(i, j+1);
if (j==0) down = OUT_POS; else down = get_pos_from_xy(i, j-1);
if (i==0) left = OUT_POS; else left = get_pos_from_xy(i-1, j);
if (i==9) right = OUT_POS; else right = get_pos_from_xy(i+1, j);
//printf("g_initStateMap[%d][%d]=(%d,%d),(%d,%d),(%d,%d),(%d,%d)\n", i, j, \
get_x_from_pos(up), get_y_from_pos(up), \
get_x_from_pos(down), get_y_from_pos(down), \
get_x_from_pos(left), get_y_from_pos(left), \
get_x_from_pos(right), get_y_from_pos(right));
g_initStateMap[i][j] = get_blk_from_pos_u_d_l_r(up, down, left, right);
}
}
g_initHeadPos = get_pos_from_xy(0, 0);
}
void printMap(array<array<stBlk, 10>, 10> stMp, pos RealHeadPos)
{
if (stMp[get_x_from_pos(RealHeadPos)][get_y_from_pos(RealHeadPos)] == 0) {
printf("printMap ERROR, RealHeadPos is NULL (%d,%d)\n", get_x_from_pos(RealHeadPos), get_y_from_pos(RealHeadPos));
return;
}
array<array<color, 10>, 10> temp;
for (int i=0; i<10; ++i) temp[i].fill(0);
pos temp2[10][10];
for(int i=0; i<10; ++i) for(int j=0; j<10; ++j) {
temp2[i][j] = OUT_POS;
}
int xx = 0;
pos p = RealHeadPos;
while (p!=OUT_POS) {
xx++;
pos q = p;
int yy = 0;
while (q!=OUT_POS) {
yy++;
char qx = get_x_from_pos(q);
char qy = get_y_from_pos(q);
temp[xx-1][yy-1] = g_initColorMap[qx][qy];
temp2[xx-1][yy-1] = q;
q = get_u_pos_from_blk(stMp[qx][qy]);
}
p = get_r_pos_from_blk(stMp[get_x_from_pos(p)][get_y_from_pos(p)]);
}
cout << "Head Pos: (" << get_x_from_pos(RealHeadPos) << "," << get_y_from_pos(RealHeadPos) << ")" << endl;
for (int j=9; j>=0; --j) {
for (int i=0; i<=9; ++i) {
//if (temp[i][j] == 0) cout<<" "; else cout<<temp[i][j];
if (temp2[i][j] == OUT_POS) printf(" "); else printf("(%d,%d) ",get_x_from_pos(temp2[i][j]),get_y_from_pos(temp2[i][j]));
}
cout<<endl;
}
cout<<endl;
}
void tickOneBlk(array<array<stBlk, 10>, 10> &S, pos &Hp, pos tickP)
{
char tickPx = get_x_from_pos(tickP);
char tickPy = get_y_from_pos(tickP);
stBlk tickBlk = S[tickPx][tickPy];
if (tickBlk == 0) {
for(int i=0;i<1000;++i) cout <<"fuck"<<endl;
return;
}
pos up = get_u_pos_from_blk(tickBlk);
char upx = get_x_from_pos(up);
char upy = get_y_from_pos(up);
pos dp = get_d_pos_from_blk(tickBlk);
char dpx = get_x_from_pos(dp);
char dpy = get_y_from_pos(dp);
// at least 1 block below it.
if (dp != OUT_POS) {
if (up == OUT_POS) {
set_u_pos_in_blk(S[dpx][dpy], OUT_POS);
}
else {
set_u_pos_in_blk(S[dpx][dpy], up);
set_d_pos_in_blk(S[upx][upy], dp);
}
}
else if (dp == OUT_POS) { // it's the bottom block
pos lp = get_l_pos_from_blk(tickBlk);
char lpx = get_x_from_pos(lp);
char lpy = get_y_from_pos(lp);
pos rp = get_r_pos_from_blk(tickBlk);
char rpx = get_x_from_pos(rp);
char rpy = get_y_from_pos(rp);
if (up == OUT_POS) {
if (lp != OUT_POS) {
if (rp == OUT_POS) {
set_r_pos_in_blk(S[lpx][lpy], OUT_POS);
}
else if (rp != OUT_POS) {
set_l_pos_in_blk(S[rpx][rpy], lp);
set_r_pos_in_blk(S[lpx][lpy], rp);
}
}
else if (lp == OUT_POS) {
if (rp == OUT_POS) {
Hp = OUT_POS;
}
else if (rp != OUT_POS) {
set_l_pos_in_blk(S[rpx][rpy], OUT_POS);
Hp = rp;
}
}
}
else if (up != OUT_POS){
if (lp != OUT_POS) {
if (rp == OUT_POS) {
set_r_pos_in_blk(S[lpx][lpy], up);
set_d_pos_in_blk(S[upx][upy], dp);
set_l_pos_in_blk(S[upx][upy], lp);
set_r_pos_in_blk(S[upx][upy], rp);
}
else if (rp != OUT_POS) {
set_r_pos_in_blk(S[lpx][lpy], up);
set_d_pos_in_blk(S[upx][upy], dp);
set_l_pos_in_blk(S[upx][upy], lp);
set_r_pos_in_blk(S[upx][upy], rp);
set_l_pos_in_blk(S[rpx][rpy], up);
}
}
else if (lp == OUT_POS) {
if (rp == OUT_POS) {
set_d_pos_in_blk(S[upx][upy], dp);
set_l_pos_in_blk(S[upx][upy], lp);
set_r_pos_in_blk(S[upx][upy], rp);
Hp = up;
}
else if (rp != OUT_POS) {
set_d_pos_in_blk(S[upx][upy], dp);
set_r_pos_in_blk(S[upx][upy], rp);
set_l_pos_in_blk(S[upx][upy], lp);
set_l_pos_in_blk(S[rpx][rpy], up);
Hp = up;
}
}
}
}
// destroy this block
S[tickPx][tickPy] = 0;
//printMap(S, Hp);
}
void printInfo(pos p, stBlk pb)
{
printf("p:(%d,%d)\n", get_x_from_pos(p), get_y_from_pos(p));
pos up = get_u_pos_from_blk(pb);
pos dp = get_d_pos_from_blk(pb);
pos lp = get_l_pos_from_blk(pb);
pos rp = get_r_pos_from_blk(pb);
printf("up:(%d,%d)\n", get_x_from_pos(up), get_y_from_pos(up));
printf("dp:(%d,%d)\n", get_x_from_pos(dp), get_y_from_pos(dp));
printf("lp:(%d,%d)\n", get_x_from_pos(lp), get_y_from_pos(lp));
printf("rp:(%d,%d)\n", get_x_from_pos(rp), get_y_from_pos(rp));
}
void updateAllPos(array<array<stBlk, 10>, 10> &state, pos &RealHeadPos)
{
array<array<pos, 10>, 10> temp;
//for (int i=0; i<10; ++i) temp[i].fill(0);
for(int i=0; i<10; ++i) for(int j=0; j<10; ++j) temp[i][j] = OUT_POS;
int xx1 = 0;
pos p1 = RealHeadPos;
while (p1 != OUT_POS) {
xx1++;
pos q1 = p1;
int yy1 = 0;
//cout<<"fuck1"<<endl;
while (q1 != OUT_POS) {
//printf("%d\n", RealHeadPos);
yy1++;
//printMap(state, RealHeadPos);
//printf("in p1=(%d,%d) q1=(%d,%d)\n",get_x_from_pos(p1), get_y_from_pos(p1), get_x_from_pos(q1), get_y_from_pos(q1));
//printInfo(p1, state[get_x_from_pos(p1)][get_y_from_pos(p1)]);
//printInfo(q1, state[get_x_from_pos(q1)][get_y_from_pos(q1)]);
temp[xx1-1][yy1-1] = q1;
q1 = get_u_pos_from_blk(state[get_x_from_pos(q1)][get_y_from_pos(q1)]);
}
p1 = get_r_pos_from_blk(state[get_x_from_pos(p1)][get_y_from_pos(p1)]);
//printf("out p1=(%d,%d) q1=(%d,%d)\n",get_x_from_pos(p1), get_y_from_pos(p1), get_x_from_pos(q1), get_y_from_pos(q1));
}
//printf("im out.\n");
for(int x=0; x<10; ++x) {
if (OUT_POS == temp[x][0]) {
break;
}
for(int y=0; y<10; ++y) {
if (OUT_POS == temp[x][y]) {
break;
}
//temp[x][y]--;
if (9 == y) {
set_u_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], OUT_POS);
}
else {
set_u_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], temp[x][y+1]);
}
if (0 == y) {
set_d_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], OUT_POS);
}
else {
set_d_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], temp[x][y-1]);
}
if (0 == x) {
set_l_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], OUT_POS);
}
else {
set_l_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], temp[x-1][y]);
}
if (9 == x) {
set_r_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], OUT_POS);
}
else {
set_r_pos_in_blk(state[get_x_from_pos(temp[x][y])][get_y_from_pos(temp[x][y])], temp[x+1][y]);
}
}
}
return;
}
bool checkIsSingle(array<array<stBlk, 10>, 10> &state, pos &ckPos)
{
char ck_x = get_x_from_pos(ckPos);
char ck_y = get_y_from_pos(ckPos);
color cx = g_initColorMap[ck_x][ck_y];
stBlk bx = state[ck_x][ck_y];
pos up = get_u_pos_from_blk(bx);
if (up!=OUT_POS && g_initColorMap[get_x_from_pos(up)][get_y_from_pos(up)]==cx){
return false;
}
pos dp = get_d_pos_from_blk(bx);
if (dp!=OUT_POS && g_initColorMap[get_x_from_pos(dp)][get_y_from_pos(dp)]==cx){
return false;
}
pos lp = get_l_pos_from_blk(bx);
if (lp!=OUT_POS && g_initColorMap[get_x_from_pos(lp)][get_y_from_pos(lp)]==cx){
return false;
}
pos rp = get_r_pos_from_blk(bx);
if (rp!=OUT_POS && g_initColorMap[get_x_from_pos(rp)][get_y_from_pos(rp)]==cx){
return false;
}
return true;
}
int destroy(array<array<stBlk, 10>, 10> &state, pos &realHeadPos, pos realTickPos, array<array<stBlk, 10>, 10> &tmpState, pos &tmpRealHeadPos)
{
pos toTick[105];
int head=0, tail=1;
toTick[tail] = realTickPos;
bool vis[257];
for(int i=0; i<257; ++i) vis[i] = 0;
vis[realTickPos] = 1;
while (head < tail) {
pos pp = toTick[++head];
char ppx = get_x_from_pos(pp);
char ppy = get_y_from_pos(pp);
color pc = g_initColorMap[ppx][ppy];
stBlk ppb = state[ppx][ppy];
pos up = get_u_pos_from_blk(ppb);
if (up!=OUT_POS && !vis[up] && g_initColorMap[get_x_from_pos(up)][get_y_from_pos(up)]==pc){
vis[up] = 1;
toTick[++tail] = up;
}
pos dp = get_d_pos_from_blk(ppb);
if (dp!=OUT_POS && !vis[dp] && g_initColorMap[get_x_from_pos(dp)][get_y_from_pos(dp)]==pc){
vis[dp] = 1;
toTick[++tail] = dp;
}
pos lp = get_l_pos_from_blk(ppb);
if (lp!=OUT_POS && !vis[lp] && g_initColorMap[get_x_from_pos(lp)][get_y_from_pos(lp)]==pc){
vis[lp] = 1;
toTick[++tail] = lp;
}
pos rp = get_r_pos_from_blk(ppb);
if (rp!=OUT_POS && !vis[rp] && g_initColorMap[get_x_from_pos(rp)][get_y_from_pos(rp)]==pc){
vis[rp] = 1;
toTick[++tail] = rp;
}
}
for(int i=1; i<=tail; ++i) {
tickOneBlk(state, realHeadPos, toTick[i]);
tickOneBlk(tmpState, tmpRealHeadPos, toTick[i]);
}
return tail;
}
int explore(array<array<stBlk, 10>, 10> state, pos RealHeadPos)
{
//cout<<RealHeadPos<<endl;
int sco = g_SCORE[state];
if ( sco != 0 ) {
return sco;
}
//printMap(state, RealHeadPos);
updateAllPos(state, RealHeadPos);
array<array<stBlk, 10>, 10> tmpState = state;
pos tmpRealHeadPos = RealHeadPos;
int tmpMax = 1;
while (tmpRealHeadPos != OUT_POS) {
if (checkIsSingle(state, tmpRealHeadPos) == true) {
tickOneBlk(tmpState, tmpRealHeadPos, tmpRealHeadPos);
}
else {
array<array<stBlk, 10>, 10> state1 = state;
pos RealHeadPos1 = RealHeadPos;
pos RealTickPos = tmpRealHeadPos;
int cnt = destroy(state1, RealHeadPos1, RealTickPos, tmpState, tmpRealHeadPos);
tmpMax = max(tmpMax, explore(state1, RealHeadPos1)+5*cnt*cnt);
}
}
g_SCORE[state] = tmpMax;
#if 0
g_mapSize++;
#endif
if(tmpMax > g_BEST_SCORE) {
g_BEST_SCORE = tmpMax;
cout << "---------------------------" << endl;
cout << "Best Score: " << g_BEST_SCORE << endl;
printMap(state, RealHeadPos);
//g_BEST_SCORE = 999999;
}
//printt(state, g_BEST_SCORE);
return tmpMax;
}
void proc()
{
g_BEST_SCORE = explore(g_initStateMap, g_initHeadPos);
cout << "BEST SCORE :" << g_BEST_SCORE << endl;
}
void random(pos a[], int n)
{
srand((unsigned)time(NULL));
for(int i=0; i<n; ++i) {
int index = rand()%(n-i)+i;
if (index != i) {
pos tmp = a[i];
a[i] = a[index];
a[index] = tmp;
}
}
}
void test(array<array<stBlk, 10>, 10> S, pos H)
{
pos tick[100];
for(int i=0; i<100; ++i) {
tick[i] = get_pos_from_xy(i/10, i%10);
}
random(tick, 100);
for(int i=0; i<100; ++i) {
int x;
stBlk tB = S[get_x_from_pos(tick[i])][get_y_from_pos(tick[i])];
pos uu = get_u_pos_from_blk(tB);
pos dd = get_d_pos_from_blk(tB);
pos ll = get_l_pos_from_blk(tB);
pos rr = get_r_pos_from_blk(tB);
printf("-----------------------------\n");
printf("tick on (%d, %d)\n", get_x_from_pos(tick[i]), get_y_from_pos(tick[i]));
printf("u:(%d,%d) d:(%d,%d) l:(%d,%d) r:(%d,%d)\n",\
get_x_from_pos(uu), get_y_from_pos(uu),\
get_x_from_pos(dd), get_y_from_pos(dd),\
get_x_from_pos(ll), get_y_from_pos(ll),\
get_x_from_pos(rr), get_y_from_pos(rr)
);
//cin >> x;
tickOneBlk(S, H, tick[i]);
printf("tick Done.\n");
//printMap(S, H);
printf("printMap Done.\n");
}
cout<<"test done"<<endl;
printf("%d\n", H);
//printMap(S, H);
}
int main()
{
globalInit();
readInitMap();
printMap(g_initStateMap, g_initHeadPos);
//test(g_initStateMap, g_initHeadPos);
//tickOneBlk(g_initStateMap, g_initHeadPos, get_pos_from_xy(4, 7));
//printMap(g_initStateMap, g_initHeadPos);
proc();
return 0;
}
