Devjo의 코딩

[Java] Baekjoon1976: 여행 가자

devyoseph — Thu, 24 Feb 2022 00:04:37 +0900

여행 가자

2 초

128 MB

19988

7720

5718

37.837%

문제

동혁이는 친구들과 함께 여행을 가려고 한다. 한국에는 도시가 N개 있고 임의의 두 도시 사이에 길이 있을 수도, 없을 수도 있다. 동혁이의 여행 일정이 주어졌을 때, 이 여행 경로가 가능한 것인지 알아보자. 물론 중간에 다른 도시를 경유해서 여행을 할 수도 있다. 예를 들어 도시가 5개 있고, A-B, B-C, A-D, B-D, E-A의 길이 있고, 동혁이의 여행 계획이 E C B C D 라면 E-A-B-C-B-C-B-D라는 여행경로를 통해 목적을 달성할 수 있다.

도시들의 개수와 도시들 간의 연결 여부가 주어져 있고, 동혁이의 여행 계획에 속한 도시들이 순서대로 주어졌을 때 가능한지 여부를 판별하는 프로그램을 작성하시오. 같은 도시를 여러 번 방문하는 것도 가능하다.

입력

첫 줄에 도시의 수 N이 주어진다. N은 200이하이다. 둘째 줄에 여행 계획에 속한 도시들의 수 M이 주어진다. M은 1000이하이다. 다음 N개의 줄에는 N개의 정수가 주어진다. i번째 줄의 j번째 수는 i번 도시와 j번 도시의 연결 정보를 의미한다. 1이면 연결된 것이고 0이면 연결이 되지 않은 것이다. A와 B가 연결되었으면 B와 A도 연결되어 있다. 마지막 줄에는 여행 계획이 주어진다. 도시의 번호는 1부터 N까지 차례대로 매겨져 있다.

출력

첫 줄에 가능하면 YES 불가능하면 NO를 출력한다.

풀이

연결관계만 알아보는 방법에는 크게 두가지가 있습니다.

DFS를 통해 재귀호출을 통한 방문체크 방식, 유니온 파인드를 이용한 합집합 방식

입력값이 많으므로 유니온 파인드 방식을 이용해 구현했습니다.

유니온 파인드 구현

1. find() 메소드 + union() 메서드

static int[] parents;

static int find(int a) { // 현재 집합의 대표값을 구해주는 메소드
    if(parents[a]==a) return a;

    parents[a] = find(parents[a]); //경로 압축 기능
    
    return parents[a]; //부모를 재귀적으로 호출
}

static void union(int a, int b) { // 두 집합을 합치는 메소드
    int aRoot = find(a); //원소 a가 속한 집합의 대표를 찾아서 저장
    int bRoot = find(b); //원소 b가 속한 집합의 대표를 찾아서 저장

    parents[aRoot] = bRoot; // 대표값의 부모만 변경
}

거의 암기 수준입니다. 유니온 파인드 구현에 필수인 두 메서드입니다.

2. 초기 집합 : 자기 자신이 대표인 각각의 집합 생성

유니온 파인드의 목적은 서로소인 집합을 빠르게 합치는 것입니다.

모든 원소를 먼저 집합의 개념으로 만들어주어야 하며 집합의 대표값을 생성해주면 곧 자기 자신이 대표인 집합이됩니다.

parents = new int[N]; // 원소 N개 존재

for(int i=1; i<N; i++) {
   parents[i] = i; // 자기 자신이 곧 대표 = 원소가 1개인 집합들 생성 
}

합치기

연결관계가 주어집니다.

0 1 0   // 0번 도시는 1번 도시와 연결
1 0 1	// 1번 도시는 0번 도시와 연결, 1번 도시는 2번 도시와 연결
0 1 0	// 2번 도시는 1번 도시와 연결

위와 같은 경우 연결관계를 주석과 같습니다.

union 메서드를 이용해 모조리 합쳐줍니다.

for (int i = 0; i < N; i++) {
   st = new StringTokenizer(br.readLine()); // 입력값을 라인마다 받아주고
   
   for (int j = 0; j < N; j++) {
       if(st.nextToken().equals("1")) { // 1, 즉 연결되어있으면
           union(i,j); // 두 원소가 포함된 집합을 서로 합쳐줌
       }
   }
   
}

결과 구하기

모든 도시를 방문하기 위해선 도시가 서로 연결되어있다는 뜻입니다.

이 말을 집합으로 가져오면 같은 집합 안에 포함된 도시라는 뜻입니다.

즉 각 원소가 가리키는 대표값이 같습니다.

제시된 도시 중 첫번째 도시의 대표값을 추출한 다음 이 대표값과 다른 도시의 대표값이 모두 같은지 확인합니다.

boolean judge = true; // 같은 도시인지 판별하는 불린 변수

st = new StringTokenizer(br.readLine());

int root = find(Integer.parseInt(st.nextToken())-1); // 제시된 처음 도시 대표값 추출

while(M-->1) {
   if(root!=find(Integer.parseInt(st.nextToken())-1)) { // 그 뒤의 도시들도 같은 대표인지 확인
       judge = false; // 다르다면? 서로 같은 집합이 아니므로 false
       break;
   }
}
System.out.println(judge?"YES":"NO");

전체코드

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

public class Main {
	static int[] parents;
	
	static int find(int a) {
		if(parents[a]==a) return a;
		
		parents[a] = find(parents[a]);
		return parents[a];
	}
	
	static void union(int a, int b) {
		int aRoot = find(a);
		int bRoot = find(b);
		
		parents[aRoot] = bRoot;
	}
	public static void main(String[] args) throws IOException {
	   BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	   StringTokenizer st;
	   int N = Integer.parseInt(br.readLine());
	   parents = new int[N];
	   for(int i=1; i<N; i++) {
		   parents[i] = i;
	   }
	   int M = Integer.parseInt(br.readLine());
	   
	   for (int i = 0; i < N; i++) {
		   st = new StringTokenizer(br.readLine());
		   for (int j = 0; j < N; j++) {
			   if(st.nextToken().equals("1")) {
				   union(i,j);
			   }
		   }
	   }
	   
	   boolean judge = true;
	   
	   st = new StringTokenizer(br.readLine());
	   
	   int root = find(Integer.parseInt(st.nextToken())-1);
	   
	   while(M-->1) {
		   if(root!=find(Integer.parseInt(st.nextToken())-1)) {
			   judge = false;
			   break;
		   }
	   }
	   System.out.println(judge?"YES":"NO");
	}   
}

[Java] Baekjoon4963: 섬의 개수

devyoseph — Wed, 23 Feb 2022 09:50:04 +0900

섬의 개수

1 초

128 MB

40870

20479

14687

