Pepperminttt's Dev

[프로그래머스/Java] 1,2,3 떨어트리기

Pepperminttt — Thu, 9 Nov 2023 14:10:50 +0900

문제

https://school.programmers.co.kr/learn/courses/30/lessons/150364

프로그래머스

코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는 기업들을 매칭 받으세요.

programmers.co.kr

문제 풀이

해당 문제는 특정 알고리즘 문제가 아닌 구현 문제로 판단하여 모든 기능을 차례대로 구현했다.

그 과정에서 숫자를 어떤 순서로 내려야하는지 많은 고민을 했다. 결과만 말하자면 계속 임의의 수를 내려보내 받은 숫자의 개수를 저장하고, 이를 target 숫자를 만들수 있냐 없냐로 분기처리하였다.

우리가 떨어뜨릴 수 있는 숫자는 1,2,3밖에 없으므로 아래와 같은 공식으로 모든 노드가 target 값을 만들 수 있는지를 숫자를 떨어뜨릴 때마다 체크해야 한다.

현재 노드가 보유하고 있는 숫자 개수 ≤ 노드의 target 값 ≤ 현재 노드가 보유하고 있는 숫자 개수 * 3

따라서, target 값대로 리프 노드에 숫자를 쌓을 수 있는지 확인하려면 다음과 같은 과정을 거쳐야 합니다.

트리에 숫자를 떨어뜨린다.
각 리프 노드에 숫자가 몇 개씩 떨어졌는지 카운팅한다.
현재까지 떨어뜨린 숫자의 개수로 모든 리프 노드에서 target 값을 만들 수 있는지를 위의 공식을 통해 확인한다.
만약 모든 리프 노드의 target 값을 만들 수 있다면 루프를 탈출합니다. 이때가 가장 적은 숫자를 사용하여 target 값대로 리프 노드에 숫자를 쌓을 수 있는 때이다. target 값을 만들 수 없는 리프 노드가 하나라도 있다면 (1.)로 돌아간다.

단, target을 만들 수 없는 트리가 입력으로 주어졌다면, 위 과정에서 무한 루프를 돌 수 있다. 어떤 노드에서 현재까지 떨어뜨린 숫자로 target 값을 만들 수 없는 경우는 다음과 같이 2가지가 있다. 이 중에서 2번째 경우가 target을 만드는 것이 불가능한 트리가 주어진 경우이다.

노드의 target 값 > 현재 노드가 보유하고 있는 숫자 개수 * 3인 경우는 현재 보유하고 있는 숫자 개수가 적어서 target 값을 만들 수 없는 경우이므로 숫자를 더 떨어트리면 target 값을 만들 수 있습니다.

현재 노드가 보유하고 있는 숫자 개수 > 노드의 target 값인 경우는 현재 보유하고 있는 숫자를 모두 1로 바꿔도 target을 만들 수 없습니다. 따라서 영원히 target대로 숫자의 합을 만들 수 없으므로, 더 이상 루프를 돌지 말고 [-1]을 return 해야 합니다.

여기까지가 target대로 숫자의 합을 만들 수 있는지 없는지를 구하고, 만들 수 있는 경우 사용하는 숫자의 최소 개수까지 구하는 과정이다.

문제 풀이 코드

import java.util.*;

class Solution {
    
    public static class Result{
        int no;
        String status;
        
        public Result(int no, String status){
            this.no = no;
            this.status = status;
        }
    }
    
    public static class Node implements Comparable<Node>{
        int no;
        ArrayList<Node> list = new ArrayList<>();
        int numCount = 0;
        ArrayList<Integer> countList = new ArrayList<>();
        ArrayList<Integer> numList = new ArrayList<>();
        
        int target;
        int route = 0;
        boolean isleap = true;
        

        public Node(int no, int target){
            this.no = no;
            this.target = target;
        }
        public void addChild(Node child){
            list.add(child);
        }
        
        public void startSet(){
            isleap = list.size() == 0;
            if(!isleap){
                list.sort(null);
                route = 0;
            }
        }
        
        public Result addNum(int num){
            if(isleap){
                if(numCount >= target){
                    return new Result(no,"over");
                }
                numCount++;
                countList.add(num);
                if(numCount <= target && numCount*3 >= target){
                    numList.clear();
                    for(int i = 0; i < numCount; i++){
                        numList.add(1);
                    }
                    int needNum = target - numCount;
                    for(int i = numCount-1; i >= 0; i--){
                        if(needNum == 0) break;
                        else if(needNum == 1){
                            numList.set(i,2);
                            break;
                        }else{
                            numList.set(i,3);
                            needNum -= 2;
                        }
                    }
                    System.out.println(numList);
                    return new Result(no,"possible");
                }
                return new Result(no,"less");
                
            }else{
                int temp = route;
                route = (route+1)%list.size();
                return list.get(temp).addNum(num);
            }
        }

        @Override
        public int compareTo(Node o){
            return this.no - o.no;
        }
    }
    
    public int[] solution(int[][] edges, int[] target) {
        Map<Integer,Node> memo = new HashMap<>();
        Node root = new Node(1,-1);
        memo.put(1,root);
        int sum = Arrays.stream(target).sum();
        
        for(int[] edge : edges){
            int parent = edge[0];
            int child = edge[1];
            
            if(!memo.containsKey(child)){
                memo.put(child,new Node(child,target[child-1]));
            }
            if(!memo.containsKey(parent)){
                memo.put(parent,new Node(parent,target[parent-1]));
            }
            memo.get(parent).addChild(memo.get(child));
            
        }
        
        for(int n : memo.keySet()){
            memo.get(n).startSet();
        }
        
        int count = 1;
        boolean[] statusBoard = new boolean[target.length];
        for(int i = 0 ; i < target.length; i++){
            if(target[i] == 0)statusBoard[i] = true;
        }
        boolean isComplete = true;
        while(true){
            Result result = root.addNum(count++);
            
            if(result.status == "over")break;
            
            if(result.status == "possible"){
                statusBoard[result.no-1] =true;
            }else{
                statusBoard[result.no-1] =false;
            }
            isComplete = true;
            for(boolean r : statusBoard){
                if(!r){
                    isComplete = false;
                    break;
                }
            }
            if(isComplete)break;
        }
        
        if(!isComplete) return new int[] {-1};
        
        ArrayList<Integer> answer = new ArrayList<>();
        
        for(int i = 1; i < count; i++){
            for(int x = 1; x <= target.length; x++){
                Node temp = memo.get(x);
                if(!temp.countList.contains(i))continue;
                answer.add(temp.numList.get(temp.countList.indexOf(i)));
                break;
            }
        }
        
        int[] answerArr = new int[answer.size()];
        for(int i = 0 ; i < answer.size(); i++){
            answerArr[i] = answer.get(i);
        }
            
        return answerArr;
    }
}

[백준/Java] 17472: 다리 만들기 2

Pepperminttt — Wed, 20 Sep 2023 15:22:20 +0900

문제 풀이

해당 문제는 그래프 탐색, 브루트포스, 최소 스패닝 트리 알고리즘을 모두 사용해야 풀 수 있는 문제이다.

1. 섬의 개수 확인 및 섬 넘버링 : 그래프 탐색

2. 각 섬의 거리 구하기 : 브루트포스

3. 최소의 길이의 다리 구하기 : 최소 스패닝 트리

1. 섬의 개수 확인 및 섬 넘버링 : 그래프 탐색

int[][] visited = new int[N][M];
		int count = 1;
		
		for(int y = 0; y < N; y++) {
			for(int x = 0; x < M; x++) {
				if(board[y][x] == 0 || visited[y][x] != 0 )continue;
				
				ArrayDeque<Pos> dq = new ArrayDeque<>();
				
				dq.add(new Pos(x,y));
				
				while(!dq.isEmpty()) {
					Pos cur = dq.poll();
					
					if(visited[cur.y][cur.x] != 0)continue;
					visited[cur.y][cur.x] = count;
					
					for(int i = 0 ; i < 4 ; i++) {
						int mx = dx[i] + cur.x;
						int my = dy[i] + cur.y;
						
						if(mx >= M|| mx < 0 || my >= N || my < 0 || visited[my][mx] != 0 || board[my][mx] == 0)continue; 
						
						dq.add(new Pos(mx,my));
					}
				}
				
				count++;
			}
		}

