2월 3주차

java/src/feb/week3/boj/두용액_박재환.java

@@ -0,0 +1,51 @@
+package feb.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 두용액_박재환 {
+    static BufferedReader br;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        init();
+        br.close();
+    }
+    static StringTokenizer st;
+    static int n;
+    static int[] arr;
+    static void init() throws IOException {
+        n = Integer.parseInt(br.readLine().trim());
+        arr = new int[n];
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=0; i<n; i++) arr[i] = Integer.parseInt(st.nextToken());
+        Result result = findNearestNum();
+        System.out.println(result.a + " " + result.b);
+    }
+    static class Result {
+        int a, b;
+        int sum;
+        Result(int a, int b, int sum) {
+            this.a = a;
+            this.b = b;
+            this.sum = sum;
+        }
+    }
+    static Result findNearestNum() {
+        Result result = null;
+        Arrays.sort(arr);           // 오름차순 정렬
+        int l=0, r=n-1;
+        while(l<r) {
+            int a = arr[l];
+            int b = arr[r];
+            int sum = Math.abs(a+b);
+            if(result == null || result.sum > sum) {
+                result = new Result(a, b, sum);
+            }
+            if(sum == 0) break;         // 더 이상 최적값을 찾을 수 없음
+            // 포인터 위치 변경
+            if(a+b > 0) r--;            // 두 수의 합이 양수 -> 큰 값을 줄여봄
+            else l++;                   // 두 수의 합이 음수 -> 작은 값을 줄여봄
+        }
+        return result;
+    }
+}

java/src/feb/week3/boj/수열과쿼리37_박재환.java

@@ -0,0 +1,113 @@
+package feb.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 수열과쿼리37_박재환 {
+    static BufferedReader br;
+    static StringBuilder sb;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        sb = new StringBuilder();
+        init();
+        br.close();
+        System.out.println(sb);
+    }
+    static StringTokenizer st;
+    static void input() throws IOException {
+        n = Integer.parseInt(br.readLine().trim());
+        arr = new int[n+1];
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=1; i<n+1; i++) arr[i] = Integer.parseInt(st.nextToken());
+    }
+    static int n;
+    static int[] arr;
+    static void init() throws IOException {
+        input();
+        SegmentTree tree = new SegmentTree(n);
+        tree.buildTree(1, 1, n);
+        int queryCount = Integer.parseInt(br.readLine().trim());
+        while(queryCount-- > 0) {
+            st = new StringTokenizer(br.readLine().trim());
+            int cmd = Integer.parseInt(st.nextToken());
+            if(cmd == 1) {
+                int targetId = Integer.parseInt(st.nextToken());
+                int targetValue = Integer.parseInt(st.nextToken());
+                tree.update(1, 1, n, targetId, targetId, targetValue);
+            }
+            else if(cmd == 2) {
+                int s = Integer.parseInt(st.nextToken());
+                int e = Integer.parseInt(st.nextToken());
+                sb.append(tree.evenQuery(1, 1, n, s, e)).append('\n');
+            }
+            else if(cmd == 3) {
+                int s = Integer.parseInt(st.nextToken());
+                int e = Integer.parseInt(st.nextToken());
+                sb.append(tree.oddQuery(1, 1, n, s, e)).append('\n');
+            }
+        }
+    }
+    static class SegmentTree {
+        /**
+         * 갱신 자체가 구간에 대한 업데이트는 아님
+         */
+        int size;
+        int[] even;
+        int[] odd;
+
+        SegmentTree(int n) {
+            this.size = n;
+            this.even = new int[4*size];
+            this.odd = new int[4*size];
+        }
+
+        void buildTree(int id, int l, int r) {
+            if(l == r) {        // 리프노드라면
+                // 현재 원소가 짝수인지 홀수인지 확인 후 갱신
+                if(arr[l]%2 == 0) even[id]++;
+                else odd[id]++;
+                return;
+            }
+            int mid = l + (r-l)/2;
+            buildTree(2*id, l, mid);
+            buildTree(2*id+1, mid+1, r);
+
+            // 홀수와 짝수 노드를 구분해서 갱신
+            even[id] = even[2*id] + even[2*id+1];
+            odd[id] = odd[2*id] + odd[2*id+1];
+        }
+
+        void update(int id, int l, int r, int s, int e, int v) {
+            if(r < s || l > e) return;
+            if(l >= s && r <= e) {      // 리프노드
+                // 기존 값을 확인한 뒤, 갱신
+                int prev = arr[s];
+                if(prev%2 == 0) even[id]--;
+                else odd[id]--;
+                // 새로운 값 갱신
+                if(v%2 == 0) even[id]++;
+                else odd[id]++;
+                arr[l] = v;
+                return;
+            }
+            int mid = l + (r-l)/2;
+            update(2*id, l, mid, s, e, v);
+            update(2*id+1, mid+1, r, s, e, v);
+            // 홀수와 짝수 노드를 구분해서 갱신
+            even[id] = even[2*id] + even[2*id+1];
+            odd[id] = odd[2*id] + odd[2*id+1];
+        }
+        int evenQuery(int id, int l, int r, int s, int e) {
+            if(r < s || l > e) return 0;
+            if(l >= s && r <= e) return even[id];
+            int mid = l + (r-l)/2;
+            return evenQuery(2*id, l, mid, s, e) + evenQuery(2*id+1, mid+1, r, s, e);
+        }
+        int oddQuery(int id, int l, int r, int s, int e) {
+            if(r < s || l > e) return 0;
+            if(l >= s && r <= e) return odd[id];
+            int mid = l + (r-l)/2;
+            return oddQuery(2*id, l, mid, s, e) + oddQuery(2*id+1, mid+1, r, s, e);
+        }
+    }
+}

