백준 7662: 이중 우선순위 큐 [Gold 4] / Java
백준 7662: 이중 우선순위 큐 [Gold 4] / Java https://www.acmicpc.net/problem/7662      문제 설명 이중 우선순위 큐(dual priority queue)는 전형적인 우선순위 큐처럼 데이터를 삽입, 삭제할 수 있는 자료 구조이다. 전형적인 큐와의 차이점은 데이터를 삭제할 때 연산(operation) 명령에 따라 우선순위가 가장 높은 데이터 또는 가장 낮은 데이터 중 하나를 삭제하는 점이다. 이중 우선순위 큐를 위해선 두 가지 연산이 사용되는데, 하나는 데이터를 삽입하는 연산이고 다른 하나는 데이터를 삭제하는 연산이다. 데이터를 삭제하는 연산은 또 두 가지로 구분되는데 하나는 우선순위가 가장 높은 것을 삭제하기 위한 것이고 다른 하나는 우선순위가 가장 낮은 ..
2025.03.08
no image
백준 1676: 팩토리얼 0의 개수 [Silver 5] / Java
백준 1676: 팩토리얼 0의 개수https://www.acmicpc.net/problem/1676      문제 설명 N!에서 뒤에서부터 처음 0이 아닌 숫자가 나올 때까지 0의 개수를 구하는 프로그램을 작성하시오.     입력 첫째 줄에 N이 주어진다. (0 ≤ N ≤ 500)   출력첫째 줄에 구한 0의 개수를 출력한다.   제출 코드실행속도 : 64ms메모리 : 11512KB     숫자 끝에 0이 붙으려면 어떤 수에 10을 곱해야 한다는 것이 포인트  그렇다면, 팩토리얼 에서 10이 곱해지는 경우는 2*5뿐이다 (10도 2*5 쌍이라고 볼 수 있다) 따라서 N!에서 끝 0의 개수는?  1부터 N까지 모든 수를 소인수분해했을 때  2,5 짝의 개수를 구하면 됨. 여기서 2의 개수는 2, 4, 8 ..
2025.01.12
no image
백준 11729: 하노이 탑 이동 순서 [Gold 5] / Java
백준 11729: 하노이 탑 이동 순서https://www.acmicpc.net/problem/11729      문제 설명 세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다. 이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로 옮기려 한다. 한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다. 이 작업을 수행하는데 필요한 이동 순서를 출력하는 프로그램을 작성하라. 단, 이동 횟수는 최소가 되어야 한다.   아래 그림은 원판이 5개인 경우의 예시이다.         입력 첫째 줄에 첫 번째 장대에 쌓인 원판의 개수 N (1 ≤ N ≤ 20)이 주어진다. ..
2025.01.11
no image
백준 1158: 요세푸스 문제 [Silver 4] / Java
백준 1158: 요세푸스 문제 https://www.acmicpc.net/problem/1158      문제 설명 요세푸스 문제는 다음과 같다.   1번부터 N번까지 N명의 사람이 원을 이루면서 앉아있고, 양의 정수 K(≤ N)가 주어진다. 이제 순서대로 K번째 사람을 제거한다. 한 사람이 제거되면 남은 사람들로 이루어진 원을 따라 이 과정을 계속해 나간다. 이 과정은 N명의 사람이 모두 제거될 때까지 계속된다. 원에서 사람들이 제거되는 순서를 (N, K)-요세푸스 순열이라고 한다. 예를 들어 (7, 3)-요세푸스 순열은 이다.   N과 K가 주어지면 (N, K)-요세푸스 순열을 구하는 프로그램을 작성하시오.      입력 첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ ..
2024.12.22
no image
StringBuilder 초기화하는 방법, 속도 비교(feat. 백준 15666 N과M(12))
StringBuilder 초기화하는 방법 new로 인스턴스 새로 생성StringBuilder sb = new StringBuilder();for (int i=0; i 10억회 반복 시 속도 -> 64ms   2. delete() 메서드 사용StringBuilder sb = new StringBuilder();for (int i=0; i 10억회 반복 시 속도 -> 4ms   3. setLengt() 메서드 사용StringBuilder sb = new StringBuilder();for (int i=0; i 10억회 반복 시 속도 -> 4ms     매번 new를 이용해 객체를 새로 생성해 초기화하는 방법은 실행속도 측면에서 가장 최악이었다. 나머지 방법과 비교해 무려 16배 가량 느린 속도를 보여줬다. ..
2024.12.19
no image
백준 1806: 부분합 [Gold 4] / Java
백준 1806: 부분합 https://www.acmicpc.net/problem/1806      문제 설명 10,000 이하의 자연수로 이루어진 길이 N짜리 수열이 주어진다. 이 수열에서 연속된 수들의 부분합 중에 그 합이 S 이상이  되는 것 중, 가장 짧은 것의 길이를 구하는 프로그램을 작성하시오.      입력  첫째 줄에 N (10 ≤ N  공백으로 구분되어져 있으며, 10,000이하의 자연수이다.      출력  첫째 줄에 구하고자 하는 최소의 길이를 출력한다.  만일 그러한 합을 만드는 것이 불가능하다면 0을 출력하면 된다.      제출 코드1. 시간 초과수열을 입력받으면서, 누적합을 저장하는 배열을 추가로 만들어 누적합을 저장했다. 모든 배열의 합을 일일이 구하지 않아도 누적합에서 빼기 ..
2024.12.18
백준 2108: 통계학 [Silver 3] / Java
백준 2108: 통계학 https://www.acmicpc.net/problem/2108    문제 설명  수를 처리하는 것은 통계학에서 상당히 중요한 일이다. 통계학에서 N개의 수를 대표하는 기본 통계값에는 다음과 같은 것들이 있다. 단, N은 홀수라고 가정하자.  산술평균 : N개의 수들의 합을 N으로 나눈 값중앙값 : N개의 수들을 증가하는 순서로 나열했을 경우 그 중앙에 위치하는 값최빈값 : N개의 수들 중 가장 많이 나타나는 값범위 : N개의 수들 중 최댓값과 최솟값의 차이  N개의 수가 주어졌을 때, 네 가지 기본 통계값을 구하는 프로그램을 작성하시오.      입력  첫째 줄에 수의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 단, N은 홀수이다. 그 다음 N개의 줄에는 정수들이 주어..
2024.11.17
백준 14501: 퇴사 [Silver 3] / Java
백준 14501: 서로 다른 부분 문자열의 개수https://www.acmicpc.net/problem/11478    문제 설명상담원으로 일하고 있는 백준이는 퇴사를 하려고 한다. 오늘부터 N+1일째 되는 날 퇴사를 하기 위해서, 남은 N일 동안 최대한 많은 상담을 하려고 한다. 백준이는 비서에게 최대한 많은 상담을 잡으라고 부탁을 했고, 비서는 하루에 하나씩 서로 다른 사람의 상담을 잡아놓았다. 각각의 상담은 상담을 완료하는데 걸리는 기간 Ti와 상담을 했을 때 받을 수 있는 금액 Pi로 이루어져 있다. N = 7인 경우에 다음과 같은 상담 일정표를 보자.  1 일차2 일차3 일차4 일차5 일차6 일차7 일차Ti3511242Pi102010201540200  1일에 잡혀있는 상담은 총 3일이 걸리며, ..
2024.11.15
백준 11478: 서로 다른 부분 문자열의 개수[Silver 3] / Java
백준 11478: 서로 다른 부분 문자열의 개수https://www.acmicpc.net/problem/11478    문제 설명문자열 S가 주어졌을 때, S의 서로 다른 부분 문자열의 개수를 구하는 프로그램을 작성하시오.부분 문자열은 S에서 연속된 일부분을 말하며, 길이가 1보다 크거나 같아야 한다.예를 들어, ababc의 부분 문자열은 a, b, a, b, c, ab, ba, ab, bc, aba, bab, abc, abab, babc, ababc가 있고, 서로 다른것의 개수는 12개이다.    입력첫째 줄에 문자열 S가 주어진다. S는 알파벳 소문자로만 이루어져 있고, 길이는 1,000 이하이다.    출력첫째 줄에 S의 서로 다른 부분 문자열의 개수를 출력한다.    내 답연속되는 모든 부분 문자..
2024.11.02
백준 2252: 줄 세우기[Gold 3] / Java
백준 2252: 줄 세우기https://www.acmicpc.net/problem/2252    문제 설명N명의 학생들을 키 순서대로 줄을 세우려고 한다. 각 학생의 키를 직접 재서 정렬하면 간단하겠지만, 마땅한 방법이 없어서 두 학생의 키를 비교하는 방법을 사용하기로 하였다. 그나마도 모든 학생들을 다 비교해 본 것이 아니고, 일부 학생들의 키만을 비교해 보았다.일부 학생들의 키를 비교한 결과가 주어졌을 때, 줄을 세우는 프로그램을 작성하시오.  입력첫째 줄에 N(1 ≤ N ≤ 32,000), M(1 ≤ M ≤ 100,000)이 주어진다. M은 키를 비교한 횟수이다. 다음 M개의 줄에는 키를 비교한 두 학생의 번호 A, B가 주어진다. 이는 학생 A가 학생 B의 앞에 서야 한다는 의미이다.학생들의 번호..
2024.10.30
백준 7662: 이중 우선순위 큐 [Gold 4] / Java

 

 

 
 

 

문제 설명

 

이중 우선순위 큐(dual priority queue)는 전형적인 우선순위 큐처럼 데이터를 삽입, 삭제할 수 있는 자료 구조이다.

 

전형적인 큐와의 차이점은 데이터를 삭제할 때 연산(operation) 명령에 따라 우선순위가 가장 높은 데이터 또는 가장 낮은 데이터 중 하나를 삭제하는 점이다. 이중 우선순위 큐를 위해선 두 가지 연산이 사용되는데, 하나는 데이터를 삽입하는 연산이고 다른 하나는 데이터를 삭제하는 연산이다. 데이터를 삭제하는 연산은 또 두 가지로 구분되는데 하나는 우선순위가 가장 높은 것을 삭제하기 위한 것이고 다른 하나는 우선순위가 가장 낮은 것을 삭제하기 위한 것이다. 정수만 저장하는 이중 우선순위 큐 Q가 있다고 가정하자. Q에 저장된 각 정수의 값 자체를 우선순위라고 간주하자.

 

Q에 적용될 일련의 연산이 주어질 때 이를 처리한 후 최종적으로 Q에 저장된 데이터 중 최댓값과 최솟값을 출력하는 프로그램을 작성하라.

 

 

 

 

 

입력

 

입력 데이터는 표준입력을 사용한다.

입력은 T개의 테스트 데이터로 구성된다. 입력의 첫 번째 줄에는 입력 데이터의 수를 나타내는 정수 T가 주어진다. 각 테스트 데이터의 첫째 줄에는 Q에 적용할 연산의 개수를 나타내는 정수 k (k ≤ 1,000,000)가 주어진다. 이어지는 k 줄 각각엔 연산을 나타내는 문자(‘D’ 또는 ‘I’)와 정수 n이 주어진다. ‘I n’은 정수 n을 Q에 삽입하는 연산을 의미한다. 동일한 정수가 삽입될 수 있음을 참고하기 바란다. ‘D 1’는 Q에서 최댓값을 삭제하는 연산을 의미하며, ‘D -1’는 Q 에서 최솟값을 삭제하는 연산을 의미한다. 최댓값(최솟값)을 삭제하는 연산에서 최댓값(최솟값)이 둘 이상인 경우, 하나만 삭제됨을 유념하기 바란다.

만약 Q가 비어있는데 적용할 연산이 ‘D’라면 이 연산은 무시해도 좋다. Q에 저장될 모든 정수는 -231 이상 231 미만인 정수이다.

 

 

 

출력

출력은 표준출력을 사용한다. 각 테스트 데이터에 대해, 모든 연산을 처리한 후 Q에 남아 있는 값 중 최댓값과 최솟값을 출력하라. 두 값은 한 줄에 출력하되 하나의 공백으로 구분하라. 만약 Q가 비어있다면 ‘EMPTY’를 출력하라.

 

 

 

제출 코드

 

 

 

20%에서 오답

 

 

우선순위큐를 2개 만들어 1개는 오름차순(pq), 1개는 내림차순(rpq)으로 관리하려 했다.

 

그래서 값 추가 시에는 각각 추가, 제거 시에는 최소값 제거는 pq에서, 최대값 제거는 rpq에서 제거하는 전략을

 

세웠는데, 2개의 큐가 동기화되지 않아 삽입과 제거가 무작위로 이루어지면서 무결성이 깨졌다.

 

 

public class Main {
	public static void main(String[] args) throws Exception, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		PriorityQueue<Integer> pq = new PriorityQueue<>();
		PriorityQueue<Integer> rpq = new PriorityQueue<>(Comparator.reverseOrder());
		
		int T = Integer.parseInt(br.readLine()); // 케이스 수 입력
		// 테스트케이스 순회
		for (int t=1; t<=T; t++) {
			// 연산의 수
			int n = Integer.parseInt(br.readLine());
			
			// 초기화
			pq.clear();
			rpq.clear();
			int size = 0;
			
			// 연산 입력
			for (int i=0; i<n; i++) {
				StringTokenizer st = new StringTokenizer(br.readLine());
				String com = st.nextToken();
				int num = Integer.parseInt(st.nextToken());
				
				
				if (com.equals("I")) {
					pq.add(Integer.valueOf(num));
					rpq.add(Integer.valueOf(num));
					size += 1;
				} else {
					if (size <= 0) continue;
					if (num == -1) {
						pq.poll();
						size -= 1;
					} else {
						rpq.poll();
						size -= 1;
					}
				}
				
			}
			if (size <= 0) System.out.println("EMPTY");
			else if (size <= 1) System.out.println(pq.poll());
			else {
				System.out.print(rpq.poll()+" ");
				System.out.println(pq.poll());
			}
			
			
		}
	}
}​



 

 

 

 

개선 코드

 

 

public class Main {
	public static void main(String[] args) throws Exception, IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		TreeMap<Integer, Integer> tm = new TreeMap<>();
		
		int T = Integer.parseInt(br.readLine()); // 케이스 수 입력
		// 테스트케이스 순회
		for (int t=1; t<=T; t++) {
			// 연산의 수
			int n = Integer.parseInt(br.readLine());
			
			// 초기화
			tm.clear();
			
			// 연산 입력
			for (int i=0; i<n; i++) {
				StringTokenizer st = new StringTokenizer(br.readLine());
				String com = st.nextToken();
				int num = Integer.parseInt(st.nextToken());
				
				if (com.equals("I")) {
					tm.put(num, tm.getOrDefault(num, 0)+1); // 해당 값에 대해 개수 +1 증가
				} else {
					if (tm.isEmpty()) continue;
					// 최소값 제거
					if (num == -1) {
						if (tm.get(tm.firstKey()) <= 1) {
							tm.remove(tm.firstKey());
						} else {
							tm.put(tm.firstKey(), tm.get(tm.firstKey())-1);
						}
					}
					// 최대값 제거
					else {
						if (tm.get(tm.lastKey()) <= 1) {
							tm.remove(tm.lastKey());
						} else {
							tm.put(tm.lastKey(), tm.get(tm.lastKey())-1);
						}
					}
				}
				
			}
			if (tm.isEmpty()) System.out.println("EMPTY");
			else {
				System.out.print(tm.lastKey()+" ");
				System.out.println(tm.firstKey());
			}
		}
	}
}

 

 

TreeMap 자료구조는 자동으로 key값을 기준으로 정렬해준다.

 

이를 활용해 firstkey, lastkey 메서드를 이용하여 최소값과 최대값을 각각 관리해줄 수 있다!

 

 

 

 

깨달은 점

 

TreeMap이라는 자료구조가 생소해 푸는 방법을 생각하기 힘들었다.

 

자료구조에 대한 이해의 필요성을 깊이 느끼고,

 

TreeMap에 대해 정리해야겠다!

백준 1676: 팩토리얼 0의 개수

 

 
 

 

문제 설명

 

N!에서 뒤에서부터 처음 0이 아닌 숫자가 나올 때까지 0의 개수를 구하는 프로그램을 작성하시오.

 

 

 

 

 

입력

 

첫째 줄에 N이 주어진다. (0 ≤ N ≤ 500)

 

 

 

출력

첫째 줄에 구한 0의 개수를 출력한다.

 

 

 

제출 코드

실행속도 : 64ms

메모리 : 11512KB

 

 

 

 

 숫자 끝에 0이 붙으려면 어떤 수에 10을 곱해야 한다는 것이 포인트

 

 그렇다면, 팩토리얼 에서 10이 곱해지는 경우는 2*5뿐이다 (10도 2*5 쌍이라고 볼 수 있다)


 따라서 N!에서 끝 0의 개수는? 

 

1부터 N까지 모든 수를 소인수분해했을 때  2,5 짝의 개수를 구하면 됨.

여기서 2의 개수는 2, 4, 8 ... 로 5의 개수보다 확실히 많으므로,


 => 결국 5의 개수를 세면 된다!

 

 

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		
		int zeroCount = 0;
		
		for (int i=5; i<=N; i+=5) {
			// 5로 나눠지는 횟수만큼 0 개수 추가
			zeroCount += countFive(i);
		}
		
		System.out.println(zeroCount);
	}

	private static int countFive(int i) {
		int count = 0;
		while (i % 5 == 0) {
			i /= 5;
			count += 1;
		}
		return count;
	}
}

 

