31-InSange

[InSange]

🔗 문제 링크

Valid Arrangement of Pairs

✔️ 소요된 시간

3시간

✨ 수도 코드

개요

그래프 문제로 간선에 대한 정보들을 2차원 배열 형태로 주어진다.
Input: pairs = [[5,1],[4,5],[11,9],[9,4]]

첫 번째 노드는 출발지고 두 번째 요소로 주어지는 노드는 도착지이다.
5 -> 1
4 -> 5
11 -> 9
9 -> 4

어떤 노드에서 출발을 하였을 때 해당 간선들을 모두 이용하여 유효한 그래프를 만들어야 한다.
즉, 주어진 pairs의 간선들을 모두 사용해서 각 노드들을 통과하는 연속된 배열을 표현해야함.

중요한 점은 주어지는 간선은 무조건 유효하다는 점.

이렇게 중간 노드에서 다른 노드로 간 후 다른 간선들을 이용할 수 없는 경우가 없다.

위의 예제로 이런 식으로 모든 간선들을 활용해서 유효한 그래프를 만들어야 한다.

접근 방식

무조건 유효하다는 점에서 모든 간선들을 다 이용할 때 두 가지의 경우를 생각할 수 있다.

1. 위의 그림 처럼 모든 노드들이 동일하게 하나의 간선으로 이어져 있거나 N개의 간선으로 이어져 있을 경우.
2. 어떤 특정한 노드에서 진출 차수(OutDegree)가 진입 차수(InDegree)보다 1 많을 경우. 이 경우 해당 노드에서 출발을 해주어야 돌고 돌아 N번의 진입 차수 만큼 돌았을 때 나머지 한 경로를 따라 갈 수 있기 때문이다.

Constraints:

1 <= pairs.length <= 10^5
pairs[i].length == 2
0 <= starti, endi <= 10^9
starti != endi
No two pairs are exactly the same.
There exists a valid arrangement of pairs.

주어진 제약 조건에서 요소의 크기가 0에서 10^9이기에 일반적인 배열로 각 노드에 진출, 진입 차수를 관리하기는 어렵다고 생각했다.
unordered_map에서 각 노드의 진출 노드들을 관리해주는 식으로 결정.
그럼 각 노드들에서 주어진 간선 정보를 바탕으로 진출할 경우. 진출할 노드들에 대한 정보들을 관리해주어야 하는데 visit 배열로 관리해주기에는 너무 크기에 방문한 노드들을 직접 제거해주는 방식으로 deque를 활용하기로 했다.
그리고 출발지를 정하기위해 각 진입, 진출 차수를 저장해줄 unordred_map을 추가.

unordered_map<int, deque<int>> nodes; // n개의 노드들과 간선으로 연결된 노드들의 정보를 포함.
unordered_map<int, int> inDegree; // n개의 노드들로부터 진입 차수
unordered_map<int, int> outDegree; // n개의 노드들로부터 진출차수

노드들에 대한 정보를 추가해주었으면 그래프 탐색을 해주면 된다.
우리는 간선을 통해 순차적으로 노드들을 방문해주면 된다.
DFS를 활용할 것이라는 계획까지는 좋았지만 풀이가 쉽게 떠오르지 않아서 다른 글을 참고.

출발 노드부터 시작하여 노드와 연결된 노드들을 하나씩 제거 해준 뒤 다음 노드를 탐색한다.
그럼 결국 비워져있는 노드를 발견하게 될 것이고.
해당 비워져있는 노드는 최종 노드가 될 것이다. (가장 마지막에 방문한 노드이기에)
그렇게 재귀를 통해 돌아오다보면 각각의 노드들이 비워져있을 것이고 비워져있는 노드들을 result 배열에 저장한다.

여기서 우리는 가장 마지막에 방문할 노드부터 추가를 하였기에 result 배열에 마지막으로 push되는 노드는 출발지점이 될 것이다.

각 노드를 두 개씩 묶어 거꾸로 ans 2차원 배열에 넣어주면 끝.

중간에
pairs = [[1,2],[1,3],[2,1]]
위와 같이 주어졌을 때
1->3을 먼저 방문했을 때 어떻게 되는거지 의문이 들었었는데
3을 먼저 방문하든 2를 먼저 방문하든 간에 nodes[3]의 값은 비워져있기에 무조건 result에 첫번째로 방문하게 될 것 이다.
2의 경우 다시 1 노드로 돌아오기 때문이다.
result = [3, 1, 2, 1] 로 될 것이다.

소스 코드

class Solution {
public:
    unordered_map<int, deque<int>> nodes;
    unordered_map<int, int> inDegree;
    unordered_map<int, int> outDegree;
    
    vector<int> result;
    
    void DFS(int index)
    {
        while(!nodes[index].empty())
        {
            int nextNode = nodes[index].front();
            nodes[index].pop_front();
            DFS(nextNode);
        }
        result.push_back(index); // 결국. 모든 노드들을 방문했다면. 즉 비워져있는 노드에 방문했다면 도착지 경로가 거꾸로 이어지게 됨.
    }
    
    vector<vector<int>> validArrangement(vector<vector<int>>& pairs) {
        for(const vector<int>& pair : pairs)
        {
            int depart = pair[0];
            int dest = pair[1];
            
            nodes[depart].push_back(dest);
            inDegree[dest]++;
            outDegree[depart]++;
        }
        
        int startNode = -1;
        
        for(const auto& degree : outDegree)
        {
            int curNode = degree.first;
            if(outDegree[curNode] == inDegree[curNode] + 1) // 현재 노드에서 출발지가 현재 노드로 들어오는 진입의 개수 + 1일 경우. 이 노드는 돌고 돌아 다시 해당 노드를 거쳐야 모든 노드를 방문할 수 있음.
            {
                startNode = curNode;
                break;
            }
        }
        
        if(startNode == -1) // 출발 노드를 발견 못했다면 모든 노드는 각각 하나의 진입, 진출지를 동일하게 가지는 것
        {
            startNode = pairs[0][0];
        }
        
        DFS(startNode);
        
        vector<vector<int>> ans;
        for(int i = result.size() - 1; i > 0; i--)
        {
            ans.push_back({result[i], result[i-1]}); // 출발지와 도착지를 거꾸로 변경
        }
        
        return ans;
    }
};

📚 새롭게 알게된 내용

항상 예외사항을 생각하고 풀다보니 간단한 문제였음에도 조금 오래걸렸던 것 같다.