java/src/feb/week3/boj/에바쿰_박재환.java

@@ -0,0 +1,103 @@
+package feb.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 에바쿰_박재환 {
+    static BufferedReader br;
+    static StringBuilder sb;
+    public static void main(String[] args) throws IOException {
+        br = new BufferedReader(new InputStreamReader(System.in));
+        sb = new StringBuilder();
+        init();
+        br.close();
+        System.out.println(sb);
+    }
+    static StringTokenizer st;
+    static int n;
+    static int[] arr;
+    static long[] tree;
+    static long[] lazy;
+    static void init() throws IOException {
+        st = new StringTokenizer(br.readLine().trim());
+        n = Integer.parseInt(st.nextToken());
+        int q1 = Integer.parseInt(st.nextToken());
+        int q2 = Integer.parseInt(st.nextToken());
+
+        arr = new int[n+1];
+        st = new StringTokenizer(br.readLine().trim());
+        for(int i=1; i<n+1; i++) arr[i] = Integer.parseInt(st.nextToken());
+
+        tree = new long[4 * (n+1)];
+        lazy = new long[4 * (n+1)];
+        buildTree(1, 1, n);
+        int total = q1 + q2;
+        while(total-- > 0) {
+            st = new StringTokenizer(br.readLine().trim());
+            int cmd = Integer.parseInt(st.nextToken());
+            if(cmd == 1) {
+                int s = Integer.parseInt(st.nextToken());
+                int e = Integer.parseInt(st.nextToken());
+                if (s > e) {
+                    int tmp = s;
+                    s = e;
+                    e = tmp;
+                }
+                sb.append(query(1, 1, n, s, e)).append('\n');
+            } else if(cmd == 2) {
+                int s = Integer.parseInt(st.nextToken());
+                int e = Integer.parseInt(st.nextToken());
+                long v = Long.parseLong(st.nextToken());
+                if (s > e) {
+                    int tmp = s;
+                    s = e;
+                    e = tmp;
+                }
+                update(1, 1, n, s, e, v);
+            }
+        }
+    }
+
+    static long buildTree(int id, int l, int r) {
+        if(l == r) return tree[id] = arr[l];
+        int mid = l + (r - l)/2;
+        return tree[id] = buildTree(2*id, l, mid) + buildTree(2*id+1, mid+1, r);
+    }
+
+    static void push(int id, int l, int r) {
+        if(lazy[id] == 0 || l == r) return;
+
+        long lazyV = lazy[id];
+        int mid = l + (r - l)/2;
+
+        tree[2*id] += ((mid-l+1) * lazyV);
+        lazy[2*id] += lazyV;
+
+        tree[2*id+1] += ((r-mid) * lazyV);
+        lazy[2*id+1] += lazyV;
+
+        lazy[id] = 0;
+    }
+
+    static long query(int id, int l, int r, int s, int e) {
+        if(r < s || l > e) return 0L;
+        if(l >= s && r <= e) return tree[id];
+        push(id, l, r);
+        int mid = l + (r - l)/2;
+        return query(2*id, l, mid, s, e) + query(2*id+1, mid+1, r, s, e);
+    }
+
+    static void update(int id, int l, int r, int s, int e, long v) {
+        if(r < s || l > e) return;
+        if(l >= s && r <= e) {
+            tree[id] += ((r - l + 1) * v);
+            lazy[id] += v;
+            return;
+        }
+        push(id, l, r);
+        int mid = l + (r - l)/2;
+        update(2*id, l, mid, s, e, v);
+        update(2*id+1, mid+1, r, s, e, v);
+        tree[id] = tree[2*id] + tree[2*id+1];
+    }
+}