5의 개수만 세면 되므로, 5부터 N까지 i를 5씩 증가시키며 5의 배수일 때만

 

countFive 메서드를 만들어 5의 수를 세었다.

 

 

 

 

개선 코드

 

 

 

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        int zeroCount = 0;

        // 5의 배수마다 5의 개수를 더함
        for (int i = 5; i <= n; i *= 5) {
            zeroCount += n / i;
        }

        System.out.println(zeroCount);
    }
}

 

  • i를 5씩 증가시키는 대신, 5의 제곱 배수를 한 번에 처리했다.

    이를 통해 5, 25, 125 등에서 각각 추가로 생기는 5의 개수를 누적할 수 있다.

  • 기존 코드는 i를 5씩 증가시켜 시간복잡도가 O(N/5* log₅N) 인 반면,

    이 방식은 i를 5씩 곱해주며 시간 복잡도를 O(log₅N)으로 최적화할 수 있었다!

 

 

 

깨달은 점

 

기존 코드도 충분히 효율적인 코드라고 느껴져 더 개선할 점이 있을까 생각했는데,

 

5의 개수를 구하는 과정에서 5의 지수마다 변곡점이 생기므로, 5씩 곱해주며 계산할 수 있는 방법이 있다는 것에 놀랐다.

 

언제나 더 효율적인 코드는 존재한 다는 것을 다시 한번 느낀다.

