Social Developer

블로그 이전

SDev — Tue, 17 Sep 2024 21:18:22 +0900

얼마전 휴대폰 번호도 바꾸고, 카카오 계정도 변경한 뒤 문제가 생겼는데

블로그 계정이 기존 카카오 계정에 귀속되어 있다는 것이다.

문의 결과 같은 명의의 다른 카카오 계정으로 블로그를 넘기지도 못해서, 아깝지만 이참에 블로그도 바꿔보려고 한다.

바뀌는 블로그는 https://honey-berry.tistory.com/

honeyberry 님의 기술 블로그

honeyberry 님의 기술 블로그 입니다.

honey-berry.tistory.com

앞으로 다시 꾸준히 해보자!

linux/unix 환경에서 disk filesystem 조회하기

SDev — Mon, 19 Feb 2024 17:11:57 +0900

$ df -h
Filesystem       Size   Used  Avail Capacity iused     ifree %iused  Mounted on

-t 옵션은 human readable의 약자로, 읽기 쉽게 출력하도록 하는 옵션이다.

Filesystem: 파일 시스템의 이름 또는 식별자.
Size: 파일 시스템의 총 크기.
Used: 파일 시스템에서 사용 중인 공간의 크기.
Avail: 파일 시스템에서 사용 가능한 공간의 크기.
Use%: 사용 중인 공간의 비율.
Mounted on: 파일 시스템이 마운트된 디렉토리 또는 위치.

[BOJ] 10869번 Golang 풀이

SDev — Mon, 13 Dec 2021 23:59:48 +0900

Golang에 보다 익숙해지기 위해 Golang으로 가벼운 알고리즘 문제들의 풀이를 시작한다.

먼저 답안 소스는 아래와 같다.

package main

import (
	"fmt"
)

func main() {
	var a, b int
	fmt.Scanln(&a, &b)

	fmt.Println(a + b)
	fmt.Println(a - b)
	fmt.Println(a * b)
	fmt.Println(a / b)
	fmt.Println(a % b)
}

간단한 문제이지만 여기서 확인할만한 점은 golang의 int 자료형의 범위, fmt.scanln 함수 정도일 것 같다.

golang에서는 int8, int32, int64, uint8... 등 숫자와 관련된 다양한 자료형이 있는데 여기서 사용한 int의 크기는 시스템에 따라 결정된다. 이 문제에서는 a, b가 모두 10,000보다 같거나 작으므로 곱해도 1억 이하의 수다. 32비트 시스템에서 동작되더라도 범위를 벗어날 일은 없다.

Golang에서의 숫자 관련 자료형 확인하기 : http://pyrasis.com/book/GoForTheReallyImpatient/Unit08

다음으로 fmt.scanln 함수를 살펴본다.

Golang은 공식 사이트에서 각종 패키지에 대한 설명이 잘 나와있다.