2. 각 섬의 거리 구하기 : 브루트포스

각 섬에서 다른 섬까지의 거리를 브루트포스를 사용하여 구한다.

int[][] distance = new int[count][count];
		for(int i = 0 ; i < count; i++) {
			Arrays.fill(distance[i], INF);
			distance[i][i] = 0;
		}
		
		for(int y = 0; y < N; y++) {
			for(int x = 0; x < M; x++) {
				if(visited[y][x] == 0)continue;
				
				int cur = visited[y][x];
				
				for(int i = 0 ; i < 4; i++) {
					int mx = x;
					int my = y;
					int dist = 0;
					while(true) {
						mx += dx[i];
						my += dy[i];
						dist++;
						if(mx >= M || mx < 0 || my >= N || my < 0 || visited[my][mx] == cur) break;
						if(visited[my][mx] != 0) {
							if(dist -1 > 1)
								distance[cur][visited[my][mx]] = Math.min(distance[cur][visited[my][mx]], dist-1);
							break;
						}
					}
				}
				
			}
		}

3. 최소의 길이의 다리 구하기 : 최소 스패닝 트리

2에서 구한 각 길을 통해서 최소 스패닝 트리로 최소 길이의 다리를 구한다.

이 때 길이가 2이상인 다리를 짓지 못하여 고립된 섬이 있는지 먼저 확인하여 고립이 된 섬이 있다면 최소 스패닝 트리의 조건을 만족시키지 못한다. 그렇기에 -1을 출력한다.

for(int i = 1 ; i < count; i++) {
			int cnt = Arrays.stream(distance[i]).reduce(0, (x,v)-> v > 1 && v <INF ? x+1:x);
			if(cnt < 1) {
				System.out.println(-1);
				return;
			}
		}

아래 코드는 프림 알고리즘으로 최소 길이를 구하는 코드이다.

PriorityQueue<Route> pq = new PriorityQueue<>();
		boolean[] vi = new boolean[count];
		int answer = 0;
		int check = 0;
		pq.add(new Route(1,0));
		
		
		while(!pq.isEmpty()) {
			Route cur = pq.poll();
			
			if(vi[cur.to])continue;
			vi[cur.to] = true;
			answer+= cur.cost;
			check++;
			for(int x = 1; x < count;x++) {
				if(x == cur.to || vi[x] || distance[cur.to][x] <= 1 || distance[cur.to][x] ==INF)continue;
				
				pq.add(new Route(x,distance[cur.to][x]));
			}
			
		}

풀이 코드

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

public class Main {
	
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static int INF = Integer.MAX_VALUE;
	
	static int[] dx = {0,1,0,-1};
	static int[] dy = {-1,0,1,0};
	
	static class Route implements Comparable<Route>{
		
		int to;
		int cost;

		public Route() {}
		public Route(int to, int cost) {
			this.to = to;
			this.cost = cost;
		}
		@Override
		public int compareTo(Route o) {
			return this.cost - o.cost;
		}
		@Override
		public String toString() {
			return "Route [to=" + to + ", cost=" + cost + "]";
		}
		
	}
	
	static class Pos{
		int x;
		int y;
		
		public Pos() {}
		public Pos(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}
	
	public static void main(String[] args) throws IOException{
		st = new StringTokenizer(br.readLine());
		
		int N = Integer.parseInt(st.nextToken());
		int M = Integer.parseInt(st.nextToken());
		
		int[][] board = new int[N][M];
		
		for(int i = 0; i < N; i ++) board[i] = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		
		int[][] visited = new int[N][M];
		int count = 1;
		
		for(int y = 0; y < N; y++) {
			for(int x = 0; x < M; x++) {
				if(board[y][x] == 0 || visited[y][x] != 0 )continue;
				
				ArrayDeque<Pos> dq = new ArrayDeque<>();
				
				dq.add(new Pos(x,y));
				
				while(!dq.isEmpty()) {
					Pos cur = dq.poll();
					
					if(visited[cur.y][cur.x] != 0)continue;
					visited[cur.y][cur.x] = count;
					
					for(int i = 0 ; i < 4 ; i++) {
						int mx = dx[i] + cur.x;
						int my = dy[i] + cur.y;
						
						if(mx >= M|| mx < 0 || my >= N || my < 0 || visited[my][mx] != 0 || board[my][mx] == 0)continue; 
						
						dq.add(new Pos(mx,my));
					}
				}
				
				count++;
			}
		}
		
		
		int[][] distance = new int[count][count];
		for(int i = 0 ; i < count; i++) {
			Arrays.fill(distance[i], INF);
			distance[i][i] = 0;
		}
		
		for(int y = 0; y < N; y++) {
			for(int x = 0; x < M; x++) {
				if(visited[y][x] == 0)continue;
				
				int cur = visited[y][x];
				
				for(int i = 0 ; i < 4; i++) {
					int mx = x;
					int my = y;
					int dist = 0;
					while(true) {
						mx += dx[i];
						my += dy[i];
						dist++;
						if(mx >= M || mx < 0 || my >= N || my < 0 || visited[my][mx] == cur) break;
						if(visited[my][mx] != 0) {
							if(dist -1 > 1)
								distance[cur][visited[my][mx]] = Math.min(distance[cur][visited[my][mx]], dist-1);
							break;
						}
					}
				}
				
			}
		}
		
		
		for(int i = 1 ; i < count; i++) {
			int cnt = Arrays.stream(distance[i]).reduce(0, (x,v)-> v > 1 && v <INF ? x+1:x);
			if(cnt < 1) {
				System.out.println(-1);
				return;
			}
		}
		
		PriorityQueue<Route> pq = new PriorityQueue<>();
		boolean[] vi = new boolean[count];
		int answer = 0;
		int check = 0;
		pq.add(new Route(1,0));
		
		
		while(!pq.isEmpty()) {
			Route cur = pq.poll();
			
			if(vi[cur.to])continue;
			vi[cur.to] = true;
			answer+= cur.cost;
			check++;
			for(int x = 1; x < count;x++) {
				if(x == cur.to || vi[x] || distance[cur.to][x] <= 1 || distance[cur.to][x] ==INF)continue;
				
				pq.add(new Route(x,distance[cur.to][x]));
			}
			
		}
		System.out.println(answer == 0 || check != count-1 ? -1 : answer);
		
	}
}

[백준 / Java] 2110번: 공유기 설치

Pepperminttt — Tue, 19 Sep 2023 12:25:22 +0900

문제

도현이의 집 N개가 수직선 위에 있다. 각각의 집의 좌표는 x1, ..., xN이고, 집 여러개가 같은 좌표를 가지는 일은 없다.

도현이는 언제 어디서나 와이파이를 즐기기 위해서 집에 공유기 C개를 설치하려고 한다. 최대한 많은 곳에서 와이파이를 사용하려고 하기 때문에, 한 집에는 공유기를 하나만 설치할 수 있고, 가장 인접한 두 공유기 사이의 거리를 가능한 크게 하여 설치하려고 한다.

C개의 공유기를 N개의 집에 적당히 설치해서, 가장 인접한 두 공유기 사이의 거리를 최대로 하는 프로그램을 작성하시오.

입력

첫째 줄에 집의 개수 N (2 ≤ N ≤ 200,000)과 공유기의 개수 C (2 ≤ C ≤ N)이 하나 이상의 빈 칸을 사이에 두고 주어진다. 둘째 줄부터 N개의 줄에는 집의 좌표를 나타내는 xi (0 ≤ xi ≤ 1,000,000,000)가 한 줄에 하나씩 주어진다.

출력

첫째 줄에 가장 인접한 두 공유기 사이의 최대 거리를 출력한다.

예제 입력 1

예제 출력 1

문제 풀이

해당 문제는 탐색해야 하는 것을 인지하면 쉽게 풀 수 있는 문제이다. 우리가 구해야 하는 것은 공유기 사이의 최대 거리이다. 그렇기에 공유기 사이의 거리를 변수로 두고 이분 탐색을 통해 최대 거리를 구하면 된다.

문제의 자세한 설명은 https://st-lab.tistory.com/277에서 읽어보자.

코드

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

public class Main {
	
