생각하다

[알고리즘] Dynamic Programming(동적 계획법, DP) | 백준 1463. 1로 만들기 _Java

3o14 — Tue, 29 Aug 2023 15:11:15 +0900

피보나치 수열로 메모이제이션의 필요성 알아보기

피보나치 수열이란?

0과 1로 시작하고 이전의 두 수의 합을 다음 항으로 하는 수열을 피보나치 수열이라 함
- 0, 1, 1, 2, 3, 5, 8, 13, …
피보나치 수열의 i번째 값을 계산하는 함수 F를 정의하면 다음과 같다
- F0 = 0, F1 = 1
- Fi = Fi-1 + Fi-2 for i ≥ 2
위의 정의로부터 피보나치 수열의 i번째 항을 반환하는 함수를 재귀함수로 구현할 수 있음

fibo(n)
	IF n < 2: RETURN n
	ELSE    : RETURN fibo(n-1) + fibo(n-2)

피보나치 수열의 문제점

앞의 예에서 피보나치 수를 구하는 함수를 재귀함수로 구현한 알고리즘은 아래와 같은데

이는 엄청난 중복 호출 문제를 초래함을 알 수 있다.

여기서 얼마나 중복되었는지, 중복을 피할 수 있는 방법은 무엇인지 알아 볼 수 있다.

메모이제이션 (Memoization)

컴퓨터 프로그램을 실행할 때 이전에 계산한 값을 메모리에 저장해서 매번 다시 계산하지 않도록 하는 것 → 실행 속도가 빨라짐 (동적 계획법의 핵심)
memoization 글자 그대로 해석하면 ‘메모리에 넣기(to put in memory)’라는 의미이며 ‘기억되어야 할 것’이라는 뜻의 라틴어 memorandum에서 파생되었다.

피보나치 수를 구하는 알고리즘에서 fibo1(n)의 값을 계산하자마자 저장하면 (memoize), 실행 시간을 O(n)으로 줄일 수 있다.

Memoization을 적용한 알고리즘

// memo를 위한 배열을 할당하고, 모두 0으로 초기화한다
// memo[0]을 0으로 memo[1]는 1로 초기화한다

fibo1(n)
	IF n >= 2 AND memo[n] = 0
		memo[n] <- fibo1(n-1) + fibo1(n-2)
	RETURN memo[n] // 메모해둔 값이 있다면 그거 사용하기

코드 구현

단순 재귀호출로 구현한 피보나치 수열

// 단순 재귀 호출로 피보나치 구현하기
private static long fibo1(int n) { // 피보나치 n항 구하기
    totalCnt1++;
    callCnt1[n]++;
    if(n<2) return n;
    return fibo1(n-1) + fibo1(n-2);
}

메모이제이션을 이용해 구현한 피보나치 수열

// 메모이제이션을 통한 피보나치 구현
private static long fibo2(int n) {
    totalCnt2++;
    callCnt2[n]++;

    if(memo[n] == -1) { // 메모 안되어있을 경우 재귀 호출
        memo[n] = fibo2(n-1) + fibo2(n-2);
    }
    return memo[n]; // 메모 되어있을 경우 바로 메모값 반환
}

전체 코드

package Algorithm;
import java.util.*;
import java.io.*;
public class FibonacciTest {

	static long totalCnt1, totalCnt2, callCnt1[], callCnt2[], memo[];
	
// 단순 재귀 호출로 피보나치 구현하기
	private static long fibo1(int n) { // 피보나치 n항 구하기
		totalCnt1++;
		callCnt1[n]++;
		if(n<2) return n;
		return fibo1(n-1) + fibo1(n-2);
		
	}
	
// 메모이제이션을 통한 피보나치 구현
	private static long fibo2(int n) {
		totalCnt2++;
		callCnt2[n]++;
		
		if(memo[n] == -1) { // 메모 안되어있을 경우 재귀 호출
			memo[n] = fibo2(n-1) + fibo2(n-2);
		}
		return memo[n]; // 메모 되어있을 경우 바로 메모값 반환
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub

		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		
		totalCnt1 = totalCnt2 = 0;
		callCnt1 = new long[N+1];
		callCnt2 = new long[N+1];
		memo = new long[N+1];
		
		
		Arrays.fill(memo, -1); // 메모 배열 초기값 -1로 세팅
		
		memo[0] = 0;
		memo[1] = 1;
		
		System.out.println(fibo1(N));
		System.out.println("fibo1: " + totalCnt1);
		for (int i = 0; i < N; i++) {
			System.out.println("fibo1["+i+"] : " + callCnt1[i]);
		}
		System.out.println("-------------------");
		System.out.println(fibo2(N));
		System.out.println("fibo2: " + totalCnt2);
		for (int i = 0; i < N; i++) {
			System.out.println("fibo2["+i+"] : " + callCnt2[i]);
		}
	}

}

5를 입력했을때 결과값 차이

5
5
fibo1: 15
// 각 fibo1[n]이 호출된 횟수
fibo1[0] : 3
fibo1[1] : 5
fibo1[2] : 3
fibo1[3] : 2
fibo1[4] : 1
-------------------
5
fibo2: 9
// 각 fibo1[n]이 호출된 횟수
fibo2[0] : 1
fibo2[1] : 2
fibo2[2] : 2
fibo2[3] : 2
fibo2[4] : 1

입력값: 45 일 때 결과값 차이 보기

45를 입력했을때 결과값 차이