(https://pkg.go.dev/fmt#Scanln)

설명에 잘 나와있듯 Scan 함수와 유사하면서 개행문자를 만났을 때, 마지막 item 이후의 개행 혹은 EOF(End of File)일 때 Scan을 멈춘다.

(EOF : 컴퓨팅에서 더이상 읽어올 데이터가 없음)

[Elasticsearch] Elasticsearch는 멀티테넌시?

SDev — Tue, 6 Jul 2021 23:55:39 +0900

최근 2021 멋쟁이사자처럼 세렝게티 올빼미 프로젝트에서 카카오엔터프라이즈와 k8s 과정을 하면서 Metric Monitoring & Logging 기술 중 Elasticsearch를 알아보고 있다.

Elasticsearch의 특징 중 하나가 멀티테넌시(Multi-tenancy)라는데, 이 개념에 대해 전혀 몰랐기 때문에 기술을 익히면서 찾아보고 지나갔는데 시간이 지나고 다시 봤을 때 기억이 나지 않아 여기 정리해두려고 한다.

멀티테넌시(Multi-tenancy)

tenancy의 뜻을 찾아보면, '(주택, 토지 등의)차용[임차/소작]'으로 소개되어 있다. 쉽게 말해 빌려 쓴다는 뜻이다. 멀티테넌시를 구글링해보면 단일테넌시와 구분지어 설명되어 있는 글을 쉽게 볼 수 있다.

단일 테넌시는 하나의 소프트웨어나 인스턴스가 하나의 사용자 혹은 사용자그룹을 위해 작동하는 아키텍처,

멀티테넌시는 하나의 소프트웨어나 인스턴스가 여러 사용자 혹은 사용자그룹을 위해 작동하는 아키텍처라고 한다.

쉽게 예를 들면, 웹메일 서비스로 생각해볼 수 있다. 웹메일 서비스는 멀티테넌시 구조로 동작하고 있다. 많은 사람들이 크게 하나의 웹메일 서비스(gmail, naver...)를 이용해 메일을 주고받고 있다. 하지만 여기서 중요한 것은 여러 사용자 및 사용자 그룹이 사용하더라도 각각이 독립적으로 이용한다는 사실이다. 모든 사용자의 메일 데이터는 각 메일 서비스 제공 기업에서 관리하지만, 사용자는 나를 제외한 다른 사람들의 메일 자료에 접근할 수 없고 마치 나만을 위한 서비스처럼 느껴진다.

만약 멀티테넌시가 아닌 단일테넌시라면 어땠을까? 단일 사용자 및 그룹을 위해 작동하는 아키텍처라는 점에서 모든 사용자가 각 메일 프로그램을 다운로드하고, 각 기기에서 설치한 뒤 각자의 기기 내에서 메일 데이터를 보관하고 사용하며 심지어 노트북에서 받은 메일은 스마트폰에서 읽을 수 없을 수도 있다.

멀티테넌시 아키텍처의 장점

비용 절감

소프트웨어를 지탱하는 하드웨어 측면에서 바라보면 규모의 경제로 인해 자원 구축 비용 절감, IT 리소스를 유연하게 할당할 수 있는 유연성을 포함해 새로운 버전이 나와도 장비 쪽 소프트웨어만 업데이트하면 모든 사용자가 새로운 기능을 사용할 수 있어 관리 비용도 크게 절감할 수 있다. 크게 최근 많이 사용되고 있는 클라우드 서비스와 맥락을 같이한다.

편리한 데이터 통합

하나의 시스템과 소프트웨어를 여러 사용자가 공유하는 구조이므로 사용자별 데이터가 사실상 같은 저장소에 저장된다. 결과적으로 대규모 데이터를 모을 수 있고, 분석하는 작업도 더 편리해진다. 최근 분석에 대한 수요가 커지고, 데이터의 양도 급속도로 거대해지면서 더 두드러지고 있다.

멀티테넌시 아키텍처의 단점

개인화를 지원하기 위한 정교한 아키텍처 구현

개인화를 지원하기 위해 그만큼 더 정교한 아키텍처 설계가 필요하다. 자칫 소프트웨어나 인스턴스 하나의 장애가 수많은 사용자 및 사용자그룹에게 모두 피해를 입힐 수 있고, 일부 사용자를 위한 업데이트가 또 다른 사용자에게는 오히려 불편함을 유발할 수도 있다.

보안

구조적으로 사용자별로 완전히 구분되어 있는 것처럼 보이지만, 실상은 단일 저장소에 여러 사용자 및 사용자그룹의 데이터가 보관되어 있다. 따라서 각 단위의 데이터가 서로 섞이지 않도록 해야 하고, 몸집이 커지는 만큼 해킹 위협에 대해서도 그만한 보안 체계를 갖춰야만 한다.

멀티테넌시 용어의 다양한 쓰임

지금까지 일반적인 소프트웨어 관점에서의 멀티테넌시 구조를 살펴봤는데, 쿠버네티스와 같은 컨테이너 오케스트레이션 플랫폼에서 멀티테넌시라는 용어는 또 조금 다르게 쓰인다. 소프트웨어 관점에서 tenancy 대상인 tenant(사용자)는 사용자, 사용자 그룹이지만, 컨테이너 오케스트레이션 플랫폼에서는 프로젝트 단위가 tenancy이기 때문이다. 즉 컨테이너 오케스트레이션 플랫폼에서 멀티테넌시라는 용어는 대개 여러개의 프로젝트를 서비스하는 단일 클러스터를 의미하고, 이 클러스터는 서로 분리 실행하도록 설정되어 있다.

그리고, 다시 Elasticsearch로 돌아가보자. Elasticsearch는 왜 멀티테넌시 구조인가?

Elasticsearch는 여러 개의 분리된 인덱스(Indecies)를 그룹으로 저장한다. 인덱스는 관계형 DB에서 데이터베이스와 대응되는 개념이다. 관계형 DB에서 다른 데이터베이스의 데이터를 검색하려면 별도의 커넥션을 생성해야하는데, Elasticsearch에서는 서로 다른 인덱스의 데이터를 하나의 쿼리로 묶어서 검색하고 하나의 출력으로 모아줄 수 있다. 이 때문에 Elasticsearch를 멀티테넌시 구조라고 소개하는 것이다.

참고 자료

ITWorld용어풀이| 멀티테넌시(Multitenancy) - https://www.itworld.co.kr/news/101255
RedHat, 클라우드컴퓨팅 멀티테넌시란? - https://www.redhat.com/ko/topics/cloud-computing/what-is-multitenancy
ElasticSearch(6.1.1) 알아보기 - https://chuckolet.tistory.com/47

[BOJ] 5373번 큐빙 Java 풀이

SDev — Sat, 26 Jun 2021 08:23:37 +0900

하루동안 7시간에 걸쳐 문제를 풀었다. 문제 출력으로는 큐브의 윗 면만 출력하면 되는데, 히든 케이스를 위해 디버깅하는 과정에서 전체 큐브의 변화를 체크하지 않으면 디버깅이 더 어렵기 때문에 다른 면의 움직임까지 찍어보면서 문제를 풀었다.

전반적인 문제 풀이 방법은 직접 큐브의 한 번의 회전 움직임을 모두 직접 지정해두는 방식으로 해결했다. 이전에 주사위 굴리기(14499번) 문제와 약간 유사했던 것 같은데, 다른 방식으로 해결할 수도 있는지는 아직 모르겠다. 내 경우에는 문제 풀이 접근을 찾았더라도 직접 코드를 작성하는 시간과 디버깅에 쓴 시간이 매우 길었기 때문에 더 좋은 풀이가 있지 않을까..

내 풀이에서 독특한 점은 큐브를 3차원 배열로 저장하지 않고, 2차원 배열로 저장했다는 점이다. 아래와 같이 큐브의 한 면 내에서 인덱스를 0~8까지 지정해 생성하고 관리해주는 것이다.

0	1	2
3	4	5
6	7	8

풀이 접근도 접근이지만, 디버깅이 매우 어렵다. 내 경우에는 직접 큐브 회전을 시뮬레이션할 수 있는 웹사이트를 찾아 이를 디버깅에 활용했다.

https://rubiks-cube-solver.com/fr/

Programme de résolution Rubik's Cube

Le programme de résolution Rubik's Cube en ligne calcule les étapes nécessaires pour résoudre un Rubik's Cube mélangé. Entrez les couleurs de votre puzzle, cliquez sur Résoudre

rubiks-cube-solver.com

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

public class Main {
	static int cases;
	static char[][] cube = new char[6][9];

	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
		
		cases = Integer.parseInt(br.readLine());
		for(int k = 0; k < cases; k++) {
			init();
			int operNum = Integer.parseInt(br.readLine());
			String[] opers = new String[operNum];
			st = new StringTokenizer(br.readLine());
			
			for(int i = 0; i < operNum; i++) {
				opers[i] = st.nextToken();
				rotate(opers[i]);
			}
			printUp();
		}
	}
	
	public static void rotate(String oper) {
		char[][] temp = copy();
		int index = -1;
		
		if(oper.charAt(0) == 'U') {
			index = 0;
		}else if(oper.charAt(0) == 'D') {
			index = 1;
		}else if(oper.charAt(0) == 'F') {
			index = 2;
		}else if(oper.charAt(0) == 'B') {
			index = 3;
		}else if(oper.charAt(0) == 'L') {
			index = 4;
		}else if(oper.charAt(0) == 'R') {
			index = 5;
		}
		
		if(oper.charAt(1) == '+') {
			// 돌린 면의 숫자 재배치
			cube[index][0] = temp[index][6]; cube[index][1] = temp[index][3]; cube[index][2] = temp[index][0];
			cube[index][3] = temp[index][7]; cube[index][4] = temp[index][4]; cube[index][5] = temp[index][1];
			cube[index][6] = temp[index][8]; cube[index][7] = temp[index][5]; cube[index][8] = temp[index][2];
			if(oper.charAt(0) == 'U') {
				cube[2][0] = temp[5][0]; cube[2][1] = temp[5][1]; cube[2][2] = temp[5][2];
				cube[4][0] = temp[2][0]; cube[4][1] = temp[2][1]; cube[4][2] = temp[2][2];
				cube[3][0] = temp[4][0]; cube[3][1] = temp[4][1]; cube[3][2] = temp[4][2];
				cube[5][0] = temp[3][0]; cube[5][1] = temp[3][1]; cube[5][2] = temp[3][2];
			}else if(oper.charAt(0) == 'D') {
				cube[5][6] = temp[2][6]; cube[5][7] = temp[2][7]; cube[5][8] = temp[2][8];
				cube[3][6] = temp[5][6]; cube[3][7] = temp[5][7]; cube[3][8] = temp[5][8];
				cube[4][6] = temp[3][6]; cube[4][7] = temp[3][7]; cube[4][8] = temp[3][8];
				cube[2][6] = temp[4][6]; cube[2][7] = temp[4][7]; cube[2][8] = temp[4][8];
			}else if(oper.charAt(0) == 'F') {
				cube[5][0] = temp[0][6]; cube[5][3] = temp[0][7]; cube[5][6] = temp[0][8];
				cube[1][2] = temp[5][0]; cube[1][1] = temp[5][3]; cube[1][0] = temp[5][6];
				cube[4][2] = temp[1][0]; cube[4][5] = temp[1][1]; cube[4][8] = temp[1][2];
				cube[0][8] = temp[4][2]; cube[0][7] = temp[4][5]; cube[0][6] = temp[4][8];
			}else if(oper.charAt(0) == 'B') {
				cube[4][6] = temp[0][0]; cube[4][3] = temp[0][1]; cube[4][0] = temp[0][2];
				cube[1][6] = temp[4][0]; cube[1][7] = temp[4][3]; cube[1][8] = temp[4][6];
				cube[5][8] = temp[1][6]; cube[5][5] = temp[1][7]; cube[5][2] = temp[1][8];
				cube[0][0] = temp[5][2]; cube[0][1] = temp[5][5]; cube[0][2] = temp[5][8];
			}else if(oper.charAt(0) == 'L') {
				cube[2][0] = temp[0][0]; cube[2][3] = temp[0][3]; cube[2][6] = temp[0][6];
				cube[1][0] = temp[2][0]; cube[1][3] = temp[2][3]; cube[1][6] = temp[2][6];
				cube[3][8] = temp[1][0]; cube[3][5] = temp[1][3]; cube[3][2] = temp[1][6];
				cube[0][6] = temp[3][2]; cube[0][3] = temp[3][5]; cube[0][0] = temp[3][8];
			}else if(oper.charAt(0) == 'R') {
				cube[3][6] = temp[0][2]; cube[3][3] = temp[0][5]; cube[3][0] = temp[0][8];
				cube[1][8] = temp[3][0]; cube[1][5] = temp[3][3]; cube[1][2] = temp[3][6];
				cube[2][2] = temp[1][2]; cube[2][5] = temp[1][5]; cube[2][8] = temp[1][8];
				cube[0][2] = temp[2][2]; cube[0][5] = temp[2][5]; cube[0][8] = temp[2][8];
			}
		}else if(oper.charAt(1) == '-') {
			// 돌린 면의 숫자 재배치
			cube[index][0] = temp[index][2]; cube[index][1] = temp[index][5]; cube[index][2] = temp[index][8];
			cube[index][3] = temp[index][1]; cube[index][4] = temp[index][4]; cube[index][5] = temp[index][7];
			cube[index][6] = temp[index][0]; cube[index][7] = temp[index][3]; cube[index][8] = temp[index][6];
			if(oper.charAt(0) == 'U') {
				cube[5][0] = temp[2][0]; cube[5][1] = temp[2][1]; cube[5][2] = temp[2][2];
				cube[2][0] = temp[4][0]; cube[2][1] = temp[4][1]; cube[2][2] = temp[4][2];
				cube[4][0] = temp[3][0]; cube[4][1] = temp[3][1]; cube[4][2] = temp[3][2];
				cube[3][0] = temp[5][0]; cube[3][1] = temp[5][1]; cube[3][2] = temp[5][2];
			}else if(oper.charAt(0) == 'D') {
				cube[2][6] = temp[5][6]; cube[2][7] = temp[5][7]; cube[2][8] = temp[5][8];
				cube[5][6] = temp[3][6]; cube[5][7] = temp[3][7]; cube[5][8] = temp[3][8];
				cube[3][6] = temp[4][6]; cube[3][7] = temp[4][7]; cube[3][8] = temp[4][8];
				cube[4][6] = temp[2][6]; cube[4][7] = temp[2][7]; cube[4][8] = temp[2][8];
			}else if(oper.charAt(0) == 'F') {
				cube[4][8] = temp[0][6]; cube[4][5] = temp[0][7]; cube[4][2] = temp[0][8];
				cube[1][0] = temp[4][2]; cube[1][1] = temp[4][5]; cube[1][2] = temp[4][8];
				cube[5][6] = temp[1][0]; cube[5][3] = temp[1][1]; cube[5][0] = temp[1][2];
				cube[0][6] = temp[5][0]; cube[0][7] = temp[5][3]; cube[0][8] = temp[5][6];
			}else if(oper.charAt(0) == 'B') {
				cube[5][2] = temp[0][0]; cube[5][5] = temp[0][1]; cube[5][8] = temp[0][2];
				cube[1][8] = temp[5][2]; cube[1][7] = temp[5][5]; cube[1][6] = temp[5][8];
				cube[4][0] = temp[1][6]; cube[4][3] = temp[1][7]; cube[4][6] = temp[1][8];
				cube[0][2] = temp[4][0]; cube[0][1] = temp[4][3]; cube[0][0] = temp[4][6];
			}else if(oper.charAt(0) == 'L') {
				cube[0][0] = temp[2][0]; cube[0][3] = temp[2][3]; cube[0][6] = temp[2][6];
				cube[3][8] = temp[0][0]; cube[3][5] = temp[0][3]; cube[3][2] = temp[0][6];
				cube[1][6] = temp[3][2]; cube[1][3] = temp[3][5]; cube[1][0] = temp[3][8];
				cube[2][0] = temp[1][0]; cube[2][3] = temp[1][3]; cube[2][6] = temp[1][6];
			}else if(oper.charAt(0) == 'R') {
				cube[2][2] = temp[0][2]; cube[2][5] = temp[0][5]; cube[2][8] = temp[0][8];
				cube[1][2] = temp[2][2]; cube[1][5] = temp[2][5]; cube[1][8] = temp[2][8];
				cube[3][6] = temp[1][2]; cube[3][3] = temp[1][5]; cube[3][0] = temp[1][8];
				cube[0][8] = temp[3][0]; cube[0][5] = temp[3][3]; cube[0][2] = temp[3][6];
			}
		}
	}
	
	// 초기 cube의 각 면에 지정된 색을 칠해주는 메서드
	public static void init() {
		char color = '-';
		for(int k = 0; k < 6; k++) {
			if(k == 0) color = 'w';
			else if(k == 1) color = 'y';
			else if(k == 2) color = 'r';
			else if(k == 3) color = 'o';
			else if(k == 4) color = 'g';
			else if(k == 5) color = 'b';
			for(int i = 0; i < 9; i++) {
				cube[k][i] = color;
			}
		}
	}
	// cube 배열 복사본을 생성해 반환하는 메서드
	public static char[][] copy(){
		char[][] temp = new char[6][9];
		for(int k = 0; k < 6; k++) {
			for(int i = 0; i < 9; i++) {
				temp[k][i] = cube[k][i];
			}
		}
		return temp;
	}
	
	public static void printUp() {
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < 3; i++) {
			sb.append(cube[0][i * 3]);
			sb.append(cube[0][i * 3 + 1]);
			sb.append(cube[0][i * 3 + 2]);
			if(i != 2) {
				sb.append("\n");
			}
		}
		System.out.println(sb.toString());
	}
	
	// test를 위해 cube의 모든 면을 출력하는 메서드
	public static void print() {
		String name = "";
		for(int k = 0; k < 6; k++) {
			if(k == 0) name = "윗면";
			else if(k == 1) name = "아랫면";
			else if(k == 2) name = "앞면";
			else if(k == 3) name = "뒷면";
			else if(k == 4) name = "왼쪽면";
			else if(k == 5) name = "오른쪽면";
			System.out.println(name);
			System.out.println(Arrays.toString(cube[k]));
			System.out.println();
		}
	}
}