	static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	static StringTokenizer st;
	static int INF = Integer.MAX_VALUE;
	

	
	public static void main(String[] args) throws IOException{
		st = new StringTokenizer(br.readLine());
		
		int h = Integer.parseInt(st.nextToken());
		int r = Integer.parseInt(st.nextToken());
		
		ArrayList<Integer> houseList = new ArrayList<>();
		for(int i = 0; i < h; i++) {
			houseList.add(Integer.parseInt(br.readLine()));
		}
		houseList.sort(null);
		
		int left = 1;
		int right = houseList.get(h-1) - houseList.get(0) + 1;
		int mid = (left + right) / 2;

		while(left < right) {
			
			mid = (left + right) / 2;
			int index = 0;
			int count = 1;
			for(int i = 1 ; i < h; i++) {
				if(houseList.get(i) - houseList.get(index) >= mid) {
					count++;
					index = i;
				}
			}

			if(count >= r) {
				left = mid+1;
				
			}else{
				right = mid;
			}
		}
		System.out.println(left-1);
	}
}

[백준/Java] 1517번: 버블 소트(병합 정렬[Merge Sort])

Pepperminttt — Thu, 31 Aug 2023 10:10:11 +0900

문제

N개의 수로 이루어진 수열 A[1], A[2], …, A[N]이 있다. 이 수열에 대해서 버블 소트를 수행할 때, Swap이 총 몇 번 발생하는지 알아내는 프로그램을 작성하시오.

버블 소트는 서로 인접해 있는 두 수를 바꿔가며 정렬하는 방법이다. 예를 들어 수열이 3 2 1 이었다고 하자. 이 경우에는 인접해 있는 3, 2가 바뀌어야 하므로 2 3 1 이 된다. 다음으로는 3, 1이 바뀌어야 하므로 2 1 3 이 된다. 다음에는 2, 1이 바뀌어야 하므로 1 2 3 이 된다. 그러면 더 이상 바꿔야 할 경우가 없으므로 정렬이 완료된다.

입력

첫째 줄에 N(1 ≤ N ≤ 500,000)이 주어진다. 다음 줄에는 N개의 정수로 A[1], A[2], …, A[N]이 주어진다. 각각의 A[i]는 0 ≤ |A[i]| ≤ 1,000,000,000의 범위에 들어있다.

출력

첫째 줄에 Swap 횟수를 출력한다

예제 입력 1

3
3 2 1

예제 출력 1

문제 풀이

해당 문제는 최대 배열의 길이가 500,000이므로 버블소트를 진행한다면 O(N^2)로 시간 초과가 나온다. 시간 초과를 피하기 위해 버블 솔트와 같이 스왑을 하지만 시간 복잡도가 낮은 병합 정령(merge sort)로 문제를 풀었다.

병합 정렬을 이용하여 nlogn으로 해결할 수 있다.

정렬된 LeftArray와 RightArray로 나누어서 LeftArray의 길이를 count에 넣고 정렬을 시작한다.

이제 LeftArray의 맨 앞단의 숫자와 RightArray의 맨 앞단 숫자를 비교한다.
이 과정에서 작은 숫자를 새로운 배열에 추가한다.
해당 숫자가 RightArray의 숫자라면 count를 SwapCount에 추가한다.
해당 숫자가 LeftArray의 숫자라면 count를 줄인다.
위 그림에서는 RightArray의 1을 삽입하고, count 3을 Swapcount에 추가한다.

LeftArray 값이 작으므로 2를 넣고, LeftArray의 값이 들어가는 경우 Count를 1 줄인다.

LeftArray 값이 작으므로 3을 넣고, Count를 줄인다.

RightArray 값이 작으므로 4를 넣고, Swap에 Count를 더한다.
한쪽 배열이 비어있으면 다른 배열의 값을 그냥 넣는다.

위 병합 정렬을 사용하면 시간 초과 없이 스왑 횟수를 출력할 수 있다.

풀이 코드

import java.io.*;
import java.util.*;
import java.util.Map.Entry;

public class Main {
	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static StringTokenizer st;
	public static int INF = Integer.MAX_VALUE;
	
	
	static long swapCount = 0;
    static long[] sorted;
	
	public static void main(String[] args) throws IOException {
		
		int N = Integer.parseInt(br.readLine());
       
        
        sorted = new long[N];
        long[] arr = new long[N];
 
        arr = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::parseLong).toArray();
 
        mergeSort(arr, 0,N-1);
	        
        System.out.println(swapCount);
	}
    static void mergeSort(long[] arr, int left, int right) {
    	if(left < right) {
    		int mid = (left + right) / 2;
    		mergeSort(arr,left,mid);
    		mergeSort(arr,mid+1,right);
    		merge(arr, left,right);
    	}
    }
 
    static void merge(long[] arr, int start, int end) {
    	int mid = (start+end) / 2;
    	int left = start;
    	int right = mid+1;
    	int index = start;
    	
    	while(left <= mid && right <= end) {
    		if(arr[left] <= arr[right]) {
    			sorted[index++] = arr[left++];
    		}else {
    			sorted[index++] = arr[right++];
    			swapCount += mid + 1 - left;
    		}
    	}
    	while(left <= mid) {
    		sorted[index++] = arr[left++];
    	}
    	while(right <= end) {
    		sorted[index++] = arr[right++];
    	}
    	for(int i = start; i <= end; i++) {
    		arr[i] = sorted[i];
    	}
    }
}

문자열 매칭 알고리즘(KMP)

Pepperminttt — Tue, 29 Aug 2023 17:38:31 +0900

문자열 매칭 알고리즘

특정한 글이 있을 때 그 글 안에서 하나의 문자열을 찾는 알고리즘이다. 워드파일 또는 웹 브라우저 DB에서 문자열을 검색할 때 패턴 매칭 알고리즘을 사용하여 검색 결과를 표시한다.

단순 문자열 알고리즘

가장 간단한 문자열 매칭 알고리즘으로, 말 그대로 하나씩 확인하는 방법을 사용한다.

검색할 문자열 ABDEGH
찾는 문자열 DE

가장 앞부분부터 찾는 문자열이 매칭될 때 까지 탐색을 시작한다.

검색할 문자열	A	B	D	E	G	H
찾는 문자열	D	E

매칭이 이루어지지 않았다면 한 칸씩 옆으로 이동시킨다.

검색할 문자열	A	B	D	E	G	H
찾는 문자열		D	E

매칭이 이루어졌으면 탐색을 종료한다.

검색할 문자열	A	B	D	E	G	H
찾는 문자열			D	E

이 알고리즘은 이중포문으로 시간복잡도는 O(N*M)이 된다. 효율적이지는 않지만 코드가 직관적이라서 간단하게 사용하기 좋다.

KMP(Knuth-Morris-Pratt) 알고리즘 ⭐

위와 같은 단순 문자열 매칭 알고리즘은 긴 문자열을 탐색할 경우 최악의 경우가 발생하면 엄청난 시간이 소요될 것이다. 그래서 모든 경우를 다 비교하지 않아도 되는 KMP 문자열 매칭 알고리즘을 알아보자.

KMP는 접두사와 접미사의 개념을 활용하여 모든 경우를 계산하지 않고 반복되는 연산을 줄여나가 매칭 문자열을 빠르게 점프하는 기법으로 효율적으로 문자열 매칭을 이루어나간다.

