Sorting and Searching

정렬, 이분검색과 결정 알고리즘

1. 선택정렬

✨ 문제

N개이 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.

정렬하는 방법은 선택정렬입니다.

입력

첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.

두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.

출력

오름차순으로 정렬된 수열을 출력합니다.

예시 입력 1

6
13 5 11 7 23 15

예시 출력 1

5 7 11 13 15 23

🎐 답변

import java.util.Scanner;

public class SelectionSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 자연수 N을 입력받습니다.
        int N = scanner.nextInt();
        int[] numbers = new int[N];
        
        // N개의 자연수를 입력받습니다.
        for (int i = 0; i < N; i++) {
            numbers[i] = scanner.nextInt();
        }
        
        // 선택 정렬 수행
        selectionSort(numbers);
        
        // 정렬된 결과 출력
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }

    public static void selectionSort(int[] arr) {
        int N = arr.length;

        for (int i = 0; i < N - 1; i++) {
            // 현재 위치에서 가장 작은 값의 인덱스를 찾습니다.
            int minIndex = i;
            for (int j = i + 1; j < N; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 현재 위치의 값과 가장 작은 값을 교환합니다.
            if (minIndex != i) {
                int temp = arr[i];
                arr[i] = arr[minIndex];
                arr[minIndex] = temp;
            }
        }
    }
}

2. 버블정렬

✨ 문제

N개이 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.

정렬하는 방법은 버블정렬입니다.

입력

첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.

두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.

출력

오름차순으로 정렬된 수열을 출력합니다.

예시 입력 1

6
13 5 11 7 23 15

예시 출력 1

5 7 11 13 15 23

🎐 답변

import java.util.Scanner;

