HDU1379 DNA Sorting 简单排序

DNA Sorting

                                                                                                       Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
                                                                                                                               Total Submission(s): 854    Accepted Submission(s): 442

Problem 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.


This problem contains multiple test cases!

The first line of a multiple input is an integer N, then a blank line followed by N input blocks. Each input block is in the format indicated in the problem description. There is a blank line between input blocks.

The output format consists of N output blocks. There is a blank line between output blocks.

 

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 (1 < 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''. If two or more strings are equally sorted, list them in the same order they are in the input file.

 

Sample Input

1

10 6
AACATGAAGG
TTTTGGCCAA
TTTGGCCAAA
GATCAGATTT
CCCGGGGGGA
ATCGATGCAT

 

Sample Output

CCCGGGGGGA
AACATGAAGG
GATCAGATTT
ATCGATGCAT
TTTTGGCCAA
TTTGGCCAAA

 

　　数据很弱，该题要求输出稳定排序，所以这里采用了bobblesort，看了大家都是 0MS过的，呵呵，暴力去！！

　　代码如下：

#include <iostream>

using namespace std;

char str[105][55];

int rec[105][2]; // 0 号元素用来存储下标，1 号元素用来存储逆序值

int get( char *s, int len )
{
	int ans= 0;
	for( int i= 0; i< len- 1; ++i )
	{
		for( int j= i+ 1; j< len; ++j )
		{
			if( s[i]> s[j] )
			{
				ans++;	
			}
		}
	}
	return ans;
}

void swap( const void *a, const void *b, int size )
{
  　　	char *x= ( char * )a, *y= ( char * )b;
	for( int i= 0; i< size; ++i )
	{
		char c= *x;
		*x= *y;
		*y= c;
		x+= 1, y+= 1;
	}
	return;
}

void bsort( int rec[][2], int m )
{
	for( int i= 0; i< m- 1; ++i )
	{
		for( int j= 0; j< m- i- 1; ++j )
		{
			if( rec[j][1]> rec[j+ 1][1] )
			{
				swap( rec[j], rec[j+ 1], sizeof( rec[0] ) );
			}
		}
	}
	return;
}

int main(  )
{
	int N;
	cin>>N;
	while( N-- )
	{
		int n, m;
		cin>> n>> m;
		for( int i= 0; i< m; ++i )
		{
			cin>> str[i];
			rec[i][0]= i;
			rec[i][1]= get( str[i], n );
//			cout<< rec[i][1]<< endl;
		}
		bsort( rec, m );
		for( int i= 0; i< m; ++i )
		{
			cout<< str[ rec[i][0] ]<< endl;
		}
		if( N> 1 )
		{
			cout<< "\n";
		}
	}
	return 0;
}