KMP 알고리즘을 동작시키기 위해서는 접두사도 되고 접미사도 되는 문자열의 최대 길이를 저장해주는 table을 미리 정의해줘야한다. table[]은 pattern이 어디까지 일치했는지가 주어질 때 다음 시작 위치를 어디로 해야할지를 말해주기 때문에, 이를 흔히 부분 일치 테이블이라고 부른다.

table[i] = pattern(0...i)의 접두사도 되고 접미사도 되는 문자열의 최대 길이

예를 들어, abacaaba가 있을 때 다음과 같다.

i	pattern(0...i)	접두사이면서 접미사인 최대 문자열	table[i]
0	a	(없음)	0
1	ab	(없음)	0
2	aba	a	1
3	abac	(없음)	0
4	abaca	a	1
5	abacaa	a	1
6	abacaab	ab	2
7	abacaaba	aba	3

a b a c a a b a

‣ table[] 0 0 1 0 1 1 2 3

일치하는 접두사와 접미사의 최대길이는 aba로 3이다. 해당 탐색한 결과를 table[] 배열에 저장하면 다음과 같이 저장된다.

static int[] makeTable(String pattern) {
	int n = pattern.length();
	int[] table = new int[n];
		
	int idx=0;
	for(int i=1; i<n; i++) {
        // 일치하는 문자가 발생했을 때(idx>0), 연속적으로 더 일치하지 않으면 idx = table[idx-1]로 돌려준다.
		while(idx>0 && pattern.charAt(i) != pattern.charAt(idx)) {
			idx = table[idx-1];
		}
			
		if(pattern.charAt(i) == pattern.charAt(idx)) {
			idx += 1;
			table[i] = idx;  
		}
	}
	return table;
}

table 생성 완료

접두사와 접미사가 일치하는 최대길이를 구한 부분 일치 테이블을 구했다면 이후 동작 과정은 간단하다. 이제 table함수를 이용하여 parent 문자열과 find 문자열을 index=0부터 비교해주면 된다.

KMP 알고리즘의 구현 방식

a) idx>0, parent의 i번째 문자 != find의 j(idx)번째 문자

idx = table[idx-1];

문자열 매칭이 시작된 후 연속적으로 매칭이 되지않을때 다시 매칭을 시작해야 하므로 idx값을 다시 돌려준다.

그런데 만약 문자열 매칭된 부분이 접두사와 접미사가 같은 구간이라면 idx는 0이아닌 그 일치하는 길이만큼의 값을 받게된다. 그러므로 앞에 접두사부분을 생략하고 다시 재빠르게 탐색이 가능해진다.

b) parent의 i번째 문자 == find의 j(idx)번째 문자

if( idx == find문자열 길이-1) : 탐색 종료
else : idx값 1증가

idx값이 (find문자열 길이-1)까지 도달했다면 문자열 매칭을 성공한 것이므로 탐색을 종료한다. 아니면 일치할 때마다 idx값을 1증가하여 다음 문자를 매칭하도록 한다.

i = matched + begin, idx = matched 라고 생각하면 위와 동일하다.

static void KMP(String parent, String pattern) {
	int[] table = makeTable(pattern);
		
	int n1 = parent.length();
	int n2 = pattern.length();
		
	int idx = 0; // 현재 대응되는 글자 수
	for(int i=0; i< n1; i++) {
		// idx번 글자와 짚더미의 해당 글자가 불일치할 경우, 
		// 현재 대응된 글자의 수를 table[idx-1]번으로 줄인다.
		while(idx>0 && parent.charAt(i) != pattern.charAt(idx)) {
			idx = table[idx-1];
		}
		// 글자가 대응될 경우	
		if(parent.charAt(i) == pattern.charAt(idx)) {
			if(idx == n2-1) {
				System.out.println(i-idx+1 + "번째에서 찾았습니다. ~" + (i+1) );
				idx =table[idx];
			}else {
				idx += 1;
			}
		}
	}
}

KMP 알고리즘 탐색과정

KMP 알고리즘은 접두사와 접미사가 일치하는 경우에 문자열 매칭을 탐색할 때 점프를 할 수 있어서 굉장히 효율적으로 작동하게 된다. 직접 예시를 풀어나가보면서 이해해보자.

먼저 두 문자열을 비교하여 접두사와 접미사의 일치하는 최대의 길이를 찾아준다.

검색할 문자열(pattern): ababacabacaaba이고, 찾는 문자열(find): abacaaba 이라고 하자.

pattern의 테이블을 다음과 같이 구해준 다음 위의 로직과 같이 반복문을 돌려준다.

pattern: table배열 [ 0 0 1 0 1 1 2 3]
반복문 i: 0 ~ parent문자열 길이(n1)

1) i=0, idx =0 → idx 1증가

a 일치

parent

pattern

idx

2) i=1, idx =1 → idx 1증가

b 일치

parent

pattern

idx

3) i=2, idx =2 → idx 1증가

a 일치

parent

pattern

idx

4) i=3, idx =3 → idx = table[idx-1] = table[2] = 1

b != c 불일치

parent

pattern

idx

5) i=4, idx =1 → idx 1증가

이전 탐색에서 불일치 되어도 idx=1부터 시작하는 이유는 pattern 접두사 a와 접미사 a가 일치하므로 idx=1 (b)부터 탐색하는 것이다. 이것이 kmp 알고리즘이 빠르게 동작하는 이유다.

a 일치

parent

pattern

idx

6~7 ) c, a 일치 → idx 증가

parent

pattern

idx

8) i=7, idx= 5 → idx =table[4] = 1

b != a 불일치

parent

pattern

idx

9) i=8, idx= 1

8)에서 불일치되었으므로 다시 탐색을 시작한다. 이번에도 접두사 접미사 a가 일치하므로 탐색 b(idx=1)부터 재탐색을 시작한다.

parent

pattern

idx

나머지) i = 9 ~ 14

parent

pattern

idx

이렇게 끝까지 탐색하면 idx = 7 ( pattern문자열 길이-1)에 도달한다. 이는 매칭이 되었다는 뜻이므로 탐색을 완료해준다.

* 만약 계속 탐색하려면 idx = table[idx]를 해줘서 idx를 다시 돌려주면 된다.

실행 결과

정리

정리하자면 접두사가 일치하는 길이만큼만 j인덱스를 이동시키면 된다.

j=0, aba (0~2) >> src: aba~~ba..~~. <-> find : aba~~c...~~
c에서 어긋나므로 j = table[j-1] = table[2] =1이므로, b부터 다시 탐색한다
j=1, (a생략) baca (2~6) len=5 >> src : ababacaba <-> find : abacaaba
b에서 어긋나므로 j = table[j-1] = table[5] =1 , b부터 다시 탐색한다
j=6, abacaaba (6~13) len=8
일치하므로 종료

KMP 문자열 매칭 알고리즘은 탐색시간을 위와 같은 방식으로 줄여준다. 그래서 시간복잡도도 기존 단순 문자열 매칭 알고리즘은 O(n*m)이지만 KMP는 table생성할 때 반복문 한번, kmp 매칭할 때 한번 해서 O(n+m)으로 굉장히 줄여준다.

Reference

- https://m.blog.naver.com/PostView.nhn?blogId=ndb796&logNo=221240660061&proxyReferer=https:%2F%2Fwww.google.com%2F
- https://loosie.tistory.com/192

[백준 / Java] 1194번: 달이 차오른다, 가자.

Pepperminttt — Fri, 25 Aug 2023 10:10:22 +0900

문제

지금 민식이가 계획한 여행은 달이 맨 처음 뜨기 시작할 때 부터, 준비했던 여행길이다. 하지만, 매번 달이 차오를 때마다 민식이는 어쩔 수 없는 현실의 벽 앞에서 다짐을 포기하고 말았다.

