TH

[Java]Set

sskl660 — Tue, 22 Mar 2022 00:52:20 +0900

Set

Set은 내부 데이터를 중복해서 저장할 수 없고, 저장된 객체에 순서가 없다.
따라서 Set은 List와 같이 인덱스를 사용하여 원소에 바로 접근할 수 없다.

HashSet

Java는 내부적으로 Set 인터페이스를 따로 정의해 두었다. 이곳에 다양한 Set 구현체를 활용하여 코드를 작성할 수 있는데, HashSet은 기본적인 Set의 특성을 그대로 반영한 클래스이다.

Set<Integer> set = new HashSet<>();
set.add(5);
set.add(5);
set.add(1);
set.add(1);
set.add(3);

System.out.println(set);

다음과 같이 중복된 자료를 저장하더라도 중복되지 않게 저장되는 것을 확인할 수 있다.

TreeSet

Set은 TreeSet을 사용하여 내부적으로 정렬된 상태를 유지하도록 할 수 있다.

TreeSet<Integer> set = new TreeSet<>(new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		// Set을 내림차순으로 정렬하는 기준 설정
		return Integer.compare(o2, o1);
	}
	
});

set.add(5);
set.add(5);
set.add(1);
set.add(1);
set.add(3);

System.out.println(set.pollFirst());
System.out.println(set.pollLast());
System.out.println(set);

또 코드와 같이 Deque의 특성을 가지고 있어, 앞뒤로 꺼내는 연산이 가능하다.

LinkedHashSet

Set은 삽입 순서를 보장하지 않는다. 하지만 LinkedHashSet은 연결리스트 형태로 구현이 되어 있기 때문에 삽입 순서를 보장하는 특징이 있다.

LinkedHashSet<Integer> set = new LinkedHashSet<>();
		
set.add(5);
set.add(5);
set.add(1);
set.add(1);
set.add(3);
set.add(7);
set.add(-1);

System.out.println(set);

[Java]우선순위큐(PriorityQueue)

sskl660 — Tue, 22 Mar 2022 00:16:56 +0900

우선순위큐(PriorityQueue)

스택은 후입선출, 큐는 선입선출을 특징을 가졌다. 이와 달리 우선순위큐는 사용자가 지정한 우선순위에 의거하여 원소를 꺼내는 특징이 있다.

기본적인 사용

Java에서는 PrioryQueue 클래스를 이미 내부적으로 포함하고 있다. 이는 기본적으로 오름차순으로 수를 꺼낼 수 있도록 구현되어 있다.

PriorityQueue<Integer> pq = new PriorityQueue<>();
pq.offer(5);
pq.offer(3);
pq.offer(9);
pq.offer(1);

while(!pq.isEmpty()) {
	System.out.println(pq.poll());
}

정렬기준 정하기(사용자 정의)

PriorityQueue의 생성하는 단계에서 Comparator 인터페이스를 재정의한다면 원소가 뽑히는 순서(정렬 기준)를 사용자가 원하는대로 재정의할 수 있다.

PriorityQueue<Integer> pq = new PriorityQueue<>(new Comparator<Integer>() {
	@Override
	public int compare(Integer o1, Integer o2) {
		return Integer.compare(o2, o1); // 내림차순 정렬
	}
});
pq.offer(5);
pq.offer(3);
pq.offer(9);
pq.offer(1);

while(!pq.isEmpty()) {
	System.out.println(pq.poll());
}

다음과 같이 Comparator 인터페이스를 생성하면 compare 함수를 재정의하여 원하는 비교 기준을 설정해주어야 한다. 위의 예시에서는 내림차순으로 정렬할 수 있도록 설정하였다.

객체 정렬

위와 같이 내부적으로 정렬 기준을 정하는 것은 다른 객체를 정렬하는 기준을 만들어줄수도 있다. 때문에 2차원 배열과 같은 내용도 정렬이 가능하다.

PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>() {
	@Override
	public int compare(int[] o1, int[] o2) {
		// 만일 2차원 배열의 첫 번째 원소가 같다면, 2번째 원소를 기준으로 내림차순 정렬한다.
		if(o1[0] == o2[0]) {
			return Integer.compare(o2[1], o1[1]);
		}
		// 2차원 배열의 첫 번째 원소를 기준으로 오름차순 정렬한다.
		return Integer.compare(o1[0], o2[0]);
	}
});
pq.offer(new int[] {5, 2});
pq.offer(new int[] {3, 3});
pq.offer(new int[] {1, 4});
pq.offer(new int[] {1, 5});
pq.offer(new int[] {7, 5});

while(!pq.isEmpty()) {
	System.out.println(Arrays.toString(pq.poll()));
}

당연히 객체를 만들고, 객체의 원소를 비교 대상으로 두어 객체의 정렬 기준을 정해주는 것도 가능하다.
- 객체 자체의 정렬 기준을 만들고 싶은 경우에는 정의한 객체에 Comparable 인터페이스를 포함시켜 객체 자체의 정렬 기준을 미리 정해주는 방법도 존재한다.

[Java] 문자열 문제풀이시 자주 사용되는 내용들

sskl660 — Mon, 21 Mar 2022 22:23:34 +0900

String ↔ Integer

// String -> Integer
int num = Integer.parseInt(string);

// Integer -> String
String string = Integer.toString(num);

// Byte, Long, Float, Double 모두 동일한 함수를 가지고 있다.

String ↔ Character

/***
 * String -> Character
 */
String sentence = "15151515";
// 한 글자 변환
char c = sentence.charAt(0);

// 전체 글자 변환
char[] c_arr = sentence.toCharArray();

/***
 * Character -> String
 */
// 한 글자 변환
String string = String.valueOf(c);

// 전체 글자 변환
String string = String.valueOf(c_arr);

Integer ↔ Character

// Integer -> Character
char c =  6 + '0';

// Character -> Integer
int num = c - '0';

부분 문자열 구하기

String string = "Hello World!";
System.out.println(string.substring(0, 5)); // start_idx, end_idx + 1

[Java]최장 공통 부분 수열(LCS, Longest Common Subsequence)

sskl660 — Sun, 11 Jul 2021 18:49:32 +0900

*최장 공통 부분 수열(LCS, Longest Common Subsequence)

->최장 공통 부분 수열이란, 주어진 두 수열이 주어졌을 때 두 수열 모두의 부분 수열이 되는 수열 중 가장 긴 것을 말한다.

->LCS를 구하는 문제는 역시 백준 Gold5 9251 LCS 문제를 기반으로 알고리즘을 설명하도록 하겠다.

※ 문제 주소 : https://www.acmicpc.net/problem/9251

9251번: LCS

LCS(Longest Common Subsequence, 최장 공통 부분 수열)문제는 두 수열이 주어졌을 때, 모두의 부분 수열이 되는 수열 중 가장 긴 것을 찾는 문제이다. 예를 들어, ACAYKP와 CAPCAK의 LCS는 ACAK가 된다.

www.acmicpc.net

->해당 테스트 케이스를 바탕으로 LCS를 이해하면 다음과 같다. 아래 그림을 참고하자.

두 수열의 부분 수열 중 공통 되는 부분 수열의 길이가 가장 긴 것.

*동적 계획법을 활용한 풀이

->Knapsack Problem, LIS와 마찬가지로 해당 블로그에 포스팅한 '동적 계획법 접근 방식'을 바탕으로 문제를 해결하겠다.

※ 참고 : https://sskl660.tistory.com/87

[Java]동적 계획법(Dynamic Programming)

*동적 계획법(Dynamic Programming) ->동적 계획법이란 특정 범위까지의 최적해(상위 문제)를 구하기 위하여 다른 범위까지의 최적해(하위 문제)를 이용하여 효율적으로 해를 구하는 알고리즘 설계

sskl660.tistory.com

1. 문제를 특정한 부분 문제로 생각해보고, 해당 문제를 저장할 dp 테이블을 정의해본다.

(1) 각 문자열이 비교되는 위치에서 가질 수 있는 LCS의 최대 값은 무엇일까?

->LCS 문제 풀이의 기본적인 접근은 위 질문으로부터 시작된다. 주어진 테스트 케이스를 예로 들면, 다음과 같은 느낌을 갖는 다는 것을 이해해보자.

(2) 해당 위치에서 가질 수 있는 LCS의 최대 값을 효과적으로 저장하기 위해, 2차원 배열을 활용하여 값을 저장한다.

->각 문자열이 비교되는 위치에서 가질 수 있는 LCS의 최대 값을 저장한다는 말이 잘 이해되지 않을 것이다. 우선 결론적으로 LCS 문제 해결은 아래 2차원 배열 형태의 dp 테이블을 활용하게 될 것이다. 아래 그림을 참고한다면 조금 더 이해하기 좋을 것이다.

(3) 우선 값을 채워보자

->우선, 첫 번째 문자열에 대하여 두 번째 문자열의 문자를 하나씩 비교하며 테이블을 갱신해보자. 그렇다면 두 번째 문자열의 첫 번째 문자인 'C'와 첫 번째 문자열을 비교하게 될 것이다.

우선 C를 A와 비교한다면 두 문자가 일치하지 않기 때문에, LCS의 값은 1이 된다는 것을 알 수 있다.

두 번째로 C를 C와 비교한다면 두 문자는 일치하므로, 해당 위치에서 가질 수 있는 LCS의 값은 1이 된다는 것을 알 수 있다.

세 번째로 C와 A를 비교하면 두 문자는 일치하지 않는다. 그렇다면 해당 위치에 0을 채워야 할까? dp 테이블의 정의를 다시 살펴보자. 해당 위치의 의미는 두번째 문자열의 첫 문자인 'C'가 첫 번째 문자열의 첫 번째 문자와 두 번째 문자의 비교를 끝내고 세 번째 문자인 'A'와 비교하는 위치이다. 또한, 그 위치에 지금까지 C가 해당 위치에서 가질 수 있는 최대 LCS의 값을 저장해야 한다고 하였다. 따라서, 이전 문자에서 비교했던 최대 값인 1을 그대로 해당 위치에 가져와야함을 알 수 있다.

마찬가지 방식으로 나머지 테이블도 채울 수 있다.

여기서 주의해야 할 점은 첫 번째 문자열과 두 번째 문자열 모두 상호적으로 해당 위치의 의미는 각 문자열이 비교되는 위치에서 가질 수 있는 LCS의 최대 값을 의미한다는 것이다. 우선 나머지 테이블도 채워보도록 하자.

->자, 그럼 이번에는 두 번째 문자열의 두 번째 문자열인 'A'에 대하여 첫 번째 문자열의 모든 문자열을 비교해보도록 하자.

우선 처음부터 A와 A를 비교하므로 문자가 일치한다. 그렇다면 당연히 해당 위치에 적어도 1이라는 값을 가지게 될 것임을 알 수 있다. 그렇다고 무작정 규칙을 생각하지 않으면서 그 값을 넣으면 안된다는 것을 지금까지 여러 다이나믹 프로그래밍 문제를 풀면서 경험적으로 알게 되었다.

그렇다면 이전 문자열의 비교에서 사용된 것 처럼, 이전에 구했던 최대 값을 전이 시키면 되지 않을까? 하지만 0이라는 값을 전이 시키면 해당 위치에는 0이라는 값이 들어갈 것이다. 아직은 정보가 부족하다. 우선 테이블을 채우는 과정을 계속 진행해보자.

우선 두 번째 문자열의 첫 번째 문자인 'C'를 첫 번째 문자열과 비교하며 채워나갔던 것처럼, A와 C는 문자가 서로 일치하지 않으므로 그 값을 전이시켜 두 번째 열을 채웠다.

그렇다면 세번째 열에서도 1을 채워야 하는가? 일단 첫 번째 경우와 다른점은 세 번째 위치에서 A와 A로 문자열이 서로 일치한다는 것이다. 그렇지만, 두 번째 문자열에 현재 위치까지 보유한 A라는 문자는 단 하나 뿐이고, 무턱대고 해당 위치를 + 1해버린다면 두 번째 문자열의 2번째 위치까지 A라는 문자가 두 개라는 것을 의미하게 된다.

또 다른 정보는, 우선 직관적으로 해당 위치에서 각 문자열의 "CA"라는 부분이 공통적을 도출된다는 것을 알 수 있다. 따라서 해당 위치는 최소 2의 값을 가져야 함도 알 수 있다.

자, 여기서 규칙성을 파악해보자. 테이블의 행을 i, 열을 j라고 한다면 해당 위치의 위(i - 1), 왼쪽(j - 1), 왼쪽 위 대각선 (i - 1, j - 1)방향의 정보를 참고할 수 있고 결론적으로 해당 정보들을 바탕으로 현재 위치의 값들을 갱신하게 된다. 그렇다면 각 위치의 정보가 의미하는 바를 분석해보자.

(4) 윗 행(i - 1)의 값이 의미하는 정보

->해당 위치의 바로 윗 행이 의미하는 정보는 두 번째 문자열의 'C'가 해당 위치에서 첫 번째 문자열의 'A'까지 비교하면서 얻은 최대 LCS의 값을 의미한다.

(5) 왼쪽 열(j - 1)의 값이 의미하는 정보

->해당 위치의 바로 왼쪽 열이 의미하는 정보는 첫 번째 문자열의 두 번째 문자인 'C'가 해당 위치에서 두 번째 문자열의 'A'까지 비교하면서 얻은 최대 LCS의 값을 의미한다.

(6) 윗 행(i - 1), 왼쪽 열(j - 1)의 값이 의미하는 정보

->해당 위치의 윗 행, 왼쪽 열이 의미하는 정보는 현재 문자에 대하여 각 이전 문자열의 이전 문자가 해당 위치에서 가질 수 있는 최대 LCS의 값을 의미한다.

(7) 4, 5, 6에서 얻은 정보를 종합해보자.

->우선 우리는 앞서 테이블을 채우는 과정에서 경험적으로 해당 위치의 문자가 같거나, 다르다면 처리를 다르게 해주어야 될 것 같다는 사실을 유추해볼 수 있었다. 이제 그 정보와 앞서 얻은 정보를 결합해 볼 차례이다.

※ 해당 위치의 문자가 일치하는 경우.

앞서 언급한 바와 같이, 해당 문자의 대각선에 위치한 값의 의미는 각 이전 문자열의 이전 문자가 해당 위치에서 가질 수 있는 최대 LCS의 값이라고 하였다. 즉, 현재 문자가 일치한다면 각 문자가 추가되는 위치에서 LCS의 값을 증가시킬 가능성이 존재한다는 것을 의미한다. 따라서 해당 값에 + 1을 하여 해당 테이블을 갱신할 수 있다.

※ 해당 위치의 문자가 일치하지 않는 경우.

->다음 테이블을 채워보자. 이번에는 A와 Y라는 문자가 일치하지 않기 때문에, 대각선 정보는 활용할 수 없다.

일치하지 않기 때문에, 이제 남은 윗 행 정보와 왼쪽 열의 정보를 활용해야 한다는 사실을 알 수 있다. 그리고 그 정의 그대로, 각 첫 번째 문자열과 두 번째 문자열이 지금까지 조사한 최대 LIS의 값 중 더 큰 값을 갖는 것을 선택해야 한다는 것을 유추해볼 수 있다.

따라서 이때는 좌측의 값이 더 크기 때문에, 좌측의 값을 해당 테이블에 갱신해주는 것이다.

2. 부분 문제의 관계를 생각하며 점화식을 도출한다.

->즉, 해당 위치의 문자가 일치하느냐의 여부에 따라서 다른 점화식을 적용하여 해당 위치의 값을 갱신해야 된다는 것을 이해할 수 있다. 따라서 다음과 같은 점화식을 도출할 수 있을 것이다.

3. 점화식을 바탕으로 dp 테이블을 갱신하면서 최종적으로 전체 문제를 해결한다.

->우선 해당 점화식을 진행하기 위해서는 서로 문자가 없는 상태에서 시작하는 경우도 고려(기저 조건)해야 하기 때문에 기존 배열에 패딩을 추가하여 0으로 초기화 해줘야 한다는 사실을 알 수 있다(문자가 없는 경우 비교를 수행해도 일치하는 문자는 없기 때문에 0).

이렇게 각 테이블을 채우고 dp[B문자열의길이][A문자열의길이]가 의미하는 것은 B문자열의 K라는 문자가 A문자열의 P라는 문자까지 비교하며 얻은 최대 LCS의 값을 의미하게 된다. 따라서 해당 값을 출력하면 된다.

4. 구현

->위의 규칙을 그대로 코드로 옮기면 된다. 아래 코드를 참고하자.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class LCS {
	static char[] A, B;
	static int[][] dp;
	static int max = 0;
	
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 각 문자열을 입력 받는다.
		String a = br.readLine();
		String b = br.readLine();
		// 각 문자열의 길이가 다르므로 따로 저장해둔다.
		int alength = a.length();
		int blength = b.length();
		// 각 문자열을 나눠서 저장할 char 배열.
		A = new char[alength + 1];
		B = new char[blength + 1];
		// 각 문자열을 char 배열에 문자 하나씩 옮겨 담는다.
		for(int i = 1; i <= alength; i++) {
			A[i] = a.charAt(i - 1);
		}
		for(int i = 1; i <= blength; i++) {
			B[i] = b.charAt(i - 1);
		}
		
		// 각 문자의 비교가 끝났을 때, 해당 위치에서 가질 수 있는 LCS의 값을 저장할 2차원 dp테이블을 정의한다.
		// 첫 행에서도 이전 문자를 참고할 수 있도록 패딩을 준다.
		dp = new int[blength + 1][alength + 1];
		
		// B의 모든 문자열을 A문자열과 비교
		for(int i = 1; i <= blength; i++) {
			for(int j = 1; j <= alength; j++) {
				// 만일 두 문자가 같은 경우
				if(B[i] == A[j]) {
					// 대각선의 값을 참고하여 LCS의 값을 + 1한다.
					dp[i][j] = dp[i - 1][j - 1] + 1;
				}
				// 두 문자가 다른 경우
				else {
					// 각 문자열의 이전 문자 중 최대 LCS값을 선택.
					dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
				}
			}
		}
		
		// 최종으로 탐색한 위치에 LCS의 최대 값이 저장되어 있을 것이다.
		System.out.println(dp[blength][alength]);
	}
}

->두 문자열의 각 문자를 비교하는 과정을 수반하기 때문에, O(N^2)의 시간복잡도를 갖게 된다.

※ 여기까지가 다이나믹 프로그래밍에서 가장 유명한 3가지 예제 였다(Knapsack, LIS, LCS). 이는 다이나믹 프로그래밍이 무엇인지 감을 잡기 좋은 예제들이고, 몇몇 문제에서는 이곳에서 배운 논리를 기반으로 문제를 출제하기도 하므로 기본적인 예제에 대한 이해는 반드시 해두도록 하자.

[Java]최장 증가 부분 수열(LIS, Longest Increasing Subsequence)

sskl660 — Sun, 11 Jul 2021 17:19:06 +0900

*최장 증가 부분 수열(LIS, Longest Increasing Subsequence)

->최장 증가 부분 수열이란, 주어진 수열에서 오름차순으로 정렬된 가장 긴 부분 수열을 찾는 문제이다. 여기서 부분 수열은 연속적이거나, 유일할 필요는 없다.

->아래 그림을 참고하여 이해하도록 하자.

증가하는 부분 수열. 수열이 연속적일 필요는 없다.

최장 증가 부분 수열. 해당 수열에서 찾을 수 있는 가장 긴 부분 수열이다.

해당 예시로 주어진 배열에서는 가장 긴 증가하는 부분 수열(이하 LIS)은 1, 2, 3, 7임을 직관적으로 알 수 있다.

->LIS를 구하는 문제는 Knapsack, LCS와 더불어 다이나믹 프로그래밍의 기초를 다지는데 자주 사용되는 예제 중 하나이다. 이 문제 역시 백준 Silver2 11053 가장 긴 증가하는 부분 수열 문제를 기반으로 알고리즘을 설명하도록 하겠다.

※ 문제 주소 : https://www.acmicpc.net/problem/11053

11053번: 가장 긴 증가하는 부분 수열

수열 A가 주어졌을 때, 가장 긴 증가하는 부분 수열을 구하는 프로그램을 작성하시오. 예를 들어, 수열 A = {10, 20, 10, 30, 20, 50} 인 경우에 가장 긴 증가하는 부분 수열은 A = {10, 20, 10, 30, 20, 50} 이

www.acmicpc.net

※ 이 문제 역시 백 트래킹을 활용하여 문제를 해결할 수 있지만, 해당 풀이는 O(2^N)의 시간 복잡도를 갖기도 하고 Knapsack Problem과 유사한 논리를 바탕으로 풀이할 수 있기 때문에 생략하도록 하겠다.

*동적 계획법을 활용한 풀이 : O(N^2)

->먼저, 비교적 이해하기 쉬운 동적 계획법을 활용한 풀이를 바탕으로 문제를 해결해보자. 해당 풀이는 O(N^2)의 시간 복잡도를 가지고 있다.

->Knapsack Problem과 마찬가지로 해당 블로그에 포스팅한 '동적 계획법 접근 방식'을 바탕으로 문제에 접근해보겠다.

※ 참고 : https://sskl660.tistory.com/87

[Java]동적 계획법(Dynamic Programming)

sskl660.tistory.com

1. 문제를 특정한 부분 문제로 생각해보고, 해당 문제를 저장할 dp 테이블을 정의해본다.

(1) 해당 수열의 i번째 원소의 위치에서 가질 수 있는 LIS의 값은 무엇일까?

->문제에 따르면 수열의 크기가 N인 배열이 입력으로 주어질 것이고, 우리는 우선 간단하게 N개의 원소 중 1번째, 2번째, 3번째... N번째 위치 해당 원소가 가질 수 있는 LIS의 값을 부분 문제로 생각해볼 수 있다.

->따라서, 해당 위치에서 해당 원소가 가질 수 있는 LIS의 값을 저장할 1차원 dp 테이블을 만들고 문제에 접근해보자. 아래 그림을 참고하도록 하자.

dp 테이블의 원소의 값은 배열의 해당 위치의 원소에서 가질 수 있는 LIS의 값을 의미한다.

->우선, 첫 번째 원소부터 생각해보자. 10이라는 원소가 가질 수 있는 LIS의 값은 우선 본인 그 자체의 길이를 생각할 수 있다. 따라서 dp[1]의 값은 1로 채울 수 있음을 알 수 있다.

->다음으로 두 번째 원소 20을 살펴보자. 우선, 첫 번째 원소와 마찬가지로, 20은 본인 그 자체의 길이를 바탕으로 초기화가 가능하기 때문에 1이라는 값으로 초기화할 수 있음을 알 수 있다. 이로부터 우선 해당 테이블의 원소에 dp 값을 채울 때 원소의 값을 1로 초기화할 수 있음을 유추해볼 수 있다.

하지만 우리는 우선 직관적으로 해당 위치에서 LIS의 값이 1로 설정되면 안된다는 것을 알고있다. 이전 원소(10)에 비하여 증가하는 상태이므로 해당 위치의 값은 2로 설정되어야 한다는 것을 알 수 있다.

우선 이 단계에서 부터 지금까지 기억해둔 dp 테이블에 저장된 값과 비교하여 규칙성을 찾을 수 있다면 좋겠지만 그 관계를 유추하기 쉽지 않을 것이다. 우선 다른 원소들도 차근차근 채워보자.

->다음으로 세 번째 원소인 10을 살펴보자. 마찬가지로 본인의 길이를 바탕으로 해당 위치를 1로 설정한다.

두 번째 원소를 채울 때와는 다르게, 해당 위치에서는 직관적으로 보아도 그 값이 갱신될 가능성이 없어보인다. 따라서, 해당 테이블은 1로 채우고 넘어갈 수 있음을 알 수 있다.

->다음으로 네 번째 원소인 30을 살펴보자. 마찬가지로 해당 위치는 1로 초기화가 가능할 것이다.

하지만 직관적으로 보았을 때, 해당 위치는 10, 20이후 30이라는 증가된 부분 수열을 이룰 수 있는 위치이기 때문에 해당 위치의 값이 3이 되어야 한다는 것을 알 수 있다.

자, 이제 규칙성을 파악해보자. 우선 dp 테이블에 저장되는 값은 해당 원소의 위치에서 가질 수 있는 LIS의 값이었다는 것을 잊어서는 안된다. 그렇다면 그 값 들을 어떻게 활용할 수 있을까?

우선 30이라는 값은 앞선 원소들(10, 20, 10)에 비하여 큰 값을 가지고 있음을 알 수 있다. 즉, 어떤 원소가 오더라도 해당 원소 뒤에 추가 되면서 최장 증가 부분 수열이 될 수 있음을 나타낸다고 이해할 수 있다. 근데 우리가 dp 테이블에 저장한 값은 해당 원소의 위치에서 가질 수 있는 LIS의 길이였다. 즉, 해당 위치에서 앞 원소들에 비하여 증가할 가능성이 존재한다면, 해당 위치의 LIS의 값에 자신의 길이를 +1 해주면 된다는 것을 파악할 수 있다.

즉, 다시 처음부터 자신의 길이인 1로 채우는 경우(초기화)부터 생각해보자.

우선 1번째 원소(10)에 대하여 30이라는 수는 부분 수열의 길이를 증가시킬 수 있으므로 dp[1] + 1의 값을 dp[4]의 값 후보에 올릴 수 있다.

마찬가지로 2, 3번째 원소(20, 10)에 대하여 30이라는 수는 부분 수열의 길이를 증가시킬 수 있으므로 dp[2] + 1, dp[3] + 1의 값을 dp[4]의 값 후보에 올릴 수 있다.

자, 그렇다면 이제 본인의 길이 1과 1, 2, 3번째 원소에 대하여 본인을 추가시킨 LIS의 길이 중 가장 큰 값은 무엇인가? 이는 2번째 원소로부터 본인의 길이를 추가시킨 3이 될 것임을 알 수 있다. 따라서 해당 위치의 값은 3이 되는 것이다.

->다음으로 5번째 원소인 20에 대하여 생각해보자. 앞선 논리를 이해했다면 해당 규칙을 그대로 적용시키기만 하면 5번째 원소의 위치에서의 LIS의 값은 쉽게 구할 수 있다. 우선, 본인의 길이인 1로 해당 원소의 값을 채운다.

이때, 20이라는 값은 앞선 원소(10, 20, 10, 30)에 대하여 그 값이 10인 경우(1번째, 3번째 원소)에 대해서만 부분 수열의 길이가 증가할 가능성이 있다. 따라서, 해당 위치의 LIS의 값에 본인의 길이를 + 1한 경우만 후보에 올라갈 수 있다.

당연히 이 값 중 가장 큰 값은 2가 될 것이고, 해당 위치에는 2라는 값으로 채워질 것임을 알 수 있다. 직관적으로 보아도 해당 위치에서 가질 수 있는 LIS의 값은 2가 되는 것을 알 수 있다.

->마지막 원소인 50역시 마찬가지 논리로 생각하면 dp[4]의 값을 활용하여 최종적으로 dp[6] = 4가 됨을 알 수 있다.

2. 부분 문제의 관계를 생각하며 점화식을 도출한다.

->위의 규칙성을 점화식으로 세워보자. 우선, 해당 원소의 위치에 방문할 때 마다 해당 위치의 길이는 본인의 길이로 초기화 할 수 있다는 사실을 기반으로 dp[i] = 1로 초기화(기저 조건)할 수 있다는 것을 알 수 있다.

->또한, 방문한 원소의 위치의 모든 앞 원소에 대하여 부분 수열의 길이가 증가할 가능성이 존재(Arr[i] > Arr[1]...Arr[i - 1인 모든 경우)한다면, 해당 위치의 dp 테이블의 값에 + 1(본인의 길이)을 한 값이 dp[i]의 후보가 될 수 있다는 사실을 기반으로 점화식을 세울 수 있다. 즉 아래와 같은 식을 세울 수 있다.

3. 점화식을 바탕으로 dp 테이블을 갱신하면서 최종적으로 전체 문제를 해결한다.

->여기에서는 Knapsack Problem과 다르게, dp[N]의 값을 최종 답안으로 도출하면 안된다! dp 테이블의 정의를 다시 살펴보면 dp 테이블에 저장된 값은 해당 위치에서 '해당 원소가' 가질 수 있는 LIS의 값이었지, 해당 수열에서 가질 수 있는 LIS가 아니었다는 것에 주의해야 한다. 위의 예시에서 5, 6번째 위치를 바꿔 생각해보면 이해하기 쉽다. 아래 그림을 참고하자.

4. 구현

->지금까지 살펴본 바와 같이, 규칙성과 기억된 값(dp 테이블)을 적절히 활용하는 방법을 충분히 이해하였다면 코드를 작성하는 것은 매우 간단하고 쉬운 일이다. 아래 코드를 참고하도록 하자.

import java.util.Scanner;

public class LIS_DP1 {
	static int N;
	static int[] arr;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		arr = new int[N];
		for (int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
		}

		// 각 위치에서의 LIS를 저장할 1차원 dp 테이블을 정의한다.
		int[] dp = new int[N];
		// 최대 LIS의 값.
		int max = 1;

		// 첫 번째 원소부터 N번째 원소까지 dp 테이블의 값을 채워 나간다.
		for (int i = 0; i < N; i++) {
			// 우선 해당 위치를 본인의 길이(1)로 초기화한다.
			dp[i] = 1;
			// 현재 원소의 위치에 대하여, 앞의 원소의 값을 비교하며 값을 갱신한다.
			for (int j = 0; j < i; j++) {
				// 만일 부분 수열이 증가할 가능성이 있다면
				if (arr[j] < arr[i]) {
					// dp 테이블에 저장된 LIS를 바탕으로 가장 큰 값을 dp[i]의 값으로 갱신한다.
					dp[i] = Math.max(dp[i], dp[j] + 1);
				}
			}

			// 전체 수열에서 LIS의 값을 갱신한다.
			max = Math.max(max, dp[i]);
		}

		System.out.println(max);
		sc.close();
	}
}

->해당 로직을 이해했다면 알 수 있겠지만, 각 위치에서 모든 앞 원소를 참고하는 2중 for문으로 구성되기 때문에 O(N^2)의 시간 복잡도를 갖는 것이다.

*동적 계획법을 활용한 풀이 : O(NlogN)

->이번에 살펴볼 방법은 직관적으로 이해하기도 힘들고, 이분 탐색을 활용하기 때문에 난이도가 있는 풀이라고 할 수 있겠다. 그래서 이해가 잘 안 되는 것이 당연하지만.. 우선 아이디어의 컨셉부터 살펴 보자.

->앞선 방법을 이용하면, 각 원소의 위치를 조사할 때 마다 앞의 모든 원소를 탐색하는 과정을 거쳐야 했다. 따라서 O(N^2)이라는 시간 복잡도를 가지게 되었고, 이번에 사용하려는 방법에서는 앞의 모든 원소를 탐색하는 과정을 O(logN)까지 줄여볼 수 있지 않을까? 라는 물음에서 출발한다.

1. 문제를 특정한 부분 문제로 생각해보고, 해당 문제를 저장할 dp 테이블을 정의해본다.

(1) 현재 위치에서 부분 수열의 길이가 추가될 가능성이 있는가?

->앞의 해결 방법에서는 앞의 모든 원소의 크기와 비교하면서 현재 위치에서 부분 수열의 길이가 추가될 가능성이 있는지 파악하였다. 하지만 이 방법에서는 조금 다른 방법으로 그 가능성을 찾는다.

(2) 현재까지 조사한 앞 원소들에 대하여, 부분 수열을 만들 수 있는 최적의 수 조합을 저장해보자.

->예를 들어 i번째 원소를 조사한다고 생각했을때 1 ~ i - 1번째 원소에 대하여 i번째 원소가 부분 수열의 길이를 증가시킬 가능성이 있는지 생각하기 위해서, 1 ~ i - 1번째 원소에서 i번째 수가 부분 수열을 만들 수 있는 가능성을 쉽게 파악할 정보를 제공할 배열을 만든다는 이야기이다. 그런데 신기하게도 이 방법에서 이 배열은 만들어진다면 그 가능성을 쉽게 파악할 수 있을 뿐 만 아니라, 그 배열의 총 길이 자체가 LIS의 값이 된다!

->실제 테스트 케이스를 바탕으로 그림을 보면서 이해해보자. 우선 i번째 위치에서 1차원 dp 테이블에 채워진 원소의 총 길이는 '전체 수열에서 해당 위치에서 가질 수 있는' LIS의 길이를 의미하고, 원소의 값들은 i번째 원소가 부분 수열의 길이를 늘릴 가능성이 있는지 파악할 원소로 구성되어 있다. 여기에서 주의할 점은 앞 방법과 다르게 해당 위치에서 기록된 dp배열의 길이 그 자체가 전체 문제(최종 LIS의 값)의 최적해가 된다는 사실이다.

->우선 첫 번째 원소부터 생각해보면, 당연히 10이라는 값 자체를 dp[1]에 대입해주면된다. 그렇다면 테이블의 정의에 따라 1번째 원소에서 채워진 원소의 총 길이는 1로 LIS의 길이와 같고, 뒤에 조사할 수들이 부분 수열의 길이를 늘릴 가능성이 있는 정보를 제공해준다.

->다음으로 두 번째 원소를 생각해보자. 2번째 위치에서 LIS의 값은 2이기 때문에, dp[2]는 20을 채우는 것이 당연할 것이다. 또한 이 값들이 이후 3 ~ 6번째 원소의 부분 수열의 길이를 늘릴 가능성이 있는지 파악할 정보가 된다는 것을 기억하라.

->세 번째 원소부터가 중요하다. 우선, 우리가 아는 바로는 3번째 원소의 위치에서 LIS는 2가 되어야한다. 왜냐하면, 3번째 위치에서 전체적으로 가질 수 있는 LIS의 최대 값은 이전에 10, 20으로 구성된 부분 수열의 길이를 저장하면 되기 때문이다.

따라서, dp의 원소는 따로 조작할 필요가 없어보인다. 대신, dp에 구성된 원소는 다음 원소가 부분 수열의 길이를 늘릴 가능성이 있는 정보를 제공한다고 하였다. 우선 이해가 잘 안되겠지만, 현재 위치의 원소의 값이 dp에 저장된 값들 보다 같거나 작은 값이 있다면, 해당 값들 중 가장 작은 값의 위치와 원소를 교환하고 다음 과정을 진행한다고 알아두고 넘어가자.

->다음은 네 번째 원소이다. 우선, 4번째 위치에서 가질 수 있는 LIS는 3임을 알 수 있다(10, 20, 30으로 부분 수열이 구성됨). 따라서, dp[3]에 30이라는 값이 추가되는 것이 자연스러울 것인데 여기서부터는 어떤 규칙을 바탕으로 dp테이블에 원소를 넣는지 이해해보자.

우선 우리는 지금까지 Arr 배열에 주목하여 30이 부분 수열의 길이를 늘릴 수 있는지 판단하였다. 하지만 앞서 말했듯이 뭔지는 모르겠지만 dp 테이블의 원소들의 값은 30이 부분 수열의 길이를 늘릴 수 있는지 판단할 정보를 제공하고 있다고 하였다. 우리가 Arr 배열을 보면서 판단한 정보는 부분 수열 10, 20이 현재 가장 긴 LIS를 갖는 수열임을 확인했을 것이다. 그런데 확인해보면 dp 배열에도 10, 20의 값이 저장되어 있음을 알 수 있다. 우리는 이 정보로부터 30이라는 숫자가 부분 수열의 길이를 늘릴 가능성이 있음을 파악할 수 있다. 그런데 여기서 주의할 점은, dp 배열에 저장된 값들이 현재까지 원소들을 조사하며 만들어진 LIS 배열 그 자체라고 생각하면 안된다.

->우선 5번째 원소에 대하여 dp배열을 계속 추가해보자. 마찬가지로, 해당 위치에서 가질 수 있는 LIS는 4일 것이고, 앞에서 구성된 부분 수열 중 가장 긴 부분 수열은 10, 20, 30으로 구성된 것으로 보아 dp[4]에 50이라는 값을 추가해주면 된다는 것을 알 수 있다. dp 배열에 저장된 원소를 확인해보면, 50이라는 값이 dp 배열에 저장된 모든 원소보다 큼을 알 수 있다.

->마지막으로 6번째 원소인 20을 다시 살펴보자. 이번에는 dp 배열을 참고해보았을 때, 저장된 값들 모두에 대하여 20이 크다는 보장이 없다. 3번째 원소때와 마찬가지로 현재 위치의 원소의 값이 dp에 저장된 값들 보다 같거나 작은 값이 있다면, 해당 값들 중 가장 작은 값의 위치와 원소를 교환하는 작업을 진행해준다.

->자, 어떻게든 이 과정을 따라오며 dp 테이블을 갱신하는 과정을 진행해보았고 결론적으로 dp에 구성된 원소의 길이는 4로, 우리가 구하고자 했던 LIS의 값 4와 일치한다는 것을 확인할 수 있다. 그런데 왜 이런일이 가능한 것일까?

(3) dp 테이블에 최적의 수 조합을 저장한다?

->앞 과정은 우선 dp 테이블을 갱신하는 과정이 어떻게 진행되는지 무지성으로 따라하며 보여준 것이고, 이번에는 테스트 케이스를 달리하여 이해해보도록하자. 아래 그림을 보자.

앞서 갱신한 논리를 바탕으로 2번째 원소까지 dp 테이블을 갱신하면, 다음과 같은 값들을 저장함을 알 수 있을 것이다.

->그렇다면 바로 세 번째 원소 50에 대하여 갱신을 진행해보자. 앞선 논리를 바탕으로 한다면, dp에 저장된 모든 원소에 대하여 작은 부분 중 가장 작은 값의 위치와 해당 값을 바꿔줘야 하므로, 다음과 같이 갱신이될 것이다.