49.051%

문제

정사각형으로 이루어져 있는 섬과 바다 지도가 주어진다. 섬의 개수를 세는 프로그램을 작성하시오.

한 정사각형과 가로, 세로 또는 대각선으로 연결되어 있는 사각형은 걸어갈 수 있는 사각형이다.

두 정사각형이 같은 섬에 있으려면, 한 정사각형에서 다른 정사각형으로 걸어서 갈 수 있는 경로가 있어야 한다. 지도는 바다로 둘러싸여 있으며, 지도 밖으로 나갈 수 없다.

입력

입력은 여러 개의 테스트 케이스로 이루어져 있다. 각 테스트 케이스의 첫째 줄에는 지도의 너비 w와 높이 h가 주어진다. w와 h는 50보다 작거나 같은 양의 정수이다.

둘째 줄부터 h개 줄에는 지도가 주어진다. 1은 땅, 0은 바다이다.

입력의 마지막 줄에는 0이 두 개 주어진다.

출력

각 테스트 케이스에 대해서, 섬의 개수를 출력한다.

풀이

서로의 포함관계를 구할 수 있는 알고리즘에는 DFS와 유니온 파인드가 있습니다.

원소가 많을수록 유니온 파인드가 유리하지만 배열의 크기가 50x50이므로 DFS로 빠르게 구현할 수 있다고 보았습니다.

지도 구현

땅 아니면 바다이므로 값은 2개로 나타낼 수 있습니다.

2차원 불린 배열을 통해 나타냅니다.

입력값

w h 순으로 주어지고 0 0을 입력 받는 순간 전체 종료합니다.

특이한 점은 너비 높이 = 열 / 행 으로 주어진다는 점입니다.

그래서 순서에 주의해서 반복문을 이용해 값을 넣어줍니다.

while(true) { 
    st = new StringTokenizer(br.readLine());
    int w = Integer.parseInt(st.nextToken());
    int h = Integer.parseInt(st.nextToken());

    if(w==0 && h==0) break;

    boolean[][] map = new boolean[h][w];

    for(int i=0; i<h; i++) { //행은 h
        st = new StringTokenizer(br.readLine());
        for(int j=0; j<w; j++) { // 열은 w 
            if(st.nextToken().equals("1")) {
                map[i][j] = true;
            }
        }
    }
}

DFS

영역 표시를 위해 섬에 포함된 땅 어느 부분을 밟는 순간 1을 세어주고

그와 동시에 연결된 모든 땅을 방문 표시함으로 조사했다라는 표시를 남깁니다.

지도를 재활용하지 않기 때문에 방문체크 배열을 만들지 않고 땅을 아예 false로 바꾸어(지워서) 바다로 만듭니다.

변경사항

검사하다 배열 밖으로 벗어날 수 있으므로 w,h 값을 메소드의 파라미터로 넣어주거나 정적변수로 할당합니다.

static int w,h,cnt; // main메소드 바깥 부분에 정적 변수로 할당하고 

static void dfs(int row, int col) { // 메소드 생성

}

구현

바깥 범위라면 현재 메소드를 종료하도록 하고 대각 방향까지 넣어줍니다.

	static int[] dx = {0,0,1,-1,1,-1,-1,1}; //8방좌표
	static int[] dy = {1,-1,0,0,1,-1,1,-1};
	
	static void dfs(int row, int col) {
		if(row<0 || row>=h || col<0 || col>=w || !map[row][col]) return;
        //경계값 조건 + 만약 밟은 곳이 바다라면 종료
        
		map[row][col] = false; //현재가 땅이라면 바다로 바꿈
		
		for(int i=0; i<8; i++) {
			dfs(row+dx[i],col+dy[i]);
		}
	}

카운트

한 번 땅을 밟는 순간 연결된 모든 구역을 바다로 만들면서 1을 카운트합니다.

전체 지도를 탐색하면서 이를 반복해줍니다.

전체 코드

import java.io.*;
import java.util.*;
public class Main {
	static int w,h,cnt;
	static boolean[][] map;
	
	static int[] dx = {0,0,1,-1,1,-1,-1,1}; //8방좌표
	static int[] dy = {1,-1,0,0,1,-1,1,-1};
	
	static void dfs(int row, int col) {
		if(row<0 || row>=h || col<0 || col>=w || !map[row][col]) return;
		
		map[row][col] = false;
		
		for(int i=0; i<8; i++) {
			dfs(row+dx[i],col+dy[i]);
		}
	}
	

public static void main(String[] args) throws IOException{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st;
	
	while(true) { 
		st = new StringTokenizer(br.readLine());
		w = Integer.parseInt(st.nextToken());
		h = Integer.parseInt(st.nextToken());
		cnt = 0;
		if(w==0 && h==0) break;
		
		map = new boolean[h][w];
		
		for(int i=0; i<h; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j=0; j<w; j++) {
				if(st.nextToken().equals("1")) {
					map[i][j] = true;
				}
			}
		}
		
		for(int i=0; i<h; i++) {
			for(int j=0; j<w; j++) {
				if(map[i][j]) {
					cnt++;
					dfs(i,j);
				}
			}
		}
		System.out.println(cnt);
	}

}
}

[Java] Baekjoon1717: 집합의 표현

devyoseph — Tue, 22 Feb 2022 13:39:54 +0900

집합의 표현

2 초

128 MB

54678

17296

10487

28.478%

문제

초기에 {0}, {1}, {2}, ... {n} 이 각각 n+1개의 집합을 이루고 있다. 여기에 합집합 연산과, 두 원소가 같은 집합에 포함되어 있는지를 확인하는 연산을 수행하려고 한다.

집합을 표현하는 프로그램을 작성하시오.

입력

첫째 줄에 n(1 ≤ n ≤ 1,000,000), m(1 ≤ m ≤ 100,000)이 주어진다. m은 입력으로 주어지는 연산의 개수이다. 다음 m개의 줄에는 각각의 연산이 주어진다. 합집합은 0 a b의 형태로 입력이 주어진다. 이는 a가 포함되어 있는 집합과, b가 포함되어 있는 집합을 합친다는 의미이다. 두 원소가 같은 집합에 포함되어 있는지를 확인하는 연산은 1 a b의 형태로 입력이 주어진다. 이는 a와 b가 같은 집합에 포함되어 있는지를 확인하는 연산이다. a와 b는 n 이하의 자연수 또는 0이며 같을 수도 있다.

출력

1로 시작하는 입력에 대해서 한 줄에 하나씩 YES/NO로 결과를 출력한다. (yes/no 를 출력해도 된다)

풀이

유니온 파인드를 이용한 풀이를 진행합니다.