java/src/feb/week3/boj/오름세_세그먼트트리_박재환.java

@@ -0,0 +1,81 @@
+package feb.week3.boj;
+
+import java.util.*;
+import java.io.*;
+
+public class 오름세_세그먼트트리_박재환 {
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st;
+        String input;
+        while((input = br.readLine()) != null) {
+            int n = Integer.parseInt(input.trim());
+            int[] arr = new int[n];
+            st = new StringTokenizer(br.readLine().trim());
+            for(int i=0; i<n; i++) arr[i] = Integer.parseInt(st.nextToken());
+            solution(n, arr);
+        }
+        br.close();
+    }
+    static int[] tree;
+    static void solution(int n, int[] arr) {
+        /**
+         * 좌표 압축
+         */
+        compress(arr);
+        tree = new int[4*size];
+        /**
+         * arr 원소를 순차적으로 처리한다.
+         * 1. a 의 이전위치까지 최장 증가 부분 수열을 구한다.
+         * 2. 1에서 구한 값에 + 1을 한 값이 현재 수의 최장증가 부분 수열이다.
+         */
+        for(int i=0; i<n; i++) {
+            int num = compressArr[i];
+            /**
+             * num 이전까지 최장 증가 수열을 가져온다.
+             */
+            int prevLis = query(1, 1, size, 1, num-1);
+            int curLis = prevLis + 1;
+            update(1, 1, size, num, num, curLis);
+        }
+        System.out.println(tree[1]);
+    }
+    static int[] compressArr;
+    static int size;
+    static void compress(int[] arr) {
+        int id = 0;
+        int[] temp = arr.clone();
+
+        Arrays.sort(temp);
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i : temp) {
+            if(!map.containsKey(i)) {
+                map.put(i, ++id);
+            }
+        }
+
+        compressArr = new int[arr.length];
+        size = id;
+        for(int i=0; i<arr.length; i++) {
+            compressArr[i] = map.get(arr[i]);
+        }
+    }
+    static int query(int id, int l, int r, int s, int e) {
+        if(r < s || l > e) return 0;
+        if(l >= s && r <= e) return tree[id];
+
+        int mid = l + (r-l)/2;
+        return Math.max(query(2*id, l, mid, s, e), query(2*id+1, mid+1, r, s, e));
+    }
+    static void update(int id, int l, int r, int s, int e, int v) {
+        if(r < s || l > e) return;
+        if(l >= s && r <= e) {
+            tree[id] = v;
+            return;
+        }
+        int mid = l + (r-l)/2;
+        update(2*id, l, mid, s, e, v);
+        update(2*id+1, mid+1, r, s, e, v);
+        tree[id] = Math.max(tree[2*id], tree[2*id+1]);
+    }
+}