Feat: #228, #248, #263, #279 solutions

Author: crumbs22

non-overlapping-intervals/crumbs22.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int eraseOverlapIntervals(vector<vector<int>>& intervals) {
+
+        // 끝나는 시간을 기준으로 정렬
+        sort(intervals.begin(), intervals.end(), [](const vector<int>& a, const vector<int>& b) { return a[1] < b[1]; });
+
+        int count = 1; // 첫 구간은 항상 선택
+        int end = intervals[0][1]; // 첫 구간의 끝
+
+        for (int i = 1; i < intervals.size(); i++) {
+            // 현재 구간이 겹치지 않으면 선택
+            if (intervals[i][0] >= end) {
+                count++;
+                end = intervals[i][1];
+            }
+        }
+
+        // 제거해야 하는 구간 수 = 전체 - 선택된 개수
+        return intervals.size() - count;
+    }
+};

number-of-connected-components-in-an-undirected-graph/crumbs22.cpp

@@ -0,0 +1,35 @@
+/*
+
+*/
+class Solution {
+public:
+    int countComponents(int n, vector<vector<int>> &edges) {
+        vector<vector<int>> graph(n);
+        vector<bool> visited(n, false);
+
+        for (auto edge : edges) {
+            int u = edge[0];
+            int v = edge[1];
+            graph[u].push_back(v);
+            graph[v].push_back(u);
+        }
+
+        int cnt = 0;
+        for (int i = 0; i < n; i++) {
+            if (!visited[i]) {
+                dfs(i, graph, visited);
+                cnt++;
+            }
+        }
+        return cnt;
+    }
+
+    void dfs(int node, vector<vector<int>> &graph, vector<bool> &visited) {
+        visited[node] = true;
+        for (int neighbor : graph[node]) {
+            if (!visited[neighbor]) {
+                dfs(neighbor, graph, visited);
+            }
+        }
+    }
+};

remove-nth-node-from-end-of-list/crumbs22.cpp

@@ -0,0 +1,35 @@
+/*
+    노드의 개수 cnt를 세고, n과 cnt를 통해 움직여야 할 위치 mv를 계산한다
+    mv가 0일 때 첫번째 노드를 제거하므로 head->next를 반환
+    mv가 0이 아닐 때는 head부터 mv만큼 이동한 후, 그 노드의 이전 노드(fh)와 다음 노드(tmp->next)를 연결한다
+    시간복잡도는 O(n)이고 추가적인 공간은 사용하지 않으므로 공간복잡도는 O(1)이다
+*/
+class Solution {
+public:
+    ListNode* removeNthFromEnd(ListNode* head, int n) {
+
+        int cnt = 0;
+        ListNode* end = head;
+        while (end) {
+            end = end->next;
+            cnt++;
+        }
+
+        int mv = cnt - n;
+        if (mv == 0)
+            return (head->next);
+        ListNode* fh = nullptr;
+        ListNode* tmp = head;
+        for (int i = 0; i < mv; i++) {
+            fh = tmp;
+            tmp = tmp->next;
+        }
+        if (!fh)
+            return (nullptr);
+        if (tmp->next)
+            fh->next = tmp->next;
+        else
+            fh->next = nullptr;
+        return (head);
+    }
+};

same-tree/crumbs22.cpp

@@ -0,0 +1,24 @@
+/*
+	전위순회 하면서 두 트리가 같은지 비교
+	재귀적으로 탐색하므로 
+	두 트리의 자식노드 중 하나라도 없다면 탈출한다
+	p->val == q->val 조건이 아닌 p->val != q->val 조건을 판단해야 
+	p->val과 q->val이 같을 때 그 다음 자식노드로 내려가는 return문으로 빠질 수 있다
+	(p->val == q->val 조건을 사용하면 true가 반환되므로 중간에 종결된다)
+	시간복잡도는 트리의 높이와 같다
+	다른 추가적 공간은 사용하지 않으므로 공간복잡도는 O(1)이다
+*/
+class Solution {
+public:
+    bool isSameTree(TreeNode* p, TreeNode* q) {
+
+        if (!p && !q)
+            return (true);
+        if (!p || !q)
+            return (false);
+        if (p->val != q->val)
+            return (false);
+
+        return (isSameTree(p->left, q->left) && isSameTree(p->right, q->right));
+    }
+};