각각의 집합의 대표를 자기 자신으로 설정해줍니다.

 n = Integer.parseInt(st.nextToken());
 int m = Integer.parseInt(st.nextToken());

 parents = new int[n+1];

 for(int i=0; i<n+1; i++) {
     parents[i] = i; //자기 자신이 대표
 }

해당 집합의 대표 찾기 메소드 생성

유니온 파인드의 핵심 메소드입니다.

1차원 배열에는 해당 원소의 부모가 들어있는데 부모를 연속적으로 호출해서 자기 자신이 부모가 되는 값까지 거슬러 오릅니다.(집합 대표)

static int find(int a) { //대표찾기
    if(parents[a]==a) return a; //자기 자신이 부모라면 = 곧 이 집합의 대표

    parents[a] = find(parents[a]); // 압축: 현재 원소 a를 대표 가지에 붙여줌
    return parents[a]; //대표를 찾아 반환
}

또한 부모를 찾아 오르면서 좌표압축을 해줄 수 있습니다. (현재 가지를 떼어내서 부모가지에 붙여줌)

합집합 메소드

현재 원소가 포함된 집합의 대표를 찾은 다음 한 집합 대표의 부모를 다른 집합 대표로 바꿔주면 서로 합쳐집니다.

이 때 find 메소드를 기반으로 대표 번호를 찾고

static void union(int a, int b) { //합치기
    int aRoot = find(a);
    int bRoot = find(b);
    if(aRoot == bRoot) return; //두 집합이 같은 경우 리턴

    parents[bRoot] = aRoot; // 다르면 한쪽에 합치기
}

서로 포함관계 확인하기

위 합집합 메소드만 안다면 거의 동일한 구성으로 확인할 수 있습니다.

static void isUnited(int a, int b) { //같으면 true

    int aRoot = find(a);
    int bRoot = find(b);

    if(aRoot == bRoot) {//두 집합이 같은 경우
        sb.append("YES"+"\n"); //스트링 빌더로 저장했습니다
        return;
    }

    sb.append("NO"+"\n");
}

전체코드

import java.io.*;
import java.util.*;
public class Main {
	
	static int n,parents[];
	static StringBuilder sb = new StringBuilder();
	
	static int find(int a) { //대표찾기
		if(parents[a]==a) return a;
		
		parents[a] = find(parents[a]); // 압축
		return parents[a];
	}
	
	static void isUnited(int a, int b) { //같으면 true
		
		int aRoot = find(a);
		int bRoot = find(b);
		
		if(aRoot == bRoot) {//두 집합이 같은 경우
			sb.append("YES"+"\n");
			return;
		}
		
		sb.append("NO"+"\n");
	}
	
	static void union(int a, int b) { //합치기
		int aRoot = find(a);
		int bRoot = find(b);
		if(aRoot == bRoot) return; //두 집합이 같은 경우 리턴
		
		parents[bRoot] = aRoot; // 다르면 한쪽에 합치기
	}
	
public static void main(String[] args) throws IOException{
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	StringTokenizer st;
	
	 st = new StringTokenizer(br.readLine());
	 n = Integer.parseInt(st.nextToken());
	 int m = Integer.parseInt(st.nextToken());
	 
	 parents = new int[n+1];
	 
	 for(int i=0; i<n+1; i++) {
		 parents[i] = i; //자기 자신이 대표
	 }
		 
	 while(m-->0) { //m개의 입력값 받아주기
		 st = new StringTokenizer(br.readLine());
		 int command = Integer.parseInt(st.nextToken());
		 int a = Integer.parseInt(st.nextToken());
		 int b = Integer.parseInt(st.nextToken());
		 
		 switch(command) { //0은 합집합, 1은 합집합 확인 연산
		 	case 0: union(a,b); break;
		 	case 1: isUnited(a, b); break;
		 }
	 }
		 
	 System.out.println(sb.toString());
}
}

[Python] Baekjoon1992: 쿼드트리

devyoseph — Thu, 17 Feb 2022 19:50:37 +0900

쿼드트리

2 초

128 MB

26291

16169

12685

60.909%

문제

흑백 영상을 압축하여 표현하는 데이터 구조로 쿼드 트리(Quad Tree)라는 방법이 있다. 흰 점을 나타내는 0과 검은 점을 나타내는 1로만 이루어진 영상(2차원 배열)에서 같은 숫자의 점들이 한 곳에 많이 몰려있으면, 쿼드 트리에서는 이를 압축하여 간단히 표현할 수 있다.

주어진 영상이 모두 0으로만 되어 있으면 압축 결과는 "0"이 되고, 모두 1로만 되어 있으면 압축 결과는 "1"이 된다. 만약 0과 1이 섞여 있으면 전체를 한 번에 나타내지를 못하고, 왼쪽 위, 오른쪽 위, 왼쪽 아래, 오른쪽 아래, 이렇게 4개의 영상으로 나누어 압축하게 되며, 이 4개의 영역을 압축한 결과를 차례대로 괄호 안에 묶어서 표현한다

위 그림에서 왼쪽의 영상은 오른쪽의 배열과 같이 숫자로 주어지며, 이 영상을 쿼드 트리 구조를 이용하여 압축하면 "(0(0011)(0(0111)01)1)"로 표현된다. N ×N 크기의 영상이 주어질 때, 이 영상을 압축한 결과를 출력하는 프로그램을 작성하시오.

입력

첫째 줄에는 영상의 크기를 나타내는 숫자 N 이 주어진다. N 은 언제나 2의 제곱수로 주어지며, 1 ≤ N ≤ 64의 범위를 가진다. 두 번째 줄부터는 길이 N의 문자열이 N개 들어온다. 각 문자열은 0 또는 1의 숫자로 이루어져 있으며, 영상의 각 점들을 나타낸다.

출력

영상을 압축한 결과를 출력한다.

풀이

색종이 문제와 비슷한 원리로 풀이할 수 있습니다.

차이점은 만약 현재 사각형이 4개로 쪼개지지 않는다면 그냥 숫자로 나타내지만

쪼개진다면 (소괄호)로 감싸주어야 한다는 것입니다.

입력값 받아주기

입력값은 그냥 문자열 그대로 받아서 리스트에 넣었습니다.

N = int(input())
lst = []

for i in range(N):
    lst.append(input()) # 문자열이 들어갑니다

메소드 구성

주어진 영상의 크기 N을 메소드의 인자로 넘겨줍니다. 매 재귀마다 현재 영상의 크기를 바로 알 수 있습니다.

1) 모두 같은 색인지 확인하기

현재 영상의 맨 왼쪽 위의 한 점을 추출해서 그 값을 저장합니다 (0이거나 1).

현재 영상의 탐색 시작점을 row, col이라고 했을 때 그 점을 기준으로 N크기만큼 탐색합니다.