->네 번째 원소도 마찬가지로 갱신하면 다음과 같이 갱신이 될 것이다.

만일 이러한 갱신이 진행되지 않는다면 어떻게 될까? 우선 직관적으로 보았을 때, 해당 수열에서 최종 LIS 배열은 {10, 15, 20, 30}으로 구성될 것을 알 수 있다. 그리고 우리는 dp 배열 만을 바탕으로 현재 위치의 수가 부분 수열의 길이를 늘릴 가능성이 있는지 파악하겠다고 하였다. 하지만 앞선 갱신과정이 진행되지 않는다면, 2번째 원소의 위치에는 100이라는 값이 저장되어 있을 것이고 뒤에오는 수인 15, 20, 30은 dp 배열만 보았을 때 부분 수열의 길이를 늘릴 여지가 없음을 알 수 있다.

또 반대로 이런 갱신이 이루어 졌다면 2번째 원소의 위치는 위 그림과 같이 15로 갱신이 될 것이고, 그 뒤에 오는 수인 20, 30이 dp 배열만 보고도 부분 수열의 길이를 늘릴 여지가 있다는 것을 확인할 수 있다.

따라서 이런 갱신을 진행해주는 것이다. 다만 이때 주의할 것은 저장된 원소가 LIS 배열 그 자체를 의미하지는 않는다고 하였다. 예를 들어 아래 수열을 바탕으로 LIS를 생각해보자.

그림에서 확인해보면 LIS 배열은 {10, 20, 30}이 되는 것을 확인할 수 있는데, dp 배열에 저장된 수들과 일치하지 않음을 알 수 있다.

(4) 이게 왜 되는겨..?

->아무튼 이 과정들을 진행하면 최종적으로 dp 배열에 채워진 원소의 값들이 LIS 배열 자체를 의미하지는 않더라도, dp 배열의 길이 자체는 LIS의 길이가 됨을 경험적으로 확인할 수 있었다. 계속해서 강조하지만, 해당 배열의 길이는 LIS를 의미하지만 구성된 원소는 다음 원소가 부분 수열의 길이를 늘릴 수 있는 가능성을 보여줄 최적화된 정보라고 하였다. 이 사실을 잊지 말고 최근에 본 예시를 바탕으로 수열을 추가해보자.

위에 제시한 예시에서, 마지막에 20이라는 수가 추가되었다면 같은 논리에 의하여 dp[3]의 값은 20으로 교체될 것이다. 여기서 우리는 교체 된다는 사실에 주목하여야 한다. 우선 어차피 '교체'가 일어난다면, 해당 dp 원소의 최종 길이(= LIS = 3)는 변화가 없을 것이다.

두 번째는 정보 제공의 문제이다. 이 '교체'로 인하여 이후 추가될 원소들에게 부분 수열의 길이가 늘어날 가능성이 있는지 정보를 제공해주었다! 아래 그림을 참고하면 이해하기 쉬울 것이다.

우리는 지금까지 {10, 20, 30}이라는 부분 수열을 생각하고 있었지만 해당 갱신으로 인하여 자연스럽게 {10, 15, 20}이라는 부분 수열이 이후 부분 수열의 길이를 늘릴 때 더 최적의 정보를 제공한다는 것을 알게 되었다.

즉, 가장 작은 증가 폭을 갖는 부분 수열을 시시각각 갱신해주는 것이 이후 부분 수열의 길이를 늘릴 때 유용할 것이고 어차피 교체가 일어나는 과정에서 LIS의 길이는 변화하지 않기 때문에 dp에 구성된 원소를 기준에 맞게 갱신하는 것은 상관없다는 것이다. 어떻게 이런 아이디어를 생각해 낸 것일까..? 난 못할듯..

2. 부분 문제의 관계를 생각하며 점화식을 도출한다.

->자, 앞의 규칙성을 이해하였다면 점화식을 도출하는 것은 역시 간단하다. 우선, 원소를 추가할 때 마다 현재까지 저장된 dp를 탐색하며 해당 원소보다 큰 값을 갖는 원소가 있는지 탐색한다.

->이때 그런 값을 찾았다면, 그런 값들 중 가장 작은 값과 해당 원소의 위치를 교체해주고, 그런 값을 찾지 못했다면, dp 배열에 채워진 원소의 가장 마지막 부분에 해당 원소를 추가해주는 작업을 반복적으로 진행해주면 된다.

->이때, dp 에 저장된 원소들은 '오름차순'으로 정렬되어 있다는 사실을 알 수 있고 이 때문에 초기에 고려했던 앞 부분을 탐색하는 과정을 '이분 탐색'을 바탕으로 O(LogN)으로 줄일 수 있다. 따라서, 해당 알고리즘을 사용하면 시간 복잡도는 모든 원소(N개)에 대하여 탐색하는 과정을 O(LogN)만큼 반복하므로 총 O(NLogN)을 가진다는 것을 확인할 수 있다.

3. 점화식을 바탕으로 dp 테이블을 갱신하면서 최종적으로 전체 문제를 해결한다.

->초기에 설정한 바와 같이 최종 dp 테이블에 채워진 원소의 길이 = LIS임을 확인할 수 있다. 따라서 dp테이블에 실질적으로 저장된 원소의 값들의 길이를 출력해주면 된다.

4. 구현

->이 논리는 이해하기도 힘들고, 또 구현하는 과정에서 이분 탐색을 활용해야하기 때문에 구현하는 과정도 기존 dp에 비하여 간단하지 않다. 아래 코드를 참고하도록 하자.

import java.util.Scanner;

public class LIS_DP2 {
	static int N;
	static int[] arr, dp;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		arr = new int[N];
		for (int i = 0; i < N; i++) {
			arr[i] = sc.nextInt();
		}

		// dp에 실질적으로 저장된 원소의 길이 = LIS인 1차원 dp테이블을 만든다.
		// 해당 dp에 저장된 원소(0이 아닌 값)들은 이후 조사하는 원소들이 부분 수열을 늘릴 수 있을지에 대한 정보를 제공한다.
		dp = new int[N];
		// 처음에 저장된 원소는 없으므로, LIS = 0이다.
		int LIS = 0;

		// 첫 번째 원소부터 N번째 원소까지 dp 테이블의 값을 채워 나간다.
		for (int i = 0; i < N; i++) {
			// 이분 탐색을 활용하여 dp테이블에 저장된 원소를 탐색하며 현재 선택된 숫자가 dp테이블의 어떤 위치에 포함될지 파악한다.
			int idx = BinarySearch(arr[i], 0, LIS, LIS + 1);
			
			// 찾지 못한 경우
			if(idx == -1) {
				// 가장 마지막 위치에 원소를 삽입하고 LIS의 길이를 늘린다.
				dp[LIS++] = arr[i];
			}
			// 찾은 경우
			else {
				// 해당 위치에 현재 값을 삽입하여 갱신한다.
				dp[idx] = arr[i];
			}
		}
		
		// LIS의 길이를 출력한다.
		System.out.println(LIS);

		sc.close();
	}

	private static int BinarySearch(int num, int start, int end, int size) {
		int res = 0;
		while (start <= end) {
			// 중앙 값을 찾는다.
			int mid = (start + end) / 2;

			// 만일 현재 선택된 원소가 해당 원소보다 작거나 같다면, 앞 부분을 탐색한다.
			if (num <= dp[mid]) {
				// 해당 원소의 위치를 기억해둔다.
				res = mid;
				end = mid - 1;
			}
			// 만일 현재 선택된 원소가 해당 원소보다 크다면, 뒷 부분을 탐색한다.
			else {
				start = mid + 1;
			}
		}

		// dp테이블에서 삽입될 위치를 찾지 못한 경우(즉, 모든 수들보다 큰 경우).
		if (start == size) {
			return -1;
		}
		// dp테이블에서 삽입될 위치를 찾은 경우.
		else {
			return res;
		}
	}
}

->해당 문제의 최대 수열의 크기가 N이기 때문에 시간에서 큰 차이가 나지 않아보이지만, 입력 값이 클 수록 그 차이는 더 확연해 질 것이다.

1번 풀이 : 아래, 2번 풀이 : 위

※ 여기까지가 다이나믹 프로그래밍의 대표적인 예제인 LIS에 관한 설명이다. 오히려 Knapsack Problem보다 2번째 풀이에서는 격이 다른 어려움을 느꼈을지도 모른다. 계속해서 얘기하지만 당연하다. 사실 나도 잘 이해를 못하겠다 어떻게 이런 생각을 하는지.. 아무튼 이 문제로 부터는 정보를 어떻게 저장할 것이고, 그 정보를 어떻게 활용할 수 있느냐에 대한 인싸이트를 얻어볼 수 있다.

[Java]배낭 문제(Knapsack Problem)

sskl660 — Sun, 11 Jul 2021 02:32:49 +0900

*배낭 문제(Knapsack Problem)

->배낭 문제는 조합 최적화의 유명한 문제로, 배낭에 담을 수 있는 무게의 최댓값이 정해져 있는 경우, '일정 가치'와 '무게'가 있는 짐들을 배낭에 넣을 때 가치의 합이 최대가 되로록 짐을 고르는 방법을 찾는 문제이다.

※ 조합 최적화란 쉽게 말해 모든 조합의 경우의 수를 고려하지 않고, 최적화하여 조합의 경우의 수를 줄이는 것을 말한다.

->배낭 문제는 두 가지로 나눌 수 있다.

(1) 분할가능 배낭문제(Fractional Knapsack Problem)

->짐을 쪼갤 수 있다는 가정을 둔다. 예를 들어, 물건이 4kg이고 가치가 8이라면 물건을 2kg으로 나눠 가치가 4인 경우로 분할 해 배낭에 담을 수 있다고 생각하면 된다.

->해당 문제는 그리디 알고리즘을 활용하여 해결할 수 있다.

(2) 0-1 배낭문제(0-1 Knapscak Problem)

->짐을 쪼갤 수 없다는 가정을 둔다. 예를 들어, 물건이 4kg이고 가치가 8이라면 물건은 분할 불가능하고 그 무게와 가치 그대로 배낭에 담을 수 있다고 생각하면 된다.

->해당 문제는 동적 계획법을 활용하여 해결할 수 있다.

*0-1 배낭 문제(0-1 Knapsack Problem)

->앞서 설명한 바와 같이 물건을 쪼갤 수 없는 경우를 가정하고 배낭에 물건을 담아 얻을 수 있는 최대 가치를 구하는 문제이다. 즉, 물건을 넣거나(1) 빼거나(0)라는 의미를 강조하기 위해 0-1 배낭 문제라는 이름이 붙었다.

※ 0-1 배낭 문제와 다이나믹 프로그래밍 : 앞서 설명한 바와 같이 0-1 배낭 문제는 동적 계획법을 활용하여 문제를 해결할 수 있다. 여기서는 백준의 Gold5 12865 평범한배낭 문제를 예로 들어 알고리즘을 설명하도록 하겠다. 해당 문제 자체가 0-1 배낭 문제를 나타낸다고 보면 된다.

※ 문제 주소 : https://www.acmicpc.net/problem/12865

12865번: 평범한 배낭

첫 줄에 물품의 수 N(1 ≤ N ≤ 100)과 준서가 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어진다. 두 번째 줄부터 N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)

www.acmicpc.net

*백 트래킹을 활용한 풀이

->동적 계획법을 활용하기 전에, 가장 일반적으로 생각해볼 수 있는 방법은 백트래킹 패러다임을 적용해보는 것이다. 물건이 들어있거나, 들어 있지 않거나(부분 집합의 논리)를 바탕으로 모든 경우를 탐색해서 문제를 해결할 수 있다. 아래 코드를 참고해보도록 하자.

import java.util.Scanner;

public class KnapSack_BackTracking {
	static int N, K;
	static int[][] items;
	static int max;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		K = sc.nextInt();
		// 물건 당 첫 번째 열에는 물건의 무게를, 두 번째 열에는 물건의 가치를 저장한다.
		items = new int[N][2];
		for (int i = 0; i < N; i++) {
			items[i][0] = sc.nextInt();
			items[i][1] = sc.nextInt();
		}
		max = 0;

		// DFS 탐색을 활용하여 모든 경우를 고려해본다.
		dfs(0, 0, 0);
		System.out.println(max);
		sc.close();
	}

	private static void dfs(int depth, int weight, int val) {
		// 모든 물건을 확인하였으면 최종 물건의 가치를 확인하고 재귀를 종료한다.
		if (depth == N) {
			// 현재까지의 최대 가치보다 크다면 값 갱신.
			max = Math.max(max, val);
			return;
		}
		// 물건을 포함할 수 있는 경우 포함하고 재귀를 진행한다.
		if (weight + items[depth][0] <= K) {
			dfs(depth + 1, weight + items[depth][0], val + items[depth][1]);
		}
		// 물건을 포함하지 않고 재귀를 진행한다.
		if (weight <= K) {
			dfs(depth + 1, weight, val);
		}
	}
}

->주어진 테스트 케이스를 적용해보면, 가방에 조합이 가능한 모든 경우를 고려해보면서 재귀가 진행되는 것을 확인할 수 있을 것이다. 또한, 모든 경우를 고려하였기 때문에 시간이 충분하다면 정확한 결과를 도출할 것이다.

->하지만 문제는 당연히 시간이다. 이 방식의 경우 물건을 선택하거나, 선택하지 않는 부분 집합의 논리를 사용하기 때문에 O(2^N)의 지수 시간 복잡도를 갖는다. 즉, 문제에서 주어진 것 처럼 N이 100인 경우에는 2^100번 정도의 연산을 진행해야만 문제를 해결할 수 있다! 따라서 코드를 제출해보면 시간 초과가 발생하는 것을 확인할 수 있을 것이다.

*동적 계획법을 활용한 풀이(2차원 dp 테이블 사용)

->이번에는 동적 계획법을 사용하여 문제를 풀이해보자. 해당 블로그에 포스팅한 '동적 계획법 접근 방식'을 바탕으로 문제에 접근해보겠다.

※ 참고 : https://sskl660.tistory.com/87

[Java]동적 계획법(Dynamic Programming)

sskl660.tistory.com

1. 문제를 특정한 부분 문제로 생각해보고, 해당 문제를 저장할 dp 테이블을 정의해본다.

(1) 물건 1개를 넣을 때, 각 무게(1 ~ K)당 가질 수 있는 최대 가치는 무엇일까?

->우선 물건은 한 개만 존재한다고 가정해보고, 각 무게당 넣을 수 있는 물건의 최대 가치를 생각해보는 것이다. 예를 들어 테스트 케이스에서 주어진 물건 중 무게가 6이고 가치가 13인 물건에 대해서만 생각해보면 아래 테이블과 같이 생각해볼 수 있다.

1부터 7까지의 무게에서, 무게는 6이고 가치는 13인 물건을 넣을 때 각 무게에서의 최대 가치는?

->우선 무게가 1인 경우, 해당 물건을 넣을 수 없으므로 다음과 같이 테이블을 채울 수 있을 것이다.

->다음으로 무게가 2인 경우도 마찬가지로 물건을 넣을 수 없으므로 다음과 같이 테이블을 채울 수 있다.

->같은 방식으로 무게가 5인 경우까지 0으로 채울 수 있고, 무게가 6이 되는 순간 물건을 넣을 수 있으므로 무게가 6인 경우는 가질 수 있는 최대 가치가 13이 된다.

->다음으로 무게가 7인 경우 역시, 해당 물건을 넣을 수 있으므로 13으로 채워짐을 알 수 있다.

->자, 그러면 이 데이터에서 어떠한 규칙성을 발견할 수 있을까? 물건이 단 한 개만 존재하는 경우에는 단순히 물건을 넣을 수 있으면 가치를 넣고, 넣을 수 없으면 가치를 0으로 두는 규칙을 사용하여 dp 테이블을 완성할 수 있다. 이제 이러한 느낌을 바탕으로 여러 물건이 주어진 경우를 고려해보자.

(2) 물건을 1 ~ N개를 넣을 때, 각 무게(1 ~ K)당 가질 수 있는 최대 가치는 무엇일까?

->이번에는 편의상 이해를 돕기 위해, 무게가 3이고 가치가 6인 물건과 무게가 4이고 가치가 8인 문제를 먼저 넣는다는 가정하에 테이블을 갱신해보자. 우선, 무게가 3이고 가치가 6인 물건은 앞의 논리대로 테이블을 채웠다고 생각한다. 그렇다면 아래와 같은 상태일 것이다.

->이제, 무게가 4이고 가치가 8인 물건을 앞선 방식으로 넣어보자. 우선 무게가 1인 경우 물건을 담을 수 없으므로 가치는 0일 것이다. 이는 무게가 3인 경우까지 반복 될 것이다. 그런데 무게가 3이 되는 지점에 0을 채우는 것이 과연 맞을까?

해당 테이블에 값을 저장하는 기준이 무엇이었는가? 답은 N번째 물건까지 고려할 때, 해당 위치에서 가질 수 있는 최대 가치를 해당 위치에 저장해두는 것이었다. 그렇다면 해당 위치에는 2번째 물건까지 고려했을때, 무게 3에서의 최대 가치가 저장되어 있어야 하는데, 그 값은 0이 아닌 1번째 물건을 넣어서 얻은 6임을 알 수 있다.

즉, 기존에 사용하던 물건을 넣을 수 있으면 가치를 넣고, 넣을 수 없으면 가치를 0으로 두는 규칙은 활용할 수 없다는 것을 알 수 있다. 따라서 다른 규칙을 생각해보아야 한다. 우선 여기서는, 해당 위치에 물건을 넣을 수 없다면, 이전에 구한 해당 무게에서의 최대 가치를 그대로 가져오면 된다는 것을 파악하였다.

->다음으로, 무게가 4인 경우역시 중요하다. 이번에는 무게가 3인 경우와 달리 2번째 물건을 넣을 수 있다. 즉, 이 경우

에는 현재 물건의 가치와 이전 물건까지 저장했던 해당 무게에서의 가치를 비교하여 더 큰 값을 저장하면 된다는 것을 알 수 있다.

->마찬가지 방식으로 하면 무게 6까지 같은 방식으로 비교하며 값을 채워나갈 수 있음을 알 수 있다.

->자, 이제 무게가 7인 경우가 관건이다. 앞선 방식을 활용한다면 해당 위치에는 8이라는 가치가 들어가야 할 것이다. 하지만 우리는 직관적으로 무게가 7인 경우 첫 번째 물건과 두 번째 물건을 모두 넣을 수 있으므로 해당 위치에는 14라는 가치가 들어가야 한다는 것을 알고 있다. 즉, 기존에 사용하던 규칙에서 조금 수정이 필요함을 알 수 있다.

동적 계획법은 이전에 구한 최적해를 활용하여 다른 부분 문제의 최적해를 구하는 과정이라고 하였다. 우리는 첫 번째로 한 개의 물건이 존재하는 경우 최적해를 구하는 과정을 살펴보았지만 해당 규칙은 각 부분 문제의 연관성이 없었다. 두 번째로 설정한 규칙에서는 이전 물건에서 구했던 최적해를 활용하여, 현재 물건의 현재 위치에서의 최적해를 구하는데 참고하였지만 예외가 발생하였다. 따라서, 이전 최적해를 어떻게 사용할 지 다시 생각해보아야한다.

현재 무게를 포함 시키지 않는다면 가방에 수용할 수 있는 무게는 3임을 알 수 있다. 그렇다면 무게가 3인 경우의 최적해를 활용해 볼 수 있지 않을까?라는 물음을 던져볼 수 있을 것이다. 즉, 우리가 비교할 것은 바로 자신의 값이 아닌, 이전 물건까지 고려했던 최적해의 값에 현재 가치를 더한 값과, 이전에 구했던 무게에서의 최적해를 비교하여 최대 값을 구하는 것이다. 아래 그림을 통해 이해해보자.

결론부터 말하자면 이게 0-1 KnapSack을 푸는 규칙과 저장할 테이블 배열이다. 나머지 부분은 방금 규칙을 바탕으로 채울 수 있다.

2. 부분 문제의 관계를 생각하며 점화식을 도출한다.

->위 규칙을 따라 테이블을 완성하면 다음과 같아짐을 확인할 수 있다. 사실 위의 과정에서 규칙성을 파악했다면, 점화식은 그냥 도출되는 것임을 확인할 수 있다.

구체적으로 점화식을 생각해본다면 테이블의 이름을 dp라고하고, 행을 i, 열을 j로 표시한다면 다음과 같을 것이다.

여기에서 W는 현재 고려하는 물건의 무게를 의미하고, V는 현재 고려하는 물건의 가치를 의미한다.

3. 점화식을 바탕으로 dp 테이블을 갱신하면서 최종적으로 전체 문제를 해결한다.

->우선 해당 점화식을 적용하기 위해 기저 조건이 필요하고 이 때문에 2차원 dp테이블을 정의 할 때, 인덱스가 0인 경우 패딩을 주어 기저 조건을 만들어 준다. 이 정보들을 바탕으로 테이블을 완성해보면 아래와 같다.

즉, 물건을 넣지 않은 경우를 생각하여 첫 번째 물건을 담을 때 기저 조건(최적해)을 바탕으로 테이블을 갱신할 수 있도록 설정해주는 것이다.

아무튼 초기 dp 테이블의 정의에 따라 dp[4][7]의 값은 4번째 물건까지 고려했을때, 무게 7에서의 최대 가치를 의미한다는 것을 알 수 있다. 결론적으로 이 값이 해당 문제(전체 문제)의 최종 해임을 확인할 수 있다.

4. 구현

->위 로직을 이해하였다면 구현은 그냥 하면 된다. 로직이 어려운 것이지, 대부분 동적 계획법 코드는 생각만 해내면 점화식을 바탕으로 구현하기 때문에 코드가 깔끔한 장점이 있다!

import java.util.Scanner;

public class KnapSack_DP1 {
	static int N, K;
	static int[][] items;
	static int max;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		K = sc.nextInt();
		// 물건 당 첫 번째 열에는 물건의 무게를, 두 번째 열에는 물건의 가치를 저장한다.
		// 물건이 없는 경우도 고려하여 인덱스가 0인 경우(패딩)를 추가해준다.
		items = new int[N + 1][2];
		for (int i = 1; i <= N; i++) {
			items[i][0] = sc.nextInt();
			items[i][1] = sc.nextInt();
		}
		max = 0;

		// 먼저 i번째 물건의 j번째 무게에서 가질 수 있는 최댓값을 저장할 수 있는 2차원 dp테이블을 정의한다.
		// 이때, 기저 조건을 위해 dp테이블에 인덱스가 0인 경우(패딩)를 추가해준다.
		int[][] dp = new int[N + 1][K + 1];

		// 1번째 물건부터 N번째 물건까지 모두 고려한다.
		for (int i = 1; i <= N; i++) {
			// 무게가 1인 경우부터 무게가 K인 경우까지 모두 고려한다.
			for (int j = 1; j <= K; j++) {
				// 해당 위치에 물건을 넣을 수 없는 경우.
				if (items[i][0] > j) {
					// i - 1번째 물건까지 고려했을때 무게 j에서의 최대 가치(최적해)를 그대로 가져온다.
					dp[i][j] = dp[i - 1][j];
				}
				// 해당 위치에 물건을 넣을 수 있는 경우.
				else {
					// i - 1번째 물건까지 고려했을때 무게 j에서의 최대 가치(최적해)와,
					// i - 1번째 물건까지 고려했을때 무게 j - items[i][0](현재 무게)의 최대 가치(최적해) + items[i][1](현재 가치) 중에서
					// 더 큰 값을 선택한다!
					dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - items[i][0]] + items[i][1]);
				}
			}
		}
		
		// dp[N][K]를 출력한다(dp테이블의 정의에 따르면 N가지 물건을 모두 고려했을때 K무게에서의 최대 가치를 출력하는 것!).
		System.out.println(dp[N][K]);
		sc.close();
	}
}

->이렇게 상황에 따라서 dp테이블을 2차원으로 정의해주어야 할 수도 있다! 또, 구현하는 과정에서 이렇게 규칙성을 찾고 테이블의 종류를 고려한다는 것이 만만치 않은 일임을 몸소 체감할 수 있었을 것이다.

*동적 계획법을 활용한 풀이(1차원 dp 테이블 사용)

->앞의 방식으로도 머리가 아프겠지만, 조금 더 나아가서 dp 테이블을 1차원으로 줄여볼 수는 없을까?라는 물음을 바탕으로 코드를 구현해보자.

1. 테이블을 갱신하는 과정에서 테이블에서 활용되지 않는 정보는 무엇인가?

->이전 테이블을 다시 참고해본다면, 해당 테이블에서 바로 이전 행(i - 1)을 제외한 그 이전 행들의 정보(1 ~ i - 2)들은 활용되지 않음을 알 수 있다.

단계를 진행할 때 마다, 바로 이전 행만을 참고하고 있음을 알 수 있다.

2. 그렇다면 이전 행들을 잘 기억해둔다면, 굳이 2차원 테이블을 만들지 않아도 되지 않을까?

->해당 가정을 기반으로 1차원 dp 테이블을 만들고 이전 행들을 단순히 기억하면서 다음 행을 갱신해보자. 우선 이 문제를 고려하기 위해서는 물건을 넣어보는 순서를 조금 바꿔주어야 한다. 위의 예시에서 첫 번째 물건과 두 번째 물건을 넣는 순서를 바꿔서 생각해보자.

->우선 첫 번째 물건을 넣는 경우이다.

애초에 2차원 배열이었다면, 빨간색 화살표와 같이 단순히 그 값을 참고하면서 현재 값을 갱신하였을 것이다. 하지만 현재는 dp 테이블이 1차원 배열이기 때문에, 파란색 화살표와 같이 실시간으로 그 값이 갱신될 때 마다 갱신된 값을 참고하면서 값이 변할 것이다. 일단, 이 단계에서는 딱히 문제가 없다.

->그럼 두 번째 물건을 넣는 경우를 살펴보자.

마찬가지로 2차원 배열이었따면, 빨간색 화살표와 같이 그 값을 참고하면서 현재 값을 갱신하였을 것이다. 하지만 현재는 dp 테이블이 1차원 배열이기 때문에, 파란색 화살표와 같이 실시간으로 갱신된 값을 참고하며 그 값이 갱신되는데, 이때 2차원 배열일 때 이전 배열의 인덱스 3에서의 값과 1차원 배열일 때 인덱스 3의 값이 다르다는 것을 확인할 수 있다. 이것이 다르다는 것의 의미는 참고하는 값이 예기치 못한 이유로 변화되었다는 것을 의미하고, 이것은 해당 위치가 이전에 우리가 정의했던 dp 테이블의 정의(해당 위치에서 갖는 최대 가치, 최적해)를 따른다는 것을 보장할 수 없다는 것을 의미한다!

3. 이전 행들을 잘 기억하면... 되지 않을까..?

->일단 일반적인 방식으로 무작정 1차원 배열을 갱신하며 기억하면 안된다는 것을 확인하였다. 그렇다면 어떻게 1차원 배열에 그 값을 잘 저장하면 이 문제를 해결할 수 있지 않을까? 결론부터 말하자면 값을 뒤에서 부터 갱신하는 방법을 사용하면 문제를 해결할 수 있다.

->앞선 과정을 똑같이 진행해보자. 우선, 첫 번째 물건을 넣는 경우를 생각해보자.

다음과 같이 무게를 7부터 시작하여, 앞 배열을 참고해도 결과는 달라지지 않는다는 것을 확인할 수 있다. 어차피 이전 배열은 최적해를 보장하고 있기 때문에, 앞에서 부터 참고하든 뒤에서 부터 참고하든 그 결과는 같다는 의미이다.

->똑같이 두 번째 물건을 넣는 경우를 생각해보자.

이해를 돕기 위해 무게 7부터 차근차근 생각해보겠다. 마찬가지로 2차원 배열을 사용하는 방식이었다면, 빨간색 화살표와 같이 값을 참고할 것이고, 1차원 배열을 사용하는 방식이라면 파란색 화살표와 같이 값을 참고할 것이다.

마찬가지로 2차원 배열을 사용하는 방식이었다면, 빨간색 화살표와 같이 값을 참고할 것이고, 1차원 배열을 사용하는 방식이라면 파란색 화살표와 같이 값을 참고할 것인데, 앞선 방식과는 다르게 인덱스가 3인 지점이 아직 갱신이 일어나지 않았으므로, 2차원 배열에서 값을 참고하는 것과 같은 상태로 유지되고 있음을 알 수 있다. 즉, 인덱스 6인 지점에 현재까지의 최대 가치인 8이 적절히 들어가는 것을 확인할 수 있다.

4. 구현

->위 로직을 이해하였다면 역시 구현은 그냥 하면 된다. 아래 코드를 참고해보자.

import java.util.Scanner;

public class KnapSack_DP2 {
	static int N, K;
	static int[][] items;
	static int max;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		K = sc.nextInt();
		// 물건 당 첫 번째 열에는 물건의 무게를, 두 번째 열에는 물건의 가치를 저장한다.
		// 물건이 없는 경우도 고려하여 인덱스가 0인 경우(패딩)를 추가해준다.
		items = new int[N + 1][2];
		for (int i = 1; i <= N; i++) {
			items[i][0] = sc.nextInt();
			items[i][1] = sc.nextInt();
		}
		max = 0;

		// 먼저 i번째 물건의 j번째 무게에서 가질 수 있는 최댓값을 저장할 수 있는 1차원 dp테이블을 정의한다.
		// 이때, 기저 조건을 위해 dp테이블에 무게가 0인 경우(패딩)를 추가해준다.
		int[] dp = new int[K + 1];

		// 1번째 물건부터 N번째 물건까지 모두 고려한다.
		for (int i = 1; i <= N; i++) {
			// 무게가 K인 경우부터 무게가 items[i][0]인 경우까지 모두 고려한다.
			for (int j = K; j >= items[i][0]; j--) {
				// 해당 위치에 물건을 넣을 수 없는 경우, 1차원 테이블이 딱히 갱신이 되지 않는다.
				// 따라서 2차원 dp 테이블을 사용하는 경우와 달리 분기문이 사라진다.
				
				// 해당 위치에 물건을 넣을 수 있는 경우.
				// i - 1번째 물건까지 고려했을때 무게 j에서의 최대 가치(최적해)와,
				// i - 1번째 물건까지 고려했을때 무게 j - items[i][0](현재 무게)의 최대 가치(최적해) + items[i][1](현재 가치) 중에서
				// 더 큰 값을 선택한다!
				dp[j] = Math.max(dp[j], dp[j - items[i][0]] + items[i][1]);
			}
		}

		// dp[N][K]를 출력한다(dp테이블의 정의에 따르면 N가지 물건을 모두 고려했을때 K무게에서의 최대 가치를 출력하는 것!).
		System.out.println(dp[K]);
		sc.close();
	}
}

->여기서 주의할 점은 1차원 배열을 이용함으로써 물건을 넣을 수 없는 경우 물건을 그대로 가져오는 코드를 생략할 수 있다는 것이고, 또한 그로인해 물건을 넣고 빼는 조건을 제거하였으므로 물건의 무게는 현재 고려하는 물건의 무게를 넣을 수 있는 부분까지만(j >= items[i][0]) 고려해야 한다는 것이다.

->당연하겠지만, 1차원 배열을 사용하기 때문에 메모리의 사용이 적다는 것을 확인할 수 있다. 또한 모든 무게를 고려하지 않는 조건 때문인지 시간도 줄었음을 확인할 수 있다.

위 : 1차원 배열 사용, 아래 : 2차원 배열 사용

->이처럼 몇 가지 로직을 바탕으로 값을 기억하는 방식을 적절히 조절할 수 있다면, dp 테이블은 다양하게 정의할 수 있음을 알 수 있다.

※ 여기까지가 다이나믹 프로그래밍의 정석 예제 중 하나인 0-1 배낭 문제에 대한 설명이다. 어려운게 너무너무너무 당연하기 때문에.. 잘 이해가 안되더라도 주눅들지 말고 끝까지 연습해 보도록 하자. 다음에는 다이나믹 프로그래밍의 또 다른 정석 예제인 LIS와 LCS에 대해서 포스팅하도록 하겠다.

[Java]동적 계획법(Dynamic Programming)

sskl660 — Sat, 10 Jul 2021 22:37:02 +0900

*동적 계획법(Dynamic Programming)

->동적 계획법이란 특정 범위까지의 최적해(상위 문제)를 구하기 위하여 다른 범위까지의 최적해(하위 문제)를 이용하여 효율적으로 해를 구하는 알고리즘 설계 기법이다.

->쉽게 말해, 이전에 구한 값을 기반으로 규칙성을 파악하여 다음 값을 구하는 것이라고 생각하면 된다.

->알고리즘 설계 기법(패러다임) 중 하나이다. 하위 문제의 최적해를 적절히 사용하여 상위 문제를 해결함으로써, 불필요한 계산을 줄일 수 있다.

※ 어떤 문제를 해결할 때, 기본적인 방법은 모든 경우의 수를 고려하는 것(완전 탐색)이다. 어떤 문제를 해결할 때, 그 문제에 대한 모든 경우의 수를 고려할 수 있는 설계가 가능하다면, 그 문제는 시간과 자원이 매우 많이 들지는 몰라도 언젠가 반드시 정확한 결과를 도출할 것이다. 다만 시공간적 자원의 한계로 인하여 분할 정복, 그리디, 백트래킹 등과 같은 알고리즘 설계 기법이 등장한 것이고 동적 계획법 역시 그러한 한계를 해결하기 위해 설계된 알고리즘 패러다임인 것이다.

※ 동적 계획법(Dynamic Programming)이라는 이름은 딱히 해당 알고리즘의 패러다임을 이해하는데 직관적이지 않은 편이다. 동적 계획법의 고안자인 벨만이 연구소에서 펀딩을 받기 위해서 이름을 최대한 간지나게 지을려다보니 Dynamic이라는 용어를 사용하게 됐다고 한다.