[BOJ] 15686번 치킨 배달 Java 풀이

SDev — Sat, 26 Jun 2021 08:11:15 +0900

문제를 처음 풀었을 때는 시간 초과를 받고, 풀이를 약간 변형해서 통과했다.

첫 번째 풀이 DFS - 시간초과

    public static void dfs(int cnt) {
		// 치킨집을 m개 오픈한 경우 도시의 치킨거리 계산
		if(cnt == m) {
			int cityDist = calculate();
			answer = Math.min(answer, cityDist);
		}
		
		// m개 미만 오픈한 경우 오픈
		for(int i = 0; i < n; i++) {
			for(int j = 0; j < n; j++) {
				if(board[i][j] == 2 && !isOpened[i][j]) {
					// 오픈해서 dfs 호출 
					isOpened[i][j] = true;
					chickens.add(new Info(i, j, 2));
					dfs(cnt + 1);
					// 호출 후 원상복구
					isOpened[i][j] = false;
					chickens.remove(chickens.size() - 1);
				}
			}
		}
	} // end of dfs

첫 번째 풀이에서는 전체 지도(board)의 0행 0열부터 차례대로 찾으며 열려있지 않은 치킨집을 오픈시킨다. 백트래킹 방식으로 동작하기 때문에 같은 조합의 치킨집을 오픈하더라도, 아래와 같은 케이스들이 모두 별개로 취급되어 치킨거리를 계산하게 된다.