45
1134903170
fibo1: 3672623805
fibo1[0] : 701408733
fibo1[1] : 1134903170
fibo1[2] : 701408733
fibo1[3] : 433494437
fibo1[4] : 267914296
fibo1[5] : 165580141
fibo1[6] : 102334155
fibo1[7] : 63245986
fibo1[8] : 39088169
fibo1[9] : 24157817
fibo1[10] : 14930352
fibo1[11] : 9227465
fibo1[12] : 5702887
fibo1[13] : 3524578
fibo1[14] : 2178309
fibo1[15] : 1346269
fibo1[16] : 832040
fibo1[17] : 514229
fibo1[18] : 317811
fibo1[19] : 196418
fibo1[20] : 121393
fibo1[21] : 75025
fibo1[22] : 46368
fibo1[23] : 28657
fibo1[24] : 17711
fibo1[25] : 10946
fibo1[26] : 6765
fibo1[27] : 4181
fibo1[28] : 2584
fibo1[29] : 1597
fibo1[30] : 987
fibo1[31] : 610
fibo1[32] : 377
fibo1[33] : 233
fibo1[34] : 144
fibo1[35] : 89
fibo1[36] : 55
fibo1[37] : 34
fibo1[38] : 21
fibo1[39] : 13
fibo1[40] : 8
fibo1[41] : 5
fibo1[42] : 3
fibo1[43] : 2
fibo1[44] : 1
-------------------
1134903170
fibo2: 89
fibo2[0] : 1
fibo2[1] : 2
fibo2[2] : 2
fibo2[3] : 2
fibo2[4] : 2
fibo2[5] : 2
fibo2[6] : 2
fibo2[7] : 2
fibo2[8] : 2
fibo2[9] : 2
fibo2[10] : 2
fibo2[11] : 2
fibo2[12] : 2
fibo2[13] : 2
fibo2[14] : 2
fibo2[15] : 2
fibo2[16] : 2
fibo2[17] : 2
fibo2[18] : 2
fibo2[19] : 2
fibo2[20] : 2
fibo2[21] : 2
fibo2[22] : 2
fibo2[23] : 2
fibo2[24] : 2
fibo2[25] : 2
fibo2[26] : 2
fibo2[27] : 2
fibo2[28] : 2
fibo2[29] : 2
fibo2[30] : 2
fibo2[31] : 2
fibo2[32] : 2
fibo2[33] : 2
fibo2[34] : 2
fibo2[35] : 2
fibo2[36] : 2
fibo2[37] : 2
fibo2[38] : 2
fibo2[39] : 2
fibo2[40] : 2
fibo2[41] : 2
fibo2[42] : 2
fibo2[43] : 2
fibo2[44] : 1

메모이제이션의 단점

추가적인 메모리 공간이 필요하다.
재귀 함수 호출로 인한 시스템 호출 스택을 사용하게 되고 실행 속도 저하 또는 오버플로우가 발생할 수 있다.
해결책은?

동적 계획법 (Dynamic Programming)

동적 계획법은 그리디 알고리즘과 같이 최적화 문제를 해결하는 알고리즘이다.
- 경우의 수 구할 때도 동적 계획법을 사용할 수 있다.
동적 계획법은 먼저 작은 부분 문제들의 해를 구하고 이들을 이용하여 보다 큰 크기의 부분 문제들을 해결하여, 최종적으로 원래 주어진 문제를 해결하는 알고리즘 설계 기법이다.

동적 계획법의 적용 요건

중복 부분문제 구조(Overlapping subproblems)
최적 부분문제 구조(Optimal substructure)

중복 부분문제 구조(Overlapping subproblems)

DP는 큰 문제를 이루는 작은 문제들을 먼저 해결하고, 작은 문제들의 최적해(Optimal Solution)을 이용하여 순환적으로 큰 문제를 해결한다.
- 순환적인 관계(recurrence relation)를 명시적으로 표현하기 위해서 동적 계획법에서는 일반적으로 수학적 도구인 점화식을 사용한다.
DP는 문제의 순환적인 성질 때문에 이전에 계산되었던 작은 문제의 해가 다른 어딘가에서 필요하게 되는데(Overlapping subproblems) 이를 위해 DP에서는 이미 해결된 작은 문제들의 해들을 어떤 저장 공간(table)에 저장하게 된다.
그리고 이렇게 저장된 해들이 다시 필요할 때 마다 해를 얻기 위해 다시 문제를 재계산하지 않고 table의 참조를 통해서 중복 계산을 피할 수 있다.

최적 부분문제 구조(Optimal substructure)

동적 계획법이 최적화에 대한 어느 문제에나 적용될 수 있는 것은 아니다. 주어진 문제가 최적화의 원칙(Principle of Optimality)을 만족해야만 동적 계획법을 효율적으로 적용할 수 있다.
최적화의 원칙이란 어떤 문제에 대한 해가 최적일 때 그 해를 구성하는 작은 문제들의 해 역시 최적이어야 한다는 것이다. 동적 계획법의 방법 자체가 큰 문제의 최적 해를 작은 문제의 최적해들을 이용하여 구하기 때문에 만약 큰 문제의 최적해가 작은 문제들의 최적해들로 구성되지 않는다면 이 문제는 동적 계획법을 적용할 수 없다.

https://www.acmicpc.net/problem/1463

1463번: 1로 만들기

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

www.acmicpc.net

분류

다이나믹 프로그래밍

문제 설명

정수 X에 사용할 수 있는 연산은 다음과 같이 세 가지 이다.

X가 3으로 나누어 떨어지면, 3으로 나눈다.
X가 2로 나누어 떨어지면, 2로 나눈다.
1을 뺀다.

정수 N이 주어졌을 때, 위와 같은 연산 세 개를 적절히 사용해서 1을 만들려고 한다. 연산을 사용하는 횟수의 최솟값을 출력하시오.

입력

첫째 줄에 1보다 크거나 같고, 106보다 작거나 같은 정수 N이 주어진다.

출력

첫째 줄에 연산을 하는 횟수의 최솟값을 출력한다.

시간복잡도 3^n 이 나오는 풀이법

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

public class Main {

