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 = 0;
    //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=0; i<N; i++){
        scanf("%d", &A[i]);
        B[A[i]] = i;//记录A[i]所在的位置 
        if(A[i] == 0) 
            zero.index = i;
    }
    SwapZero(A, B, N);
    printf("%d
", zero.count);
    return 0;
}

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

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


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