GenomicRangeQuery /codility/ preFix sums

首先上题目：

A DNA sequence can be represented as a string consisting of the letters A, C, G and T, which correspond to the types of successive nucleotides in the sequence. Each nucleotide has an impact factor, which is an integer. Nucleotides of types A, C, G and T have impact factors of 1, 2, 3 and 4, respectively. You are going to answer several queries of the form: What is the minimal impact factor of nucleotides contained in a particular part of the given DNA sequence?

The DNA sequence is given as a non-empty string S =S[0]S[1]...S[N-1] consisting of N characters. There are M queries, which are given in non-empty arrays P and Q, each consisting of M integers. The K-th query (0 ≤ K < M) requires you to find the minimal impact factor of nucleotides contained in the DNA sequence between positions P[K] and Q[K] (inclusive).

For example, consider string S = CAGCCTA and arrays P, Q such that:

    P[0] = 2    Q[0] = 4
    P[1] = 5    Q[1] = 5
    P[2] = 0    Q[2] = 6

The answers to these M = 3 queries are as follows:

• The part of the DNA between positions 2 and 4 contains nucleotides G and C (twice), whose impact factors are 3 and 2 respectively, so the answer is 2.
• The part between positions 5 and 5 contains a single nucleotide T, whose impact factor is 4, so the answer is 4.
• The part between positions 0 and 6 (the whole string) contains all nucleotides, in particular nucleotide Awhose impact factor is 1, so the answer is 1.

Assume that the following declarations are given:

struct Results {
  int * A;
  int M;
};

Write a function:

struct Results solution(char *S, int P[], int Q[], int M);

that, given a non-empty zero-indexed string S consisting of N characters and two non-empty zero-indexed arrays P and Q consisting of M integers, returns an array consisting of M integers specifying the consecutive answers to all queries.

The sequence should be returned as:

• a Results structure (in C), or
• a vector of integers (in C++), or
• a Results record (in Pascal), or
• an array of integers (in any other programming language).

For example, given the string S = CAGCCTA and arrays P, Q such that:

    P[0] = 2    Q[0] = 4
    P[1] = 5    Q[1] = 5
    P[2] = 0    Q[2] = 6

the function should return the values [2, 4, 1], as explained above.

Assume that:

• N is an integer within the range [1..100,000];
• M is an integer within the range [1..50,000];
• each element of arrays P, Q is an integer within the range [0..N − 1];
• P[K] ≤ Q[K], where 0 ≤ K < M;
• string S consists only of upper-case English letters A, C, G, T.

Complexity:

• expected worst-case time complexity is O(N+M);
• expected worst-case space complexity is O(N), beyond input storage (not counting the storage required for input arguments).

Elements of input arrays can be modified.

Copyright 2009–2015 by Codility Limited. All Rights Reserved. Unauthorized copying, publication or disclosure prohibited.

2.题目分析

这个题目看上去蛮简单，就是在一个序列中的任意一段slice中，找出出现过的最小值。

不过要求时间复杂度为O（N），便费了一些周折。

1. 首先是将str转换为int 数组，为后面的处理加速，免去每次都要遍历。

先用strlen函数获得str的长度，再通过temp 指针遍历这个str，将A转为1，C转为2，G转为3，T转为4。

获得了这个数组之后就比较好操作了~

2. 获得任何段的最小值看似很简单，遍历就可以了，不过这样时间复杂度就会变为O（N*M）。

如何减少时间复杂度呢？答案是用空间换时间。

通过prefix的想法，我先统计出了在每一个位置之前包括这个位置，1所出现的次数，2所出现的次数，3所出现的次数，4所出现的次数。

分别存入数组A,B,C,D；

每次查询时，只要判断A[end of slice]-A[Begin of Slice]是否大于零，即可判断是否1出现过。这一步的时间复杂度就从O(N)降为了O（1）；

注意，需要检查str[begin of slice]是否为1,因为当这个位置是1时，是不会表现出来的。

其余查询依然，通过增加空间复杂度，降低了时间的复杂度。

找出最小的出现值即可。

3.代码如下:

 // you can write to stdout for debugging purposes, e.g.
 // printf("this is a debug message\n");

 struct Results solution(char *S, int P[], int Q[], int M) {
     struct Results result;
     // write your code in C99
     int len = strlen(S);
     // printf("len is %d",len);

     int arr[len];
     int i;
     char* temp = S;
     for(i=;i<len;i++)
     {
         if(*temp=='C')
         {
             arr[i]=;
         }
         else if(*temp=='A')
         {
             arr[i]=;
         }
         else if(*temp=='G')
         {
             arr[i]=;
         }
         else if(*temp=='T')
         {
             arr[i]=;
         }
         temp++;
     }

     int A[len];
     int B[len];
     int C[len];
     int D[len];

         if(arr[]==)
         {
             A[]=;
             B[]=;
             C[]=;
             D[]=;
         }

         if(arr[]==)
         {
             A[]=;
             B[]=;
             C[]=;
             D[]=;
         }

         if(arr[]==)
         {
             A[]=;
             B[]=;
             C[]=;
             D[]=;
         }

         if(arr[]==)
         {
             A[]=;
             B[]=;
             C[]=;
             D[]=;
         }

     // printf("%d %d %d %d \n",A[0],B[0],C[0],D[0]);
     for(i=;i<len;i++)
     {
         // printf("%d\n",arr[i]);
         if(arr[i]==)
         {
             A[i]=A[i-]+;
             B[i]=B[i-];
             C[i]=C[i-];
             D[i]=D[i-];
         }

         if(arr[i]==)
         {
             A[i]=A[i-];
             B[i]=B[i-]+;
             C[i]=C[i-];
             D[i]=D[i-];
         }

         if(arr[i]==)
         {
             A[i]=A[i-];
             B[i]=B[i-];
             C[i]=C[i-]+;
             D[i]=D[i-];
         }

         if(arr[i]==)
         {
             A[i]=A[i-];
             B[i]=B[i-];
             C[i]=C[i-];
             D[i]=D[i-]+;
         }

         // printf("%d %d %d %d \n",A[i],B[i],C[i],D[i]);
     }
     result.A = malloc(sizeof(int)*M);
     result.M = M;

     for(i=;i<M;i++)
     {
         int tempP = P[i];
         int tempQ = Q[i];
         if(arr[tempP]== || (A[tempQ]-A[tempP]) > )
         {
             result.A[i]=;
         }
         else if(arr[tempP]== || (B[tempQ]-B[tempP]) > )
         {
             result.A[i]=;
         }
         else if(arr[tempP]== || (C[tempQ]-C[tempP]) > )
         {
             result.A[i]=;
         }
         else
         {
             result.A[i]=;
         }
     }

     return result;
 }