	static long []arr;
	private static int func(int n, int cnt) {
		if(n == 1) {
			return 0;
		}
		
		int min = func(n-1, cnt+1) +1;
		
		if(n%2 == 0) {
			int min1 = func(n/2, cnt+1) +1;
			min = Math.min(min, min1);
		}
		if(n%3 == 0) {
			int min1 = func(n/3, cnt+1) +1;
			min = Math.min(min, min1);
		}
		
		return min;
	}
	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		int cnt = 0;
		int ans = func(N, cnt);
		
		System.out.println(ans);
	}

}

dp를 이용한 풀이법

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

public class Main {
	static int N;
	static int res = Integer.MAX_VALUE;
	static int[] dp;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		//구현
		dp = new int[N+1]; //0
		dp[1] = 0;
		for(int i = 2; i <= N; i++) {
			//1빼기
			dp[i] = dp[i-1] + 1;
			//2로 나누어 보기(나누어 떨어지면)
			if(i % 2 == 0) {
				dp[i] = Math.min(dp[i], dp[i/2]+1);
			}
			//3으로 나누어보기(나누어 떨어지면)
			if(i % 3 == 0) {
				dp[i] = Math.min(dp[i], dp[i/3]+1);
			}
		}
		System.out.println(dp[N]);
		
	}
}

dp없이 제일 효율적인 방법

재귀 호출할 때 연산 횟수를 같이 갱신시키는 방법이다.

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

public class Main {

	static int []dp;
	private static int func(int n, int cnt) {
		if(n < 2) return cnt;
		
		return Math.min(func(n/2, cnt+1 + (n%2)), func(n/3, cnt+1 + (n%3)));
	}
	public static void main(String[] args) throws NumberFormatException, IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		int N = Integer.parseInt(br.readLine());
		System.out.println(func(N, 0));
	}
}

[BOJ/백준] 17070번 파이프 옮기기 1 _Java

3o14 — Wed, 23 Aug 2023 15:18:24 +0900

백준 17070. 파이프 옮기기 1 _Java

문제 설명

분류

다이나믹 프로그래밍, 그래프 이론, 그래프 탐색

문제 설명

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의 번호이고, 행과 열의 번호는 1부터 시작한다. 각각의 칸은 빈 칸이거나 벽이다.

오늘은 집 수리를 위해서 파이프 하나를 옮기려고 한다. 파이프는 아래와 같은 형태이고, 2개의 연속된 칸을 차지하는 크기이다.

파이프는 회전시킬 수 있으며, 아래와 같이 3가지 방향이 가능하다.

파이프는 매우 무겁기 때문에, 유현이는 파이프를 밀어서 이동시키려고 한다. 벽에는 새로운 벽지를 발랐기 때문에, 파이프가 벽을 긁으면 안 된다. 즉, 파이프는 항상 빈 칸만 차지해야 한다.

파이프를 밀 수 있는 방향은 총 3가지가 있으며, →, ↘, ↓ 방향이다. 파이프는 밀면서 회전시킬 수 있다. 회전은 45도만 회전시킬 수 있으며, 미는 방향은 오른쪽, 아래, 또는 오른쪽 아래 대각선 방향이어야 한다.

파이프가 가로로 놓여진 경우에 가능한 이동 방법은 총 2가지, 세로로 놓여진 경우에는 2가지, 대각선 방향으로 놓여진 경우에는 3가지가 있다.

아래 그림은 파이프가 놓여진 방향에 따라서 이동할 수 있는 방법을 모두 나타낸 것이고, 꼭 빈 칸이어야 하는 곳은 색으로 표시되어져 있다.

가로

세로

대각선

가장 처음에 파이프는 (1, 1)와 (1, 2)를 차지하고 있고, 방향은 가로이다. 파이프의 한쪽 끝을 (N, N)로 이동시키는 방법의 개수를 구해보자.

입력

첫째 줄에 집의 크기 N(3 ≤ N ≤ 16)이 주어진다. 둘째 줄부터 N개의 줄에는 집의 상태가 주어진다. 빈 칸은 0, 벽은 1로 주어진다. (1, 1)과 (1, 2)는 항상 빈 칸이다.

출력

첫째 줄에 파이프의 한쪽 끝을 (N, N)으로 이동시키는 방법의 수를 출력한다. 이동시킬 수 없는 경우에는 0을 출력한다. 방법의 수는 항상 1,000,000보다 작거나 같다.

예제 입력

예제 출력

풀이법

1. dp 메모이제이션할 3차월 배열을 만든다.

가로 방향 dp[][][0]
세로 방향 dp[][][1] 세로
대각 방향 dp[][][2] 대각

2. map을 돌면서 가로, 세로, 대각일 경우를 나누어 수행한다.

현재 상태가 가로일 경우
- 다음값 = 이전의 가로값 + 이전의 대각값
현재 상태가 세로일 경우
- 다음값 = 이전의 세로값 + 이전의 대각값
현재 상태가 대각일 경우
- 다음값 = 이전의 가로값 + 이전의 세로값 + 이전의 대각값

3. 구할 값인 마지막 요소의 수를 반환한다.

dp에서 가로, 세로, 대각일 경우를 합해서 반환한다.

