Codility - Lesson 8: Flags

https://codility.com/programmers/lessons/8

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.

https://codility.com/media/train/solution-flags.pdf.

First of all, instead of retaining the indices of the peeks as above solutions, we create an array that holds the next peek on the right side of the array at each index.

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

    //for N < 3, there can be no peak.

    if (N < 3){

        return 0;

    }

    

    int* next_peek = (int*)alloca(sizeof(int) * N);

    

    //-1 stands for there is no more peek.

    next_peek[N - 1] = -1;

    

    //scan backwards

    int peek_cnt = 0;

    int i;

    for (i = N - 2; i > 0; i--){

        if (A[i - 1] < A[i] && A[i] > A[i + 1]){

            next_peek[i] = i;

            peek_cnt++;

        }

        else {

            next_peek[i] = next_peek[i + 1];

        }

    }

    next_peek[0] = next_peek[1];

        

    //now let's check 

    int max_flags = 0;

    for (i = 1; (i - 1) * i + 2 < N && i <= peek_cnt; i++){

        int pos = 0;

        int num = 0;

        while (pos < N && num < i){

            pos = next_peek[pos];

            //we don't have any more peek. exit this loop.

            if (pos == -1){

                break;

            }

            //we can set a flag at the pos. 

            //increment pos to seek the next peek

            num++;

            pos += i;

        }

    

        max_flags = max_flags < num ? num : max_flags;

    }

    

    return max_flags;

}

http://codesays.com/2014/solution-to-boron2013-flags-by-codility/

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

def solution(A):     from math import sqrt     A_len = len(A)     next_peak = [-1] * A_len     peaks_count = 0     first_peak = -1     # Generate the information, where the next peak is.     for index in xrange(A_len-2, 0, -1):         if A[index] > A[index+1] and A[index] > A[index-1]:             next_peak[index] = index             peaks_count += 1             first_peak = index         else:             next_peak[index] = next_peak[index+1]     if peaks_count < 2:         # There is no peak or only one.         return peaks_count     max_flags = 1     max_min_distance = int(sqrt(A_len))     for min_distance in xrange(max_min_distance + 1, 1, -1):         # Try for every possible distance.         flags_used = 1         flags_have = min_distance-1 # Use one flag at the first peak         pos = first_peak         while flags_have > 0:             if pos + min_distance >= A_len-1:                 # Reach or beyond the end of the array                 break             pos = next_peak[pos+min_distance]             if pos == -1:                 # No peak available afterward                 break             flags_used += 1             flags_have -= 1         max_flags = max(max_flags, flags_used)     return max_flags

http://codility-lessons.blogspot.com/2015/03/lesson-8-flags.html

Then, this leeds to the conclusion; as long as we can always start from the 1st peek and then pick up the nearest peek that satisfies the given constraint, it is enough to check if k flags can be set or not. 

While this code gives the 100% correctness score, the performance score is obviously bad.
int check(int k, int* peeks, int peek_cnt)

{

    //if we have to put only one flag, it is always possible..

    if (k == 1){

        return 1;

    }

    

    //the first flag can be set.

    int prev = peeks[0];

    int rest = k - 1;

    

    //check if this is true

    int i = 1;

    while (i < peek_cnt){

        int curr = peeks[i];

        if (curr - prev >= k){

            prev = curr;

            rest--;

            //we consumed the all the flag.

            if (rest == 0){

                return 1;

            }

        }

        i++;

    }

    

    return 0;

}

int solution(int A[], int N) 

{

    //the max number of the peeks is less than N / 2.

    int* peeks = (int*)alloca(sizeof(int) * (N / 2) );

    int peek_cnt = 0;

    

    //let's find the peeks first.

    int i;

    for (i = 1; i < N - 1; i++){

        if (A[i - 1] < A[i] && A[i] > A[i + 1]){

            peeks[peek_cnt] = i;

            peek_cnt++;

        }

    }

    

    //we don't have to check when there is no peek found.

    if (peek_cnt == 0){

        return 0;

    }

    

    //check how many flags can be set...

    int max_flags = 0;

    for (int i = peek_cnt; i > 0; i--){

        int ret = check(i, peeks, peek_cnt);

        if (ret != 0){

            max_flags = i;

            break;

        }

    }

    

    return max_flags;

}