민식이는 매번 자신의 다짐을 말하려고 노력했지만, 말을 하면 아무도 못 알아들을 것만 같아서, 지레 겁먹고 벙어리가 되어버렸다. 결국 민식이는 모두 잠든 새벽 네시 반쯤 홀로 일어나, 창 밖에 떠있는 달을 보았다.

하루밖에 남지 않았다. 달은 내일이면 다 차오른다. 이번이 마지막기회다. 이걸 놓치면 영영 못간다.

영식이는 민식이가 오늘도 여태것처럼 그냥 잠 들어버려서 못 갈지도 모른다고 생각했다. 하지만 그러기엔 민식이의 눈에는 저기 뜬 달이 너무나 떨렸다.

민식이는 지금 미로 속에 있다. 미로는 직사각형 모양이고, 여행길을 떠나기 위해 미로를 탈출하려고 한다. 미로는 다음과 같이 구성되어져있다.

빈 칸: 언제나 이동할 수 있다. ('.')
벽: 절대 이동할 수 없다. ('#')
열쇠: 언제나 이동할 수 있다. 이 곳에 처음 들어가면 열쇠를 집는다. ('a', 'b', 'c', 'd', 'e', 'f')
문: 대응하는 열쇠가 있을 때만 이동할 수 있다. ('A', 'B', 'C', 'D', 'E', 'F')
민식이의 현재 위치: 빈 곳이고, 민식이가 현재 서 있는 곳이다. ('0')
출구: 달이 차오르기 때문에, 민식이가 가야하는 곳이다. 이 곳에 오면 미로를 탈출한다. ('1')

달이 차오르는 기회를 놓치지 않기 위해서, 미로를 탈출하려고 한다. 한 번의 움직임은 현재 위치에서 수평이나 수직으로 한 칸 이동하는 것이다.

민식이가 미로를 탈출하는데 걸리는 이동 횟수의 최솟값을 구하는 프로그램을 작성하시오.

입력

첫째 줄에 미로의 세로 크기 N과 가로 크기 M이 주어진다. (1 ≤ N, M ≤ 50) 둘째 줄부터 N개의 줄에 미로의 모양이 주어진다. 같은 타입의 열쇠가 여러 개 있을 수 있고, 문도 마찬가지이다. 그리고, 문에 대응하는 열쇠가 없을 수도 있다. '0'은 한 개, '1'은 적어도 한 개 있다. 열쇠는 여러 번 사용할 수 있다.

출력

첫째 줄에 민식이가 미로를 탈출하는데 드는 이동 횟수의 최솟값을 출력한다. 만약 민식이가 미로를 탈출 할 수 없으면, -1을 출력한다.

예제 입력 1

1 7
f0.F..1

예제 출력 1

예제 입력 2

5 5
....1
#1###
.1.#0
....A
.1.#.

예제 출력 2

-1

예제 입력 3

7 8
a#c#eF.1
.#.#.#..
.#B#D###
0....F.1
C#E#A###
.#.#.#..
d#f#bF.1

예제 출력 3

예제 입력 4

3 4
1..0
###.
1...

예제 출력 4

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

1194번: 달이 차오른다, 가자.

첫째 줄에 미로의 세로 크기 N과 가로 크기 M이 주어진다. (1 ≤ N, M ≤ 50) 둘째 줄부터 N개의 줄에 미로의 모양이 주어진다. 같은 타입의 열쇠가 여러 개 있을 수 있고, 문도 마찬가지이다. 그리고,

www.acmicpc.net

문제 풀이

해당 문제는 최단 거리 문제이다. 하지만 문이 존재하고, 해당 문에 맞는 열쇠를 가지고 있어야지만 해당 문을 통과할 수 있다는 조건이 존재한다.

이 조건을 visited에 추가하여 문제를 풀 수 있지만, 문이 많이 존재하게 된다면 매우 큰 배열이 필요할 것이다. 그렇기에 키에 대한 정보를 비트단위로 저장하면 해당 문제를 알맞게 풀 수 있다.

기존 최단 거리를 구하는 방식을 동일하기에 해당 부분은 제외하고 설명하겠다.(BFS 알고리즘)

우선 visited를 2중 배열이 아닌 3중 배열로 생성하여 key값을 저장할 수 있도록 한다.

boolean[][][] visited = new boolean[col][row][1<<doors.size()]; 
// 이때 비트 마스킹을 위해 '1<<문의 개수' 크기로 선언해준다

이 후 qu에 있는 데이터를 처리하면서 이동 경로에 A~Z(문)이 존재할 경우 가지고 있는 key에서 해당 문의 index 부분이 1이면 통과하고, 0이라면 continue로 문을 통과하지 않게 설계한다.

...
int mx = x + dx[i];
int my = y + dy[i];
if(mx < 0 || mx >= row || my < 0 || my >= col || board[my][mx].equals("#") 
        || visited[my][mx][key]) continue;

if( board[my][mx].codePointAt(0) >= "A".codePointAt(0) 
   && board[my][mx].codePointAt(0) <= "Z".codePointAt(0) 
   && (key & (1 << doors.indexOf(board[my][mx]))) != (1 << doors.indexOf(board[my][mx]))) {
    continue;
}
...

이동 경로에 a~z(key)가 존재한다면, 해당 키를 기존에 가지고 있다면 일반적인 움직임으로 작동하고, 만약 기존에 가지고 있지 않는 키라면 key의 비트에서 해당 키의 index를 1로 변경하고, 해당 키를 전달해준다.

...
if(board[my][mx].codePointAt(0) >= "a".codePointAt(0) 
        && board[my][mx].codePointAt(0) <= "z".codePointAt(0)) {
    char target = (char) (board[my][mx].codePointAt(0) - 32);
    String str = Character.toString(target);
    if(doors.contains(str)) {
        int tempKey = key | (1<<doors.indexOf(str));
        qu.add(new Pos(mx,my,tempKey));
        count.add(c+1);
    }else {
        qu.add(new Pos(mx,my,key));
        count.add(c+1);
    }
}else {
    qu.add(new Pos(mx,my,key));
    count.add(c+1);
}
...

풀이 코드

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.io.*;

public class Main {
	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static StringTokenizer st;
	
	public static int[] dx = {0,1,0,-1};
	public static int[] dy = {-1,0,1,0};
	public static String[][] board;
	public static ArrayList<Pos> destinations = new ArrayList<>(); 
	public static ArrayList<String> doors = new ArrayList<>();
	public static ArrayList<String> keys = new ArrayList<>(); 
	public static class Pos{
		int x;
		int y;
		int key;
		
		public Pos() {}
		public Pos(int x, int y) {
			this.x = x;
			this.y = y;
			this.key = 0;
		}
		public Pos(int x, int y, int key) {
			this.x = x;
			this.y = y;
			this.key = key;
		}
		@Override
		public String toString() {
			return "pos => x : " + x + ", y = " + y + " key = " + Integer.toBinaryString(key);
		}
	}
	
