【题解】【数组】【堆栈】【Codility】Fish

N voracious fish are moving along a river. Calculate how many fish are alive. 

You are given two non-empty zero-indexed arrays A and B consisting of N integers. Arrays A and B represent N voracious fish in a river, ordered downstream along the flow of the river. The fish are numbered from 0 to N − 1, fish number P is represented by A[P] and B[P], and if P < Q then fish P is initially upstream of fish Q. Initially, each fish has a unique position.

Array A contains the sizes of the fish. All its elements are unique. Array B contains the directions of the fish. It contains only 0s and/or 1s, where:

• 0 represents a fish flowing upstream,
• 1 represents a fish flowing downstream.

If two fish move in opposite directions and there are no other (living) fish between them, they will eventually meet each other. Then only one fish can stay alive − the larger fish eats the smaller one. More precisely, we say that two fish P and Q meet each other when P < Q, B[P] = 1 and B[Q] = 0, and there are no living fish between them. After they meet:

• If A[P] > A[Q] then P eats Q, and P will still be flowing downstream,
• If A[Q] > A[P] then Q eats P, and Q will still be flowing upstream.

We assume that all the fish are flowing at the same speed. That is, fish moving in the same direction never meet. The goal is to calculate the number of fish that will stay alive.

For example, consider arrays A and B such that:

 

 A[0] = 4 B[0] = 0 A[1] = 3 B[1] = 1 A[2] = 2 B[2] = 0 A[3] = 1 B[3] = 0 A[4] = 5 B[4] = 0

 

Initially all the fish are alive and all except fish number 1 are moving upstream. Fish number 1 meets fish number 2 and eats it, then it meets fish number 3 and eats it too. Finally, it meets fish number 4 and is eaten by it. The remaining two fish, numbers 0 and 4, never meet and therefore stay alive.

Write a function:

int solution(vector<int> &A, vector<int> &B);

that, given two non-empty zero-indexed arrays A and B consisting of N integers, returns the number of fish that will stay alive.

For example, given the arrays shown above, the function should return 2, as explained above.

Assume that:

• N is an integer within the range [1..100,000];
• each element of array A is an integer within the range [0..1,000,000,000];
• each element of array B is an integer that can have one of the following values: 0, 1;
• the elements of A are all distinct.

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.

思路：

1用一个stack来存flowing downstream的鱼，新来的鱼：

（1） 如果是flowing downstream，直接压栈

（2） 如果是flowing upsteam，跟栈顶元素相遇，要么使得栈顶pop几次，要么它被吃掉over

2 如果此时stack为空的话，放走flowing upstream的鱼并计数（注意这里越过大循环私自进行i++，需要再加i < B.size()控制），压入第一个flowing downstream的鱼。

3 最后别忘了写返回值，放走flowing upstream鱼的数量nalive，加上stack里flowing downstream的数量

 

#include <stack>
int solution(vector<int> &A, vector<int> &B) {
    if(A.size() < 2) return A.size();

    int nalive = 0;//upstream存活的鱼
    int i = 0;
    stack<int> safe;//downstream暂时存活的鱼
    while(i < B.size()){
        if(B[i] == 0){
            while(!safe.empty() && A[i] > safe.top()){//栈不为空的条件很重要
                safe.pop();
            }
        }else{
            safe.push(A[i]);//压入downstream的鱼
        }
        if(safe.empty()){//pop操作也可能导致栈空，因此这一步放在后面
            while(B[i] == 0 && i < B.size()){//数组不越界的条件很重要
                nalive++;
                i++;
            }
            if(i == B.size())
                return nalive;
            safe.push(A[i]);//压入downstream的鱼
        }
        i++;//处理下一条鱼
    }
    return nalive + safe.size();
}