(참고 : https://namu.wiki/w/%EB%8F%99%EC%A0%81%20%EA%B3%84%ED%9A%8D%EB%B2%95#toc)

*적용 가능한 문제

->동적 계획법은 아래 두 조건을 만족하는 경우 해당 패러다임을 적용하여 문제를 해결하는데 유용하다고 알려져있다.

(1) 최적 부분 문제 구조(Optimal Substructure)

->쉽게 말해 앞서 정의한 바와 같이 이전에 구한 최적해(부분 문제)를 바탕으로 다음 문제의 최적해(전체 문제)를 구할 수 있는 구조여야 한다는 것이다.

->다시 말해 부분 문제가 전체 문제의 최적해라는 보장이 있는 구조를 최적 부분 문제 구조라고 생각하면 된다.

※ 최적 부분 문제 구조를 갖는 경우 : 최적 부분 문제 구조를 갖는 경우는 대표적으로 어떤 경유지를 거쳐서 목적지로 가는 문제가 있다. 아래 그림을 보자.

그림에서 서울에서 부산으로 가는 최단 경로를 구하는 문제(전체 문제)를 생각해보자. 그런데 그림에서 서울에서 부산으로 가는 최단 경로는 서울에서 대전으로 가는 최단 경로(부분 문제)와 서울에서 부산으로가는 최단 경로(부분 문제이자 전체 문제)로 나누어 생각할 수 있다. 또한, 서울에서 대전으로가는 최단 경로 200km(최적해)는 이후 대전에서 부산으로가는 최단 경로 150km와(여기에서 150km는 최적해를 의미하지 않는다. 부분 문제의 해라고 보기 힘들기 때문이다) 적절히 조합하여 전체 문제를 해결 가능함을 알 수 있다.

※ 최적 부분 문제 구조를 갖지 않는 경우 : 위 그림에서 조건을 몇가지 살짝 바꿔보자.

그림에서 서울에서 부산으로 가는 최소 비용을 구하는 문제(전체 문제)를 생각해보자. 앞 선 문제와 비슷하지만, 여기에는 '서울에서 대전을 경유해서 바로 부산으로 가는 경우의 비용은 33000원'이라는 조건이 하나 더 추가 되었다. 이 조건으로 인해, 앞서 나누었던 부분 문제(서울에서 대전)는 전체 문제를 해결하는 최적해라는 보장이 사라져 버린다! 즉, 동적 계획법을 잘 활용하려면 부분 문제를 어떻게 설정해야지 최적 부분 문제 구조를 갖는지 잘 파악해야 함을 알 수 있다.

(2) 중복 부분 문제 구조(Overlapping Subproblems)

->말 그대로 부분 문제들이 반복되는 경향이 존재한다는 것을 의미한다. 쉽게 말해서 부분 문제를 분할해가는 과정에서, 그 각 상위 문제와 하위 문제의 관계가 반복되는 경향이 존재한다는 것을 의미한다.

->위의 예시를 바탕으로 아래 그림을 살펴보자.

마찬가지로 서울에서 부산으로 가는 최단 경로(전체 문제)를 해결한다고 생각해보자. 그래서 우선 서울에서 대전으로 가는 최단경로(부분 문제)는 무엇일까?라는 질문을 출발하여 서울에서 경기로 가는 최단경로(최하위 부분 문제)는 무엇일까?라는 질문까지 내려갔다. 이 구조에서 부분 문제의 구조가 '각 위치 까지의 최단 경로는 무엇인가?'로 반복된다는 것을 알 수 있다. 그냥 쉽게 말해 이런 구조를 갖는 것이 중복 부분 문제 구조를 갖는다라고 이해해두면 된다.

※ 결국 이 그림이 동적 계획법의 사고 진행 과정이 어떤 방식으로 진행되는지 단편적으로 이해하는데 도움이 될 수 있을 것이다. 전체 문제를 부분 문제로 나누고, 그 부분 문제를 작은 문제부터 해결(서울에서 경기, 서울에서 대전, 서울에서 부산)해 나아가고, 각 단계에서 구한 해를 다음 문제에서 재사용함으로써 전체 문제를 해결하는 것을 확인할 수 있다.

*vs 분할 정복 패러다임

->동적 계획법과 분할 정복 패러다임 모두 전체 문제를 부분 문제로 나누어 생각한다는 점에서 그 차이점을 느끼기 어려울 수 있다. 이를 구분하기 가장 좋은 것은 동적 계획법은 부분 문제 사이에 연관성이 존재하고, 분할 정복은 부분 문제 사이에 연관성이 존재하지 않는다는 점을 이해하면 된다.

->예를 들어 병합 정렬(Merge Sort)을 생각해보자. 병합 정렬의 경우 모든 배열을 각각 분할(부분 문제)하고, 최종적으로 분할된 배열부터 각 배열을 합치며 정렬하는 과정을 반복(단순히 부분 문제를 큰 문제로 결합하며 해결)하는 것이다. 즉, 부분 문제 사이에 딱히 별 연관성이 없음을 알 수 있다.

*구현 방식

->동적 계획법은 특성상 Top-down 방식과 Bottom-up 방식으로 구현이 가능하다.

->사실 어떤 문제를 푸느냐에 따라서 Top-down 방식으로 구현하든 Bottom-up 방식으로 구현하든 각 방식이 압도적으로 우위를 가지는 장단점은 명확하지 않다고 한다. 따라서, 장단점의 경우에는 보통 이러하다더라~ 정도로 이해하면 좋을 것 같다.

(1) Top-down 구현 방식

->전체 문제부터 시작하여, 가장 작은 문제(기저 문제)까지 호출한 뒤, 작은 문제에서 해결한 값을 저장 및 기억(Memoization)하면서 해당 결과 값을 재활용하면서 문제를 해결하는 구현 방식을 말한다. 이러한 문제 해결의 특성상 재귀 호출을 사용하는 특징이 있다.

->재귀 호출을 사용하기 때문에 Stack Overflow 등의 문제가 발생할 수 있지만, 전체 문제부터 시작하여 작은 문제로 내려가는 직관적인 구조이기 때문에 이해하기 쉬운 장점이 존재한다.

(2) Bottom-up 구현 방식

->가장 작은 문제(기저 문제)부터 시작하여, 작은 문제를 해결하여 그 값을 저장(Tabulation)하고, 이 값들을 기반으로 다음 문제를 순차적으로 해결하며 전체 문제까지 해결하는 구현 방식을 말한다. 이러한 문제 해결의 특성상 반복문을 사용하는 특징이 있다.

->반복문을 사용하기 때문에 Top-down 방식에 비하여 효율성이 좋다고 알려져 있지만, 앞서 말한대로 문제 및 오버헤드, 설계에 따라서 Case by Case라고 한다. 또한 직관적인 구조가 아니기 때문에 구현이 어려울 수 있는 단점이 존재한다.

※ Tabulation? : Tabulation의 사전적 정의는 '도표 작성'이다. 문제 해결 방식이 표를 채워나가는 것과 유사하다고 하여 붙여진 이름이다. 따라서 Bottom-up방식을 사용하는 경우는 Memoization이라고 부르지 않고 Tabulation을 활용하여 값을 재활용한다고 이해하면 된다.

*피보나치 수열과 다이나믹 프로그래밍

->다이나믹 프로그래밍을 설명할 때, 가장 기본적이고 자주 사용되는 문제는 피보나치 수열의 값을 구하는 문제이다.

(1) 피보나치 수열이란?

->첫째 항과 둘째 항이 1의 값을 가지고, 그 뒤의 모든 항은 바로 앞 두 항의 합으로 구성된 수열을 말한다. 예를 들면, 다음과 피보나치 수열은 다음과 같이 진행된다. 1, 1, 2, 3, 5, 8, 13, 21...

->즉, 피보나치 수열을 Fn이라고 한다면, 피보나치 수열은 다음과 같이 수학적으로 정의할 수 있다.

(2) 피보나치 수열의 일반항의 값을 구하는 프로그램을 작성해보자(단순 재귀 호출).

->재귀를 사용하면, 피보나치 수열을 구하는 일반적인 프로그램을 작성하는 것은 쉽다. 코드로 작성하면 아래와 같을 것이다.

import java.util.Scanner;

public class FibonacciNumber {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		
		// n번째 피보나치 수를 구하고 출력하라.
		System.out.println(Fibonacci(n));
		sc.close();
	}

	private static long Fibonacci(int n) {
		// 기저 조건(피보나치 수열의 초항).
		if(n == 1 || n == 2) {
			return 1;
		}
		// 점화식.
		return Fibonacci(n - 1) + Fibonacci(n - 2);
	}
}

->하지만 해당 프로그램은 효율적으로 동작할까? 당장 100만 입력해봐도 결과를 도출하는데 매우 오랜 시간이 걸릴 것임을 알 수 있다. 그 이유는 아래 호출 구조를 보면서 파악해보자.

일반적인 재귀를 사용한 경우 재귀 호출 구조도와 반복되는 부분 확인

그림과 같이 호출이 반복될 때 마다, 이미 구했던 값임에도 불구하고 다음 재귀에서 반복해서 재귀 호출이 발생하는 것을 확인할 수 있다. 이 경우 시간 복잡도는 O(2^N)이라고 한다. 즉, 연산의 횟수가 N이 늘어남에 따라 지수배 만큼 늘어나기 때문에 효율적인 구현이라고 볼 수 없다.

(3) Top-down 구현 방식으로 피보나치 수열의 일반항의 값을 구해보자.

->이제 앞에서 학습한 다이나믹 프로그래밍의 구현 방식 중 하나인 Top-down 구현 방식을 활용하여 코드를 작성해보자. 일반적으로 재귀를 사용하는 구조는 같지만, 부분 문제에서 구한 값을 기억(Memoization)하면서 다음 재귀에서 재활용하는 과정을 추가해주면 된다.

import java.util.Scanner;

public class FibonacciNumber_TopDown {
	// Memoization을 적용할 배열.
	static long[] dp;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		dp = new long[n + 1];

		// n번째 피보나치 수를 구하고 출력하라.
		System.out.println(Fibonacci(n));
		sc.close();
	}

	private static long Fibonacci(int n) {
		// 기저 조건(피보나치 수열의 초항).
		if (n == 1 || n == 2) {
			return dp[n] = 1;
		}
		// 만일, 저장된 값이 존재하는 경우 기억된 값을 바로 넘겨준다.
		if (dp[n] != 0) {
			return dp[n];
		}
		// 그렇지 않은 경우, 기저 조건까지 내려가서 구해진 값을 저장하면서 재귀를 전이한다.
		else {
			return dp[n] = Fibonacci(n - 1) + Fibonacci(n - 2);
		}
	}
}

->이렇게 부분 문제에서 해결한 값을 저장(Memoization)하면서 문제를 해결하는 경우 불필요한 계산 과정을 줄여주기 때문에 엄청난 속도 향상을 보임을 알 수 있다! 이 경우 시간 복잡도는 O(N)을 갖는다고 한다. 아래 호출 구조를 참고해보자.

값을 그때마다 기억하고, 적절하게 호출하면서 불 필요한 계산 과정을 줄일 수 있다!

(4) Top-down 구현 방식으로 피보나치 수열의 일반항의 값을 구해보자.

->그럼 이번에는 앞에서 학습한 다이나믹 프로그래밍의 구현 방식 중 다른 하나인 Bottom-down 구현 방식을 활용하여 코드를 작성해보자. Bottom-up 구현 방식은 가장 작은 문제(기저 문제)부터 시작하여, 작은 문제를 해결하여 그 값을 저장(Tabulation)하고, 이 값들을 기반으로 다음 문제를 순차적으로 해결하며 전체 문제까지 해결하는 구현 방식이라고 하였다. 즉, 기저 조건(1항, 2항의 값은 1)을 기반으로 다음 값을 구하면서 테이블을 채워가는 방식으로 반복문을 구현하면 된다. 아래 코드를 참고하자.

import java.util.Scanner;

public class FibonacciNumber_BottomUp {
	// Tabulation을 적용할 배열.
	static long[] dp;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		dp = new long[n + 1];
		// 기저 조건을 바탕으로 초항을 먼저 초기화 해둔다.
		dp[1] = 1;
		dp[2] = 1;

		// n번째 피보나치 수를 구하고 출력하라.
		System.out.println(Fibonacci(n));
		sc.close();
	}

	private static long Fibonacci(int n) {
		// 기저 조건을 기반으로 테이블을 채워나간다(Tabulation).
		for(int i = 3; i <= n; i++) {
			// 점화식을 이용하여 쉽게 구할 수 있다.
			dp[i] = dp[i - 1] + dp[i - 2];
		}
		
		return dp[n];
	}
}

->마찬가지로 이렇게 부분 문제에서 해결한 값을 저장(Tabulation)하면서 문제를 해결하는 경우 불필요한 계산 과정을 줄여주기 때문에 엄청난 속도 향상을 보임을 알 수 있다! 이 경우 역시 시간 복잡도는 O(N)을 갖는다고 한다.

※ 사실 Tabulation을 사용하지 않더라도 단순 반복문을 이용하여 피보나치수의 일반항의 값을 구할 수 있음을 알 수 있을 것이다. 즉, 굳이 값을 저장하지 않더라도 반복문을 적용한다면 앞의 두 값만 기억하고 있다면 굳이 메모리 공간을 낭비하지 않더라도 결과를 계산할 수 있다는 말이다. 다만 전체적인 과정의 값을 모두 기억해가며 풀어가는 방식이 동적 계획법의 정석이기 때문에 이렇게 소개한 것 뿐이고, 이 경우와 마찬가지로 데이터를 어떤 방식으로 기억할 지(단순히 변수에 담을지, n차원 배열에 담을지, 트리 자료구조에 담을지...)는 문제에 따르게 다르게 생각하면 된다. 실제로 데이터를 어떤 방식으로 저장할지를 생각하는 것이 동적 계획법의 출발이고, 알고리즘 실력을 가르는 중요한 요소임을 많은 문제 풀이를 하며 이해할 수 있을 것이다.

※ Top-down 방식과 달리 기저 조건부터 출발해 전체 문제를 해결하는 것을 확인할 수 있다. 이를 바탕으로 Top-down방식과 Bottom-up방식의 차이점을 이해할 수 있을 것이다.

*동적 계획법 문제 접근 방식

->해당 글을 잘 이해하였다면 동적 계획법은 이러하다..는 대략적인 느낌은 이해했을 것이라 생각한다. 다만, 실전 DP문제를 마주하면 나의 알고리즘 실력에 자괴감이 들때가 많을 것이다. 그 만큼 동적 계획법은 난이도가 있는 알고리즘 패러다임이고, 당연한 것이기 때문에... 꾸준히 연습하는 것 밖에 답이 없어보인다...

->다음은 일반적인 동적 계획법 문제 접근 방식이다. 물론 접근 방식을 알고 있다고해도 쉽게 적용하긴 힘들 것이다...

(1) 문제를 특정한 부분문제로 나누고, 해당 부분 문제의 최적해들을 저장할 dp 테이블을 정의해본다.

->이를 테면 앞의 서울에서 부산까지 가는 최단 경로를 구하는 예시를 기준으로 생각해보면, 'n번째 지역까지 가는데 필요한 최단 경로'라는 부분 문제를 생각해볼 수 있고, 이를 1차원 배열에 저장하면 되겠다는 생각을 해볼 수 있다.

->쉽게 말해 부분 문제를 무엇으로 둘거고, 그걸 어떻게 저장해볼까?를 생각하는 단계이다.

(2) 부분 문제의 관계를 생각하며 점화식을 도출한다.

->이를 테면 앞의 서울에서 부산까지 가는 최단 경로를 구하는 예시를 기준으로 생각해보면 'dp[n] = dp[n - 1] + (n - 1지역에서 n으로 가는 최단 거리)' 라는 점화식을 세울 수 있음을 알 수 있다.

->쉽게 말해 해당 부분 문제의 규칙성을 파악해보고, 점화식과 기저 조건을 정의하는 단계이다. 물론... 규칙성을 찾는것이 말 처럼 쉽지는 않을 것이다.

(3) 점화식을 바탕으로 dp 테이블을 갱신하면서 최종적으로 전체 문제를 해결한다.

->이를 테면 앞의 서울에서 부산까지 가는 최단 경로를 구하는 예시를 기준으로 생각해보면 결국 dp[n]의 값이 최종 답이 되는 것을 확인할 수 있다.

->사실 이 단계는 확인하는 단계이다. 데이터를 저장할 dp테이블 설계와 각 데이터간의 연관성을 바탕으로 점화식을 잘 정의하였다면 올바른 답이 도출되는 것을 확인할 수 있을 것이다.

[Java]삽입 정렬(Insertion Sort)

sskl660 — Fri, 25 Jun 2021 01:38:02 +0900

*삽입 정렬(Insertion Sort)

->삽입 정렬이란 2번째 원소부터 n번째 원소까지 차례로 해당 원소가 위치할 인덱스에 원소를 삽입하는 방식을 사용하는 정렬 방식이다.

->2번째 원소부터 n번째 원소부터 차례로 각 원소가 맞는 위치에 '삽입'하는 방식을 사용하며 배열을 정렬하기 때문에 삽입 정렬이라고 이름지었다.

※사람에게 어떤 대상을 정렬하라고 한다면 무의식적으로 수행하는 정렬 방식이라고 한다!

*삽입 정렬의 이해

->어떤 대상을 '오름차순'으로 정렬할 때 삽입 정렬은 2번째 원소부터 앞의 원소와 비교하는 과정을 통해 적절한 위치에 삽입하고, n번째 원소까지 이 방식을 반복함으로써 정렬을 진행할 수 있다. 예를 들어 [6, 2, 3, 4, 1]이라는 배열을 삽입 정렬을 이용하여 오름차순 정렬을 해보면 다음과 같다.

초기 배열 상태. Array[CurIndex]는 임시 변수에 저장하여 값을 기억해둔다.

현재 선택된 원소의 앞 원소와 비교를 하며 현재 원소의 적절한 위치를 찾는 방식이기 때문에, 우선 Array[0]와 Array[CurIndex]를 비교를 하게 된다. 이때, Array[0] > Array[CurIndex]이므로 0번째 인덱스의 원소를 뒤로 미뤄버린다.

현재 대상 원소인 Array[CurIndex]의 값보다 Array[0]의 값이 크기 때문에, 해당 값을 다음 인덱스인 1로 미뤄버린다.

그렇다면 다음과 같은 상태가 되어 있을 것이다.

이때 가장 앞 원소까지 탐색이 종료되었으므로, 최종적으로 미뤄졌던 인덱스에 현재 인덱스의 값을 '삽입'한다.

0번째 인덱스에서 미뤄지는 것이 종료되었으므로, 해당 위치에 초기에 선택했던 값을 삽입한다.

그렇다면 다음과 같은 상태가 되어 있을 것이다.

2번째 원소에 대한 탐색이 종료되었으므로, 이번에는 3번째 원소에 대한 값을 기준으로 위 과정을 똑같이 반복해준다. 즉 초기 상태는 아래와 같아질 것이다.

초기 배열 상태. 마찬가지로 Array[CurIndex]의 값은 임시 변수에 저장하여 값을 기억해둔다.

마찬가지로 현재 원소의 앞의 원소만을 탐색하기 때문에, Array[1]과 Array[CurIndex]의 값을 비교하게 될 것이다. 이때, Array[1] > Array[CurIndex]이므로 해당 원소의 위치를 뒤로 미뤄버린다.

해당 원소를 뒤로 미뤄버린다.

따라서 다음과 같은 상태가 되어 있을 것이다.

다음으로 Array[0]와 Array[CurIndex]를 비교해보면 Array[CurIndex]의 값이 더 크기 때문에, 탐색을 종료한다. 탐색을 종료한 지점이 1이므로, 해당 위치에 임시로 저장해두었던 Array[CurIndex]의 값을 삽입해준다.

Array[0] < Array[CurIndex]이므로, 1번째 원소에서 탐색이 종료되고 해당위치에 기억해두었던 값을 삽입해주면된다.

이러한 과정을 n번째 원소까지 반복해준다면 정렬이 완료된다.

*삽입 정렬의 구현

->쉽게 말해 2번째 원소부터 시작하여, n번째 원소까지 해당 원소의 앞 원소들과 비교하여 해당 원소가 위치해야할 자리를 찾는 과정을 구현해주면 된다.

package sort;

import java.util.Arrays;

public class InsertionSort {
	static int[] nums;

	public static void main(String[] args) {
		nums = new int[10];
		for (int i = 0; i < 10; i++) {
			nums[i] = (int) (Math.random() * 10);
		}
		System.out.println("<정렬 전>");
		System.out.println(Arrays.toString(nums));
		
		for(int i = 1; i < nums.length; i++) {
			// 현재 선택된 원소의 값을 임시 변수에 저장해준다.
			int temp = nums[i];
			// 현재 원소를 기준으로 이전 원소를 탐색하기 위한 index 변수.
			int prev = i - 1;
			// 현재 선택된 원소가 이전 원소보다 작은 경우까지만 반복. 단, 0번째 원소까지만 비교한다.
			while(prev >= 0 && nums[prev] > temp) {
				// 현재 선택된 원소가 현재 탐색중인 원소보다 작다면, 해당 원소는 다음 인덱스로 미뤄버린다.
				nums[prev + 1] = nums[prev];
				// 다음 대상 원소를 탐색한다.
				prev--;
			}
			// 탐색이 종료된 지점에 현재 선택되었던 변수의 값을 삽입해준다.
			nums[prev + 1] = temp;
		}
		
		System.out.println("<정렬 후>");
		System.out.println(Arrays.toString(nums));
	}
}

*삽입 정렬의 시간 복잡도

->예를들어 [5, 4, 3, 2, 1]과 같은 최악의 경우에는 각각의 탐색에서 무조건 앞의 모든 원소를 뒤로 미뤄버리는 작업을 해야하기 때문에, 시간 복잡도는 O(n^2)이다.

->이렇게 탐색을 진행하면서 원소를 뒤로 미뤄버리는 방식을 사용하기 때문에 자료구조에 따라 다른 성능을 보일 수 있다. 다만, 정렬하고자 하는 대상의 원소 수가 적다면 일반적으로 빠르다고 알려진 알고리즘보다 좋은 성능을 가지고 있다고한다. 따라서 고성능 알고리즘에서는 배열의 사이즈가 큰 경우에는 O(nlogn)정렬을 사용하다가 정렬해야 하는 부분이 작아지면 삽입 정렬로 전환하는 방식을 사용한다고도 한다. 일반적인 경우 탐색을 제외하면 삽입 정렬의 방식이 오버헤드가 매우 적기 때문이라고 한다.

※참고 : https://namu.wiki/w/%EC%A0%95%EB%A0%AC%20%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98#s-2.1.3

->앞 부분에서 삽입해야할 위치를 찾는 경우, 앞 부분은 이미 정렬되어 있다는 점을 활용하여, 위치를 찾는 방법에 이진 탐색을 활용해볼 수 있다. 이 경우 최선의 경우 O(nlogn)의 시간 복잡도를 갖는다.

[Java]선택 정렬(Selection Sort)

sskl660 — Fri, 25 Jun 2021 00:44:27 +0900

*선택 정렬(Selection Sort)

->선택 정렬이란 한 번의 배열 탐색에서 가장 작은 원소의 '위치'를 찾고, 그 위치와 배열의 가장 첫 번째 원소부터 차례로 바꿔주는 방식을 사용(오름 차순으로 정렬하는 경우)하는 정렬 방식이다.

※가장 큰 원소의 위치를 찾고, 배열의 가장 마지막 원소부터 차례로 바꿔주는 방식을 사용해도 된다. 다만 반복문을 구현할 때 작은 원소의 값을 찾는 방식이 조금 더 구현하기 편하기 때문에 작은 원소를 찾는 방법을 주로 사용한다.

->말 그대로 큰 원소나 작은 원소를 선택하고 그 위치를 바꿔주기 때문에 선택 정렬이라는 이름을 사용한다.

*선택 정렬의 이해

->어떤 대상을 '오름차순'으로 정렬할 때 선택 정렬은 원소를 처음부터 탐색하면서, 작은 수를 찾고 그 수를 배열의 앞쪽과 차례로 보내는 방식을 사용한다. 예를 들어 [3, 1, 5, 7, 10]이라는 배열을 선택 정렬을 이용하여 오름차순 정렬을 해보면 다음과 같다.

초기 배열 상태

우선, 첫 번째 원소의 값을 기억해두고 1번째 인덱스부터 4번째 인덱스까지 더 작은 값이 나올때마다 해당 위치의 인덱스를 기억해둔다. 따라서 우선 Array[MinIndex]에 대하여 Array[1]의 값을 비교하면 Array[1]의 값이 작기 때문에 Array[1]의 인덱스인 1을 기억해둔다.

Array[MinIndex] > Array[1]이므로, MinIndex = 1로 갱신해준다.

마찬가지로 2번째 인덱스와 현재 Array[MinIndex]의 값을 비교해준다. 이때, Array[MinIndex]의 값이 더 작기 때문에 MinIndex의 값이 따로 갱신되지 않는다.

Array[MinIndex] < Array[2]이므로 MinIndex는 따로 갱신되지 않는다.

3, 4번째 인덱스 역시 현재 Array[MinIndex]의 값보다 크기 때문에 MinIndex의 값은 따로 갱신이 일어나지 않는다.

Array[MinIndex] < Array[3], Array[MinIndex] < Array[4] 이므로 MinIndex는 따로 갱신되지 않는다.

이렇게 한 번의 탐색이 완료되었을 때 최종적으로 해당 배열에서 가장 작은 값은 1번째 인덱스에 있는 값임을 알 수 있다. 따라서, 해당 값을 배열의 0번째 원소와 바꾸어 준다.

해당 배열에서 가장 작은 수는 1번째 원소이므로, 해당 값을 0번째 원소와 바꾸어준다.

그리고 다음 반복해서는 초기 값을 1번째 인덱스부터 시작하여 마찬가지로 가장 작은 값을 앞으로 보내준다면 오름차순으로 정렬이 될 것이다.

*선택 정렬의 구현

package sort;

import java.util.Arrays;

public class SelectionSort {
	static int[] nums;

	public static void main(String[] args) {
		nums = new int[10];
		for (int i = 0; i < 10; i++) {
			nums[i] = (int) (Math.random() * 10);
		}
		System.out.println("<정렬 전>");
		System.out.println(Arrays.toString(nums));
		
		for(int i = 0; i < nums.length - 1; i++) {
			// 현재 탐색에서 가장 앞의 원소를 초기 값으로 설정해둔다.
			int MinIndex = i;
			// 탐색을 진행하며, 가장 작은 값을 찾는다.
			for(int j = i + 1; j < nums.length; j++) {
				if(nums[MinIndex] > nums[j])
					MinIndex = j;
			}
			// 탐색이 완료되면 가장 작은 값을 가장 앞의 원소와 가장 작은 원소의 위치를 바꾸어준다.
			int temp = nums[MinIndex];
			nums[MinIndex] = nums[i];
			nums[i] = temp;
		}
		
		System.out.println("<정렬 후>");
		System.out.println(Arrays.toString(nums));
	}
}

결과

*선택 정렬의 시간 복잡도

->버블 정렬과 마찬가지로 총 반복 횟수 = n(n-1)/2가 된다. 따라서, 선택 정렬의 시간 복잡도는 O(n^2)이다.

->선택 정렬은 어떤 정렬이 오더라도 비교하는 방식이 같기 때문에, 일반적인 상황에서 비슷한 성능을 보유한다.

->버블 정렬과 마찬가지로 직관적으로 이해가 편하고, 불필요하게 원소들을 교체하는 작업이 없기 때문에 버블 정렬보다 '일반적인 상황'에서 빠른 성능을 보이지만 여전히 시간 복잡도가 O(n^2)이기 때문에 실전에서 사용하기 힘든 정렬이다.

[Java]버블 정렬(Bubble Sort)

sskl660 — Fri, 25 Jun 2021 00:08:41 +0900

*버블 정렬(Bubble Sort)

->버블 정렬이란 인접한 두 원소를 비교하며, 큰 수를 계속하여 뒤로 보내 정렬하는 방식을 사용(오름 차순으로 정렬하는 경우)하는 정렬 방식이다.

->원소들이 거품이 올라오는 것처럼 보여 거품 정렬(Bubble Sort)이라고 이름지었다.

*버블 정렬의 이해

->어떤 대상을 '오름차순'으로 정렬할 때 버블 정렬은 원소를 처음부터 탐색하면서, 큰 수를 계속하여 뒤로 밀어내는 방식을 사용한다. 예를 들어 [5, 3, 1, 10, 7]이라는 배열을 버블 정렬을 이용하여 오름차순 정렬을 해보면 다음과 같다.

초기 배열 상태

먼저, Array[0]와 Array[1]을 비교해보자. Array[0]가 Array[1]보다 크기 때문에, 이 두 배열의 원소의 위치를 바꾸어준다.

Array[0]와 Array[1]을 비교하고, 앞의 원소가 더 크다면 두 원소의 자리를 바꾸어준다.

다음으로 Array[1]과 Array[2]를 비교해보자. 마찬가지로 Array[1]이 Array[2]보다 크기 때문에, 이 두 배열의 원소의 위치를 바꾸어준다.

Array[1]과 Array[2]를 비교하고, 앞의 원소가 더 크다면 두 원소의 자리를 바꾸어준다.

다음으로 Array[2]와 Array[3]을 비교해보자. 이때, Array[2]는 Array[3]보다 작기 때문에 두 원소의 자리를 바꾸지 않는다.

Array[2]은 Array[3]보다 크기 않으므로, 자리를 교체하지 않는다.

마지막으로 Array[3]과 Array[4]를 비교해보자. Array[3]은 Array[4]보다 크기 때문에, 두 원소의 자리를 바꾸어준다.

Array[3]은 Array[4]보다 크기 때문에, 두 원소의 자리를 교체해준다.

이렇게 순차적으로 한 번의 자리 교체가 완료되면, 가장 큰 수가 배열의 가장 뒤로 보내진 것을 확인할 수 있다. 따라서 이러한 점을 이용하여, 이 과정을 (배열의 크기 - 1)번 반복해주면 한 번의 반복마다 순차적으로 큰 수가 뒤로 밀리는 것을 보장할 수 있다. 즉, 모든 반복이 완료되면 배열의 모든 수는 오름차순으로 정렬이 될 것이다.

*버블 정렬의 구현

->다만 이 과정에서 이미 뒤로 보내진 수들은 다시 정렬 여부를 확인할 필요가 없기 때문에, 한 번의 반복마다 교체를 확인하는 인덱스를 1씩 줄여주며 반복을 하는 구현 방법을 주로 사용한다.

package sort;

import java.util.Arrays;

public class BubbleSort {
	static int[] nums;

	public static void main(String[] args) {
		nums = new int[10];
		for (int i = 0; i < 10; i++) {
			nums[i] = (int) (Math.random() * 10);
		}
		System.out.println("<정렬 전>");
		System.out.println(Arrays.toString(nums));
		
		// 한 번의 반복이 완료될 때 마다 가장 큰 수는 배열의 가장 마지막 부분으로 밀리는 것이 보장된다.
		for(int i = nums.length - 1; i > 0; i--) {
			// 따라서, 한 번의 반복마다 가장 뒤의 인덱스는 비교하지 않도록 반복문을 설계할 수 있다.
			for(int j = 0; j < i; j++) {
				// 만일, 앞의 수가 뒤의 수보다 더 크다면 swap 연산을 진행해준다.
				if(nums[j] > nums[j + 1]) {
					int temp = nums[j];
					nums[j] = nums[j + 1];
					nums[j + 1] = temp;
				}
			}
		}
		
		System.out.println("<정렬 후>");
		System.out.println(Arrays.toString(nums));
	}
}

결과

*버블 정렬의 시간 복잡도

->위의 구현을 따르면 n - 1번의 교체작업부터 순차적으로 1번의 교체작업까지 반복하므로, 총 반복 횟수 = 1 + 2 + ... + (n - 1)의 형태를 가질 것이다. 즉, 총 반복 횟수 = n(n- 1)/2가 될 것이다. 따라서, 버블 정렬의 시간 복잡도는 O(n^2)이다.

->가장 큰 수를 뒤로 보내는 방식을 사용하기 때문에, 이미 정렬하고자 하는 배열이 어느정도 정렬이 되어 있는 상태 일수록 최선의 성능을 낼 수 있다.

->직관적으로 이해가 쉬운 정렬로 구현하기 쉽지만 일반적으로 O(n^2)의 시간복잡도를 갖기 때문에 실전에서는 거의 사용할 일이 없다. 다만 버블 정렬에 사용되는 Swap연산이 중요하기 때문에 초기 프로그래밍시 자주 사용되는 예제 중 하나이다.

GitHub Desktop(Pull, Push)

sskl660 — Sat, 8 May 2021 22:53:57 +0900

깃(Git)은 컴퓨터 파일의 변경사항을 추적하고, 여러 사용자간 협업을 위한 분산 버전 관리 시스템이다.

기본적으로 Git은 버전 관리, 백업, 협업 등 매우 다양하지만 심오한 개념을 가지고있고 GUI를 이용한 방식, CLI를 이용한 방식이 있지만 CLI는 초보자가 바로 능숙하게 다루기엔 다소 어려운 부분들이 존재한다.

이 글에서는 GUI방식을 기반으로 개발된 GitHub DeskTop 프로그램의 Pull을 이용하여 GitHub 서버에서 자료를 가져오는 방법과 Push를 이용하여 서버로 자료를 보내는 방법만 매우 담백하게 작성하였다.

*Clone

-> Clone은 쉽게 말해 GitHub(Server)에 저장된 내용을 내 컴퓨터(Local)로 가져오는 작업이다.

(1) 먼저, 아래 그림과 같이 GitHub DeskTop의 파일 탭에서 Clone repositor를 선택한다.

(2) 나타나는 창에서 URL을 클릭하고, 1번 영역에는 자료를 가져올 GitHub의 주소를, 2번 영역에는 해당 파일을 내 컴퓨터에 저장할 경로를 입력한다. 이때, GitHub의 주소는 해당 프로젝트 우측 상단에서 아래와 같이 복사해오면 된다. 작성을 완료했으면, Clone 버튼을 누른다. 내 컴퓨터에 자료가 다운로드 된 것을 확인할 수 있다.

원하는 프로젝트의 좌상단에 위치한 녹색 버튼을 누르고 나타나는 주소를 복사한다.

*Pull

-> 이후 해당 주소에서 변경된 자료들은 Repository 탭의 Pull을 이용하여 내 컴퓨터로 간편하게 가져올 수 있다.

*Push

-> Push는 반대로 내 컴퓨터에서 변경된 사항을 GitHub에 업로드 하는 작업이다. 협업을 하는 경우는 여러 제약 조건이 붙겠지만, 여기서는 그냥 GitHub에 업로드하는 방법만 서술하였다.

(1) 기본적으로 내 컴퓨터에서 GitHub와 연동된 폴더에서 변화가 일어나면, 좌측의 Change에 변경된 내용이 표시된다. History의 경우, 해당 서버에서 변경된 내용을 모두 추적할 수 있다.

(2) 내 컴퓨터에서 변경된 사항을 최종적으로 확정(Commit)하는 단계이다. 1번 영역에는 변경 사항을 요약하는 제목을, 2번 영역에는 변경사항에 대한 설명을 작성해준다. 작성을 완료하였으면, Commit to main버튼을 눌러 변경 사항을 확정한다.

(3) Commit이 완료 되었으면, 아래 그림과 같이 Push버튼이 활성화된다. Push 버튼을 누르면 서버에 내가 변경한 사항이 업로드 된다.

[Java]누적 합(Prefix Sum , Cumulative Sum)

sskl660 — Thu, 22 Apr 2021 13:46:17 +0900

*누적 합(Prefix Sum, Cumulative Sum)

-> 누적 합이란, 말 그대로 나열된 수의 누적된 합을 말한다.

-> 조금 더 엄밀히 말하면, 수열 An에 대해서, 구간 [1, 1]의 합, 구간 [1, 2]의 합, 구간 [1, 3]의 합, ..., [1, n]의 합을 누적 합이라고 한다.

자연수를 나타내는 수열 An의 5항까지의 누적 합

※ 따라서 Prefix Sum의 각 요소는 해당 해당 인덱스까지의 부분 합(Partial Sum)을 의미한다. 부분 합은 급수에서 말하는 그 부분합의 의미가 맞다.

*누적 합의 사용

-> 누적 합은 그 목적에 따라 다양한 문제에 활용이 가능하다.

-> 대표적으로 누적 합을 사용하는 문제는 카운팅 정렬(Counting Sort), 구간 합 구하기가 존재한다.

*단순 반복을 이용한 구간 합 구하기

-> 이 글의 핵심 목적이다. 일반적으로 구간의 합을 구하는 경우에는 다음과 같이 모든 구간의 값을 더해주는 방법을 생각해볼 수 있다.

import java.util.Scanner;

public class PrefixSum {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] arr = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
		int[] arr2 = {1, 5, 8, 10, 24, 3, 5, 100, 99, 7};
		int a = sc.nextInt();
		int b = sc.nextInt();
		int sum1 = 0;
		int sum2 = 0;
		for(int i = a; i <= b; i++) {
			sum1 += arr[i];
			sum2 += arr2[i];
		}
		System.out.println(sum1);
		System.out.println(sum2);
		sc.close();
	}
}

3번 ~ 5번 인덱스의 구간합

하지만 이렇게 모든 입력마다 구간합을 일일히 구해주는 경우에는 구간의 길이가 M이라고 하면 매 구간합을 구할 때 마다 O(M)이라는 시간이 걸리게 된다. 즉, N개의 구간 에 대해 구간의 길이가 M인 구간합을 구하는 경우 O(NM)의 시간이 걸리는 것을 알 수 있다.

예를 들어, 자연수 구간 [1, 200,000]에서 각 자연수를 시작점으로 구간의 길이가 10000인 구간합을 모두 구하라는 문제를 생각해보면 해당 연산을 바탕으로 모든 구간합을 구하는 경우 총 20억번 가량의 연산을 진행하여야 한다.

*누적 합을 이용한 구간 합 구하기

-> 이러한 문제를 개선하기 위해 누적 합을 이용하여 구간 합을 구하는 방법을 사용한다면, 시간 복잡도를 O(N + M)까지 줄일 수 있다. 이 방법은 수열의 부분 합 관련 문제를 풀 때 많이 사용하던 아이디어를 가져오면 된다.

-> 일반적으로 수열 An에서 구간 [i, j]까지의 구간 합을 구하는 경우를 생각해보자.

그림과 같이 n항 까지의 합을 Sn이라고 정의한다면, 구간 [i, j]의 구간합은 Sj와 Si-1을 뺀 값을 구하여 바로 구할 수 있다. 즉, Sn까지의 구간합을 모두 구해 놓기만 한다면(O(M)) 구간 합을 구하는 연산 자체는 O(1)의 시간이면 구할 수 있기 때문에 결론적으로 O(N + M)의 시간 복잡도를 갖는 구간 합을 구하는 연산을 만들 수 있다.

-> 결론적으로 누적 합을 구하고, 그 누적합을 이용하여 주어진 구간의 합을 구하는 로직을 이용하여 구간 합을 더 빠르게 계산할 수 있다. 아래는 위와 같은 입력 값을 바탕으로 누적 합을 이용한 구간 합을 구하는 로직을 구현해 보았다.

import java.util.Scanner;

public class PrefixSum {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
		int[] arr2 = { 1, 5, 8, 10, 24, 3, 5, 100, 99, 7 };
		int a = sc.nextInt();
		int b = sc.nextInt();

		// 누적 합 구하기
		// 배열의 크기를 + 1하는 이유는, 0번 인덱스 ~ n번 인덱스의 구간합도 구할 수 있게 만들기 위함이다.
		int[] prefix_sum = new int[11];
		int[] prefix_sum2 = new int[11];
		for (int i = 1; i < arr.length; i++) {
			prefix_sum[i] += prefix_sum[i - 1] + arr[i];
			prefix_sum2[i] += prefix_sum2[i - 1] + arr2[i];
		}
		
		// 구간 합 구하기
		System.out.println(prefix_sum[b] - prefix_sum[a - 1]);
		System.out.println(prefix_sum2[b] - prefix_sum2[a - 1]);
		sc.close();
	}
}

3번 ~ 5번 인덱스의 구간합

※ 주석에도 언급해 두었지만, 0번째 인덱스 ~ n번째 인덱스의 구간 합도 구할 수 있게 만들기 위해서는 배열의 크기를 하나 늘려서 앞에 0이라는 값을 추가해주어야 0번째 인덱스에 대한 구간 합도 구할 수 있다.

[Java]거듭 제곱의 계산

sskl660 — Tue, 20 Apr 2021 17:17:25 +0900

*거듭 제곱의 계산

-> 거듭 제곱을 구현하는 방법은 간단하다. 기본적으로는 그 정의 그대로 어떤 수를 n번 곱하여 거듭제곱을 구현 가능하다. 하지만 n번 곱하기 때문에 시간복잡도는 O(n)이 걸린다는 것을 알 수 있다.

거듭제곱의 정의를 이용한 거듭 제곱

*개선된 거듭 제곱의 계산

-> 이러한 거듭 제곱은 분할 정복을 기반으로 시간복잡도를 O(logN)까지 줄일 수 있다!