처음의 추출한 값과 달라진다면 4갈래로 쪼개주어야합니다. 불린 변수를 하나 지정해서 값이 달라지면 값이 바뀌도록 합니다.

def dfs(row, col, N): # N은 영상의 크기
    global lst # 리스트의 정보를 가져옴

    S = lst[row][col] # 글자 추출
    
    judge = True # 하나라도 다른게 있다면 False로 바꿈
    
    L = '' //초기 문자열
    
    # 모두 같은 색인지 검사하는 부분
    for i in range(N):
        for j in range(N):
            if S != lst[row+i][col+j]:
                judge = False # 다르다면? False
                break

2) 소괄호 넣기

만약 4갈래로 나눌 필요가 없다면? 그냥 0이나 1을 출력하면 됩니다. (judge = True)

하지만 나눠야한다면 소괄호로 감싸주고 그 안에서 재귀를 호출합니다. (judge = False)

    if judge:
        L = S
    else:
        L = '('+dfs(row, col, N // 2)+dfs(row, col + N // 2, N // 2)+dfs(row + N // 2, col, N // 2)+dfs(row + N // 2, col + N//2, N // 2)+')'

전체 코드

def dfs(row, col, N): # L은 글자
    global lst

    S = lst[row][col] # 글자 추출
    judge = True
    L = ''
    # 모두 같은 색인지 검사하는 부분
    for i in range(N):
        for j in range(N):
            if S != lst[row+i][col+j]:
                judge = False
                break
    if judge:
        L = S
    else:
        L = '('+dfs(row, col, N // 2)+dfs(row, col + N // 2, N // 2)+dfs(row + N // 2, col, N // 2)+dfs(row + N // 2, col + N//2, N // 2)+')'

    return L

N = int(input())
lst = []

for i in range(N):
    lst.append(input()) # 문자열이 들어갑니다

print(dfs(0, 0, N))

[Java] Baekjoon1987: 알파벳

devyoseph — Thu, 17 Feb 2022 18:14:16 +0900

알파벳

2 초

256 MB

64557

20424

12535

29.011%

문제

세로 R칸, 가로 C칸으로 된 표 모양의 보드가 있다. 보드의 각 칸에는 대문자 알파벳이 하나씩 적혀 있고, 좌측 상단 칸 (1행 1열) 에는 말이 놓여 있다.

말은 상하좌우로 인접한 네 칸 중의 한 칸으로 이동할 수 있는데, 새로 이동한 칸에 적혀 있는 알파벳은 지금까지 지나온 모든 칸에 적혀 있는 알파벳과는 달라야 한다. 즉, 같은 알파벳이 적힌 칸을 두 번 지날 수 없다.

좌측 상단에서 시작해서, 말이 최대한 몇 칸을 지날 수 있는지를 구하는 프로그램을 작성하시오. 말이 지나는 칸은 좌측 상단의 칸도 포함된다.

입력

첫째 줄에 R과 C가 빈칸을 사이에 두고 주어진다. (1 ≤ R,C ≤ 20) 둘째 줄부터 R개의 줄에 걸쳐서 보드에 적혀 있는 C개의 대문자 알파벳들이 빈칸 없이 주어진다.

출력

첫째 줄에 말이 지날 수 있는 최대의 칸 수를 출력한다.

풀이

말은 (1,1)부터 움직이고 지금까지 지나온 모든 알파벳과는 다른 알파벳을 밟을 수 있다고 합니다.

움직일 수 있는 최대값을 구해야합니다.

방문 체크 배열

알파벳을 인덱싱 해야합니다. A는 0으로 B는 1로... Z는 25로 나타낼 것입니다.

java의 형변환을 통해 대문자를 아스키코드로 변환할 수 있습니다.

int idx = (int)'A'%65; // 0 = A의 번호를 0으로 시작하기 위해서 65로 나눈 나머지를 구합니다
int idx = (int)'Z'%65; // 25

백트래킹

가지치기를 통해 이미 경계값을 벗어나거나 방문한 곳이라면 바로 종료시킵니다.

만약 가지치기를 통과했다면 방문해도 된다는 뜻이므로 방문체크를 해주고 다음 재귀로 진행합니다.

나왔을 때 방문해제를 해줍니다.

static void dfs(int row,int col,int cnt) {
		if(row<0 || row >= R || col<0 || col>=C || v[(int)arr[row][col]%65]) {
			return;
		} // 가지치기를 이용해 경계값을 벗어나면 종료시키고 이미 방문한 곳이라도 종료시킵니다.
		
		
		v[(int)arr[row][col]%65] = true; //방문체크
		
		// 다음 재귀호출
		
		v[(int)arr[row][col]%65] = false; //방문해제
	}

이동

일일히 쓸 수 있지만 반복문을 이용해 코드를 단순화했습니다.

static int[] dx = {0,0,1,-1}; //반복문으로 돌리기 위한 방향 배열입니다
static int[] dy = {1,-1,0,0};

for(int i=0; i<4; i++) {
	dfs(row+dx[i],col+dy[i],cnt); // 다음 재귀 호출
}

전체코드

package workplace;
import java.util.*;

public class Main {
	/** 알파벳을 숫자 표현 = 아스키 코드를 65로 나눈 나머지로 표현했습니다 */
	
	static int R,C,MAX=0; //변수들을 dfs 메소드에서 사용합니다
	static boolean[] v; //방문체크 배열
	static char arr[][]; //알파벳을 기록할 배열입니다
	static int[] dx = {0,0,1,-1}; //반복문으로 돌리기 위한 방향 배열입니다
	static int[] dy = {1,-1,0,0};
	
	static void dfs(int row,int col,int cnt) {
		if(row<0 || row >= R || col<0 || col>=C || v[(int)arr[row][col]%65]) {
			return;
		} // 가지치기를 이용해 경계값을 벗어나면 종료시키고 이미 방문한 곳이라도 종료시킵니다.
		
		cnt += 1; // 방문을 확정합니다. 현재까지 움직인 거리(cnt)에 1을 더합니다
		v[(int)arr[row][col]%65] = true; //방문체크
		
		MAX = Math.max(MAX, cnt); //최대값을 갱신합니다
		
		for(int i=0; i<4; i++) {
			dfs(row+dx[i],col+dy[i],cnt);
		}
		
		v[(int)arr[row][col]%65] = false; //방문해제
	}
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		R = sc.nextInt();
		C = sc.nextInt();
		v = new boolean[26]; //방문 체크 배열: 알파벳 체크
		arr = new char[R][C];
		
		for(int i=0; i<R; i++) {
			String s = sc.next();
			for(int j=0; j<C; j++) {
				arr[i][j] = s.charAt(j);
			}
		}
		
		dfs(0,0,0); // (1, 1)부터 시작이지만 배열 상으론 (0, 0) 입니다
		System.out.println(MAX);
	}
}

[Python] Baekjoon2630: 색종이 만들기

devyoseph — Thu, 17 Feb 2022 17:29:19 +0900

색종이 만들기

1 초

128 MB

18801

12673

10423

69.556%

문제

아래 <그림 1>과 같이 여러개의 정사각형칸들로 이루어진 정사각형 모양의 종이가 주어져 있고, 각 정사각형들은 하얀색으로 칠해져 있거나 파란색으로 칠해져 있다. 주어진 종이를 일정한 규칙에 따라 잘라서 다양한 크기를 가진 정사각형 모양의 하얀색 또는 파란색 색종이를 만들려고 한다.

전체 종이의 크기가 N×N(N=2k, k는 1 이상 7 이하의 자연수) 이라면 종이를 자르는 규칙은 다음과 같다.

전체 종이가 모두 같은 색으로 칠해져 있지 않으면 가로와 세로로 중간 부분을 잘라서 <그림 2>의 I, II, III, IV와 같이 똑같은 크기의 네 개의 N/2 × N/2색종이로 나눈다. 나누어진 종이 I, II, III, IV 각각에 대해서도 앞에서와 마찬가지로 모두 같은 색으로 칠해져 있지 않으면 같은 방법으로 똑같은 크기의 네 개의 색종이로 나눈다. 이와 같은 과정을 잘라진 종이가 모두 하얀색 또는 모두 파란색으로 칠해져 있거나, 하나의 정사각형 칸이 되어 더 이상 자를 수 없을 때까지 반복한다.

위와 같은 규칙에 따라 잘랐을 때 <그림 3>은 <그림 1>의 종이를 처음 나눈 후의 상태를, <그림 4>는 두 번째 나눈 후의 상태를, <그림 5>는 최종적으로 만들어진 다양한 크기의 9장의 하얀색 색종이와 7장의 파란색 색종이를 보여주고 있다.

입력으로 주어진 종이의 한 변의 길이 N과 각 정사각형칸의 색(하얀색 또는 파란색)이 주어질 때 잘라진 하얀색 색종이와 파란색 색종이의 개수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에는 전체 종이의 한 변의 길이 N이 주어져 있다. N은 2, 4, 8, 16, 32, 64, 128 중 하나이다. 색종이의 각 가로줄의 정사각형칸들의 색이 윗줄부터 차례로 둘째 줄부터 마지막 줄까지 주어진다. 하얀색으로 칠해진 칸은 0, 파란색으로 칠해진 칸은 1로 주어지며, 각 숫자 사이에는 빈칸이 하나씩 있다.

출력

첫째 줄에는 잘라진 햐얀색 색종이의 개수를 출력하고, 둘째 줄에는 파란색 색종이의 개수를 출력한다.

풀이

사각형 검사

현재 사각형을 기준으로 맨 왼쪽, 위 원소를 추출합니다. 그 원소를 기준으로 이제 비교를 시작합니다.

만약 첫번째 원소랑 달리지는 순간? 반복문을 멈추고 4방향으로 쪼갭니다.

사각형 방향 통과

반복문 끝에 다다른 경우 사각형을 더 이상 쪼개지 않고 첫번째 원소가 0인지 1인지 확인합니다.

첫번째 원소가 0이라면 하얀색 색종이에 +1, 첫번째 원소가 1이라면 파란색 색종이에 +1 합니다.

전체코드1

def dfs(row,col,n):
    global N,lst,white,blue

    first = lst[row][col]

    judge = True # 일단 색종이가 전부 같은 색이라고 가정

    # 모두 같은 색인지 검사하는 부분
    for i in range(row,row+n):
        for j in range(col,col+n):
            if lst[i][j] != first:
                judge = False   # 하나라도 다른 색이 있다면
                break           # 반복문 종료
        if not judge:
            break

    if not judge:
        dfs(row, col, int(n/2))  # 1 번째
        dfs(row, col + int(n/2),int(n/2))  # 2 번째
        dfs(row + int(n/2), col, int(n/2))  # 3 번째
        dfs(row + int(n/2), col + int(n/2), int(n/2))  # 4 번째
    else:
        if first: # first가 1이었을 때
            blue += 1
        else:
            white += 1


N = int(input())
white = blue = 0
lst = []

for i in range(N):
    lst.append(list(map(int,input().split())))

dfs(0,0,N)

print(white)
print(blue)

코드가 너무 자바 느낌이 나서 Pythonic하게 수정해봤습니다.

전체코드2

중간에 false를 통해 빠져나오는 것과 사각형 내부 원소 모두의 합을 구해서 판단하는 것의 효율이 비슷했습니다.

모두의 합이 0이라면 내부 사각형의 원소들은 모두 0이라는 뜻이며

모두의 합이 nxn이라면 모두의 합이 1로 파악할 수 있습니다.

def dfs(row, col, n):
    global N, lst, white, blue

    S = 0

    # 모두 같은 색인지 검사하는 부분
    for i in range(n):
        for j in range(n):
            S += lst[row+i][col+j]

    if S == 0:
        white += 1
    elif S == n * n:
        blue += 1
    else:
        dfs(row, col, n // 2)  # 1 번째
        dfs(row, col + n // 2, n // 2)  # 2 번째
        dfs(row + n // 2, col, n // 2)  # 3 번째
        dfs(row + n // 2, col + n // 2, n // 2)  # 4 번째


N = int(input())
white = blue = 0
lst = []

for i in range(N):
    lst.append(list(map(int, input().split())))

dfs(0, 0, N)

print(white)
print(blue)

[Java] Baekjoon14696: 딱지놀이

devyoseph — Thu, 17 Feb 2022 13:11:01 +0900

딱지놀이

2 초

512 MB

4594

2720

2177

63.193%

문제

두 어린이 A, B가 딱지놀이를 한다. 딱지놀이 규칙은 다음과 같다. 두 어린이는 처음에 여러 장의 딱지를 가지고 있고, 매 라운드마다 각자 자신이 가진 딱지 중 하나를 낸다. 딱지에는 별(★), 동그라미(●), 네모(■), 세모(▲), 네 가지 모양 중 하나 이상의 모양이 표시되어 있다. 두 어린이가 낸 딱지 중 어느 쪽이 더 강력한 것인지는 다음 규칙을 따른다.

만약 두 딱지의 별의 개수가 다르다면, 별이 많은 쪽의 딱지가 이긴다.
별의 개수가 같고 동그라미의 개수가 다르다면, 동그라미가 많은 쪽의 딱지가 이긴다.
별, 동그라미의 개수가 각각 같고 네모의 개수가 다르다면, 네모가 많은 쪽의 딱지가 이긴다.
별, 동그라미, 네모의 개수가 각각 같고 세모의 개수가 다르다면, 세모가 많은 쪽의 딱지가 이긴다.
별, 동그라미, 네모, 세모의 개수가 각각 모두 같다면 무승부이다.

예를 들어, 두 어린이 A, B가 낸 딱지가 다음 그림과 같다고 하자.

위 규칙을 따르면 A의 딱지는 별 하나를 가지고 있고 B의 딱지는 별이 없으므로 승자는 A이다. 위의 그림이 라운드 1의 상황이었고, 라운드 2, 3, 4, 5의 상황이 아래 표와 같을 때, 라운드 2, 3, 4의 승자는 각각 B, B, A이며, 라운드 5에서는 무승부가 되어 이를 D로 표현하였다.

라운드A의 딱지B의 딱지결과

1	★	●●■▲	A
2	■★●■▲	★●●▲	B
3	●■▲▲	■●■▲	B
4	★●■▲	★●■	A
5	★★■●▲	★■★▲●	D

별, 동그라미, 네모, 세모를 각각 숫자 4, 3, 2, 1로 표현한다. 예를 들어, 라운드 1의 경우 어린이 A가 낸 딱지의 그림 ★는 4로 표현할 수 있고, 어린이 B가 낸 딱지의 그림 ●●■▲는 3 3 2 1 로 표현할 수 있다.

라운드의 수 N과 두 어린이가 순서대로 내는 딱지의 정보가 주어졌을 때, 각 라운드별로 딱지놀이의 결과를 구하는 프로그램을 작성하시오.

입력

표준 입력으로 다음 정보가 주어진다. 첫 번째 줄에는 딱지놀이의 총 라운드 수를 나타내는 자연수 N이 주어진다. N 은 1 이상 1,000 이하이다. 다음 줄에는 라운드 1에서 어린이 A가 내는 딱지에 나온 그림의 총 개수 a가 주어진다. a는 1 이상 100 이하이다. 뒤따라 나오는 a개의 정수는 어린이 A가 낸 딱지의 그림을 나타내는데, 각각 4, 3, 2, 1 중 하나의 값이다. 4, 3, 2, 1의 순서대로 주어지지 않을 수 있음에 주의하라. 다음 줄에는 라운드 1에서 어린이 B가 내는 딱지에 나온 그림의 총 개수 b가 주어진다. b도 1 이상 100 이하이다. 뒤따라 나오는 b개의 정수는 어린이 B가 낸 딱지의 그림을 나타내는데, 역시 4, 3, 2, 1 중 하나의 값이다. 역시 4, 3, 2, 1의 순서대로 주어지지 않을 수 있음에 주의하라. 다음 두 줄에는 라운드 2에서 어린이 A, B가 낸 딱지의 그림들을 같은 식으로 표현한다. 위와 같은 식으로 매 라운드마다 두 어린이가 낸 딱지의 정보는 두 줄에 표현되며, N 라운드의 딱지 정보는 차례대로 총 2N 개의 줄에 주어진다.

출력

표준 출력으로 총 N 줄을 출력한다. 출력의 i번째 (1 ≤ i ≤ N) 줄에 정확히 한 글자를 출력하는데, 출력하는 글자는 A, B, D 중 하나로 라운드 i의 결과를 나타낸다. 각 라운드의 결과는 A가 승자라면 A, B가 승자라면 B, 무승부라면 D이다.

풀이

별 > 동그라미 > 네모 > 세모 순으로 승리를 판단합니다.

문제상 숫자로는 4 > 3 > 2 > 1 순으로 승리를 판단합니다.

카운팅 배열 사용

모양들을 모두 숫자로 나타내지만 순서가 뒤죽박죽이므로 1부터 4를 입력할 수 있도록 5크기의 배열을 만듭니다.

int[] A = new int[5];
int[] B = new int[5];

그리고 모양들을 입력받을 때마다 여기에 기록해줍니다.

비교

별이 4부터 시작하므로 배열의 끝부터 서로 비교합니다. 4 > 3 > 2 > 1

승부가 결정되면 반복문을 종료합니다.

만약 반복문이 끝나도록 승부가 나지 않으면 D를 출력합니다.

전체코드

import java.util.*;

public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		while(N-->0) {
			int[] A = new int[5];
			int[] B = new int[5]; //카운팅 배열
			char result = 'D';
			
			int num = sc.nextInt();
			while(num-->0) {
				A[sc.nextInt()]++;
			}
			
			num = sc.nextInt();
			while(num-->0) {
				B[sc.nextInt()]++;
			}
			
			for(int i=4; i>=0; i--) {
				if(A[i]>B[i]) {
					result = 'A';
					i = -1; //반복문 종료
				}else if(A[i]<B[i]) {
					result = 'B';
					i = -1;
				}
			}
			System.out.println(result);
		}
	}
}

[Java] Baekjoon2851: 슈퍼 마리오

devyoseph — Thu, 17 Feb 2022 12:51:52 +0900

슈퍼 마리오

1 초

128 MB

11633

4578

4047

40.010%

문제

슈퍼 마리오 앞에 10개의 버섯이 일렬로 놓여져 있다. 이 버섯을 먹으면 점수를 받는다.

슈퍼 마리오는 버섯을 처음부터 나온 순서대로 집으려고 한다. 하지만, 모든 버섯을 집을 필요는 없고 중간에 중단할 수 있다. 중간에 버섯을 먹는 것을 중단했다면, 그 이후에 나온 버섯은 모두 먹을 수 없다. 따라서 첫 버섯을 먹지 않았다면, 그 이후 버섯도 모두 먹을 수 없다.

마리오는 받은 점수의 합을 최대한 100에 가깝게 만들려고 한다.

버섯의 점수가 주어졌을 때, 마리오가 받는 점수를 출력하는 프로그램을 작성하시오.

입력

총 10개의 줄에 각각의 버섯의 점수가 주어진다. 이 값은 100보다 작거나 같은 양의 정수이다. 버섯이 나온 순서대로 점수가 주어진다.

출력

첫째 줄에 마리오가 받는 점수를 출력한다. 만약 100에 가까운 수가 2개라면 (예: 98, 102) 마리오는 큰 값을 선택한다.

풀이

인덱스 내부에서 100이 넘을 때까지 더하고 이전값과 현재값을 비교해 100과의 차이가 더 적은 수를 반환합니다.

100을 기준으로 100보다 작은 값, 큰 값 구하기

구하는 값이 두 개므로 변수를 두 개 사용해야합니다.

한 변수는 100을 넘기 전까지의 합을 기록해야하고 한 변수는 100을 넘었을 때의 합을 기록해야합니다.

100을 처음 넘었을 때 그 값을 구한 다음 다시 그 값에서 더해줬던 값을 빼서 100을 넘기 전의 값을 구할 수 있습니다.

이 두개를 비교해 100에 가장 가까운 수를 고르고 출력하면 됩니다.

이 풀이에서는 위 방법과 조금은 다르게 이전항에 현재항을 대입하고 현재항에 값을 더하는 식으로 구현했습니다.

전체 코드

import java.util.*;

public class Main {
	public static void main(String[] args){
		Scanner sc = new Scanner(System.in);
		int prev=0,now=0;
        
		for(int i=0; i<10; i++) { //10개의 입력값
			prev = now; //현재 now 값을 이전값 prev에 저장합니다
            
			now += sc.nextInt(); //그리고 now에 다음 값을 더합니다
            
			if(now>=100) { // now가 100을 넘기는 순간: prev에는 100보다 작은 값, now에는 100보다 큰 값이 저장
				i=10; //반복문을 종료합니다.
			}
		}
		if(now-100<=Math.abs(100-prev)) { // 그 둘을 비교하고 100과의 차이가 적은 수를 내보냅니다
			System.out.println(now);
		}else {
			System.out.println(prev);
		}
	}
}

[Java] SW4012: 요리사

devyoseph — Wed, 16 Feb 2022 14:30:33 +0900

시간 : 50개 테스트케이스를 합쳐서 C의 경우 5초 / C++의 경우 5초 / Java의 경우 5초 / Python의 경우 10초
메모리 : 힙, 정적 메모리 합쳐서 256MB 이내, 스택 메모리 1MB 이내

두 명의 손님에게 음식을 제공하려고 한다.

두 명의 손님은 식성이 비슷하기 때문에, 최대한 비슷한 맛의 음식을 만들어 내야 한다.

N개의 식재료가 있다.

식재료들을 각각 N / 2개씩 나누어 두 개의 요리를 하려고 한다. (N은 짝수이다.)

이때, 각각의 음식을 A음식, B음식이라고 하자.

비슷한 맛의 음식을 만들기 위해서는 A음식과 B음식의 맛의 차이가 최소가 되도록 재료를 배분해야 한다.

음식의 맛은 음식을 구성하는 식재료들의 조합에 따라 다르게 된다.

식재료 i는 식재료 j와 같이 요리하게 되면 궁합이 잘 맞아 시너지 Sij가 발생한다. (1 ≤ i ≤ N, 1 ≤ j ≤ N, i ≠ j)

각 음식의 맛은 음식을 구성하는 식재료들로부터 발생하는 시너지 Sij들의 합이다.

식재료 i를 식재료 j와 같이 요리하게 되면 발생하는 시너지 Sij의 정보가 주어지고, 가지고 있는 식재료를 이용해 A음식과 B음식을 만들 때, 두 음식 간의 맛의 차이가 최소가 되는 경우를 찾고 그 최솟값을 정답으로 출력하는 프로그램을 작성하라.

[예시]

N = 4인 예를 생각해보자. 시너지 Sij는 [Table 1]과 같이 주어진다.

(세로축으로 i번째 위치에 있고 가로축으로 j번째 위치에 있는 값이 Sij이다.)

[Table 1]

식재료 1과 식재료 2를 A음식으로 만들고 식재료 3과 식재료 4를 B음식으로 만드는 경우를 생각하자.

1) 식재료 1을 식재료 2와 같이 요리했을 때 발생하는 시너지 S12는 5이다.

2) 식재료 2를 식재료 1과 같이 요리했을 때 발생하는 시너지 S21는 4이다.

3) A음식의 맛은 5 + 4 = 9가 된다.

