POJ题目之1007号

纸上得来终觉浅，绝知此事要躬行，越来越觉得自己的动手能力有点差了，因此决定动手写写画画了，开始从POJ开始做起，做一道，贴出来一道。自己监督自己，加强动手能力。

一：

    这是一道求逆序的问题，方法是用归并排序，求的给定字符串的逆序是多少。

   花了至少5个小时,然而还不是好的解决方法

package problem;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Comparator;
import java.util.Scanner;
import java.util.TreeSet;
import java.util.Vector;

public class problem107test1 {

	/**
	 * @param args
	 * 第一本完成了功能，但是存在一些问题
	 * 1：提交不行，因为会有版本的问题
	 * 2：其中存在一些小问题，都没有解决。
	 */
	private static int reverse = 0;
	//目的求逆序对,方法用归并排序来计数
	private static void Merge(char[] array,int left,int middle,int right){
		int leftleght = middle-left+1;
		int rightlength = right-middle;
		char[] leftarray = new char[leftleght];
		char[] rightarray = new char[rightlength];
		//复制数据出来
		int i,j,k=left;
		for(i=0;i<leftleght;i++){
			leftarray[i] = array[k++];
		}
		for(j=0;j<rightlength;j++){
			rightarray[j] = array[k++];
		}
		
		i=j=0;
		k = left;
		//进行合并
		while(i<leftleght&&j<rightlength){
			if(leftarray[i]<=rightarray[j]){
				array[k++] = leftarray[i++];
			}else{
				array[k++] = rightarray[j++];
				//这里是逆序了,可是怎么计算了,说明array[i]以及后面的都比array[j]大，但是却在前面，因此是逆序
				reverse+=leftleght-i;
			}
		}
		while(i<leftleght){
			array[k++] = leftarray[i++];
		}
		while(j<rightlength){
			array[k++] = rightarray[j++];
		}
		
	}

	private static void Merge_sort(char[] array,int left,int right){
		int middle = left+(right-left)/2;
		if(left<right){
			Merge_sort(array, left, middle);
			Merge_sort(array, middle+1, right);
			Merge(array, left, middle, right);
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//接受数据
		Scanner scan = new Scanner(System.in);
		int length = scan.nextInt();
		int count = scan.nextInt();
		String temp;
		ArrayList<String> input = new ArrayList<String>();
		for(int i=0;i<count;i++){
			temp = scan.next();
			//scan.nextLine()方法，到底是干什么的,为什么就是不行了
			input.add(temp);
		}
		
		//这里要疯了，为什么数据全都为空了
		
		//对数据进行排序,我不知道如何创建Entry，所以用map来转换
		DNAComparator<Entry<String,Integer> > mycomparator = new DNAComparator<Entry<String,Integer> >();
		Map<String,Integer> map = new LinkedHashMap<String,Integer>();
		for(int i=0;i<count;i++){
			Merge_sort(input.get(i).toCharArray(),0,length-1);
			map.put(input.get(i), reverse);
			reverse = 0;
		}
		
		//可是TreeSet,TreeMap都是1.6版本的，POJ都不支持啊。
		TreeSet<Entry<String,Integer> > sort = new TreeSet<Entry<String,Integer> >(mycomparator);
		for(Entry<String,Integer> entry:map.entrySet()){
			sort.add(entry);
		}
		//打印原始数据
		//这里出现深层次的原因了，显示出就不适合用TreeSet，或者说TreeSet是怎么判断两个数是否相等
		//他不能装一样的东西，而我的comparator接口，会显然定义出相等，那么我要尝试，才知道
		Entry<String,Integer> entry ;
		for(int i=0;i<count;i++){
			entry = sort.pollFirst();
			System.out.println(entry.getKey());
		}
	}
}

class DNAComparator<T> implements Comparator<T>{

	@Override
	public int compare(T o1, T o2) {
		// TODO Auto-generated method stub
		@SuppressWarnings("unchecked")
		Entry<String,Integer> entry1 = (Entry<String, Integer>) o1;
		@SuppressWarnings("unchecked")
		Entry<String,Integer> entry2 = (Entry<String, Integer>) o2;
		if(entry1==entry2){
			return 0;
		}else
			return entry1.getValue()>entry2.getValue()?1:-1;
	}
	
}

但是还是有些问题，我要慢慢解决，当时出现的问题是接受数据后，我打印都是空数据，以为scan.nextLine方法有问题，事后验证了一下，没有问题，不知道开始原因出在哪儿。

在我最初用的是如下所示的Comparator,但是就是TreeSet中的元素减少了，所以自己找点了资料，以及实验，明白了原来Comparator是比较相等，还是不相等，而不是比较大小的。重点在等还是不等，然后修改如上。

class MyComparator<T> implements Comparator<T>{

	@Override
	public int compare(T o1, T o2) {
		// TODO Auto-generated method stub
		@SuppressWarnings("unchecked")
		Entry<String,Integer> entry1 = (Entry<String, Integer>) o1;
		@SuppressWarnings("unchecked")
		Entry<String,Integer> entry2 = (Entry<String, Integer>) o2;
		if(entry1.getValue()>=entry2.getValue()){
			return 1;
		}else
			return 0;
	}
}

想来想去：我重新做了一个类，来做比较，放在数组里面。思路如下

class DNA implements Comparable<DNA>{
	private String dna;
	private int reverse;
	public DNA(String dna, int reverse) {
		super();
		this.dna = dna;
		this.reverse = reverse;
	}
	public String getDna() {
		return dna;
	}
	public void setDna(String dna) {
		this.dna = dna;
	}
	public int getReverse() {
		return reverse;
	}
	public void setReverse(int reverse) {
		this.reverse = reverse;
	}
	
	@Override
	public int compareTo(DNA o) {
		if(this.getReverse()==o.getReverse())
			return 0;
		else
			return this.getReverse()>o.getReverse()?1:-1;
	}
	
}

Arrays.sort(data);

//但是提交有问题，我想可能是sort自身的问题，最后我自己想了想用个稳定的排序自己解决。

//排序,自己进行排序，要找个稳定排序的算法，冒泡，插入，归并，基数排序是稳定，我选择插入排序吧
		DNA sf;
		for(int i=1;i<count;i++){
			int k = i-1;
			sf = data[i];
			while(k>=0&&(sf.getReverse()<data[k].getReverse())){
				data[k+1] = data[k];
				k--;
			}
			data[++k] = sf;
		}

最后发我发现自己提交的经验比较少，原来是包含了包，不应该包含包，然后上面的Arrays方法没有问题。

可是当我发现提交后，发现别人用c++，做的真是简洁，自己怎么就那么傻了，智商差距啊。明天来用c++也来试试看，顺便也找找别人用java做的比较好的。