[이재훈] Day03

leetcode2/1easy/Q2511.java

@@ -0,0 +1,42 @@
+package Leetcode;
+
+/*
+1. 아이디어 :
+
+ - 양쪽에서 1을 찾은 다음에 -1을 찾았을때 그 사이의 거리를 재서 최대값을 값으로 리턴
+
+2. 시간복잡도 :
+O( n )
+3. 자료구조/알고리즘 :
+- /
+ */
+
+public class Q2511 {
+    class Solution {
+        public int captureForts(int[] forts) {
+
+            int pos = -1;
+            int maxFortsCaptured = 0;
+            for(int i = 0; i<forts.length; i++) {
+                if(forts[i] == 1) pos = i;
+
+                if(pos != -1 && forts[i] == -1) {
+                    maxFortsCaptured = Math.max(maxFortsCaptured, i - pos -1);
+                    pos = -1;
+                }
+            }
+
+            pos = -1;
+            for(int i = forts.length-1;i >=0;i--) {
+                if(forts[i] == 1) pos = i;
+
+                if(pos != -1 && forts[i] == -1) {
+                    maxFortsCaptured = Math.max(maxFortsCaptured, pos - i -1);
+                    pos = -1;
+                }
+            }
+
+            return maxFortsCaptured;
+        }
+    }
+}

leetcode2/1easy/Q993.java

@@ -36,11 +36,9 @@ public boolean isCousins(TreeNode root, int x, int y) {
 
                     if(node.val == y) isYExisted =true;
 
-
                     if(node.left != null) q.offer(node.left);
                     if(node.right != null) q.offer(node.right);
                     if(node.left != null && node.right != null) {
-
                         if((node.left.val == x || node.left.val == y) &&
                                 (node.right.val == x || node.right.val == y)) {
                             q.pollLast();

leetcode2/2medium/Q3310.java

@@ -0,0 +1,72 @@
+package Leetcode;
+
+/*
+1. 아이디어 :
+
+- 인접 리스트 생성 후
+- bfs로 하나씩 빼내서 infected된 애들을 전부 저장
+- 만약 infected된애들외에 다른애들이 그룹내에 있다면 전체를 리턴
+- 없다면 inflected된 애들 제외하고 나머지 저장 후 리턴
+
+2. 시간복잡도 :
+O( n * m )
+3. 자료구조/알고리즘 :
+- / bfs
+ */
+
+import java.util.*;
+
+public class Q3310 {
+    class Solution {
+        public List<Integer> remainingMethods(int n, int k, int[][] invocations) {
+            List<Integer> res = new ArrayList<>();
+
+            // 인접리스트 만들기
+            List<Integer>[] originalList = new List[n];
+            List<Integer>[] callerList = new List[n];
+            for(int i =0;i < n;i++) {
+                res.add(i);
+                originalList[i] = new ArrayList<>();
+                callerList[i] = new ArrayList<>();
+            }
+            for(int[] inv : invocations) {
+                int a = inv[0];
+                int b = inv[1];
+
+                originalList[a].add(b);
+                callerList[b].add(a);
+            }
+
+            boolean[] bugs = new boolean[n];
+            Queue<Integer> q = new LinkedList<>();
+            q.offer(k);
+            bugs[k] = true;
+
+            // find all bugs
+            while(!q.isEmpty()) {
+                int bug = q.poll();
+                for(int b : originalList[bug]) {
+                    if(!bugs[b]) {
+                        bugs[b] = true;
+                        q.add(b);
+                    }
+                }
+            }
+
+            // 만약 버그 노드 제외하고 다른 애들이 해당 그룹에 있을경우 전체를 반환
+            for(int i = 0; i<n; i++) {
+                if(!bugs[i]) continue;
+                for(int caller : callerList[i]) {
+                    if(!bugs[caller]) return res;
+                }
+            }
+
+            // 아닐경우에는 bugs에 있는 애들을 제외하고 처리
+            res = new ArrayList<>();
+            for(int i = 0; i<n;i++) {
+                if(!bugs[i]) res.add(i);
+            }
+            return res;
+        }
+    }
+}