public class BubbleSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 자연수 N을 입력받습니다.
        int N = scanner.nextInt();
        int[] numbers = new int[N];
        
        // N개의 자연수를 입력받습니다.
        for (int i = 0; i < N; i++) {
            numbers[i] = scanner.nextInt();
        }
        
        // 버블 정렬 수행
        bubbleSort(numbers);
        
        // 정렬된 결과 출력
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }

    public static void bubbleSort(int[] arr) {
        int N = arr.length;

        // 버블 정렬 알고리즘
        for (int i = 0; i < N - 1; i++) {
            for (int j = 0; j < N - 1 - i; j++) {
                // 인접한 두 요소를 비교하여 정렬합니다.
                if (arr[j] > arr[j + 1]) {
                    // 교환
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }
}

3. 삽입정렬

✨ 문제

N개이 숫자가 입력되면 오름차순으로 정렬하여 출력하는 프로그램을 작성하세요.

정렬하는 방법은 삽입정렬입니다.

입력

첫 번째 줄에 자연수 N(1<=N<=100)이 주어집니다.

두 번째 줄에 N개의 자연수가 공백을 사이에 두고 입력됩니다. 각 자연수는 정수형 범위 안에 있습니다.

출력

오름차순으로 정렬된 수열을 출력합니다.

예시 입력 1

6
11 7 5 6 10 9

예시 출력 1

5 6 7 9 10 11

🎐 답변

import java.util.Scanner;

public class InsertionSort {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 자연수 N을 입력받습니다.
        int N = scanner.nextInt();
        int[] numbers = new int[N];
        
        // N개의 자연수를 입력받습니다.
        for (int i = 0; i < N; i++) {
            numbers[i] = scanner.nextInt();
        }
        
        // 삽입 정렬 수행
        insertionSort(numbers);
        
        // 정렬된 결과 출력
        for (int number : numbers) {
            System.out.print(number + " ");
        }
    }

    public static void insertionSort(int[] arr) {
        int N = arr.length;

        // 삽입 정렬 알고리즘
        for (int i = 1; i < N; i++) {
            int key = arr[i]; // 현재 정렬할 요소
            int j = i - 1;

            // 정렬된 부분 배열의 요소와 비교하여 위치를 찾습니다.
            while (j >= 0 && arr[j] > key) {
                arr[j + 1] = arr[j]; // 한 칸씩 뒤로 이동
                j--;
            }
            arr[j + 1] = key; // 적절한 위치에 삽입
        }
    }
}

4. LRU

✨ 문제

캐시메모리는 CPU와 주기억장치(DRAM) 사이의 고속의 임시 메모리로서 CPU가 처리할 작업을 저장해 놓았다가

필요할 바로 사용해서 처리속도를 높이는 장치이다. 워낙 비싸고 용량이 작아 효율적으로 사용해야 한다.

철수의 컴퓨터는 캐시메모리 사용 규칙이 LRU 알고리즘을 따른다.

LRU 알고리즘은 Least Recently Used 의 약자로 직역하자면 가장 최근에 사용되지 않은 것 정도의 의미를 가지고 있습니다.

캐시에서 작업을 제거할 때 가장 오랫동안 사용하지 않은 것을 제거하겠다는 알고리즘입니다.

캐시의 크기가 주어지고, 캐시가 비어있는 상태에서 N개의 작업을 CPU가 차례로 처리한다면 N개의 작업을 처리한 후

캐시메모리의 상태를 가장 최근 사용된 작업부터 차례대로 출력하는 프로그램을 작성하세요.

입력

첫 번째 줄에 캐시의 크기인 S(3<=S<=10)와 작업의 개수 N(5<=N<=1,000)이 입력된다.

두 번째 줄에 N개의 작업번호가 처리순으로 주어진다. 작업번호는 1 ~100 이다.

출력

마지막 작업 후 캐시메모리의 상태를 가장 최근 사용된 작업부터 차례로 출력합니다.

예시 입력 1

5 9
1 2 3 2 6 2 3 5 7

예시 출력 1

7 5 3 2 6

힌트

🎐 답변

import java.util.LinkedList;
import java.util.Scanner;

public class LRUCache {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 캐시의 크기 S와 작업의 개수 N 입력
        int S = scanner.nextInt();
        int N = scanner.nextInt();
        
        // 작업 번호를 저장할 LinkedList (FIFO 구조)
        LinkedList<Integer> cache = new LinkedList<>();

        // N개의 작업 번호 입력
        for (int i = 0; i < N; i++) {
            int job = scanner.nextInt();

            // 작업이 캐시에 이미 존재하는지 확인
            if (cache.contains(job)) {
                // 존재하면 해당 작업을 제거하고 가장 최근에 사용된 것으로 업데이트
                cache.remove(Integer.valueOf(job));
            } else {
                // 캐시가 꽉 차면 가장 오래된 작업을 제거
                if (cache.size() >= S) {
                    cache.removeLast();
                }
            }
            // 작업을 캐시에 추가
            cache.addFirst(job);
        }

        // 캐시의 상태를 가장 최근 사용된 작업부터 출력
        for (int i = 0; i < cache.size(); i++) {
            System.out.print(cache.get(i) + " ");
        }
    }
}

5. 중복확인

✨ 문제

현수네 반에는 N명의 학생들이 있습니다.

선생님은 반 학생들에게 1부터 10,000,000까지의 자연수 중에서 각자가 좋아하는 숫자 하나 적어 내라고 했습니다.

만약 N명의 학생들이 적어낸 숫자 중 중복된 숫자가 존재하면 D(duplication)를 출력하고,

N명이 모두 각자 다른 숫자를 적어냈다면 U(unique)를 출력하는 프로그램을 작성하세요.

입력

첫 번째 줄에 자연수 N(5<=N<=100,000)이 주어진다.

두 번째 줄에 학생들이 적어 낸 N개의 자연수가 입력된다.

출력

첫 번째 줄에 D 또는 U를 출력한다.

예시 입력 1

8
20 25 52 30 39 33 43 33

예시 출력 1

🎐 답변

import java.util.HashSet;
import java.util.Scanner;

public class UniqueNumberChecker {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 학생 수 N 입력
        int N = scanner.nextInt();
        HashSet<Integer> numbers = new HashSet<>();

        boolean hasDuplicate = false; // 중복 확인 변수

