문제

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

KOI 통신연구소는 레이저를 이용한 새로운 비밀 통신 시스템 개발을 위한 실험을 하고 있다. 실험을 위하여 일직선 위에 N개의 높이가 서로 다른 탑을 수평 직선의 왼쪽부터 오른쪽 방향으로 차례로 세우고, 각 탑의 꼭대기에 레이저 송신기를 설치하였다. 모든 탑의 레이저 송신기는 레이저 신호를 지표면과 평행하게 수평 직선의 왼쪽 방향으로 발사하고, 탑의 기둥 모두에는 레이저 신호를 수신하는 장치가 설치되어 있다. 하나의 탑에서 발사된 레이저 신호는 가장 먼저 만나는 단 하나의 탑에서만 수신이 가능하다.

예를 들어 높이가 6, 9, 5, 7, 4인 다섯 개의 탑이 수평 직선에 일렬로 서 있고, 모든 탑에서는 주어진 탑 순서의 반대 방향(왼쪽 방향)으로 동시에 레이저 신호를 발사한다고 하자. 그러면, 높이가 4인 다섯 번째 탑에서 발사한 레이저 신호는 높이가 7인 네 번째 탑이 수신을 하고, 높이가 7인 네 번째 탑의 신호는 높이가 9인 두 번째 탑이, 높이가 5인 세 번째 탑의 신호도 높이가 9인 두 번째 탑이 수신을 한다. 높이가 9인 두 번째 탑과 높이가 6인 첫 번째 탑이 보낸 레이저 신호는 어떤 탑에서도 수신을 하지 못한다.

탑들의 개수 N과 탑들의 높이가 주어질 때, 각각의 탑에서 발사한 레이저 신호를 어느 탑에서 수신하는지를 알아내는 프로그램을 작성하라.

입력

첫째 줄에 탑의 수를 나타내는 정수 N이 주어진다. N은 1 이상 500,000 이하이다. 둘째 줄에는 N개의 탑들의 높이가 직선상에 놓인 순서대로 하나의 빈칸을 사이에 두고 주어진다. 탑들의 높이는 1 이상 100,000,000 이하의 정수이다.

 

출력

첫째 줄에 주어진 탑들의 순서대로 각각의 탑들에서 발사한 레이저 신호를 수신한 탑들의 번호를 하나의 빈칸을 사이에 두고 출력한다. 만약 레이저 신호를 수신하는 탑이 존재하지 않으면 0을 출력한다.


코드

package barkingDog.stack;

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

public class Main {
    public static class Node{
        int idx;
        int value;

        public Node(int idx, int value){
            this.idx = idx;
            this.value = value;
        }
    }

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

        int N = Integer.parseInt(br.readLine());

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

        Stack<Node> stack = new Stack<>();

        StringBuilder sb = new StringBuilder();

        for(int i = 1; i <= N; i++){
            int v = Integer.parseInt(st.nextToken());

            while(true){
                // 스택에 아무 것도 없으면
                if(stack.isEmpty()){
                    // 현재 값을 스택에 넣기
                    // 내 앞에 값이 없으니(큰 값이 없으니) 0 넣기
                    stack.push(new Node(i, v));
                    sb.append("0 ");
                    break;
                }

                // 스택에 값이 있으면
                Node node = stack.peek();

                // 스택에 있는 값보다 현재 값이 작으면
                if(node.value < v){
                    // 스택에 있는 값 뽑기
                    // 나보다 큰 값이 있거나 스택이 빌 때까지
                    // 계속 뽑게 됨
                    stack.pop();
                }
                // 스택에 있는 값보다 현재 값이 크거나 같으면
                // 스택에 있는 값이 신호를 받을 것임!
                else{
                    // 스택에 있는 값의 인덱스를 정답에 추가
                    // 스택에 현재 값 추가하기
                    sb.append(node.idx).append(" ");
                    stack.push(new Node(i, v));
                    break;
                }


            }
        }

        System.out.println(sb.toString());
    }
}

 

현재 탑보다 높은 탑 중 가장 왼쪽으로 현재 탑과 가까운 탑이 신호를 수신한다. 방향도 한 방향이며, 나랑 가장 가까운 값을 확인하는 것이기 때문에 스택을 사용해 문제를 풀었다. 결과는 stringbuilder에 중간 중간 추가하였다.

