poj1007 树状数组逆序对

 

 

如题：http://poj.org/problem?id=1007

DNA Sorting

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 87544		Accepted: 35192

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

 

思路：树状数组求每一个字符串的逆序对个数。因为只有4个字母acgt，因此也就有了O（n）的算法。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;

int n,m;
char s[110][60];
int c[60];
typedef pair<char,int>P;
typedef pair<int,int>P1;

int cmp(P p1,P p2)
{
 return p1.first<p2.first;
}
int lowbit(int x)
{
 return x&(x^(x-1));
}
void add(int i,int x)
{
 while(i<=n)
 {
  c[i]+=x;
  i+=lowbit(i);
 }
}
int Sum(int i)
{
 int s=0;
 while(i>0)
 {
  s+=c[i];
  i-=lowbit(i);
 }
 return s;
}
int Inversion(char * s)
{
 memset(c,0,sizeof(c));
 P p[60];
 int cnt[60]={0};
 int i;
 for(i=0;i<n;i++)  
 {
  p[i+1].first=s[i];
  p[i+1].second=i+1;
 }
 sort(p+1,p+1+n,cmp);
 int id=1;
 cnt[p[1].second]=id;
 for(i=2;i<=n;i++)   //离散化
 {
  if(p[i].first==p[i-1].first)
   cnt[p[i].second]=id;
  else
   cnt[p[i].second]=++id;
 }
 int sum=0;
 for(i=1;i<=n;i++)  //插入
 {
  add(cnt[i],1);  //在离散化后的cnt[i]位置插入1
  sum+=i-Sum(cnt[i]);
 }
 return sum;
}

class cmp1
{
public:
 bool operator()(P1 &a,P1 &b)//按逆序对数从小到大输出，如数量一样，按原始下标输出。
 {
  if(a.first!=b.first)
  return a.first>b.first; //first是逆序对数,second是输入的第几个字符串
  return a.second>b.second;
 }
};
int main()
{
// freopen("C:\\1.txt","r",stdin);
 cin>>n>>m;
 int i;
 priority_queue<P1,vector<P1>,cmp1>q; //最终输出的队列
 for(i=1;i<=m;i++)
 {
  scanf("%s",s[i]);
  int num=Inversion(s[i]);  //树状数组求逆序对数量
  q.push(P1(num,i));   //入队列等待输出
 }
 while(!q.empty())
 {
  P1 x=q.top();
  printf("%s\n",s[x.second]);
  q.pop();
 }
}