        // N개의 자연수 입력
        for (int i = 0; i < N; i++) {
            int num = scanner.nextInt();

            // HashSet에 숫자가 이미 존재하면 중복
            if (!numbers.add(num)) {
                hasDuplicate = true; // 중복이 발견됨
                break; // 더 이상 확인할 필요 없음
            }
        }

        // 결과 출력
        if (hasDuplicate) {
            System.out.println("D");
        } else {
            System.out.println("U");
        }

        scanner.close(); // Scanner 닫기
    }
}

6. 장난꾸러기

✨ 문제

새 학기가 시작되었습니다. 철수는 새 짝꿍을 만나 너무 신이 났습니다.

철수네 반에는 N명의 학생들이 있습니다.

선생님은 반 학생들에게 반 번호를 정해 주기 위해 운동장에 반 학생들을 키가 가장 작은 학생부터 일렬로 키순으로 세웠습니다.

제일 앞에 가장 작은 학생부터 반 번호를 1번부터 N번까지 부여합니다. 철수는 짝꿍보다 키가 큽니다.

그런데 철수가 앞 번호를 받고 싶어 짝꿍과 자리를 바꿨습니다.

선생님은 이 사실을 모르고 학생들에게 서있는 순서대로 번호를 부여했습니다.

철수와 짝꿍이 자리를 바꾼 반 학생들의 일렬로 서있는 키 정보가 주어질 때 철수가 받은 번호와 철수 짝꿍이 받은 번호를

차례로 출력하는 프로그램을 작성하세요.

입력

첫 번째 줄에 자연수 N(5<=N<=100)이 주어진다.

두 번째 줄에 제일 앞에부터 일렬로 서있는 학생들의 키가 주어진다.

키(높이) 값 H는 (120<=H<=180)의 자연수 입니다.

출력

첫 번째 줄에 철수의 반 번호와 짝꿍의 반 번호를 차례로 출력합니다.

예시 입력 1

9
120 125 152 130 135 135 143 127 160

예시 출력 1

3 8

🎐 답변

import java.util.*;
class Main {	
	public ArrayList<Integer> solution(int n, int[] arr){
		ArrayList<Integer> answer=new ArrayList<>();
		int[] tmp=arr.clone();
		Arrays.sort(tmp);
		for(int i=0; i<n; i++){
			if(arr[i]!=tmp[i]) answer.add(i+1);
		}
		return answer;
	}
	public static void main(String[] args){
		Main T = new Main();
		Scanner kb = new Scanner(System.in);
		int n=kb.nextInt();
		int[] arr=new int[n];
		for(int i=0; i<n; i++) arr[i]=kb.nextInt();
		for(int x : T.solution(n, arr)) System.out.print(x+" ");
	}
}

7. 좌표 정렬

✨ 문제

N개의 평면상의 좌표(x, y)가 주어지면 모든 좌표를 오름차순으로 정렬하는 프로그램을 작성하세요.

정렬기준은 먼저 x값의 의해서 정렬하고, x값이 같을 경우 y값에 의해 정렬합니다.

입력

첫째 줄에 좌표의 개수인 N(3<=N<=100,000)이 주어집니다.

두 번째 줄부터 N개의 좌표가 x, y 순으로 주어집니다. x, y값은 양수만 입력됩니다.

출력

N개의 좌표를 정렬하여 출력하세요.

예시 입력 1

예시 출력 1

🎐 답변

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

public class SortCoordinates {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 좌표의 개수 N 입력
        int N = scanner.nextInt();
        int[][] coordinates = new int[N][2];

        // 좌표 입력
        for (int i = 0; i < N; i++) {
            coordinates[i][0] = scanner.nextInt(); // x값
            coordinates[i][1] = scanner.nextInt(); // y값
        }

        // 좌표 정렬: 먼저 x값으로, x값이 같으면 y값으로 정렬
        Arrays.sort(coordinates, new Comparator<int[]>() {
            @Override
            public int compare(int[] a, int[] b) {
                if (a[0] == b[0]) { // x값이 같을 경우
                    return Integer.compare(a[1], b[1]); // y값으로 비교
                }
                return Integer.compare(a[0], b[0]); // x값으로 비교
            }
        });