4) 식재료 3을 식재료 4와 같이 요리했을 때 발생하는 시너지 S34는 3이다.

5) 식재료 4를 식재료 3과 같이 요리했을 때 발생하는 시너지 S43은 3이다.

6) B음식의 맛은 3 + 3 = 6이 된다.

따라서, 두 음식 간의 맛의 차이는 |9 – 6| = 3이 된다.

식재료 2와 식재료 4를 A음식으로 만들고 식재료 1과 식재료 3을 B음식으로 만드는 경우를 생각하자.

7) 식재료 2를 식재료 4와 같이 요리했을 때 발생하는 시너지 S24는 1이다.

8) 식재료 4를 식재료 2와 같이 요리했을 때 발생하는 시너지 S42는 2이다.

9) A음식의 전력은 1 + 2 = 3이 된다.

10) 식재료 1을 식재료 3과 같이 요리했을 때 발생하는 시너지 S13은 3이다.

11) 식재료 3과 식재료 1을 같이 요리했을 때 발생하는 시너지 S31은 2이다.

12) B음식의 맛은 3 + 2 = 5가 된다.

따라서, 두 음식간의 맛의 차이는 |3 – 5| = 2가 된다.

이 경우가 A음식과 B음식 간의 맛의 차이가 최소인 경우이다.