백준 11729: 하노이 탑 이동 순서

 

 
 

 

문제 설명

 

세 개의 장대가 있고 첫 번째 장대에는 반경이 서로 다른 n개의 원판이 쌓여 있다. 각 원판은 반경이 큰 순서대로 쌓여있다.

 

이제 수도승들이 다음 규칙에 따라 첫 번째 장대에서 세 번째 장대로 옮기려 한다.

 

  1. 한 번에 한 개의 원판만을 다른 탑으로 옮길 수 있다.
  2. 쌓아 놓은 원판은 항상 위의 것이 아래의 것보다 작아야 한다.

 

이 작업을 수행하는데 필요한 이동 순서를 출력하는 프로그램을 작성하라. 단, 이동 횟수는 최소가 되어야 한다.

 

 

 

아래 그림은 원판이 5개인 경우의 예시이다.

 

 

 

 

 

 

 

 

 

입력

 

첫째 줄에 첫 번째 장대에 쌓인 원판의 개수 N (1 ≤ N ≤ 20)이 주어진다.

 

 

 

 

 

 

 

출력

 

첫째 줄에 옮긴 횟수 K를 출력한다.

 

두 번째 줄부터 수행 과정을 출력한다. 두 번째 줄부터 K개의 줄에 걸쳐 두 정수 A B를 빈칸을 사이에 두고 출력하는데,

 

이는 A번째 탑의 가장 위에 있는 원판을 B번째 탑의 가장 위로 옮긴다는 뜻이다.

 

 

 

 

 

제출 코드(실패)

 

Stack OverFlow가 발생했다.

 

특정 규칙을 찾아보려 했으나 찾지 못해 완전 탐색 방식을 사용했다.

 

한번의 재귀함수 호출에서 5가지 경우의 수로 뻗어 나가다 보니

 

5의 지수만큼 스택에 쌓여 순식간에 오버플로우가 발생했다.

 

문제 해결 방법을 다시 생각해야 했다.

 

public class Main {
	static int N, min;
	static Stack<Integer>[] towers;
	static String result;

	public static void main(String[] args) throws IOException {
		Scanner sc = new Scanner(System.in);
        
		N = sc.nextInt();
		min = Integer.MAX_VALUE;
		result = "";
		// 장대 3개, 최대 높이 N개의 탑
		towers = new Stack[3];
		for (int i=0; i<3; i++) {
			towers[i] = new Stack<>();
		}
		for (int i = N; i >= 1; i--) {
			towers[0].push(i);
		}
		
		dfs(0, 0, 0, new StringBuilder());

		System.out.println(min);
		System.out.println(result);
	}

	private static void dfs(int count, int prevPop, int prevPush, StringBuilder route) {
		System.out.println(prevPop+"에서 "+prevPush+"로 이동 " + towers[0]+" | "+towers[1]+" | "+towers[2]);
		if (towers[2].size() >= N) {
			if (min > count) {
				min = count;
				result = route.toString();
			}
			return;
		}
		
		int length = route.length();
		// i번 타워에서 j번 타워로 옮기기
		for (int i = 0; i < 3; i++) {
			for (int j = 0; j < 3; j++) {
				if (i==j) continue;
				// 이전 이동과 반대되는 이동(왔다갔다)은 PASS
				if (prevPush == i && prevPop == j) continue;
				if (towers[i].size() <= 0) continue;
				if (towers[j].size() == 0 || towers[j].peek() > towers[i].peek()) {
					moveDisk(i, j); // 옮기기
					route.append(i).append(' ').append(j).append('\n');
					dfs(count + 1, i, j, route); // 재귀함수 호출
					moveDisk(j, i); // 원상복구
					route.delete(length, route.length()-1);
				}
			}
		}
	}