(1, 2), (3, 4), (4, 5)
(1, 2), (4, 5), (3, 4)
(4, 5), (1, 2), (3, 4)
(3, 4), (1, 2), (4, 5)
(4, 5), (3, 4), (1, 2)
(3, 4), (4, 5), (1, 2)

만약 (1, 2), (3, 4), (4, 5) 3개의 위치에 치킨집을 오픈한다고 했을 때, 위 6가지 케이스들은 모두 같은 치킨거리를 갖게 되지만 모두 따로 계산되어 각각 치킨거리를 탐색하게 된다. 치킨집의 최대 갯수가 13개인데 위와 같이 자리를 모두 바꾼다면? 13! = 약 60억으로 시간초과가 날 수 밖에 없다.

이런 문제를 두 번째 문제에서 스택을 활용해 해결한다.

두 번째 풀이 DFS - 성공

    public static void dfs(int start, int cnt) {
		// 치킨집을 m개 오픈한 경우 도시의 치킨거리 계산
		if(cnt == m) {
			int cityDist = calculate();
			answer = Math.min(answer, cityDist);
		}
		
		// m개 미만 오픈한 경우 오픈
		for(int i = start; i < chickens.size(); i++) {
			Info now = chickens.get(i);
			// 오픈해서 dfs 호출
			selected.push(now);
			dfs(i + 1, cnt + 1);
			// 호출 후 원상복구
			selected.pop();
		}
	} // end of dfs