코드

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

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 map[][] = new int[N][N];
		int dp[][][] = new int[N][N][3]; // 가로, 세로, 대각선을 표시하기 위한 3차원 배열
		
		for (int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for (int j = 0; j < N; j++) {
				map[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		// map 입력 완료
        
		dp[0][1][0] = 1; // 최초 상태
		for (int i = 0; i < N; i++) {
			for (int j = 2; j < N; j++) {
				if( j-1 > 0 && map[i][j] == 0) { // 가로
					dp[i][j][0] = dp[i][j-1][0] + dp[i][j-1][2];
				}
				if(i-1 >= 0 && map[i][j] == 0) { // 세로
					dp[i][j][1] = dp[i-1][j][1] + dp[i-1][j][2];
				}
				if(i-1 >= 0 && j-1 >= 0 && map[i][j] == 0 && map[i-1][j] == 0 && map[i][j-1] == 0) { // 대각
					dp[i][j][2] = dp[i-1][j-1][0] + dp[i-1][j-1][1] + dp[i-1][j-1][2];
				}
			}
		}
		
		int ans = dp[N-1][N-1][0] + dp[N-1][N-1][1] + dp[N-1][N-1][2];
		System.out.println(ans);
	}
	
}

후기

골드 어려워

https://www.acmicpc.net/problem/17070

17070번: 파이프 옮기기 1

유현이가 새 집으로 이사했다. 새 집의 크기는 N×N의 격자판으로 나타낼 수 있고, 1×1크기의 정사각형 칸으로 나누어져 있다. 각각의 칸은 (r, c)로 나타낼 수 있다. 여기서 r은 행의 번호, c는 열의

www.acmicpc.net

[알고리즘] 백트래킹(Backtracking) | 백준 9663. N-Queen _Java

3o14 — Thu, 17 Aug 2023 14:49:11 +0900

백트래킹(Backtracking) 알고리즘

백트래킹 알고리즘이란?

백트래킹은 조합 최적화, 문제 해결 등 여러 문제에서 사용되는 알고리즘 기법 중 하나입니다. 주로 모든 가능한 경우의 수를 탐색하면서 해답을 찾는데 사용되며, 문제의 조건을 만족하지 않으면 해당 경로를 포기하고 이전 단계로 돌아가는 방식으로 동작합니다.

백트래킹 알고리즘 구현 단계

선택 (Choose): 다음으로 시도할 선택을 하거나, 다음 상태로 진행합니다.
조건 확인 (Constraint): 선택한 것이 조건을 만족하는지 확인합니다.
해결 여부 판단 (Is it a solution?): 현재 선택과 조건이 문제의 해결을 이끌어냈는지 확인합니다.
해결하지 못한 경우 (No): 선택한 것이 조건을 만족하지 않으면 이전 상태로 돌아갑니다.
해결한 경우 (Yes): 문제가 해결되었다면 결과를 출력하거나 저장합니다.
반복 (Iterate): 다음 경우의 수를 확인하기 위해 다시 1단계로 돌아갑니다.

Java로 구현하기

N-Queen 문제

N-퀸 문제는 대표적인 백트래킹 알고리즘을 사용하는 문제입니다.

N x N 크기의 체스판 위에 N개의 퀸을 서로 공격하지 않도록 배치하는 방법의 횟수를 출력하는 문제입니다.

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

public class Main {
	static int N, col[], ans;
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		N = sc.nextInt();
		col = new int[N+1]; // 1열부터 사용
		ans = 0; // 가능한 경우의 수
		
		setQueen(1);
		System.out.println(ans);
	}
	
	// 해당 퀸을 현재 행에 가능한 모든 곳에 놓아보기
	private static void setQueen(int row) {
		// 가지 치기
		if(!isAvailable(row-1)) return;
		// 기저 조건
		if(row>N) {
			ans++;
			return;
		}
		
		// 유도파트
		for (int c = 1; c <= N; c++) {
			col[row] = c;
			setQueen(row+1);
		}
		
	}
	
	private static boolean isAvailable(int row) { // row: 마지막으로 놓아진 퀸의 행
		for (int i = 1; i < row; i++) {
			if(col[i] == col[row] || row-i == Math.abs(col[row] - col[i])) {
				return false;
			}
		}
		return true;
	}

}

https://www.acmicpc.net/problem/9663

9663번: N-Queen

N-Queen 문제는 크기가 N × N인 체스판 위에 퀸 N개를 서로 공격할 수 없게 놓는 문제이다. N이 주어졌을 때, 퀸을 놓는 방법의 수를 구하는 프로그램을 작성하시오.

www.acmicpc.net

[Next.js] NextJS에서 google font 사용 및 설정하기

3o14 — Mon, 7 Aug 2023 00:48:50 +0900

Next.js에서 구글 폰트 사용하기

import { 폰트명 } from "next/font/google";

<head>에 글로벌 폰트 적용시키기

import { Inter } from 'next/font/google'
 
const inter = Inter({ subsets: ['latin'] })
 
export default function MyApp({ Component, pageProps }) {
  return (
    <>
      <style jsx global>{`
        html {
          font-family: ${inter.style.fontFamily};
        }
      `}</style>
      <Component {...pageProps} />
    </>
  )
}

한 페이지에서만 폰트 사용하기

import { Inter } from 'next/font/google'
 
const inter = Inter({ subsets: ['latin'] })
 
export default function Home() {
  return (
    <div className={inter.className}>
      <p>Hello World</p>
    </div>
  )
}

Font Function Arguments

import React from "react";
import { Roboto } from "@next/font/google";
const bold = Roboto({
  weight: "700",
  display: "fallback",
  subsets: ["latin"],
  style: "normal",
  variable: "--roboto-bold",
  fallback: ["system-ui"],
});
const medium = Roboto({
  weight: "500",
  display: "fallback",
  subsets: ["latin"],
  style: "normal",
  variable: "--roboto-medium",
  fallback: ["system-ui"],
});
export {
  bold as robotoBold,
  medium as robotoMedium,
}

weight: 폰트의 가중치를 설정하는 key
display: css에서 font-display 키워드를 설정 하는 key
subsets: font가 적용할 수 있는 언어 중에서 먼저 가져 올 나라의 언어를 설정하는 key
style: font의 스타일이 normal인지 italic인지 설정하는 key
variable: CSS 변수 방식으로 사용할 때의 이름을 정의하는 key
fallback: 해당 font를 가져오지 못하였을 때의 대체 글꼴을 설정하는 key

https://nextjs.org/docs/pages/api-reference/components/font#nextfontgoogle

Components: Font | Next.js

Using Pages Router Features available in /pages

nextjs.org

https://nextjs.org/docs/pages/building-your-application/optimizing/fonts#apply-the-font-in-head

Optimizing: Fonts | Next.js

Using Pages Router Features available in /pages

nextjs.org