	private static void moveDisk(int popTower, int pushTower) {
		int popDisk = towers[popTower].pop();
		towers[pushTower].push(popDisk);
	}
}

 

 

 

 

 

개선 코드

public class Main {
	static int N, moveCount;
	static Stack<Integer>[] towers;
	static StringBuilder result;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		N = Integer.parseInt(br.readLine());
		moveCount = 0;
		result = new StringBuilder();

		moveDisks(N, 1, 3, 2);

		System.out.println(moveCount);
		System.out.println(result);
	}

	private static void moveDisks(int diskCount, int start, int end, int sub) {
		if (diskCount == 1) {
			moveCount += 1;
			result.append(start).append(' ').append(end).append('\n');
			return;
		}
		// 보조기둥으로 diskCount-1개만큼 옮기기
		moveDisks(diskCount - 1, start, sub, end);
		// 남은 1개 원판을 목표기둥으로 옮기기
		moveCount += 1;
		result.append(start).append(' ').append(end).append('\n');
		// 보조기둥의 원판들을 목표기둥으로 옮기기
		moveDisks(diskCount - 1, sub, end, start);
	}
}

 

문제를 작은 문제로 쪼개야 했다.

 

문제 해결을 위한 로직은 아래와 같다.

 

 

1. N-1개의 원판을 보조기둥으로 옮긴다.

 

2. 남은 1개의 원판을 목표 기둥으로 옮긴다.

 

3. 보조기둥에 있는 N-1개의 원판을 목표 기둥으로 옮긴다.

 

 

로직을 재귀함수 호출 방식으로 N이 1이 될 때까지 잘게 쪼개 문제를 해결한다.

 

 

 

깨달은 점

 

나름 충격적인 풀이법이었다.

 

이 문제의 해결 방식을 보고

 

문제를 작은 단위로 쪼개 문제를 해결하는 분할 정복의 느낌을 많이 받았는데,

 

문제를 가능한 간단한 해결 방법을 생각하는 것, 작은 단위로 쪼개 생각하는 능력을 기르는 훈련이 필요함을 느꼈다.

 

백준 1158: 요세푸스 문제

 

 

 
 

 

문제 설명

 

요세푸스 문제는 다음과 같다.

 

 

 

1번부터 N번까지 N명의 사람이 원을 이루면서 앉아있고, 양의 정수 K(≤ N)가 주어진다.

 

이제 순서대로 K번째 사람을 제거한다. 한 사람이 제거되면 남은 사람들로 이루어진 원을 따라 이 과정을 계속해 나간다.

 

이 과정은 N명의 사람이 모두 제거될 때까지 계속된다.

 

원에서 사람들이 제거되는 순서를 (N, K)-요세푸스 순열이라고 한다.

 

예를 들어 (7, 3)-요세푸스 순열은 <3, 6, 2, 7, 5, 1, 4>이다.

 

 

 

N과 K가 주어지면 (N, K)-요세푸스 순열을 구하는 프로그램을 작성하시오.

 

 

 

 

 

 

입력

 

첫째 줄에 N과 K가 빈 칸을 사이에 두고 순서대로 주어진다. (1 ≤ K ≤ N ≤ 5,000)

 

 

 

 

 

 

 

출력

 

예제와 같이 요세푸스 순열을 출력한다.

 

 

 

 

 

제출 코드

 
  • 실행속도: 372ms
  • 메모리: 12096KB

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
	static int N, K, size;
	static boolean[] survived;
	static int[] ans;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		// 입력값 입력
		N = Integer.parseInt(st.nextToken()); // 사람 수
		K = Integer.parseInt(st.nextToken()); // 제거 규칙

		survived = new boolean[N + 1]; // 생존 여부를 기록
		Arrays.fill(survived, true);  // 시작은 모두 생존으로 처리
		
		ans = new int[N]; // 제거된 사람 기록
		size = 0; // ans배열의 크기 기록

		eliminate();

		print();
	}

	private static void print() {
		StringBuilder sb = new StringBuilder();
		sb.append('<');
		for (int i = 0; i < N; i++) {
			if (i < N - 1)
				sb.append(ans[i]).append(',').append(' ');
			else
				sb.append(ans[i]).append('>');
		}

		System.out.println(sb);
	}

	private static void eliminate() {
		// 첫번째 제거 대상 제거 후 반복작업 수행
		int pointer = K;
		survived[K] = false;
		ans[size++] = K;

		// 모두 제거될 때까지 작업 반복
		while (size < N) {
			int cnt = K;	// 포인터 이동횟수 카운터
			
			while (cnt > 0) {
				pointer += 1;	
				if (pointer>N) pointer %= N;	// 모듈러 연산
				if (survived[pointer]) cnt -= 1;	// 포인터가 생존했을 경우에만 카운트 줄임
			}
			
			survived[pointer] = false;
			ans[size++] = pointer;
		}
		
		
	}

}

 

 

 

1. survived 배열을 이용해 원에서 제거되었는지 여부를 확인

 

 

2. ans 배열에 제거된 사람의 번호를 순서대로 저장

 

 

3. 이중 while문을 이용해 pointer를 1개씩 움직여가며 조정했다.

    1개씩 움직인 이유는 이미 제거된 사람의 번호는 옮긴 횟수에 들어가지 않아야 하기 때문.

 

 

 

 

 

개선 코드

  • 실행속도: 76ms   ← 5배 속도 향상
  • 메모리: 12096KB
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
	static int N, K, size;
	static boolean[] survived;
	static int[] ans;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		// 입력값 입력
		N = Integer.parseInt(st.nextToken()); // 사람 수
		K = Integer.parseInt(st.nextToken()); // 제거 규칙

		ans = new int[N]; // 제거된 사람 기록
		size = 0; // ans배열의 크기 기록

		eliminate();

		print();
	}

	private static void print() {
		StringBuilder sb = new StringBuilder();
		sb.append('<');
		for (int i = 0; i < N; i++) {
			if (i < N - 1)
				sb.append(ans[i]).append(',').append(' ');
			else
				sb.append(ans[i]).append('>');
		}

		System.out.println(sb);
	}

	private static void eliminate() {
		int pointer = 0;
		List<Integer> list = new ArrayList<>();
		for (int i = 1; i <= N; i++) {
			list.add(i);
		}
		while (size<N) {
			pointer = (pointer + K - 1) % list.size();
			ans[size++] = list.remove(pointer);
		}
	}
}

 

 

주요 개선 사항

 

1. survived 배열 사용하지 않음.

 

2. 배열 대신 리스트를 생성하여 사람 제거 시 자동으로 인덱스가 당겨지도록 함.

 

3. pointer를 K만큼 더해 한번에 움직임

    이것이 가능한 이유는 리스트 자료구조를 사용해 알아서 제거된 사람을 걸러주는 역할을 했기 때문!

 

 

 

깨달은 점

 

리스트를 사용해도 메모리 사용량에 큰 차이가 없었으며, 실행속도도 5배 가량 빨라졌다.

 


무조건 배열이 실행속도가 빠른 것은 아님을 알게 되었다.

 

 

오히려 리스트 자료구조를 사용하여 K만큼 한번에 건너뛸 수 있어 연산량을 많이 줄일 수 있었다.

 

 

중간 요소를 제거하거나 새로 삽입할 경우에는 뒤의 요소들을 한번에 당겨주는 리스트 자료구조가 유리함!

 

 

 

 

 

 

 
 

 

