735. Asteroid Collision

问题描述：

We are given an array asteroids of integers representing asteroids in a row.

For each asteroid, the absolute value represents its size, and the sign represents its direction (positive meaning right, negative meaning left). Each asteroid moves at the same speed.

Find out the state of the asteroids after all collisions. If two asteroids meet, the smaller one will explode. If both are the same size, both will explode. Two asteroids moving in the same direction will never meet.

Example 1:

Input: 
asteroids = [5, 10, -5]
Output: [5, 10]
Explanation: 
The 10 and -5 collide resulting in 10.  The 5 and 10 never collide.

 

Example 2:

Input: 
asteroids = [8, -8]
Output: []
Explanation: 
The 8 and -8 collide exploding each other.

 

Example 3:

Input: 
asteroids = [10, 2, -5]
Output: [10]
Explanation: 
The 2 and -5 collide resulting in -5.  The 10 and -5 collide resulting in 10.

 

Example 4:

Input: 
asteroids = [-2, -1, 1, 2]
Output: [-2, -1, 1, 2]
Explanation: 
The -2 and -1 are moving left, while the 1 and 2 are moving right.
Asteroids moving the same direction never meet, so no asteroids will meet each other.

 

Note:

• The length of asteroids will be at most 10000.
• Each asteroid will be a non-zero integer in the range [-1000, 1000]..

 

解题思路：

我曾经在一个面试中碰到过这道题，当时想的有点复杂，但是也是解出来了。

现在看的话，可以根据方向来解：

若当前小行星cur向左，则检查左边的第一个活着的小行星adj：

　　1. 若adj也向左，则表明当前小行星cur不可能与左边的小行星们发生碰撞

　　2.若adj向右则检查谁会活下来，若adj活下来，推出循环；若cur活下来，继续循环

若当前小行星cur向右，则会检查右边第一个活着的小行星adj：

　　1. 若adj也向右，则表明当前小行星cur不可能与右边的小行星们发生碰撞

　　2.若adj向左则检查谁会活下来，若adj活下来，推出循环；若cur活下来，继续循环

 

当当前小行星死掉的时候，就需要推出循环。

这样最坏的时间复杂度为O(n²)

代码：

class Solution {
public:
    vector<int> asteroidCollision(vector<int>& asteroids) {
        if(asteroids.size() < 2) return asteroids;
        vector<int> ret;
        int n = asteroids.size();
        vector<bool> status(n, true);
        int cur = 0;
        for(int cur = 0; cur < n; cur++){
            if(!status[cur]) continue;
            if(asteroids[cur] < 0){
                //left
                int adj = cur-1;
                while(adj > -1){
                    if(status[adj]){
                        if(asteroids[adj] < 0) break;
                        if(asteroids[adj] > abs(asteroids[cur])){
                            status[cur] = false;
                            break;
                        }else if(asteroids[adj] < abs(asteroids[cur])){
                            status[adj] = false;
                        }else{
                            status[cur] = false;
                            status[adj] = false;
                            break;
                        }
                    }
                    adj--;
                }
            }else{
                //right
                int adj = cur + 1;
                while(adj < n ){
                    if(status[adj]){
                        if(asteroids[adj] > 0) break;
                        if(abs(asteroids[adj]) > asteroids[cur]){
                            status[cur] = false;
                            break;
                        }else if(abs(asteroids[adj]) < asteroids[cur]){
                            status[adj] = false;
                        }else{
                            status[cur] = false;
                            status[adj] = false;
                            break;
                        }
                    }
                    adj++;
                }
            }
        }
        for(int i = 0; i < n; i++){
            if(status[i]) ret.push_back(asteroids[i]);
        }
        return ret;
    }
};

最快的解法：

这里用一个数组来盛放活下来的小行星。

用当前小行星与最后一个活下来的小行星做比较，之前的小行星死掉则可以直接pop_back()

class Solution {
public:
    vector<int> asteroidCollision(vector<int>&A) {

        vector<int> s;
        for (auto a : A) {
            if (a > 0) s.push_back(a);
            else {
                int x = -a;
                while (s.size() && s.back() > 0 && s.back() < x) s.pop_back();
                if (s.empty() || s.back() < 0) s.push_back(a);
                else if (s.back() == x) s.pop_back();
            }
        }
        return s;
    }
};