hdu-1379 DNA Sorting

DNA Sorting

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

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
  
  
  
  


  
  
  
  

   
   题目大意就是每个字符串找逆序对的数量，再按逆序对数量来做个升序的排序就好了，代码如下：
  
  
  
  

   
   
//
//  main.cpp
//  hdu1379
//
//  Created by Morris on 16/7/19.
//  Copyright © 2016年 Morris. All rights reserved.
//

#include <cstdio> 
#include <cstring> 
#include <vector>
#include <algorithm>

namespace {
    using std::scanf;
    using std::printf;
    using std::strlen;
    using std::vector;
    using std::sort;
}

typedef struct inversion {
    char str[100];
    int cnt;
} inver_t;

int cmp(const inver_t &__x, const inver_t &__y);

int main(int argc, const char *argv[])
{
    int N;
    int n, m;
    int count;
    inver_t tmp;
    vector<inver_t> vec;
    while (~scanf("%d", &N)) {
        scanf("%d%d", &n, &m);
        int i;
        int j, k;
        for (i = 0; i < m; ++i) {
            count = 0;
            scanf("%s", tmp.str);
            
            for (j = 0; j < strlen(tmp.str) - 1; ++j) {
                for (k = j + 1; k < strlen(tmp.str); ++k) {
                    if (tmp.str[j] > tmp.str[k]) {
                        ++count;
                    }
                }
            }
            
            tmp.cnt = count;
            vec.push_back(tmp);
        }
        
        sort(vec.begin(), vec.end(), cmp);
        for (i = 0; i < vec.size(); ++i) {
            printf("%s\n", vec[i].str);
        }
        
        vec.clear();
    }
    return 0;
}

int cmp(const inver_t &__x, const inver_t &__y)
{
    return __x.cnt < __y.cnt;
}