StringBuilder 초기화하는 방법

 

  1. new로 인스턴스 새로 생성

StringBuilder sb = new StringBuilder();

for (int i=0; i<1000000000; i++) {
	sb = new StringBuilder();
}

 

10억회 반복 시 속도 -> 64ms

 

 

 

2. delete() 메서드 사용

StringBuilder sb = new StringBuilder();

for (int i=0; i<1000000000; i++) {
	sb.delete(0, sb.length());
}

 

10억회 반복 시 속도 -> 4ms

 

 

 

3. setLengt() 메서드 사용

StringBuilder sb = new StringBuilder();

for (int i=0; i<1000000000; i++) {
	sb = new StringBuilder();
}

 

10억회 반복 시 속도 -> 4ms

 

 

 

 

 

매번 new를 이용해 객체를 새로 생성해 초기화하는 방법은 실행속도 측면에서 가장 최악이었다.

 

나머지 방법과 비교해 무려 16배 가량 느린 속도를 보여줬다.

 

그리고 setLength, delete 메서드를 사용해 초기화 하는 방법은 4ms로 비슷한 모습을 보였다.

 

앞으로 StringBuilder를 초기화해야 할 경우엔 객체 생성은 최대한 피해야 하겠다.

 

 

나의 경우에는 delete보단 setLength 메서드가 더 사용하기 간편하기에 setLength를 사용할 것 같다.

 

 

 

실제 알고리즘 문제에 적용 시 속도는 ? 

 

 

 

그렇다면 실제 문제에 적용하면 어떨까?

 

 

 

백준 문제 내용은 아래 링크 참조.

 

백준 10666: N과M(12)

 

 

 

 

내 제출 코드

 

조합(Combination) 알고리즘을 사용해 수열에서 필요한 개수만큼 숫자를 뽑은 후,

 

중복되는 수열을 제거하는 과정에 StringBuilder를 사용했다.

 

(물론 효율적인 방법이 아니기에 개선 필요.)

 

 

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

/*
 * 비내림차순이어야 하므로, 배열 입력받은 후 정렬하고 조합 작업 시작해야 함.
 * 배열을 오름차순으로 정렬하고, 0번 인덱스부터 선택할지 안할지 탐색.
 * 최종 수열 완성 시 이미 존재하는지 여부 확인.
 * 
 * 시간복잡도 개선을 위해 배열로 관리.
 */

public class Main {
	static int N, M;
	static int[] arr;
	static int[] tmp;
	static String[] pick;
	static int size;
	static StringBuilder sb;
	static StringBuilder ans;

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		sb = new StringBuilder();
		ans = new StringBuilder();

		N = Integer.parseInt(st.nextToken());
		M = Integer.parseInt(st.nextToken());

		arr = new int[N]; // 원본 배열
		tmp = new int[M]; // 숫자 조합 배열
		pick = new String[6435]; // 최종 출력할 조합 (최대크기인 8C4 = 70)

		size = 0; // 최종 출력할 조합 배열의 크기

		// 배열 입력
		st = new StringTokenizer(br.readLine());
		for (int i = 0; i < N; i++) {
			arr[i] = Integer.parseInt(st.nextToken());
		}

		Arrays.sort(arr); // 배열 오름차순 정렬

		combination(0, 0); // 조합 시작

		System.out.println(ans);
	}

	private static void combination(int aidx, int tidx) {
	    // 기저조건: tidx가 M에 도달했을 때
	    if (tidx == M) {
	        for (int n : tmp) {
	            sb.append(n).append(' '); // 공백을 추가해서 숫자를 구분
	        }

	        // 중복 여부 확인
	        for (int i = 0; i < size; i++) {
	            if (pick[i].equals(sb.toString())) {
	                sb.setLength(0);
	                return;
	            }
	        }

	        // 중복 없다면 arr배열에 추가 후 정답 출력
	        pick[size++] = sb.toString();

	        ans.append(sb).append('\n');

	        sb.setLength(0);
	        return;
	    }

	    // 불완전 선택 (무시): aidx가 N 이상이면 더 이상 선택할 수 없음
	    if (aidx >= N) {
	        return;
	    }

	    // 재귀 호출부
	    for (int i = aidx; i < N; i++) {
	        tmp[tidx] = arr[i]; // tidx는 M을 넘지 않음
	        combination(i, tidx + 1); // i를 그대로 넘기므로 중복 조합 허용
	    }
	}

}

 

 

 

여기에서 StringBuilder를 초기화하는 부분만 3가지 방법 각각으로 수정해 비교해보겠다.

???????????????????

 

 

setLength가 가장 짧지만 유의미한 차이는 아니였다...

 

 

그러니 참고만 하자.

백준 1806: 부분합

 

 

 
 

 

문제 설명

 

10,000 이하의 자연수로 이루어진 길이 N짜리 수열이 주어진다. 이 수열에서 연속된 수들의 부분합 중에 그 합이 S 이상이

 

되는 것 중, 가장 짧은 것의 길이를 구하는 프로그램을 작성하시오.

 

 

 

 

 

 

입력

 

 

첫째 줄에 N (10 ≤ N < 100,000)과 S (0 < S ≤ 100,000,000)가 주어진다. 둘째 줄에는 수열이 주어진다. 수열의 각 원소는

 

공백으로 구분되어져 있으며, 10,000이하의 자연수이다.

 

 

 

 

 

 

출력

 

 

첫째 줄에 구하고자 하는 최소의 길이를 출력한다.

 

만일 그러한 합을 만드는 것이 불가능하다면 0을 출력하면 된다.

 

 

 

 

 

 

제출 코드

1. 시간 초과

수열을 입력받으면서, 누적합을 저장하는 배열을 추가로 만들어 누적합을 저장했다.

 

모든 배열의 합을 일일이 구하지 않아도 누적합에서 빼기 한번으로 부분합을 구할 수 있도록 하기 위함이었다.

 

(예)

 

하지만, 이 또한 N개의 인덱스 중 2개를 뽑아 조합하는 경우의 수만큼 작업이 수행되므로,

 

100000 C 2 = 약 50억 가량의 작업이 소요될 수 있어 시간이 초과하였다.

 

 

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		int N = Integer.parseInt(st.nextToken());
		int S = Integer.parseInt(st.nextToken());
		int[] arr = new int[N+1];
		int[] sum = new int[N+1];
		st = new StringTokenizer(br.readLine());
		for (int i = 1; i <= N; i++) {
			arr[i] = Integer.parseInt(st.nextToken());
			sum[i] = sum[i - 1] + arr[i];
		}
		
		if (S <= 0) {
			System.out.println(0);
			return;
		}
		// 부분합 수열의 개수
		for (int n=1; n<=N; n++) {
			for (int start=1; start<=N-n; start++) {
				if (sum[start+n]-sum[start] >= S) {
					System.out.println(n);
					return;
				}
			}
		}
		
		System.out.println(0);
	}
}

 

 

 

 

 

 

2.  성공

 

start 포인터와 end 포인터를 각각 선언하여

 

두 포인터의 위치를 조금씩 조정해가며 최소 개수의 수열을 구하는 방법이 있었다.

 

이 방법을 사용하면, end포인터와 start포인터 각각 움직이더라도 배열을 1번만 순회하므로

 