        // 결과 출력
        for (int[] coord : coordinates) {
            System.out.println(coord[0] + " " + coord[1]);
        }

        scanner.close(); // Scanner 닫기
    }
}

8. 이분 검색

✨ 문제

임의의 N개의 숫자가 입력으로 주어집니다. N개의 수를 오름차순으로 정렬한 다음 N개의 수 중 한 개의 수인 M이 주어지면

이분검색으로 M이 정렬된 상태에서 몇 번째에 있는지 구하는 프로그램을 작성하세요. 단 중복값은 존재하지 않습니다.

입력

첫 줄에 한 줄에 자연수 N(3<=N<=1,000,000)과 M이 주어집니다.

두 번째 줄에 N개의 수가 공백을 사이에 두고 주어집니다.

출력

첫 줄에 정렬 후 M의 값의 위치 번호를 출력한다.

예시 입력 1

8 32
23 87 65 12 57 32 99 81

예시 출력 1

🎐 답변

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

public class BinarySearchExample {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 첫 줄에서 N과 M 입력
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        
        int[] numbers = new int[N];

        // 두 번째 줄에서 N개의 수 입력
        for (int i = 0; i < N; i++) {
            numbers[i] = scanner.nextInt();
        }

        // 배열 정렬
        Arrays.sort(numbers);

        // 이분 검색
        int index = binarySearch(numbers, M);

        // 출력: M의 위치 번호 (1-based index)
        System.out.println(index + 1);

        scanner.close(); // Scanner 닫기
    }

    // 이분 검색을 위한 메서드
    public static int binarySearch(int[] array, int target) {
        int left = 0;
        int right = array.length - 1;

        while (left <= right) {
            int mid = left + (right - left) / 2;

            if (array[mid] == target) {
                return mid; // 타겟을 찾은 경우 인덱스 반환
            }
            if (array[mid] < target) {
                left = mid + 1; // 타겟이 오른쪽에 있는 경우
            } else {
                right = mid - 1; // 타겟이 왼쪽에 있는 경우
            }
        }

        return -1; // 타겟이 존재하지 않을 경우
    }
}

9. 뮤직비디오

✨ 문제

지니레코드에서는 불세출의 가수 조영필의 라이브 동영상을 DVD로 만들어 판매하려 한다.

DVD에는 총 N개의 곡이 들어가는데, DVD에 녹화할 때에는 라이브에서의 순서가 그대로 유지되어야 한다.

순서가 바뀌는 것을 우리의 가수 조영필씨가 매우 싫어한다. 즉, 1번 노래와 5번 노래를 같은 DVD에 녹화하기 위해서는

1번과 5번 사이의 모든 노래도 같은 DVD에 녹화해야 한다. 또한 한 노래를 쪼개서 두 개의 DVD에 녹화하면 안된다.

지니레코드 입장에서는 이 DVD가 팔릴 것인지 확신할 수 없기 때문에 이 사업에 낭비되는 DVD를 가급적 줄이려고 한다.

고민 끝에 지니레코드는 M개의 DVD에 모든 동영상을 녹화하기로 하였다. 이 때 DVD의 크기(녹화 가능한 길이)를 최소로 하려고 한다.

그리고 M개의 DVD는 모두 같은 크기여야 제조원가가 적게 들기 때문에 꼭 같은 크기로 해야 한다.

입력

첫째 줄에 자연수 N(1≤N≤1,000), M(1≤M≤N)이 주어진다.

다음 줄에는 조영필이 라이브에서 부른 순서대로 부른 곡의 길이가 분 단위로(자연수) 주어진다.

부른 곡의 길이는 10,000분을 넘지 않는다고 가정하자.

출력

첫 번째 줄부터 DVD의 최소 용량 크기를 출력하세요.

예시 입력 1

9 3
1 2 3 4 5 6 7 8 9

예시 출력 1

🎐 답변

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

public class DVDMinSize {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 입력: N (곡 수), M (DVD 수)
        int N = scanner.nextInt();
        int M = scanner.nextInt();
        int[] songs = new int[N];

        // 입력: 곡의 길이
        for (int i = 0; i < N; i++) {
            songs[i] = scanner.nextInt();
        }