[BOJ/백준] 11723번 집합 비트마스크_Java

3o14 — Thu, 3 Aug 2023 16:11:32 +0900

백준 11723. 집합 _Java

문제 설명

비어있는 공집합 S가 주어졌을 때, 아래 연산을 수행하는 프로그램을 작성하시오.

add x: S에 x를 추가한다. (1 ≤ x ≤ 20) S에 x가 이미 있는 경우에는 연산을 무시한다.
remove x: S에서 x를 제거한다. (1 ≤ x ≤ 20) S에 x가 없는 경우에는 연산을 무시한다.
check x: S에 x가 있으면 1을, 없으면 0을 출력한다. (1 ≤ x ≤ 20)
toggle x: S에 x가 있으면 x를 제거하고, 없으면 x를 추가한다. (1 ≤ x ≤ 20)
all: S를 {1, 2, ..., 20} 으로 바꾼다.
empty: S를 공집합으로 바꾼다.

입력

첫째 줄에 수행해야 하는 연산의 수 M (1 ≤ M ≤ 3,000,000)이 주어진다.

둘째 줄부터 M개의 줄에 수행해야 하는 연산이 한 줄에 하나씩 주어진다.

출력

check 연산이 주어질때마다, 결과를 출력한다.

입출력 예

예제 입력

26
add 1
add 2
check 1
check 2
check 3
remove 2
check 1
check 2
toggle 3
check 1
check 2
check 3
check 4
all
check 10
check 20
toggle 10
remove 20
check 10
check 20
empty
check 1
toggle 1
check 1
toggle 1
check 1

예제 출력

풀이법

비트마스킹을 이용해서 풀면 된다.

코드

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

public class Main {
    private static final BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    private static final BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    static StringBuilder sb = new StringBuilder();

    public static void main(String[] args) throws IOException {
       int n = Integer.parseInt(br.readLine());
       int bitset = 0;

       while(n-- > 0){
            StringTokenizer st = new StringTokenizer(br.readLine());
            String cmd = st.nextToken();
            int num;

            // 수행연산
            switch (cmd){
                case "add" :
                    num = Integer.parseInt(st.nextToken());
                    bitset |= (1 << (num - 1));
                    break;
                case "remove" :
                    num = Integer.parseInt(st.nextToken());
                    bitset = bitset & ~(1 << (num - 1));
                    break;
                case "check" :
                    num = Integer.parseInt(st.nextToken());
                    sb.append((bitset & (1 << (num - 1))) != 0 ? "1\n" : "0\n");
                    break;
                case "toggle" :
                    num = Integer.parseInt(st.nextToken());
                    bitset ^= (1 << (num - 1));
                    break;
                case "all" :
                    bitset |= (~0);
                    break;
                case "empty" :
                    bitset &= 0;
                    break;
            }
        }
        bw.write(sb.toString());
        bw.close();
        br.close();
    }
}

후기

너어어무 어렵지만 이해해야지

https://www.acmicpc.net/problem/11723

11723번: 집합

첫째 줄에 수행해야 하는 연산의 수 M (1 ≤ M ≤ 3,000,000)이 주어진다. 둘째 줄부터 M개의 줄에 수행해야 하는 연산이 한 줄에 하나씩 주어진다.

www.acmicpc.net

[BOJ/백준] 1157번 단어 공부 _Java

3o14 — Tue, 1 Aug 2023 09:45:56 +0900

백준 1157. 단어 공부 _Java

코드

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

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String [] str = br.readLine().toUpperCase().split("");
		
		String[] str2 = Arrays.stream(str).distinct().toArray(String[]::new);
		// 배열 -> stream -> distinct(중복 제거) -> 배열
		
		int max = 0;
		String ans = null;
		for(String s:str2) {
			int cnt = Collections.frequency(Arrays.asList(str), s);
			if(cnt > max) {
				max = cnt;
				ans = s;
			}
			else if(cnt == max)
				ans = "?";
		}
		
		System.out.println(ans);
	}
}

배열 중복 제거하기

String[] str2 = Arrays.stream(str).distinct().toArray(String[]::new);
// 배열 -> stream -> distinct(중복 제거) -> 배열

배열 내 특정 요소의 개수 구하기

Collections.frequency(구할 리스트, 찾을 문자);

int cnt = Collections.frequency(Arrays.asList(str), s);

https://www.acmicpc.net/problem/1157

1157번: 단어 공부

알파벳 대소문자로 된 단어가 주어지면, 이 단어에서 가장 많이 사용된 알파벳이 무엇인지 알아내는 프로그램을 작성하시오. 단, 대문자와 소문자를 구분하지 않는다.

www.acmicpc.net

[백준/BOJ] 27866번 문자와 문자열 _Java

3o14 — Sun, 23 Jul 2023 18:09:41 +0900

백준 27866. 문자와 문자열 _Java

문제 설명

단어 S와 정수 i가 주어졌을 때, S의 i번째 글자를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에 영어 소문자와 대문자로만 이루어진 단어 S가 주어진다. 단어의 길이는 최대 1000이다.

둘째 줄에 정수 i가 주어진다. (1 <= i <= |S| )

출력

S의 i번째 글자를 출력한다.

제한사항

1 초

1024 MB

입출력 예

예제 입력

Sprout
3

예제 출력

코드

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

public class Main {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		String []str = st.nextToken().split("");
		st = new StringTokenizer(br.readLine());
		int n = Integer.parseInt(st.nextToken());
		for(int i=1; i<=str.length; i++) {
			if(i == n) {
				System.out.println(str[i-1]);
			}
		}
	}
}

후기

1) int를 비교할 때, a==b를 사용한다.

2) Integer를 비교할 때, a==b를 사용하면 오류 발생
a.equals(b)를 사용한다.

비교 대상 중 primitive type(int) 의 변수가 하나라도 있다면, == 연산자는 값으로 비교한다.

27866번: 문자와 문자열