O(n)의 시간복잡도를 가진다고 할 수 있다.

 

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		int N = Integer.parseInt(st.nextToken());
		int S = Integer.parseInt(st.nextToken());
		int[] arr = new int[N+2];
		st = new StringTokenizer(br.readLine());
		
		for (int i = 1; i <= N; i++) {
			arr[i] = Integer.parseInt(st.nextToken());
		}
		
		int start = 0;
		int end = 0;
		int minL = Integer.MAX_VALUE;
		int currSum = 0;
		
		while(end <= N+1 && start <= N) {
			if (currSum < S) {
				currSum += arr[end++];
			}
			else {
				minL = Math.min(minL,  end-start);
				currSum -= arr[start++];
			}
		}
		
		if (minL == Integer.MAX_VALUE) {
			System.out.println(0);
		} else {
			System.out.println(minL);
		}
	}
}

 

백준 2108: 통계학

 

 
 

문제 설명

 

 

수를 처리하는 것은 통계학에서 상당히 중요한 일이다. 통계학에서 N개의 수를 대표하는 기본 통계값에는

 

다음과 같은 것들이 있다. 단, N은 홀수라고 가정하자.

 

 

  1. 산술평균 : N개의 수들의 합을 N으로 나눈 값
  2. 중앙값 : N개의 수들을 증가하는 순서로 나열했을 경우 그 중앙에 위치하는 값
  3. 최빈값 : N개의 수들 중 가장 많이 나타나는 값

  4. 범위 : N개의 수들 중 최댓값과 최솟값의 차이

 

 

N개의 수가 주어졌을 때, 네 가지 기본 통계값을 구하는 프로그램을 작성하시오.

 

 

 

 

 

 

입력

 

 

첫째 줄에 수의 개수 N(1 ≤ N ≤ 500,000)이 주어진다. 단, N은 홀수이다. 그 다음 N개의 줄에는 정수들이 주어진다.

 

입력되는 정수의 절댓값은 4,000을 넘지 않는다.

 

 

 

 

 

 

출력

 

 

첫째 줄에는 산술평균을 출력한다. 소수점 이하 첫째 자리에서 반올림한 값을 출력한다.

 

둘째 줄에는 중앙값을 출력한다.

 

셋째 줄에는 최빈값을 출력한다. 여러 개 있을 때에는 최빈값 중 두 번째로 작은 값을 출력한다.

 

넷째 줄에는 범위를 출력한다.

 

 

 

 

 

 

내 답

 

1. 수를 입력받아 배열에 저장할 때, 수의 총합인 sum변수를 선언해 총합을 구해두었다.

 

 

2. 최빈수를 구하기 위해 카운트 배열을 쓰고자 했으나,

 

수 범위를 500,000까지인 것으로 잘못 읽어 메모리 초과 발생을 우려해 Map 자료형을 선택했다.

 

또한 최빈수가 여러개일 때 그 수를 저장하기 위해 리스트를 사용했다.

 

 

3. 또한 Arrays.sort를 통해 최대값과 최소값(arr[N-1]-arr[0]) 차이, 중앙값(arr[N/2])을 얻어냈다.

 

 

 

>> 결과적으로 최빈수를 구하는 과정에서 list를 만들고, Collections.sort를 사용한 것, map자료형을 사용한 것이

 

실행속도를 늦춘 원인으로 판단했다. 크기 8001짜리 카운트 배열을 활용해 구했다면 훨씬 빠를 것으로 예상했다. 

 

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		StringBuilder sb = new StringBuilder();

		Map<Integer, Integer> map = new HashMap<>(); // 최빈값 계산

		int n = sc.nextInt();
		int[] arr = new int[n];

		int sum = 0;
		// 입력받으면서 총합 구함
		for (int i = 0; i < n; i++) {
			int tmp = sc.nextInt();
			arr[i] = tmp;
			sum += tmp;
			// 해당 값의 빈도를 카운트
			if (map.containsKey(tmp)) {
				map.put(tmp, map.get(tmp) + 1);
			} else {
				map.put(tmp, 1);
			}
		}

		// 산술평균 출력
		sb.append(Math.round((double) sum / n)).append('\n');
		// 중앙값 계산
		Arrays.sort(arr); // 오름차순 정렬
		sb.append(arr[n / 2]).append('\n');

		// 최빈값 계산
		int max = 0;
		List<Integer> list = new ArrayList<>();
		for (int key : map.keySet()) {
			if (map.get(key) > max) {
				max = map.get(key);
				list.clear();
				list.add(key);
			} else if (map.get(key) == max) {
				list.add(key);
			}
		}
		Collections.sort(list);
		if (list.size() <= 1) {
			sb.append(list.get(0)).append('\n');
		} else {
			sb.append(list.get(1)).append('\n');
		}
		
		// 최대값, 최소값 차이
		sb.append(arr[n - 1] - arr[0]);

		System.out.println(sb);
	}
}

 

 

 

 

개선 사항

 

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

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        StringBuilder sb = new StringBuilder();

        int n = sc.nextInt();
        int[] arr = new int[n];
        int[] count = new int[8001]; // -4000 ~ 4000 범위를 담을 수 있는 배열

        int sum = 0;
        int maxFrequency = 0;
        // 입력받으면서 총합과 빈도 계산
        for (int i = 0; i < n; i++) {
            int value = sc.nextInt();
            arr[i] = value;
            sum += value;
            count[value + 4000]++; // -4000 ~ 4000을 0 ~ 8000으로 매핑
            maxFrequency = Math.max(maxFrequency, count[value + 4000]);
        }

        // 산술평균 계산 (반올림)
        sb.append(Math.round((double) sum / n)).append('\n');

        // 중앙값 계산을 위해 정렬
        Arrays.sort(arr);
        sb.append(arr[n / 2]).append('\n');

        // 최빈값 계산
        int max = Integer.MAX_VALUE;
        boolean foundSecond = false;
        for (int i = 0; i < count.length; i++) {
            if (count[i] == maxFrequency) {
                if (max == Integer.MAX_VALUE) {
                    max = i - 4000;
                } else if (!foundSecond) {
                    max = i - 4000;
                    foundSecond = true;
                }
            }
        }
        sb.append(mode).append('\n');

        // 최대값과 최소값의 차이 계산
        sb.append(arr[n - 1] - arr[0]).append('\n');

        // 결과 출력
        System.out.println(sb);
    }
}

 

 

  1. 수를 입력받을 때, sum값을 구하는 것 뿐 아니라 카운트배열을 활용해 바로 카운트하고,

    최빈값도 갱신하여 구함



  2. 카운트 배열을 순회하며 최빈값을 만나면 저장해두고,

    그다음 큰 수에서 최빈값을 마주치면 해당 값을 최빈값으로 갱신


    문제를 더 잘 읽자..!!
백준 14501: 서로 다른 부분 문자열의 개수
 
 

문제 설명

상담원으로 일하고 있는 백준이는 퇴사를 하려고 한다.

 

오늘부터 N+1일째 되는 날 퇴사를 하기 위해서, 남은 N일 동안 최대한 많은 상담을 하려고 한다.

 

백준이는 비서에게 최대한 많은 상담을 잡으라고 부탁을 했고, 비서는 하루에 하나씩 서로 다른 사람의 상담을 잡아놓았다.

 

각각의 상담은 상담을 완료하는데 걸리는 기간 Ti와 상담을 했을 때 받을 수 있는 금액 Pi로 이루어져 있다.

 

N = 7인 경우에 다음과 같은 상담 일정표를 보자.

 

  1 일차 2 일차 3 일차 4 일차 5 일차 6 일차 7 일차
Ti 3 5 1 1 2 4 2
Pi 10 20 10 20 15 40 200

 

 

1일에 잡혀있는 상담은 총 3일이 걸리며, 상담했을 때 받을 수 있는 금액은 10이다. 5일에 잡혀있는 상담은 총 2일이 걸리

 