다른 경우에서는 맛의 차이가 2보다 작을 수 없다.

따라서, 본 예의 정답은 2가 된다.

[제약사항]

1. 시간 제한 : 최대 50개 테스트 케이스를 모두 통과하는 데 C / C++ / Java 모두 3초

2. 식재료의 수 N은 4이상 16이하의 짝수이다. (4 ≤ N ≤ 16)

3. 시너지 Sij는 1이상 20,000이하의 정수이다. (1 ≤ Sij ≤ 20,000, i ≠ j)

4. i와 j가 서로 같은 경우의 Sij값은 정의되지 않는다. 입력에서는 0으로 주어진다.

[입력]

입력의 맨 첫 줄에는 총 테스트 케이스의 개수 T가 주어지고,

그 다음 줄부터 T개의 테스트 케이스가 주어진다.

각 테스트 케이스의 첫 번째 줄에는 식재료의 수 N이 주어진다.

다음 N개의 줄에는 N * N개의 시너지 Sij값들이 주어진다. i와 j가 서로 같은 경우는 0으로 주어진다.

[출력]

테스트 케이스 개수만큼 T개의 줄에 각각의 테스트 케이스에 대한 답을 출력한다.

각 줄은 "#t"로 시작하고 공백을 하나 둔 다음 정답을 출력한다. (t 는 1부터 시작하는 테스트 케이스의 번호이다.)