	public static void main(String[] args) throws IOException{
		st = new StringTokenizer(br.readLine());
		
		int col = Integer.parseInt(st.nextToken());
		int row = Integer.parseInt(st.nextToken());
		
		board = new String[col][row];
		Pos curPos = new Pos();
		
		for(int c = 0; c < col;c++) {
			board[c] = br.readLine().split("");
			
			for(int r = 0; r < row; r++) {
				if(board[c][r].equals("0")) {
					curPos.x = r;
					curPos.y = c;
				}else if(board[c][r].equals("1")) {
					destinations.add(new Pos(r,c));
				}else if(board[c][r].codePointAt(0) >= "A".codePointAt(0) && board[c][r].codePointAt(0) <= "Z".codePointAt(0)) {
					if(!doors.contains(board[c][r]))
						doors.add(board[c][r]);
				}else if(board[c][r].codePointAt(0) >= "a".codePointAt(0) && board[c][r].codePointAt(0) <= "z".codePointAt(0)) {
					if(!keys.contains(board[c][r]))
						keys.add(board[c][r]);
				}
			}
		}
		
		doors.sort(null);

		boolean[][][] visited = new boolean[col][row][1<<doors.size()];
		Queue<Pos> qu = new LinkedList<>();
		Queue<Integer> count = new LinkedList<>();
		
		qu.add(curPos);
		count.add(0);
		
		boolean possible = false;
		while(!qu.isEmpty()) {
			Pos cur = qu.poll();
			int x = cur.x;
			int y = cur.y;
			int key = cur.key;
			int c = count.poll();
			
			
			if(board[y][x].equals("1")) {
				System.out.println(c);
				possible = true;
				break;
			}
			
			if(visited[y][x][key])continue;
			visited[y][x][key] = true;
			
			for(int i = 0 ; i < 4; i++) {
				int mx = x + dx[i];
				int my = y + dy[i];
				if(mx < 0 || mx >= row || my < 0 || my >= col || board[my][mx].equals("#") 
						|| visited[my][mx][key]) continue;
			
				if( board[my][mx].codePointAt(0) >= "A".codePointAt(0) && board[my][mx].codePointAt(0) <= "Z".codePointAt(0) && (key & (1 << doors.indexOf(board[my][mx]))) != (1 << doors.indexOf(board[my][mx]))) {
					continue;
				}
				
				if(board[my][mx].codePointAt(0) >= "a".codePointAt(0) 
						&& board[my][mx].codePointAt(0) <= "z".codePointAt(0)) {
					char target = (char) (board[my][mx].codePointAt(0) - 32);
					String str = Character.toString(target);
					if(doors.contains(str)) {
						int tempKey = key | (1<<doors.indexOf(str));
						qu.add(new Pos(mx,my,tempKey));
						count.add(c+1);
					}else {
						qu.add(new Pos(mx,my,key));
						count.add(c+1);
					}
				}else {
					qu.add(new Pos(mx,my,key));
					count.add(c+1);
				}
			}
		}
		if(!possible)System.out.println(-1);
		
	}
}

[LostArk Open API] 로스트아크 프로젝트 구상 및 open API 사용하기

Pepperminttt — Thu, 24 Aug 2023 10:05:47 +0900

로스트아크 Open API 프로젝트

로스트아크는 현재 유저들이 직접 게임 내 정보를 활용할 수 있도록 Open API를 제공한다. 해당 API로 로스트아크의 News, 캐릭터 정보, 길드, 마켓 등 다양한 인게임의 정보를 받아올 수있다.

API로 받아올 수 있는 데이터 카테고리

개인적으로 로스트아크에서 생활 컨텐츠를 즐기는 편인데, 해당 API로 효율 좋은 생활 컨텐츠 방향을 정할 수 있을 것이라고 생각해서 생활 관련 정보를 제공해주는 프로젝트를 진행하기로 했다. 해당 정보를 알려주는 사이트들은 이미 많기 때문에 좋은 성능이라기 보다는 나에게 최적화 된 사이트를 만드는 것이 목적이다.

- 참고 사이트

아이스 팽 : https://loa.icepeng.com/
로아 도구 : https://loatool.taeu.kr/

현재는 간단한 사이트만 생각하고 있으나, 추후에 위 참고 사이트와 같이 새로운 기능을 더 추가할 예정이다.

로스트아크 Open API 사용해보기

프로젝트를 진행하기 위해 가장 먼저 API를 사용해보기로 하였다.

1. Open API key 발급 받기

우선 로스트아크 Open API 사이트에 접속을 하고 Stove 로그인을 진행한다.

가운데 'GET ACCESS TO LOSTARK API' 버튼을 눌러 발급 페이지로 이동하면 아래 화면처럼 기존 발급된 API 데이터와 새로 만들 수 있는 버튼이 존재한다.

API키와 이전 생성한 key의 이름은 가린 상태이다.

'CREATE A NEW CLIENT' 버튼을 눌러 key 발급을 진행하면 된다. 해당 과정은 간단하기에 설명은 넘어가기로 한다.

2. API Key 테스트해보기

해당 홈페이지에서는 API를 사용하기 위한 Documents를 제공해주고 있다. Documents에서는 해당 API를 사용해볼 수 있어 쉽게 사용법을 이해할 수 있었다.

현재 공지사항을 받아오는 API로 API Key를 테스트해보자

news 관련 Documents

위 사진에서 'AUTHORIZE' 버튼을 눌러 이전에 발급 받은 API key를 입력해주자. 이 때 Input box에 존재하는 bearer는 지우지 않고 뒤에 key를 입력해주자.

API key 입력 예시

key등록 후 아래 NEWS 탭을 선택하여 'Try it out' 버튼을 통해 해당 API를 테스트 할 수 있다.

정상적으로 Response 데이터가 나오는 것을 확인할 수 있다.

3. React app에서 API 사용해보기 (axois)

이제 홈페이지에서 제공하는 API를 axois를 통해 데이터를 받아와보자.

API테스트로는 현재 경매장에서 '오레하'라는 이름을 포함하는 아이템의 데이터를 가지고 와 볼 것이다.(생활 컨텐츠로 주로 제작하는 아이템이다.)

위 데이터를 가지고 오기 위해서는 markets/items API를 사용할 것이다.

markets/items API 명세서

우선 axios의 기본 세팅을 진행하다. 기본 세팅은 평소에 각자 사용하기 위한 기본 설정으로 진행하면 되는데 Headers에 authorization data를 넣어주어야한다. 이때 데이터는 이전에 발급 받은 API key를 넣어주면 된다.

필자는 개인적으로 instance를 미리 만들어두는 편이라 아래와 같이 사전 작업을 진행하였다. API key는 env에 넣어주었다.

import axios from "axios";

const accessToken = process.env.REACT_APP_API_TOKEN;

const instance = axios.create({
  baseURL: "https://developer-lostark.game.onstove.com",
  headers: {
    "content-type": "application/json;charset-UTF-8",
    accept: "application/json,",
  },
});

instance.interceptors.request.use(
  function (config: any) {
    config.headers!.authorization = accessToken;
    return config;
  },
  function (error) {
    return Promise.reject(error);
  }
);
export default instance;

이제 API를 호출하기 전에 POST로 보내줄 data를 만들어보자.

markets/items에 필요한 data는 명세서에서 확인할 수 있다.

이 때 해당 데이터에 입력할 값은 /markets/options API로 확인할 수 있다.

해당 데이터는 홈페이지에서 확인하도록 하자.(스크롤로 모든 데이터를 확인할 수 있다.)

이제 모든 준비가 끝났으니 바로 API를 사용해보자

  const getAPIData = async () => {
    const res = instance({
      method: "post",
      url: "markets/items",
      data: {
        Sort: "GRADE",
        CategoryCode: 50010,
        ItemName: "오레하",
        PageNo: 0,
        SortCondition: "ASC",
      },
    }).then((data) => {
      console.log(data);
    });
  };

  useEffect(() => {
    getAPIData();
  }, []);

위 코드처럼 정확한 데이터를 입력하면 아래와 같이 콘솔창에 원하는 데이터들이 나오는 것을 확인할 수 있다.

마치며

이번 포스팅에서는 간단하게 API를 테스트 해보았고, 이제 다음 포스트에서는 받아오는 데이터를 활용하는 포스트를 작성할 예정이다.

[Java] ArrayDeque 클래스

Pepperminttt — Wed, 23 Aug 2023 10:10:01 +0900

들어가기 전에

ArrayDeque 클래스는 이름에서도 알 수 있듯이 Deque와 관련된 클래스인 것을 알 수 있다. 그리고 Stack 클래스의 문제점, LIFO 구조를 만들 때 ArrayDeque로 해야 하는 상황에 대해서 알아보자.

public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable {}