-> 기본적인 아이디어는 다음과 같다. 예를 들어 5^10을 계산한다고 생각하였을 때, 아래와 같은 과정을 거쳐서 그 값을 구하는 것 이다.

거듭 제곱을 반으로 나눠, 한 값을 구하고 거듭 제곱이 짝수냐, 홀수냐에 따라 다르게 합치는 방식

-> 따라서, 재귀를 이용하여 다음과 같은 거듭제곱을 구현할 수 있음을 알 수 있다.

거듭 제곱 계산

*구현

-> 점화식도 구하였으니 그대로 구현하기만 해주면 된다.

import java.util.Scanner;

public class Exponentiation {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		long a = sc.nextInt(); // 밑
		long b = sc.nextInt(); // 지수

		System.out.println(pow(a, b));
		sc.close();
	}

	private static long pow(long a, long b) {
		// 지수가 0인 경우(종료 조건).
		if (b == 0) {
			return 1;
		}

		// 반으로 나눈 거듭제곱 계산.
		long res = pow(a, b / 2);

		// 지수가 짝수인 경우.
		if (b % 2 == 0) {
			return res * res;
		}
		// 지수가 홀수인 경우
		else {
			return res * res * a;
		}
	}
}

페르마의 소정리(Fermat's Little Theorem)

sskl660 — Tue, 20 Apr 2021 00:36:20 +0900

*페르마의 소정리(Fermat's Little Theorem)

-> 우선 페르마의 소정리를 활용하기 위해서는 기본적으로 모듈러 산술(연산)과 합동식에 대한 이해가 선행되어야 한다. 다음 포스팅을 참고하도록 하자. sskl660.tistory.com/75

모듈러 산술(Modular Arithmetic)

*모듈러 산술(Modular Arithmetic) -> 모듈러 산술(모듈러 연산)은 정수의 합과 곱을 어떤 주어진 수의 나머지를 이용하여 정의하는 방법을 말한다. -> 쉽게 말해 나머지를 이용한 산술 연산이라고 생

sskl660.tistory.com

-> 페르마의 소정리는 특정한 상황에서 어떤 수의 나머지를 빠르게 구할 때 사용이 가능하다. 특정한 상황은 아래 정리를 참고하도록 하자.

페르마의 소정리

쉽게 말해 a^(p - 1)과 1을 p로 나눈 나머지는 같다, 즉, a^(p - 1)의 나머지는 1이다라는 말이다.

-> 예를 들어, 97이라는 소수가 있고 5는 97의 배수가 아니기 때문에 5^(97 - 1) ≡ 1 (mod 97)이 성립한다는 것을 위 정리를 통해 알 수 있다. 여기에서 합동 관계의 거듭 제곱에 관련된 성질을 이용하면, 어마어마하게 큰 수의 나머지도 간단하게 구할 수 있는 경우가 존재함을 알 수 있게된다.

모듈러 산술(Modular Arithmetic)

sskl660 — Mon, 19 Apr 2021 23:54:04 +0900

*모듈러 산술(Modular Arithmetic)

-> 모듈러 산술(모듈러 연산)은 정수의 합과 곱을 어떤 주어진 수의 나머지를 이용하여 정의하는 방법을 말한다.

-> 쉽게 말해 나머지를 이용한 산술 연산이라고 생각하면 된다. 사칙 연산과 마찬가지로 정수의 나머지에도 연산과 관련된 개념이 존재한다.

-> 모듈러 연산은 정수론, 컴퓨터 과학의 보안 등 여러 분야에서 유용하게 사용될 수 있다. 알고 있다면 알고리즘 문제에서 몇몇 연산을 편하게 할 수 있는 방법을 생각하는 기반이 될 수 있다. 모듈러 연산 자체를 응용한 문제는 그렇게 많지 않지만, 이를 기반으로한 수학적 개념(정수론)의 기반이 되기 때문에 이해해두도록 하자.

*모듈러 산술 연산과 합동(Congruent)

-> 모듈러 산술 연산 : 쉽게 말해 나머지 연산을 하는 것을 말한다. 보통 언어에서 사용하는 %연산과 비교하여 작성해보면 다음과 같다.

mod 연산의 정의

-> 합동(Congruent) : mod 연산은 합동 관계를 바탕으로 두 수의 관계를 정의하는 경우가 많이 있다.

합동 관계의 정의

※ m | (a - b)에서 | 의 의미는 (a - b)는 m으로 나누어 떨어진다는 의미이다. 쉽게 말해, 10은 2로 나누어 떨어진다는 것을 수학적으로 표현하면 2 | 10이다. 나누어 떨어지지 않는 경우는 ł 라는 기호를 이용하여 표현한다.

※ 쉽게 말해 a - b가 m이라는 정수로 나누어 떨어진다면, a ≡ b (mod m)과 같이 표현하겠다라는 의미라고 생각하면 된다.

※ 이는 다르게 말하면, a와 b는 m에 의하여 나눠 졌을때의 나머지가 동일하다는 것을 의미한다. 이것을 조금 더 직관적으로 이해하기 위하여 예를 들어보면 어떤 수를 5로 나눌 때, 그 수의 나머지가 2인 것들을 모아서 생각해 보도록 하자. 그럼 아래와 같이 나열할 수 있을 것이다.

이때, 나누어지는 수들의 관계를 분석해보면 나누는 수 5에 의하여 나누어지는 수들 중 나머지가 같은 수(2, 7, 12...)는 나누는 수 만큼의 차이가 존재한다는 것을 알 수 있다. 즉, 5에 대한 나머지가 같은 수들의 집합에서 임의의 두 수를 꺼내서 빼도 항상 그 뺀 차이는 5로 나누어 떨어진다는 것을 알 수 있다. 따라서 이러한 규칙성을 m | (a - b)라고 표현한 것 뿐이고, 그것을 수식으로 표현한 것이다 a ≡ b (mod m)일 뿐이다.

*모듈러 산술 연산의 특징

-> 모듈러 산술 연산은 분배 법칙이 성립한다.

덧셈, 뺄셈, 곱셈에 대한 모듈러 산술 연산 분배 법칙

나눗셈의 경우 곱셈의 역원을 이용하여 분배법칙을 적용시킬 수 있다.

-> 예를 들면 (5 + 11) mod 7 = (5 mod 7 + 11 mod 7) + mod 7 = 2임을 알 수 있다.

*합동식의 성질

-> 사실상 이 글의 핵심으로, 모듈러 산술을 적용하기 위한 기본 재료가 되는 개념들이다. 증명에 대해서 이해를 해두는 것도 좋지만, 이 글은 알고리즘 문제에서 주로 사용되는 합동식의 성질 이해를 위주로 작성하겠다. 합동식의 성질에 대한 증명은 나무위키의 합동식 문서의 '성질' 문단에서 참고할 수 있다.

namu.wiki/w/%ED%95%A9%EB%8F%99%EC%8B%9D

합동식 - 나무위키

1. d∤bd\nmid bd∤b인데 해가 존재한다고 가정하자. 그럼 적당한 정수 yyy에 대하여 ax+my=bax+my=bax+my=b가 성립한다. 그런데 d∣ax+my=bd\mid ax+my=bd∣ax+my=b이므로 d∣bd\mid bd∣b이다. 이는 가정에 모순되므

namu.wiki

(1) 덧셈, 뺄셈, 곱셈에 관련된 성질

덧셈, 뺄셈에 관련된 성질

-> 쉽게 말해 a와 b로 m으로 나눈 나머지가 같고 c와 d를 m으로 나눈 나머지가 같으면 a ± c 와 b ± d 를 m으로 나눈 나머지도 같다는 의미이다. 예를 들면 49 ≡ 1 (mod 8)이고 37 ≡ 5 (mod 8)일 때 위의 성질에 의하여 86 ≡ 6 (mod 8)임을 알 수 있다.

곱셈에 관련된 성질

-> 위의 성질과 별로 다른 점이 없다. 곱셈에 대해서도 똑같은 논리가 적용된다. 예를 들면 33 ≡ 5 (mod 7)이고 122 ≡ 17 (mod 7)일 때 위의 성질에 의하여 4026 ≡ 85 (mod 7)임을 알 수 있다.

(2) 거듭 제곱에 관련된 성질

거듭 제곱에 관련된 성질

-> 이 역시 쉽게 말하면, a와 b를 m으로 나눈 나머지가 동일 하다면, 각 숫자를 동일하게 거듭제곱한 숫자를 m으로 나눈 나머지도 동일하다는 의미를 갖는다. 예를 들면 77 ≡ 7 (mod 8)일 때, 77^10 ≡ 7^10 (mod 8)도 성립한다는 것을 알 수 있다.

*합동식의 성질의 활용

-> 합동식의 성질을 활용하면 다음과 같이 일반적으로는 계산하기 힘든 문제도 간단하게 해결할 수 있다.

※ 3^333의 1의 자리수를 구하시오.

-> 1의 자리수를 구한다는 것은, 해당 숫자를 10으로 나눈 나머지를 구한다는 것과 같은 의미이다(특정 자리수를 구하는 것은 대상 숫자를 10의 거듭제곱 중 하나로 나누어 구할 수 있다).

-> 우선 거듭 제곱에 관련된 모듈러 산술의 성질을 이용하여 접근하기 위해 작은 숫자부터 규칙성을 찾아보자. 3 ^ 4 ≡ 1 (mod 10)이고, 따라서 거듭 제곱의 성질을 적용하면 3 ^ 332 ≡ 1 ^ 83 (mod 10)임을 알 수 있다. 즉 이 식은 3 ^ 332 ≡ 1 (mod 10)과 같고, 곱셈에 관련된 모듈러 산술의 성질을 이용하면 3 ^ 333 = 3 (mod 10)임을 알 수 있다. 따라서 3 ^333의 1의 자리수는 3임을 알 수 있다.

-> 물론 1의 자리수가 반복되는 규칙성을 이용해서도 문제를 해결할 수 있지만, 해당 문제를 풀기 위해 사용한 모듈러 산술의 아이디어를 활용하면 1, 10, 100의 자리 등을 구할 수 있음을 알 수 있다.

[Java]유클리드 호제법(Euclidean Algorithm)

sskl660 — Mon, 19 Apr 2021 18:16:50 +0900

*유클리드 호제법(Euclidean Algorithm)

-> 유클리드 호제법은 두 개의 자연수 or 두 개의 다항식의 최대공약수를 구하는 방법이다.

유클리드 호제법

※ a는 b의 피제수(즉, 나누어지는 수)이므로 a > b이다.

※ 따라서 수식의 q는 몫, r은 나머지를 의미한다(따라서 r은 0보다 같거나 크고 b보다는 작아야 한다).

-> 유클리드 호제법은 최대공약수를 구하는데 사용한다고 하였다. 최대공약수는 수학적으로 두 수의 모든 약수를 나열한 뒤 공통되는 약수 중 최대를 선택하거나 소인수 분해를 이용한 방법이 있지만, 유클리드 호제법을 이용하면 더 빠른 시간 안에 최대공약수를 구할 수 있다.

*유클리드 호제법의 사용

-> 피제수가 제수에 의해 나누어 떨어진다면, 그 피제수와 제수의 최대공약수는 제수이다. 이 명제를 응용하면 몇 번의 반복된 연산을 이용하여 최대공약수를 구할 수 있다.

-> 126과 45의 최대공약수를 구하는 아래 예시를 확인해보자.

126을 45로 나누면 그 몫은 대충 q라고 생각하고(최대공약수를 구한다면 굳이 생각하지 않아도 된다), 나머지는 36이 될 것이다. 126과 45의 최대공약수는 유클리드 호제법에 의하여 45와 36의 최대공약수와 같다고 하였으므로, 45에 대하여 36을 나누고 나머지를 구한다. 마찬가지 방법으로 45와 36의 최대공약수는 유클리드 호제법에 의하여 36과 9의 최대공약수와 같다. 그런데 여기서, 36은 9로 나누어 떨어지므로 36과 9의 최대 공약수는 9임을 알 수 있다. 즉, 앞선 과정을 반복하여 피제수가 제수에 의해 나누어 떨어지는 순간이 되면, 초기 두 자연수 혹은 두 다항식의 최대공약수를 구할 수 있다. 아래 예시도 확인 해보자. 본인이 쉽게 최대공약수를 알 수 있는 두 수를 선택해서 해당 로직을 적용해보면 더욱 좋다.

따라서, 510과 2의 최대공약수는 2임을 알 수 있고 이에 따라 1534와 1022의 최대 공약수도 2임을 알 수 있다.

*유클리드 호제법을 이용한 최대공약수를 구하는 방법 구현

-> 위의 로직을 정확히 이해하였다면 재귀 혹은 반복문을 이용하여 구현은 쉽게 할 수 있다. 아래 코드를 참고하도록 하자.

import java.util.Scanner;

public class EuclideanAlgorithm {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt(); // 제수
		int b = sc.nextInt(); // 피제수

		System.out.println(GCD(a, b));
		sc.close();
	}

	// 유클리드 호제법을 이용한 최대 공약수 구하기
	private static int GCD(int a, int b) {
		// 나머지가 0이라면 해당 수가 최종 최대 공약수이다.
		if (a % b == 0) {
			return b;
		}
		// 그렇지 않다면 제수를 다음 피제수로, 나머지를 다음 제수로 바꾸어 재귀를 진행한다.
		else {
			return GCD(b, a % b);
		}
	}
}

[Java]플로이드-워셜 알고리즘(Floyd-Warshall Algorithm)

sskl660 — Thu, 15 Apr 2021 22:44:08 +0900

*플로이드-워셜 알고리즘(Floyd-Warshall Algorithm)

-> 플로이드-워셜 알고리즘은 음수 사이클이 없는 그래프내의 각 모든 정점에서 각 모든 정점에 까지의 최단거리를 모두 구할 수 있는 알고리즘이다. 다익스트라 알고리즘과는 다르게 그래프에 음수 사이클만 존재하지 않으면, 음의 가중치를 갖는 간선이 존재해도 상관이 없다는 것이다.

※음수 사이클 : 사이클의 모든 경로를 지나 원래 지점으로 돌아 왔을때, 최종적인 비용이 음수가 되는 경우.

예를 들면, 위 그림에서 1번 노드에서 2번 노드로 갔다가, 2번 노드에서 1번 노드로 가면 최종적으로 -1의 비용으로 그래프를 방문하였으므로 음수 사이클이다. 아래 경우도 마찬가지이다.

*플로이드-워셜 알고리즘의 이해

-> 플로이드-워셜 알고리즘은 다이나믹 프로그래밍 기법을 사용한 알고리즘이고, 인접 행렬을 이용하여 각 노드간 최소 비용을 계산한다.

-> 플로이드-워셜 알고리즘은 모든 노드에서, 모든 노드로 가는 최소 비용을 단계적으로 갱신하면서 진행되는 알고리즘이다. 여기서 '단계적으로 갱신한다'란, 노드에서 노드로 가는 간선의 개수가 0개에서, N개(총 노드의 개수 만큼 간선을 선택)까지 몇 개의 간선을 거쳐서 해당 노드로 가는지를 모두 고려한다는 이야기이다. 아래 그래프를 바탕으로 이해해보자.

우선, 0개의 간선을 거쳐서 모든 노드에서 모든 노드로 가는 경우를 생각해보자. 0개의 간선을 거쳐서 모든 노드에서 모든 노드로 가는 방법은 자기 자신에서 자기 자신의 노드로 가는 경우 밖에 없다. 따라서, 초기 인접 행렬의 값은 자기 자신에서 자기 자신으로 가는 경우(=0)를 제외하고는 다른 노드로 갈 수 있는 방법이 없으므로 모두 매우 큰값으로 초기화해준다(N개의 정점을 모두 거쳐서 해당 정점으로 가더라도 그것보다 더 큰 값을 초기화 해주어야 한다). 그렇다면 인접행렬은 아래와 같은 값을 가지게 될 것이다(편의상 큰 값은 INF로 표시하겠다).

그 다음은 1개의 간선을 거쳐서 모든 노드에서 노드로 가는 경우를 생각해보자. 1개의 간선을 거쳐서 모든 노드로 가는 방법은, 말 그대로 주어진 그래프의 간선의 연결상태를 고려하라는 것이다. 물론 노드에서 노드로가는 간선이 여러가지 인 경우가 존재한다면, 그 간선 중 최소 비용인 것을 선택하면 된다. 보통 여기까지가 플로이드 관련 알고리즘 문제에서 초기화 단계에 속한다. 즉, 위 그림 그대로 간선의 연결 상태를 고려하여 인접행렬을 초기화하면 다음과 같을 것이다.

이렇게 간선 0개를 거친 경우, 1개를 거친 경우, ..., N개를 거친 경우의 최소 거리 비용을 비교하면서 인접행렬(각 정점에서 정점까지의 거리 비용을 나타냄)을 갱신하는 것이 플로이드 알고리즘의 매커니즘이다. 어차피 연결되어 있지 않는 노드는 초기에 매우 큰값(INF)으로 초기화되어 있을 것이고, 간선의 개수를 차례로 고려하면서 최소 비용이 고려될 것이므로 노드에서 노드로 가는 거리는 항상 최소인 상태를 유지할 것이다.

그 다음은 2개의 간선을 거쳐서 모든 노드에서 노드로 가는 경우를 생각해보자. 2개의 간선을 거쳐서 다른 노드로 가는 것을 고려하기 가장 쉬운 방법은 무엇일까? 여기에서 플로이드 알고리즘의 구현 아이디어를 얻을 수 있는데, 그것은 바로 특정 노드을 거쳐서 해당 노드로 가는 것이다. 예를 들어 아래 그림처럼 0번 정점을 기준으로 2번 노드에 대해서 생각해보면 다음과 같다.

2번 노드에서 0번 노드를 거쳐서 0번 노드로 가는 방법(2개의 간선을 지난다). 이때 값은 7이므로, 기존 값과 다른점이 없으므로 갱신이 일어나지 않는다.

2번 노드에서 0번 노드를 거쳐서 1번노드로 가는법. 이때 총 비용은 12이고, 기존의 비용은 3이므로 갱신이 일어나지 않는다.

2번 노드에서 0번 노드를 거쳐서 2번노드로 가는법. 이때 총 비용은 14이고, 기존의 비용은 0이므로 갱신이 일어나지 않는다.

2번 노드에서 0번 노드를 거쳐서 3번노드로 가는법. 이때 총 비용은 9이고, 기존의 비용은 10이므로 9로 갱신된다!

2번 노드에서 0번 노드를 거쳐서 4번노드로 가는법. 이때 총 비용은 8이고, 기존의 비용은 INF(갈수 없음)이므로 8로 갱신된다!

즉, 그림과 같은 방법을 모든 노드에 대해서 똑같이 고려해주는 것이다. 이렇게 N개의 간선, 즉, N개의 노드를 거쳐서 가는 경우까지 차례로 모두 고려해 준다면, 간선 0개 ~ N개를 거쳐서 해당 노드로 가는 비용 중 최솟값을 모두 고려가 가능하다는 것을 알 수 있다. 위의 그림을 바탕으로 2번 노드의 값들이 어떻게 갱신되었는지 확인해보자.

당연히 나머지 노드도 마찬가지 방식으로 갱신된 것이다.

※ 사실 자신의 노드에서 자신의 노드로 가는 간선은 문제에서 주어지지 않는 이상 0개이므로 설명 중 모순인 부분이 존재하지만, 이해를 조금 더 쉽게 돕기 위해 일관적이지 않게 설명을 해보았다.

*플로이드-워셜 알고리즘의 구현

-> 위의 내용만 정확히 이해했다면, 여타 다이나믹 프로그래밍 방식이 굉장히 간결한 코드를 이끌어 낸 것 처럼 플로이드 워셜 알고리즘의 코드도 굉장히 간결하게 표현된다는 것을 확인할 수 있다.

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

/*
sample input(첫 번째 숫자는 노드의 개수, 두 번째 숫자는 간선의 개수 이다).
5
8
0 1 5
0 4 1
0 2 7
0 3 2
1 2 3
1 3 6
2 3 10
3 4 4
 */
public class 플로이드 {
	static int N, M;
	static int[][] dist;

	public static void main(String[] args) throws NumberFormatException, IOException {
		// 초기화
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(br.readLine());
		M = Integer.parseInt(br.readLine());
		// 플로이드 초기 거리 테이블 초기화
		dist = new int[N][N];
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				// 자기 자신으로 가는 길은 최소 비용이 0이다.
				if (i == j) {
					dist[i][j] = 0;
					continue;
				}
				// 자기 자신으로 가는 경우를 제외하고는 매우 큰 값(N개의 노드를 모두 거쳐서 가더라도 더 큰 값).
				dist[i][j] = 100_000_000;
			}
		}

		for (int i = 0; i < M; i++) {
			StringTokenizer st = new StringTokenizer(br.readLine());
			int a = Integer.parseInt(st.nextToken());
			int b = Integer.parseInt(st.nextToken());
			int cost = Integer.parseInt(st.nextToken());

			// 가는 경로가 하나가 아닐 수 있다. 따라서 그 중 최소 비용을 저장해두면 된다.
			dist[a][b] = Math.min(dist[a][b], cost);
			dist[b][a] = Math.min(dist[b][a], cost);
		}

		// 플로이드 워셜 알고리즘
		// 노드를 1개부터 N개까지 거쳐가는 경우를 모두 고려한다.
		for (int k = 0; k < N; k++) {
			// 노드 i에서 j로 가는 경우.
			for (int i = 0; i < N; i++) {
				for (int j = 0; j < N; j++) {
					// k번째 노드를 거쳐가는 비용이 기존 비용보다 더 작은 경우 갱신
					// 또는 연결이 안되어있던 경우(INF) 연결 비용 갱신.
					dist[i][j] = Math.min(dist[i][j], dist[i][k] + dist[k][j]);
				}
			}
		}

		// 출력
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				// 연결이 안되어 있는 경우
				if (dist[i][j] == 100_000_000) {
					System.out.print("INF ");
				} else {
					System.out.print(dist[i][j] + " ");
				}
			}
			System.out.println();
		}
	}
}

최종 결과

*시간복잡도

-> 구현을 확인하면 알 수 있겠지만, 시간 복잡도를 구하는 방법은 매우 간단한다. 모든 노드(V)에 대해서, V x V 행렬을 갱신해주는 연산을 진행하므로 O(V^3)의 시간복잡도를 갖는다.

-> 무려 O(V^3)라는 시간 복잡도를 갖기 때문에, 입력의 크기가 100 정도만 되어도 백 만번의 연산이 수행되어야 한다. 따라서, 플로이드 알고리즘을 사용하는 경우는 입력의 크기를 주의깊게 살펴보도록 하자.

[Java]크루스칼 알고리즘(Kruskal Algorithm)

sskl660 — Thu, 15 Apr 2021 17:15:21 +0900

*크루스칼 알고리즘(Kruskal Algorithm)

-> 크루스칼 알고리즘은 그래프에서 최소 비용 신장 부분 트리(최소 신장 트리 : Minimum Spanning Tree(MST))를 찾는 알고리즘이다.

※ 최소 신장 트리, 신장 트리와 같은 용어를 조금 더 자세히 알고 싶다면 위키백과를 참고하도록 하자.

ko.wikipedia.org/wiki/%EC%8B%A0%EC%9E%A5_%EB%B6%80%EB%B6%84_%EA%B7%B8%EB%9E%98%ED%94%84