이제는 치킨집의 위치를 지도에서 꺼내지 않고, chickens라는 List에서 꺼내온다. 리스트에 미리 치킨집이 들어올 수 있는 위치들을 저장해놓고, 리스트의 인덱스를 dfs 메서드의 인자로 주고받으면서 어디부터 오픈할지를 저장해둔다.

그리고, selected를 Stack으로 두면서 전체 경우의 수를 한 번씩만 탐색하도록 한다. 지도를 처음부터 선택하도록 하는 것이 아닌 인자를 하나 추가하고 다른 자료구조를 사용하는 방식으로 시간복잡도를 매우 개선할 뿐만 아니라 코드 라인 수도 줄이고 풀이도 훨씬 간결해졌다.

두 번째 풀이 전체 코드

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Stack;
import java.util.StringTokenizer;

public class Main {
	static int n, m, answer;
	static int[][] board;
	static List<Info> houses = new ArrayList<>();
	static List<Info> chickens = new ArrayList<>();
	static Stack<Info> selected = new Stack<>();
	
	
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		n = Integer.parseInt(st.nextToken());
		m = Integer.parseInt(st.nextToken());
		board = new int[n][n];
		answer = Integer.MAX_VALUE;
		
		for(int i = 0; i < n; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j = 0; j < n; j++) {
				board[i][j] = Integer.parseInt(st.nextToken());
				// 집이면 리스트에 추가해놓음
				if(board[i][j] == 1) {
					houses.add(new Info(i, j, 1));
				}else if(board[i][j] == 2) {
					chickens.add(new Info(i, j, 2));
				}
			}
		}
		dfs(0, 0);
		System.out.println(answer);
	}
	
	public static void dfs(int start, int cnt) {
		// 치킨집을 m개 오픈한 경우 도시의 치킨거리 계산
		if(cnt == m) {
			int cityDist = calculate();
			answer = Math.min(answer, cityDist);
		}
		
		// m개 미만 오픈한 경우 오픈
		for(int i = start; i < chickens.size(); i++) {
			Info now = chickens.get(i);
			// 오픈해서 dfs 호출
			selected.push(now);
			dfs(i + 1, cnt + 1);
			// 호출 후 원상복구
			selected.pop();
		}
	} // end of dfs
	
	public static int calculate() {
		int cityMinDist = 0;
		// 집을 하나씩 골라
		for(int i = 0; i < houses.size(); i++) {
			Info nowHouse = houses.get(i);
			int minDist = Integer.MAX_VALUE;
			// 치킨집마다 거리를 계산하고 최소 치킨거리 갱신 가능하면 갱신
			for(int j = 0; j < selected.size(); j++) {
				Info nowChicken = selected.get(j);
				// 현재 집과 치킨집 거리 계산
				int dist = Math.abs(nowHouse.row - nowChicken.row) 
						+ Math.abs(nowHouse.col - nowChicken.col);
				// 최소 치킨거리 갱신 가능하면 갱신
				minDist = Math.min(dist, minDist);
			}
			// 현재 집에서 가장 가까운 치킨거리를 도시 치킨거리에 반영
			cityMinDist += minDist;
		}
		return cityMinDist;
	}
	

}
class Info{
	int row, col;
	int type;
	public Info(int row, int col, int type) {
		this.row = row;
		this.col = col;
		this.type = type;
	}
	@Override
	public String toString() {
		return "Info [row=" + row + ", col=" + col + ", type=" + type + "]";
	}
}