위 코드에서 보면 상속관계를 보니 Deque 인터페이스를 구현하고 있는 클래스인 것을 알 수 있다. 그런데 Stack 클래스 대신에 ArrayDeque 클래스를 사용해서 LIFO 구조를 만들어라 라는 말이 있다. 왜냐하면 Stack 클래스는 LIFO 구조를 유지하기 위해서는 Vector 클래스를 상속받으면 안되지만 자바 초기 버전부터 존재하다 보니 자바에서 잘못 상속을 한 경우입니다.

우선 스택 클래스에는 큰 문제점 3가지가 존재하는데 어떤 것인지 살펴보자.

Stack 클래스의 문제점 3가지

public class Stack<E> extends Vector<E> {

    public Stack() {
    }

    public E push(E item) {
        addElement(item);

        return item;
    }

    public synchronized E pop() {
        E       obj;
        int     len = size();

        obj = peek();
        removeElementAt(len - 1);

        return obj;
    }

    public synchronized E peek() {
        int     len = size();

        if (len == 0)
            throw new EmptyStackException();
        return elementAt(len - 1);
    }

    public boolean empty() {
        return size() == 0;
    }

    public synchronized int search(Object o) {
        int i = lastIndexOf(o);

        if (i >= 0) {
            return size() - i;
        }
        return -1;
    }

}

Stack 클래스는 Vector 클래스를 확장하고 있는 것을 볼 수 있다. 그리고 메소드들 마다 synchronized 키워드를 붙혀 멀티 스레드 환경에서 Thread-Safe한 것을 볼 수 있다. (push 메소드도 내부 코드를 따라가다 보면 Vector 클래스의 push를 사용해 synchronized가 되어 있다.)

Stack 클래스의 단점 3가지를 정리하면 아래와 같다.

모든 메소드에 synchronized가 있기 때문에 단일 스레스 환경에서는 성능이 떨어진다.
Vector 클래스를 상속받았기 때문에 LIFO 구조를 유지하는 것이 아니라 중간에서 데이터를 삭제하고 삽입하는 것이 가능하다.
Stack 클래스를 만들 때 초기 용량을 설정할 수 없다.

이러한 단점을 보완하기 위해서 LIFO 구조를 만들 때 ArrayDeque를 사용하라 권장한다.

ArrayDeque는 무엇일까?

This class is likely to be faster than Stack when used as a stack, and faster than LinkedList when used as a queue.

ArrayDeque 공식문서에 보면 스택구조로 사용하면 Stack 클래스보다 빠르고, 큐 구조로 사용하면 Queue 클래스보다 빠르다고 한다.

Using the Deque interface is the most convenient approach for LIFO data structures as it provides all the needed stack operations

이처럼 LIFO 구조를 만들기 위해 적합한 클래스는 Deque 인터페이스를 구현하는 ArrayDeque 클래스이다. 하지만 ArrayDeque는 Thread-Safe하지 않다는 단점이 있다.그렇기에 멀티 쓰레드 환경에서는 문제가 있습니다. 그래서 아래와 같이 synchronized를 장식해 ArrayDeque를 만들 수 있다.

public class DequeBasedSynchronizedStack<T> {

    // Internal Deque which gets decorated for synchronization.
    private ArrayDeque<T> dequeStore;

    public DequeBasedSynchronizedStack(int initialCapacity) {
        this.dequeStore = new ArrayDeque<>(initialCapacity);
    }

    public DequeBasedSynchronizedStack() {
        dequeStore = new ArrayDeque<>();
    }

    public synchronized T pop() {
        return this.dequeStore.pop();
    }

    public synchronized void push(T element) {
        this.dequeStore.push(element);
    }

    public synchronized T peek() {
        return this.dequeStore.peek();
    }

    public synchronized int size() {
        return this.dequeStore.size();
    }
}

ArrayDeque 다른 특징들

Resizable-array implementation of the Deque interface. Array deques have no capacity restrictions

공식 문서에 보면 위와 같이 ArrayDeque는 용량 제한이 없다고 말한다. 내부적으로 어떤 방식으로 일어나는지 알아보자.

public class ArrayDeque<E> extends AbstractCollection<E>
                           implements Deque<E>, Cloneable, Serializable
{
    transient Object[] elements; // non-private to simplify nested class access

    transient int head;

    transient int tail;

    public ArrayDeque() {
        elements = new Object[16];
    }

    private void doubleCapacity() {
        assert head == tail;
        int p = head;
        int n = elements.length;
        int r = n - p; // number of elements to the right of p
        int newCapacity = n << 1;
        if (newCapacity < 0)
            throw new IllegalStateException("Sorry, deque too big");
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);
        System.arraycopy(elements, 0, a, r, p);
        elements = a;
        head = 0;
        tail = n;
    }  
}

위의 코드는 ArrayDeque 내부 코드 중 일부이다. 일단 먼저 생성자에 매개변수 없이 만들면 기본 용량이 16인 것을 볼 수 있다. 그러면 공식문서에서 나온거 처럼 ArrayDeque는 기본 용량을 넘으면 어떻게 용량을 추가할까?

그건 doubleCapacity() 메소드를 보면 알 수 있다.

int n = elements.length;
int newCapacity = n << 1;

위와 같이 배열의 길이의 2배 만큼 늘리는 것을 볼 수 있다. 그 외적인 Stack, Queue 구조로 할 수 있는 메소드들이 있다.

Reference

[백준 / Java] 2473번 : 세 용액

Pepperminttt — Tue, 22 Aug 2023 10:10:16 +0900

문제

KOI 부설 과학연구소에서는 많은 종류의 산성 용액과 알칼리성 용액을 보유하고 있다. 각 용액에는 그 용액의 특성을 나타내는 하나의 정수가 주어져있다. 산성 용액의 특성값은 1부터 1,000,000,000까지의 양의 정수로 나타내고, 알칼리성 용액의 특성값은 -1부터 -1,000,000,000까지의 음의 정수로 나타낸다.

같은 양의 세 가지 용액을 혼합한 용액의 특성값은 혼합에 사용된 각 용액의 특성값의 합으로 정의한다. 이 연구소에서는 같은 양의 세 가지 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들려고 한다.

예를 들어, 주어진 용액들의 특성값이 [-2, 6, -97, -6, 98]인 경우에는 특성값이 -97와 -2인 용액과 특성값이 98인 용액을 혼합하면 특성값이 -1인 용액을 만들 수 있고, 이 용액이 특성값이 0에 가장 가까운 용액이다. 참고로, 세 종류의 알칼리성 용액만으로나 혹은 세 종류의 산성 용액만으로 특성값이 0에 가장 가까운 혼합 용액을 만드는 경우도 존재할 수 있다.

산성 용액과 알칼리성 용액이 주어졌을 때, 이 중 같은 양의 세 개의 서로 다른 용액을 혼합하여 특성값이 0에 가장 가까운 용액을 만들어내는 세 용액을 찾는 프로그램을 작성하시오.

입력

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 3 이상 5,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -1,000,000,000 이상 1,000,000,000 이하이다. N개의 용액들의 특성값은 모두 다르고, 산성 용액만으로나 알칼리성 용액만으로 입력이 주어지는 경우도 있을 수 있다.

출력

첫째 줄에 특성값이 0에 가장 가까운 용액을 만들어내는 세 용액의 특성값을 출력한다. 출력해야하는 세 용액은 특성값의 오름차순으로 출력한다. 특성값이 0에 가장 가까운 용액을 만들어내는 경우가 두 개 이상일 경우에는 그 중 아무것이나 하나를 출력한다.

예제 입력 1

5
-2 6 -97 -6 98

예제 출력 1

-97 -2 98

예제 입력 2

7
-2 -3 -24 -6 98 100 61

예제 출력 2

-6 -3 -2

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

2473번: 세 용액

첫째 줄에는 전체 용액의 수 N이 입력된다. N은 3 이상 5,000 이하의 정수이다. 둘째 줄에는 용액의 특성값을 나타내는 N개의 정수가 빈칸을 사이에 두고 주어진다. 이 수들은 모두 -1,000,000,000 이상

