20-InSange

[InSange]

🔗 문제 링크

Robot Collisions

✔️ 소요된 시간

5시간

✨ 수도 코드

풀이 방법

position과 healths 그리고 directions가 준다. 각 배열의 인덱스는 하나의 로봇의 위치, 체력, 방향을 가리킨다.

로봇은 directions에 주어진 방향으로 가게되며 부딫히는 경우. 체력이 적은 로봇은 healths가 0이 되고 체력이 많은 로봇은 1 깎인다.
같을 경우에는 둘다 healths가 0이 된다.

첫번째 풀이방식

왼쪽, 오른쪽으로 이동하는 로봇들을 우선순위 큐에 넣어준다.
오른쪽으로 이동하는 로봇은 내림차순으로,
왼쪽으로 이동하는 로봇은 오름차순으로 정렬해준다.
R = { 5, 4, 3, 2, 1 }
L = { 6, 7, 9, 10}
과 같은 형식.

1. R 로봇의 인덱스가 L 로봇의 인덱스보다 크면 스택에다가 쌓아둔다. ( R 로봇의 인덱스가 클 경우 L 로봇과 부딫힐 경우가 없음. )
2. 만약 R 로봇 우선순위큐가 비어진다면? L 로봇보다 모두 인덱스가 크기 때문에 서로 부딫힐 일이 없어진다!
3. 그게 아닐 경우. R 로봇의 인덱스가 L 로봇의 인덱스보다 작아서 서로 부딫히는 경우를 계산해준다.
4. 체력이 높은 쪽은 -1, 낮은 쪽은 0으로 healths배열의 값을 변경해준다.
5. 체력이 같을 경우 둘 다 0으로 변경
6. 3 ~ 5가 끝나면 스택에 넣어져있는 R 로봇들의 인덱스를 다시 집어 넣어준다.
7. healths의 값이 0이 아닌 값들을 ans 배열에다가 집어넣어준다.

class Solution {
public:
    vector<int> survivedRobotsHealths(vector<int>& positions, vector<int>& healths, string directions) {
        vector<int> ans;
        
        priority_queue<pair<int, int>> RIndexArr;
        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> LIndexArr;
        
        for(int i = 0; i < directions.length(); i++)
        {
            if(directions[i] == 'R') RIndexArr.push({positions[i], i});
            else LIndexArr.push({positions[i], i});
        }
        
        stack<pair<int, int>> temp;
        while(!RIndexArr.empty() && !LIndexArr.empty())
        {
            cout << RIndexArr.top().first << ", " << LIndexArr.top().first << "\n";
            
            while(!RIndexArr.empty() && RIndexArr.top().first > LIndexArr.top().first)
            {
                temp.push(RIndexArr.top());
                RIndexArr.pop();
            }
            // 비어있을 때 -> 비교할게 없으면? L통과
            if(RIndexArr.empty())
            {
                LIndexArr.pop();
            }
            else
            {
                int LIndex = LIndexArr.top().second;
                int RIndex = RIndexArr.top().second;

                // R의 HP값이 크다면?
                if(healths[LIndex] < healths[RIndex])
                {
                    healths[RIndex]--;
                    healths[LIndex] = 0;
                    LIndexArr.pop();
                }
                else if(healths[LIndex] == healths[RIndex])
                {   // 같다면?
                    healths[RIndex] = 0;
                    healths[LIndex] = 0;
                    LIndexArr.pop();
                    RIndexArr.pop();
                }
                else
                {   // L이 크다면?
                    healths[RIndex] = 0;
                    healths[LIndex]--;
                    RIndexArr.pop();
                }
            }
            
            // R 다시 집어넣기.
            while(!temp.empty())
            {
                RIndexArr.push(temp.top());
                temp.pop();
            }
        }
        
        for(int val : healths)
        {
            if(val) ans.push_back(val);
        }
        
        return ans;
    }
};

결과는 무수히 많은 값이 존재할 경우. 다시 집어넣고 계산하는 것은 결국 시간 초과를 초래한다.

두번째 풀이 방법

positions와 인덱스를 함께 묶어서 positions을 기준으로 우선순위 큐 배열을 정렬해준다.
R은 스택에다가 집어넣고 L을 만났을 경우에 스택에서 R들을 차례대로 꺼내 비교한다.

class Solution {
public:
    vector<int> survivedRobotsHealths(vector<int>& positions, vector<int>& healths, string directions) {
        vector<int> ans;

        priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> IndexArr;
        stack<pair<int, int>> Rst;
        
        for(int i = 0; i < positions.size(); i++)
        {
            IndexArr.push({positions[i], i});
        }
        
        while(!IndexArr.empty())
        {
            int val = IndexArr.top().first;
            int index = IndexArr.top().second;
            
            cout << val << ", " << index << "\n";
            IndexArr.pop();
            
            if(directions[index] == 'L')
            {
                while(!Rst.empty())
                {
                    int stVal = Rst.top().first;
                    int stIndex = Rst.top().second;
                    
                    if(healths[stIndex] == healths[index])
                    {
                        healths[stIndex] = 0;
                        healths[index] = 0;
                        Rst.pop();
                        break;
                    }
                    else if(healths[stIndex] > healths[index])
                    {
                        healths[index] = 0;
                        healths[stIndex]--;
                        break;
                    }
                    else
                    {
                        healths[stIndex] = 0;
                        healths[index]--;
                        Rst.pop();
                    }
                }
            }
            else
            {
                Rst.push({val, index});
            }
        }
        
        for(int health : healths)
        {
            if(health) ans.push_back(health);
        }
        
        return ans;
    }
};

📚 새롭게 알게된 내용

[yuyu0830]

재밌는 문제였네요! 양 쪽을 전부 스택에 넣지 않고 한 쪽만 스택에 넣고 한 쪽은 바로바로 비교하는 부분이랑 어차피 정답도 시작에 주어진 순서로 정렬되어있어야하니까 포지션 별로 정리하되 결국 healths vector에서 값 처리하는 부분까지 고민 많이한 것 같은 흔적이 있네요 ㅎㅎ

우선순위 큐를 사용해서 정렬 순서가 어떻게 정리되는가 조금 어려웠는데 pair<int, int> 를 이용해서 포인터? 처럼 접근해서 원본 순서는 건들지 않고 사용하는 것 까지 재밌는 문제에 재밌는 코드였습니다!

[seongwon030]

오른쪽으로 가는 로봇들만 스택에 집어넣고 하나씩 빼면서 왼쪽으로 가는 로봇의 인덱스를 비교해 주는게 첫번째 풀이 방법보다 확실히 효율적으로 보이네요. 코드 잘 봤습니다!