[BOJ] 15684번 사다리 조작 Java 풀이

SDev — Sat, 26 Jun 2021 07:40:18 +0900

DFS로 구현하다가 막혀, 다른 분의 풀이 소스를 참고했다. DFS 백트래킹으로 최솟값을 찾는 문제를 접근하면 반드시 끝까지 탐색하면서 최솟값을 갱신할 수 있으면 갱신하는 방식으로만 풀이가 가능하다고 생각했다. 그런데 모든 문제에 적용할 수는 없겠지만, 이 문제에서는 DFS를 약간 변형하는 방법으로 효율적으로 풀이를 하는 방법이 있었다.

참고: https://leveloper.tistory.com/96

풀이 구성

void dfs(int x, int count): 가로선을 놓은 개수(count), 가로선을 놓을 지 말지 탐색할 높이(x)를 기준으로 재귀적으로 가로선을 놓고 다음 함수를 호출한 뒤, 다시 가로선을 제거하는 메서드

boolean check(): 모든 세로선이 주어진 조건을 만족하는지 판별해주는 boolean 반환 메서드

int[][] map: 사다리 정보 가진 2차원 배열, 1이면 오른쪽 방향 사다리를 둔 상태이고 2이면 왼쪽 방향으로 사다리를 둔 상태로 저장

boolean finish: 현재 map을 기반으로 주어진 조건 만족하는지를 나타내는 플래그 변수

전체 코드

import java.io.BufferedReader; 
import java.io.InputStreamReader; 
import java.util.StringTokenizer; 
public class Main { 
	private static int n, m, h, answer; 
	private static int[][] map; 
	private static boolean finish = false; 
	
	public static void main(String[] args) throws Exception {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
		StringTokenizer st = new StringTokenizer(br.readLine()); 
		n = Integer.parseInt(st.nextToken()); 
		m = Integer.parseInt(st.nextToken()); 
		h = Integer.parseInt(st.nextToken()); 
		map = new int[h + 1][n + 1]; 
		
		for (int i = 0; i < m; i++) { 
			int x, y;
			st = new StringTokenizer(br.readLine()); 
			x = Integer.parseInt(st.nextToken()); 
			y = Integer.parseInt(st.nextToken());
			// 1이면 오른쪽 방향 사다리, 2이면 왼쪽 방향 사다리
			map[x][y] = 1; 
			map[x][y + 1] = 2;
		} 
		
		// 사다리를 놓아보고 성공한다면 바로 break, 안되면 3번까지
		for (int i = 0; i <= 3; i++) { 
			answer = i; 
			dfs(1, 0); 
			if (finish) break;
		} 
		
		System.out.println((finish) ? answer : -1);
	} 
	
	private static void dfs(int x, int count) {
		// 답을 찾았다면 더이상 연산하지 않음
		if (finish) return; 
		
		// 0 ~ 3번째 사다리를 놓은 상태에서
		if (answer == count) { 
			// 모든 세로선이 조건을 만족한다면 종료
			if (check()) finish = true; 
			return;
		} 
		// 높이 depth를 1부터 h까지
		for (int i = x; i < h + 1; i++) {
			// 1번부터 마지막 전 세로선까지
			for (int j = 1; j < n; j++) {
				// 우측으로 가로선이 존재하지 않으면
				if (map[i][j] == 0 && map[i][j + 1] == 0) {
					// 가로선을 놓는다
					map[i][j] = 1; 
					map[i][j + 1] = 2;
					// 가로선을 놓은 상태에서 dfs 호출
					dfs(i, count + 1); 
					// 다시 가로선 제거
					map[i][j] = map[i][j + 1] = 0;
				}
			}
		} 
	} 
	
	// 모든 세로선이 조건을 만족하는지 판별해주는 boolean 반환 메서드 
	private static boolean check() { 
		// i: 세로선
		// y: 움직이는 위치에서의 column
		for (int i = 1; i <= n; i++) { 
			int x = 1, y = i;
			// j: 높이
			// x: h번 하강하는 과정에서의 depth
			for (int j = 0; j < h; j++) {
				// 1이면 오른쪽 이동
				if (map[x][y] == 1) y++;
				// 2이면 왼쪽 이동
				else if (map[x][y] == 2) y--;
				// 1만큼 내려감
				x++; 
			} 
			// 출발 세로선 인덱스와 도착한 세로선 인덱스가 다르면 false
			if (y != i) return false; 
		} 
		// 모든 세로선의 출발 세로선 인덱스와 도착한 세로선 인덱스가 같은 경우 true
		return true; 
	} 
}

[BOJ] 15683번 감시 Java 풀이

SDev — Sat, 19 Jun 2021 14:14:10 +0900

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