며, 받을 수 있는 금액은 15이다.

 

상담을 하는데 필요한 기간은 1일보다 클 수 있기 때문에, 모든 상담을 할 수는 없다. 예를 들어서 1일에 상담을 하게 되면,

 

2일, 3일에 있는 상담은 할 수 없게 된다. 2일에 있는 상담을 하게 되면, 3, 4, 5, 6일에 잡혀있는 상담은 할 수 없다.

 

또한, N+1일째에는 회사에 없기 때문에, 6, 7일에 있는 상담을 할 수 없다.

 

퇴사 전에 할 수 있는 상담의 최대 이익은 1일, 4일, 5일에 있는 상담을 하는 것이며, 이때의 이익은 10+20+15=45이다.

 

상담을 적절히 했을 때, 백준이가 얻을 수 있는 최대 수익을 구하는 프로그램을 작성하시오.

 

 

 

 

입력

첫째 줄에 N (1 ≤ N ≤ 15)이 주어진다.

 

둘째 줄부터 N개의 줄에 Ti와 Pi가 공백으로 구분되어서 주어지며, 1일부터 N일까지 순서대로 주어진다.

 

(1 ≤ Ti ≤ 5, 1 ≤ Pi ≤ 1,000)

 

 

 

 

출력

첫째 줄에 백준이가 얻을 수 있는 최대 이익을 출력한다.

 

 

 

 

내 답

 

 재귀메서드를 이용해 모든 경우의 수를 파악하고자 했다.

 

N이 15까지이기 때문에 모든 모든 경우의 수를 따지면 2^15로 시간이 오래걸릴 수 있지만,

 

기간 안에 상담을 끝내지 못하는 경우를 가지치기하고, 

 

해당 일에 상담을 맡을 경우 소요되는 시간만큼 인덱스를 넘어가면 충분히 가능할 것이라 생각해

 

모든 경우의 수를 탐색했다.

 

 

 

import java.util.Scanner;

/*
 * 재귀메서드를 활용하여 1번째 날부터 N번째 날까지 모든 경우의 수를 탐색.
 */
public class Main {
	static int N, max;
	static int[][] schedule;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);

		max = 0;
		N = sc.nextInt();
		schedule = new int[N][2];

		for (int i = 0; i < N; i++) {
			schedule[i][0] = sc.nextInt();
			schedule[i][1] = sc.nextInt();
		}

		DFS(0, 0);

		System.out.println(max);
	}

	private static void DFS(int idx, int profit) {
		if (idx >= N) {
			max = Math.max(profit, max);
			return;
		}

		// 해당 날짜의 상담을 기간 내에 마칠 수 있는지 확인
		if (schedule[idx][0] <= N - idx) {
			// 상담을 한다
			DFS(idx + schedule[idx][0], profit + schedule[idx][1]);
		}
		DFS(idx + 1, profit);
	}
}

 

 

 

 

 

 

 

 

개선 사항

 

 

import java.io.*;
import java.util.*;

public class Main {
    static StringTokenizer st; 
    static int[] dp; 

    public static void main(String args[]) throws Exception {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine()); // N: 상담 가능한 총 날짜 수

        dp = new int[N + 1]; // dp 배열 초기화 (0 ~ N까지)

        for (int i = 0; i < N; i++) { // i: 현재 날짜
            st = new StringTokenizer(br.readLine()); // i번째 상담의 기간(t)과 수익(p)을 입력
            int t = Integer.parseInt(st.nextToken()); // 상담 기간
            int p = Integer.parseInt(st.nextToken()); // 상담 수익

            if (i + t <= N) { // 상담이 기한 내에 종료되는 경우
                dp[i + t] = Math.max(dp[i + t], dp[i] + p); // i + t일의 최대 수익 갱신
            }
            dp[i + 1] = Math.max(dp[i], dp[i + 1]); // 다음 날로 넘어갈 때 최대 수익 유지
        }

        System.out.println(dp[N]); // N일에 가능한 최대 수익 출력
    }
}

 

 

 

동적프로그래밍 알고리즘을 이용해 풀 수 있다.

 

이전 배열을 참고해 중복 계산을 피하면서도 최적의 값을 구할 수있다.

 

처음 풀 때도 dp방식을 생각하지 않은 것은 아닌데,

 

마땅한 풀이가 생각나지 않아 브루트포스로 문제를 해결했다.

 

더 많은 동적프로그래밍 문제를 풀어봐야겠다.

 

 

 

 

 

 

 

백준 11478: 서로 다른 부분 문자열의 개수
 
 

문제 설명

문자열 S가 주어졌을 때, S의 서로 다른 부분 문자열의 개수를 구하는 프로그램을 작성하시오.

부분 문자열은 S에서 연속된 일부분을 말하며, 길이가 1보다 크거나 같아야 한다.

예를 들어, ababc의 부분 문자열은 a, b, a, b, c, ab, ba, ab, bc, aba, bab, abc, abab, babc, ababc가 있고, 서로 다른것의 개수는 12개이다.

 

 

 

 

입력

첫째 줄에 문자열 S가 주어진다. S는 알파벳 소문자로만 이루어져 있고, 길이는 1,000 이하이다.

 

 

 

 

출력

첫째 줄에 S의 서로 다른 부분 문자열의 개수를 출력한다.

 

 

 

 

내 답

연속되는 모든 부분 문자열을 반복문 2개를 통해 추출하고,

 

 

중복 제거의 경우 Set을 이용해 중복을 제거했다.

 

 

시간 복잡도를 줄이고자 StringBuilder를 사용해 문자열을 담았으나,

 

 

결과적으로 950ms의 아쉬운 실행속도가 나왔다.

 

 

 

 

원인은 중복 제거 시 Set 자료구조를 사용할 때 중복을 제거하는 과정의 시간복잡도가

 

 

O(N^2)이기 때문에 시간이 오래 걸린 것으로 추측된다.

 

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;

public class S3_서로다른부분문자열의개수 {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String str = br.readLine();
		
		Set<String> set = new HashSet<>();;
		
		int len = str.length();
		for (int i=0; i<len; i++) {
			StringBuilder sb = new StringBuilder();
			for (int j=i; j<len; j++) {
				sb.append(str.charAt(j));
				set.add(sb.toString());
			}
		}
		
		System.out.println(set.size());
	}
}

 

 

 

 

 

 

보완점

 

 

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String input = reader.readLine();
        int n = input.length();

        // 접미사 배열 생성
        String[] suffix = new String[n];
        for (int i = 0; i < n; i++) {
            suffix[i] = input.substring(i);
        }

        // 접미사 배열 정렬
        Arrays.sort(suffix);
        int len = 0;

        // LCP 계산
        for (int i = 1; i < n; i++) {
            int curr = 0;
            int minLen = Math.min(suffix[i].length(), suffix[i - 1].length());
            while (curr < minLen && suffix[i].charAt(curr) == suffix[i - 1].charAt(curr)) {
                curr++;
            }
            len += curr;
        }

        // 총 부분 문자열 개수에서 중복된 부분을 뺀 개수 출력
        int total = (n * (n + 1)) / 2; // 총 부분 문자열 개수
        System.out.println(total - len);
    }
}

 

 

접미사 배열을 생성하여 정렬한 뒤,

 

 

정렬된 접미사들을 앞 뒤 접미사와 비교하며 공통 접두사 길이를 계산해 중복 부분 문자열을 제거하는 방식인

 

 

LCP 알고리즘 풀이를 사용했다.

 

 