첫째 줄에 영어 소문자와 대문자로만 이루어진 단어 $S$가 주어진다. 단어의 길이는 최대 $1\,000$이다. 둘째 줄에 정수 $i$가 주어진다. ($1 \le i \le \left|S\right|$)

www.acmicpc.net

[Java] 자바의 접근 제한자, 싱글톤 패턴으로 객체 instance 생성하기

3o14 — Sat, 22 Jul 2023 22:44:19 +0900

자바의 접근 제한자, 싱글톤 패턴으로 객체 instance 생성하기

접근 제한자

자바(Java)에서는 접근 제한자(access modifier)를 사용하여 클래스, 메서드, 필드, 생성자 등의 멤버들에 대한 접근 범위를 지정할 수 있습니다. 자바에서 사용할 수 있는 네 가지 접근 제한자는 다음과 같습니다.

public: 가장 넓은 범위의 접근 제한자입니다. public으로 선언된 멤버는 모든 곳에서 접근할 수 있습니다. 다른 패키지에서도 접근이 가능합니다.
protected: protected로 선언된 멤버는 같은 패키지 내에서는 접근 가능하며, 다른 패키지의 하위 클래스에서도 접근 가능합니다.
default (package-private): 접근 제한자를 별도로 지정하지 않은 경우를 default 접근 제한자라고 합니다. 같은 패키지 내에서만 접근이 가능하고, 다른 패키지에서는 접근할 수 없습니다.
private: 가장 제한적인 범위의 접근 제한자입니다. private으로 선언된 멤버는 해당 클래스 내에서만 접근이 가능하며, 외부에서는 접근할 수 없습니다.

코드 예시

public class MyClass {
    public int publicField;       // 모든 곳에서 접근 가능
    protected int protectedField; // 같은 패키지 및 하위 클래스에서 접근 가능
    int defaultField;             // 같은 패키지에서 접근 가능 (접근 제한자를 명시하지 않은 경우)
    private int privateField;     // 해당 클래스 내에서만 접근 가능

    public void publicMethod() {
        // 모든 곳에서 접근 가능한 메서드
    }

    protected void protectedMethod() {
        // 같은 패키지 및 하위 클래스에서 접근 가능한 메서드
    }

    void defaultMethod() {
        // 같은 패키지에서 접근 가능한 메서드 (접근 제한자를 명시하지 않은 경우)
    }

    private void privateMethod() {
        // 해당 클래스 내에서만 접근 가능한 메서드
    }
}

이와 같이 접근 제한자를 적절히 사용하여 클래스의 캡슐화(encapsulation)를 유지하고, 필요한 멤버들에 대한 접근을 제어할 수 있습니다.

싱글톤 패턴으로 instance 생성하기

public class Algo {
	int x;
	private static Algo instance; // private으로 객체 인스턴스 생성 (static)
	private Algo() {} // private로 생성자 접근 금지
	
	public static Algo getInstance() {
		if(instance == null) { // 인스턴스 생성이 아직 안된 상태일 경우
			instance = new Algo(); // Algo객체 인스턴스 생성
		}
		return instance; // 인스턴스 반환
	}
}

public class AlgoTest {
	public static void main(String[] args) {
		Algo a = new Algo(); // 오류 -> Algo 클래스 생성자가 private이기 때문
		Algo b = new Algo(); // 오류
	
		Algo c = Algo.getInstance(); // 정상 작동
		System.out.println(c.x); // 정상 작동
	}
}

[Java] OOP 추상클래스와 인터페이스

3o14 — Fri, 21 Jul 2023 13:57:20 +0900

객체지향 프로그래밍(OOP) 추상클래스와 인터페이스

추상 클래스

추상클래스의 개념을 알아보기 전에 아래 클래스들의 공통 분모를 뽑아서 상속 구조를 만들어봅시다.

before : 상속 사용 전

public class DieselSUV {
	private int curX, curY;
	
	public void reportPosition() {
		System.out.printf("현재 위치: (%d, %d)%n", curX, curY);
	}

	public void addFuel() {
		System.out.printf("주유소에서 급유");
	}
}

public class ElectricCar {
	private int curX, curY;
	
	public void reportPosition() {
		System.out.printf("현재 위치: (%d, %d)%n", curX, curY);
	}
	public void addFuel() {
		System.out.printf("급속 충전");
	}
}

after : 상속 사용 후

class Vihicle {
	int curX, curY;
	
	public void reportPosition() {
		System.out.printf("현재 위치: (%d, %d)%n", curX, curY);
	}

	public void addFuel() {
		System.out.printf("연료가 필요");
	}
}

class DieselSUV extends Vihicle {
	public void addFuel() {
		System.out.printf("주유소에서 급유");
	}
}

class ElectricCar extends Vihicle {
	public void addFuel() {
		System.out.printf("급속 충전");
	}
}

main 메소드

public class VehicleTest {
	public static void main(String[] args) {
		Vehicle[] vehicles = { new DieselSUV(), new ElectricCar() };
		
		for(Vehicle v : vehicles) {
			v.addFuel();
			v.reportPosition();
		}
	}
}

그런데 여기서 부모 클래스 Vehicle의 addFuel의 메소드는 쓰이지 않고 있지 않습니다. 이처럼 구현할 필요가 없는 부모 클래스의 메소드는 추상화를 시켜두는 방법이 있습니다. 추상화는 abstract 키워드로 이루어집니다.

abstract class Vehicle {
	private int curX, curY;
	
	public void reportPosition() {
		System.out.printf("현재 위치: (%d, %d)%n", curX, curY);
	}

	public abstract void addFuel();
}

메소드의 선언부만 남기고 구현부는 세미콜론으로 대체합니다.
구현부가 없다는 의미로 abstract 키워드를 메소드 선언부에 추가해줍니다.
객체를 생성할 수 없는 클래스라는 의미로 클래스 선언부에 abstract를 추가합니다.
이런 형태를 abstract method design pattern이라고 합니다.

