POJ 2983 M × N Puzzle

M × N Puzzle

Time Limit: 4000MS		Memory Limit: 131072K
Total Submissions: 4860		Accepted: 1321

Description

The Eight Puzzle, among other sliding-tile puzzles, is one of the famous problems in artificial intelligence. Along with chess, tic-tac-toe and backgammon, it has been used to study search algorithms.

The Eight Puzzle can be generalized into an M × N Puzzle where at least one of M and N is odd. The puzzle is constructed with MN − 1 sliding tiles with each a number from 1 toMN − 1 on it packed into a M by N frame with one tile missing. For example, with M = 4 and N = 3, a puzzle may look like:

1	6	2
4	0	3
7	5	9
10	8	11

Let's call missing tile 0. The only legal operation is to exchange 0 and the tile with which it shares an edge. The goal of the puzzle is to find a sequence of legal operations that makes it look like:

1	2	3
4	5	6
7	8	9
10	11	0

The following steps solve the puzzle given above.

START

1	6	2
4	0	3
7	5	9
10	8	11

DOWN
⇒

1	0	2
4	6	3
7	5	9
10	8	11

LEFT
⇒

1	2	0
4	6	3
7	5	9
10	8	11

UP
⇒

1	2	3
4	6	0
7	5	9
10	8	11

…

RIGHT
⇒

1	2	3
4	0	6
7	5	9
10	8	11

UP
⇒

1	2	3
4	5	6
7	0	9
10	8	11

UP
⇒

1	2	3
4	5	6
7	8	9
10	0	11

LEFT
⇒

1	2	3
4	5	6
7	8	9
10	11	0

GOAL

Given an M × N puzzle, you are to determine whether it can be solved.

Input

The input consists of multiple test cases. Each test case starts with a line containing M and N (2 ≤ M, N ≤ 999). This line is followed by M lines containing N numbers each describing an M × N puzzle.

The input ends with a pair of zeroes which should not be processed.

Output

Output one line for each test case containing a single word YES if the puzzle can be solved and NO otherwise.

Sample Input

3 3
1 0 3
4 2 5
7 8 6
4 3
1 2 5
4 6 9
11 8 10
3 7 0
0 0

Sample Output

YES
NO

 #include<cstdio>

 //#include<iostream>

 #include<cstring>

 #include<algorithm>

 #include<cmath>

 #include<vector>

 //#include<queue>

 //#include<set>

 #define INF 0x3f3f3f3f

 #define N 10000005

 #define re register

 #define Ii inline int

 #define Il inline long long

 #define Iv inline void

 #define Ib inline bool

 #define Id inline double

 #define ll long long

 #define Fill(a,b) memset(a,b,sizeof(a))

 #define R(a,b,c) for(register int a=b;a<=c;++a)

 #define nR(a,b,c) for(register int a=b;a>=c;--a)

 #define Min(a,b) ((a)<(b)?(a):(b))

 #define Max(a,b) ((a)>(b)?(a):(b))

 #define Cmin(a,b) ((a)=(a)<(b)?(a):(b))

 #define Cmax(a,b) ((a)=(a)>(b)?(a):(b))

 #define D_e(x) printf("\n&__ %d __&\n",x)

 #define D_e_Line printf("-----------------\n")

 #define D_e_Matrix for(re int i=1;i<=n;++i){for(re int j=1;j<=m;++j)printf("%d ",g[i][j]);putchar('\n');}

 using namespace std;

 //    The Code Below Is Bingoyes's Function Forest.

 Ii read(){

     int s=,f=;char c;

     for(c=getchar();c>''||c<'';c=getchar())if(c=='-')f=-;

     while(c>=''&&c<='')s=s*+(c^''),c=getchar();

     return s*f;

 }

 Iv print(ll x){

     if(x<)putchar('-'),x=-x;

     if(x>)print(x/);

     putchar(x%^'');

 }

 /*

 Iv Floyd(){

     R(k,1,n)

         R(i,1,n)

             if(i!=k&&dis[i][k]!=INF)

                 R(j,1,n)

                     if(j!=k&&j!=i&&dis[k][j]!=INF)

                         Cmin(dis[i][j],dis[i][k]+dis[k][j]);

 }

 Iv Dijkstra(int st){

     priority_queue<int>q;

     R(i,1,n)dis[i]=INF;

     dis[st]=0,q.push((nod){st,0});

     while(!q.empty()){

         int u=q.top().x,w=q.top().w;q.pop();

         if(w!=dis[u])continue;

         for(re int i=head[u];i;i=e[i].nxt){

             int v=e[i].pre;

             if(dis[v]>dis[u]+e[i].w)

                 dis[v]=dis[u]+e[i].w,q.push((nod){v,dis[v]});

         }

     }

 }

 Iv Count_Sort(int arr[]){

     int k=0;

     R(i,1,n)

         ++tot[arr[i]],Cmax(mx,a[i]);

     R(j,0,mx)

         while(tot[j])

             arr[++k]=j,--tot[j];

 }

 Iv Merge_Sort(int arr[],int left,int right,int &sum){

     if(left>=right)return;

     int mid=left+right>>1;

     Merge_Sort(arr,left,mid,sum),Merge_Sort(arr,mid+1,right,sum);

     int i=left,j=mid+1,k=left;

     while(i<=mid&&j<=right)

         arr[i]<=arr[j]?

             tmp[k++]=arr[i++]:

             tmp[k++]=arr[j++],sum+=mid-i+1;//Sum Is Used To Count The Reverse Alignment

     while(i<=mid)tmp[k++]=arr[i++];

     while(j<=right)tmp[k++]=arr[j++];

     R(i,left,right)arr[i]=tmp[i];

 }

 Iv Bucket_Sort(int a[],int left,int right){

     int mx=0;

     R(i,left,right)

         Cmax(mx,a[i]),++tot[a[i]];

     ++mx;

     while(mx--)

         while(tot[mx]--)

             a[right--]=mx;

 }

 */

 int n,m,a[N],sum_start,tmp[N];

 Iv Merge_Sort(int arr[],int left,int right,int &sum){

     if(left>=right)return;

     int mid=left+right>>;

     Merge_Sort(arr,left,mid,sum),Merge_Sort(arr,mid+,right,sum);

     int i=left,j=mid+,k=left;

     while(i<=mid&&j<=right)

         arr[i]<=arr[j]?

             tmp[k++]=arr[i++]:

             (tmp[k++]=arr[j++],sum+=mid-i+);//Sum Is Used To Count The Reverse Alignment

     while(i<=mid)tmp[k++]=arr[i++];

     while(j<=right)tmp[k++]=arr[j++];

     R(i,left,right)arr[i]=tmp[i];

 }

 int main(){

     int n;

     while(scanf("%d %d",&n,&m)!=EOF,n,m){

         sum_start=;

         int sum_end,num_cnt=;

         R(i,,n)

             R(j,,m){

                 int num=read();

                 !num?

                     sum_end=i:

                     a[++num_cnt]=num;

             }

         Merge_Sort(a,,num_cnt,sum_start);

         D_e(sum_start);

         sum_end=n-sum_end;

         if(m&)sum_end=;

         (sum_start&)==(sum_end&)?

             printf("YES\n"):

             printf("NO\n");

     }

     return ;

 }

 /*

     Note:

         When Commas Are Used In Trinary Operators, Parentheses Shoule Be Used.

     Error:

         None.

 */