정답은 두 음식 간의 맛의 차이가 최소가 되도록 A음식과 B음식을 만들었을 때 그 차이 값이다.

[풀이]

N을 입력 받으면 먼저 배열을 만들어서 시너지들을 입력해주어야 합니다. = arr[N][N]

그리고 N/2 만큼 선택해서 시너지를 계산하고 나머지 N/2만큼 선택해 시너지를 계산해서 둘을 비교합니다.

부분집합

dfs를 이용해 부분집합을 생성합니다. 대신 제한조건으로 집합의 크기가 N/2가 되는 집합들만 사용합니다. 그 외에는 계산 처리하지 않습니다.

방문체크

이 풀이방법의 핵심은 방문체크라고 생각합니다. 방문했다면 체크해주고 빠져나올 때 체크를 해지해주면서 현재 누가 체크됐는지 바로 파악할 수 있고 이 정보를 이용해 부분집합의 크기가 N/2가 되는 순간 바로 시너지를 구할 수 있습니다.

시너지 구하기

많은 방법이 있지만 저는 최대한 코드를 단순화하고 싶어서 방문체크 배열의 길이를 N이라고 했을 때

N 중의 하나의 원소를 선택한 뒤 다시 그 N 안에서 다른 원소를 선택하는 이중 반복문을 사용했습니다.

    	for(int i=0; i<N; i++) {
    		for(int j=0; j<N; j++) {
    			if(v[i]!=v[j] || i==j) continue; // 서로 다른 팀이거나 같은 번호일 때 넘어가기
    			
    			if(v[i]) { //동일한 팀이고 true면 A팀
    				A += arr[i][j];
    			}else if(!v[i]) {
    				B += arr[i][j];
    			}
    		}
    	}