처음 보는 알고리즘 방식이라 참신하고 좋은 방법이라는 생각이 든다.

 

 

익혀놓아야 겠다.

 

 

 

 

 

 

LCP 배열 계산

 

1. 가능한 모든 접미사를 저장해둔다.

 

apple => apple, pple, ple, le, e

 

 

 

2. 접미사들을 사전 순으로 정렬한다.

 

apple, e, le, ple, pple

 

 

 

3. 각 접미사들을 순회하며 이전 접미사와 비교해 공통 접두사의 길이를 계산한 LCP 배열에 저장해둔다.

 

apple : e => 0

e : le => 0

le : ple => 0

ple : pple => 1

 

 

 

 

따라서 중복되는 경우는 총 1가지이다!

 

백준 2252: 줄 세우기
 
 

문제 설명

N명의 학생들을 키 순서대로 줄을 세우려고 한다. 각 학생의 키를 직접 재서 정렬하면 간단하겠지만, 마땅한 방법이 없어서 두 학생의 키를 비교하는 방법을 사용하기로 하였다. 그나마도 모든 학생들을 다 비교해 본 것이 아니고, 일부 학생들의 키만을 비교해 보았다.

일부 학생들의 키를 비교한 결과가 주어졌을 때, 줄을 세우는 프로그램을 작성하시오.

 

 

입력

첫째 줄에 N(1 ≤ N ≤ 32,000), M(1 ≤ M ≤ 100,000)이 주어진다. M은 키를 비교한 횟수이다. 다음 M개의 줄에는 키를 비교한 두 학생의 번호 A, B가 주어진다. 이는 학생 A가 학생 B의 앞에 서야 한다는 의미이다.

학생들의 번호는 1번부터 N번이다.

 

 

 

출력

첫째 줄에 학생들을 앞에서부터 줄을 세운 결과를 출력한다. 답이 여러 가지인 경우에는 아무거나 출력한다.

 

 

 

내 답

1차 시도 (오답)

문제를 계속 째려보다 보니 위상정렬 알고리즘이 생각났다.

 

주어지는 입력에서 키를 비교한 입력값 각각을 간선이라고 생각하고,

 

앞에 오는 숫자가 시작노드, 뒤에 오는 숫자가 종점 노드가 되는 방향 그래프를 그려

 

나를 향하는 노드가 없는 노드부터 큐에 담아 순서대로 출력하는 그림을 그린 후 코드를 작성했다.

 

 

 

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

public class Main {
	static int N, M;
	static int[][] adjArr;
	static boolean[] visited;
	static StringBuilder sb;

	public static void main(String[] args) throws IOException {
		init(); // 변수 선언 및 초기화 메서드

		wisangSort();	// 위상정렬

		print(); // 출력 메서드
	}

	// 변수 선언 및 초기화 메서드
	static void init() throws IOException {
		sb = new StringBuilder();
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());

		N = Integer.parseInt(st.nextToken()); // 학생 수
		M = Integer.parseInt(st.nextToken()); // 학생 수

		adjArr = new int[N + 1][N + 1]; // 인접행렬
		for (int r = 0; r < M; r++) {
			st = new StringTokenizer(br.readLine());
			adjArr[Integer.parseInt(st.nextToken())][Integer.parseInt(st.nextToken())] = 1;
		} // 인접행렬 작성

		visited = new boolean[N + 1]; // 방문배열
	}

	// 위상정렬 수행 메서드
	private static void wisangSort() {
		Queue<Integer> q = new LinkedList<>();

		// 자기 자신을 향하는 노드가 없는 시작지점 노드를 큐에 삽입
		out: for (int e = 1; e <= N; e++) {
			for (int s = 1; s <= N; s++) {
				if (adjArr[s][e] > 0)
					continue out;
			}
			q.add(e);
			visited[e] = true;
		}
		
		while (!q.isEmpty()) {
			int curr = q.poll();	// 큐에서 뽑기
			sb.append(curr).append(' ');	// 스트링빌더에 추가
			
			// 인접행렬을 뒤져 아직 방문 안했으면서 인접한 노드를 큐에 삽입
			for (int i=1; i<=N; i++) {
				if (adjArr[curr][i] > 0 && !visited[i]) {
					q.add(i);
					visited[i] = true;
				}
			}
		}
	}

	// 출력 메서드
	private static void print() {
		System.out.println(sb);
	}
}

 

 

 

 

결과는 메모리 초과.

 

원인으로 의심되는 것들은 크게 2가지였다.

 

1. 방문배열을 추가적으로 선언하여 불필요한 메모리 사용

2. 인접리스트 대신 인접 행렬을 사용하여 불필요한 메모리 사용

 

하지만 둘 모두 수정해보아도 메모리 초과는 여전했다.

 

 

 

 

 

2차 시도 (정답)

 

결국 원인은 위상정렬을 구현하는 과정의 문제였다.

 

위상정렬 알고리즘을 생각한 것은 잘했지만, 구체적인 구현 방법이 생각나지 않아

 

내가 머리속에서 굴린 알고리즘으로만 구현했더니 통과가 안되었다.

 

결국 위상정렬 알고리즘을 다시 찾아보고 나서야 정답을 맞출 수 있었다.

 

 

package boj;

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

public class Main {
    static int N, M;
    static List<Integer>[] adjList;
    static int[] inDegree;
    static StringBuilder sb;

    public static void main(String[] args) throws IOException {
        init(); // 변수 선언 및 초기화 메서드
        wisangSort(); // 위상정렬
        print(); // 출력 메서드
    }

    // 변수 선언 및 초기화 메서드
    static void init() throws IOException {
        sb = new StringBuilder();
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        N = Integer.parseInt(st.nextToken()); // 학생 수
        M = Integer.parseInt(st.nextToken()); // 비교 횟수

        adjList = new ArrayList[N + 1]; // 인접 리스트
        inDegree = new int[N + 1]; // 진입 차수

        for (int i = 1; i <= N; i++) {
            adjList[i] = new ArrayList<>();
        }

        for (int r = 0; r < M; r++) {
            st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            adjList[u].add(v); // u -> v 간선 추가
            inDegree[v]++; // v의 진입 차수 증가
        }
    }

    // 위상정렬 수행 메서드
    private static void wisangSort() {
        Queue<Integer> q = new LinkedList<>();

        // 진입 차수가 0인 노드를 큐에 삽입
        for (int i = 1; i <= N; i++) {
            if (inDegree[i] == 0) {
                q.add(i);
            }
        }

        while (!q.isEmpty()) {
            int curr = q.poll(); // 큐에서 뽑기
            sb.append(curr).append(' '); // 스트링빌더에 추가
            
            // curr와 인접한 노드들에 대해 진입 차수를 감소시키고 0이 되면 큐에 추가
            for (int neighbor : adjList[curr]) {
                inDegree[neighbor]--;
                if (inDegree[neighbor] == 0) {
                    q.add(neighbor);
                }
            }
        }
    }

    // 출력 메서드
    private static void print() {
        System.out.println(sb);
    }
}

 

 

결론은

 

방문배열을 사용하는 것이 아니라,

 

진입차수 배열을 생성하여

 

큐에서 꺼낸 노드와 인접한 노드들과의 간선을 1개씩 제거하며 진입차수를 떨어트리고,

 

진입차수가 0인 것들을 큐에 담는 과정이 필요했다...

 

 

다시한번 위상정렬 알고리즘을 공부할 수 있는 기회가 되었다.

 

다음에는 진입차수 배열을 사용하는 것을 잊지 말아야지!