奇偶序列分别计数

解题思路:

    将原序列分为奇序列和偶序列来看，两条序列各自遍历计数，得出各自的最多数（个数）和次多数。若 奇最多的值（对应的数值） 不等于 偶最多的值，则 总修改次数 = n- 奇最多 -偶最多；若 奇最多的值 等于 偶最多的值 ，则需要加入次多数进行替代，取 奇最多+偶次多 和 偶最多+奇次多 之中的最多者，然后 总修改次数=n-这个最多者。

注意事项:

    注意 奇次多 和 偶次多 可能不存在，那么就直接将它们的数量置为0即可。其次就是不需要关注 奇次多的值 和 偶次多的值，我们只在 奇最多的值 等于 偶最多的值时，才考虑它们，那它们一定不会和 奇最多的值 和 偶最多的值 相等。

参考代码:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map.Entry;


// 小蓝的序列
public class Main {

	public static void main(String[] args) throws IOException {
			
		func1();
		
	}
	
	public static void func1() throws IOException {
		BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
		
		int n = Integer.valueOf(bf.readLine().trim());
		String[] numStrings = bf.readLine().trim().split("\\s+");
		
		HashMap<Integer, Integer> JMap = new HashMap<Integer, Integer>();
		HashMap<Integer, Integer> OMap = new HashMap<Integer, Integer>();
		
		for(int i=0; i<n; i+=2) {
			int Onum = Integer.valueOf(numStrings[i]);
			
			if(OMap.containsKey(Onum)) {
				OMap.put(Onum, OMap.get(Onum)+1);
			}else {
				OMap.put(Onum, 1);
			}
			
		}
		
		for(int i=1; i<n; i+=2) {
			int Jnum = Integer.valueOf(numStrings[i]);
			
			if(JMap.containsKey(Jnum)) {
				JMap.put(Jnum, JMap.get(Jnum)+1);
			}else {
				JMap.put(Jnum, 1);
			}
			
		}
		
		int[][] JnumsArray = new int[JMap.size()][2];
		int[][] OnumsArray = new int[OMap.size()][2];
		
		int i=0;
		for(Entry<Integer, Integer> entrys :JMap.entrySet()) {
			JnumsArray[i][0] = entrys.getKey();
			JnumsArray[i][1] = entrys.getValue();
			i++;
		}
		
		i=0;
		for(Entry<Integer, Integer> entrys :OMap.entrySet()) {
			OnumsArray[i][0] = entrys.getKey();
			OnumsArray[i][1] = entrys.getValue();
			i++;
		}
		
		Arrays.sort(JnumsArray,(a,b)->{
			return b[1] - a[1];
		});
		Arrays.sort(OnumsArray,(a,b)->{
			return b[1] - a[1];
		});
		
		int tempJ = JnumsArray[0][0];
		int tempO = OnumsArray[0][0];
		
		int countJ = JnumsArray[0][1];
		int countO = OnumsArray[0][1];
		
		int countSum = 0;
		
		if(tempJ==tempO) {  // 如果奇列和偶列最多数的值相同
			
			int countJNext;
			if(JnumsArray.length<=1) {  // 奇列只有一种数
				countJNext=0;
			}else {
				countJNext = JnumsArray[1][1];
			}
			
			int countONext;
			
			if(OnumsArray.length<=1) {  // 偶列只有一种数
				countONext=0;
			}else {
				countONext = OnumsArray[1][1];
			}
			
			int nnSum1 = countJ + countONext;
			int nnSum2 = countO + countJNext;
			
			countSum = nnSum1>nnSum2 ? nnSum1 : nnSum2;

		}else {
			countSum = countJ + countO;
		}
		
		System.out.println(n-countSum);
	
	}

}