주석에 자세하게 작성해놓았지만, 스택이 비어있을 때는 현재 탑의 높이를 스택에 넣고, 내 앞에 값이 없다는 것은 나보다 큰 값이 없다는 얘기이므로 0도 같이 sb에 추가해주었다. 스택에 값이 있을 때는 스택의 가장 상단에 있는 값과 현재 값을 비교해 현재 값보다 큰 값이 나올 때까지 계속 스택에서 뽑는다. 현재 값보다 큰 값이 스택에 최상단에 있게 되면 그 값을 stringbuilder에 추가하고 스택에 현재 값을 넣는다.

이때, 현재 탑의 높이보다 큰 값이 나올 때까지 계속 뽑아도 되는 이유가 궁금할 수 있는데, 현재 값의 오른쪽에 있는 탑들 중 현재 값보다 낮은 높이인 탑의 입장에서는 현재 탑의 왼쪽 탑 중 현재 탑보다 높은 탑이 없다면 어차피 현재 탑이 신호를 수신할 것이고, 현재 탑의 높이는  나중에 스택에 넣기 때문에 상관없다. 또한, 현재 탑의 오른쪽에 있는 탑들 중 현재 값보다 높은 높이인 탑의 입장에서는 어차피 현재 탑의 높이가 자신의 높이보다 낮기 때문에 적어도 현재 탑의 높이보다 낮은 탑들은 일단 수신을 받을 수 없음이 확실하므로 스택에서 제거되어도 상관없다.

 

++ 추가로 원래 입력을 적게 받는다고 생각해 Scanner를 사용하였는데, 메모리 초과가 나서 BufferedReader로 변경하여 해결했다. 문제를 읽어보니 N이 500,000까지 돼 탑을 500,000개 입력 받을 수도 있었다... Scanner와 BufferedReader의 메모리 효율이 다른 이유는 아래에 따로 정리하겠다.


(수정 예정! Scanner vs BufferedReader 의 메모리 효율)

728x90

문제

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

지민이는 N개의 원소를 포함하고 있는 양방향 순환 큐를 가지고 있다. 지민이는 이 큐에서 몇 개의 원소를 뽑아내려고 한다.

지민이는 이 큐에서 다음과 같은 3가지 연산을 수행할 수 있다.

  1. 첫 번째 원소를 뽑아낸다. 이 연산을 수행하면, 원래 큐의 원소가 a1, ..., ak이었던 것이 a2, ..., ak와 같이 된다.
  2. 왼쪽으로 한 칸 이동시킨다. 이 연산을 수행하면, a1, ..., ak가 a2, ..., ak, a1이 된다.
  3. 오른쪽으로 한 칸 이동시킨다. 이 연산을 수행하면, a1, ..., ak가 ak, a1, ..., ak-1이 된다.

큐에 처음에 포함되어 있던 수 N이 주어진다. 그리고 지민이가 뽑아내려고 하는 원소의 위치가 주어진다. (이 위치는 가장 처음 큐에서의 위치이다.) 이때, 그 원소를 주어진 순서대로 뽑아내는데 드는 2번, 3번 연산의 최솟값을 출력하는 프로그램을 작성하시오.

 

입력

첫째 줄에 큐의 크기 N과 뽑아내려고 하는 수의 개수 M이 주어진다. N은 50보다 작거나 같은 자연수이고, M은 N보다 작거나 같은 자연수이다. 둘째 줄에는 지민이가 뽑아내려고 하는 수의 위치가 순서대로 주어진다. 위치는 1보다 크거나 같고, N보다 작거나 같은 자연수이다.

 

출력

첫째 줄에 문제의 정답을 출력한다.


코드

