poj 1007

DNA Sorting

Time Limit: 1000 MSMemory Limit: 10000 KB[显示标签]

Description

One measure of ``unsortedness'' in a sequence is the number of pairs of entries that are out of order with respect to each other. For instance, in the letter sequence ``DAABEC'', this measure is 5, since D is greater than four letters to its right and E is greater than one letter to its right. This measure is called the number of inversions in the sequence. The sequence ``AACEDGG'' has only one inversion (E and D)---it is nearly sorted---while the sequence ``ZWQM'' has 6 inversions (it is as unsorted as can be---exactly the reverse of sorted).

You are responsible for cataloguing a sequence of DNA strings (sequences containing only the four letters A, C, G, and T). However, you want to catalog them, not in alphabetical order, but rather in order of ``sortedness'', from ``most sorted'' to ``least sorted''. All the strings are of the same length.

Input

The first line contains two integers: a positive integer n (0 < n <= 50) giving the length of the strings; and a positive integer m (0 < m <= 100) giving the number of strings. These are followed by m lines, each containing a string of length n.

Output

Output the list of input strings, arranged from ``most sorted'' to ``least sorted''. Since two strings can be equally sorted, then output them according to the orginal order.

Sample Input

10 6
AACATGAAGG
TTTTGGCCAA
TTTGGCCAAA
GATCAGATTT
CCCGGGGGGA
ATCGATGCAT

Sample Output

CCCGGGGGGA
AACATGAAGG
GATCAGATTT
ATCGATGCAT
TTTTGGCCAA
TTTGGCCAAA

Source

East Central North America 1998

import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

public class Main {
public static void main(String[] args){
Scanner sc=new Scanner(System.in);
sc.nextInt();
int ncase=sc.nextInt();
List<Node> l=new ArrayList<Node>();
for(int i=0;i<ncase;i++){
String str=sc.next();
l.add(new Node(str,i,getSortNum(str)));
}
Collections.sort(l);
for(Iterator<Node> it=l.iterator();it.hasNext();){
System.out.println(it.next().str);
}
sc.close();
}

private static int getSortNum(String s){
//char[] ch=s.toCharArray();
int len=s.length();
int ans=0;
for(int i=0;i<len-1;i++){
for(int j=i+1;j<len;j++){
if(s.charAt(i)>s.charAt(j)){
ans++;
}
}
}
return ans;
}

static class Node implements Comparable{

String str="";
int id=0;
int sortN=0;

Node(String str,int id,int sortN){
this.str=str;
this.id=id;
this.sortN=sortN;
}
@Override
public int compareTo(Object o) {

Node node=(Node)o;
if(node.sortN==sortN){
return node.id<id?1:(node.id==id?0:-1);
}else{
return node.sortN<sortN?1:-1;
}
}

}

}
Comparabke  Iterator