public class Main {
	static int n, m, blindSpot = 0;
	static int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
	static List<int[]> list = new ArrayList<>();
	static int[][] stat= {
			{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1},
			{1, 0, 1, 0}, {0, 1, 0, 1}, {1, 1, 0, 0}, {0, 1, 1, 0},
			{0, 0, 1, 1}, {1, 0, 0, 1}, {1, 1, 1, 0}, {0, 1, 1, 1},
			{1, 0, 1, 1}, {1, 1, 0, 1}, {1, 1, 1, 1}
	};
	
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		
		n = Integer.parseInt(st.nextToken());
		m = Integer.parseInt(st.nextToken());
		
		int[][] room = new int[n + 1][m + 1];
		
		for(int i = 1; i <= n; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j = 1; j <= m; j++) {
				room[i][j] = Integer.parseInt(st.nextToken());
				
				if(room[i][j] == 0) blindSpot++;
				if(0 < room[i][j] && room[i][j] < 6) list.add(new int[] {i, j});
			}
		}
		
		bfs(room, blindSpot);
		System.out.println(blindSpot);
		
	}
	// 모든 cctv의 동작 조합을 시도
	static void bfs(int[][] room, int blindSpot) {
		Queue<Info> q = new LinkedList<>();
		q.add(new Info(blindSpot, room));
		
		for(int i = 0; i < list.size(); i++) {
			int qLen = q.size();
			
			for(int t = 0; t < qLen; t++) {
				Info m = q.poll();
				int bs = m.blindSpot;
				int row = list.get(i)[0];
				int col = list.get(i)[1];
				
				if(room[row][col] == 1) {
					q.add(cctv(m.room, row, col, bs, stat[0]));
					q.add(cctv(m.room, row, col, bs, stat[1]));
					q.add(cctv(m.room, row, col, bs, stat[2]));
					q.add(cctv(m.room, row, col, bs, stat[3]));
				}
				if(room[row][col] == 2) {
					q.add(cctv(m.room, row, col, bs, stat[4]));
					q.add(cctv(m.room, row, col, bs, stat[5]));
				}
				if(room[row][col] == 3) {
					q.add(cctv(m.room, row, col, bs, stat[6]));
					q.add(cctv(m.room, row, col, bs, stat[7]));
					q.add(cctv(m.room, row, col, bs, stat[8]));
					q.add(cctv(m.room, row, col, bs, stat[9]));
				}
				if(room[row][col] == 4) {
					q.add(cctv(m.room, row, col, bs, stat[10]));
					q.add(cctv(m.room, row, col, bs, stat[11]));
					q.add(cctv(m.room, row, col, bs, stat[12]));
					q.add(cctv(m.room, row, col, bs, stat[13]));
				}
				if(room[row][col] == 5) {
					q.add(cctv(m.room, row, col, bs, stat[14]));
				}
			}
		}
	}
	
	// cctv를 동작시키고 결과와 blindSpot 개수를 세어 반환
	static Info cctv(int[][] room, int row, int col, int num, int[] status) {
		int[][] result = copy(room);
		
		// 비추는 방향마다 벽을 만나거나 방을 벗어날 때까지 비추도록 함
		for(int i = 0; i < 4; i++) {
			// 현재 방향을 비추지 않으면 continue
			if(status[i] == 0) continue;
			int nxtRow = row;
			int nxtCol = col;
			
			while(true) {
				nxtRow = nxtRow + dx[i];
				nxtCol = nxtCol + dy[i];
				
				// 다음 위치가 room 내부를 벗어나거나 벽이라면 이동할 수 없음
				if(nxtRow < 1 || nxtRow > n || nxtCol < 1 || nxtCol > m) break;
				if(result[nxtRow][nxtCol] == 6) break;
				
				if(result[nxtRow][nxtCol] == 0) {
					result[nxtRow][nxtCol] = 8;
					num--;
				}
			}
		}
		
		if(blindSpot > num) blindSpot = num;
		return new Info(num, result);
	}
	
	static int[][] copy(int[][] room){
		int[][] result = new int[n + 1][m + 1];
		for(int i = 0; i<= n; i++) {
			System.arraycopy(room[i], 0, result[i], 0, m + 1);
		}
		return result;
	}
}

class Info{
	int blindSpot;
	int[][] room;
	
	public Info(int blindSpot, int[][] room) {
		this.blindSpot = blindSpot;
		this.room = room;
	}
}

[BOJ] 14891번 톱니바퀴 Java 풀이

SDev — Sat, 19 Jun 2021 14:13:24 +0900

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

public class Main {
	static int[][] circles = new int[4][8];
	static int K, result;
	static int[] isRotate;
	
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		for(int i = 0; i < 4; i++) {
			String[] input = br.readLine().split("");
			for(int j = 0; j < 8; j++) {
				circles[i][j] = Integer.parseInt(input[j]);
			}
		}
		
