codility flags solution

How to solve this HARD issue

1. Problem:

    

A non-empty zero-indexed array A consisting of N integers is given.

A peak is an array element which is larger than its neighbours. More precisely, it is an index P such that 0 < P < N − 1 and A[P − 1] < A[P] > A[P + 1].

For example, the following array A:

 

    A[0] = 1
    A[1] = 5
    A[2] = 3
    A[3] = 4
    A[4] = 3
    A[5] = 4
    A[6] = 1
    A[7] = 2
    A[8] = 3
    A[9] = 4
    A[10] = 6
    A[11] = 2

has exactly four peaks: elements 1, 3, 5 and 10.

You are going on a trip to a range of mountains whose relative heights are represented by array A, as shown in a figure below. You have to choose how many flags you should take with you. The goal is to set the maximum number of flags on the peaks, according to certain rules.

Flags can only be set on peaks. What's more, if you take K flags, then the distance between any two flags should be greater than or equal to K. The distance between indices P and Q is the absolute value |P − Q|.

For example, given the mountain range represented by array A, above, with N = 12, if you take:

• two flags, you can set them on peaks 1 and 5;
• three flags, you can set them on peaks 1, 5 and 10;
• four flags, you can set only three flags, on peaks 1, 5 and 10.

You can therefore set a maximum of three flags in this case.

Write a function:

int solution(int A[], int N);

that, given a non-empty zero-indexed array A of N integers, returns the maximum number of flags that can be set on the peaks of the array.

For example, the following array A:

 

    A[0] = 1
    A[1] = 5
    A[2] = 3
    A[3] = 4
    A[4] = 3
    A[5] = 4
    A[6] = 1
    A[7] = 2
    A[8] = 3
    A[9] = 4
    A[10] = 6
    A[11] = 2

the function should return 3, as explained above.

Assume that:

• N is an integer within the range [1..200,000];
• each element of array A is an integer within the range [0..1,000,000,000].

Complexity:

• expected worst-case time complexity is O(N);
• 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. Dig into this issue

    最初我认为这个问题非常复杂，需要牵涉到例如两点间最小距离啊，删除节点啊，对peak间的间距进行排序啊等等问题。

    不过在我看到时间复杂度要求为O（N）时，我觉得我还是想多了。

 

    通过数学我们可以得出，如果dis = 最后一个peak与第一个peak之间的距离，那么（k-1）*k<dis;

    于是我们就可以算出最大可能的k，而k与dis成√的关系，于是如果按照k的scale进行循环，那么我们就成功的减少了运算的时间复杂度。

 

    对于每一个k来说，最容易实现的方法肯定是从最左边的peak向右查找（因为如果从下一个开始，dis减少，k也会变少）。所以我们从最左边peak开始

   ，加上一个k，得到下一步，在这个点上寻找下一个peak，在依次向下搜索，直到找到的peak数等于k，完成，或者找不到下一个peak了（k过大），那么k-1，重复

   上层操作。

    

     这个操作在时间复杂度上还有一个技术障碍，就是在i位置寻找下一个peak需要O(N)级别的操作，我们如何将它变为O(1)级别的操作呢？

     用一个数组即可。

     我们首先遍历这个A，找出所有peak所在位置。然后定义一个数组nextpeak[],对于nextpeak[i]，代表从i位置往后(包括i位置)，所找到的第一个peak。

     通过O（N）的空间，我们就可以将找nextpeak的操作降为O(1)级别。

 

     这样通过我们上述的循环算法，总能找到k解。而且通过具体的验证，这个算法的时间复杂度是O（N）级别的。

 3.结果:

    

 

4.源代码为：

   

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

int solution(int A[], int N) {
    // write your code in C99
    int i = 1;
    // 每一个节点是否为peak 
    int isPeak[N];
    isPeak[0]=0;
    isPeak[N-1]=0;
    // peak个数 
    int count = 0;
    for(i=1;i<N-1;i++)
    {
        if(A[i]>A[i-1]&&A[i]>A[i+1])
        {
            isPeak[i]=1;
            count++;
        }    
        else
        {
            isPeak[i]=0;
        }
    }
    //如果peak为0，那么直接退出没商量 
    if(count == 0)
    {
        return 0;
    }
    //放入相应peak的位置。 
    int peak[count];
    
    int j=0;
    for(i=0;i<N;i++)
    {
        if(isPeak[i]==1)
        {
            peak[j]=i;
            j++;
        }
    }
    
    int dis = peak[count-1]-peak[0];
    
    //最大可能k 
    int maxk =1;
    while((maxk-1)*maxk<dis)
    {
        maxk++;
    }
    if((maxk-1)*maxk!=dis)
        maxk--;
    
    // 存入在i节点处下一个peak的位置，如果不存在下一个peak，为-1； 
    int nextpeak[N];
    
    j=count-1;
    int temp = -1;
    for(i=N-1;i>0;i--)
    {
        if(i>peak[j])
        {
            nextpeak[i]=temp;
        }
        else
        {
            temp = peak[j];
            j--;
            nextpeak[i]=temp;
        }
        // printf("%d ",nextpeak[i]);
    }
    
    
    //从 maxk，向下搜索，直到找出一个i(k)满足条件 
    int start = peak[0];
    int nodes = 1;
    for(i=maxk;i>0;i--)
    {
        while(nodes<i)
        {
            start = start+i;
            if(start > N-1)
            {
                break;
            }
            start = nextpeak[start];
            // printf("\n%d ",start);
            if(start == -1)
            {
                break;
            }
            else
            {
                nodes++;
            }
        }
        if(nodes == i)
        {
            return i;
        }
        else
        {
            nodes = 1;
            start = peak[0];
        }
    }
    
    
    return nodes;
}