【原】 POJ 1007 DNA Sorting 逆序数 解题报告

 

http://poj.org/problem?id=1007

求逆序数的方法：
1、此题每个string只有4种字母，所以可以用类似counting sort的方法来以逆序扫描字符串，并以a[1...3]记录相应字符串组的个数，计算每位数与其后面几位的逆序数。复杂度n。但输入若没有限制就不能靠a[1...3]这样做了，那样的话可能每扫描一个字符++的数组位很多，需要判断的分支也很多，因此复杂度太高。
2、利用merge sort求逆序数n*lgn，对所有字符串的逆序数排序（这里用multimap简单代替）

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

 

#include <stdio.h>
#include <iostream>
#include <string>
#include <map>
#include <fstream>

using namespace std ;

//逆序扫描字符串求逆序数
//复杂度n
__int64 GetInversionCount( char *str, int n )
{
    __int64 cnt ;
    __int64 a[4] = {0} ; //a[1]:A , a[2]:A,C , a[3]:A,C,G 的个数
    int i ;

    //从后往前扫描，计算每位数与其后面几位的逆序数
    cnt = 0 ;
    for( i=n-1 ; i>=0 ; --i )
    {
        switch(str[i])
        {
        case 'A' :  //与其后面不会形成逆序对
            ++a[1] ;
            ++a[2] ;
            ++a[3] ;
            break ;
        case 'C' :  //与其后面的A形成逆序，所以逆序数要加上其后A的个数
            ++a[2] ;
            ++a[3] ;
            cnt += a[1] ;
            break ;
        case 'G' :  //与其后面的A、C形成逆序，所以逆序数要加上其后A、C的个数
            ++a[3] ;
            cnt += a[2] ;
            break ;
        case 'T' :  //与其后面的A、C、G形成逆序，所以逆序数要加上其后A、C、G的个数
            cnt += a[3] ;
            break ;
        }
    }
    return cnt ;
}

//**********************************

__int64 inversionNum = 0 ;

void Merge( char *a, char* tmpArr, int lb, int rb, int re )
{
    int le = rb-1 ;
    int tmpStart = lb ;
    int tmpEnd = re ;
    int tmpIndex = lb ;
    while( lb<=le && rb<=re )
    {
        if( a[lb] <= a[rb] )
            tmpArr[tmpIndex++] = a[lb++] ;
        else
        {
            tmpArr[tmpIndex++] = a[rb++] ;
            inversionNum += le-lb+1 ;
        }
    }

    while(lb<=le)
        tmpArr[tmpIndex++] = a[lb++] ;
    while(rb<=re)
        tmpArr[tmpIndex++] = a[rb++] ;

    while(tmpStart<=tmpEnd)
    {
        a[tmpStart] = tmpArr[tmpStart] ;
        ++tmpStart ;
    }
}

void Msort( char *a, char *tmpArr, int b, int e )
{
    if(b>=e)
        return ;
    int mid = b+(e-b)/2 ;
    Msort(a,tmpArr,b,mid) ;
    Msort(a,tmpArr,mid+1,e) ;
    Merge(a,tmpArr,b,mid+1,e) ;
}

void MergeSort( char *a , int n )
{
    char *tmpArr = new char[n+1] ;
    Msort(a,tmpArr,0,n-1) ;
    delete []tmpArr ;
}

//**********************************

void run1007()
{
    ifstream in("in.txt");

    int n,m ;
    string tmpStr ;
    multimap< __int64 , string > strMap ;
    multimap< __int64 , string >::iterator iter ;

    in>>n>>m ;

    char *a = new char[n+1] ;  //末尾'0'

    while( m-- && in>>a )  //不能用gets(a)，不然会从第一行输入的末尾开始，其末尾为换行符，而gets不会读入换行符
    {                       //所以gets读入的第一行字符为空字符
        tmpStr = a ;
        MergeSort(a,n) ;
        strMap.insert( make_pair(inversionNum,tmpStr) ) ;
        inversionNum = 0 ;
    }

    for( iter=strMap.begin() ; iter!=strMap.end() ; ++iter )
        cout<<iter->second<<endl ;

    delete []a ;
}


void run1007_1()
{
    ifstream in("in.txt");

    int n,m ;
    string tmp ;
    multimap< __int64 , string > strMap ;
    multimap< __int64 , string >::iterator iter ;

    in>>n>>m ;

    char *a = new char[n+1] ;  //末尾'0'

    while( m-- && in>>a )  //不能用gets(a)，不然会从第一行输入的末尾开始，其末尾为换行符，而gets不会读入换行符
    {                       //所以gets读入的第一行字符为空字符
        /*
        //这样会导致strMap中所有的second都是最后一个读入的字符串
        //因为作为second的a每次输入时都会被改变，其并没有复制
        __int64 count = GetInversionCount(a,n) ;
        strMap.insert( make_pair(count,a) ) ;
        */
        tmp = a ;
        __int64 count = GetInversionCount(a,n) ;
        strMap.insert( make_pair(count,tmp) ) ;

    }

    for( iter=strMap.begin() ; iter!=strMap.end() ; ++iter )
        cout<<iter->second<<endl ;

    delete []a ;
}