추상 클래스의 특징

abstract 클래스는 상속 전용의 클래스입니다.
클래스에 구현부가 없는 메소드가 있으므로 객체를 생성할 수 없습니다.
상위 클래스로서 자식을 참조하는 것은 가능합니다.

// Vehicle v = new Vehicle(); // abstract 클래스는 객체를 생성할 수 없음

Vehicle v = new DieselSUV(); // 자식을 참조하는 데는 문제 없음

조상 클래스에서 상속받은 abstract 메소드를 재정의하지 않은 경우 클래스 내부에 abstract 메소드가 있는 상황이므로 자식 클래스는 abstract 클래스로 선언되어야 합니다.

추상 클래스는 UML 상에서 이탤릭으로 표현합니다.

인터페이스 interface

인터페이스는 최고 수준의 추상화 단계입니다.

public interface MyInterface {
	public static final int MEMBER1 = 10;
	int MEMBER2 = 10;

	public abstract void method1 (int param);
	void method2 (int param);
}

클래스와 유사하게 Interface 선언을 합니다.
모든 멤버 변수는 public static final이며 생략 가능합니다.
모든 메소드는 public abstract이며 생략 가능합니다.

인터페이스 상속

클래스와 마찬가지로 인터페이스도 extends를 통해 상속이 가능하지만, 다른 점은 인터페이스는 다중 상속이 가능하다는 점입니다.

interface Fightable {
	int fire();
}

interface Transformable {
	void changeShape (boolean isHeroMode);
}

public interface Heroable extends Fightable, Transformable {
	void upgrade();
}

인터페이스 구현과 객체 참조

public class IronMan implements Heroable {
	int weaponDamage = 100;

  @Override
	public int fire() {
		System.out.printf("빔 발사: %d만큼의 데미지를 가함%n");
		return this.weaponDamage;
	}
	@Override
	public void changeShape(boolean isHeroMode) {
		String status = isHeroMode ? "장착" : "제거";
		System.out.printf("장갑 %s%n", status);
	}
	@Override
	public void upgrade() {
		System.out.printf("무기 성능 개선");
	}
}

인터페이스의 목적

인터페이스는 객체의 기능을 모두 공개한 표준화 문서와 같은 것으로, 개발자에게 인터페이스를 상속받는 클래스의 목적에 따라 인터페이스의 모든 추상 메소드를 만들도록 하는 것에 목적이 있습니다.

인터페이스의 static method

interface StaticMethodInterface {
	static void staticMethod() {
		System.out.println("Static 메소드");
	}
}

public class StaticMethodTest {
	public static void main(String[] args) {
		StaticMethodInterface.staticMethod();
	}
}

인터페이스의 static 메소드도 일반 static 메소드와 마찬가지로 별도의 객체가 필요 없습니다. 위와 같이 구현체 클래스 없이 바로 인터페이스 이름으로 메소드에 접근해서 사용이 가능합니다.

[Java] 상속(Inheritance)과 메소드 오버라이딩 vs 오버로딩

3o14 — Thu, 20 Jul 2023 09:30:18 +0900

자바의 상속과 메소드 오버라이딩(Overriding) vs 오버로딩(Overloading)

안녕하세요 오늘은 자바의 꽃 상속에 대해서 배워봤어요. 자바는 객체 지향 프로그래밍 언어로, 상속은 객체 지향 프로그래밍의 중요한 개념 중 하나입니다. 상속은 코드 재사용성과 유지 보수를 향상시키는 중요한 역할을 합니다. 이번 포스팅에서는 자바에서 상속의 개념과 이점에 대해 알아보고, 실제 예제 코드를 통해 상속을 적용하는 방법을 알아볼게요

상속(Inheritance)이란?

상속은 클래스가 다른 클래스의 특성과 동작을 물려받는 것을 의미합니다. 상속을 통해 기존 클래스의 코드를 재사용하여 새로운 클래스를 만들 수 있습니다. 이때 기존 클래스는 슈퍼 클래스 또는 부모 클래스라고 하며, 새로운 클래스는 서브 클래스 또는 자식 클래스라고 합니다.

상속의 장점

코드 재사용

기존의 클래스를 확장하여 새로운 클래스를 생성하므로 중복된 코드를 피하고 재사용성을 높일 수 있습니다.

유지 보수 용이성

공통적인 기능이 슈퍼 클래스에 있으므로 해당 기능을 수정해야 할 때 서브 클래스들도 자동으로 업데이트됩니다.

다형성

서브 클래스는 슈퍼 클래스의 타입으로 사용될 수 있으며, 이를 통해 유연하고 확장성 있는 프로그래밍이 가능합니다.

실습 코드

"동물" 클래스를 상속받아 "고양이" 클래스를 만드는 예제입니다.

javaCopy code
// 동물 클래스
class Animal {
    String name;

    Animal(String name) {
        this.name = name;
    }

    void makeSound() {
        System.out.println("동물이 소리를 내고 있습니다.");
    }
}

// 고양이 클래스, 동물 클래스를 상속받음
class Cat extends Animal {
    Cat(String name) {
        super(name);
    }

    // 동물 클래스의 makeSound() 메서드를 오버라이드(재정의)하여 고양이의 소리로 변경
    @Override
    void makeSound() {
        System.out.println(name + "가 야옹 소리를 내고 있습니다.");
    }

    void scratch() {
        System.out.println(name + "가 발톱을 강하게 세웠습니다.");
    }
}

public class Main {
    public static void main(String[] args) {
        // 고양이 객체 생성
        Cat cat = new Cat("야옹이");

        // 고양이 객체의 메서드 호출
        cat.makeSound(); // 출력: 야옹이가 야옹 소리를 내고 있습니다.
        cat.scratch();   // 출력: 야옹이가 발톱을 강하게 세웠습니다.
    }
}

