PAT 1067. Sort with Swap(0,*)

1067. Sort with Swap(0,*) (25)

 

Given any permutation of the numbers {0, 1, 2,..., N-1}, it is easy to sort them in increasing order. But what if Swap(0, *) is the ONLY operation that is allowed to use? For example, to sort {4, 0, 2, 1, 3} we may apply the swap operations in the following way:

Swap(0, 1) => {4, 1, 2, 0, 3}
Swap(0, 3) => {4, 1, 2, 3, 0}
Swap(0, 4) => {0, 1, 2, 3, 4}

Now you are asked to find the minimum number of swaps need to sort the given permutation of the first N nonnegative integers.

Input Specification:

Each input file contains one test case, which gives a positive N (<=10⁵) followed by a permutation sequence of {0, 1, ..., N-1}. All the numbers in a line are separated by a space.

Output Specification:

For each case, simply print in a line the minimum number of swaps need to sort the given permutation.

Sample Input:

10 3 5 7 2 6 4 9 0 8 1

Sample Output:

9

一开始按照选择排序做了， 结果有两个测试点超时， 看看网上的思路基本上都是判断是否被访问的算法，想了想这个应该是表排序的变形，就按照表排序方式做了，花了一下午调试 果然AC了， 特地来交流 ^_^!

 #include <stdio.h>
 #include <stdlib.h>

 typedef int ElementType;

 void Swap(ElementType *a, ElementType *b);
 void PrintA(ElementType A[], int N);
 int IsSort( ElementType A[], int m, int N);
 void SwapZero( ElementType A[], ElementType B[], int N);

 typedef struct {
     int index;//0元素所在下标
     int count;//记录交换次数
 }Zero;

 Zero zero;

 int main(){
     int N, i;
     zero.count = ;
     //freopen("C:\\in.txt","r", stdin);
     scanf("%d", &N);
     ElementType* A;//这个是原来的数组
     A = (ElementType*)malloc(N*sizeof(ElementType));
     ElementType* B;//这个是表
     B = (ElementType*)malloc(N*sizeof(ElementType));
     for( i=; i<N; i++){
         scanf("%d", &A[i]);
         B[A[i]] = i;//记录A[i]所在的位置
         if(A[i] == )
             zero.index = i;
     }
     SwapZero(A, B, N);
     printf("%d\n", zero.count);
     return ;
 }

 int IsSort( ElementType A[], int m, int N){
     int i;
     int flag = ;
     for(; m<N; m++ ){
         if( m != A[m] ) {
             flag = m;
             break;
         }
     }
     return flag;
 }

 void SwapZero( ElementType A[], ElementType B[], int N){
     int i, m = ;
     for( ; ; ){
         if( zero.index !=  ){//交换swap(0,i);
             Swap( &A[zero.index], &A[B[zero.index]]);
             B[] = B[zero.index];
             B[A[zero.index]] = zero.index;//更新表
             zero.index = B[];
             zero.count++;
         } else if( m=IsSort(A, m, N)){  //找到第一个位置不对的数字交换
             Swap( &A[zero.index], &A[m]);//交换，更新表
             B[zero.index] = m;
             B[A[zero.index]] = ;
             zero.index = B[zero.index];
             zero.count++;
         } else break;
     }
 }

 void Swap(ElementType *a, ElementType *b){
     int tmp;
      tmp = *a;
      *a = *b;
      *b = tmp;
 }