        // 이진 탐색을 위한 범위 설정
        int left = Arrays.stream(songs).max().getAsInt(); // 최대 곡 길이
        int right = Arrays.stream(songs).sum(); // 전체 곡 길이의 합
        int answer = right;

        // 이진 탐색
        while (left <= right) {
            int mid = (left + right) / 2; // DVD 크기 후보

            if (canDivide(songs, M, mid)) {
                answer = mid; // 가능한 경우, 최소 크기를 찾기 위해 오른쪽을 줄임
                right = mid - 1;
            } else {
                left = mid + 1; // 불가능한 경우, 크기를 늘림
            }
        }

        System.out.println(answer);
        scanner.close(); // Scanner 닫기
    }

    // 곡 배열을 M개의 DVD로 나누는지 확인하는 메서드
    private static boolean canDivide(int[] songs, int M, int maxSize) {
        int count = 1; // DVD 개수
        int currentSize = 0; // 현재 DVD의 크기

        for (int song : songs) {
            if (currentSize + song > maxSize) {
                count++; // 새로운 DVD에 저장
                currentSize = song; // 새로운 DVD에 첫 곡 저장
                if (count > M) { // DVD 개수를 초과한 경우
                    return false;
                }
            } else {
                currentSize += song; // 현재 DVD에 곡 추가
            }
        }
        return true; // 성공적으로 나눌 수 있음
    }
}

10. 마구간 정하기

✨ 문제

N개의 마구간이 수직선상에 있습니다. 각 마구간은 x1, x2, x3, ......, xN의 좌표를 가지며, 마구간간에 좌표가 중복되는 일은 없습니다.

현수는 C마리의 말을 가지고 있는데, 이 말들은 서로 가까이 있는 것을 좋아하지 않습니다. 각 마구간에는 한 마리의 말만 넣을 수 있고,

가장 가까운 두 말의 거리가 최대가 되게 말을 마구간에 배치하고 싶습니다.

C마리의 말을 N개의 마구간에 배치했을 때 가장 가까운 두 말의 거리가 최대가 되는 그 최대값을 출력하는 프로그램을 작성하세요.

입력

첫 줄에 자연수 N(3<=N<=200,000)과 C(2<=C<=N)이 공백을 사이에 두고 주어집니다.

둘째 줄에 마구간의 좌표 xi(0<=xi<=1,000,000,000)가 차례로 주어집니다.

출력

첫 줄에 가장 가까운 두 말의 최대 거리를 출력하세요.

예시 입력 1

5 3
1 2 8 4 9

예시 출력 1

🎐 답변

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

public class HorseStable {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // Read inputs
        int N = scanner.nextInt();
        int C = scanner.nextInt();
        int[] stables = new int[N];

        for (int i = 0; i < N; i++) {
            stables[i] = scanner.nextInt();
        }

        // Sort stable positions
        Arrays.sort(stables);

        // Binary search for the maximum minimum distance
        int left = 1; // minimum possible distance
        int right = stables[N - 1] - stables[0]; // maximum possible distance
        int maxDistance = 0;

        while (left <= right) {
            int mid = (left + right) / 2;

            // Check if we can place all C horses with at least mid distance apart
            if (canPlaceHorses(stables, C, mid)) {
                maxDistance = mid; // possible to place, try for a larger distance
                left = mid + 1;
            } else {
                right = mid - 1; // not possible, try smaller distance
            }
        }

        // Print the maximum minimum distance found
        System.out.println(maxDistance);
    }

    private static boolean canPlaceHorses(int[] stables, int C, int distance) {
        int count = 1; // Place the first horse in the first stable
        int lastPosition = stables[0]; // Position of the last placed horse

        for (int i = 1; i < stables.length; i++) {
            if (stables[i] - lastPosition >= distance) {
                count++; // We can place another horse
                lastPosition = stables[i]; // Update last position
                if (count == C) {
                    return true; // Successfully placed all horses
                }
            }
        }

        return false; // Not enough horses placed
    }
}

PreviousStack/Queue NextRecursive, Tree, Graph

Last updated 1 month ago