www.acmicpc.net

문제 풀이

해당 문제는 세 용액의 합의 절댓값이 0과 가까운 조합을 구하는 문제로 투포인터 / 이분 탐색을 통해 문제를 풀 수 있다.

투 포인터 알고리즘을 사용하기 위해서는 두개의 포인트를 사용해야 하는데 해당 문제는 세 개의 포인트를 가지고 있기에 하나의 용액을 고정하고, 나머지 두 용액을 투포인터로 합을 구하여 (고정한 용액 + 투 포인터로 구한 두 용액)의 절댓값을 비교하며 문제를 풀었다.

이때 배열을 순회하면서 두 용액 구하는 과정을 N번 반복하면 되기 때문에 O(N^2) 시간으로 문제를 풀이 할 수 있다.

한 가지 주의할 점은 세 용액 문제에서 3,000,000,000 이상이 될 수 있기 때문에 long 타입으로 풀어줘야 한다.

풀이 코드

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.io.*;


public class Main {
	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	public static StringTokenizer st;
	public static StringBuilder sb = new StringBuilder();
	public static Long INF = Long.MAX_VALUE;

	public static ArrayList<Integer> preorder = new ArrayList<>();
	public static int[] inorder;
	public static int[] postorder;
	
	public static void main(String[] args) throws IOException{
		int N = Integer.parseInt(br.readLine());
	
		long[] nums = Arrays.stream(br.readLine().split(" ")).mapToLong(Long::parseLong).sorted().toArray();
	
		long min = INF;
		long[] answer = new long[3];
		for(int i = 0 ; i < N - 2 ; i++) {
			long exNum = nums[i];
			int left = i + 1;
			int right = N-1;
			
			while(left < right) {
				long sum = nums[left] + nums[right] + exNum;
				if(min > Math.abs(sum)) {
					min = Math.abs(sum);
					answer[0] = exNum;
					answer[1] = nums[left];
					answer[2] = nums[right];
				}else {
					if(sum > 0) {
						right--;
					}else {
						left++;
					}
				}
			}
		}
		System.out.printf("%d %d %d",answer[0], answer[1], answer[2]);
	}
}

[백준 / Java] 2263번 : 트리의 순회

Pepperminttt — Mon, 21 Aug 2023 10:10:34 +0900

문제

n개의 정점을 갖는 이진 트리의 정점에 1부터 n까지의 번호가 중복 없이 매겨져 있다. 이와 같은 이진 트리의 인오더와 포스트오더가 주어졌을 때, 프리오더를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 n(1 ≤ n ≤ 100,000)이 주어진다. 다음 줄에는 인오더를 나타내는 n개의 자연수가 주어지고, 그 다음 줄에는 같은 식으로 포스트오더가 주어진다.

출력

첫째 줄에 프리오더를 출력한다.

예제 입력 1

3
1 2 3
1 3 2

예제 출력 1

2 1 3

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

2263번: 트리의 순회

www.acmicpc.net

문제 풀이

해당 문제는 인오더, 포스트오더 순회를 가지고 프리 오더 순회를 구하는 문제이다. 해당 문제는 포스트 오더의 마지막 값이 해당 순회의 root라는 점을 알아차려야 풀 수 있는 문제이다.

root를 파악하고 이를 인 오더에 적용하여 작은 트리의 root 찾는 방식은 반복하면 된다.

다음과 같은 트리가 있을 때, 인오더와 포스트오더로 나타내면 아래와 같다.

InOrder : 4 - 2 - 5 - 1 - 6 - 3 - 7

PostOrder : 4 - 5 - 2 - 6 - 7 - 3 - 1

포스트오더로 나열하면 가장 오른쪽에 있는 값은 트리의 루트가 된다.

포스트오더는 왼쪽 노드 - 오른쪽 노드 - 가운데 노드 순서대로 순회하기 때문이다.

PostOrder : 4 - 5 - 2 - 6 - 7 - 3 - 1

인오더에서는 루트를 기준으로 왼쪽은 왼쪽 자식 트리, 오른쪽은 오른쪽 자식 트리이다.

인오더는 왼쪽 노드 - 가운데 노드 - 오른쪽 노드 순서대로 순회하기 때문이다.

InOrder : 4 - 2 - 5 - 1 - 6 - 3 - 7

정리하자면, 인오더와 포스트오더의 정보가 주어졌을 때,

포스트오더를 통해서는 트리의 루트를 알 수 있고, 인오더를 통해서는 왼쪽 자식 트리와 오른쪽 자식 트리를 알 수 있다.

이제 이렇게 얻은 정보로 프리오더의 순서를 알 수 있다.

프리오더는 가운데 노드 - 왼쪽 노드 - 오른쪽 노드 순서대로 순회한다.

따라서 포스트오더에서 가장 오른쪽에 있던 루트 노드가 프리오더에서는 가장 먼저 오게 된다.

PostOrder : 4 - 5 - 2 - 6 - 7 - 3 - 1

PreOrder : 1 - ○ - ○ - ○ - ○ - ○ - ○

그렇다면 1 다음으로는 어떤 수가 와야 할까?

가운데 노드를 방문한 다음에는 왼쪽 자식 트리를 똑같은 방법으로 순회해야 한다.

마찬가지로 왼쪽 자식 트리의 루트 노드를 먼저 방문하고 그 다음 왼쪽 노드, 오른쪽 노드를 차례로 방문한다.

왼쪽 자식 노드에서는 2가 루트노드이므로 1 다음에는 2를 순회하게 된다.

마찬가지로 인오더에서 2를 기준으로 왼쪽에 있는 값들은 왼쪽 자식 노드, 오른쪽에 있는 값들은 오른쪽 자식 노드에 해당함을 알 수 있다.

PostOrder : 4 - 5 - 2

PreOrder : 1 - 2 - ○ - ○ - ○ - ○ - ○

InOrder : 4 - 2 - 5

이런식으로 계속 포스트오더에서 트리 노드를 찾고, 인오더에서는 트리 노드를 기준으로 좌우로 나누어 왼쪽 자식 트리와 오른쪽 자식 트리를 찾는방식으로 프리오더의 순서를 채워넣으면 된다.

이렇게 분할하고 반복되는 과정은 재귀를 이용하게 손쉽게 구현할 수 있다.

그렇다면 언제까지 반복하는가?

트리에 노드가 하나밖에 없을때까지 반복한다. 즉, 더 이상 왼쪽 자식 트리와 오른쪽 자식 트리로 나눌 수 없을 때까지 반복한다.

풀이 코드

import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
import java.io.*;


public class Main {
	public static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	public static BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
	public static StringTokenizer st;
	public static StringBuilder sb = new StringBuilder();
	public static int INF = 100_000_000;

	public static ArrayList<Integer> preorder = new ArrayList<>();
	public static int[] inorder;
	public static int[] postorder;
	
	public static void main(String[] args) throws IOException{
		int N = Integer.parseInt(br.readLine());
		
		inorder = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		postorder = Arrays.stream(br.readLine().split(" ")).mapToInt(Integer::parseInt).toArray();
		
		getPreorder(0,N-1,0,N-1);
		for(int i = 0 ; i < N;i++) {
			sb.append(preorder.get(i) + " ");
		}
		System.out.println(sb.toString());
	}
	
	public static void getPreorder(int inStart, int inEnd, int postStart, int postEnd) {
		if(inStart>inEnd || postStart > postEnd)return;
		
		int root = postorder[postEnd];
		int index = 0;
		for(int i = 0 ; i < inorder.length;i++) {
			if(root == inorder[i])index = i;
		}

		preorder.add(root);
		getPreorder(inStart, index - 1, postStart, postStart + index - inStart - 1);
		getPreorder(index + 1, inEnd, postStart + index - inStart, postEnd - 1);
		
	}
	
}

Reference

https://lotuslee.tistory.com/82