package barkingDog.deque;

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

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

        int minCnt = 0;

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

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


        Deque<Integer> deque = new ArrayDeque<>();

        for(int i = 1; i <= N; i++){
            deque.add(i);
        }

        for(int i = 0; i < M; i++){
            String target = st.nextToken();
            int targetIdx = 0;

            Iterator iterator = deque.iterator();

            while(iterator.hasNext()){
                if(iterator.next().toString().equals(target)){
                    break;
                }
                targetIdx++;
            }

            if(targetIdx < deque.size() - targetIdx){
                // 왼쪽으로 회전시키기
                while(deque.peekFirst() != Integer.parseInt(target)){
                    deque.add(deque.poll());
                    minCnt++;
                }

            }else{
                // 오른쪽으로 회전시키기
                while(deque.peekFirst() != Integer.parseInt(target)){
                    deque.addFirst(deque.pollLast());
                    minCnt++;
                }
            }

            // 맨 앞에 있는 target 뽑기
            deque.pollFirst();
        }

        System.out.println(minCnt);
    }
}

문제에서 뽑고 싶은 수를 제일 앞으로 위치 시켜야 1번 연산을 통해 원하는 수를 뽑을 수 있다. 또한, 최소로 2번과 3번 연산을 사용하기 위해서는 ① 현재 뽑고 싶은 target 원소의 위치를 알아내고 ②왼쪽과 오른쪽 중에서 최소로 회전할 수 있는 방향을 고른다.

 

① 현재 뽑고 싶은 target 원소의 인덱스를 알아내기

Iterator를 활용하였고, target 값과 같은 원소를 발견하면 break 해서 target의 인덱스를 알아냈다.

 

② 왼쪽 회전 vs 오른쪽 회전

왼쪽 회전을 해서 특정 원소를 맨 앞으로 이동시키는 데 걸리는 횟수는 target의 index와 같고, 오른쪽 회전을 해서 특정 원소를 맨 앞으로 이동시키는 데 걸리는 횟수는 전체 원소 개수 - target의 index와 같다.

둘 중에 더 적은 횟수인 방식을 고르고, 실제로 회전을 시켜주면서 개수도 세고 원소를 빼고 넣는 연산도 같이 해주었다. 물론 회전 횟수는 이미 구해놨으나, 원소를 빼고 넣는 연산은 필수적이기 때문에 하는 김에 같이 횟수도 정석으로 구해주었다.

 

728x90

'Algorithm > 백준' 카테고리의 다른 글

[백준][Java] 2493. 탑  (0) 2024.08.13
[백준][Java] 2178. 미로 탐색  (0) 2024.02.11
[백준][Java] 1920. 수 찾기  (0) 2024.02.11
[백준][Java] 2630. 색종이 만들기  (0) 2024.02.06
[백준][Java] 14888. 연산자 끼워넣기  (0) 2024.02.05

문제

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

N개의 정수 A[1], A[2], …, A[N]이 주어져 있을 때, 이 안에 X라는 정수가 존재하는지 알아내는 프로그램을 작성하시오.

 

입력

첫째 줄에 자연수 N(1 ≤ N ≤ 100,000)이 주어진다. 다음 줄에는 N개의 정수 A[1], A[2], …, A[N]이 주어진다. 다음 줄에는 M(1 ≤ M ≤ 100,000)이 주어진다. 다음 줄에는 M개의 수들이 주어지는데, 이 수들이 A안에 존재하는지 알아내면 된다. 모든 정수의 범위는 -2³¹보다 크거나 같고 2³¹보다 작다.

 

출력

M개의 줄에 답을 출력한다. 존재하면 1을, 존재하지 않으면 0을 출력한다.


코드

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

public class Main {

    static int N;
    static int[] arr;
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();

        N = Integer.parseInt(br.readLine());

        arr = new int[N];
        StringTokenizer st = new StringTokenizer(br.readLine());

        for(int i = 0 ; i < N; i++){
            arr[i] = Integer.parseInt(st.nextToken());
        }
        Arrays.sort(arr);

        int M = Integer.parseInt(br.readLine());

        int[] targets = new int[M];
        st = new StringTokenizer(br.readLine());

        for(int i = 0; i < M; i++){
            targets[i] = Integer.parseInt(st.nextToken());
        }

        for(int i = 0; i < M; i++){
            int result = binarySearch(targets[i]);

            sb.append(result == -1 ? 0 : 1);
            sb.append("\n");
        }