전체 코드

import java.util.*;

public class Solution {
    static int N, MIN;
    static int arr[][];
    static boolean[] v; // 방문체크
    
    static void calS() {
    	int A = 0;
    	int B = 0;
    	
    	for(int i=0; i<N; i++) {
    		for(int j=0; j<N; j++) {
    			if(v[i]!=v[j] || i==j) continue;
    			
    			if(v[i]) { //동일한 팀이고 true면 A팀
    				A += arr[i][j];
    			}else if(!v[i]) {
    				B += arr[i][j];
    			}
    		}
    	}
    	MIN = Math.min(MIN, Math.abs(A-B));
    }
    
    static void dfs(int depth, int cnt) {
    	if(cnt>N/2) { //절반 이상 뽑으면 탈락
    		return;
    	} else if(cnt==N/2) {
    		
    			calS();
    		
    		return;
    		
    	} else if(depth==N) {
    		return;
    	}
    	
    	
    	v[depth] = true;
    	dfs(depth+1,cnt+1);
    	v[depth] = false;
    	dfs(depth+1, cnt);
    }
public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);
        int T = sc.nextInt();
        
        for(int t=1; t<=T; t++) {
        	MIN = Integer.MAX_VALUE;
	        N = sc.nextInt(); // 음식의 개수
	        v = new boolean[N];
	        arr = new int[N][N]; // 시너지를 저장할 배열
	        
	        for(int i=0; i<N ; i++) { //시너지 입력 넣어주기
	        	for(int j=0; j<N; j++) {
	        		arr[i][j]= sc.nextInt();
	        	}
	        }
	        
	        dfs(0,0);
	        
	        System.out.println("#"+t+" "+MIN);
        }
	}
}

[Java] Baekjoon11723: 집합, 비트마스킹 구현

devyoseph — Wed, 16 Feb 2022 11:10:20 +0900

집합

1.5 초

4 MB (하단 참고)

46300

14373

10103

29.682%

문제

비어있는 공집합 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 연산이 주어질때마다, 결과를 출력한다.

풀이

부분집합을 비트마스크로 나타낼 수 있습니다.

2의 20승이면 1048576 로 정수형의 범위를 벗어나지 않습니다.

SHIFT 연산은 기본입니다.

OR 연산( | ) 을 이용한 원소추가 [ add ]

x 번째 원소를 추가하기 위해서는 1을 왼쪽으로 x만큼 Shift 연산한 값과 OR 연산합니다.

101110 : 현재 부분집합의 상태 -> 4번째 원소가 비어있는데 추가하고 싶다면?

010000 : 1<<4 인 값과 OR 연산

111110

AND 연산으로 값 체크 [ check ]

1<<x 를 한 값과 원래 S와 AND 연산하고 만약 그 값이 0이 아니라면?

S에서도 x원소가 있다는 뜻이므로 1을 출력합니다. 만약 0이라면 없는 것이므로 0을 출력합니다.

AND 연산( & ) 을 이용한 원소제거 [ remove ]

x 번째 원소를 제거하기 위해서는 그 부분의 1만 없애주어야합니다.

하나만 제거하기 위해서는 &연산을 이용해야하는데 만약 1<<x 를 하게 되면 1000000의 모습입니다.

and 연산한다면 뒤 0에 의해 값들이 모두 변경되기 때문에 비트를 뒤집어줍니다.

01111111 이런 모습으로 만든다음 and 연산한다면?

0부분이 있는 쪽만 0으로 바뀌고 나머지는 1로 무사할 것입니다.

XOR 연산( ^ ) 을 이용한 원소토글 [ toggle ]

XOR의 성질을 이해해야합니다.

원래 원소가 1일 때 0으로 바꾸기 위해서는? 1과 XOR 연산하면 됩니다.

원래 원소가 0일 때 1로 바꾸기 위해서는? 1과 XOR 연산하면 됩니다.

즉 원래 원소가 1이든 0이든 1과 XOR 연산하면 그 반대가 나옵니다.

그와 반대로 원소가 무엇이든 0과 XOR 연산하면 그대로 나옵니다.

이 성질을 이용해 1<<x 값과 XOR연산을 수행합니다.

NOT 연산을 이용한 모든 원소 추가 [ all ]

원소가 하나도 없는 상태는 0으로 표현합니다.

모든 원소가 있도록 하려면 0을 뒤집습니다.

S = ~0

전체 코드

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


public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		StringBuilder sb = new StringBuilder();
		int M = Integer.parseInt(br.readLine());
		int S = 0;
		while(M-->0) {
			st = new StringTokenizer(br.readLine());
			
			switch(st.nextToken()){
				case "add": // OR 연산으로 추가합니다
					S |= 1<<Integer.parseInt(st.nextToken());
					break;
				case "remove": // 비트를 뒤집고 AND 연산
					S &= ~(1<<Integer.parseInt(st.nextToken()));
					break;
				case "check": // AND 연산으로 확인
					sb.append((S & 1<<Integer.parseInt(st.nextToken()))!=0?1:0).append("\n");
					break;
				case "toggle": // 원래 원소가 1이든 0이든 1과 XOR 연산하면 그 반대가 나옵니다.
					S ^= 1<<Integer.parseInt(st.nextToken());
					break;
				case "all":
					S |= ~0;
					break;
				case "empty": S = 0; break;
			}
		}
		System.out.println(sb.toString());
	}
}