蓝桥杯-第九届决赛——交换次数

交换次数

程序设计（满分81分）

标题：交换次数

IT产业人才需求节节攀升。业内巨头百度、阿里巴巴、腾讯（简称BAT）在某海滩进行招聘活动。

招聘部门一字排开。由于是自由抢占席位，三大公司的席位随机交错在一起，形如：

ABABTATT，这使得应聘者十分别扭。

于是，管理部门要求招聘方进行必要的交换位置，使得每个集团的席位都挨在一起。即最后形如：

BBAAATTT 这样的形状，当然，也可能是：

AAABBTTT 等。

现在，假设每次只能交换2个席位，并且知道现在的席位分布，

你的任务是计算：要使每个集团的招聘席位都挨在一起需要至少进行多少次交换动作。

输入是一行n个字符（只含有字母B、A或T），表示现在的席位分布。

输出是一个整数，表示至少交换次数。

比如，输入：

TABTABBTTTT

程序应该输出：

3

再比如，输入：

TTAAABB

程序应该输出：

0

我们约定，输入字符串的长度n 不大于10万

资源约定：

峰值内存消耗（含虚拟机） < 256M

CPU消耗  < 1000ms

注意：请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。

不要使用package语句。不要使用jdk1.7及以上版本的特性。

主类的名字必须是：Main，否则按无效代码处理。

思路：经过读题和一系列分析，发现，有这几种顺序：

ABT、ATB、TAB 、TBA、BTA、BAT     后三个其实就是把字符串倒序后再排

分别把这几种依次排，然后记最小的交换次数就好。

试了很多的数据，发现都通过了。

用递归的话，字符数大会导致栈溢出。所以我这里没有用递归。

import java.util.Scanner;

public class Main {

	public static int count = 0;
	public static int min = Integer.MAX_VALUE;
	public static int numa = 0,numb = 0,numt = 0;
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		String n = in.next();
		char [] a = n.toCharArray();
		if(show(a)){
			System.out.println(count);
		}else{
			for(int i=0;i<a.length;i++){
				if(a[i]=='A'){
					numa++;
				}else if(a[i]=='B'){
					numb++;
				}else{
					numt++;
				}
			}
			show1(a);
			char [] a1 = new char[a.length];
			for(int i=0;i<a.length;i++){
				a1[i] = a[a.length-i-1];
			}
			show1(a1);
			System.out.println(min);
		}
}

//	ABT TBA
//	ATB BTA
//	TAB BAT
	private static void show1(char [] a) {
//		ABT TBA
//		ATB BTA
		char [] b = new char[a.length];
		for(Integer i=0;i<a.length;i++){
			b[i] = a[i];
		}
		sort(0,a.length-1,'A',b);
		int numAWW = count;
		char [] c = new char[a.length];
		for(Integer i=0;i<a.length;i++){
			c[i] = b[i];
		}
		sort(numa,a.length-1,'B',c);
		int numABT = count;
		min = min>numABT?numABT:min;
		c = new char[a.length];
		for(Integer i=0;i<a.length;i++){
			c[i] = b[i];
		}
		count = numAWW;
		sort(numa,a.length-1,'T',c);
		int numATB = count;
		min = min>numATB?numATB:min;
		count=0;
		
//		TAB BAT
		b = new char[a.length];
		for(Integer i=0;i<a.length;i++){
			b[i] = a[i];
		}
		sort(0,a.length-1,'T',b);
		int numTWW = count;
		c = new char[a.length];
		for(Integer i=0;i<a.length;i++){
			c[i] = b[i];
		}
		sort(numa,a.length-1,'A',c);
		int numTAB = count;
		min = min>numTAB?numTAB:min;
		count=0;
	}
	/**
	 * 交换位置
	 * 
	 */
	public static char [] temp(int i,int j,char [] a){
		char temp = a[i];
		a[i] = a[j];
		a[j] = temp;
		count++;
		return a;
	}
	
	public static char [] sort(Integer start,Integer end,char ch,char [] a){
		if(start>=end||end>=a.length){
			return a;
		}
		for(int i=end;i>=start;i--){
			if(a[i]==ch){
				boolean fal = true;
				while(fal){
					if(a[start]!=ch){
						temp(start,i,a);
						start+=1;
						fal = false;
					}else{
						start+=1;
						if(start>=i){
							return a;
						}
					}
				}
				
			}
		}
		
		return a;
	}
	/**
	 * 如果用递归，会栈溢出
	 * @param start
	 * @param end
	 * @param ch
	 * @param a
	 * @return
	 */
//	从start到end把ch排到前面
	public static char[] sort1(Integer start,Integer end,char ch,char [] a){
		if(start>=end||end>=a.length){
			return a;
		}
		if(a[end]==ch){
			if(a[start]!=ch){
				temp(start,end,a);
				sort(start+1,end-1,ch,a);
			}else{
				sort(start+1,end,ch,a);
			}
			
		}else{
			sort(start,end-1,ch,a);
		}
		return a;
	}
	
	/**
	 * 判断是否符合连续的
	 * @return true or false
	 */
	public static boolean show(char [] a){
		char t = a[0];
		Integer count = 1;
		for(Integer i=0;i<a.length;i++){
			if(t!=a[i]){
				count++;
				t = a[i];
				if(count>3)
					return false;
			}
		}
		return true;
	}
}