		K = Integer.parseInt(br.readLine());
		StringTokenizer st;
		for(int k = 0; k < K; k++) {
			st = new StringTokenizer(br.readLine());
			int circleIndex = Integer.parseInt(st.nextToken());
			int direction = Integer.parseInt(st.nextToken());
			isRotate = new int[4];
			
			check(circleIndex - 1, direction);
			rotate();
		}
		System.out.println(countScore());
	}
	
	static int countScore() {
		int result = 0;
		for(int i = 0; i < 4; i++) {
			if(circles[i][0] == 1) {
				result += Math.pow(2, i);
			}
		}
		return result;
	}
	
	static void check(int circleNum, int dir) {
		isRotate[circleNum] = dir;
		
		int prev = circleNum - 1;
		int next = circleNum + 1;
		
		if(prev >= 0 && isRotate[prev] == 0) {
			// 왼쪽 바퀴 검사
			if(circles[prev][2] != circles[circleNum][6]) {
				check(prev, dir * -1);
			}
		}
		
		if(next <= 3 && isRotate[next] == 0) {
			// 오른쪽 바퀴 검사 
			if(circles[circleNum][2] != circles[next][6]) {
				check(next, dir * -1);
			}
		}
	}
	
	static void rotate() {
		for(int i = 0; i < 4; i++) {
			if(isRotate[i] != 0) {
				int[] result = new int[8];
				
				for(int j = 0; j < 8; j++) {
					int resultIndex = j + isRotate[i];
					
					if(resultIndex == -1) {
						resultIndex = 7;
					}else if(resultIndex == 8) {
						resultIndex = 0;
					}
					
					result[resultIndex] = circles[i][j];
				}
				circles[i] = result;
			}
		}
	}
}

[BOJ] 14890번 경사로 Java 풀이

SDev — Sat, 19 Jun 2021 14:12:36 +0900

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

public class Main {
	static int N, L, answer;
	static int[][] board;
	static boolean[][] isPlaced;
	
	public static void main(String[] args) throws Exception{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st = new StringTokenizer(br.readLine());
		N = Integer.parseInt(st.nextToken());
		L = Integer.parseInt(st.nextToken());
		
		board = new int[N][N];
		isPlaced = new boolean[N][N];
		
		for(int i = 0; i < N; i++) {
			st = new StringTokenizer(br.readLine());
			for(int j = 0; j < N; j++) {
				board[i][j] = Integer.parseInt(st.nextToken());
			}
		}
		
		// 행 기준 검사
		for(int i = 0; i < N; i++) {
			boolean isPossible = true;
			for(int j = 0; j < N - 1; j++) {
				// 경사가 1 차이나는 지점을 만나면 
				if(Math.abs(board[i][j] - board[i][j + 1]) == 1) {
					// 좌상향 경사로인 경우
					// 경사로를 놓을 수 있는 길이가 부족하거나, 
					if(board[i][j] > board[i][j + 1]) {
						if(j + L > N - 1) {
							isPossible = false;
							continue;
						}
						// 그 길이의 블록에 이미 놓아진 경사로가 이미 있거나, 높이가 1 낮은 블록들이 아니라면 불가
						for(int k = 1; k <= L; k++) {
							if(isPlaced[i][j + k] || board[i][j + k] + 1 != board[i][j]) {
								isPossible = false;
								break;
							}
						}
						if(isPossible) {
							for(int k = 1; k <= L; k++) {
								isPlaced[i][j + k] = true;
							}
						}
					}else {	// 우상향 경사로인 경우
						if(j - L + 1 < 0) {
							isPossible = false;
							continue;
						}
						for(int k = 0; k < L; k++) {
							if(isPlaced[i][j - k] || board[i][j - k] + 1 != board[i][j + 1]) {
								isPossible = false;
								break;
							}
						}
						if(isPossible) {
							for(int k = 0; k < L; k++) {
								isPlaced[i][j - k] = true;
							}
						}
					}
				}else if(Math.abs(board[i][j] - board[i][j + 1]) > 1) {
					isPossible = false;
				}
			}
			// 경사로를 놓을 수 있거나, 모두 높이가 같다면 answer 증가
			if(isPossible) {
				answer++;
			}
		}
		
		// 경사로 초기화
		isPlaced = new boolean[N][N];
		
		
		// 열 기준 검사
		for(int j = 0; j < N; j++) {
			boolean isPossible = true;
			for(int i = 0; i < N - 1; i++) {
				// 경사가 1 차이나는 지점을 만나면 
				if(Math.abs(board[i][j] - board[i + 1][j]) == 1) {
					// 경사로를 놓을 수 있는 길이가 부족하거나, 
					if(board[i][j] > board[i + 1][j]) {
						if(i + L > N - 1) {
							isPossible = false;
							continue;
						}
						// 그 길이의 블록에 이미 놓아진 경사로가 이미 있거나, 높이가 1 낮은 블록들이 아니라면 불가
						for(int k = 1; k <= L; k++) {
							if(isPlaced[i + k][j] || board[i + k][j] + 1 != board[i][j]) {
								isPossible = false;
								break;
							}
						}
						if(isPossible) {
							for(int k = 1; k <= L; k++) {
								isPlaced[i + k][j] = true;
							}
						}
					}else {	
						if(i - L + 1 < 0) {
							isPossible = false;
							continue;
						}
						for(int k = 0; k < L; k++) {
							if(isPlaced[i - k][j] || board[i - k][j] + 1 != board[i + 1][j]) {
								isPossible = false;
								break;
							}
						}
						if(isPossible) {
							for(int k = 0; k < L; k++) {
								isPlaced[i - k][j] = true;
							}
						}
					}
				}else if(Math.abs(board[i][j] - board[i + 1][j]) > 1) {
					isPossible = false;
				}
			}
			// 경사로를 놓을 수 있거나, 모두 높이가 같다면 answer 증가
			if(isPossible) {
				answer++;
			}
		}
		System.out.println(answer);
	} // end of main
}