신장 부분 그래프 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 그래프의 신장 부분 나무 그래프 왼쪽의 그래프는 오른쪽과 같이 총 8개의 신장 부분 나무 그래프들을 갖는다. 그래프 이론에서, 신장 부분 그래프(身長部分grap

ko.wikipedia.org

*크루스칼 알고리즘의 매커니즘

-> 크루스칼 알고리즘은 기본적으로 그리디한 선택을 바탕으로 알고리즘을 진행한다.

(1) 주어진 그래프의 모든 간선에 대해서, 간선의 연결비용을 낮은 순으로 오름 차순 정렬한다.

(2) 정렬된 간선 순서대로 선택하면서, 간선의 양 끝 정점을 Union 한다. 단, 이때 선택된 두 정점이 같은 집합에 속해있다면 사이클(cycle)이 있다고 판단하고 포함시키지 않는다.

이러한 매커니즘을 바탕으로 최종 선택된 간선을 연결한 것이 최소 비용 신장트리이다.

※ 크루스칼 알고리즘은 사실상 서로소 집합만 정확히 알고 있으면 매커니즘은 어렵지 않다. 서로소 집합에 대해서 먼저 명확히 이해하고 있어야만 한다. 서로소 집합에 대하여 잘 모른다면 아래 글을 참고하도록 하자.

sskl660.tistory.com/71?category=845232

[Java] 서로소 집합(Disjoint Set)(Union-Find)(Merge-Find Set)

*서로소 집합(Disjoint Set) -> 서로소 집합 자료구조는 상호 배타적으로 이루어진 집합(서로소 집합 : 공통 원소가 없는 두 집합)을 효율적으로 표현하기 위해 만들어진 자료구조이다. -> 서로소 집

sskl660.tistory.com

-> 예를 들어 다음과 같은 그래프에서 최소 신장 트리를 찾아보도록 하자. 우선 첫 번째로, 연결된 간선의 연결 비용이 낮은 순으로 위에서 부터 오름차순 정렬하고, 다음 간선을 선택할때 사이클을 판단하기 위해 서로소 집합을 활용하기로 하였으므로, 각 노드의 초기 집합은 아래와 같을 것이다.

초기 상태

그 다음은 말 그대로 비용이 적은 간선의 양 끝 노드를 선택하면서 사이클이 존재하지 않는다면 Union 및 해당 간선 선택, 존재한다면 스킵하는 형태로 모든 간선에 대하여 탐색이 끝날 때 까지 동작을 반복하면 된다. 아래 그림들은 이 과정을 나타내는 예시이다.

먼저, 첫 번째 간선을 선택한다. 두 노드 2, 3은 서로 독립된 집합이기 때문에 Union을 진행하고 간선도 선택한다.

마찬가지 방법으로 두 번째 간선을 선택한다. 두 노드 1, 6은 서로 독립된 집합이므로 Union 및 간선을 선택한다.

여기까지는 앞 과정과 다른 것이 없다.

5, 6번 노드를 간선에 대해서는 각 노드 5번의 최종 부모는 1, 6번의 최종 부모는 1로 두 집합이 이미 같은 집합에 속해있음을 알 수 있다. 그림에서 확인해보면 알겠지만, 두 노드를 연결하는 순간 사이클이 발생한다. 따라서, 이 경우는 그냥 스킵하면 된다.

나머지 노드에 대해서도 마찬가지로 진행해주면, 최종적으로 선택된 간선(빨간색)이 최소 신장트리(MST)가 됨을 확인할 수 있다.

*크루스칼 알고리즘의 구현

-> 앞서 언급한대로 서로소 집합만 명확히 구현이 가능하다면, 크루스칼 알고리즘의 로직 자체는 크게 어렵지 않다는 것을 확인할 수 있다.

-> 위의 예시 그대로 크루스칼 알고리즘을 구현하면 아래와 같다. 보통 알고리즘 문제에서는 정렬된 상태로 주어지지 않기 때문에, 정렬되지 않은 상태로 입력을 주고 정렬하는 로직도 추가해 주었다.

import java.util.Arrays;
import java.util.Scanner;

/*
sample input(첫 줄의 첫 숫자는 정점의 개수, 두 번째 숫자는 간선의 개수).
6 9
1 6 5
2 4 6
1 2 7
3 5 15
5 6 9
3 4 10
1 3 11
2 3 3
4 5 7
 */

public class Kruskal {
	static int V, E;
	static int[][] graph;
	// 각 노드의 부모
	static int[] parent;
	// 최종적으로 연결된 최소 신장 트리 연결 비용.
	static int final_cost;

	public static void main(String[] args) {
		// 그래프의 연결상태(노드1, 노드2, 비용)를 초기화.
		Scanner sc = new Scanner(System.in);
		V = sc.nextInt();
		E = sc.nextInt();
		graph = new int[E][3];
		for (int i = 0; i < E; i++) {
			graph[i][0] = sc.nextInt();
			graph[i][1] = sc.nextInt();
			graph[i][2] = sc.nextInt();
		}
		parent = new int[V];
		final_cost = 0;

		// 간선 비용 순으로 오름차순 정렬
		Arrays.sort(graph, (o1, o2) -> Integer.compare(o1[2], o2[2]));

		// makeSet
		for (int i = 0; i < V; i++) {
			parent[i] = i;
		}
		// 낮은 비용부터 크루스칼 알고리즘 진행
		for (int i = 0; i < E; i++) {
			// 사이클이 존재하지 않는 경우에만 간선을 선택한다(여기서는 최종 비용만 고려하도록 하겠다).
			if (find(graph[i][0] - 1) != find(graph[i][1] - 1)) {
				System.out.println("<선택된 간선>");
				System.out.println(Arrays.toString(graph[i]));
				union(graph[i][0] - 1, graph[i][1] - 1);
				final_cost += graph[i][2];
				System.out.println("<각 노드가 가리키고 있는 부모>");
				System.out.println(Arrays.toString(parent) + "\n");
				continue;
			}
		}
		
		System.out.println("최종 비용 : " + final_cost);
		sc.close();
	}

	private static void union(int a, int b) {
		a = find(a);
		b = find(b);
		if (a > b) {
			parent[a] = b;
		} else {
			parent[b] = a;
		}
	}

	private static int find(int x) {
		if (parent[x] == x)
			return x;
		else
			return find(parent[x]);
	}
}

결과

※ Find 연산에서 경로 압축 기법을 사용하는 경우, 부모가 다르게 나올 수 있다. 경로 압축 기법을 명확히 이해 했다면 무슨 소리 인지 이해할 수 있을 것이다.

*시간 복잡도

-> 크루스칼 알고리즘은 O(ElogV)의 시간복잡도를 갖는다. 간단히 말하면 모든 가중치를 정렬하는데 걸리는 시간이 O(ElogE) 시간복잡도를 갖는데, 크루스칼 알고리즘에서 이 연산보다 영향력이 있는 연산은 없기 때문에 최종적으로 O(ElogE)가 걸린다고 생각하는 것이다. 이때, 간선의 수는 최대 V^2개가 될 수 있으므로 O(logE) = O(logV^2) = O(2logV) = O(logV)로도 볼 수 있고, 최종적으로 O(ElogV)의 시간 복잡도를 갖는 것이다.

-> 크루스칼 알고리즘의 자세한 증명과 시간 복잡도 증명은 위키백과를 참고하도록 하자.

ko.wikipedia.org/wiki/%ED%81%AC%EB%9F%AC%EC%8A%A4%EC%BB%AC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98

크러스컬 알고리즘 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 컴퓨터 과학에서, 크러스컬 알고리즘(영어: Kruskal’s algorithm)은 최소 비용 신장 부분 트리를 찾는 알고리즘이다. 변의 개수를 E {\displaystyle E} , 꼭짓점의 개수를

ko.wikipedia.org

[Java]서로소 집합(Disjoint Set)(Union-Find)(Merge-Find Set)

sskl660 — Thu, 15 Apr 2021 11:08:39 +0900

*서로소 집합(Disjoint Set)

-> 서로소 집합 자료구조는 상호 배타적으로 이루어진 집합(서로소 집합 : 공통 원소가 없는 두 집합)을 효율적으로 표현하기 위해 만들어진 자료구조이다.

-> 서로소 집합은 서로 다른 두 개의 집합을 병합하는 연산(Union)(Merge)과 집합의 원소가 어떤 집합에 속해 있는지 판단하는 연산(Find)을 기반으로 구현되기 때문에, Union-Find 혹은 Merge-Find Set이라고도 불린다.

-> 서로소 집합을 구현하는 방법은 연결 리스트를 이용하는 방법과, 트리를 이용하는 방법이 있는데, 이 글에서는 트리를 이용하는 방법에 대해서만 다룬다.

*서로소 집합의 단순 구현(트리)

-> 서로소 집합은 기본적으로 총 3가지 연산(MakeSet, Find, Union)으로 구성되어 있다.

(1) MakeSet 연산 : 대상 원소들을 우선 모두 각각 독립된 집합으로 분리하는 과정이다. 서로소 집합은 대상 원소가 각각 어떤 집합에 포함되어 있는지 번호를 주어 표시한다. 우선 처음 주어지는 원소들은 따로 집합이 정해져 있지 않기 때문에, 자기 자신의 원소 번호를 자신이 속해있는 집합으로 초기화하는 과정이라고 생각하면 된다. 앞으로 1, 2, 3, 4, 5원소를 기준으로 예를 들어 서로소 집합을 구현해보도록 하겠다.

초기 원소는 자기 자신의 번호를 자신이 속한 집합이라고 인식한다.

자기 자신이 가리키는 대상 = 자신이 속한 집합이 되기 때문에, 자기 자신이 가리키는 대상을 parent(부모)라고 표현하기도 한다. 이를 바탕으로 코드를 구현하면 다음과 같다.

import java.util.Arrays;

public class DisjointSet {
	public static void main(String[] args) {
		int[] parent = MakeSet(5);
		// 각 인덱스(=노드)는 자기 자신을 가리키고 있다
		System.out.println(Arrays.toString(parent));
	}

	private static int[] MakeSet(int size) {
		// 각 인덱스에 번호가 대응하도록 사이즈를 1더하여 배열 선언.
		int[] arr = new int[size + 1];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		return arr;
	}
}

결과

(2) Union 연산, Find 연산 : 다음은 서로소 집합을 하나의 집합으로 합쳐주는 연산인 Union 연산과 대상 원소가 어떤 대상을 가리키는지, 즉 어떤 집합에 포함되어 있는지(부모가 누구인지)를 파악하는 연산인 Find 연산을 구현해보자. 두 연산은 구현 상에서 서로 밀접한 관계가 있기 때문에, 동시에 이해하는 것이 낫다.

-> 먼저 Union 연산을 살펴보자. 서로 다른 두 원소를 같은 집합으로 포함시키기 위해서는 어떤 방법을 사용할까? 정답은 두 원소가 모두 같은 부모(parent)를 가리키도록 값을 변경해주면 된다. 이 경우 보통 두 원소중 작은 값을 기준으로 가리키는 부모를 통일 시켜준다(자세한 내용은 뒤의 최적화와 관련된 내용 참고!). 이를 테면 원소 1, 2를 같은 집합으로 속하게 만들고 싶다면 아래와 같은 그림이 될 것이다.

1, 2가 같은 집합에 속해있다면, 원소 2는 1을 부모로 가리켜야 한다.

그림과 같은 상황이라면, 각 원소는 {1, 1, 3, 4, 5}와 같은 형태로 가리키는 대상이 설정되어 있을 것이다.

-> 위와 같은 상황을 이해하면, Find 연산을 구현하는 것은 쉽다. 찾고자 하는 원소가 자신의 인덱스 값과 같다면, 즉 자기 자신이 부모인 상황이라면 그 값이 그 집합을 대표하는 번호일 것이다. 그렇지 않다면, 지금 원소가 가리키는 값을 재귀적으로 다시 Find 함수에 넘겨주어 부모 노드까지 탐색을 하면 된다. 즉, 재귀함수를 이용하여 구현할 수 있다.

private static int find(int[] parent, int x) {
  // 만일, 찾는 대상과 인덱스 번호가 같다면 그 인덱스(=노드)가 해당 집합의 부모이다.
  if(parent[x] == x)
	return x;
  // 그렇지 않다면, 해당 인덱스가 가리키는 값(부모 노드)을 따라 최종 부모노드까지 탐색한다.
  else
 	return find(parent, parent[x]);
}

-> Find 연산을 구현했으니, 이제 Union 연산을 구현하면 될 것 같지만 한가지 주의할 점이 있다. 그것은 Union 연산은 서로 다른 '두 집합'을 합치는 연산이라는 것이다. 예를들어 지금까지의 논리로 앞서 만든 집합의 상태에서 3을 1, 2의 집합에 포함시키고, 4, 5를 또 다른 집합으로 만들었다고 가정해보자. 그렇다면 다음과 같은 그림이 될 것이다.

원소 1, 2, 3이 같은 집합이고 4, 5가 같은 집합이다.

그렇다면 이 상태에서 원소 3, 5를 이용하여 두 집합을 합치는 경우 다음과 같은 실수를 범해서는 안된다.

private static void union(int[] parent, int a, int b) {
	// 각 대상이 가리키는 부모를 구한다.
	int o1 = find(parent, a);
	int o2 = find(parent, b);
	// 부모가 작은 쪽으로 흡수해야 하므로 분기문을 나눈다.
	if (o1 > o2) {
		// a원소의 부모를 b원소의 부모로 바꾼다.
		parent[a] = o2;
	} else {
		// b원소의 부모를 a원소의 부모로 바꾼다.
		parent[b] = o1;
	}
}

이렇게 하게 된다면 원소 5에 대해서만 3이 포함된 집합의 부모를 가리키게 된다. 즉 다음과 같은 그림의 상황이 된다.

두 집합이 합쳐진 것이 아니라, 원소만 해당 집합으로 편입 되었다.

서로소 집합에서 '합치기 연산'은 앞서 말했지만 '두 집합을 합치는 연산'이다. 따라서, 두 집합의 부모(대표자)가 다른 부모를 가리키도록 로직을 설계해주어야 한다! 그렇다면 아래와 같은 코드로 구현할 수 있을 것이고, 그림은 다음과 같은 것이다.

private static void union(int[] parent, int a, int b) {
	// 각 집합을 대표하는 부모가 다른 부모로 편입 되어야 한다. 원소가 편입되어서는 안된다.
	a = find(parent, a);
	b = find(parent, b);
	if (a > b) {
		parent[a] = b;
	} else {
		parent[b] = a;
	}
}

두 서로소 집합을 하나의 집합으로 합친 모습

이 모든 과정을 하나의 코드로 합치면 아래와 같고, 앞서 합친 순서대로 결과를 출력해보면 다음과 같을 것이다.

import java.util.Arrays;

public class DisjointSet {
	public static void main(String[] args) {
		int[] parent = MakeSet(5);
		// 각 인덱스(=노드)는 자기 자신을 가리키고 있다
		System.out.println(Arrays.toString(parent));

		union(parent, 1, 2);
		System.out.println(Arrays.toString(parent));
		union(parent, 2, 3);
		System.out.println(Arrays.toString(parent));
		union(parent, 4, 5);
		System.out.println(Arrays.toString(parent));
		union(parent, 3, 5);
		System.out.println(Arrays.toString(parent));
		System.out.println(find(parent, 1));
		System.out.println(find(parent, 2));
		System.out.println(find(parent, 3));
		System.out.println(find(parent, 4));
		System.out.println(find(parent, 5));
	}

	private static void union(int[] parent, int a, int b) {
		// 각 집합을 대표하는 부모가 다른 부모로 편입 되어야 한다. 원소가 편입되어서는 안된다.
		a = find(parent, a);
		b = find(parent, b);
		if (a > b) {
			parent[a] = b;
		} else {
			parent[b] = a;
		}
	}

	private static int find(int[] parent, int x) {
		// 만일, 찾는 대상과 인덱스 번호가 같다면 그 인덱스(=노드)가 해당 집합의 부모이다.
		if (parent[x] == x)
			return x;
		// 그렇지 않다면, 해당 인덱스가 가리키는 값(부모 노드)을 따라 최종 부모노드까지 탐색한다.
		else
			return find(parent, parent[x]);
	}

	private static int[] MakeSet(int size) {
		// 각 인덱스에 번호가 대응하도록 사이즈를 1더하여 배열 선언.
		int[] arr = new int[size + 1];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		return arr;
	}
}

※ 알고리즘 문제 풀이시 주의점 : 여기서 parent 배열은 '각 원소의 부모'를 나타내는 것 뿐이지 각 원소가 실제로 어떤 집합에 속해있는지를 표현해주지 않는다. 각 원소가 어떤 집합에 속해있는지를 파악하기 위해서는 반드시 Find 연산을 사용해야만 한다.

*시간복잡도

-> 우선 기본적으로 Union 연산과 Find 연산을 살펴보면 Union 연산내에서 가장 큰 영향을 미치는 연산이 Find 연산임을 알 수 있다. 즉, Union 연산과 Find 연산의 시간 복잡도는 동일하다.

-> 트리의 원소가 편중되어 있는 형태라면, 매 연산마다 노드의 끝까지 탐색해야 되기 때문에 O(n)의 시간복잡도를 가지게 될 것이다.

트리가 편중된 경우

*서로소 집합 최적화

-> 앞선 서로소 집합의 성능을 개선하기 위하여, Union 연산 혹은 Find 연산에서 각각 연산의 성능을 향상시키는 방법이 존재한다. 두 방법 중 하나를 선택하면 되지만, 보통 경로 압축(Path Compression)기법을 기반으로한 Find 연산에서의 최적화 방법을 자주 사용한다.

(1) Union 연산에서의 최적화(Union by Rank) : 두 집합을 서로 합치는 과정에서 아무런 기준없이 합치게 된다면 트리의 깊이가 깊어질 수도 있는 문제가 발생한다. 예를 들어, 원소 1, 2가 같은 집합이고 3, 4, 5가 같은 집합인 경우 1, 2 집합을 3, 4, 5 집합에 합치는 경우는 문제가 발생하지 않는다. 즉, 원소의 개수가 적은 집합이 많은 집합에 편입된다면 문제가 발생하지 않는다.

원소의 개수가 적은 집합이 흡수되는 경우 전체 트리의 깊이는 변화하지 않는다.

하지만 반대로 원소의 개수가 많은 집합이 적은 집합으로 편입된다면 트리의 깊이가 점점 깊어지는 문제가 발생한다.

원소의 개수가 많은 집합이 흡수되는 경우 전체 트리의 깊이는 점점 커진다.

이렇게 깊이가 점점 깊어지면, Find 연산이 재귀의 형태로 이루어져 있으므로 Find 연산을 수행할 때 최악의경우 O(n)의 시간복잡도를 갖는다. 이를 해결하기 위하여 Rank를 이용한 Union 연산(Union by Rank)을 진행한다. 이 연산은 간단히 말하면, 기존에 두 집합을 합하는 과정에서 부모 노드의 번호가 작은 쪽으로 편입하는 대신, 각 집합의 크기(트리의 깊이)를 Rank라는 값으로 기억해두고 앞서 언급한대로 Rank가 더 큰 쪽으로 트리를 편입시키는 방법을 사용한다. 이 경우 시간 복잡도를 O(logN)까지 줄일 수 있다. 이 글에서는 Rank를 이용한 방법으로 따로 구현을 하지는 않겠다. 개념만 알아두도록 하자.

(2) Find 연산에서의 최적화(경로 압축 : Path Compression) : 앞서 Rank를 이용한 방법보다 구현이 더 쉽기 때문에 서로소 집합 연산의 성능을 향상 시킬때 자주 사용되는 방법이다. 이 방법은 Find 연산이 재귀의 형태로 구현된 점, 매 탐색마다 트리의 부모 노드까지 탐색하는 비효율을 방지한다는 두 가지 아이디어를 바탕으로 구현할 수 있다. 예를 들어 다음과 같은 그림에서 각 원소는 각자의 부모를 가리키고 있지만, 실상 Find 연산을 사용하면 그 부모가 모두 똑같은 1임을 알 수 있다.

파란색 : 각 원소가 가리키는 대상(parent 배열), 빨간색 : Find 연산을 수행하면 실제로 각 원소가 가리키는 최종 부모.

따라서, 이러한 점을 활용하여 재귀를 반환(return)하는 과정에서 각 부모를 최종 부모로 바꿔주면서 반환하여 각 원소의 최종 부모를 통일 시켜준다.

Find 연산을 반환하는 과정에서 각 부모를 최종 부모로 갱신 시켜준다.

그렇다면 트리는 최종적으로 다음과 같은 구조를 가지게 될 것이다. 다만 이 그림에서 알 수 있듯이, Find 연산은 낮은 깊이에서 탐색을 시작한다면, 더 깊은 대상은 최적화가 되지 않는다는 단점이 존재한다.(만일, 5가 아닌 3에 대해서만 Find 연산을 수행한 경우를 생각해보자).

경로 압축을 통한 최종 트리 구조.

즉, find 연산를 다음과 같이 개선하여 구현할 수 있다.

private static int find(int[] parent, int x) {
	// 만일, 찾는 대상과 인덱스 번호가 같다면 그 인덱스(=노드)가 해당 집합의 부모이다.
	if (parent[x] == x)
		return x;
	// 경로 압축
	else
		return parent[x] = find(parent, parent[x]);
}

이 경우 시간 복잡도를 O(α(n))까지 줄일 수 있다. 이는 사실상 O(1)의 시간복잡도와 유사하다고 생각하면 된다.

※ α(n) 이란?

-> 굳이 알 필요는 없지만, 간단히 서술하자면 여기서 α(n)는 아커만 함수의 역함수이다. 간단히 말하면 아커만 함수는 작은 입력으로 매우 큰 증가를 만드는 함수인데(우리가 아는 팩토리얼 연산보다도 더 심하다!), 이 함수의 역함수 이기 때문에, 반대로 어떤 큰 입력이 와도 작은 값을 도출할 것(보통 α(n)은 실용적으로 5보다 작다고 알려져 있다)이다. 따라서 기존 서로소 집합 연산에 비하여 더 빠른 연산이 가능한 것이다. 자세한 내용은 아커만 함수 위키백과의 '역함수' 파트를 참고하도록 하자. ko.wikipedia.org/wiki/%EC%95%84%EC%BB%A4%EB%A7%8C_%ED%95%A8%EC%88%98

아커만 함수 - 위키백과, 우리 모두의 백과사전

위키백과, 우리 모두의 백과사전. 계산 가능성 이론에서, 빌헬름 아커만의 이름을 딴 아커만 함수(Ackermann函數, 영어: Ackermann function)는 원시 재귀 함수가 아닌 전역적인 재귀 함수(계산가능 함수)

ko.wikipedia.org

※ 두 기법을 동시에 사용하는 것은?

-> 서로소 집합 연산의 성능을 향상 시키기 위한 방법이 2가지나 존재하기 때문에, 그렇다면 이 2가지 방법을 동시에 사용하면 성능이 좋지 않을까? 라는 의문을 가질 수 있다. 일리 있는 말이지만, Rank 관리 기법은 트리의 깊이를 다루는 방법이었고, 경로 압축 기법에서는 경로를 압축할 때 마다 트리의 깊이가 시시각각으로 변화하였다. 그런데 이렇게 경로압축을 통해 시시각각 변화하는 트리의 깊이를 따로 관리하고, Rank 관리 기법에 그 깊이들을 다시 활용하는 방식은 굉장히 복잡하다. 따라서 보통 두 방법 중 하나만 사용하더라도, 코딩테스트 대비 성능 면에서는 충분하다.

*총정리

-> 경로 압축 기법을 적용하고, 각 코드를 최대한 간소화 시켜 코드를 작성하면 서로소 집합은 다음과 같이 구현할 수 있다.

package pr;

import java.util.Arrays;

public class DisjointSet {
	static int[] parent;

	public static void main(String[] args) {
		// makeSet
		parent = new int[5];
		// 각 인덱스(=노드)는 자기 자신을 가리키고 있다
		parent = MakeSet(5);
		System.out.println(Arrays.toString(parent));
		
		// 1이 포함된 집합, 2가 포함된 집합 합치기.
		union(1, 2);
		System.out.println(Arrays.toString(parent));
		// 2가 포함된 집합, 3이 포함된 집합 합치기.
		union(2, 3);
		System.out.println(Arrays.toString(parent));
		// 4가 포함된 집합, 5가 포함된 집합 합치기.
		union(4, 5);
		System.out.println(Arrays.toString(parent));
		// 3이 포함된 집합, 5가 포함된 집합 합치기.
		union(3, 5);
		System.out.println(Arrays.toString(parent));
		
		// Find 연산을 통한 각 노드가 속한 집합 확인.
		System.out.println(find(1));
		System.out.println(find(2));
		System.out.println(find(3));
		System.out.println(find(4));
		System.out.println(find(5));
	}

	// Union
	private static void union(int a, int b) {
		// 각 집합을 대표하는 부모가 다른 부모로 편입 되어야 한다. 원소가 편입되어서는 안된다.
		a = find(a);
		b = find(b);
		// 일반적으로 더 작은 값으로 다른 집합이 편입되도록 한다.
		if (a > b) {
			parent[a] = b;
		} else {
			parent[b] = a;
		}
	}

	// Find
	private static int find(int x) {
		// 만일, 찾는 대상과 인덱스 번호가 같다면 그 인덱스(=노드)가 해당 집합의 부모이다.
		if (parent[x] == x)
			return x;
		// 경로 압축
		else
			return parent[x] = find(parent[x]);
	}

	// makeSet
	private static int[] MakeSet(int size) {
		// 각 인덱스에 번호가 대응하도록 사이즈를 1더하여 배열 선언.
		int[] arr = new int[size + 1];
		for (int i = 0; i < arr.length; i++) {
			arr[i] = i;
		}
		return arr;
	}
}

[Database]서브 쿼리(MySQL)

sskl660 — Mon, 12 Apr 2021 14:33:28 +0900

*서브 쿼리(SubQuery)

-> 서브 쿼리란 말 그대로 다른 쿼리 내부에 포함되어 있는 쿼리를 말한다.

-> SELECT 문을 이용한 데이터 조회는 결과적으로 검색 조건을 만족하는 또 하나의 테이블을 만들어 내는 것을 의미한다고 볼 수 있다. 이러한 점을 활용하여 검색 결과 테이블을 활용하여 다시 쿼리를 진행하는 것을 서브 쿼리라고 생각하면 이해하기 쉽다.

*서브 쿼리의 종류

-> 서브쿼리는 쿼리의 위치가 어디에 있느냐에 따라서 세 가지 종류로 나눌 수 있다.

(1) 중첩 서브 쿼리(Nested Subquery) : WHERE절에 사용하는 서브 쿼리.

(2) 인라인 뷰(Inline View) : FROM절에 사용하는 서브 쿼리.

(3) 스칼라 서브 쿼리(Scalar Subquery) : SELECT절에 사용하는 서브 쿼리.

*MySQL Sample Database

-> 아래 데이터베이스는 MySQL에서 기본적으로 제공해주는 연습용 SQL 테이블 데이터이다. 해당 데이터를 이용하여 쿼리를 연습해보도록 하겠다.

www.mysqltutorial.org/mysql-sample-database.aspx/

*서브 쿼리의 사용

-> 예를 들어 특정 이름을 가진 고객의 주문 정보를 조회한다고 생각해보자. 먼저 Join을 이용하면 다음과 같은 방법을 사용해볼 수 있다.

-- 이름이 "Atelier graphique"인 고객의 주문 정보
select orderNumber, orderDate
from customers c join orders o
on c.customerNumber = o.customerNumber
where customerName = "Atelier graphique";

하지만, 서브 쿼리를 이용하면 테이블을 굳이 조합하지 않더라도 해당 고객의 정보를 서브 쿼리를 이용하여 가져 온 뒤 쿼리를 연결하여 정보를 조회할 수도 있다.

-- 이름이 "Atelier graphique"인 고객의 주문 정보
select orderNumber, orderDate
from orders
where customerNumber = (select customerNumber
			from customers
                      where customerName = "Atelier graphique");

어떤 검색 조건을 만족하는 테이블을 조회하는 방법은 이와 같이 여러가지 방법이 사용될 수 있다. 따라서, 적절한 경우에 적절한 쿼리를 사용하여 테이블을 조회하는 방법을 고민하는 것이 바람직하다(상황에 따라 어떤 쿼리를 쓰느냐에 따라 효율이 달라질 수 있다).

*중첩 서브 쿼리(Nested Subquery) : WHERE절에 사용하는 서브 쿼리.

(1) 단일 행 서브쿼리 : 서브 쿼리의 결과가 1개의 행을 도출하는 경우 단일 행 서브쿼리라고 한다. 위의 예시는 단일 행 서브쿼리라고 볼 수 있다.

-- 전체 상품의 평균 가격보다 가격이 높은 주문 정보
select *
from orderdetails
where priceEach > (select avg(buyPrice)
		from products)
order by priceEach;

(2) 다중 행 서브쿼리 : 서브 쿼리의 결과가 여러개의 행을 도출하는 경우 다중 행 서브쿼리라고 한다.

-- IN : 서브 쿼리 결과중 하나의 값이라도 같은 값이 존재한다면
-- 구매 가격이 40 ~ 45사이인 물건들의 주문 내역
select orderNumber, productCode, priceEach
from orderdetails
where productCode in (select productCode
			from products
			where buyPrice between 40 and 45);

다중 행 서브 쿼리를 사용하는 경우, 서브 쿼리로 출력되는 결과행이 다수이기 때문에 IN, ANY, ALL과 같은 복수 행 연산자를 사용하여야 한다.

-- ANY : 서브 쿼리 결과에 대하여 어느 하나의 값이라도 만족하면 결과 반환.
-- 전체 물건의 구매 가격에 대하여 하나라도 주문 가격이 낮은 경우
select orderNumber, productCode, priceEach
from orderdetails
where priceEach < any (select buyPrice
		from products);

-- ALL : 서브 쿼리 결과에 대하여 모든 값이 만족해야만 결과 반환.
-- 전체 물건의 구매 가격에 대하여 항상 주문 가격이 높은 경우
select orderNumber, productCode, priceEach
from orderdetails
where priceEach > all (select buyPrice
		from products);

(3) 다중 열 서브쿼리 : 서브 쿼리의 결과가 여러 열을 도출하는 경우 다중 열 서브쿼리라고 한다.

-- 사무실 코드가 1인 사원들의 매니저, 직업이 일치하는 사원들의 사번과 이름
select employeeNumber, lastName, firstName
from employees
where (reportsTo, jobTitle) in (select reportsTo, jobTitle
				from employees
				where officeCode = 1);

*인라인 뷰(Inline View) : FROM절에 사용하는 서브 쿼리.

-> 앞서 SELECT 문을 이용한 데이터 조회는 결과적으로 검색 조건을 만족하는 또 하나의 테이블을 만들어 내는 것을 의미한다고 하였었다. 인라인 뷰는 이러한 점을 적극 활용하여 FROM절에 동적으로 생성된 테이블을 배치하여 질의를 수행하는 방법이다.

-- 모든 고객의 평균 신용 한도보다 신용 한도가 큰 고객들의 담당 직원
select *
from (select customerNumber, salesRepEmployeeNumber, creditLimit
	  from customers
	  where creditLimit > (select avg(creditLimit) from customers)) a join employees e
on a.salesRepEmployeeNumber = e.employeeNumber
order by creditLimit;

*스칼라 서브 쿼리(Scalar Subquery) : SELECT절에 사용하는 서브 쿼리.

-> 마찬가지로 데이터 조회를 통해 만들어진 결과를 SELECT 절에 배치하여 결과를 형성한다. 원리를 바탕으로 생각하면 크게 이해하기 어렵지 않다.

-- 고객번호가 120 ~ 150번인 고객들의 고객 정보와 담당 직원 이름
select customerNumber, customerName, salesRepEmployeeNumber, 
(select lastName from employees where customers.salesRepEmployeeNumber = employees.employeeNumber) as Counselor
from customers
where customerNumber between 120 and 150;

*서브 쿼리와 DDL, DML

-> 쿼리의 결과가 또 하나의 테이블을 반환한다는 점을 이용하여 CREATE, INSERT, UPDATE, DELETE문에 다양하게 활용할 수 있다.

-- CREATE 문에서 테이블을 복사하는 경우
create table student2
select * from student;

create table student2
select studentNo, studentName, grade from student;

-- 테이블의 구조만 복사하고 싶은 경우(WHERE절을 활용한다).
create table student2
select * from student
where false;

-- INSERT 문에서 테이블 데이터를 복사하는 경우
insert into student2
select * from student;

[Database]조인과 집합연산(MySQL)

sskl660 — Sun, 11 Apr 2021 22:26:34 +0900

*조인(Join)

-> 조인이란 둘 이상의 테이블에서 데이터가 필요한 경우, 여러 테이블을 조합하여 데이터를 사용하기 위해 사용되는 연산이다.

-> 기본적으로 RDBMS는 중복 데이터를 최소화하기 위하여 데이터를 쪼개서 저장하기 때문에, 이러한 조인 연산이 필요하다.

*MySQL Sample Database

-> 아래 데이터베이스는 MySQL에서 기본적으로 제공해주는 연습용 SQL 테이블 데이터이다. 해당 데이터를 이용하여 쿼리를 연습해보도록 하겠다.

www.mysqltutorial.org/mysql-sample-database.aspx/

MySQL Sample Database

This page provides you with a MySQL sample database that helps you to practice with MySQL effectively and quickly. You can download the sample database and load it into your MySQL Server.

www.mysqltutorial.org

*INNER JOIN

-> 가장 일반적인 조인으로써, 조건에 맞는 테이블의 교집합을 추출해내는 조인이라고 생각하면 이해하기 쉽다.

서로 연관된 내용을 검색하고 출력한다.

※ 조인 조건 : 두 테이블을 연결시키는 기준을 설정한다. 이 기준에 따라서 크게 동등 조인과 비동등 조인으로 조인이 분류되기도 한다.

(1) 동등 조인(EQUI JOIN) : 테이블의 기본키(Primary Key), 외래키(Foreign Key) 관계를 기반으로 테이블을 조합하는 방식이다. 쉽게 말해 서로 같은 값을 갖는 조건을 활용하여 테이블을 조합한다.

-- customer 테이블의 기본키인 customerNumber와 orders 테이블의 외래키인 customerNumber를 이용하여 테이블을 조인
select *
from customers join orders
on customers.customerNumber = orders.customerNumber;

조인은 테이블을 합치는 과정이기 때문에, 중복되는 열에 대하여 어떤 테이블의 소유인지 명시를 해주어야 한다. 위와 같이 테이블이름을 모두 적어주는 방법도 있지만, 별칭을 활용하는 방법도 사용할 수 있다.

-- customer 테이블의 기본키인 customerNumber와 orders 테이블의 외래키인 customerNumber를 이용하여 테이블을 조인
select *
from customers c join orders o
on c.customerNumber = o.customerNumber;

위와 같이 테이블을 조인하는 경우, 해당 조인 조건에 대응하는 모든 경우의 수를 산출한다. 이를 CROSS JOIN 혹은 Cartesian Product라고도 하며 일반적인 경우에는 모든 경우의 수를 산출하는 경우가 거의 없으므로 자주 사용하지 않는다.

customer 테이블

order테이블

Cartesian Product(Cross Join)결과. 고객의 주문 수에 따라 고객의 정보가 중복되는 것을 확인할 수 있다.

따라서 보통 INNER JOIN은 WHERE 절과 함께 사용하여 원하는 검색 결과만 조회하는 경우가 많다.

-- 103번 고객의 주문 내역
select c.customerNumber, c.customerName, o.orderNumber, o.orderDate
from customers c join orders o
on c.customerNumber = o.customerNumber
where c.customerNumber = 103;

결과

-- 103번 ~ 120번 고객의 주문 내역
select c.customerNumber, c.customerName, o.orderNumber, o.orderDate
from customers c join orders o
on c.customerNumber = o.customerNumber
where c.customerNumber between 103 and 120;

결과

만일, 두 테이블에 대하여 같은 컬럼명을 갖는 모든 열에 대한 동등 조인 결과 값을 검색하고 싶다면, NATURAL JOIN을 사용하면 된다. MySQL 데이터 베이스에는 해당 조건을 보여 줄만한 예제 데이터가 존재하지 않지만, 예를 들어 A반과 B반 학생 각각의 국영수 성적을 담은 테이블이 있다고 할 때, A, B반에서 모든 성적이 똑같은 학생을 확인해보고자 할때 NATURAL JOIN을 활용할 수 있다. 사실상 사용할 일이 거의 없다.

(2) 비동등 조인(NON-EQUI JOIN) : 테이블의 기본키, 외래키외에 다른 column을 사용하여 조인 조건으로 사용하는 조인을 말한다.

-> 예를 들어 다음과 같은 상품의 등급을 가격에 따라 분류한 테이블이 존재한다고 생각해보자

여기에 비동등 조인을 이용하여 상품별 등급을 출력해줄 수 있다.

-- 각 상품의 퀄리티를 다음과 같은 조인 조건을 만족하며 조합하라.
select productCode, productName, buyPrice, grade
from products join quality
on buyPrice >= low and buyPrice <= high
order by buyPrice;

위의 기준과 같이 상품의 등급이 분류되었음을 확인할 수 있다.

*OUTER JOIN

-> INNER JOIN의 경우 교집합을 추출하는 방식이기 때문에, 다른 쪽 테이블에 데이터가 존재하지 않는 경우 해당 데이터는 고려하지 않는 문제점이 존재한다. 이를 해결하기 위해 사용할 수 있는 것이 OUTER JOIN이다.

-> 예를 들어 MySQL의 데이터에서 고객(customers)에 대한 담당 직원(employees)이 존재하지 않는 경우가 존재한다.

select customerNumber, customerName, salesRepEmployeeNumber
from customers;

담당 직원이 존재하지 않는 고객

따라서, 고객 테이블과 직원 테이블을 INNER JOIN하는 경우, Havel & Zbyszek Co에 대한 정보가 사라진 것을 확인할 수 있다.

select customerNumber, customerName, salesRepEmployeeNumber
from employees join customers
on employeeNumber = salesRepEmployeeNumber
order by customerNumber;

이때, OUTER JOIN을 활용하면 해당 고객도 포함하여 검색 결과를 도출할 수 있다.

select customerNumber, customerName, salesRepEmployeeNumber
from customers left outer join employees
on employeeNumber = salesRepEmployeeNumber
order by customerNumber;

담당직원이 존재하지 않는 경우도 출력해준다.

-> 이처럼 OUTER JOIN은 다음과 같은 벤다이어 그램을 가진다고 생각하면 된다.

다만 MySQL에서는 FULL OUTER JOIN을 지원하지 않기 때문에, 집합 연산자를 활용하여 FULL OUTER JOIN을 검색 결과를 도출할 수 있다.

*SELF JOIN

-> 자기 자신의 테이블에 대해서도 조인이 가능하다. 쉽게 생각하면 자신의 테이블이 2개 존재한다고 생각하고 조인을 진행하면 SELF JOIN이 된다.

-- 직원과 직원의 매니저(보고하는 대상)
select e.employeeNumber, e.lastName, m.employeeNumber as "Manager", m.lastName
from employees e join employees m
on e.reportsTo = m.employeeNumber;

*집합 연산자(SET Operator)

-> 앞서 조인은 집합 연산과 유사한 방식으로 동작한다는 사실을 확인할 수 있었다. 마찬가지로, SQL에서는 여러가지 집합 연산을 제공하는데 MySQL의 경우에는 UNION 연산만을 지원한다(그 외의 집합 연산은 여러 연산자 및 조인을 활용하여 구현할 수 있다).

-> UNION 연산과 FULL OUTER JOIN : MySQL에서는 FULL OUTER JOIN을 제공하지 않는다고 하였다. 따라서, LEFT OUTER JOIN과 RIGHT OUTER JOIN을 UNION(합집합)하면, FULL OUTER JOIN을 구현할 수 있다.

select customerNumber, customerName, salesRepEmployeeNumber
from customers left outer join employees
on employeeNumber = salesRepEmployeeNumber
UNION
select customerNumber, customerName, salesRepEmployeeNumber
from customers right outer join employees
on employeeNumber = salesRepEmployeeNumber
order by customerNumber;

-> UNION vs UNION ALL : 이 둘의 차이는 중복되는 행의 제거(distinct)여부 이다. 기본적으로 UNION연산은 합집합 과정에서 중복되는 요소는 제거하면서 두 테이블을 합친다. 반면 UNION ALL연산은 두 테이블의 중복되는 요소를 제거하지 않고 테이블을 합친다.

[Database]내장 함수, 집계 함수와 GROUP BY절(MySQL)

sskl660 — Sun, 11 Apr 2021 17:40:58 +0900

*MySQL API

-> 앞서 제시한 데이터 타입, 혹은 기존에 익숙한 프로그래밍 언어와 마찬가지로 MySQL의 자세한 문법이나 사용을 보고 싶으면 API문서를 참고하는 습관을 들이도록 하자. 내장 함수에 있어서도 마찬가지이다.

dev.mysql.com/doc/refman/8.0/en/functions.html

MySQL :: MySQL 8.0 Reference Manual :: 12 Functions and Operators

Chapter 12 Functions and Operators Expressions can be used at several points in SQL statements, such as in the ORDER BY or HAVING clauses of SELECT statements, in the WHERE clause of a SELECT, DELETE, or UPDATE statement, or in SET statements. Expressions

dev.mysql.com

*더미 테이블

-> SQL에는 보통 테이블이 존재 하지 않지만, 테이블을 표시하고 싶은 경우(예를 들면 산술 연산에 대한 결과등을 테이블 형태로 출력), 참조를 위한 가상의 테이블을 제공해준다. 이것을 더미 테이블이라고 부르며, 보통 dual이라는 이름의 형태로 존재한다.

-- 더미 테이블 dual
select 1 + 1
from dual;

-- 테이블 이름을 아예 참조하지 않아도 무관하다.
select 1 + 1;

*알아두면 편리한 내장 함수들

-- 절대값
select abs(-7), abs(0), abs(3);

-- 올림(정수 기준)
select ceil(1.24);

-- 내림(정수 기준)
select floor(1.24);

-- 반올림(대상 수, 기준 자릿수) : 기준 자릿수는 1의 자릿수를 기준으로 왼쪽은 -, 오른쪽은 +로 자릿수가 늘어난다.
-- Ex : 100의 자리에 대하여 반올림
select round(153.1254, -2);

-- Ex : 소숫점 아래 2번째 자리에 대하여 반올림
select round(153.1254, 2);

-- Ex : 1의 자리에 대하여 반올림
select round(153.1254);

-- 모든 문자를 소문자로
select lcase("SElect");

-- 모든 문자를 대문자로
select ucase("SElect");

-- 현재 날짜
select now();

-- 날짜 형식 지정(연, 월, 일, 요일, 시, 분, 초).
select date_format(now(), "%Y.%M.%D %W %H:%I:%S");
select date_format(now(), "%y.%m.%d %w %h:%i:%s");

*MySQL Sample Database

-> 아래 데이터베이스는 MySQL에서 기본적으로 제공해주는 연습용 SQL 테이블 데이터이다. 해당 데이터를 이용하여 쿼리를 연습해보도록 하겠다.

www.mysqltutorial.org/mysql-sample-database.aspx/

MySQL Sample Database

This page provides you with a MySQL sample database that helps you to practice with MySQL effectively and quickly. You can download the sample database and load it into your MySQL Server.

www.mysqltutorial.org

*집계 함수(Aggregate Function)

-> 집계 함수란, 여러행 또는 테이블 전체 행으로부터 하나의 결과값을 반환하는 함수이다. 보통 GROUP BY절과 함께 사용되는 경우가 많다.

-- 검색된 행의 개수를 출력
select count(*)
from student;

-- 학생 성적의 총합
select sum(grade)
from student;

-- 학생 성적의 평균
select avg(grade)
from student;

-- 학생 성적 중 최고 성적
select max(grade)
from student;

-- 학생 성적 중 최저 성적
select min(grade)
from student;

*집계 함수(Aggregation Function)와 GROUP BY절

-> 집계 함수란, 여러행 또는 테이블 전체 행으로부터 하나의 결과를 반환하는 함수라고 하였다. 예를 들어 고객 테이블에서 같은 주에 속하는 고객들의 평균 신용 한도를 알아보고 싶다고 가정하자. 이때 다음과 같은 쿼리를 수행하면 문제가 발생한다.

-- 오류 코드
select state, avg(creditLimit)
from customers;

왜냐하면 avg(creditLimit)에 대한 쿼리의 수행 결과는 전체 테이블에 대하여 수행이 되어 1개의 행을 반환하지만, state 열은 여러개의 결과를 반환하기 때문이다.

-> 이러한 문제를 해결하기 위하여, 집계함수를 전체 테이블에 한 번에 적용하는 것이 아닌 지정한 그룹마다 집계함수를 구하기 위한 방법이 필요하고 이 방법이 GROUP BY절을 활용하는 것이다.

-- 같은 주에 속하는 고객들의 평균 신용 한도
select state, avg(creditLimit)
from customers
group by state
order by state;

-- 각 주문별 최고 판매액과 최저 판매액
select orderNumber, max(priceEach), min(priceEach)
from orderdetails
group by orderNumber;

*HAVING절

-> GROUP BY절에 조건에 맞는 대상만 그루핑하고 싶은 경우 HAVING절을 사용하면 된다. WHERE절 대신 HAVING절을 사용하는 이유는, WHERE절이 GROUP BY절보다 먼저 수행되기 때문에 GROUP BY절의 조건은 따로 고려해주는 것이다.

-- 100 ~ 150번 고객 중 같은 주에 속하는 고객들의 평균 신용 한도(단, 평균 신용한도가 50000이상인 지역만)
select state, avg(creditLimit) -- 5
from customers -- 실행 순서 1
where customerNumber between 100 and 150 -- 2
group by state -- 3
having avg(creditLimit) > 50000 -- 4
order by avg(creditLimit); -- 6

[Database]DML(MySQL)

sskl660 — Sun, 11 Apr 2021 16:50:31 +0900

*DML(Data Manipulation Language) : 데이터 조작어. 데이터베이스 객체에서 데이터를 CRUD(Create Read Update Delete : insert select update delete)한다.

(1) 데이터 삽입(INSERT)

-- 모든 열에 데이터를 삽입하는 경우
insert into table_name
values (val1, val2, ...);

-- 특정 열에 데이터를 삽입하는 경우(권장)
insert into table_name (col_name1, col_name2, ...)
values (val1, val2, ...);

-- 여러 데이터(행)를 한 번에 삽입하는 경우
insert into table_name (col_name1, col_name2, ...)
values (val1, val2, ...),
       (val1, val2, ...);
       
-- Ex
insert into student (studentname, studentid, studentpwd)
values ("kim", "asas", "1234"),
       ("lee", "asdf", "1234");

(2) 데이터 변경(UPDATE)

-- UPDATE(where 절을 생략하면 모든 데이터가 바뀌니 주의!).
update table_name
set col_name1 = val1, ...
where conditions;

-- Ex
update student
set studentname = "park", studentid = "aaaa"
where studentno = 2;

(3) 데이터 삭제(DELETE)

-- DELETE(UPDATE와 마찬가지로 where절을 삭제하면 모든 데이터가 삭제되니 주의!).
delete from table_name
where conditions;

-- Ex
delete from student
where studentno = 3;

(4) 데이터 조회(READ)

-> 테이블 조회(기본)

-- 전체 테이블 조회
select *
from table_name;

-- Ex
select *
from student;

-- 특정 열을 선택하여 조회
select col_name, col_name2, ...
from table_name;

-- Ex
select studentNo, studentName
from student;

-- 중복되는 행을 제외하고 조회(DISTINCT 명령어)
select distinct col_name
from studnt;

-> 별칭 : 열에 사용자 지정 이름을 새로 붙인다(AS).

-- 문법
select col_name as "alias"
from table_name;

-- Ex
select studentNo as "학번"
from student;

-> 조건을 만족하는 테이블 내용 조회 : WHERE 절

-- Ex : 나이가 21살 이상인 학생 조회
select *
from student
where age >= 21;

-- 조건에 AND, OR, NOT을 활용할 수 있다.
-- AND Ex : 나이가 21살이고, 이름이 kim인 학생 조회
select *
from student
where age = 21 and studentName = "kim";

-- OR Ex : 나이가 21살 이거나, 이름이 kim인 학생 조회
select *
from student
where age = 21 or studentName = "kim";

-- NOT Ex : 나이가 21살이 아닌 학생 조회
select *
from student
where not (age = 21);

-- IN, BETWEEN을 이용한 범위 조건
-- IN Ex : 나이가 21, 22, 23살인 학생 조회
select *
from student
where age in (21, 22, 23);

-- BETWEEN Ex : 나이가 21, 22, 23살인 학생 조회
select *
from student
where age BETWEEN 21 AND 23;

-- NULL 값에 대한 비교 : NULL 값은 '-' 연산자가 아닌 'is' 연산자를 사용해야 한다.
select *
from student
where studentNo is null;

※ LIKE 명령어와 wild card(%, _) : 특정 문자를 포함한 대상을 검색할 수 있다.

-- % : 어떤 문자가 몇 개가 와도 상관 없다.
-- 이름이 "김"으로 시작하는 모든 학생 조회
select *
from student
where studentName like "김%";

-- 이름에 "김"을 포함하는 모든 학생 조회
select *
from student
where studentName like "%김%";

-- 이름이 "김"으로 끝나는 모든 학생 조회
select *
from student
where studentName like "%김";

-- _ : 해당 문자의 개수 만큼 해당 위치에 어떤 문자가 와도 상관 없다.
-- 이름이 "김"으로 시작하고 3글자인 모든 학생 조회
select *
from student
where studentName like "김__";

-- 이름 중간에 "김"을 포함하고 3글자인 모든 학생 조회
select *
from student
where studentName like "_김_";

-> 출력행 정렬 : ORDER BY 절

-- 테이블을 오름차순(ASC : 디폴트), 내림차순(DESC)으로 정렬한다.
-- ASC Ex : 학생의 나이순 오름차순으로 정렬
select *
from student
order by age;

-- DESC Ex : 학생의 나이순 내림차순으로 정렬
select *
from student
order by age desc;

*MySQL API

-> 앞서 제시한 데이터 타입, 혹은 기존에 익숙한 프로그래밍 언어와 마찬가지로 MySQL의 자세한 문법이나 사용을 보고 싶으면 API문서를 참고하는 습관을 들이도록 하자.

dev.mysql.com/doc/refman/8.0/en/sql-statements.html

MySQL :: MySQL 8.0 Reference Manual :: 13 SQL Statements

dev.mysql.com

[Database]DDL(MySQL)

sskl660 — Sun, 11 Apr 2021 15:47:51 +0900

*DDL(Data Definition Language) : 데이터 정의어.

*데이터베이스 : 생성, 변경, 삭제, 사용.

-- 다국어 처리
create database db
default character set utf8mb3 collate utf8mb3_general_ci;

-- 이모지 문자까지 다국어 처리
create database db
default character set utf8mb4 collate utf8mb4_general_ci;

-- 변경
alter database db
default character set utf8mb4 collate utf8mb4_general_ci;

-- 삭제
drop database db;

-- 데이터베이스 사용
use db;

*테이블

(1) 데이터 타입 : dev.mysql.com/doc/refman/8.0/en/data-types.html

MySQL :: MySQL 8.0 Reference Manual :: 11 Data Types

MySQL supports SQL data types in several categories: numeric types, date and time types, string (character and byte) types, spatial types, and the JSON data type. This chapter provides an overview and more detailed description of the properties of the type

dev.mysql.com

(2) 테이블 생성(CREATE)

-> 문법

create table table_name(
	col_name1 Type [option],
	col_name2 Type [option],
	...
    );

-> 예시

create database db
default character set utf8mb4 collate utf8mb4_general_ci;

use db;

create table student (
	studentno INT NOT NULL auto_increment primary key,
	studentname VARCHAR(20) NOT NULL,
	studentid VARCHAR(20),
	studentpwd VARCHAR(20)
    );

※ option에는 다음과 같은 속성들이 존재한다.

-> NOT NULL : null 값을 허용하지 않는다.

-> AUTO INCREMENT : 새 레코드가 추가 될 때 마다 필드 값을 자동으로 1씩 증가시킨다.

-> PRIMARY KEY : 테이블에서 행을 고유하게 식별하기 위해 사용한다(기본키).

-> FOREIGN KEY : 특정 테이블의 PK컬럼에 저장되어 있는 값을 저장하고 가리킨다(참조키, 외래키).

-> UNIQUE: 컬럼에 중복된 값 저장 불가능(NULL 제외).

-> DEFAULT value: 기본값을 value로 설정한다.

-> UNSIGNED : Type이 숫자인 경우, 값을 0 혹은 양수로 제한한다.

(3) 테이블 변경(ALTER)

-- ADD(새로운 열 추가)
alter table table_name add col_name TYPE [option];

-- Add Ex
alter table student add age INT NOT NULL;

-- RENAME(열 이름 변경)
alter table table_name rename column col_name to change_name;

-- RENAME Ex
alter table student rename column age to grade;

-- MODIFY(열 데이터 타입 변경)
alter table table_name modify col_name TYPE;

-- MODIFY Ex
alter table student modify grade decimal(10);

-- DROP(열 삭제)
alter table table_name drop col_name;

-- DROP Ex
alter table student drop grade;

(4) 테이블 삭제(DROP)

-- DROP(테이블 삭제)
drop table table_name;

-- DROP Ex
drop table student;

*MySQL API

dev.mysql.com/doc/refman/8.0/en/sql-statements.html

MySQL :: MySQL 8.0 Reference Manual :: 13 SQL Statements

dev.mysql.com

[Database]SQL 개요

sskl660 — Sun, 11 Apr 2021 15:47:19 +0900

*RDBMS(Relational Database Management System)

->RDBMS란 관계형 데이터베이스 시스템을 지칭하는 약어이다. RDBMS는 테이블 기반의 DBMS로, 데이터를 테이블 단위로 관리한다.

*SQL(Structured Query Language)

->SQL이란, 데이터베이스에 있는 정보를 사용할 수 있도록 지원하는 언어이다. 기본적으로 NoSQL을 제외한 모든 DBMS에서 사용이 가능하며, 데이터의 대소문자를 제외한 대소문자는 구별하지 않는다는 특징을 가지고 있다.

*SQL 구문의 기본적인 구성

(1) DDL(Data Definition Language) : 데이터를 정의하는 언어이다. 데이터베이스 객체의 구조를 정의하는 역할을 하며, 테이블 생성, 삭제, 수정등의 기능을 수행한다.

명령어	기능
CREATE	데이터베이스 관련 객체(데이터베이스, 뷰, 테이블...)를 생성한다.
ALTER	존재하는 데이터베이스 관련 객체를 수정한다.
DROP	존재하는 데이터베이스 관련 객체를 삭제한다.

(2) DML(Data Manipulation Language) : 데이터를 조작하는 언어이다. 데이터베이스의 데이터를 조작하는 역할을 한다. 대표적으로 컴퓨터 소프트웨어가 가지는 기본적인 데이터 처리 기능인 CRUD(Create, Read, Update, Delete)를 테이블의 레코드에서 수행한다.

명령어	기능
INSERT(C)	데이터베이스 관련 객체(데이터베이스, 뷰, 테이블...)에 데이터를 입력한다.
SELECT(R)	데이터베이스 관련 객체에 데이터를 조회한다.
UPDATE(U)	데이터베이스 관련 객체에 데이터를 수정한다.
DELETE(D)	데이터베이스 관련 객체에 데이터를 삭제한다.

(3) DCL(Data Control Language) : 데이터를 제어하는 언어이다. 데이터베이스의 접근 권한, 조작 권한등을 정의하는 역할을 한다.

명령어	기능
GRANT	데이터베이스 관련 객체(데이터베이스, 뷰, 테이블...)에 대한 권한을 사용자에게 부여한다.
REVOKE	데이터베이스 관련 객체에 대한 사용자의 권한을 취소한다.

(4) TCL(Transaction Control Language) : 트랜잭션을 제어하는 언어이다.

명령어	기능
COMMIT	실행한 명령어를 데이터베이스에 최종적으로 적용시킨다(저장).
ROLLBACK	실행한 명령어를 COMMIT 명령어 수행 전으로 복구시킨다(되돌리기).

[Java]그래프의 표현

sskl660 — Fri, 12 Mar 2021 00:41:28 +0900

*그래프의 표현

->프로그래밍을 하다보면 그래프를 만들어야 하는 경우가 발생할 수 있는데, 프로그래밍에서 그래프를 표현하는 방법은 크게 2가지(인접 행렬, 인접 리스트)로 나뉜다.

->인접 행렬 : 수학에서 행렬은 그래프를 표현하는데 사용되기도 하였다. 따라서 프로그래밍에서 2차원 배열은 행렬의 성질을 갖는다는 점을 활용하여 마찬가지로 그래프를 표현할 수 있다. 기본적으로 인접행렬을 이용한 그래프 표현은 각 인덱스를 정점이라고 생각하고, 정점이 교차하는 지점(좌표)을 연결된 상태라고 표시해주면 된다.

(1) 무향 그래프 : 방향을 가지지 않는 그래프를 말한다. 따라서, 행렬이 대칭적으로 같은 값을 갖는 특징을 갖는다.

무향 그래프와 인접행렬 값

(2) 유향 그래프 : 방향을 가지고 있는 그래프를 말한다. 따라서, 무조건 행렬이 대칭적으로 같은 값을 갖지는 않는다.

유향 그래프와 인접행렬 값

->인접 리스트 : 인접 리스트를 이용하는 방식은 연결 리스트 자료구조를 활용하여 그래프를 표현할 수 있다. 1차원 배열의 각 인덱스를 노드라고 생각하고, 정점의 연결이 있을 때마다 해당 정점에 연결된 노드 정보를 추가해주면 된다.

(1) 무향 그래프 : 연결된 노드의 정보를 추가할때 각 노드에 대하여 각각 정보를 추가해주면 된다.

무향 그래프와 인접 리스트 값

(2) 유향 그래프 : 연결된 노드의 정보만 추가해주면 된다.

유향 그래프와 인접 리스트 값

*장단점

->인접 행렬은 간선의 추가와 삭제가 빈번하게 사용되는 경우, 인접 리스트는 노드의 추가와 삭제가 빈번하게 사용되는 경우 사용하는 것이 좋다.

*인접 행렬 구현

->알고리즘 문제에서는 주로 연결되는 두 노드의 정점과 비용으로 그래프의 연결성이 주어지기 때문(노드 노드 비용)에, 그 상황을 가정하여 인접행렬을 구현해보면 다음과 같다.

import java.util.Scanner;

/*
정점, 간선의 개수 이후
(노드, 노드, 비용)이 주어진 경우
5 6
5 1 1
1 2 2
1 3 3
2 3 4
2 4 5
3 4 6
 */

public class Graph {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// V = 정점의 개수, E = 간선의 개수.
		int V = sc.nextInt();
		int E = sc.nextInt();
		
		// 2차원 배열(인접 행렬)을 만든다.
		// 인덱스의 번호 = 노드의 번호 이기 때문에, 2차원 배열의 크기를 임의로 1 늘려서 정의한다(스킬).
		int[][] graph = new int[V + 1][V + 1];
		
		int row;
		int col;
		int cost;
		for(int i = 0; i < E; i++) {
			row = sc.nextInt();
			col = sc.nextInt();
			cost = sc.nextInt();
			graph[row][col] = cost;
			// 만일, 무향 그래프라면 반대의 상황도 추가해 준다.
			// graph[col][row] = cost;
		}
		
		// 인접 행렬 출력
		for(int i = 1; i < V + 1; i++) {
			for(int j = 1; j < V + 1; j++) {
				System.out.print(graph[i][j] + " ");
			}
			System.out.println();
		}
		sc.close();
	}
}

