Sort with Swap(0, i)

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$ (\le 10^5≤10​5​​) 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

思路：如果不计较最小步数的话就很简单：i从1到n，0先占领i位置，然后与i交换。

而这里要求最小步数，最开始猜想会不会最小就是按照这样呢？于是模拟了一遍

package SortwithSwap0;
import java.util.*;

/*
 * 模拟一遍算出来的是不是最小的步数？
 */
public class simulate {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        int zeroIdx = -1, sum = 0;
        for(int i=0; i<n; i++)	{
        	a[i]=sc.nextInt();
        	if(a[i] == 0)	zeroIdx = i;
        }
        
        for(int i=1; i<n; i++) {
        	if(a[i] == i)	continue;
        	
        	if(a[i] != 0) {
        		sum ++;
        		
        		a[zeroIdx] = a[i];
        		a[i] = 0;
        		zeroIdx = i;
        		
        		System.out.println(Arrays.toString(a));
        	}
        	
        	sum ++;
        	zeroIdx = get(a, i);
        	a[zeroIdx] = 0;
        	a[i] = i;
        	
        	
        	System.out.println(Arrays.toString(a));
        }
        
        if(a[0] != 0) 	sum ++;
        
        System.out.println(sum);
	}

	private static int get(int[] a, int t) {
		for(int i=0; i<a.length; i++)
			if(a[i] == t)	return i;
		return 0;
	}
}

用例通不过，确实，每次这样先占领似乎是有些冗余，如果能0在哪个index上面就和index交换，这样就省去了每次都要占领的1次，一直交换到什么时候呢？仔细一想就是交换到0又回到了 0 index的位置就完了，而这不就是index和nums[index]构成的一个环吗？

如果0在这个环里，毫无疑问我们就这样做，但是如果0不在环里面呢？

这时也可以证明：需要将0加到换里面，然后执行上面的操作，

package SortwithSwap0;
import java.util.*;

/*
 * simulation的过程中发现有很多交换是浪费的
 * 1. 可以证明要想最小的交换一定要 idx与number构成环
 * 2. 可以怎么只需要一次交换，就可以把0插入到环中
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        for(int i=0; i<n; i++)	a[i] = sc.nextInt();
        int sum = 0; 
        boolean[] marked = new boolean[n];
        
        for(int i=0; i<n; i++) {
        	if(a[i] == i) {
        		marked[i] = true;
        		continue;
        	}
        	
        	if(!marked[i]) {
        		int cnt = 0, j = i;
        		while(true) {
        			cnt ++;
        			marked[j] = true;
        			j = a[j];
        			
        			if(i == j)	break;
        		}
        		
        		if(i == 0)	sum += cnt - 1;
        		else		sum += cnt + 1;
        	}
        }
        
        System.out.println(sum);
	}

}