위 예제에서 Animal 클래스는 name 필드와 makeSound() 메서드를 갖고 있습니다. Cat 클래스는 Animal 클래스를 상속받아 scratch() 메서드를 추가로 가지고 있습니다. Cat 클래스에서 makeSound() 메서드를 오버라이드하여 동물의 소리 대신 고양이의 소리로 출력되도록 변경했습니다.

슈퍼클래스와 서브클래스, extends

슈퍼 클래스 : 부모 클래스 (super class)
서브 클래스 : 상속받는 자식 클래스 (sub class)
extends : 상속을 선언할 때 확장한다는 의미로 사용하는 extends 키워드

상속 사용해보기

class Point {
	private int x, y; // 한 점을 구성하는 x, y 좌표
	public void set(int x, int y) {
		this.x = x; this.y = y;
	}
	
	public void showPoint() { // 점의 좌표 출력
		System.out.println("(" + x + ", " + y + ")");
	}
}

class ColorPoint extends Point { // Point를 상속받은 ColorPoint 선언
	private String color; // 점의 색

	public void setColor(String color) {
		this.color = color;
	}

	public void showColorPoint() { // 컬러 점의 좌표 출력
		System.out.println(color);
		showPoint(); // Point 클래스의 showPoint() 호출
	}
}

(x, y)의 한 점을 표현하는 Point 클래스와 이를 상속받아 색을 가진 점을 표현하는 ColorPoint 클래스를 만들고 활용해보는 코드입니다.

public class ColorPointEx {
	public static void main (String[] args) {
		Point p = new Point(); // Point 객체 생성
		p.set(1, 2); // Point 클래스의 set() 호출
		p.showPoint();

		ColorPoint cp = new ColorPoint(); // ColorPoint 객체 생성
		cp.set(3, 4); // Point 클래스의 set() 호출
		cp.setColor("red"); // ColorPoint 클래스의 setColor() 호출
		cp.showColorPoint(); // 컬러와 좌표 출력
	}
}

위와 같이 cp 객체를 구성하는 ColorPoint 클래스의 public 멤버와 슈퍼 클래스인 Point 클래스의 public 멤버를 모두 접근할 수 있습니다. 그러나 x, y, color 필드는 private 속성이므로 접근할 수 없습니다.

동적 바인딩 vs 정적 바인딩

동적 바인딩 : 오버라이딩된 메소드 호출

동적 바인딩(dynamic binding)은 실행할 때 메소드를 컴파일 시(compile time)에 결정하지 않고 실행 시(run time)에 결정하는 것을 말합니다. 자바에서는 동적 바인딩을 통해 오버라이딩된 메소드가 항상 실행되도록 보장합니다.

정적 바인딩 : super 키워드로 슈퍼클래스에 접근하기

자바에서는 동적 바인딩에 의해 항상 서브 클래스에 오버라이딩한 메소드가 호출됩니다. 그러면 슈퍼 클래스의 메소드에 접근하려면 어떻게 해야 할까요? 아래처럼 super 키워드를 이용하면 됩니다.

super.슈퍼클래스의멤버

슈퍼클래스에 대한 접근자 super

super는 자바 컴파일러에 의해 지원되는 것으로 슈퍼 클래스에 대한 레퍼런스입니다. super를 이용하면 슈퍼 클래스의 필드와 메소드에 모두 접근할 수 있습니다.

name = "Circle";        // Circle 클래스의 name에 "Circle" 기록
super.name = "Shape";   // Shape 클래스의 name에 "Shape" 기록
super.draw();           // Shape 클래스의 draw() 호출. 정적 바인딩

오버로딩(overloading)과 오버라이딩(overriding)

오버로딩과 오버라이딩은 자바에서 다형성을 이루는 방법입니다.

오버라이딩 Overriding

오버라이딩은 상위 클래스에서 정의된 메소드를 하위 클래스에서 재정의하는 것을 의미합니다.

javaCopy code
class Animal {
    public void makeSound() {
        System.out.println("Some generic sound");
    }
}

class Dog extends Animal {
    // Animal 클래스의 makeSound 메서드를 오버라이딩함
    @Override
    public void makeSound() {
        System.out.println("Bark! Bark!");
    }
}

class Cat extends Animal {
    // Animal 클래스의 makeSound 메서드를 오버라이딩함
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound(); // 출력 결과: "Bark! Bark!"
        animal2.makeSound(); // 출력 결과: "Meow!"
    }
}

오버로딩 Overloading

오버로딩은 같은 이름의 메소드를 매개변수의 타입이나 개수가 다른 형태로 여러 개 정의하는 것을 의미합니다.

public class Calculator {

    // 정수형 두 개를 더하는 메서드
    public int add(int a, int b) {
        return a + b;
    }

    // 실수형 두 개를 더하는 메서드
    public double add(double a, double b) {
        return a + b;
    }

    // 문자열을 이어붙이는 메서드
    public String add(String a, String b) {
        return a + b;
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        int sum1 = calculator.add(3, 5);
        double sum2 = calculator.add(2.5, 3.7);
        String result = calculator.add("Hello, ", "world!");

        System.out.println("Sum of integers: " + sum1);
        System.out.println("Sum of doubles: " + sum2);
        System.out.println("Concatenated string: " + result);
    }
}

요약

자바의 상속과 메소드 오버라이딩과 오버로딩은 객체 지향 프로그래밍의 중요한 개념들로서 코드의 재사용성과 유연성을 높이는 데 도움이 됩니다. 상속을 통해 코드를 재활용하고, 동적 바인딩을 통해 실행 시점에 메소드를 연결하는 다형성을 지원합니다. 정적 바인딩은 컴파일 시점에 메소드를 연결하며, 오버라이딩은 상위 클래스의 메소드를 하위 클래스에서 재정의하여 다형성을 구현합니다. 오버로딩은 같은 이름의 메소드를 매개변수의 타입이나 개수가 다른 형태로 정의하여 다양한 입력을 처리할 수 있습니다.