https://github.com/nkatre/Codility/blob/master/Hard/Peak%20and%20Flags%20(boron2013)

find the peak array first
use binary to find the flag number, start = 1, end = array.size(). make flag = (start + end) / 2;
time O( nlgn).
tips: pay attention to sf and ef , used flag
    public int solution(int[] A) {
   ArrayList<Integer> array = new ArrayList<Integer>();
   for (int i = 1; i < A.length - 1; i++) {
    if (A[i - 1] < A[i] && A[i + 1] < A[i]) {
     array.add(i);
    }
   }
   if (array.size() == 1 || array.size() == 0) {
    return array.size();
   }
   int sf = 1;
   int ef = array.size();
   int result = 1;
   while (sf <= ef) {
    int flag = (sf + ef) / 2;
    boolean suc = false;
    int used = 0;
    int mark = array.get(0);
    for (int i = 0; i < array.size(); i++) {
     if (array.get(i) >= mark) {
      used++;
      mark = array.get(i) + flag;
      if (used == flag) {
       suc = true;
       break;
      }
     }
    }
    if (suc) {
     result = flag;
     sf = flag + 1;
    } else {
     ef = flag - 1;
    }
   }
   return result;
  }
http://blog.csdn.net/liushuying668/article/details/38272157
思路：1.首先建一个N元容器B，用以存储peak的信息。（若第i个元素是peak，则B[i]=1，否则为0）

   2.建立一个N元容器C，用以存储第i个元素的下一个peak元素下标。若第i个元素本身就是peak，则C[i]=i，否则C[i]=C[i+1]，令C[N-1]=-1

           3.由题设可知若有k个flag，则每相邻两个flag之间距离要大于等于k，由于首尾元素均不为peak，故k(k-1)+2<=N，可得k<=floor(sqrt(N))+1

   故外层循环：i从1到sqrt(N)+1；令pos表示当前元素下标，num表示内层迭代次数也即flag数，内层循环：pos<N，num<i，先找到一个    peak，即令pos=C[pos]，若C[pos]不等于-1，说明当前位置之后仍有peak存在，故pos+=i（flag间隔为i），num++，C[pos]等于-1说明当    前位置之后（含当前位置）无peak存在，跳出内层循环。

   用res记录多次迭代中num的最大值，则res就是最大可能的flag数

Notice that for every index i we cannot take more than i flags and set more than N i + 1 flags. We can take a maximum of O( √ N) flags, and the position of each of them can be found in a constant time, so the total number of operations does not exceed O(N + 1+ 2+. . .+ √ N) = O(N + √ N ^2 ) = O(N).
http://codesays.com/2014/solution-to-boron2013-flags-by-codility/

def solution(A):

    from math import sqrt

    A_len = len(A)

    next_peak = [-1] * A_len

    peaks_count = 0

    first_peak = -1

    # Generate the information, where the next peak is.

    for index in xrange(A_len-2, 0, -1):

        if A[index] > A[index+1] and A[index] > A[index-1]:

            next_peak[index] = index

            peaks_count += 1

            first_peak = index

        else:

            next_peak[index] = next_peak[index+1]

    if peaks_count < 2:

        # There is no peak or only one.

        return peaks_count

    max_flags = 1

    max_min_distance = int(sqrt(A_len))

    for min_distance in xrange(max_min_distance + 1, 1, -1):

        # Try for every possible distance.

        flags_used = 1

        flags_have = min_distance-1 # Use one flag at the first peak

        pos = first_peak

        while flags_have > 0:

            if pos + min_distance >= A_len-1:

                # Reach or beyond the end of the array

                break

            pos = next_peak[pos+min_distance]

            if pos == -1:

                # No peak available afterward

                break

            flags_used += 1

            flags_have -= 1

        max_flags = max(max_flags, flags_used)

    return max_flags