USACO - 2.1.3 - Sorting a Three-Valued Sequence

 

原创文章转载请注明出处

摘要： 模拟

一. 题目翻译

1. 描述：

排序是一种很频繁的计算任务。现在考虑最多只有三值的排序问题。一个实际的例子是，当我们给某项竞赛的优胜者按金银铜牌排序的时候。在这个任务中可能的值只有三种1，2和3。我们用交换的方法把他排成升序的。

写一个程序计算出，给定的一个1,2,3组成的数字序列，排成升序所需的最少交换次数。

2. 格式：

          INPUT FORMAT:

          (file sort3.in)

          第一行：

          奖牌个数N (1 <= N <= 1000)

          第 2行到第N+1行:

          每行一个数字，表示奖牌。共N行。（1..3）

          OUTPUT FORMAT:

          (file sort3.out)

          共一行，一个数字。表示排成升序所需的最少交换次数。

3. SAMPLE：

          SAMPLE INPUT:

9

2

2

1

3

3

3

2

3

1

          SAMPLE OUTPUT:

4

          

二.  题解

1. 题意理解（将问题分析清楚，大致用什么思路）：

          题目可以直接模拟，由于只有三个值，所以首先将所有的1还原到排序后的位置，然后再将2还原到排序位置，那么剩下的数字3必然在排序的位置。

          这种实现有个小问题，就是如何能够使交换的次数最少 ？ 等价的问题就是如果现在2占用着1的位置，那么我们尽量将这个2移动到排序后2所在的位置区域，也就是移动一次就可以使两个数字归位（参考sample中在第一位的2的移动，与在第三位1移动，两个数字都归位了）。但是也有一种可能就是无法通过一次交换实现两个数字归位（参考sample中的第二位2的移动，只能与最后一位的1交换，但是这个1占用的是排序后3的位置）。

          对于上述的问题，如果当前数字是2，那么我们从2的起始位置开始遍历，也就是能够优先满足一次交换使两个数字归位的情况。如果当前数字是3，我们从3的结束位置倒序遍历。

 

2.  具体实现（具体实现过程中出现的问题）：

          请参考代码注释。

3. 启示：

          其实还有另外一种方法，用一个数组a[i][j]表示数字i在j的位置上，用一个堆栈将a[i][j]入栈，如果堆栈中有a[j][i]，则a[i][j]与a[j][i]都出栈（比较次数+1）。如果有a[j][(i+1)%3]那么a[i][(i+1)%3]入栈（比较次数+1）。重复此操作直到栈中没有元素了。

三.  代码

/*
ID:fightin1
LANG:JAVA
TASK:sort3
*/


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;

public class sort3 {

	public static void main(String[] args) {
		try {
//			Scanner in = new Scanner(System.in);
//			PrintWriter pw = new PrintWriter(System.out);
			
			Scanner in = new Scanner(new BufferedReader(new FileReader(
			"sort3.in")));
			PrintWriter pw = new PrintWriter(new BufferedWriter(new FileWriter(
			"sort3.out")));
			
			int num = in.nextInt();
			int cnt = 0;
			int[] input = new int[num];
			int[] sorted = new int[num];
			int[] position = new int[4];
			
			for (int i=0;i<num;i++){
				int temp = in.nextInt();
				if (temp == 1){
					position[1]++;
				} else if (temp == 2){
					position[2]++;
				} else {
					position[3]++;
				}
				input[i] = temp;
				sorted[i] = temp;
			}
			
			Arrays.sort(sorted);
			position[3] = position[2] + position[1];
			position[2] = position[1];
			position[1] = 0;
			
			for (int i=position[1];i<position[2];i++){
				int temp = input[i];
				if (temp == 2){
					for (int j=position[2];j<num;j++){
						if (input[j] == sorted[i]){
							exchange(i, j, input);
							cnt ++;
							break;
						}
					}
				} else if (temp == 3){
					for (int j=num-1;j>=position[2];j--){
						if (input[j] == sorted[i]){
							exchange(i, j, input);
							cnt ++;
							break;
						}
					}
				}
			}
			
			for (int i=position[2];i<position[3];i++){
				int temp = input[i];
				if (temp == 3){
					for (int j=num-1;j>=position[2];j--){
						if (input[j] == sorted[i]){
							exchange(i, j, input);
							cnt ++;
							break;
						}
					}
				}
			}
			
			pw.println(cnt);
			pw.close();
			in.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	public static void exchange(int i,int j,int[] target){
		int temp = target[i];
		target[i] = target[j];
		target[j] = temp;
	}
}