유향 그래프

무향 그래프(대칭성을 확인할 수 있다)

*인접 리스트 구현

->알고리즘 문제에서는주로 연결되는 두 노드의 정점과 비용으로 그래프의 연결성이 주어지기 때문(노드 노드 비용)에, 마찬가지로 그 상황을 가정하여 인접 리스트를 구해보면 다음과 같다.

->자바의 경우, 리스트 안에 자유롭게 노드를 추가 가능한 리스트를 추가할 수 있어야 하기 때문에 List 내부에 동적 리스트를 선언하여 처리해준다. 또한, 그 안에 대상 노드와 비용을 리스트처럼 처리하는 경우가 많기 때문에, Node라는 클래스(객체)를 따로 선언해주어 처리해주는 것이 깔끔하다.

package Graph;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/*
정점, 간선의 개수 이후
(노드, 노드, 비용)이 주어진 경우
5 6
5 1 1
1 2 2
1 3 3
2 3 4
2 4 5
3 4 6
 */

public class Graph {
	// 노드와 비용을 포함하는 객체를 미리 만들어준다.
	static public class Node {
		// 연결되는 정점
		int end;
		// 비용
		int cost;

		Node(int end, int cost) {
			this.end = end;
			this.cost = cost;
		}

		@Override
		public String toString() {
			return "[" + end + ", "
					+ "" + cost + "]";
		}
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// V = 정점의 개수, E = 간선의 개수.
		int V = sc.nextInt();
		int E = sc.nextInt();
		
		// 1차원 리스트를 만든다.
		// 인덱스의 번호 = 노드의 번호 이기 때문에, 1차원 리스트의 크기를 임의로 1 늘려서 정의한다(스킬).
		List<ArrayList<Node>> graph = new ArrayList<ArrayList<Node>>();
		for (int i = 0; i < V + 1; i++) {
			graph.add(new ArrayList<Node>());
		}

		int a;
		int b;
		int cost;
		for (int i = 0; i < E; i++) {
			a = sc.nextInt();
			b = sc.nextInt();
			cost = sc.nextInt();
			
			graph.get(a).add(new Node(b, cost));
			// 만일, 무향 그래프라면 반대의 상황도 추가해 준다.
			// graph.get(b).add(new Node(a, cost));
		}

		// 인접 행렬 출력
		System.out.println(graph);
		sc.close();
	}
}

유향 그래프

무향 그래프

->유향 그래프의 1번째 인덱스(1번 노드)의 1번째 인덱스(첫 번째 대상 노드)는 2번 노드로 가는데 비용이 2가 든다는 의미, 2번째 인덱스(두 번째 대상 노드)는 3번 노드로 가는데 비용이 3이 든다는 의미이다. 적절히 잘 구현된 것을 확인할 수 있다.

->각 인덱스 내부의 대상 노드 값을 오름차순으로 정렬하면 더 깔끔하게 표현가능하지만, 큰 상관은 없다.

[Java]다익스트라 알고리즘(Dijkstra Algorithm)

sskl660 — Fri, 12 Mar 2021 00:40:29 +0900

*다익스트라 알고리즘(Dijkstra Algorithm)

-> 다익스트라 알고리즘은 음의 가중치(음의 간선, 음의 값)가 없는 그래프의 한 노드에서 각 모든 노드까지의 최단거리를 구하는 알고리즘을 말한다.

-> 초기 모델은 O(V^2)의 시간복잡도를 가졌다. 이후 우선순위 큐 등을 이용한 고안된 알고리즘이 탄생했고, 현재는 O((V+E)log V)의 시간복잡도를 가지고 있다(만일 연결 그래프라면 O(ElogV)까지 시간 복잡도를 줄일 수 있다고 한다). 일반적으로는 그래프가 희소 그래프인 경우에 우선순위 큐를 이용하는 것이 낫다고 한다.

※음의 가중치를 가지면 안되는 이유는 최소 비용의 음의 무한대 발산, 그리디 알고리즘 적용 불가능 등이 있다. 후자는 제일 아래에 있는 다익스트라 알고리즘 정당성 증명을 참고하도로 하자.

※연결 그래프 : 모든 두 꼭짓점 사이에 경로가 존재하는 그래프.

※희소 그래프 : 밀집 그래프의 반대. 밀집 그래프란, 간선의 수가 최대에 가까운 그래프를 만한다. 보통, 간선의 총 개수가 정점의 개수^2과 근사하다면 밀집 그래프이다.

*다익스트라 알고리즘의 매커니즘

-> 다익스트라 알고리즘은 기본적으로 그리디 알고리즘이자 다이나믹 프로그래밍 기법을 사용한 알고리즘이다.

-> 다익스트라 알고리즘은 기본적으로 아래 두 단계를 반복하여 임의의 노드에서 각 모든 노드까지의 최단거리를 구한다. 임의의 노드에서 다른 노드로 가는 값을 비용이라고 한다.

(1) 방문하지 않은 노드 중에서 가장 비용이 적은 노드를 선택한다(그리디 알고리즘).

(2) 해당 노드로부터 갈 수 있는 노드들의 비용을 갱신한다(다이나믹 프로그래밍).

-> 예를 들어 아래 그림에서, A노드에서 출발하여 F노드로 가는 최단 경로를 구하는 문제를 다익스트라 알고리즘을 적용하여 생각해보자.

각 단계마다 기준이 필요하기 때문에, 지금부터는 방문하지 않은 노드의 집합을 Before, 방문한 노드의 집합을 After, 현재까지 A노드가 방문한 곳 까지의 최소 비용을 D[대상 노드]라고 정의하도록 하자. 그렇다면 현재 각 집합이 가지고 있는 값은 다음과 같은 것 이다.

<초기화 단계>

그렇다면, 이 상태에서 방문하지 않은 노드 중 가장 비용이 적은 대상 노드는 어디일까? A노드에서 다른 간선으로 가는 비용이 0인 간선이 존재하지 않는다면, 당연히 A노드일 것이다. 또한, 그러한 값이 존재한다고 하더라도 첫 번째 단계에서는 'A노드에서 A노드로 가는 지점이 가장 짧다'라고 그냥 정의하고 시작한다. 즉, 첫 번째 단계에서는 가장 비용이 적은 노드를 선택할 기준이 없기 때문에 출발지인 A노드 자신을 초기 선택 노드로 초기화한다.

아직 A노드를 방문하지는 않았지만, A노드에서 A노드로 가는 비용이 가장 적다라고 정의한 상태.

<알고리즘 적용>

초기화가 끝났으니, 이제 앞서 언급한 두 가지 논리를 그냥 반복해서 적용하면 끝이다. 위 상태에서 방문하지 않은 노드 중 가장 비용이 적은 대상 노드는 어디 인가? 당연히 A노드이다. 또한, A노드를 기준으로 갈 수 있는 인접 노드로의 최소 비용은 얼마일까? 결과는 아래와 같을 것이다.

A노드 방문 완료.

다음 단계는 어떨까? 앞선 단계를 그냥 계속 반복하기만 하면 된다. 현재 상태에서 방문하지 않은 노드 중 가장 비용이 적은 노드는 어디 인가? A노드는 방문 하였기 때문에 B노드가 될 것이다. 따라서 B노드를 방문하고, B노드와 인접한 노드들의 최소 비용을 갱신해주면 된다.

B노드에서 C노드로 가는 비용은 9이다. 하지만 이미 C노드로가는 최소 비용이 5이므로 갱신할 필요가 없다. B노드에서 F노드로 가는 비용은 아직 모르므로, 최초 방문 값인 12로 설정해 주었다.

다음 단계도 마찬가지이다. 이제는 A노드와 B노드를 방문하였기 때문에, 그 중에서 가장 비용이 적은 노드인 D를 선택하고 방문한 뒤 같은 과정을 진행해주면 된다. 이후 과정은 생략하고 그림과 그림 설명으로 대체하도록 하겠다.

D노드를 거쳐 C노드로 가는 비용은 4이고, 현재까지 C노드로 가는 최소 비용이 5였기 때문에, D[C]를 4로 갱신할 수 있다. 이전 단계와 마찬가지로, E노드로가는 비용은 미정이었기 때문에 최초 방문 값인 10으로 설정할 수 있다.

그 다음으로 선택된 노드는 C이고, C노드에서 E노드로 가는 값과 F노드로 가는 값은 각각 기존 E노드나 F노드로 가는 비용보다 모두 작다. 따라서 각 값을 갱신할 수 있다.

그 다음으로 선택된 노드는 E이고, E노드에서 F노드로 가는 비용은 기존 F노드로 가는 비용보다 작다. 따라서 그 값을 갱신해 주었다.

마지막으로 방문해야하는 노드인 F에서는 더 이상 갈 수 있는 노드가 존재하지 않으므로, 방문만 완료하고 알고리즘을 종료해주면 된다.

모든 노드 방문 완료.

따라서, 다익스트라 알고리즘에 의한 A노드부터 F노드까지(혹은 A노드부터 각 모든 정점 까지)의 최소 비용은 위와 같은 값을 가진다.

*다익스트라 알고리즘의 구현 : O(V^2)

->우선 위의 로직을 구현하기 위해서는 입력으로 주어진 그래프를 저장하는 방법을 알아야 한다. 그래프를 표현하는 방법이 미숙하다면 아래 게시글을 참고하도록 하자.sskl660.tistory.com/60

[Java]그래프의 표현

*그래프의 표현 ->프로그래밍을 하다보면 그래프를 만들어야 하는 경우가 발생할 수 있는데, 프로그래밍에서 그래프를 그리를 방법은 크게 2가지(인접 행렬, 인접 리스트)로 나뉜다. ->인접 행렬

sskl660.tistory.com

->한 번 방문한 배열은 방문할 수 없으므로 방문 여부를 체크할 배열이 필요할 것이고, 각 노드 까지의 최소 비용을 저장할 배열이 필요할 것이다.

->구현에서 고려해 주어야 하는 것은, 미방문 지점의 값을 항상 최소의 값으로 갱신하는 것이 목표이기 때문에, 미 방문 지점은 매우 큰 값으로 초기화하여 로직을 처리해주면 된다(구할 수 있다면, 노드가 가질 수 있는 최대 비용을 넣어두어도 된다).

->최소 비용을 갖는 노드을 선택하는 과정은 앞선 일반적인 구현에서는 최악의 경우 모든 노드을 확인해야 하고, 이 것은 V번 반복하기 때문에 O(V^2)의 시간 복잡도를 갖는다.

package Graph;

import java.util.ArrayList;
import java.util.Scanner;

/*
sample input
5 6
1
5 1 1
1 2 2
1 3 3
2 3 4
2 4 5
3 4 6
 */

// 도착 지점과, 도착지점으로 가는 비용을 의미하는 클래스를 정의한다.
class Node {
	int idx;
	int cost;

	// 생성자
	Node(int idx, int cost) {
		this.idx = idx;
		this.cost = cost;
	}
}

public class Dijkstra {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 노드와 간선의 개수
		int V = sc.nextInt();
		int E = sc.nextInt();
		// 출발지점
		int start = sc.nextInt();

		// 1. 인접리스트를 이용한 그래프 초기화
		ArrayList<ArrayList<Node>> graph = new ArrayList<ArrayList<Node>>();
		// 노드의 번호가 1부터 시작하므로, 0번 인덱스 부분을 임의로 만들어 놓기만 한다.
		for (int i = 0; i < V + 1; i++) {
			graph.add(new ArrayList<>());
		}
		// 그래프에 값을 넣는다.
		for (int i = 0; i < E; i++) {
			// a로 부터 b로 가는 값은 cost이다.
			int a = sc.nextInt();
			int b = sc.nextInt();
			int cost = sc.nextInt();

			graph.get(a).add(new Node(b, cost));
		}

		// 2. 방문 여부를 확인할 boolean 배열, start 노드부터 end 노드 까지의 최소 거리를 저장할 배열을 만든다.
		boolean[] visited = new boolean[V + 1];
		int[] dist = new int[V + 1];

		// 3. 최소 거리 정보를 담을 배열을 초기화 한다.
		for (int i = 0; i < V + 1; i++) {
			// 출발 지점 외 나머지 지점까지의 최소 비용은 최대로 지정해둔다.
			dist[i] = Integer.MAX_VALUE;
		}
		// 출발 지점의 비용은 0으로 시작한다.
		dist[start] = 0;

		// 4. 다익스트라 알고리즘을 진행한다.
		// 모든 노드을 방문하면 종료하기 때문에, 노드의 개수 만큼만 반복을 한다.
		for (int i = 0; i < V; i++) {
			// 4 - 1. 현재 거리 비용 중 최소인 지점을 선택한다.
			// 해당 노드가 가지고 있는 현재 비용.
			int nodeValue = Integer.MAX_VALUE;
			// 해당 노드의 인덱스(번호).
			int nodeIdx = 0;
			// 인덱스 0은 생각하지 않기 때문에 0부터 반복을 진행한다.
			for (int j = 1; j < V + 1; j++) {
				// 해당 노드를 방문하지 않았고, 현재 모든 거리비용 중 최솟값을 찾는다.
				if (!visited[j] && dist[j] < nodeValue) {
					nodeValue = dist[j];
					nodeIdx = j;
				}
			}
			// 최종 선택된 노드를 방문처리 한다.
			visited[nodeIdx] = true;

			// 4 - 2. 해당 지점을 기준으로 인접 노드의 최소 거리 값을 갱신한다.
			for (int j = 0; j < graph.get(nodeIdx).size(); j++) {
				// 인접 노드를 선택한다.
				Node adjNode = graph.get(nodeIdx).get(j);
				// 인접 노드가 현재 가지는 최소 비용과
				// 현재 선택된 노드의 값 + 현재 노드에서 인접 노드로 가는 값을 비교하여 더 작은 값으로 갱신한다.
				if (dist[adjNode.idx] > dist[nodeIdx] + adjNode.cost) {
					dist[adjNode.idx] = dist[nodeIdx] + adjNode.cost;
				}
			}
		}

		// 5. 최종 비용을 출력한다.
		for (int i = 1; i < V + 1; i++) {
			if (dist[i] == Integer.MAX_VALUE) {
				System.out.println("INF");
			} else {
				System.out.println(dist[i]);
			}
		}
		sc.close();
	}
}

*다익스트라 알고리즘의 구현(우선순위 큐 이용) : O((V+E)log V)

->기본적으로 다익스트라 알고리즘은 최소 비용을 갖는 노드를 선택하고, 주변 노드의 값을 갱신하였다. 그렇다면, 비용을 나타내는 배열에서 갱신된 노드를 제외하고는 여전히 INF의 값을 갖기 때문에 굳이 고려해줄 필요가 없음을 알게 된다. 즉, 갱신하는 주변 노드의 값에 대해서만 다음 최소 비용을 갖는 노드를 선택해주면 된다는 것이 우선순위큐를 이용하는 것의 핵심이다.

->우선 순위큐에 들어가는 노드의 수 = 갱신해야하는 주변 노드의 수라고 하였다. 이 말을 다르게하면, 갱신해야하는 주변 노드의 수 = 갱신해야 하는 주변 노드로의 간선의 수를 말한다. 즉, 우선 순위 큐에 삽입하는 최대 횟수는 간선의 개수이다. 따라서, 모든 간선에 대하여 삽입 연산이 발생하기 때문에 최대 O(ElogE)의 시간이 걸릴 것이다. 그런데, 희소 그래프의 경우 E <= V^2이므로, 최대 O(ElogV)의 시간이 걸린다고도 볼 수 있다. 각 노드들을 우선순위큐에 추출해주는 연산에대해서는 최대 V개의 노드에 대하여 우선순위큐에서 추출할 것이므로 최대 O(VlogV)의 시간이 걸릴 것이고 따라서 최대 모든 노드, 간선에대하여 우선 순위큐를 계산해줘야 하므로 O((V+E)logV)의 시간이 걸릴 것 이다.

※주의할 점

->우선 순위큐에 넣는 다음 노드는 최소 비용으로 선택된 노드의 주변 노드라고 하였다. 그런데, 이 주변 노드를 무차별적으로 우선순위큐에 넣고 무차별적으로 검사를 한다면 문제가 발생한다. 즉, 최소 비용으로 뽑은 노드의 방문 체크를 하지 않는 경우와 갱신이 이루어 지지 않는 노드까지 우선 순위큐에 넣는 경우 모두 중복된 노드를 재 방문 하게 되는 문제가 발생한다. 자세한 내용은 아래 코드의 주석을 참고하자.

->시간 복잡도의 핵심은 poll() 연산(최소 비용을 뽑는 연산)과 offer() 연산(최소 비용 후보를 우선 순위큐에 넣는 연산)이다. 만일, 중복 노드를 무차별적으로 큐에 넣는다면 위에서 결과적으로 말한 최대 V개의 노드에서 우선순위큐를 추출하는 O(VlogV)가 보장되지 못한다. 따라서, 중복 노드 방문을 두 가지 조건을 기반으로 방지한다.

package Graph;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

/*
sample input
5 6
1
5 1 1
1 2 2
1 3 3
2 3 4
2 4 5
3 4 6
 */

public class Dijkstra2 {
	static int V, E, start;
	static ArrayList<ArrayList<Node>> graph;

	static class Node {// 다음 노드의 인덱스와, 그 노드로 가는데 필요한 비용을 담고 있다.
		int idx, cost;

		Node(int idx, int cost) {
			this.idx = idx;
			this.cost = cost;
		}
	}

	public static void main(String[] args) throws IOException {
		// 초기화
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		V = Integer.parseInt(st.nextToken());
		E = Integer.parseInt(st.nextToken());
		start = Integer.parseInt(br.readLine());
		graph = new ArrayList<ArrayList<Node>>();
		for (int i = 0; i < V + 1; i++) {
			graph.add(new ArrayList<Node>());
		}
		for (int i = 0; i < E; i++) {
			st = new StringTokenizer(br.readLine());
			int s = Integer.parseInt(st.nextToken());
			int e = Integer.parseInt(st.nextToken());
			int c = Integer.parseInt(st.nextToken());
			// 문제에서는 유향 그래프에서의 다익스트라 알고리즘(이 조건도 문제에 따라 중요하다!).
			graph.get(s).add(new Node(e, c));
		}

		// 다익스트라 알고리즘 초기화
		int[] dist = new int[V + 1]; // 최소 비용을 저장할 배열
		for (int i = 0; i < V + 1; i++) {
			dist[i] = Integer.MAX_VALUE;
		}

		// 주의점 1. 다익스트라 알고리즘의 최소비용을 기준으로 추출해야 한다. 최대 비용을 기준으로 하는 경우 최악의 경우 지수시간 만큼의 연산을
		// 해야한다!
		PriorityQueue<Node> q = new PriorityQueue<Node>((o1, o2) -> Integer.compare(o1.cost, o2.cost));
		// 시작 노드에서, 시작 노드로 가는 값이 초기에 가장 짧은 비용을 갖는 노드이다.
		// 즉, 도착 정점은 start, 비용은 0인 노드를 가장 먼저 선택할 것이다.
		q.offer(new Node(start, 0));
		// 해당 노드를 선택한 것이나 마찬가지 이므로, dist[start] = 0으로 갱신.
		dist[start] = 0;
		while (!q.isEmpty()) {
			Node curNode = q.poll();

			// 목표 정점이 꺼내 졌다면, 해당 노드까지는 최솟값 갱신이 완료 되었다는 것이 확정이다(다익스트라 알고리즘).
			// 따라서, 반복문을 종료해도 되지만, 해당 코드는 시작 정점에 대하여 모든 정점으로의 최단 경로를 구하는 것을 가정한다.
			// 아래 주석된 코드는 목표 정점이 구해졌다면 빠르게 탈출할 수 있는 조건이다.
//			if (curNode.idx == end) {
//				System.out.println(dist[curNode.idx]);
//				return;
//			}

			// 꺼낸 노드 = 현재 최소 비용을 갖는 노드.
			// 즉, 해당 노드의 비용이 현재 dist배열에 기록된 내용보다 크다면 고려할 필요가 없으므로 스킵한다.
			// 주의점 2 : 중복노드 방지1 : 만일, 이 코드를 생략한다면, 언급한 내용대로 이미 방문한 정점을 '중복하여 방문'하게 된다.
			// 만일 그렇다면, 큐에 있는 모든 다음 노드에대하여 인접노드에 대한 탐색을 다시 진행하게 된다.
			// 그래프 입력이 만일 완전 그래프의 형태로 주어진다면, 이 조건을 생략한 것 만으로 시간 복잡도가 E^2에 수렴할 가능성이 생긴다.
			if (dist[curNode.idx] < curNode.cost) {
				continue;
			}

			// 선택된 노드의 모든 주변 노드를 고려한다.
			for (int i = 0; i < graph.get(curNode.idx).size(); i++) {
				Node nxtNode = graph.get(curNode.idx).get(i);
				// 만일, 주변 노드까지의 현재 dist값(비용)과 현재 선택된 노드로부터 주변 노드로 가는 비용을 비교하고, 더 작은 값을 선택한다.
				// 주의점 3 : 중복노드 방지 2 : 만일, 조건문 없이 조건문의 내용을 수행한다면 역시 중복 노드가 발생한다.
				// 간선에 연결된 노드를 모두 넣어준다면 앞서 언급한 정점의 시간 복잡도 VlogV를 보장할 수 없다.
				// 마찬가지로 E^2에 수렴할 가능성이 생긴다. 따라서 이 조건 안에서 로직을 진행해야만 한다.
				if (dist[nxtNode.idx] > curNode.cost + nxtNode.cost) {
					dist[nxtNode.idx] = curNode.cost + nxtNode.cost;
					// 갱신된 경우에만 큐에 넣는다.
					q.offer(new Node(nxtNode.idx, dist[nxtNode.idx]));
				}
			}
		}

		// 결과 출력
		System.out.println(Arrays.toString(dist));
	}
}

*다익스트라 알고리즘 정당성 증명

->다익스트라 알고리즘의 정당성을 증명하기 위하여 위키백과등을 참고하면 복잡한 수식으로 표현되어 있어 이해하기가 어려운 편인데, 여기에서는 조금 더 직관적인 설명으로 정당성을 이해해보도록 하겠다. 원래는 수학적 귀납법을 이용하여 엄밀하게 증명해야 하지만, 여기서는 직관적인 이해에 초점을 맞추어 기술하도록 하겠다.

->우선, 다익스트라 알고리즘을 진행하며 우리는 매번 현재 최소 비용을 갖는 노드를 선택하였다. 여기서 눈치가 빠른 사람이라면 알고 있었겠지만, 자세히 확인해보면 그렇게 선택이 된 노드는 다익스트라 알고리즘이 모든 노드를 방문할 때까지(즉, 알고리즘이 종료될 때 까지) 최소 비용의 갱신이 더 이상 이루어지지 않았다는 점을 알 수 있다(갱신 되는 노드는 아직 선택되지 않은 노드들에 대해서만 이루어지고 있다!).

->어쨋든 최소 비용을 갖는 노드로 선택이 되었다면, 그 노드는 앞으로 다른 노드를 방문하는 것과 관계없이 항상 값이 갱신되지 않을 것이라는 말이다. 다익스트라 알고리즘은 이 명제를 이용하여 정당성을 증명한다(왜냐하면, 이 명제가 참이라면 모든 노드에 대한 방문을 완료 하였을때 각 노드는 최솟값을 가지고 있을 것이다).

->글로만 적어서는 여러가지 수식을 써야하고, 이해도 잘 안되기 때문에 아래 그림을 참고하며 이해하도록 하자.

※ 최소비용이 갱신되지 않는 이유

->첫 부분에서 언급하였지만 다익스트라 알고리즘은 그리디 알고리즘이다. 쉽게 말해 다익스트라 알고리즘의 기본적인 아이디어는 '최단 거리는 최단 거리로 이루어져 있다', 다르게 말해 '최단 거리를 이어 붙여서 최단 거리를 만든다'는 것이다. 즉, 그리디 알고리즘의 최적 부분 구조 조건이 성립하기 때문에 위와 같은 결과가 발생하는 것이다.

※ 다익스트라 알고리즘 증명

->가설 : 이미 선택된 노드는 최단 거리가 갱신되지 않는다(즉, 다익스트라 알고리즘으로 선택된 노드는 최종 최소 비용이다).

->우리는 지금부터 이 가설을 증명하기 위해 귀류법을 사용할 것이다.

(1) 이미 선택된 노드는 앞으로 선택되는 노드에 의해서 최단 거리가 갱신이 된다라고 가정해보자. 즉, 이후 선택하는노드를 거쳐 들어오는 더 짧은 최단 경로가 존재한다고 생각해보자.

(2) 만일 그러한 노드가 존재한다면, 해당 노드는 적어도 한 번 다익스트라 알고리즘을 이용해 거쳐온 노드외의 노드를 지나야만 한다. 이 사실은 조금만 생각해보면 당연한 이야기이다. 왜냐하면, 다익스트라 알고리즘으로 선택되어진 모든 노드만을 거쳐서 지나온다면, 해당 노드는 다익스트라 알고리즘으로 선택된 노드의 최소 비용을 갱신할 수 없다. 아래 그림을 보며 이해해보자.

(3) 즉, 다음과 같이 다익스트라 알고리즘으로 선택된 경로 외에 다른 노드에서 들어오는 경로가 존재할 것이다.

(4) 하지만 이 사실은 잘 생각해보면 모순되는 부분을 가지고 있다. 어떤 부분일까? 애초에 다익스트라 알고리즘이 어떻게 진행되고 있었는지를 생각해보자. 다익스트라 알고리즘에서 다음 노드를 선택하는 기준이 무엇이었는가? 그렇다. 'E'라는 노드를 선택하는 기준은 현재 E가 가지고 있는 비용이 최소였기 때문에 선택한 것이다! 그런데, 만약 저러한 노드가 존재하는 상황이 발생한다면 우리는 정해진 규칙에 따라서 다익스트라 알고리즘을 진행하지 않은 것이다. 만일, 해당 노드를 Z라고 가정한다면 Z부터 E까지의 간선의 길이는 0 보다 큰 값을 가지고 있을 것(음의 가중치를 가지면 안되는 이유)이다. 즉, 시작 노드 S부터 노드 Z까지의 길이는 시작 노드 S부터 E까지의 거리보다 짧다! 다익스트라 알고리즘은 분명 매번 최소 비용을 갖는 노드만을 선택한다고 하였는데, 그것보다 더 짧은 비용을 갖는 노드가 존재한다고하면 당연히 모순이다.

(5) 즉, 초기에 설정한 가정(이미 선택된 노드는 앞으로 선택되는 정점에 의해서 최단 거리가 갱신이 된다)은 모순이다. 즉, 귀류 가정이 모순이므로, 본 명제는 참임을 알 수 있다. 수식을 이용한 증명은 위키백과 정확성 증명부분을 참고하도록하자. ko.wikipedia.org/wiki/%EB%8D%B0%EC%9D%B4%ED%81%AC%EC%8A%A4%ED%8A%B8%EB%9D%BC_%EC%95%8C%EA%B3%A0%EB%A6%AC%EC%A6%98

데이크스트라 알고리즘

위키백과, 우리 모두의 백과사전. 컴퓨터 과학에서, 데이크스트라 알고리즘(영어: Dijkstra algorithm) 또는 다익스트라 알고리즘은 도로 교통망 같은 곳에서 나타날 수 있는 그래프에서 꼭짓점 간의

ko.wikipedia.org

[Java]순열과 다음 순열

sskl660 — Thu, 25 Feb 2021 23:10:02 +0900

*재귀를 이용한 순열 구하기

-> 처음에는, 재귀를 이용하여 모든 순열을 구하였다. 하지만 이전에 공부한 다음 순열을 이용하여도 모든 순열을 구할 수 있다.

sskl660.tistory.com/48

[Java] 순열(Permutation)

*순열(Permutation) -> 순열이란, 임의의 집합을 순서를 부여하여 차례로 나열하는 것을 말한다. Ex) 이를 테면 집합 {1, 2, 3}중 3개의 원소를 선택한 순열을 구하시오라고 하면, 결과는 {123, 132, 213, 231,

sskl660.tistory.com

sskl660.tistory.com/54

[Java]다음 순열(Next Permutation)

*다음 순열(Next Permutation). -> 다음 순열이란, 말 그대로 해당 숫자의 다음에 올 순열의 수를 의미한다. Ex) {1, 2, 3}에서 3개를 선택하는 경우 순열은 123, 132, 213, 231, 312, 321이 있다. 그렇다면 123..

sskl660.tistory.com

-> 보통 재귀를 이용한 방식은 생각보다 메모리와 시간을 다음 순열을 이용한 방법보다 더 잡아 먹는다. 따라서, 다음 순열을 반복적으로 구하는 과정을 통하여 순열을 구하는 방법을 연습하도록 하자.

*다음 순열을 이용한 모든 순열 구하기

-> 첫 순열을 포함하여, (모든 순열의 경우의수(nPn) - 1)번 만큼 다음 순열을 구해준다면 모든 순열을 구할 수 있다.

-> 예를 들어 집합 {1, 2, 3}에서 3개를 선택한 모든 순열을 다음 순열을 이용하여 구현해보자.

package cases;

import java.util.Arrays;

public class Permutation2 {
	static int[] nums = { 1, 2, 3 };

	public static void main(String[] args) {
		// 순열의 총 개수를 구한다.
		int per_num = 1;
		for (int i = 1; i <= nums.length; i++) {
			per_num *= i;
		}
		System.out.println("순열의 총 개수  = " + per_num);

		// 해당 순열의 개수 만큼 다음 순열을 구한다.
		for (Integer num : nums) {
			System.out.print(num + " ");
		}
		System.out.println();
		for (int i = 0; i < per_num - 1; i++) {
			nextPermutation();
			System.out.println();
		}
	}

