From 2ec239635b01e0858c85f0950baff8d983e0089d Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 30 Aug 2023 00:02:13 +0900
Subject: [PATCH 1/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=2013305=EB=B2=88=20?=
 =?UTF-8?q?=EC=A3=BC=EC=9C=A0=EC=86=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\354\243\274\354\234\240\354\206\214.java" | 111 ++++++++++++++++++
 parkhayoon/temp.java                          |   4 -
 2 files changed, 111 insertions(+), 4 deletions(-)
 create mode 100644 "parkhayoon/BOJ_13305_\354\243\274\354\234\240\354\206\214.java"
 delete mode 100644 parkhayoon/temp.java

diff --git "a/parkhayoon/BOJ_13305_\354\243\274\354\234\240\354\206\214.java" "b/parkhayoon/BOJ_13305_\354\243\274\354\234\240\354\206\214.java"
new file mode 100644
index 0000000..fab5adf
--- /dev/null
+++ "b/parkhayoon/BOJ_13305_\354\243\274\354\234\240\354\206\214.java"
@@ -0,0 +1,111 @@
+package algo.week01;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+/*
+ * 도시 N개 일직선 도로
+ * 제일 왼쪽 -> 오른쪽
+ * 도로 사이 길이가 다를 수 있음
+ * 
+ * 처음 출발 시 자동차 기름 없어서 주유소에서 기름 넣고 출발
+ * 기름통 크기 무제한, 얼마든지 많은 기름을 넣을 수 있음
+ * 1km당 1L 기름 사용
+ * 각 도시에는 단 하나의 주유소
+ * 주유소 마다 리터당 가격이 다를 수 있음
+ * 이동 최소 비용 계산
+ * 
+ * 입력
+ * 첫째 줄: 도시의 개수 N(2 ≤ N ≤ 100,000)
+ * 다음 줄: 인접한 두 도시를 연결하는 도로의 길이 N-1개
+ * 다음 줄: 주유소의 리터당 가격이 제일 왼쪽 도시부터 순서대로 N개의 자연수
+ * 제일 왼쪽 도시부터 제일 오른쪽 도시까지의 거리는 1이상 1,000,000,000 이하의 자연수
+ * 리터당 가격은 1 이상 1,000,000,000 이하의 자연수
+ * 
+ * 출력
+ * 제일 왼쪽 도시에서 제일 오른쪽 도시로 가는 최소 비용
+ * 
+ * 아이디어
+ * A(출발점) -> C(경유지 : A-B 사이에서 최솟값) -> B(도착점)
+ * 최솟값 = PriceA * Dist(C-A) + PriceC * Dist(B-C)
+ * 1) A-C 구간 : A-C 구간 최솟값 찾고 위 과정 반복
+ *         A-D-C 최솟값 = PriceA * Dist(D-A) + PriceD * Dist(C-D) 갱신
+ * 2) C-B 구간 : 최소값 고정
+ * 
+ * 풀이 1) 배열로 최솟값 구하기
+ * 풀이 2) 우선순위 큐로 최솟값 구하기
+ * 
+ */
+public class BOJ_13305_주유소 {
+	
+	static class Oil implements Comparable<Oil>{
+		int idx, price;
+
+		public Oil(int idx, int price) {
+			super();
+			this.idx = idx;
+			this.price = price;
+		}
+
+		@Override
+		public int compareTo(Oil o) {
+			if(this.price != o.price)
+				return this.price > o.price ? 1 : -1;
+			else
+				return this.idx < o.idx ? 1 : -1;
+		}
+		
+	}
+    
+    static int N; // 도시의 개수 N
+    static int[] dist; // 누적 도로의 길이 목록
+    static int[] price; // 리터 당 가격 목록
+    static long sum; // 비용 저장
+    static PriorityQueue<Oil> pq = new PriorityQueue<Oil>();
+
+    public static void main(String[] args) throws IOException {
+        
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        N = Integer.parseInt(br.readLine());
+        dist = new int[N];
+        price = new int[N];
+        
+        StringTokenizer st = new StringTokenizer(br.readLine());
+        dist[0] = 0; // 0에서 0으로 가는 거리 = 0
+        for(int i=1; i<N; i++) { // 저장 내용 : 0에서 i로 가는 거리의 길이
+            int temp = Integer.parseInt(st.nextToken());
+            dist[i] = dist[i-1]+temp;
+        }
+        st = new StringTokenizer(br.readLine());
+        int minIdx = 0;
+        for(int i=0; i<N; i++) {
+            price[i] = Integer.parseInt(st.nextToken());
+            pq.add(new Oil(i, price[i])); // 전체 범위에서 최소 기름값을 가지는 위치 구하기
+            //if(price[i]<price[minIdx]) 
+            	//minIdx = i;
+        }
+        minIdx = pq.poll().idx;
+        findMin(minIdx, N-1); // 최소 기름값 위치, 그 위치에서 갈 다음 위치
+        System.out.println(sum);
+        
+    }
+    
+    private static void findMin(int idx, int lastIdx) {
+    	sum += (long)(dist[lastIdx]-dist[idx])*price[idx]; // 경유지 -> 도착점 비용 계산
+    	if(idx==0) return; // 경유지 = 시작점이면 종료
+    	int minIdx = 0; // 현재 최소 기름값 위치 이전의 최소 기름값 위치 갱신
+    	//for(int i=0; i<idx; i++) {
+    		//if(price[i]<price[minIdx])
+            	//minIdx = i;
+    	//}
+    	while(!pq.isEmpty()) {
+    		minIdx = pq.poll().idx;
+    		if(minIdx<idx) // 이전 최솟값 위치보다 더 앞에있는 최솟값이면 갱신 후 그 위치에서부터 다시 계산
+    			break;
+    	}
+    	findMin(minIdx, idx);
+    }
+}
\ No newline at end of file
diff --git a/parkhayoon/temp.java b/parkhayoon/temp.java
deleted file mode 100644
index 90a41fb..0000000
--- a/parkhayoon/temp.java
+++ /dev/null
@@ -1,4 +0,0 @@
-package parkhayoon;
-
-public class temp {
-}

From 145afdfc0b8a3c0f8773d3bd53874da5bf8e0c74 Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 30 Aug 2023 00:04:50 +0900
Subject: [PATCH 2/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=2011053=EB=B2=88=20?=
 =?UTF-8?q?=EA=B0=80=EC=9E=A5=20=EC=A6=9D=EA=B0=80=ED=95=98=EB=8A=94=20?=
 =?UTF-8?q?=EB=B6=80=EB=B6=84=EC=88=98=EC=97=B4?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\353\266\204\354\210\230\354\227\264.java" | 42 +++++++++++++++++++
 1 file changed, 42 insertions(+)
 create mode 100644 "parkhayoon/BOJ_11053_\352\260\200\354\236\245\354\246\235\352\260\200\355\225\230\353\212\224\353\266\200\353\266\204\354\210\230\354\227\264.java"

diff --git "a/parkhayoon/BOJ_11053_\352\260\200\354\236\245\354\246\235\352\260\200\355\225\230\353\212\224\353\266\200\353\266\204\354\210\230\354\227\264.java" "b/parkhayoon/BOJ_11053_\352\260\200\354\236\245\354\246\235\352\260\200\355\225\230\353\212\224\353\266\200\353\266\204\354\210\230\354\227\264.java"
new file mode 100644
index 0000000..2e130bc
--- /dev/null
+++ "b/parkhayoon/BOJ_11053_\352\260\200\354\236\245\354\246\235\352\260\200\355\225\230\353\212\224\353\266\200\353\266\204\354\210\230\354\227\264.java"
@@ -0,0 +1,42 @@
+package algo.week01;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+public class BOJ_11053_가장증가하는부분수열 {
+
+    static int N; // 수열의 길이 N
+    static int[] arr; // 수열
+    static int[] dp; // 선택한 부분 수열의 길이 저장
+
+    public static void main(String[] args) throws IOException {
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        arr = new int[N];
+        dp = new int[N];
+        st = new StringTokenizer(br.readLine());
+        for (int i=0; i<N; i++)
+            arr[i] = Integer.parseInt(st.nextToken());
+
+        dp();
+        int result = 0;
+        for(int i=0; i<N; i++)
+            result = Math.max(result, dp[i]+1);
+        System.out.println(result);
+    }
+
+    private static void dp() {
+        for(int i=0; i<N; i++) {
+            for(int j=0; j<i; j++) { // 선택한 i값 이전에서 비교
+                if(arr[j]<arr[i]) // 만약 앞의 값보다 뒤의 값이 더 긴 경우 - 오름차순의 경우, 부분 수열로 추가 가능
+                    dp[i] = Math.max(dp[i], dp[j]+1); // 현재까지 해당 값까지 최대 부분수열의 길이가 더 긴지 확인
+            }
+        }
+    }
+
+}
\ No newline at end of file

From 1c8f2507ab5f7a1544c7c967bc0fd69a1cf32508 Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 30 Aug 2023 00:05:32 +0900
Subject: [PATCH 3/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=201931=EB=B2=88=20?=
 =?UTF-8?q?=ED=9A=8C=EC=9D=98=EC=8B=A4=20=EB=B0=B0=EC=A0=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\354\213\244\353\260\260\354\240\225.java" | 81 +++++++++++++++++++
 1 file changed, 81 insertions(+)
 create mode 100644 "parkhayoon/BOJ_1931_\355\232\214\354\235\230\354\213\244\353\260\260\354\240\225.java"

diff --git "a/parkhayoon/BOJ_1931_\355\232\214\354\235\230\354\213\244\353\260\260\354\240\225.java" "b/parkhayoon/BOJ_1931_\355\232\214\354\235\230\354\213\244\353\260\260\354\240\225.java"
new file mode 100644
index 0000000..ae79655
--- /dev/null
+++ "b/parkhayoon/BOJ_1931_\355\232\214\354\235\230\354\213\244\353\260\260\354\240\225.java"
@@ -0,0 +1,81 @@
+package algo.week01;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+/*
+ * 한개의 회의실에서 N개의 회의에 대하여 사용표 만들기
+ * 각 회의 I에 대해 시작시간, 종료시간이 주어짐
+ * 각 회의가 겹치지 않게 하면서 회의 사용 최대 개수
+ * 회의는 중단 불가눙, 한 회의 종료 동시 다음 회의 시작 가능, 시작시간과 종료시간 동일할 수 있음
+ * 
+ * 입력
+ * 첫째 줄: 회의의 수 N(1 ≤ N ≤ 100,000)
+ * 이후 N개 줄: 각 회의의 정보(시작시간, 종료시간)(0 ≤ 시간 ≤ 2^31 - 1)
+ * 
+ * 출력
+ * 각 회의가 겹치지 않게 하면서 회의 사용 최대 개수
+ * 
+ * 아이디어
+ * 최대한 많은 회의를 골라야 함
+ * 1) 무조건 제일 짧은 회의? - 가장 짧은 회의 선정이 최적 조건을 만족하진 않음 ex. 1-5, 6-10, 4-7
+ * 2) 제일 빨리 끝나는 회의? - 시간 순서대로 지나감 -> 빨리 끝날수록 더 많은 회의 넣을 수 있음
+ * 
+ * 오류 발생 후 검색
+ * 반례)
+ * 2
+ * 4 4
+ * 3 4
+ * 2 4
+ * 정답: 2, 출력: 1
+ * => end뿐만 아니라 start도 정렬!
+ */
+public class BOJ_1931_회의실배정 {
+
+	static class Time implements Comparable<Time>{ // 회의실 시작, 종료 시간 저장
+		int start, end;
+
+		public Time(int start, int end) {
+			this.start = start;
+			this.end = end;
+		}
+
+		@Override
+		public int compareTo(Time o) { // end, start 순으로 정렬
+			if(this.end != o.end)
+				return this.end>o.end ? 1 : -1;
+			else
+				return this.start>o.start ? 1 : -1;
+		}
+	}
+
+	public static void main(String[] args) throws NumberFormatException, IOException {
+		
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		int N = Integer.parseInt(br.readLine());
+		PriorityQueue<Time> pq = new PriorityQueue<>(); // 최소 종료 시간 찾기 - PriorityQueue
+
+		for(int i=0; i<N; i++) {
+			StringTokenizer st = new StringTokenizer(br.readLine());
+			int start = Integer.parseInt(st.nextToken());
+			int end = Integer.parseInt(st.nextToken());
+			pq.add(new Time(start, end));
+		}
+
+		int sum = 1; // 회의 1개를 선택한 채 시작하므로 1부터 시작
+		int oldEnd = pq.poll().end; // 초기값: 제일 먼저 종료되는 회의
+		while(!pq.isEmpty()) {
+			Time current = pq.poll();
+			if(current.start<oldEnd) continue; // 이전 회의 종료 시간보다 현재 선택한 회의 시작시간이 더 빠른 경우 - 시간이 겹치므로 확인하지 않음
+			oldEnd = current.end; // 시간이 겹치지 않는 경우 종료 갱신
+			sum++;
+		}
+
+		System.out.println(sum);
+		
+	}
+
+}

From 4c394fc44df6f422ff2ef534fd0ee6680872dd0f Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 6 Sep 2023 00:20:35 +0900
Subject: [PATCH 4/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=2014501=EB=B2=88=20?=
 =?UTF-8?q?=ED=87=B4=EC=82=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .../BOJ_14501_\355\207\264\354\202\254.java"  | 109 ++++++++++++++++++
 1 file changed, 109 insertions(+)
 create mode 100644 "parkhayoon/BOJ_14501_\355\207\264\354\202\254.java"

diff --git "a/parkhayoon/BOJ_14501_\355\207\264\354\202\254.java" "b/parkhayoon/BOJ_14501_\355\207\264\354\202\254.java"
new file mode 100644
index 0000000..6cb001b
--- /dev/null
+++ "b/parkhayoon/BOJ_14501_\355\207\264\354\202\254.java"
@@ -0,0 +1,109 @@
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.PriorityQueue;
+import java.util.StringTokenizer;
+
+/*
+문제
+퇴사일: 오늘부터 N+1일
+남은 N일 동안 최대한 많은 상담
+하루에 하나씩 서로 다른 사람의 상담
+각각의 상담: 완료까지 걸리는 시간 Ti, 상담했을 때 받을 수 있는 금액 Pi
+하루에 여러 개의 상담을 할 순 없음
+이때 얻을 수 있는 최대 수익을 구하시오
+
+입력
+첫째 줄: 날짜 N (1 ≤ N ≤ 15)
+N개 줄: 1일부터 N일까지 Ti, Pi (1 ≤ Ti ≤ 5, 1 ≤ Pi ≤ 1,000)
+
+출력
+얻을 수 있는 최대 이익
+
+아이디어
+dp[]
+1) 1일까지 얻을 수 있는 최대이익 → 2일까지 얻을 수 있는 최대이익 → …
+2) 종료일 순서대로 정렬
+시작일 = i
+종료일 = i + Ti - 1
+cost = Pi
+while(종료일 < N)
+if(dp[종료일]==0)
+dp[종료일] =
+
+0 1 2 3 4 5 6
+2 5 2 3 5 8 7
+10 20 10 20 15 40 200
+
+정렬
+0 2 10 V
+2 2 10
+3 3 20 V
+1 5 20
+4 5 15 V
+6 7 200
+5 8 40
+
+0 1 2 3 4 5 6 7 8 9
+4 4 4 4 4 5 7 9 11 13
+50 40 30 20 10 10 20 30 40 50
+
+정렬
+0 4 50 V
+1 4 40
+2 4 30
+3 4 20
+4 4 10
+5 5 10 V
+6 7 20 - 이론에 오류가 발생! -> sum이 아닌 dp[]를 사용해보자
+7 9 30 V
+8 11 40
+9 13 50
+ */
+public class BOJ_14501_퇴사 {
+
+    static class Work implements Comparable<Work>{
+        int start, end, price; // 상담 시작일, 종료일, 금액
+
+        public Work(int start, int end, int price) {
+            this.start = start;
+            this.end = end;
+            this.price = price;
+        }
+
+
+        @Override
+        public int compareTo(Work o) {
+            if(this.end==o.end)
+                return this.start>o.start?1:-1;
+            return this.end>o.end?1:-1;
+        }
+    }
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        int N = Integer.parseInt(br.readLine());
+        int[] dp = new int[N];
+
+        PriorityQueue<Work> pq = new PriorityQueue<>();
+        for(int i=0; i<N; i++) {
+            StringTokenizer st = new StringTokenizer(br.readLine());
+            int time = Integer.parseInt(st.nextToken());
+            int price = Integer.parseInt(st.nextToken());
+            pq.add(new Work(i, i+time-1, price)); // 시작일, 종료일(시작일~시작일+기간), 비용
+        }
+
+        while(!pq.isEmpty()) { // 일단은 모든 상담을 확인
+            Work current = pq.poll(); // 현재 상담 확인
+            if(current.end>=N) break; // 종료일 기준 정렬 - 초과하면 이후 상담들도 불가능 -> 반복문 종료
+            dp[current.end] = Math.max(dp[current.end], current.price); // 현재 상담만 선택한 경우 확인
+            for(int i=0; i<current.start; i++) {
+                dp[current.end] = Math.max(dp[current.end], dp[i]+current.price); // 겹치지 않는 상담들을 한 경우 확인
+            }
+        }
+        int maxSum = 0;
+        for(int d : dp) // 기간 별 최적 답 중 최댓값 출력
+            maxSum = Math.max(maxSum, d);
+        System.out.println(maxSum);
+    }
+}
\ No newline at end of file

From b1e6faf4fb884559fb9bd50fa28663acbfda404e Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 6 Sep 2023 00:50:47 +0900
Subject: [PATCH 5/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=201700=EB=B2=88=20?=
 =?UTF-8?q?=EB=A9=80=ED=8B=B0=ED=83=AD=20=EC=8A=A4=EC=BC=80=EC=A4=84?=
 =?UTF-8?q?=EB=A7=81(=EB=AF=B8=EC=99=84=EC=84=B1)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\354\274\200\354\244\204\353\247\201.java" | 85 +++++++++++++++++++
 1 file changed, 85 insertions(+)
 create mode 100644 "parkhayoon/BOJ_1700_\353\251\200\355\213\260\355\203\255\354\212\244\354\274\200\354\244\204\353\247\201.java"

diff --git "a/parkhayoon/BOJ_1700_\353\251\200\355\213\260\355\203\255\354\212\244\354\274\200\354\244\204\353\247\201.java" "b/parkhayoon/BOJ_1700_\353\251\200\355\213\260\355\203\255\354\212\244\354\274\200\354\244\204\353\247\201.java"
new file mode 100644
index 0000000..efbbf92
--- /dev/null
+++ "b/parkhayoon/BOJ_1700_\353\251\200\355\213\260\355\203\255\354\212\244\354\274\200\354\244\204\353\247\201.java"
@@ -0,0 +1,85 @@
+package algo.week2;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.StringTokenizer;
+
+/*
+ * 문제
+ * 자기가 사용하고 있는 전기용품의 사용순서를 알아내었고,
+ * 이를 기반으로 플러그를 빼는 횟수를 최소화하는 방법을 고안
+ *
+ * 입력
+ * 첫 줄: 멀티탭 구멍의 개수 N(1≤N≤100), 전기 용품의 총 사용횟수 K(1≤K≤100)
+ * 둘째 줄: 전기용품의 이름이 K 이하의 자연수로 사용 순서대로 주어짐
+ *
+ * 출력
+ * 하나씩 플러그를 빼는 최소의 횟수
+ *
+ * 아이디어
+ * 최소 횟수 플러그부터 뽑기?
+ * 어디서 배운 거 같긴 한데... - 정처기?
+ *
+ * 1. 초기상태
+ * 끼운 플러그 배열이 비어있으면 입력값 넣기
+ * 단, 이미 꼽힌 상태면 지나가기
+ *
+ * 2. 반복
+ * 만약 플러그 배열이 꽉 차있음, 새로운 용품이름이 들어옴 - 무조건 뽑아야 함
+ * 무엇을 뽑을까?
+ *
+ * 예시
+ * 2 7
+ * 2 3 2 3 1 2 7 - 사용 빈도 수 배열에 저장, 적은 순서대로 뽑기
+ */
+public class BOJ_1700_멀티탭스케줄링 {
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        int N = Integer.parseInt(st.nextToken());
+        int K = Integer.parseInt(st.nextToken());
+        int[] plugs = new int[N];
+        int[] products = new int[K];
+        int[] check = new int[K+1]; // 배열이 플러그에 있는지 or기기 사용 횟수 저장
+
+        st = new StringTokenizer(br.readLine());
+        for(int i=0; i<K; i++) {
+            products[i] = Integer.parseInt(st.nextToken());
+            check[products[i]]++;
+        }
+
+        // 1. 플러그가 꽉 찰 때까지 확인
+        int idx = 0;
+        for(int p : products) {
+            if(plugs[idx]==p) { // 만약 사용하려는 용품을 이미 사용중이면
+                check[p]--; // 사용 횟수 1 감소
+            }
+            else if(plugs[idx]==0) { // 만약 플러그가 비어있고, 해당 용품을 사용하지 않는 경우
+                plugs[idx]=p; // 비어있는 플러그에 용품 연결
+                check[p]--; // 사용 횟수 1 감소
+                idx++; // 다음 플러그에 넣을 용품 고르기
+            }
+            if(idx==N) break; // 플러그를 마지막 부분까지 채움
+        }
+
+        // 2. 플러그가 꽉 찬 후 뽑을 용품 고르기
+        // 1) 남은 횟수가 적은 플러그부터 뽑기?
+        // 2) 가장 나중에 오는 플러그부터 뽑기?
+        for(int i=idx+1; i<K; i++) {
+            for(int j=0; j<N; j++) { // 플러그 탐색
+                if(plugs[j]==products[i]) { // 이미 플러그 사용중 - 카운드 줄이기
+                    check[plugs[i]]--;
+                    idx++;
+                }
+                else { // 신규 플러그 - 뽑을 플러그 고르기
+
+                }
+            }
+        }
+
+    }
+
+}

From 800d9851f3eb536b13bb9708d20d43b7af96bc31 Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Wed, 6 Sep 2023 00:51:31 +0900
Subject: [PATCH 6/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=2016234=EB=B2=88=20?=
 =?UTF-8?q?=EC=9D=B8=EA=B5=AC=EC=9D=B4=EB=8F=99(=EB=AF=B8=EC=99=84?=
 =?UTF-8?q?=EC=84=B1)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\352\265\254\354\235\264\353\217\231.java" | 92 +++++++++++++++++++
 1 file changed, 92 insertions(+)
 create mode 100644 "parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"

diff --git "a/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java" "b/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"
new file mode 100644
index 0000000..50a9d1e
--- /dev/null
+++ "b/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"
@@ -0,0 +1,92 @@
+package algo.week2;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+/*
+ * 크기 NxN, 1x1 칸으로 나눠짐
+ * 각 칸은 나라 하나씩 존재, A[r][c] = r행 c열 인구수
+ * 1. 국경선 공유 두 국가의 인구차가  L ≤ x ≤ R이면 하루동안 국경 개방
+ * 2. 모든 국가가 위에 따라 국경선 개방 후 인구 이동 시작
+ * 3. 국경선이 열려서 연결되어있음 - 연합
+ * 4. 연합의 각 칸의 인구수 = 연합의 인구수 / 연합 이루는 칸 수, 소수점 버림
+ * 5. 이동 후 연합 해체, 모든 국경선 닫음
+ * 인구 이동이 발생하는 기간?
+ *
+ * 입력
+ * 첫째 줄: N,L,R(1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)
+ * N개 줄: 각 나라의 인구수(0 ≤ A[r][c] ≤ 100)
+ * 인구 이동 발생 기간 ≤ 2000
+ */
+public class BOJ_16234_인구이동 {
+
+    static int N, L, R;
+    static int[][] A;
+    static int[][] tempA;
+    static int[][] deltas = {{-1,0},{1,0},{0,-1},{0,1}};
+    static boolean[][] visited;
+    static boolean movable = true;
+    static int sum, cnt;
+
+    public static void main(String[] args) throws IOException {
+        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+        StringTokenizer st = new StringTokenizer(br.readLine());
+
+        N = Integer.parseInt(st.nextToken());
+        L = Integer.parseInt(st.nextToken());
+        R = Integer.parseInt(st.nextToken());
+        A = new int[N][N];
+        tempA = new int[N][N];
+        visited = new boolean[N][N];
+
+        for(int i=0; i<N; i++) {
+            st = new StringTokenizer(br.readLine());
+            for(int j=0; j<N; j++) {
+                A[i][j] = Integer.parseInt(st.nextToken());
+            }
+        }
+        int date = -1;
+        while(movable) {
+            movable = false;
+            for(int i=0; i<N; i++) {
+                for(int j=0; j<N; j++) {
+                    sum = A[i][j];
+                    cnt = 1;
+                    dfs(i, j);
+                    if(cnt==0) {
+                        tempA[i][j] = A[i][j];
+                        continue;
+                    }
+                    int avg = sum/cnt;
+                    for(int p=0; p<N; p++) {
+                        for(int q=0; q<N; q++) {
+                            if(visited[p][q] && tempA[p][q]==0)
+                                tempA[p][q] = avg;
+                        }
+                    }
+                }
+            }
+            date++;
+            A = tempA.clone();
+        }
+        System.out.println(date);
+    }
+
+    private static void dfs(int x, int y) {
+        visited[x][y]=true;
+        for(int d=0; d<4; d++) {
+            int dx = x+deltas[d][0];
+            int dy = y+deltas[d][1];
+            if(dx<0 || dx>=N || dy<0 || dy>=N || visited[dx][dy] || Math.abs(A[x][y]-A[dx][dy])<L || Math.abs(A[x][y]-A[dx][dy])>R) continue;
+            movable = true;
+            visited[dx][dy] = true;
+            sum += A[dx][dy];
+            cnt++;
+            dfs(dx,dy);
+        }
+    }
+
+}

From 5f246c9489c20123d5da2f883fa0451bd95707df Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Fri, 8 Sep 2023 18:25:23 +0900
Subject: [PATCH 7/8] =?UTF-8?q?=EB=B0=B1=EC=A4=80=2016234=EB=B2=88=20?=
 =?UTF-8?q?=EC=9D=B8=EA=B5=AC=EC=9D=B4=EB=8F=99?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\352\265\254\354\235\264\353\217\231.java" | 158 ++++++++++--------
 1 file changed, 91 insertions(+), 67 deletions(-)

diff --git "a/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java" "b/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"
index 50a9d1e..3379b90 100644
--- "a/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"
+++ "b/parkhayoon/BOJ_16234_\354\235\270\352\265\254\354\235\264\353\217\231.java"
@@ -3,7 +3,6 @@
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.util.Arrays;
 import java.util.StringTokenizer;
 
 /*
@@ -15,78 +14,103 @@
  * 4. 연합의 각 칸의 인구수 = 연합의 인구수 / 연합 이루는 칸 수, 소수점 버림
  * 5. 이동 후 연합 해체, 모든 국경선 닫음
  * 인구 이동이 발생하는 기간?
- *
+ * 
  * 입력
  * 첫째 줄: N,L,R(1 ≤ N ≤ 50, 1 ≤ L ≤ R ≤ 100)
  * N개 줄: 각 나라의 인구수(0 ≤ A[r][c] ≤ 100)
  * 인구 이동 발생 기간 ≤ 2000
+ * 
+ * 아이디어
+ * while(인구 이동 가능한 경우) {
+ * 		방문 배열 초기화
+ * 		배열 전체 탐색 {
+ * 				해당 점에서 dfs 탐색 {...}
+ * 				dfs 종료 후 평균 구하기
+ * 				tempA에 평균 들어가는 부분 입력
+ * 			}
+ * }
  */
 public class BOJ_16234_인구이동 {
+	
+	static int N, L, R;
+	static int[][] A;
+	static int[][] tempA; // i일차 A 이동 후 위치 저장
+	static int[][] deltas = {{-1,0},{1,0},{0,-1},{0,1}}; // 4방 탐색
+	static boolean[][] visited; // dfs 방문 확인
+	static boolean movable = true; // 인구 이동 가능 여부
+	static int sum, cnt;
 
-    static int N, L, R;
-    static int[][] A;
-    static int[][] tempA;
-    static int[][] deltas = {{-1,0},{1,0},{0,-1},{0,1}};
-    static boolean[][] visited;
-    static boolean movable = true;
-    static int sum, cnt;
-
-    public static void main(String[] args) throws IOException {
-        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-        StringTokenizer st = new StringTokenizer(br.readLine());
-
-        N = Integer.parseInt(st.nextToken());
-        L = Integer.parseInt(st.nextToken());
-        R = Integer.parseInt(st.nextToken());
-        A = new int[N][N];
-        tempA = new int[N][N];
-        visited = new boolean[N][N];
-
-        for(int i=0; i<N; i++) {
-            st = new StringTokenizer(br.readLine());
-            for(int j=0; j<N; j++) {
-                A[i][j] = Integer.parseInt(st.nextToken());
-            }
-        }
-        int date = -1;
-        while(movable) {
-            movable = false;
-            for(int i=0; i<N; i++) {
-                for(int j=0; j<N; j++) {
-                    sum = A[i][j];
-                    cnt = 1;
-                    dfs(i, j);
-                    if(cnt==0) {
-                        tempA[i][j] = A[i][j];
-                        continue;
-                    }
-                    int avg = sum/cnt;
-                    for(int p=0; p<N; p++) {
-                        for(int q=0; q<N; q++) {
-                            if(visited[p][q] && tempA[p][q]==0)
-                                tempA[p][q] = avg;
-                        }
-                    }
-                }
-            }
-            date++;
-            A = tempA.clone();
-        }
-        System.out.println(date);
-    }
-
-    private static void dfs(int x, int y) {
-        visited[x][y]=true;
-        for(int d=0; d<4; d++) {
-            int dx = x+deltas[d][0];
-            int dy = y+deltas[d][1];
-            if(dx<0 || dx>=N || dy<0 || dy>=N || visited[dx][dy] || Math.abs(A[x][y]-A[dx][dy])<L || Math.abs(A[x][y]-A[dx][dy])>R) continue;
-            movable = true;
-            visited[dx][dy] = true;
-            sum += A[dx][dy];
-            cnt++;
-            dfs(dx,dy);
-        }
-    }
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StringTokenizer st = new StringTokenizer(br.readLine());
+		
+		N = Integer.parseInt(st.nextToken());
+		L = Integer.parseInt(st.nextToken());
+		R = Integer.parseInt(st.nextToken());
+		A = new int[N][N];
+		tempA = new int[N][N];
+		visited = new boolean[N][N];
+		
+		for(int i=0; i<N; i++) {
+			st = new StringTokenizer(br.readLine());
+			for(int j=0; j<N; j++) {
+				A[i][j] = Integer.parseInt(st.nextToken());
+			}
+		}
+		
+		int date = -1; // 인구 이동 날짜 수
+		while(movable) { // 인구 이동이 가능할 때 실행
+			movable = false; // 일단 움직이지 않는다고 가정 - 추후 탐색에서 인구 이동이 가능할 때 바꿔주기
+			visited = new boolean[N][N]; // 하루 인구 이동 후 다시 전체 탐색하므로 초기화
+			tempA = new int[N][N];
+			// 배열의 모든 부분 탐색
+			for(int i=0; i<N; i++) {
+				for(int j=0; j<N; j++) {
+					// 만약 이전에 이미 탐색한 곳이면 통과
+					if(visited[i][j]) continue;
+					// 평균값 구하기 위한 전제조건
+					visited[i][j]=true; // 현재 지점 방문처리
+					sum = A[i][j]; // 인구 수의 합
+					cnt = 1; // 도시 수
+					dfs(i, j);
+					if(cnt==1) { // 만약 dfs 탐색했으나 이동 불가능한 경우
+						tempA[i][j]=A[i][j]; // 원본 값 복사
+						continue;
+					}
+					int avg = sum/cnt; // 평균 구하기(소수점 내림)
+					// 배열 내부에서 바꿔줘야 하는 연결된 부분 변경
+					for(int p=0; p<N; p++) {
+						for(int q=0; q<N; q++) {
+							if(visited[p][q] && tempA[p][q]==0) // 방문한 점  and 아직 값을 넣지 않은 점
+								tempA[p][q] = avg;
+						}
+					}
+				}
+			}
+			// 인구 이동 완료 - 날짜 1일 추가
+			date++;
+			// A 배열을 업데이트
+			A = tempA.clone();
+		}
+		
+		System.out.println(date);
+	}
+	
+	private static void dfs(int x, int y) {
+		// 4방 탐색
+		for(int d=0; d<4; d++) {
+			int dx = x+deltas[d][0];
+			int dy = y+deltas[d][1];
+			// 범위 밖이거나 이미 방문했거나 두 도시 간 차이가 L 미만, R 초과면 이동 불가
+			if(dx<0 || dx>=N || dy<0 || dy>=N || visited[dx][dy] || Math.abs(A[x][y]-A[dx][dy])<L || Math.abs(A[x][y]-A[dx][dy])>R) continue;
+			// 이동 가능한 도시가 있음 - 인구 이동 가능 확인
+			movable = true;
+			// 이동하려는 지점을 방문처리
+			visited[dx][dy] = true;
+			sum += A[dx][dy];
+			cnt++;
+			dfs(dx,dy);
+		}
+	}
 
 }

From 558e1703dc9b99b6742d541551a42b3ecea2d25c Mon Sep 17 00:00:00 2001
From: ShinyMint <maha97523@gmail.com>
Date: Fri, 8 Sep 2023 18:26:27 +0900
Subject: [PATCH 8/8] =?UTF-8?q?=ED=94=84=EB=A1=9C=EA=B7=B8=EB=9E=98?=
 =?UTF-8?q?=EB=A8=B8=EC=8A=A4=20161988=20=EC=97=B0=EC=86=8D=20=ED=8E=84?=
 =?UTF-8?q?=EC=8A=A4=20=EB=B6=80=EB=B6=84=20=EC=88=98=EC=97=B4=EC=9D=98=20?=
 =?UTF-8?q?=ED=95=A9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 ...\354\227\264\354\235\230\355\225\251.java" | 45 +++++++++++++++++++
 1 file changed, 45 insertions(+)
 create mode 100644 "parkhayoon/PG_161988_\354\227\260\354\206\215\355\216\204\354\212\244\353\266\200\353\266\204\354\210\230\354\227\264\354\235\230\355\225\251.java"

diff --git "a/parkhayoon/PG_161988_\354\227\260\354\206\215\355\216\204\354\212\244\353\266\200\353\266\204\354\210\230\354\227\264\354\235\230\355\225\251.java" "b/parkhayoon/PG_161988_\354\227\260\354\206\215\355\216\204\354\212\244\353\266\200\353\266\204\354\210\230\354\227\264\354\235\230\355\225\251.java"
new file mode 100644
index 0000000..ca3f9fc
--- /dev/null
+++ "b/parkhayoon/PG_161988_\354\227\260\354\206\215\355\216\204\354\212\244\353\266\200\353\266\204\354\210\230\354\227\264\354\235\230\355\225\251.java"
@@ -0,0 +1,45 @@
+package algo.week2;
+
+/*
+ * 연속 부분 수열 X 펄스 수열([1,-1,1,...] or [-1,1,-1,...])의 최대합
+ * 1 ≤ sequence의 길이 ≤ 500,000, -100,000 ≤ sequence의 원소 ≤ 100,000
+ * 
+ * 아이디어
+ * 연속 부분 수열의 합 응용
+ * 1) {1, -1, 1, ... }을 곱한 상태에서 최대 구하기
+ * 2) {-1, 1, -1, ... }을 곱한 상태에서 최대 구하기
+ */
+public class PG_161988_연속펄스부분수열의합 {
+
+	public static void main(String[] args) {
+		
+		int[] sequence = {2, 3, -6, 1, 3, -1, 2, 4};
+		int L = sequence.length;
+		
+		for(int i=1; i<L; i+=2) // 1) {1, -1, 1, ... } 곱해주기
+			sequence[i]*=-1;
+		long[] dp1 = new long[L]; //최대합: 100,000 * 500,000 > int 최대 범위 -> long 사용
+		dp1[0] = sequence[0];
+		long max1 = 0;
+		for(int i=1; i<L; i++)
+			dp1[i] = Math.max(0, dp1[i-1]) + sequence[i];
+		for(int i=0; i<L; i++)
+			max1 = Math.max(max1, dp1[i]);
+//		System.out.println(Arrays.toString(dp1));
+		
+		for(int i=0; i<L; i++) // 2) {1, -1, 1, ... }*(-1) = {-1, 1, -1, ... }
+			sequence[i]*=-1;
+		long[] dp2 = new long[L];
+		dp2[0] = sequence[0];
+		long max2 = 0;
+		for(int i=1; i<L; i++)
+			dp2[i] = Math.max(0, dp2[i-1]) + sequence[i];
+		for(int i=0; i<L; i++)
+			max2 = Math.max(max2, dp2[i]);
+//		System.out.println(Arrays.toString(dp2));
+		
+		long answer = Math.max(max1, max2);
+		System.out.println(answer);
+	}
+
+}