        System.out.println(sb.toString());


    }

    static int binarySearch(int target){
        int left = 0;
        int right = N - 1;
        int mid;

        while(left <= right){

            mid = (left + right) / 2;
            
            if(arr[mid] == target){
                return mid; // 탐색 완
            }

            if(arr[mid] > target){
                right = mid - 1;
            }else {
                left = mid + 1;
            }

        }
    
        return -1; // 탐색 실패
       
    }
}

이 문제를 푸는 여러 방법이 있겠지만, 이분 탐색을 공부하는 김에 사용해보았다. left, right, mid는 A의 index를 의미하고, left와 right을 이용해 mid의 값을 갱신해나가며 값을 찾는다. A배열의 left부터 right까지 확인하여 target이 있는지 찾으면 된다. 이때, A 배열은 정렬이 되어 있어야 한다. left <= right 일 때까지 돌면서 반복하고, 만약 target 값과 A[mid]의 값이 같다면 target이 A 안에 있다는 의미이기 때문에 mid 값을 리턴한다. 만약 A[mid]가 target 보다 크다면, mid보다 왼쪽에 target이 있다는 의미이기 때문에 right을 `mid - 1`로 변경하여 A[left] ~ A[mid - 1] 까지의 배열만 탐색하도록 한다. 만약 A[mid] 가 target 보다 작다면 target이 mid 보다 오른쪽에 있다는 의미이기 때문에, 그 후에 탐색할 때는 A[mid + 1]부터 A[right]까지만 보면 된다. 따라서 left를 `mid + 1`로 변경하면 된다. 만약 while 문을 통과했는데 리턴하지 못했을 때는 A 배열에 target이 존재하지 않는 것이기 때문에 -1을 리턴한다.

728x90

문제

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

세준이는 양수와 +, -, 그리고 괄호를 가지고 식을 만들었다. 그리고 나서 세준이는 괄호를 모두 지웠다.

그리고 나서 세준이는 괄호를 적절히 쳐서 이 식의 값을 최소로 만들려고 한다.

괄호를 적절히 쳐서 이 식의 값을 최소로 만드는 프로그램을 작성하시오.

 

입력

첫째 줄에 식이 주어진다. 식은 ‘0’~‘9’, ‘+’, 그리고 ‘-’만으로 이루어져 있고, 가장 처음과 마지막 문자는 숫자이다. 그리고 연속해서 두 개 이상의 연산자가 나타나지 않고, 5자리보다 많이 연속되는 숫자는 없다. 수는 0으로 시작할 수 있다. 입력으로 주어지는 식의 길이는 50보다 작거나 같다.

 

출력

첫째 줄에 정답을 출력한다.


코드

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


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

        String[] minusArr = br.readLine().split("-"); // - 기준으로 나누기

        // 최종 결과
        int result = 0;

        for(int i = 0; i < minusArr.length; i++){
            String[] plusArr = minusArr[i].split("\\+"); // + 기준으로 나누기

            int sum = 0; // + 부호를 갖고있는 number 저장하는 변수

            for(int j = 0; j < plusArr.length; j++){
                sum += Integer.parseInt(plusArr[j]);
            }

            if(i == 0){ // - 로 나누어진 배열의 가장 앞 인덱스에 들어있는 원소는 더해주어야 함
                result += sum;
            }else{
                result -= sum;
            }
        }

        System.out.println(result);
    }
}

 

값을 최소로 만들기 위해서는 열린 괄호가 `-` 바로 뒤, 닫힌 괄호가 그 다음에 등장하는 `-` 의 바로 앞에 있으면 된다. 즉 `-` 연산자를 기준으로 연산이 이루어지면 되기 때문에, `-`를 기준으로 split를 하여 minusArr에 저장하였다. 즉 minusArr의 각 원소 계산을 마치고 `-` 연산을 해주면 된다. minusArr의 원소는 `50+25+45` 이런식으로 들어가 있을 것이기 때문에 minusArr의 원소도 `+`를 기준으로 split을 해서 plusArr에 저장하고, plusArr에 들어있는 원소들을 다 더했다. 그리고 더한 결과 값을 최종 result 에서 빼주었다. 이때 minusArr[0]은 빼주면 안되고 더해주어야 한다. minusArr이 `-`를 기준으로 split 하였지만 처음 index는 앞에 `-` 부호가 없는 상태이기 때문이다.

728x90

+ Recent posts