OpenJudge DNA排序

最新推荐文章于 2022-10-17 18:55:39 发布

Hattfield

最新推荐文章于 2022-10-17 18:55:39 发布

阅读量743

点赞数 1

分类专栏： OpenJudge 文章标签： DNA排序逆序对归并排序算法时间复杂度

本文链接：https://blog.csdn.net/qq_51767234/article/details/120147289

版权

OpenJudge 专栏收录该内容

39 篇文章 0 订阅

订阅专栏

DNA排序

要求：

总时间限制: 1000ms

内存限制: 65536kB

描述：

现在有一些长度相等的DNA串（只由ACGT四个字母组成），请将它们按照逆序对的数量多少排序。

逆序对指的是字符串A中的两个字符A[i]、A[j]，具有i < j 且 A[i] > A[j] 的性质。如字符串”ATCG“中，T和C是一个逆序对，T和G是另一个逆序对，这个字符串的逆序对数为2。

输入：

第1行：两个整数n和m，n(0<n<=50)表示字符串长度，m(0<m<=100)表示字符串数量

第2至m+1行：每行是一个长度为n的字符串

输出：

按逆序对数从少到多输出字符串，逆序对数一样多的字符串按照输入的顺序输出。

样例输入：

10 6
AACATGAAGG
TTTTGGCCAA
TTTGGCCAAA
GATCAGATTT
CCCGGGGGGA
ATCGATGCAT

样例输出：

CCCGGGGGGA
AACATGAAGG
GATCAGATTT
ATCGATGCAT
TTTTGGCCAA
TTTGGCCAAA

问题分析：

这一次我们的要求是求出所给定的DNA序列中的逆序数. DNA序列中的“ACGT”是要求按照字典序进行从小到大的排序，即 $A<C<G<T$ A<C<G<T. 逆序数指的是逆序对的个数，而逆序对的定义已经在题目中给出，所以这里不再赘述。

在这个题目中我们需要做的有两件事：1）求出每一个DNA序列的逆序数；2）将这些逆序数进行比较，并以逆序数从小到大的顺序输出原DNA序列. 对于第2步，我们可以采取结构体部分排序或者pair的方式来实现，并不复杂，关键在于第一步如何处理。

求出一个序列的逆序数，一个最直观的想法就是对每一个字符，循环一遍之前所有的字符，计算出这个字符的逆序对数，最后将这些逆序数相加即可.这个算法的复杂度是 $O(n^2)$ O(n^2).(算法如下)

int CountAdverse(string DNA){
    int count=0;//逆序数
    for(int i=0;i<DNA.size();i++){
       for(int j=0;j<i;j++){
           if(DNA[j]>DNA[i]) count++;
       }
    }
    return count;
}

这样的算法根据定义来计算，很直观，但同样很简陋。所以我们希望找到一个更好的算法，可以压缩求逆序数的时间。那么我们就将目光投向了归并排序。

归并排序，顾名思义是一种排序方式。它利用递归的思想，如果要对序列P进行排序，那么可以先对P的前一半进行排序，再对后一半进行排序，再不断取两边中的最小值即可。而对P的一半排序时，又会取一半的一半，以此类推，直至取得只剩一个元素，然后递归结束，这样的算法复杂度是O(nlogn).具体算法如下：

char temp[55];
inline void Merge(string& str,int first,int mid,int last,int& count){
    int i=first;//前一半的第一个
    int j=mid+1;//后一半的第一个，注意：此时前一半与后一半分别排序好了
    int cur=first;//需要借助temp数组暂时存储，以便修改str
    while(i<=mid&&j<=last){
        if(str[i]<=str[j]){
            temp[cur++]=str[i++];
        }
        else{
            temp[cur++]=str[j++];
            count+=mid-i+1;//计算逆序数，解析在下文
        }
    }//取两边最小的
    while(i<=mid){
        temp[cur++]=str[i++];
    }//如果左边还没取完
    while(j<=last){
        temp[cur++]=str[j++];
    }//如果右边还没取完
    for(int k=first;k<=last;k++){
        str[k]=temp[k];
    }//把记录下来的正确顺序，重新填回到str中
}
inline void MergeSort(string& str,int first,int last,int& count){
    if(first==last) return;//只剩一个元素，return
    int mid=(first+last)/2;//mid就代表中间
    MergeSort(str,first,mid,count);//前一半排序
    MergeSort(str,mid+1,last,count);//后一半排序
    Merge(str,first,mid,last,count);//前一半与后一半不断取最小的
}

那么我们如何利用归并排序去求逆序数呢？对于前一半与后一半均排好序的序列P，如果前一半中的第 i 个元素已经大于后面某个元素x，那么从第 i 个元素到第mid个元素一定都大于元素x.所以我们会在上面的程序中发现 count+=mid-i+1 这一句.

那么此时我们最终代码就已经成型了，还有一些小细节需要处理，比如结构体的书写之类。这些可以直接通过代码得到解答。

最终代码：

#include<iostream>
#include<algorithm>
using namespace std;
struct SortOrder{
    string str;//DNA序列
    int Count{};//逆序数
    int Order{};//顺序
    inline bool operator<(const SortOrder& b) const{
        if(Count!=b.Count) return Count<b.Count;
        else return Order<b.Order;
    }//比较的运算符重载
};
char temp[55];
inline void Merge(string& str,int first,int mid,int last,int& count){
    int i=first;int j=mid+1;int cur=first;
    while(i<=mid&&j<=last){
        if(str[i]<=str[j]){
            temp[cur++]=str[i++];
        }
        else{
            temp[cur++]=str[j++];
            count+=mid-i+1;
        }
    }
    while(i<=mid){
        temp[cur++]=str[i++];
    }
    while(j<=last){
        temp[cur++]=str[j++];
    }
    for(int k=first;k<=last;k++){
        str[k]=temp[k];
    }
}
inline void MergeSort(string& str,int first,int last,int& count){
    if(first==last) return;
    int mid=(first+last)/2;
    MergeSort(str,first,mid,count);
    MergeSort(str,mid+1,last,count);
    Merge(str,first,mid,last,count);
}
int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    auto* DNA=new SortOrder[m];
    for(int i=0;i<m;i++){
        DNA[i].Order=i;
        cin>>DNA[i].str;
        string UseToSort=DNA[i].str;//因为函数中的引用会改变原序列，所以另设一个新的string
        MergeSort(UseToSort,0,n-1,DNA[i].Count);
    }
    sort(DNA,DNA+m);
    for(int i=0;i<m;i++){
        printf("%s\n",DNA[i].str.c_str());
    }
}