	private static void nextPermutation() {
		// 주어진 순열의 뒤부터 탐색하며, 증가하는 부분을 찾는다.
		int idx = 0;
		int N = nums.length;
		for (int i = N - 1; i > 0; i--) {
			if (nums[i - 1] < nums[i]) {
				idx = i;
				break;
			}
		}

		// 해당 인덱스를 기준으로, 좌/우지점을 나눈다.
		// 좌측의 제일 오른쪽 숫자에 대하여, 우측의 제일 오른쪽 지점부터 탐색하며 큰 수를 찾는다.
		// 해당 숫자를 찾았다면 각 숫자를 서로 Swap한다.
		for (int i = N - 1; i >= idx; i--) {
			if (nums[idx - 1] < nums[i]) {
				int temp = nums[idx - 1];
				nums[idx - 1] = nums[i];
				nums[i] = temp;
				break;
			}
		}

		// 우측 지점을 정렬한다.
		Arrays.sort(nums, idx, N);

		// 결과 출력
		for (Integer num : nums) {
			System.out.print(num + " ");
		}
	}
}

※ 만일, 주어진 수 부터의 모든 다음 순열을 구하고 싶다면, 일전에 공부한 '다음 순열은 원소가 증가하는 부분이 존재하지 않으면 존재하지 않는다'는 점을 이용하여 구하면 된다.

[Java]다음 순열(Next Permutation)

sskl660 — Thu, 25 Feb 2021 22:47:36 +0900

*다음 순열(Next Permutation).

-> 다음 순열이란, 말 그대로 해당 숫자의 다음에 올 순열의 수를 의미한다.

Ex) {1, 2, 3}에서 3개를 선택하는 경우 순열은 123, 132, 213, 231, 312, 321이 있다. 그렇다면 123 다음에 올 순열은 무엇일까? 132이다. 즉, 123의 다음 순열은 132임을 알 수 있다.

*다음 순열 구하기

-> 다음 순열을 구하는 로직은 우리가 무의식적으로 다음 순열을 구하는 로직을 천천히 곱씹으며 구체화시켜보면 가능하다. 우리는 이미 다음 순열을 구하는 방법을 알고 있다!(다만 막상 논리적 순서로 나타내보려 하면 헷갈리고 어려울 뿐이다...)

-> 규칙성을 찾기 위해서는, 작은 경우부터 침착하게 내가 어떻게 구하고 있는지 분석해보면 된다. 예를 들어, 집합 {1, 2, 3}에서 3개를 선택하는 순열은 다음과 같은 순서로 구한다.

우리는 이미 자연스럽게 다음 순열을 구할 줄 안다.

-> 우선 123의 다음 순열인 132를 구하는 과정을 생각해보자.

우선 우리는 해당 수의 뒷 부분 부터 탐색하면서, 크기가 증가하는 부분을 찾는다(뒤에서 부터 찾으면, 2에서 3으로 증가하는 부분을 먼저 찾을 수 있다).

이렇게 증가하는 부분을 찾았다면, 그 부분을 기준으로 좌/우 지점을 구분 한다.

구분된 지점에 대하여, 좌측 지점의 가장 끝 숫자에 대하여 우측 지점에서 큰 수를 찾는다. 이때, 큰 수를 찾는 순서는 우측 지점의 제일 마지막 부분부터 시작한다.

그렇게 찾은 숫자를 서로 Swap 해준다. 다음 순열을 처음 접하는 사람이라면, 우리가 이렇게 복잡한 과정을 당연히 하고 있었다는 사실에 신기함을 느낄 것이다. 하지만 여기서 끝난 것이 아니다. 한 가지 과정이 더 남아있는데, 그것은 다음 예시를 참고하자.

-> 다음으로, 132의 다음 순열인 213을 구하는 과정을 살펴보자.

마찬가지로, 해당 수의 뒷 부분부터 탐색하면서 증가하는 부분을 찾는다.

그 부분을 찾았다면, 그 지점을 기준으로 좌/우 지점을 구분한다.

구분된 지점 좌측의 가장 우측 숫자에 대하여 우측 지점의 우측 끝 부분 부터 탐색하면서, 더 큰 수를 찾는다.

그 숫자를 찾았다면, 각 숫자를 서로 Swap해준다. 하지만, 132의 다음 순열은 213인데 231이 나온 것을 확인할 수 있다. 즉, 아직 한 가지 로직이 더 남아 있음을 알 수 있다.

마지막으로, 나눠진 지점의 우측 부분의 모든 수를 '오름차순' 정렬 해준다. 여기까지가 우리가 다음 순열을 구할 때 무의식적으로 하던 행위이다. 이렇게, 규칙성을 찾는 문제는 작은 문제부터 시작하여 자신의 로직이 맞는지 천천히 검증한다면 다음 순열 뿐 만 아니라 다른 문제도 비교적 쉽게 규칙성을 찾을 수 있다.

-> 이제부터는 단순히 '구현'의 문제이다. 이 모든 과정을 코드로 구현하기만 하면 된다. 아래 예시는 입력된 수의 다음 순열을 구하는 코드이다.

package cases;

import java.util.Arrays;
import java.util.Scanner;

public class NextPermutation {
	static int[] input;
	static int N;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 입력받은 수를 배열에 저장.
		String line = sc.nextLine();
		N = line.length();
		input = new int[N];

		for (int i = 0; i < line.length(); i++) {
			input[i] = line.charAt(i) - '0';
		}

		// 다음 순열.
		nextPermutation();
		sc.close();
	}

	private static void nextPermutation() {
		// 주어진 순열의 뒤부터 탐색하며, 증가하는 부분을 찾는다.
		int idx = N - 1;
		while (idx > 0 && input[idx - 1] > input[idx]) {
			idx--;
		}

		// 만일, 증가하는 부분이 존재하지 않는다면 다음 순열은 존재하지 않는 것이다.
		if (idx == 0) {
			System.out.println("다음 순열이 존재하지 않습니다. 마지막 순열 입니다.");
			return;
		}

		// 해당 인덱스를 기준으로, 좌/우 지점으로 나눈다.
		// 좌측의 제일 오른쪽 숫자에 대하여, 우측의 제일 오른쪽 지점부터 탐색하며 큰 수를 찾는다.
		int big_idx = N - 1;
		while (big_idx > idx && input[idx - 1] > input[big_idx]) {
			big_idx--;
		}

		// 해당 숫자를 찾았다면 각 숫자를 서로 Swap한다.
		int temp = input[idx - 1];
		input[idx - 1] = input[big_idx];
		input[big_idx] = temp;

		// 우측 지점을 정렬한다.
		Arrays.sort(input, idx, N);
		
		// 결과 출력
		System.out.println(Arrays.toString(input));
	}
}

※ for문으로 구현해도 된다.

package cases;

import java.util.Arrays;
import java.util.Scanner;

public class NextPermutation {
	static int[] input;
	static int N;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 입력받은 수를 배열에 저장.
		String line = sc.nextLine();
		N = line.length();
		input = new int[N];

		for (int i = 0; i < line.length(); i++) {
			input[i] = line.charAt(i) - '0';
		}

		// 다음 순열.
		nextPermutation();
		sc.close();
	}

	private static void nextPermutation() {
		// 주어진 순열의 뒤부터 탐색하며, 증가하는 부분을 찾는다.
		int idx = N - 1;
		for (int i = N - 1; i > 0; i--) {
			if (input[i - 1] < input[i]) {
				idx = i;
				break;
			}
		}

		// 만일, 증가하는 부분이 존재하지 않으면 다음 순열은 존재하지 않는 것이다.
		if (idx == 0) {
			System.out.println("다음 순열이 존재하지 않습니다. 마지막 순열 입니다.");
			return;
		}

		// 해당 인덱스를 기준으로, 좌/우지점을 나눈다.
		// 좌측의 제일 오른쪽 숫자에 대하여, 우측의 제일 오른쪽 지점부터 탐색하며 큰 수를 찾는다.
		// 해당 숫자를 찾았다면 각 숫자를 서로 Swap한다.
		for (int i = N - 1; i >= idx; i--) {
			if (input[idx - 1] < input[i]) {
				int temp = input[idx - 1];
				input[idx - 1] = input[i];
				input[i] = temp;
				break;
			}
		}
		
		// 우측 지점을 정렬한다.
		Arrays.sort(input, idx, N);
		
		// 결과 출력
		System.out.println(Arrays.toString(input));
	}
}

[Java]부분 집합(Subset)과 멱집합(Power Set)

sskl660 — Thu, 25 Feb 2021 21:36:16 +0900

*부분 집합(Subset)

-> 부분 집합이란 쉽게 말해서 어떤 집합에 포함되는 집합을 말한다. 말 그대로 어떤 집합의 '부분'이 되는 집합이라고 생각하면 된다.

Ex) {1, 2, 3}의 부분 집합은 공집합, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3} 이 있다.

*멱집합(Power set)

-> 멱집합이란, 해당 집합의 모든 부분 집합을 모아둔 것이다.

Ex) {1, 2, 3}의 멱집합은 {공집합, {1}, {2}, {3}, {1, 2}, {1, 3}, {2, 3}, {1, 2, 3}} 이다.

*부분 집합 구하기

-> 부분 집합은 기본적으로 조합을 이용하여 쉽게 구할 수 있다. 어떤 집합에서 개수가 전체 원소의 개수가 n개인 부분 집합을 구한다면, 해당 집합에서 n개의 수를 '선택' 하면 된다. 부분 집합은 각 원소의 순서를 바꿔도 같은 부분집합이다. 따라서, 조합을 이용한다면 부분 집합을 쉽게 구할 수 있다.

*멱집합 구하기(조합 이용)

-> 멱집합은 해당 집합의 모든 부분 집합을 모은 것이라고 하였다. 따라서, 해당 집합의 원소의 개수가 총 N개라고 한다면 0부터 N개의 원소를 가지는 모든 부분 집합을 구하면 멱집합을 구할 수 있음을 알 수 있다. 따라서, 기본적으로 원소수를 바꿔 가면서 모든 조합을 구해주면 멱집합을 쉽게 구할 수 있다.

-> 예를 들어, 집합 {1, 2, 3}의 멱집합은 다음과 같이 구할 수 있다.

package cases;

import java.util.Arrays;

public class PowerSet_Combination {
	static int[] nums = { 1, 2, 3 };
	// 최대 원소의 개수
	static int max_cnt;
	// 각 부분 집합을 저장할 배열
	static int[] subset;

	public static void main(String[] args) {
		// 원소를 선택하는 개수 0 ~ 3개.
		for (int i = 0; i <= 3; i++) {
			max_cnt = i;
			subset = new int[i];
			// 대상 집합에서 원소를 0 ~ 3개를 선택하는 조합을 모두 구한다.
			Combination(0, 0);
		}
	}

	private static void Combination(int cnt, int k) {
		if (cnt == max_cnt) {
			System.out.println(Arrays.toString(subset));
			return;
		}
		for (int i = k; i < nums.length; i++) {
			subset[cnt] = nums[i];
			Combination(cnt + 1, i + 1);
		}

	}
}

*멱집합 원소의 개수(부분 집합의 총 개수)

-> 그렇다면 해당 집합의 모든 부분 집합의 개수, 즉 멱집합의 모든 원소의 개수는 몇 개 일까? 이 문제는 중복 순열의 개념을 응용하여 해결 할 수 있다.

-> 예를 들어, 집합 {1, 2, 3}에서 부분 집합을 구하는 것은 3개의 공간에 각 숫자를 넣을 것인지 말 것인지를 결정하는 문제로 치환 가능하다. 즉, 1을 넣을 공간에 1을 넣을지 말지, 2를 넣을 공간에 2를 넣을지 말지, 3을 넣을 공간에 3을 넣을지 말지를 결정하여 부분 집합을 결정할 수 있다.

부분 집합을 구하는 것은 중복 순열 문제로 치환 가능하다!

-> 따라서 최종적으로 전체 원소의 개수만큼 해당 숫자를 선택할지/선택하지 않을지를 결정하면 되기 때문에, 부분 집합의 총 개수는 2의 N승(N은 대상 집합의 총 원소의 개수)이다.

*멱집합 구하기(재귀 이용)

-> 뜬금없이 부분 집합의 총 개수를 구하는 방법을 이야기한 이유는, 부분 집합의 총 개수를 구하는 로직을 이용하여 멱집합을 구하는 방법이 존재하기 때문이다. 해당 로직을 적절히 재귀로 구현하면 역시 멱집합을 구할 수 있다.

-> 보통 멱집합에서 재귀를 이용하는 로직을 설명하기 위해서 다음과 같은 설명을 자주 볼 수 있다. 예를 들어, 집합 {1, 2, 3}의 멱집합은 집합 {1, 2, 3}에서 원소 1을 제외한 부분 집합의 모든 멱집합의 원소에, 원소 1을 포함하여 생각해주면 된다. 즉, 집합 {2, 3}의 멱집합은 공집합, {2}, {3}, {2, 3}인데, 각 멱집합의 원소에 원소 1을 추가하여 생각해주면 {1}, {1, 2}, {1, 3}, {1, 2, 3}의 경우를 추가해줄 수 있다. 이러한 과정을 거치면 최종적으로 집합 {1, 2, 3}의 멱집합과 같아진다.

-> 위의 로직은 쉽게 말해 앞에서 언급한 부분 집합의 총 개수를 구하는 로직과 같다. 즉, 어떤 원소를 포함 시킬 것인지 아니면 포함시키지 않을 것인지를 고민하며 선택을 반복하면 최종적으로 모든 부분 집합을 구할 수 있다. 집합 {1, 2, 3}의 부분 집합을 어떤 원소를 포함 시키느냐, 포함 시키지 않느냐의 문제로 해결 하는 예로 아래 트리 구조를 참고하자.

어떤 문제를 선택하느냐, 선택하지 않느냐의 문제이기 때문에 포화 이진 트리의 구조를 갖는다

-> 즉, 이렇게 이진 트리의 구조를 가지고 있기 때문에 재귀를 이용한다면, 최종적으로 모든 멱집합의 개수를 구할 수 있다. 해당 숫자를 선택했는지, 선택하지 않았는지를 표현하기 위해서 visited boolean 배열을 만들어 활용할 수 있다.

package cases;

public class PowerSet_Recursion {
	static int[] nums = { 1, 2, 3 };
	// 해당 숫자를 선택 했는지, 선택하지 않았는지를 표현해줄 배열.
	static boolean[] visited = new boolean[3];

	public static void main(String[] args) {
		// 아무것도 선택하지 않는 경우부터 시작한다.
		powerSet(0);
	}

	private static void powerSet(int cnt) {
		// 3개의 숫자에 대한 선택을 완료 하였다면, 선택된 숫자들을 출력한다.
		// 선택된 각 숫자들은 대상 배열의 '부분 집합'이다!
		if (cnt == nums.length) {
			for (int i = 0; i < nums.length; i++) {
				// 숫자가 선택 되었다면 출력한다.
				if (visited[i]) {
					System.out.print(nums[i] + " ");
				}
			}
			System.out.println();
			return;
		}

		// 해당 숫자를 선택하고 재귀를 진행한다.
		visited[cnt] = true;
		powerSet(cnt + 1);
		// 해당 숫자를 선택하지 않고 재귀를 진행한다.
		visited[cnt] = false;
		powerSet(cnt + 1);
	}
}

※ 출력 결과를 보면 위의 트리와 출력 순서가 같은 것을 확인 할 수 있다.

[Java]덱(Deque)

sskl660 — Thu, 18 Feb 2021 22:08:42 +0900

*덱(Deque)

-> 덱이란 큐와 스택의 특성을 동시에 가질 수 있는 자료구조이다.

-> 두 가지 특성을 동시에 활용할 수 있기 때문에 더 다양하게 활용될 수 있다.

덱 자료구조

*Java의 덱

-> 덱 자료 구조는 기본적으로 Queue의 구조를 채용하고 있다. 따라서 일반 큐의 연산인 poll() 메서드와 offer() 메서드는 동일하게 사용할 수 있다.

-> 덱 자료 구조는 양 방향을 모두 head로 볼 수 있다. 따라서, 배열의 관점에서 인덱스가 0인 부분의 head는 일반 큐 메서드 이름에 Fisrt를 추가하여 구분하고, 마지막 인덱스 부분의 head는 Last를 추가하여 구분한다.

-> peek() 메서드도 마찬가지이다. 좌측 부분의 head를 확인하고 싶다면 peek() 메서드 혹은 peekFirst() 메서드를 사용하면 되고, 우측 부분의 head를 확인하고 싶다면 peekLast() 메서드를 사용하면 된다.

(참고 : docs.oracle.com/javase/7/docs/api/)

Java Platform SE 7

docs.oracle.com

import java.util.ArrayDeque;
import java.util.Deque;

/**
 * 조합 : n 개 중에서 r 개 선택
 */
public class test {
    public static void main(String[] args) {
		Deque<Integer> dq = new ArrayDeque<Integer>();
		
		// 일반 큐의 구조와 마찬가지로 1, 2, 3 투입.
		dq.offer(1);
		dq.offer(2);
		dq.offer(3);
		// 큐의 좌측에 100 투입.
		dq.offerFirst(100);
		// 큐의 우측에 200 투입(그냥 offer 연산은 사용해도 된다).
		dq.offerLast(200);
		// 큐의 우측 원소를 추출
		dq.pollLast();
		
		// 큐의 우측 원소를 확인
		System.out.println(dq.peekLast());
		// 큐의 전체 숫자를 차레로 확인
		for(Integer num : dq) {
			System.out.print(num + " ");
		}
	}
}

[Java]중복 조합(Combination with repetition)

sskl660 — Thu, 18 Feb 2021 16:35:08 +0900

중복 조합을 완벽하게 이해하기 위해서는 순열, 중복 순열, 조합 세 가지를 모두 정확히 이해하고 공부하는 것이 좋다

sskl660.tistory.com/48?category=879763

[Java] 순열(Permutation)

sskl660.tistory.com

sskl660.tistory.com/49?category=879763

[Java] 중복 순열(Permutation with repetition)

*중복 순열(Permutation with repetition) ->순열을 이해했다면, 중복 순열은 이해하기 쉽다. 순열을 먼저 이해하도록 하자. sskl660.tistory.com/48 순열이란, 임의의 집합을 순서를 부여하여 차례로 나열하는

sskl660.tistory.com

sskl660.tistory.com/50?category=879763

[Java] 조합(Combination)

조합은 기본적으로 순열을 이해하고 있어야 이해하기 더 수월하다. sskl660.tistory.com/48 순열이란, 임의의 집합을 순서를 부여하여 차례로 나열하는 것을 말한다. Ex) 이를 테면 집합 {1, 2, 3}중 3개의

sskl660.tistory.com

*중복 조합(Combination with repetition)

-> 중복 조합이란, 임의의 집합을 순서가 없이 선택하는데 일반 조합과 다르게 집합의 원소를 중복해서 선택할 수 있는 차이가 존재한다.

Ex) 이를 테면 집합 {1, 2, 3}중 2개의 원소를 선택한 중복 조합의 결과는 {11, 12, 13, 22, 23, 33} 총 6가지 경우의 수가 나온다.

※ 중복 조합의 경우의 수(이 부분은 수학적인 내용이 많으니 경우의 수를 굳이 이해하고 싶지 않다면 스킵하셔도 무관합니다).

-> 중복 조합의 경우의 수는 조합에서 경우의 수를 구하는 것과 동일하게 생각하면 안된다! 조합에서 경우의 수를 구하는 것은 순열로 뽑은 수에서 '순서를 제거하는 것'이라고 하였다. 하지만 중복 조합에서는, 순서를 제거하는 경우 원치않는 경우의 수까지 제거해버리기 때문에 문제가 발생한다.

조합의 경우의 수를 이해하기 위해 위의 그림을 참고하면, {1, 2, 3}에서 2개를 선택하는 순열은 각 선택에 대하여, 순서가 존재함을 알 수 있다. 이를 테면, 12라는 선택은 순서를 부여하면 21이라는 새로운 경우를 도출할 수 있다. 마찬가지로 13은 순서를 부여하면 31이라는 새로운 경우를 도출할 수 있다. 따라서 조합에서는 이러한 '순서'의 개념을 제거한 것이다.

마찬가지로 {1, 2, 3}에서 3개를 선택하는 순열은 123이라는 선택은 순서를 부여하면 132, 213, 231, 312, 321이라는 5가지 경우를 더 도출할 수 있다. 마찬가지로 조합에서는 이 '순서'의 개념을 제거한 것 뿐이다.

-> 중복 조합의 경우의 수는 이와 다르다. 이를 테면 {1, 2, 3}에서 2개를 선택하는 중복 순열과 중복 조합을 그림을 통해 확인해보면 다음과 같다.

중복 순열에서는 '순서'라는 개념을 제거할 수 없다. 위의 예시를 그대로 활용하여 이해해보면, 12라는 선택은 순서를 부여하면 21이라는 새로운 경우의 수를 도출할 수 있지만, 11이라는 선택은 순서를 부여하더라도 11이라는 똑같은 경우를 도출하기 때문에 의미가 없다. 따라서 무턱대고 모든 경우에 대하여 동등하게 순서를 제거해버린다면 문제가 발생할 수 밖에 없기 때문에, 조합에서 경우의 수를 구하는 것 처럼 생각하면 안된다.

-> 그렇다면 중복 조합의 경우의 수는 어떻게 구할 수 있을까? 먼저 중복 조합의 경우의 수는 다음과 같이 표현하고, 다음 공식을 활용하여 구할 수 있다.

중복 조합 공식

특히 빨간 부분을 집중해서 보면서 다음 내용들을 이해해보도록 하자. 이를 테면, {1, 2, 3}의 집합에서 중복 조합을 고르는 방식은 다른 방법으로 치환하여 생각해볼 수 있다.

{1, 2, 3}이라는 집합에서 다음과 같이 1, 2, 3을 넣을 수 있는 영역을 각각 막대기를 통해서 구분한뒤, 2개를 선택하는 경우의 수를 생각해보자.

막대기로 구분 된 각 영역에, 중복을 허용하여 집합에서 숫자를 선택한 뒤 영역에 넣는 경우의 수를 생각해보면 위와 같은 경우를 생각할 수 있다. 이를 일반화하여 생각하면, n개의 원소를 가진 집합에서 r개를 선택하는 경우, 구분하는 영역을 n - 1개로 분할하는 막대기의 개수와 선택하고자하는 숫자 r개 중 숫자 r개를 선택하는 조합으로 바꾸어 생각할 수 있다!(반대로, 숫자와 막대기 중 막대기를 둘 칸을 선택하는 경우로 바꾸어 생각해도 된다. nCr = nCn-r이므로, 두 가지 중 어떤 선택을 해도 상관이 없다. 중요한 것은, 선택해야하는 숫자와 막대기의 개수는 이미 정해져 있으므로(n - 1 + r칸), 그 칸 중 숫자를 어떤 칸에 넣을 것인지 혹은 막대기를 어떤 칸에 넣을 것인지를 고민하는 느낌을 이해하면 된다).

*구현(Java)

-> 중복 조합은 조합에서 중복 선택이 가능하도록 조치만 취해주면 되기 때문에 구현은 간단하다.

※ 중복 조합 알고리즘

1. 대상 집합을 순회하며 숫자를 하나 선택하는 것을 아래와 같이 반복한다.

(1) 집합을 순회하며 탐색을 하되, 입력된 인덱스부터 탐색한다.

(2) 수를 선택했다면, 해당 인덱스와 같은 인덱스를 다음 재귀 함수에 넘겨준다.

2. 선택된 숫자가 r개가 된다면, 재귀를 종료한다.

-> 예를 들어, 1부터 3까지의 자연수 3개 중 2개를 선택한 중복 조합은 다음과 같이 구현할 수 있다.

package cases;

import java.util.Arrays;

public class Combination_with_repetition {
	// 선택하고자 하는 대상 집합.
	static int[] target = new int[] { 1, 2, 3 };
	// 대상 숫자를 담아둘 배열.
	static int[] result = new int[2];

	public static void main(String[] args) {
		combination(0, 0);
	}

	// 조합 메서드(cnt는 선택 횟수, idx는 다음 대상을 선택할때 집합에서 탐색을 시작할 인덱스).
	private static void combination(int cnt, int idx) {
		// 2개를 선택했으므로, 결과를 출력하고 재귀를 종료한다.
		if (cnt == 2) {
			System.out.println(Arrays.toString(result));
			return;
		}
		// 대상 집합을 주어진 인덱스부터 순회하며 숫자를 하나 선택한다.
		for (int i = idx; i < 3; i++) {
			// 숫자를 담는다.
			result[cnt] = target[i];
			// 자신을 재귀 호출한다(자신의 수는 중복 선택이 가능하므로, 인덱스를 그대로 넘겨준다).
			combination(cnt + 1, i);
		}
	}
}

[Java]조합(Combination)

sskl660 — Thu, 18 Feb 2021 14:42:36 +0900

조합은 기본적으로 순열을 이해하고 있어야 이해하기 더 수월하다.

sskl660.tistory.com/48

[Java] 순열(Permutation)

sskl660.tistory.com

*조합(Combination)

-> 조합이란, 임의의 집합을 순서가 없이 선택하는 것을 말한다.

Ex) 이를 테면 집합 {1, 2, 3}중 2개의 원소를 선택한 조합을 구하시오라고 하면, 결과는 {12, 13, 23} 총 3가지의 경우의 수가 나온다.

조합 경우의 수

※ 조합이 총 3가지가 나오는 이유는, 위의 예시에서 선택한 2가지 수를 박스에 하나씩 넣는 상황을 가정해보자. 우선 3개의 숫자 중 2개의 숫자를 선택하여 나열하는 순열을 구한다. 이후, 2개의 공간에 나열된 숫자들은 '순서'를 부여 받은 상태이므로 그 '순서를 부여 받은 상태를 제거' 해준다면 조합의 경우의 수를 구할 수 있다. 즉, 2개중 2개를 선택하는 순열의 경우의 수로 나눠주면 된다.

-> 위의 조합의 경우의 수를 일반화하면, n개의 수 중 r개를 선택하는 조합은 nPr의 순열을 구하고, rPr의 순열로 나눈 값을 경우의 수로 가짐을 알 수 있다.

조합 경우의 수

*구현(Java)

-> 조합은 순열에 비해 로직을 조금 더 고민해 보아야 이해할 수 있다. 순열은 순서를 고려하였기 때문에, 재귀 호출을 하여 다음 수를 선택하는 경우 집합의 처음부터 탐색하며 다음 대상을 고려하였다. 하지만 조합은 순서를 고려하지 않기 때문에, 다음 수를 선택하는 경우 집합의 처음부터 탐색하며 다음 대상을 고려하는 경우, 이미 선택했던 경우의 수를 또 선택하는 오류가 발생한다.

조합에서 다음과 같이 다음 수를 선택할때 집합의 처음부터 탐색하면, 오류가 발생한다.

->따라서 조합은 다음과 같은 로직을 이용하면 구현할 수 있다.

※ 조합 알고리즘

1. 대상 집합을 순회하며 숫자를 하나 선택하는 것을 아래와 같이 반복한다.

(1) 집합을 순회하며 탐색을 하되, 입력된 인덱스부터 탐색한다.

(2) 수를 선택했다면, 해당 인덱스보다 큰 인덱스를 다음 재귀 함수에 넘겨준다.

2. 선택된 숫자가 r개가 된다면, 재귀를 종료한다.

-> 예를 들어, 1부터 3까지의 자연수 3개 중 2개를 선택한 조합은 다음과 같이 구현할 수 있다.

import java.util.Arrays;

public class Combination {
	// 선택하고자 하는 대상 집합.
	static int[] target = new int[] { 1, 2, 3 };
	// 대상 숫자를 담아둘 배열.
	static int[] result = new int[2];

	public static void main(String[] args) {
		combination(0, 0);
	}

	// 조합 메서드(cnt는 선택 횟수, idx는 다음 대상을 선택할때 집합에서 탐색을 시작할 인덱스).
	private static void combination(int cnt, int idx) {
		// 2개를 선택했으므로, 결과를 출력하고 재귀를 종료한다.
		if (cnt == 2) {
			System.out.println(Arrays.toString(result));
			return;
		}
		// 대상 집합을 주어진 인덱스부터 순회하며 숫자를 하나 선택한다.
		for (int i = idx; i < 3; i++) {
			// 숫자를 담는다.
			result[cnt] = target[i];
			// 자신을 재귀 호출한다(자신 이전의 수를 중복 선택하지 않도록 인덱스를 +1하여 재귀를 호출한다).
			combination(cnt + 1, i + 1);
		}
	}
}

[Java]중복 순열(Permutation with repetition)

sskl660 — Thu, 18 Feb 2021 14:13:42 +0900

*중복 순열(Permutation with repetition)

->순열을 이해했다면, 중복 순열은 이해하기 쉽다. 순열을 먼저 이해하도록 하자.

sskl660.tistory.com/48

[Java] 순열(Permutation)

sskl660.tistory.com

->중복 순열이란, 임의의 집합을 순서를 부여하여 차례로 나열하는데 일반 순열과 다르게 집합의 원소를 중복해서 선택할 수 있는 차이가 존재한다.

Ex) 이를 테면 집합 {1, 2, 3}중 3개의 원소를 선택한 중복 순열의 결과는 {111, 112, 113, 121, ..., 333} 총 27가지 경우의 수가 나온다.

중복 순열 경우의 수

※ 중복 순열이 총 27가지가 나오는 이유는, 순열과는 다르게 다음 수를 선택할때 중복 선택을 허용하기 때문이다.

-> 위의 중복 순열의 경우의 수를 일반화하면, n개의 수 중 r개를 선택하는 중복 순열은 n의 r승개의 경우의 수를 가짐을 알 수 있다.

중복 순열 경우의 수

*구현(Java)

-> 순열과 마찬가지로 재귀를 이용하면 쉽게 구현할 수 있다. 중복 선택할 수 있다는 점만 다르다는 것을 기억하면 된다.

※ 중복 순열 알고리즘

1. 대상 집합을 순회하며 숫자를 하나 선택하고, 자신의 메서드를 재귀 호출한다.

2. 선택된 숫자가 r개가 된다면, 재귀를 종료한다.

-> 예를 들어, 1부터 3까지의 자연수 3개 중 2개를 선택한 중복 순열은 다음과 같이 구현할 수 있다. 일반 순열에서 중복 선택을 방지하기 위해 만들었던 visited배열과 관련 로직이 사라진 것을 확인할 수 있다.

package cases;

import java.util.Arrays;

public class Permutation_with_repetition {
	// 선택하고자 하는 대상 집합.
	static int[] target = new int[] { 1, 2, 3 };
	// 대상 숫자를 담아둘 배열을 만든다.
	static int[] result = new int[2];

	public static void main(String[] args) {
		permutation(0);
	}

	// 순열 메서드(cnt는 선택 횟수)
	private static void permutation(int cnt) {
		// 2개를 선택했으므로, 결과를 출력하고 재귀를 종료한다.
		if (cnt == 2) {
			System.out.println(Arrays.toString(result));
			return;
		}
		// 대상 집합을 순회하며 숫자를 하나 선택한다.
		for (int i = 0; i < 3; i++) {
			// 숫자를 담는다.
			result[cnt] = target[i];
			// 자신을 재귀 호출한다.
			permutation(cnt + 1);
		}
	}
}

[Java]순열(Permutation)

sskl660 — Thu, 18 Feb 2021 13:55:30 +0900

*순열(Permutation)

-> 순열이란, 임의의 집합을 순서를 부여하여 차례로 나열하는 것을 말한다.

Ex) 이를 테면 집합 {1, 2, 3}중 3개의 원소를 선택한 순열을 구하시오라고 하면, 결과는 {123, 132, 213, 231, 312, 321} 총 6가지의 경우의 수가 나온다.

순열 경우의 수

※ 순열이 총 6가지가 나오는 이유는, 위의 예시에서 선택한 3가지 수를 위 박스에 하나씩 넣는 상황을 가정해보면, 첫 번째 자리에는 {1, 2, 3}중 한 가지 숫자 어느것이든 올 수 있다. 두 번째 자리에는 앞에서 이미 한 가지 수를 선택했으므로, 그 선택한 수를 제외한 2가지 숫자가 어느 것이든 올 수 있다. 마지막 자리는 선택이 되지 않은 나머지 한 가지 수가 오게 될 것이다. 따라서 3개의 숫자를 3개선택한 순열의 경우의수는 총 6가지이다.

-> 위의 순열의 경우의 수를 일반화하면, n개의 수 중 r개를 선택하는 순열은 총 n!/(n - r)!개의 경우의수를 가짐을 알 수 있다(수학적으로 여러가지 방법으로 표현 가능하다).

순열 경우의 수

*구현(Java)

-> 로직은 위에 언급한 예시를 그대로 구현했다고 생각하면 된다. 따라서, 순열은 재귀를 이용하면 쉽게 구현할 수 있다.

※ 순열 알고리즘

1. 대상 집합을 순회하며 숫자를 하나 선택하는 것을 아래와 같이 반복한다.

(1) 만일, 숫자가 이미 선택되었다면 그 숫자는 선택할 수 없으므로 스킵한다.

(2) 만일, 숫자가 선택되지 않았다면 그 숫자에 대하여 방문 표시를하고 자신의 메서드를 재귀 호출한다.

2. 선택된 숫자가 r개가 된다면, 재귀를 종료한다.

-> 예를 들어, 1부터 3까지의 자연수 3개중 2개를 선택한 순열을 다음과 같이 구현할 수 있다.

public class Permutation {
	// 선택하고자 하는 대상 집합.
	static int[] target = new int[] { 1, 2, 3 };
	// 대상 숫자를 선택했는지를 알려주는 집합.
	static boolean[] visited = new boolean[3];

	public static void main(String[] args) {
		permutation(0, "");
	}

	// 순열 메서드(cnt는 선택 횟수, result는 결과)
	private static void permutation(int cnt, String result) {
		// 2개를 선택했으므로, 결과를 출력하고 재귀를 종료한다.
		if (cnt == 2) {
			System.out.println(result);
			return;
		}
		// 대상 집합을 순회하며 숫자를 하나 선택한다.
		for (int i = 0; i < 3; i++) {
			// 이미 해당 숫자를 선택한 경우에는 스킵.
			if (visited[i]) {
				continue;
			}
			// 선택하지 않은경우, 선택했다는 표시를 해준다.
			visited[i] = true;
			// 자신을 재귀 호출한다.
			permutation(cnt + 1, result + target[i]);
			// 선택을 해제한다.
			visited[i] = false;
		}
	}
}

-> 다음과 같이, 매개변수를 1개만 사용하여 만들수도 있다. 위의 예시와 같이 상자라는 대상을 더욱 구체화 시킨 것이라고 볼 수 있다. 매개변수의 수보다는, 순열을 구현하는 로직을 정확히 이해하도록 하자.

import java.util.Arrays;

public class Permutation {
	// 선택하고자 하는 대상 집합.
	static int[] target = new int[] { 1, 2, 3 };
	// 대상 숫자를 선택했는지를 알려주는 집합.
	static boolean[] visited = new boolean[3];
	// 대상 숫자를 담아둘 배열을 만든다.
	static int[] result = new int[2];

	public static void main(String[] args) {
		permutation(0);
	}

	// 순열 메서드(cnt는 선택 횟수)
	private static void permutation(int cnt) {
		// 2개를 선택했으므로, 결과를 출력하고 재귀를 종료한다.
		if (cnt == 2) {
			System.out.println(Arrays.toString(result));
			return;
		}
		// 대상 집합을 순회하며 숫자를 하나 선택한다.
		for (int i = 0; i < 3; i++) {
			// 이미 해당 숫자를 선택한 경우에는 스킵.
			if (visited[i]) {
				continue;
			}
			// 선택하지 않은경우, 선택했다는 표시를 해준다.
			visited[i] = true;
			// 숫자를 담는다.
			result[cnt] = target[i];
			// 자신을 재귀 호출한다.
			permutation(cnt + 1);
			// 선택을 해제한다.
			visited[i] = false;
		}
	}
}

[Java]해시맵(HashMap)

sskl660 — Sat, 13 Feb 2021 18:46:24 +0900

*Java Collections : 맵(Map) 인터페이스

->모든 데이터를 '키(Key)'와 '값(Value)'의 '한 쌍(Pair)의 형태'로 연관지어 저장한다.

->키(Key)는 중복을 허용하지 않고, 값(Value)은 중복을 허용한다.

->순서는 중요하지 않다 : 순서가 없다.

*해시맵(HashMap) 클래스

->맵 인터페이스를 구현한 자바의 대표적인 Collections 클래스.

->해시(Hash)를 사용하기 때문에 검색이 빠르다(리스트에서 검색하는 속도보다 빠르다).

->키(Key)와 값(Value)을 저장하기 때문에, HashMap<Key, Value>의 형태로 선언한다.

HashMap<Integer, String> hm = new HashMap<Integer, String>();

->기본적으로 삽입은 put, 삭제는 remove, 조회는 여러가지 방법으로 할 수 있다. 아래 API를 참고하자.

출처 : https://docs.oracle.com/javase/7/docs/api/

import java.util.HashMap;
import java.util.Map.Entry;

public class test {
	public static void main(String[] args) {
		// 해시맵 선언
		HashMap<Integer, String> hm = new HashMap<Integer, String>();
		
		// 키, 값을 각각 추가한다.
		hm.put(1, "kim");
		hm.put(2, "lee");
		hm.put(3, "park");
		// 키는 중복될 수 없다. 따라서 3번 키는 hong으로 갱신될 것이다.
		hm.put(3, "hong");
		
		// 키를 기준으로 해당 데이터를 삭제할 수 있다.
		hm.remove(1);
		
		// 해시맵 전체 출력
		System.out.println(hm);
		// 해시맵의 키 전체 출력
		System.out.println(hm.keySet());
		// 해시맵의 값 전체 출력
		System.out.println(hm.values());
		
		// 반복을 이용하여 키와 그에 대응하는 값을 가져오는 코드
		for(Entry<Integer, String> h : hm.entrySet()) {
			System.out.println(h);
		}
	}
}

자바(Java) 싱글턴 패턴(Singleton Pattern)

sskl660 — Sat, 23 Jan 2021 12:28:20 +0900

*싱글턴 패턴

->객체가 1개의 인스턴스만 가져야 하는 경우 사용하는 자바의 디자인 패턴 중 하나이다.

->장점 : 인스턴스가 1개만 생성되기 때문에 효율적인 메모리 관리가 가능하다.

->단점 : 동시에 해당 인스턴스를 공유하는 환경(특히, Multithread 환경)에서 동시성(Concurrency) 문제 고려로 인하여 프로그램의 유연성이 감소한다.

※이러한 동시성의 문제를 해결한 것을 Thread-safe하다 라고 한다. 여러가지 싱글턴 패턴(이른 초기화 방식, 게으른 초기화 방식...)이 존재하는데, 이 글에서는 이른 초기화 방식만 다룬다.

*싱글턴 패턴 : 이른 초기화(Eager Initialization)

->이른 초기화는 static 예약어를 사용하여 정적 바인딩(Static binding)을 통해 컴파일 시점에 인스턴스를 메모리에 등록하여 사용하는 방식이다. 최초로 클래스가 로딩 될 때 객체가 생성되기 때문에 Thread-safe하지만, static의 특성으로 인해 로딩 되는 시점부터 객체가 항상 생성되어 있기 때문에, 비효율적일 수 있는 문제가 있다.

class BookMgr {
	// private 예약어를 사용하여 외부에서 해당 변수에 접근하지 못하도록 막는다.
	// static 예약어를 사용하여 클래스가 최초 로딩될 때 BookMgr 인스턴스가 생성된다.
	private static BookMgr manager = new BookMgr();
	
	// private 예약어를 사용하여 외부에서 BookMgr 생성자를 사용 못하도록 막는다. 
	private BookMgr() {

	}
	
	// public 예약어를 사용하여 해당 클래스 메서드를 통해서만 생성된 1개의 인스턴스를 반환하도록 한다.
	public static BookMgr getInstance() {
		return manager;
	}
}

public class SingletonTest{
	public static void main(String[] args) {
		// 클래스 메서드를 이용하여 1개 뿐인 BookMgr 인스턴스를 호출한다.
		BookMgr manager = BookMgr.getInstance();
	}
}

자바(Java) BufferedReader 클래스

sskl660 — Mon, 18 Jan 2021 23:53:48 +0900

자바의 BufferedReader 클래스를 사용하기 전에, 먼저 스트림(Stream)의 개념과, Scanner 클래스에 대해 먼저 간단히 이해 하는 것이 좋다. 잘 모른다면 아래 글을 참고하여 이해하도록 하자.

sskl660.tistory.com/44

스트림(Stream)과 자바(Java)의 Scanner 클래스

*입출력 스트림(Stream) ->컴퓨터 공학에서 스트림은 연속적인 데이터의 흐름 혹은 데이터를 전송하는 소프트웨어 모듈을 말한다. 이름의 의미와 마찬가지로 스트림은 도착한 순서대로 데이터

sskl660.tistory.com

*vs. Scanner

->BufferedReader 와 Scanner 클래스는 대표적인 Java의 문자열을 입력받는 클래스이다. 특히 알고리즘 문제 풀이시 대용량 데이터를 처리하는 경우, BufferedReader 클래스를 많이 사용하기 때문에, 우선은 알고리즘 문제 풀이시 참고할만한 수준에서 이 두 클래스의 용도를 구분하면 다음과 같다.

(1) 수행 시간(속도) 측면 : BufferedReader가 Scanner 클래스에 비하여 더 빠르게 입력을 처리할 수 있다.

출처 : https://algospot.com/forum/read/2496/

※BufferedReader는 Scanner 클래스에 비해 더 큰 Buffer Size를 가지고 있으며, BufferedReader 클래스는 문자열을 단순히 읽어 들이는 방식이지만 Scanner 클래스는 문자열을 읽어 많은 정규식과 함께 구문 분석을 하는 용도로 사용되기 때문에 수행 시간의 차이가 발생한다! 정도로만 우선 알아두도록 하자.

(참고 : stackoverflow.com/questions/2231369/scanner-vs-bufferedreader).

※Buffer에 의한 수행 시간 차이 : Buffer는 데이터를 편리하게 이동시켜주는 수단이라고 생각하면 이해하기 좋다. 데이터를 스트림을 통해 이동한다고 하였는데, 이 데이터의 이동 자체가 자원이 드는 행위이다. 일상 생활에서 한 번에 많은 사람을 효율적으로 이동시키기 위하여 버스와 지하철을 이용하듯이, Buffer Size에 따라 한 번에 이동 시킬 수 있는 데이터의 양이 달라진다. 따라서, Buffer Size가 더 큰 BufferedReader 클래스가 더 빠른 처리 속도를 가지고 있는 것이다.

(2) 사용성 측면 : Scanner 클래스가 BufferedReader 클래스에 비해 문자열을 파싱하는 여러 기능을 많이 가지고 있기 때문에, 사용하기 편하다.

->쉽게 말해 간단한 문제의 경우 Scanner 클래스를 이용하여 간단하게 처리하면 되지만, 알고리즘 문제를 풀 때 많은 입력 데이터로 인한 수행 시간 과부하를 방지하기 위해서는 BufferedReader 클래스를 사용해야 한다.

*BufferedReader 클래스(알고리즘 문제에서 사용되는 예시)

->처음 사용하기는 까다롭지만 바이트 스트림과 문자 스트림, 그리고 버퍼에 대한 이해를 바탕으로 아래 단계를 이해하였다면 이후에는 암기하여 빠르게 입력 데이터를 처리하는 연습을 하도록 하자.

(1) InputStreamReader 클래스 이용 : 이 클래스는 바이트 스트림과 문자 스트림을 연결시켜주는 다리 역할을 한다. 표준 입력(System.in)은 InputStream 형태로 지정되어 있으며, InputStream은 바이트 단위 입력 스트림의 취상위 클래스이다. 즉, 바이트 스트림인 System.in을 InputStreamReader 클래스를 이용하여 문자 스트림으로 변경시키는 작업을 먼저 해주어야 한다.

InputStreamReader in = new InputStreamReader(System.in);

(참고1. docs.oracle.com/javase/7/docs/api/java/io/InputStream.html).

(참고2. docs.oracle.com/javase/7/docs/api/java/lang/System.html).

InputStream (Java Platform SE 7 )

Reads some number of bytes from the input stream and stores them into the buffer array b. The number of bytes actually read is returned as an integer. This method blocks until input data is available, end of file is detected, or an exception is thrown. If

docs.oracle.com

(2) BufferedReader 클래스 이용 : InputStreamReader 클래스를 이용해 변환된 문자 스트림을 버퍼 스트림에 저장 시킨다(쉽게 말해, 데이터를 버퍼라는 상자에 가공하여 적재시키는 단계).

BufferedReader br = new BufferedReader(in);

보통 앞선 1, 2 단계를 합쳐 아래와 같이 간단하게 작성한다.

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

(3) 적재된 데이터를 불러온다 : BufferedReader의 내부 메서드를 이용하여 데이터를 읽어온다. 보통 알고리즘 문제에서는 1라인 단위 스트링 데이터로 많이 불러오기 때문에 readLine() 메서드를 많이 사용한다.

(BufferedReader 메서드 참고 : docs.oracle.com/javase/7/docs/api/java/io/BufferedReader.html)

String line = br.readLine();

(4) 적재된 데이터를 가공한다 : 앞선 단계는 스트림을 적절히 변환 시키고, 적재된 데이터를 한 줄씩 불러오는 과정에 불과하다. 하지만 대부분의 알고리즘 문제를 푸는 경우, 불러온 데이터를 적절히 가공하여 사용하는 것이 주된 목표이다. 아래 두 방법은 보통 알고리즘 문제에서 BufferedReader에 적재된 데이터를 readLine() 메서드를 활용하여 한 줄 String 단위로 불러오고, 해당 라인 내에서 '특정 문자'를 기준으로 데이터들을 분류하여 해석해야되는 경우가 많기 때문에 사용하는 것임을 알아두자. 즉, StringTokenizer 클래스와 String.split() 메서드는 한 줄 String 데이터를 '특정 문자'를 기준으로 분류하기 편하기 때문에 사용하는 것이다.

(4 - 1) StringTokenizer 클래스 이용 : 생성된 객체에 특정 문자를 기준으로 문자열을 분리하여 토큰 단위로 저장하고, 메서드를 이용해 저장된 문자열을 원하는 대로 불러올 수 있다.

(StringTokenizer 메서드 참고 : docs.oracle.com/javase/7/docs/api/java/util/StringTokenizer.html).

Ex) StringTokenizer를 이용한 데이터의 가공과 사용 예.

package practice;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class BufferedReaderTest {
	public static void main(String[] args) throws Exception {
		// 바이트 스트림인 System.in을 InputStreamReader 클래스를 이용하여 문자 스트림으로 바꾼다.
		// 바꾼 문자 스트림을 BufferedReader 클래스를 이용하여 버퍼 스트림으로 바꾼다.
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		// 버퍼 스트림에서 한 줄(Line) String 데이터를 불러온다.
		// 불러온 String 데이터를 공백을 기준으로 토큰단위로 나눈뒤 저장한다.
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		// hasMoreTokens() 메서드를 이용하여 st객체에 문자열이 남아있는지 확인한다.
		while(st.hasMoreTokens()) {
			// 남아있는 토큰을 하나씩 불러온다.
			String word = st.nextToken();
			System.out.print(word + " ");
		}
	}
}

※만일 불러온 토큰 데이터를 정수로 변환하고 싶은 경우, Wrapper 클래스인 Integer 클래스를 적절히 활용하여 데이터를 가공할 수 있다!

(4 - 2) String.split() 메서드 이용 : StringTokenizer 클래스와 마찬가지로 String.split() 메서드 또한 특정 문자를 기준으로 문자열을 분리하여 토큰 단위로 저장할 수 있다. 다만, 특정 배열을 생성하여 저장하여야하고, 해당 배열의 인덱스를 참조해서 불러오는등의 번거로움이 존재한다.

package practice;

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class BufferedReaderTest {
	public static void main(String[] args) throws Exception {
		// 바이트 스트림인 System.in을 InputStreamReader 클래스를 이용하여 문자 스트림으로 바꾼다.
		// 바꾼 문자 스트림을 BufferedReader 클래스를 이용하여 버퍼 스트림으로 바꾼다.
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		// 버퍼 스트림에서 한 줄(Line) String 데이터를 불러온다.
		// 불러온 String 데이터를 공백을 기준으로 나눈뒤  String 타입의 list 배열에 저장한다.
		String[] list = br.readLine().split(" ");
		
		// list 배열에 접근하여 데이터를 불러온다.
		for (int i = 0; i < list.length; i++) {
			System.out.println(list[i]);
		}
	}
}

스트림(Stream)과 자바(Java)의 Scanner 클래스

sskl660 — Thu, 14 Jan 2021 21:22:44 +0900

*입출력 스트림(Stream)

->컴퓨터 공학에서 스트림은 연속적인 데이터의 흐름 혹은 데이터를 전송하는 소프트웨어 모듈을 말한다. 이름의 의미와 마찬가지로 스트림은 도착한 순서대로 데이터를 흘려 보낸다.

->스트림을 통해 흘러가는 데이터의 기본 단위는 바이트(Byte)이다.

->입력 스트림(Input Stream) : 입력 장치(마우스, 키보드, 네트워크...)와 프로그램이 연결되어, 입력된 데이터가 프로그램으로 순서대로 흘러간다.

->출력 스트림(Output Stream) : 프로그램과 출력 장치(모니터, 프린터, 네트워크...)가 연결되어, 출력 데이터가 출력 장치로 순서대로 흘러간다.

※위의 그림을 통해 스트림은 단방향이며, 선입선출(FIFO) 구조임을 알 수 있다.

->자바는 바이트 스트림과 문자 스트림으로 나뉜다. 바이트 스트림은 입출력되는 바이트의 바이너리 값을 있는 그대로 처리하므로 어떤 데이터가 들어와도 처리할 수 있다. 하지만 문자 스트림은 오직 문자만 다룰 수 있다.

->자바의 표준 입출력 : 자바에서는 System 클래스를 이용하여 표준 입력(System.in), 표준 출력(System.out), 표준 에러(System.err)를 제공한다.

*Scanner 클래스

->정규식을 사용하여 기본 데이터 타입/문자열을 구문 분석할 수 있는 간단한 텍스트 스캐너.

※정규식(Regular expression, regex) : 특정한 규칙을 가진 문자열의 집합을 표현하는 형식 언어. 다양한 문자열의 검색과 치환을 위하여 지원된다.

->쉽게 말해 Scanner 클래스는 다양한 타입의 입력 값들을 읽어들이기 위한 편리한 방법을 제공하는 클래스이다.

->Scanner 클래스의 생성자에는 다양한 데이터가 들어갈 수 있다.

import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		// 표준 입력 스트림을 생성자로 Scanner 클래스를 선언한 예.
		Scanner scan = new Scanner(System.in);
		
		int a = scan.nextInt();
		String b = scan.next();
		
		System.out.println(a);
		System.out.println(b);
	}
}

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) throws FileNotFoundException {
		// 텍스트 파일을 생성자로 Scanner 클래스를 선언한 예.
		Scanner scan = new Scanner(new File("./src/practice/myText.txt"));
		
		while (scan.hasNext()) {
			int a = scan.nextInt();
			System.out.println(a);
		}
	}
}

->Scanner은 공백 또는 개행 문자를 기준으로 입력 값들을 읽기 때문에, 사용자의 편의에 따라 쉽게 입력을 받을 수 있는 장점이 존재한다.

출처 : https://docs.oracle.com/javase/7/docs/api/

※nextLine() 메서드 : Scanner를 이용한 입력에서 특히 주의 해야하는 메서드이다. next(), nextInt() 등의 메서드는 띄어쓰기를 기준으로 입력 값들을 읽고, nextLine() 메서드의 경우 한 라인을 기준으로 입력 값들을 읽는다. 이 경우 문제가 발생할 수 있는데, next() 계열 메서드를 입력한 후 Enter를 입력하는 경우, next()계열 메서드는 Enter의 줄바꿈 문자를 처리하지 못하고 버퍼에 남겨 둔다. 이 남겨둔 개행 문자를 다음 라인에서 nextLine()이 인식하는 순간, 의도치 않은 출력 결과를 볼 수 있게 된다.

import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		// 이름을 입력하고 Enter를 입력하면, Enter이전의 값들만 name에 입력되고 Enter 값은 버퍼에 남는다.
		String name = scan.next();
		// 버퍼에 남은 Enter값을 바로 인식해버려, grade에는 Enter값이 할당된다.
		String grade = scan.nextLine();

		System.out.println(name);
		System.out.println(grade);
	}
}

->그림을 참고해보면, grade를 입력하기도 전에 프로그램이 종료된 것을 알 수 있다. 또한, 아래 공백문자가 grade의 값으로 출력된 것을 알 수 있다!(공백 문자를 인식하지 못했다면 아래 공백 부분은 출력되지 않는다). 이는 아래와 같은 두 가지 방법을 이용하여 해결 할 수 있다.

(1) 인위적인 개행 문자 제거


import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		
		int age = scan.nextInt();
		// 인위적으로 해당 라인을 삽입하여 개행 문자를 제거한다!
		scan.nextLine();
		String grade = scan.nextLine();

		System.out.println(age);
		System.out.println(grade);
	}
}

(2) Wrapper 클래스 활용

import java.util.Scanner;

public class ScannerTest {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);

		// 개행 문자까지 받은 뒤, Integer 클래스의 parseInt 메서드를 활용한다!
		int age = Integer.parseInt(scan.nextLine());
		String grade = scan.nextLine();

		System.out.println(age);
		System.out.println(grade);
	}
}

깊은 복사(Deep Copy)와 얕은 복사(Shallow Copy)

sskl660 — Wed, 13 Jan 2021 23:15:27 +0900

깊은 복사와 얕은 복사를 이해하기 위해서는 값 복사와 주소 복사를 이해해두어야 한다.

잘 모른다면 아래 글을 참고하여 이해하도록 하자.

sskl660.tistory.com/37?category=866784

메서드 Overloading과 매개변수

*변수의 중복 선언 ->변수의 경우는 데이터의 타입이 달라도 변수 이름이 동일한 경우를 허용하지 않는다. Ex) 다음과 같은 경우는 컴파일 에러가 발생한다. class Employee { String name; // age 변수가 in

sskl660.tistory.com

*얕은 복사(Shallow Copy)

->얕은 복사는 쉽게 말해 주소가 복사되는 것을 말한다.

public class ShallowCopy {
	public static void main(String[] args) {
		int[] list = {1, 2, 3, 4};
		int[] shallow_copy = list;
		
		System.out.println(list);
		System.out.println(shallow_copy);
	}
}

새로운 객체가 원본 객체와 동일한 주소를 바라본다!

->장점 : 같은 객체를 공유하므로 메모리를 절약하고, 빠른 장점이 존재한다. 참조에 의한 호출(Call by Reference)에서 얕은 복사가 이루어 지는 이유 중 하나이기도 하다.

->단점 : 두개 이상의 객체가 같은 대상을 가리키고 있기 때문에, 의도치 않게 여러 개의 객체가 동시에 수정될 수 있다.

*깊은 복사(Deep Copy)

->얕은 복사가 주소 복사와 관련이 있듯이, 깊은 복사는 값 복사와 마찬가지로 생각하면 된다. 즉, 새로운 메모리 공간에 값을 복사하는 것이다.

public class DeepCopy {
	public static void main(String[] args) {
		int[] list = {1, 2, 3};
		int[] deep_copy = list.clone();
		
		System.out.println(list);
		System.out.println(deep_copy);
	}
}

새로운 객체는 새로운 메모리 공간에 값이 복사된다!

->장점 : 얕은 복사와 반대로 여러 객체가 동시에 수정되는 일이 발생하지 않아, 변경에는 안전하다.

->단점 : 객체 생성 비용이 비싸며, 메모리를 많이 점유한다.

->특히, 특정 객체를 깊은 복사하는 경우 Clonable 인터페이스를 활용하여, clone()메서드를 Overriding해주어야 깊은 복사가 가능하다.

class A implements Cloneable {
	private String name;
	
	// Object 클래스는 자바의 최상위 클래스!
	// 새로운 Object를 넘겨주는 clone 메서드를 Overriding 한다.
	// CloneNotSupportedException은 해당 객체가 Clonable 인터페이스를 구현하고 있지 않는 경우를 대비한 예외이다.
	public Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

public class DeepCopy {
	public static void main(String[] args) throws CloneNotSupportedException {
		A a = new A();
		// Object 클래스(부모 클래스)를 넘겨주므로, 캐스팅이 필요하다!
		A b = (A) a.clone();
		
		System.out.println(a);
		System.out.println(b);
	}
}

[Java]큐(Queue)

sskl660 — Fri, 25 Sep 2020 21:22:53 +0900

*큐(Queue)

->큐란 선입선출(FIFO : First In First Out)의 특성을 가진 자료구조이다.

->쉽게 말해 먼저 들어간 것이 먼저 나온다. 정거장에 들어오는 지하철이나, 놀이공원에 줄 서 있는 사람들을 생각하면 이해하기 쉽다.

큐 자료구조

*Java의 큐

->큐 입력 연산은 일반적으로 offer() 메서드, 출력 연산은 poll() 메서드를 이용한다(add()와 remove()도 있지만, 이 메서드들은 Exception을 발생시키는 특징이 있다). head에 있는 원소(다음으로 나올 차례인 것)를 확인하는 연산은 peek()메서드를 이용한다.

출처 : https://docs.oracle.com/javase/7/docs/api/java/util/Queue.html

->자바의 Queue관련 API를 살펴보면 인터페이스로 구현되어 있기 때문에, 큐 인터페이스를 상속하여 구현해놓은 LinkedList<E>클래스를 이용하여 객체를 생성한다.

※이외에도 큐는 여러 방면으로 활용되는 경우가 많아, 우선순위큐(PriorityQueue)등의 다른 클래스들을 이용하여 객체를 생성하고 활용할수도 있다.

import java.util.LinkedList;
import java.util.Queue;

public class test {
	public static void main(String[] args) {
		Queue<Integer> q = new LinkedList<Integer>();
		
        // 큐에 1, 2, 3, 4를 차례로 넣는다.
		q.offer(1);
		q.offer(2);
		q.offer(3);
		q.offer(4);
        // 제일 처음 넣은 1을 뺀다.
		q.poll();
        // 제일 head의 원소를 확인 : 결과는 2.
		System.out.println(q.peek());
		System.out.println(q);
		q.clear();
		System.out.println(q);
	}
}

[Java]스택(Stack)

sskl660 — Fri, 25 Sep 2020 21:22:30 +0900

*스택(Stack)

->스택이란 후입선출(LIFO : Last In First Out)의 특성을 가진 자료구조이다.

->쉽게 말해 나중에 들어간 것이 먼저 나온다. 마트의 진열대에 물건을 놓거나, 상자에 물건을 넣은 뒤 꺼내는 것을 예시로 생각해보면 이해하기 쉽다.

스택 자료구조

*Java의 스택

->자바의 Stack관련 API를 살펴보면 스택 입력 연산은 push(), 출력 연산은 pop()메서드를 이용하며, top에 있는 원소(제일 마지막에 넣은 것)를 확인하는 연산은 peek()메서드를 이용한다. 언급한 연산 이외에 스택이 비어있는지 확인하는 empty() 메서드, 스택안에 어떤 아이템이 있는지 확인하는 search()메서드가 있다.

출처 : https://docs.oracle.com/javase/7/docs/api/java/util/Stack.html

->스택은 java.util.Vector<E> 클래스를 상속하기 때문에 여러 다양한 메서드를 호출하거나 재정의하여 편리하게 사용할 수 있다.

->자바의 스택 역시 객체를 생성하고 위의 연산을 적절히 활용하면 된다.

import java.util.Stack;

public class Stack {
	public static void main(String[] args) {
		Stack<Integer> st = new Stack<Integer>();
		
        // 스택에 1, 2, 3, 4를 차례로 넣는다.
		st.push(1);
		st.push(2);
		st.push(3);
		st.push(4);
        // 제일 마지막에 넣은 4를 뺀다.
		st.pop();
        // 제일 위의 원소 확인 : 결과는 3.
		System.out.println(st.peek());
		System.out.println(st.search(3));
        // toString()이 정의되어 있어, 스택을 쉽게 확인할 수 있다.
		System.out.println(st);
		st.clear();
		System.out.println(st);
	}
}

[Java]좌표 이동/탐색

sskl660 — Fri, 25 Sep 2020 21:21:00 +0900

*좌표 이동/탐색

-> DFS/BFS 문제를 접하다 보면, 좌표의 성질을 갖는 대상의 원소에서 다른 원소로 이동하거나, 그 주변을 탐색해야하는 로직이 빈번하게 사용된다.

*2차원 배열 좌표와 행렬

-> 2차원 배열의 인덱스별 값이 생기는 위치를 시각화하여 생각해보면 평면을 떠올릴 수 있고, 평면은 일상 생활에서 보통 좌표를 이용하여 나타낸다.

-> 일반적으로 수학에서 좌표의 1사분면은, 다음과 같은 모양을 가진다.

수학의 좌표 평면 1사분면

즉, x값이 증가할수록 오른 쪽으로 이동하고, y값이 증가할수록 위 쪽으로 이동하는 구조를 가진다. 그렇지만, 일반적으로 2차원 배열을 형성하는 경우 인덱스 별 값이 생기는 위치는 논리적으로 좌표 평면 1사분면의 구조처럼 평면이 만들어지지 않는다.

-> 2차원 배열을 형성하는 경우는 다음과 같이 좌표 평면의 3사분면의 모양과 같이 논리적 평면이 생기지만, 좌표 평면의 3사분면과 다른점은 아래 쪽으로 이동할 수록 y값이 증가한다는 사실이다.

따라서 2차원 배열의 인덱스별 값의 위치를 평면화하여 생각하는 경우는 행렬을 바탕으로 생각하는 것이 더 편리하다.

*방향

-> 어떤 대상을 기준으로 어디로 움직일 것 인가 혹은 어디로 탐색할 것 인가를 고민하기 위해서는 방향을 먼저 설정해주어야 한다. 방향을 표현하는 방법은 대표적으로 아래 두 가지 방법이 있다. 자신에게 맞는 방법을 적절히 활용하도록 하자.

※ 두 개의 일차원 배열을 이용하여 방향을 나타내는 방법

// 상하좌우
int[] dr = { -1, 1, 0, 0 };
int[] dc = { 0, 0, -1, 1 };

-> 2차원 배열의 인덱스 별 값의 위치는 행렬을 기반으로 생각하여야 한다고 했다. 즉, 행렬을 기준으로 어떤 수의 위에 있으면 행이 감소하고 열은 그대로 유지할 것이기 때문에 dr[0] = -1, dc[0] = 0의 값을 갖는다. 마찬가지 방법을 통해 아래, 왼쪽, 오른쪽 방향도 표현할 수 있다.

※ 이차원 배열을 이용하여 방향을 나타내는 방법

// 상하좌우
int[][] drdc = { { -1, 0 }, { 1, 0 }, { 0, -1 }, { 0, 1 } };

-> 위의 로직과 다른 것이 없다. 2차원 배열의 1열이 행의 방향을 의미하고, 2열이 열의 방향을 의미한다고 생각한 뒤 이를 한 번에 저장해준 것 뿐이다.

*이동

-> 이를 테면, false으로 초기화된 boolean 2차원 배열에서 이동명령에 따라 이동하는 위치마다 true로 바꾸는 경우는 다음과 같이 구현할 수 있다.

import java.util.Arrays;
import java.util.Scanner;

public class Move {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 상하좌우
		int[] dr = { -1, 1, 0, 0 };
		int[] dc = { 0, 0, -1, 1 };
		// 방향을 저장할 변수(기본 방향은 상).
		int dir = 0;
		// 맵
		boolean[][] map = new boolean[3][3];

		// 명령 입력, 0행 0열부터 시작.
		System.out.print("이동 명령을 입력하세요(Ex : RRDDRDL) : ");
		String move = sc.nextLine();
		map[0][0] = true;
		int r = 0, c = 0;

		// 이동
		for (int i = 0; i < move.length(); i++) {
			char a = move.charAt(i);
			System.out.println("움직일 방향 출력 : " + a);
			// 각 문자를 해석해 맞는 방향을 세팅 해준다.
			switch (a) {
			case 'U':
				dir = 0;
				break;
			case 'D':
				dir = 1;
				break;
			case 'L':
				dir = 2;
				break;
			case 'R':
				dir = 3;
				break;
			}
			// 이동.
			r += dr[dir];
			c += dc[dir];
			map[r][c] = true;
			// 현재 맵의 상태 출력
			for(int j = 0; j < 3; j++) {
				System.out.println(Arrays.toString(map[j]));
			}
			System.out.println();
		}
		sc.close();
	}
}

출력 결과

-> 보통 알고리즘 문제를 푸는 경우, 주어진 평면의 바깥으로 나가는 경우(인덱스 범위를 초과하는 경우)를 고려해야하는 로직이 많다. 이 경우, 다음 인덱스를 미리 저장하고 테스트해볼 변수를 새로 선언하여 문제를 해결한다.

import java.util.Arrays;
import java.util.Scanner;

public class Move {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		// 상하좌우
		int[] dr = { -1, 1, 0, 0 };
		int[] dc = { 0, 0, -1, 1 };
		// 방향을 저장할 변수(기본 방향은 상).
		int dir = 0;
		// 맵
		boolean[][] map = new boolean[3][3];

		// 명령 입력, 0행 0열부터 시작.
		System.out.print("이동 명령을 입력하세요(Ex : RRDDRDL)(바깥으로 나가면 함수 종료) : ");
		String move = sc.nextLine();
		map[0][0] = true;
		int r = 0, c = 0;
		// 임시로 이동할 좌표를 먼저 설정.
		int nr, nc;

		// 이동
		for (int i = 0; i < move.length(); i++) {
			char a = move.charAt(i);
			System.out.println("움직일 방향 출력 : " + a);
			// 각 문자를 해석해 맞는 방향을 세팅 해준다.
			switch (a) {
			case 'U':
				dir = 0;
				break;
			case 'D':
				dir = 1;
				break;
			case 'L':
				dir = 2;
				break;
			case 'R':
				dir = 3;
				break;
			}
			// 임시로 이동
			nr = r + dr[dir];
			nc = c + dc[dir];
			// 바깥으로 이동하는지 체크하는 if 제어문!!
			if (0 <= nr && nr < 3 && 0 <= nc && nc < 3) {
				r = nr;
				c = nc;
				map[r][c] = true;
			} else {
				System.out.println("바깥으로 이동할 수 없습니다.");
                sc.close();
				return;
			}
			// 현재 맵의 상태 출력
			for (int j = 0; j < 3; j++) {
				System.out.println(Arrays.toString(map[j]));
			}
			System.out.println();
		}
		sc.close();
	}
}

*탐색

-> 탐색도 이동과 크게 다를 것 없다. 어떤 인덱스의 위치를 기준으로, 순차적으로 주변을 탐색하고 싶은 경우에는 우선 방향을 잘 설정해주면 된다.

※ 상하좌우 <4방향>

// 상하좌우
int[] dr = { -1, 1, 0, 0 };
int[] dc = { 0, 0, -1, 1 };

※ 12시, 1시, 3시, 5시, 6시, 7시, 9시, 11시 <8방향>

// 12시, 1시, 3시, 5시, 6시, 7시, 9시, 11시
int[] dr = { -1, -1, 0, 1, 1, 1, 0, -1 };
int[] dc = { 0, 1, 1, 1, 0, -1, -1, -1};

-> 이를 테면, 3x3 int 배열의 특정 인덱스의 8방향에 3이라는 숫자가 몇개 있는지 탐색하는 경우는 다음과 같이 구현할 수 있다.

import java.util.Scanner;

public class Search {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		int[][] map = new int[3][3];
		System.out.println("배열에 넣을 숫자를 입력하세요.");
		// 3,3 int 배열에 입력된 숫자를 대입한다.
		for (int i = 0; i < 3; i++) {
			String line = sc.nextLine();
			for (int j = 0; j < 3; j++) {
				map[i][j] = line.charAt(j) - '0';
			}
		}

		// 탐색할 좌표 입력
		int r = sc.nextInt();
		int c = sc.nextInt();

		// 3의 개수 파악.
		int cnt = 0;
		// 12시, 1시, 3시, 5시, 6시, 7시, 9시, 11시
		int[] dr = { -1, -1, 0, 1, 1, 1, 0, -1 };
		int[] dc = { 0, 1, 1, 1, 0, -1, -1, -1 };
		for (int i = 0; i < 8; i++) {
			if (map[r + dr[i]][c + dc[i]] == 3) {
				cnt++;
			}
		}
		// 결과 출력
		System.out.println(cnt);
		sc.close();
	}
}

시간 복잡도 측정

sskl660 — Sun, 20 Sep 2020 00:47:27 +0900

알고리즘 문제를 푸는 경우, 시간 복잡도를 분석해야하는 경우가 많다.

기본적으로 시간 복잡도를 항상 생각하며 문제를 푸는 것을 우선으로 하고, 만일 직관적으로 자신의 코드가 어느정도 성능을 가지고 있는지 파악하고 싶다면 아래와 같은 코드를 활용해보자.

import time # 시간 라이브러리 함수

start = time.time() # 시간 측정 함수

# 측정하고자 하는 code

end = time.time()
print("time :", end - start) # 수행 시간 출력

딕셔너리(dictionary) 자료형

sskl660 — Sat, 19 Sep 2020 23:10:21 +0900

딕셔너리는 키(Key)와 값(Value)의 쌍을 데이터로 가지는 자료형이다. 이름 그대로 사전을 생각하면 이해하기 쉽다. 예를 들어 평일을 딕셔너리 자료형을 이용하여 영어 사전 처럼 저장하고 싶은 경우, 다음과 같은 코드를 작성할 수 있다.

week = dict()
week['월'] = 'Monday'
week['화'] = 'Tuesday'
week['수'] = 'Wednesday'
week['목'] = 'Thursday'
week['금'] = 'Friday'

다음과 같이 바로 초기화 할수도 있다.

week = {'월' : 'Monday', '화' : 'Tuesday', '수' : 'Wednesday', '목' : 'Thursday', '금' : 'Friday'}

딕셔너리 자료형이 중요한 이유는, 파이썬에서 해당 자료형은 해시 테이블(Hash table)을 이용하기 때문에 데이터의 검색 및 수정에 있어서 O(1)의 시간밖에 소요하지 않기 때문이다(Set 자료형도 O(1)의 시간밖에 소요하지 않는다). 일반적으로 리스트에서 어떤 대상을 검색하는 경우 O(n)시간이 걸리는 것을 생각하면, 특정 문제를 해결 할 때는 사전 자료형이 더욱 효과적일 수 있다.

리스트 컴프리헨션/2차원 배열 초기화

sskl660 — Sat, 19 Sep 2020 22:30:52 +0900

파이썬은 컴프리헨션(Comprehension)을 이용하여 반복 되거나 특정 조건을 만족하는 리스트를 쉽게 만들어낼 수 있다.

이것을 리스트 컴프리헨션(List Comprehension)이라고 한다. 이 외에도 딕셔너리 컴프리헨션, 셋 컴프리헨션이 있으니 참고하도록 하자. 리스트 컴프리헨션은 특히 파이썬에서 다차원 리스트를 초기화 하는 경우 유용하게 사용되므로 익숙해지도록 하자.

예를 들어, 0부터 9까지의 수를 1차원 리스트에 담고 싶은경우 일반적으로 다음과 같은 방법을 생각할 수 있다.

arr = [0] * 10
for i in range(10):
	arr[i] = i

하지만 컴프리헨션을 이용한다면, 다음과 같이 한 줄의 코드 만으로 1차원 리스트를 초기화 할 수 있다.

arr = [i for i in range(10)]

이와 같이 리스트 컴프리헨션은 앞에 반복을 원하는 대상을 두고, 뒤의 for 문을 조작해 줌으로써 원하는 동작을 하도록 만들 수 있다. 다른 예시로 0부터 9까지의 수를 반복하여 출력하고 싶다면, 다음과 같이 작성해볼 수 있다.

[print(i) for i in range(10)]

여기서 더 나아가 반복되는 대상에 조건을 달아주고 싶다면, for문 뒤에 조건문을 붙여주면 된다. 예를 들어 0부터 9까지의 숫자 중 짝수만을 출력하고 싶다면 다음과 같은 코드를 작성할 수 있다.

[print(i) for i in range(10) if i % 2 == 0]

만일 2중 for문을 이용하여 반복하고 싶다면, 뒤에 for문을 더 붙여주기만 하면 된다. 다음과 같은 코드를 작성해보고 결과를 출력해보자.

[i + j for i in range(3) for j in range(3)]

▶2차원 리스트 초기화

파이썬에서 2차원 리스트를 초기화 해주고 싶은 경우, 반드시 리스트 컴프리헨션을 이용해 주어야 한다.

예를 들어 다음과 같이 2차원 리스트를 초기화 한다면, 내부에 있는 리스트가 모두 같은 대상을 참조하기 때문에 리스트 내부의 값을 변경하는 경우 문제가 발생한다. 아래와 같이 코드를 작성해보고, 결과를 출력해보자.

arr = [[0] * 5] * 5
arr[0][0] = 5

이 문제에 대해 더 자세히 알고 싶다면, 얕은 복사와 깊은 복사의 개념에 대해서 공부하도록 하자.

이러한 문제가 있기 때문에, 파이썬에서 2차원 리스트를 초기화 하는 경우 리스트 컴프리헨션을 이용한다. 일반적으로 코딩 문제를 풀 때 행렬을 표현하기 위하여 2차원 리스트를 활용하는 경우가 많은데, 여기서는 예를 들어 3x4행렬을 만든다고 가정하면 다음과 같은 코드를 작성할 수 있다.

arr = [[0 for col in range(4)] for row in range(3)]

마찬가지로 arr[0][0]에 아무 값이나 대입해보면, 원하는 인덱스의 값만 바뀌는 것을 확인할 수 있다.

이처럼 컴프리헨션은 파이썬이 다른 언어에 비하여 코드를 간결하게 만들 수 있는 강력한 무기 중 하나이므로, 반드시 익숙해지도록 하자.

e 혹은 E를 이용한 지수 표현

sskl660 — Sat, 19 Sep 2020 21:36:51 +0900

코딩 테스트를 준비하다보면, 매우 크거나 작은 수를 표현해야 하는 경우가 있다.

이런 경우 e나 E를 이용한 지수 표현 방식을 이용하면 이를 쉽게 표현할 수 있고, 수를 표기할 때 실수를 줄일 수 있다.

이렇게 표현된 수는 실수형으로 인식된다.

유효숫자e지수(or 유효숫자E지수) == 유효숫자 * 10^지수

Ex1) 2020.0919 == 20200919e-4

Ex2) 10000000000.0 == 1e10