Young

TIL (2024.06.20)

Doit_Young — Fri, 21 Jun 2024 11:32:06 +0900

문제 1️⃣ ( 리트 코드 _ 최대도 최소도 아닌 값 찾기)

IDEA : 배열 안 모든 값이 distinct 하다는 성질을 이용한다. 배열의 길이가 2 이하면 바로 -1 을 반환하고, 이 외의 경우 Arrays.sort 를 통해 배열을 정렬한 후 해당 배열의 인덱스 1 값을 반환한다.

import java.util.Arrays;

class Solution {
    public int findNonMinOrMax(int[] nums) {

        if (nums.length <= 2) return -1;

        Arrays.sort(nums);

        return nums[1];
    }
}

문제 2️⃣ ( 리트코드 _ Top 빈도수 k 개 구하기)

IDEA : Num 클래스를 생성하여 Array.sort 를 통해 정렬된 nums 배열을 한번 돌면서 배열 속 숫자의 개수를 계산한다. 이때 동시에 PriorityQueue 에 Num 객체를 담는다. 이때 PriorityQueue 의 정렬 기준은 숫자 개수의 내림 차순이다. 이후 k 개 만큼 Queue 에서 poll 해서 정답 배열에 담아 반환한다.

import java.util.PriorityQueue;
import java.util.Arrays;

// Num 클래스 선언
class Num implements Comparable<Num> {
    int num;
    int cnt;
    
    // 생성자
    public Num (int num, int cnt) {
        this.num = num;
        this.cnt = cnt;
    }
    
    // PriorityQueue 정렬 기준
    public int compareTo (Num other) {
        return other.cnt - this.cnt;
    }
}

class Solution {
    public int[] topKFrequent(int[] nums, int k) {
    	// (1) PriorityQueue 생성 및 nums 배열 속 숫자 세기
        PriorityQueue<Num> pq = new PriorityQueue<>();
        Arrays.sort(nums);

        int cnt = 1;

        for (int i=0; i<nums.length-1; i++) {
            if (nums[i] == nums[i+1]) {
                cnt++;
            }
            else {
                pq.add(new Num(nums[i], cnt));
                cnt = 1;
            }
        }

        if (cnt == 1) { // 마지막 값 담기
            pq.add(new Num(nums[nums.length-1], 1));
        }
        else {
            pq.add(new Num(nums[nums.length-1], cnt));
        }
        
        // (2) 개수 세기를 마친 후 PriorityQueue 에서 Top k 개를 빼낸 후 answer 배열에 담기
        int[] answer = new int[k];

        for (int i=0; i<k; i++) {
            answer[i] = pq.poll().num;
        }

        return answer;

    }
}
/*
조건
➡️ 가장 빈도가 높은 k 개의 숫자를 배열로 반환
➡️ 시간 복잡도가 O(n logn) 안쪽으로, n 은 nums 배열의 길이를 의미
*/

문제 3️⃣ ( 리트 코드 _ 그래프를 표현하기 위한 최소 선의 갯수)

IDEA : 배열 정렬을 수행 한 후, 전 후 기울기 비교를 통해 선 추가 여부를 결정한다.

① 초기 IDEA

기울기 계산을 통한 기울기 비교 방식

➡️ 일반적으로 기울기 계산에 사용하는 (y2 - y1) / (x2 - x1) 을 double 자료형을 통해서 비교하면 정확한 비교가 될 수 있을 것이라고 생각했고, 해당 아이디어를 바탕으로 아래와 같이 비교 코드를 작성하였다.

while (!pq.isEmpty()) {
    now = next;
    next = pq.poll();

    double nowDir = (double) (now.price-next.price) / (now.day-next.day);

    if (preDir != nowDir) answer++;

    preDir = nowDir;
}

➡️ 그러나 이렇게 작성했을 때 double 또한 64bit 의 유한 비트수를 가지고 있기 때문에 비교될 값이 아주 작은 차이로 다르게 되면 반올림 과정에서 두 값이 동일한 특정값에 수렴하면서 정확한 측정이 어려워지고, 이로 인해 해당 테스트케이스에서는 오류가 발생하여 다른 결과값이 나오게 된다.

② 수정된 IDEA

비례 관계 확인을 통한 기울기 비교 방식

➡️ 이러한 문제를 해결하기 위해 기울기를 직접 구하는 방식이 아닌 비례 관계를 확인하는 방식으로 변경하였다. 해당 방식은 곱을 이용하는 방식으로 기존 방식처럼 반올림을 피할 수 있기 때문에 오차 범위가 확연히 줄어듬과 동시에 long 자료형을 사용하므로서 오버플로우를 방지하여 정확도를 더 높일 수 있다.

while (!pq.isEmpty()) {
    left = mid;
    mid = right;
    right = pq.poll();

    long dir_1 = (mid.price - left.price)*(right.day - mid.day);
    long dir_2 = (right.price -mid.price)*(mid.day - left.day);

    if (dir_1 != dir_2) answer++;

}

③ 개선 전 코드

import java.util.PriorityQueue;

class Chart implements Comparable<Chart> {
    int day;
    int price;

    public Chart (int day, int price) {
        this.day = day;
        this.price = price;
    }

    @Override
    public int compareTo (Chart other) {
        return this.day - other.day;
    }
}
class Solution {
    public int minimumLines(int[][] stockPrices) {
        if (stockPrices.length <= 2) {
            return stockPrices.length-1;
        }

        // (1) stockPrices 배열 정리
        PriorityQueue<Chart> pq = new PriorityQueue<>();

        for (int[] stock : stockPrices) {
            pq.add(new Chart(stock[0], stock[1]));
        }

        // (2) 차트 정리
        int answer = 1;

        Chart left = null;
        Chart mid = pq.poll();
        Chart right = pq.poll();

        while (!pq.isEmpty()) {
            left = mid;
            mid = right;
            right = pq.poll();

            long dir_1 = (mid.price - left.price)*(right.day - mid.day);
            long dir_2 = (right.price -mid.price)*(mid.day - left.day);

            if (dir_1 != dir_2) answer++;

        }

        return answer;
    }
}

➡️ day 기준으로 배열을 정렬하기 위해서 Char 클래스를 생성하고 PriorityQueue 를 사용하였는데 이렇게 할 경우 시간복잡도 및 공간복잡도가 높아지게 된다.

④ 개선 및 최종 코드

import java.util.Arrays;

class Solution {
    public int minimumLines(int[][] stockPrices) {
        if (stockPrices.length <= 2) return stockPrices.length-1;

        // (1) day 기준으로 정렬
        Arrays.sort(stockPrices,(o1,o2)-> o1[0]-o2[0]);

        // (2) 전체를 돌면서 기울기 비례 관계 확인
        int answer = 1;

        for (int i=0; i<stockPrices.length-2; i++) {
            int x1 = stockPrices[i][0];
            int x2 = stockPrices[i+1][0];
            int x3 = stockPrices[i+2][0];

            int y1 = stockPrices[i][1];
            int y2 = stockPrices[i+1][1];
            int y3 = stockPrices[i+2][1];

            long dir_1 = (y2-y1)*(x3-x2);
            long dir_2 = (y3-y2)*(x2-x1);

            if (dir_1 != dir_2) answer++;
        }

        // (3) 정답 반환
        return answer;
    }
}

➡️ Array.sort 과정에서 day 를 기준으로 정렬한다는 람다 표현식을 통해 sort 과정에서 필요한 Comparator 의 인터페이스를 생성하여 단계를 줄였다. Comparator 의 내부함수인 int compare(T o1, T o2) 를 람다식을 통해 표현했다고 할 수 있다.

// Comparator 메소드
int compare(T o1, T o2);

// 람다 표현 방식
Arrays.sort(stockPrices, (o1, o2) -> o1[0] - o2[0]);

TIL (2024.06.16)

Doit_Young — Mon, 17 Jun 2024 13:04:48 +0900

문제 1️⃣ ( 리트 코드 _ 특정 문자를 포함한 문자열 찾기)

IDEA : String 내부 함수인 indexOf 매서드르 통해 인덱스를 확인하고, -1 인 경우 해당 문자를 포함하지 않는 것으로 판단하여 나머지만 인덱스값을 정답 배열에 추가한다.

import java.util.List;
import java.util.ArrayList;

class Solution {
    public List<Integer> findWordsContaining(String[] words, char x) {
        List<Integer> answer = new ArrayList<>();

        for (int i=0; i<words.length; i++) {
            if (words[i].lastIndexOf(x) >= 0) {
                answer.add(i);
            }
        }

        return answer;
    }
}

문제 2️⃣ ( 리트 코드 _ 사이즈 그룹에 맞게 팀원 구성하기)

IDEA : 희망 그룹 명 수를 확인할 수 있는 List<Integer>[] 배열을 선언해서 해당 인덱스 값들을 알맞게 넣은 후 리스트로 부터 차례대로 희망 그룹 수 만큼 구성하여 answer 리스트에 추가한다.

import java.util.ArrayList;
import java.util.List;
import java.util.Arrays;

class Solution {
    public List<List<Integer>> groupThePeople(int[] groupSizes) {
        int[] _groupSizes = Arrays.copyOf(groupSizes, groupSizes.length);
        Arrays.sort(_groupSizes);

        // (1) 각 그룹에 해당하는 index 취합을 위한 배열 선언
        int min = _groupSizes[0];
        int max = _groupSizes[_groupSizes.length-1];

        List<Integer>[] count = new ArrayList[max+1];

        for (int i=0; i<count.length; i++) {
            count[i] = new ArrayList<>();
        }

        // (2) index 취합
        for (int j=0; j<groupSizes.length; j++) {
            count[groupSizes[j]].add(j);
        }

        // (3) 조합 후 answer 리스트에 담기
        List<List<Integer>> answer = new ArrayList<>();

        int size = 0;
        ArrayList<Integer> arr = new ArrayList<>();

        for (int i=min; i<count.length; i++) {
            List<Integer> cnt = count[i];
            size = cnt.size();

            if (size == 0) continue;

            for (int j=0; j<size; j++) {
                System.out.println(j%i);
                if (j % i == 0) {
                    arr = new ArrayList<>();
                }

                arr.add(cnt.get(j));
                System.out.println(cnt.get(j));

                if ((j+1) % i == 0) {
                    answer.add(arr);
                }
            }
        }

        return answer;
    }
}

➡️ 통과하기는 했지만 런타임이 평균에 비해 긴 편이라 좀 더 짧은 로직을 생각해보아야 할 것 같다.

TIL (2024.06.15)

Doit_Young — Sun, 16 Jun 2024 12:56:29 +0900

문제 1️⃣ ( 리트 코드 _ 좋은 짝의 수)

IDEA : 배열 안의 각수의 개수를 HashMap 에 저장한 후 전체를 돌면서 조합의 수를 더한다. 이 때 조합은 n * (n-1) / 2 로 계산 가능하다.

import java.util.Arrays;
import java.util.HashMap;
import java.util.Set;

class Solution {
    public int numIdenticalPairs(int[] nums) {

        // (1) 배열 속 전체 값 세기
        HashMap<Integer, Integer> cnt = new HashMap<>();

        int val = 0;

        for (int num : nums) {
            if (cnt.get(num) == null) {
                cnt.put(num, 1);
            }
            else {
                val = cnt.get(num);
                cnt.put(num, ++val);
            }
        }
        
        // (2) 조합 계산
        Set<Integer> keySet = cnt.keySet();

        int answer = 0;
        int n = 0;
        for (Integer key : keySet) {
            n = cnt.get(key);
            answer += n*(n-1)/2;
        }
        
        return answer;
    }
}

코드 개선 사항 ① : HashMap 값 추가

➡️ 기존 코드에서는 get 매서드를 통해 HashMap 안에 해당 값이 있는지 확인하고, 있다면 해당 값을 가져와서 1을 더한 뒤 넣고, 없다면 바로 1을 넣었다. 하지만 getOrDefault 매서드를 활용하면 기존 값이 있다면 해당 값을 가져오고 아니면 지정한 값을 가져오도록 할 수 있다.

// 개선 전

int val = 0;

for (int num : nums) {
	if (cnt.get(num) == null) {
    cnt.put(num, 1);
 }
else {
	val = cnt.get(num);
	cnt.put(num, ++val);
}

// 개선 후

for (int num : nums) {
	cnt.put(num, cnt.getOrDefault(num, 0)+1);
}

코드 개선 사항 ② : HashMap 값 하나씩 꺼내기

➡️ 기존 코드에서는 keySet 매서드를 통해 HashMap 속 key 값들을 불러온 후 for 문을 통해서 key 값을 바탕으로 값을 불러왔다면, values 매서드를 통해 바로 value 들에 접근한다.

// 개선 전
Set<Integer> keySet = cnt.keySet();

int answer = 0;
int n = 0;

for (Integer key : keySet) {
    n = cnt.get(key);
    answer += n*(n-1)/2;
}

// 개선 후

int answer = 0;

for (int count : cnt.values()) {
	answer += count * (count - 1) / 2;
}

최종 코드

class Solution {
    public int numIdenticalPairs(int[] nums) {

        // (1) 배열 속 전체 값 세기
        HashMap<Integer, Integer> cnt = new HashMap<>();

        for (int num : nums) {
	    cnt.put(num, cnt.getOrDefault(num, 0)+1);
        }
        
        // (2) 조합 계산
        int answer = 0;

        for (int n : cnt.values()) {
            answer += n*(n-1)/2;
        }

        return answer;
    }
}

문제 2️⃣ ( 리트 코드 _ XOR 연산을 통한 원래 배열 찾기)

IDEA : Java 에서 지원하는 XOR 연산인 ^ 기호를 통해 해결하였다.

class Solution {
    public int[] findArray(int[] pref) {
        int[] answer = new int[pref.length];

        answer[0] = pref[0];

        for (int i=1; i<pref.length; i++) {
            answer[i] = pref[i-1] ^ pref[i];
        }

        return answer;
    }
}

TIL (2024.06.14)

Doit_Young — Sat, 15 Jun 2024 14:39:39 +0900

문제 1️⃣ ( 리트 코드 _ 배열 섞기)

IDEA : 두 배열을 정렬한 뒤 x 값들은 2*n 인덱스에 y 값들은 2*n+1 인덱스에 넣어 새로운 배열을 생성한다.

class Solution {
    public int[] shuffle(int[] nums, int n) {
        
        int[] answer = new int[nums.length];
        
        for (int i=0; i<n; i++) {
            answer[2*i] = nums[i];
            answer[2*i+1] = nums[i+n];
        }

        return answer;
    }
}

/*
x -> 0, 2, 4, 6 -> 2n
y -> 1, 3, 5, 7 -> 2n + 1;
*/

문제 2️⃣ ( 리트 코드 _ 직사각형 쿼리들)

IDEA : 크게 아이디어라 할 것 없이 주어진 조건대로 작성하였다.

class SubrectangleQueries {
    int[][] rectangle;

    public SubrectangleQueries(int[][] rectangle) {
        this.rectangle = rectangle;   
    }
    
    public void updateSubrectangle(int row1, int col1, int row2, int col2, int newValue) {
        for (int i=row1; i<=row2; i++) {
            for (int j=col1; j<=col2; j++) {
                rectangle[i][j] = newValue;
            }
        }
    }
    
    public int getValue(int row, int col) {
        return rectangle[row][col];
    }
}

문제 3️⃣ ( 프로그래머스 _ H-Index)

IDEA : H 값이 될 수 있는 최소, 최댓값을 결정 한 후 이분 탐색을 통해 조건을 만족하는 최댓값을 구한다.

① H 후보값 범위 설정

➡️ H 후보값의 최솟값은 주어진 citations 배열의 최솟값 또는 배열의 길이 이다. 따라서 두 값중 Min 값을 최솟값으로 결정한다. H 후보값의 최댓값은 citations 배열의 최댓값으로 설정하였다.

② 이분 탐색 수행

➡️ 이분 탐색 수행을 통해 조건을 만족하는 값들 중 최댓값을 구한다. 이를 구하기 위해 이분탐색의 Bound 개념을 적용시켰다.

③ isPossible 전역함수 생성

➡️ 이분 탐색 과정에서 조건을 만족하는지 확인하기 위한 isPossible 함수를 생성하였다. 이 함수는 원하는 h 값이 조건을 만족하는지를 citations 배열을 맨 뒤값 (= 최댓값) 부터 확인하여 조건 만족 여부에 따라 true 또는 false 를 반환한다.

import java.util.Arrays;

class Solution {
    public int solution(int[] citations) {
        // (1) 배열 정렬
        Arrays.sort(citations);
        
        // (2) 이분 탐색 수행
        int left = Math.min(citations[0], citations.length);
        int right = citations[citations.length-1];
        int answer = 0;
        
        while (left <= right) {
            int mid = (left + right) / 2;
            
            if (isPossible(mid, citations)) {
                answer = Math.max(answer, mid);
                left = mid+1;
            }
            else {
                right = mid-1;
            }
            
        }
        
        return answer;
        
    }
    /*
        해당 h 값이 조건을 만족하는지 확인하는 함수
        int h : h 값
        int[] citations : 주어진 citations 배열
    */
    public static boolean isPossible(int h, int[] citations) {
        if (h > citations.length) return false;
        
        int min = Math.max(0, citations.length-h);
        for (int i=citations.length-1; i>=min; i--) {
            if (citations[i] < h) return false;
        }
        
        return true;
    }
}

TIL (2024.06.13)

Doit_Young — Sat, 15 Jun 2024 14:13:32 +0900

문제 1️⃣ ( 리트 코드 _ 학생 최소 이동값)

IDEA : 단순하게 두 배열을 정렬해서 두 값 사이의 절대값을 이동 횟수로 하여 전체를 더한다.

import java.util.Arrays;

class Solution {
    public int minMovesToSeat(int[] seats, int[] students) {
        // 두 배열 정렬
        Arrays.sort(seats);
        Arrays.sort(students);

        int answer = 0;
        for (int i=0; i<seats.length; i++) {
            answer += Math.abs(seats[i] - students[i]);
        }

        return answer;
    }
}
/*
[1, 3, 5]
[2, 4, 7]
➡️ 1 + 1 + 2 = 4

[1, 4, 5, 9]
[1, 2, 3, 6]
➡️ 0 + 2 + 2 + 3 = 7

[2, 2, 6, 6]
[1, 2, 3, 6]
➡️ 1 + 0 + 3 + 0 = 4
*/

문제 2️⃣ ( 프로그래머스 _ 순위)

➡️ 이전에 정리해놓은 블로그 글이 있어서 해당 링크로 대체한다.

(알고리즘 스터디) 15주차 금_Graph _(Programmers) 순위

프로그래머스 / Graph / Level 3 / 순위 문제 프로그래머스 코드 중심의 개발자 채용. 스택 기반의 포지션 매칭. 프로그래머스의 개발자 맞춤형 프로필을 등록하고, 나와 기술 궁합이 잘 맞는

like099.tistory.com

TIL (2024.06.12)

Doit_Young — Thu, 13 Jun 2024 12:22:13 +0900

문제 1️⃣ ( 리트 코드 _ 정렬된 이차원 배열에서 음수찾기)

IDEA : 정렬되어있는 배열이므로 이분탐색을 통해 탐색 속도를 높인다. 이때, 위아래에 대해서도 정렬이 되어있음으로 다음 배열 탐색시 전 배열 탐색 결과를 바탕으로 범위를 좁혀서 탐색할 수 있다.

IDEA 설명

class Solution {
    public int countNegatives(int[][] grid) {
        int answer = 0;

        int m = grid.length; // 세로 길이
        int n = grid[0].length; // 가로 길이

        int left = 0;
        int right = n-1;
        int idx = n;
        int mid = 0;

        for (int i=0; i<m; i++) {
            if (idx == 0){
                answer += (m-i)*n;
                break;
            }
            left = 0;
            right = idx-1;

            // 이분 탐색 수행
            while (left <= right) {
                mid = (left + right) / 2;

                if (grid[i][mid] < 0) {
                    right = mid - 1;
                    idx = Math.min(idx, mid);
                }
                else {
                    left = mid + 1;
                }
            }
            
            answer += (n-idx);
        }

        return answer;
    }
}

문제 2️⃣ ( 리트 코드 _ 짐 옮기기)

IDEA : 제시된 날 안에 짐을 옮길 수 있는지는 완전 탐색을 통해 알 수 있다. 다만 무게 제한을 이분 탐색을 통해서 속도를 개선할 수 있다.

class Solution {
    public int shipWithinDays(int[] weights, int days) {
    
    	// (1) 탐색할 무게의 범위를 결정
        int sum = 0;
        int max = 0;

        for (int weight : weights) {
            sum += weight;
            max = Math.max(max, weight);
        }
        
        // (2) 이분 탐색 수행
        int left = max;
        int right = sum;
        int minDay = sum+1;

        while (left <= right) {
            int mid = (left + right) / 2;
            
            if (isPossible(weights, days, mid)) {
            	// LowerBound 개념을 통해 최소값을 탐색
                minDay = Math.min(mid, minDay);
                right = mid-1;
            }
            else {
                left = mid+1;
            }
        }

        return minDay;
    }
    
    /*
    	int[] weights : 주어진 무게 배열
        int days : 주어진 날짜 제한
        int limit : 탐색 중인 무게 제한
    */
    public static boolean isPossible (int[] weights, int days, int limit) {

        int sum = 0;
        int cnt = 1;
		
        // 제시된 limit 무게에 대해서 모든 짐을 옮기려면 얼마나 걸리는지 확인
        for (int i=0; i<weights.length; i++) {
            if (sum + weights[i] <= limit) {
                sum += weights[i];
                continue;
            }
            else {
                sum = weights[i];
                cnt++;
            }
        }
		
        // 제한된 날짜 안에 끝나면 true 를 반환
        return cnt <= days;
    }
}

TIL (2024.06.11) _ (Programmers) 입국 심사

Doit_Young — Tue, 11 Jun 2024 16:30:38 +0900

문제 1️⃣ ( 리트 코드_조건에 맞는 짝 찾기)

IDEA : 특별한 방법은 없었고, 완탐을 통해 해결

class Solution {
    public int countPairs(List<Integer> nums, int target) {
        int answer = 0;
        
        // 완전 탐색
        for (int i=0; i<nums.size()-1; i++) {
            for (int j=i+1; j<nums.size(); j++) {
                if (nums.get(i)+nums.get(j) < target) {
                    answer++;
                    continue;
                }
            }
        }

        return answer;
    }
}

문제 2️⃣ ( 프로그래머스_입국 심사)

문제

n명이 입국심사를 위해 줄을 서서 기다리고 있습니다. 각 입국심사대에 있는 심사관마다 심사하는데 걸리는 시간은 다릅니다.

처음에 모든 심사대는 비어있습니다. 한 심사대에서는 동시에 한 명만 심사를 할 수 있습니다. 가장 앞에 서 있는 사람은 비어 있는 심사대로 가서 심사를 받을 수 있습니다. 하지만 더 빨리 끝나는 심사대가 있으면 기다렸다가 그곳으로 가서 심사를 받을 수도 있습니다.

모든 사람이 심사를 받는데 걸리는 시간을 최소로 하고 싶습니다.

입국심사를 기다리는 사람 수 n, 각 심사관이 한 명을 심사하는데 걸리는 시간이 담긴 배열 times가 매개변수로 주어질 때, 모든 사람이 심사를 받는데 걸리는 시간의 최솟값을 return 하도록 solution 함수를 작성해주세요.

제한 사항

입국심사를 기다리는 사람은 1명 이상 1,000,000,000명 이하입니다.
각 심사관이 한 명을 심사하는데 걸리는 시간은 1분 이상 1,000,000,000분 이하입니다.
심사관은 1명 이상 100,000명 이하입니다.

입출력 예

n	times	return
6	[7, 10]	28

풀이 방법

➡️ 문제에서 제시된 유형 그대로 이분탐색을 사용하였다. 이때 추가적으로 LowerBound 개념까지 활용하였다.

STEP ① : 탐색해야할 최대 범위를 설정

➡️ times 배열을 Arrays.sort() 를 활용해 오름차순 정렬 후 Index 0 에 해당하는 최소값과 n 을 곱해 최대 범위를 설정하였고, 해당 변수는 maxTime 이라고 명명하였다.

입출력 예시로 확인 하면 times 의 최소값 7 과 n 의 값 6 을 곱하여 최대 소요 시간은 42 초가 된다.

STEP ② : 이분 탐색 수행

➡️ 최대 범위를 정했으니, 이분 탐색의 개념에서 left 를 0, right 를 maxTime 그리고 LowerBound 값인 minTime 을 maxTime+1 으로 초기화 한 뒤 이분 탐색을 수행한다.

➡️ 이분 탐색 과정에서 현재 시간인 mid 값과 times 변수를 나누어 해당 시간을 기준으로 몇명이 입국 심사를 받을 수 있는지 확인한다. 만약 원하는 값 n 을 벗어나게 커진다면 더 계산할 필요없이 넘어가서 바로 left 값을 조정한다.

➡️ 이때 LowerBound 를 활용하는 이유는 LowerBound 는 목표로 하는 값의 이상인 최소의 인덱스를 반환하는 개념이기 때문이다. 따라서 예시 1 의 리턴 값인 28 이후의 29, 30 등 모든 값들은 6명이상을 입국심사 할 수 있지만 최소의 시간은 28초 이기 때문에 해당 값을 반환하게 된다.

예시 1 에 대한 LowerBound 개념 확인

STEP ③ : minTime 값 반환

➡️ 이분 탐색이 종료되면 LowerBound 에 해당 하는 값인 minTime 을 반환하면 된다.

풀이 코드

import java.util.Arrays;

class Solution {
    public long solution(int n, int[] times) {
        
        // times 배열 오름차순 정렬 
        Arrays.sort(times);
        
        // *주의* long 으로 형변환 필수!
        long maxTime = (long) n * times[0];
        
        // 이분탐색 실행
        long left = 1;
        long right = maxTime+1;
        long minTime = maxTime;
        
        while (left <= right) {
            long mid = (left + right) / 2;
            // System.out.printf("현재 시간 : %d\n", time[mid]);
            
            long cnt = 0;
            
            for (int i=0; i<times.length; i++) {
                cnt += mid / times[i];
                
                if (cnt > n) break;
                // System.out.printf("%d 더함\n", time[mid]/times[i]);
            }
            
            // System.out.printf("현재 minIdx 값 : %d\n", minIdx);
            
            if (cnt >= n) {
                // System.out.printf("cnt 가 %d 으로 더 크거나 같음\n", cnt);
                right = mid-1;
                minTime = Math.min(minTime, mid);
            }
            else {
                left = mid+1;
            }
            
            // System.out.printf("조정 후 minIdx 값 : %d\n", minIdx);
        }
        
        return minTime;
    }
}

➡️ 풀이하면서 조심해야할 점은 제한 사항에서 값들이 크므로 int 자료형을 활용할 경우 값이 넘어가 잘못된 값을 낼 수 있다. 따라서 모든 값을 long 으로 초기화 또는 형변환하여 풀이하여야 한다.

풀이 결과

TIL (2024.06.08)

Doit_Young — Sun, 9 Jun 2024 00:55:40 +0900

문제 1️⃣ (리트 코드_모음 문자열 정렬)

https://leetcode.com/problems/count-sorted-vowel-strings/description/

IDEA : 규칙성을 파악한다.

[a, e, i, o, u]
-> a(1) e(1) i(1) o(1) u(1) = 5

[aa, ae, ai, ao, au, ee, ei, eo, eu, ii, io, iu, oo, ou, uu]
-> a(5) + e(4) + i(3) + o(2) + u(1) = 15

[aaa, aae, aai, aao, aau, aee, aei, aeo, aeu, ali, ...]
-> a (15) + e(10) + i(6) + o(3) + u(1) = 35

풀이 (1)

➡️ 앞에서부터 갱신하는 방식. 앞의 줄의 합을 a의 값에 넣고 나머지는 전의 값에서 하나씩 빼면 된다는 규칙성을 생각했었다.

class Solution {
    public int countVowelStrings(int n) {
        List<Integer>[] answer = new List[n+1];

        // ArrayList 생성
        for (int i=0; i<=n; i++) {
            answer[i] = new ArrayList<>();
        }

        // 첫째줄 초기화
        for (int i=1; i<=5; i++) {
            answer[1].add(1);
        }

        for (int i=2; i<=n; i++) {
            for (int j=1; j<=5; j++) {
                if (j==1) {
                    int sum = answer[i-1].stream().mapToInt(Integer::intValue).sum();
                    answer[i].add(sum);
                    continue;
                }

                answer[i].add(answer[i].get(j-2) - answer[i-1].get(j-2));
            }
        }

        return answer[n].stream().mapToInt(Integer::intValue).sum();
    }
}

해당 방식은 규칙성은 맞으나 굳이 ArrayList 를 통해 모든 값을 저장하려고 했다는 점과 비효율적인 규칙성이라는 점에서 시간이 O(n2) 이고 메모리 차지가 많이 생길 수 있는 코드이다.

풀이 (2)

➡️ 뒤에서 부터 갱신하는 방식, 구하고자하는 위치 (j) 의 값과 전 차례에서의 구하고자 하는 값 다음값 (j+1) 의 합이 해당 위치 (j) 의 값이라는 규칙성을 활용.

class Solution {
    public int countVowelStrings(int n) {
        int[] strs = new int[] {1,1,1,1,1};

        for (int i=1; i<n; i++) {
            for (int j=3; j>=0; j--) {
                strs[j] += strs[j+1];
            }
        }

        int answer = 0;

        for (int num : strs) {
            answer += num;
        }

        return answer;
    }
}

크기가 5인 배열을 사용함으로서 메모리 사용량을 줄였다. 시간은 O(n2) 으로 거의 동일할 것 같다.

문제 2️⃣ (리트 코드_파스칼 삼각형)

https://leetcode.com/problems/pascals-triangle/description/

IDEA : 규칙대로 성실하게 코드로 옮긴다.

class Solution {
    public List<List<Integer>> generate(int numRows) {
        List<List<Integer>> answer = new ArrayList<>();

        List<Integer> row;
        int sum = 0;

        for (int i=1; i<= numRows; i++) { // numRows 만큼의 줄을 생성해야함
            row = new ArrayList<>();
            
            for (int j=1; j<=i; j++) { // numRows 개 만큼의 원소 생성 필요
                if (j==1 || j==i) { // 처음과 끝은 무조건 1
                    row.add(1);
                    // System.out.printf("%d 줄에 1 추가\n", i);
                    continue;
                }

                sum = answer.get(i-2).get(j-2) + answer.get(i-2).get(j-1);
                row.add(sum);
                // System.out.printf("%d 줄에 %d 추가\n", i, sum);
            }
            answer.add(row);
            // System.out.println("종료");
        }
        return answer;
    }
}

➡️ 주어진 규칙성에 맞춰 리스트에 계속해서 값을 추가했다. 다만 처음과 끝은 무조건 1 이므로 해당 부분은 if 문을 통해 해결하였다.

문제 3️⃣ (프로그래머스_정수 삼각형)

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

프로그래머스

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

programmers.co.kr

IDEA : 앞서 푼 두 문제에서 Math.max() 의 개념을 추가할 뿐이지, 작동과정은 거의 동일.

class Solution {
    public int solution(int[][] triangle) {
        int N = triangle.length;
        
        for (int i=1; i<N; i++) {
            for (int j=0; j<=i; j++) {
                // (1) 양끝에 해당할 경우
                if (j == 0) { // (1)-1 첫번째
                    triangle[i][j] += triangle[i-1][0];
                    continue;
                }
                else if(j == i) { // (1)-2 마지막
                    triangle[i][j] += triangle[i-1][j-1];
                    continue;
                }
                
                // (2) 나머지 중간값 처리
                triangle[i][j] += Math.max(triangle[i-1][j-1], triangle[i-1][j]);
            }
        }
        
        // (3) Max 값 확인 후 반환
        int max = -1;
        
        for (int num : triangle[N-1]) {
            max = Math.max(num, max);
        }
        return max;
    }
}

➕ 추가로 확인해보면 좋은 문제

➡️ 이 세문제를 풀면서 과거에 풀었던 비슷한 유형의 문제이지만 좀 더 생각이 필요한 문제가 떠올라 해당 문제 링크를 올려둡니다! 혹시 이 세문제를 풀고 자신감이 생겼다면 이 문제도 풀어보는 것을 추천 ❤️

문제 1 (https://school.programmers.co.kr/learn/courses/30/lessons/12913)

프로그래머스

programmers.co.kr

문제 2 (https://www.acmicpc.net/problem/1149)

TIL (2024.06.06)

Doit_Young — Fri, 7 Jun 2024 15:22:09 +0900

문제 1️⃣ (리트코드_비트 세기)

https://leetcode.com/problems/counting-bits/description/

IDEA : Integer 내부 함수인 bitCount(int i) 를 사용한다.

class Solution {
    public int[] countBits(int n) {

        int[] answer = new int[n+1];

        for (int i=1; i<=n; i++) {
            answer[i] = Integer.bitCount(i);
        }

        return answer;
    }
}

TIL (2024.06.05)

Doit_Young — Wed, 5 Jun 2024 18:50:40 +0900

문제 1️⃣ (리트 코드_문자열 밸런싱)

https://leetcode.com/problems/split-a-string-in-balanced-strings/description/

IDEA : 일일히 'R' 과 'L' 의 개수를 세서 비교하는 것이 아닌 cnt 하나의 값을 활용하여 밸런싱을 확인한다.

class Solution {
    public int balancedStringSplit(String s) {
        int answer = 0;

        int cnt = 0;
        char tmp;

        for (int i=0; i<s.length(); i++) {
            tmp = s.charAt(i);

            if (tmp == 'R') cnt++;
            else cnt--;

            if (cnt == 0) { // 'R' 과 'L' 이 균형을 이룬경우
                answer++;
                cnt = 0;
            }
        }     
        return answer;
    }
}
/*
풀이
(1) index 0 부터 s.length(), 즉 문자열 전체을 탐색
(2) charAt() 을 통해 'R' & 'L' 값을 확인하며 'R' 일 경우 cnt 값을 하나 증가 시키고 'L' 일 경우 cnt 값을 하나 감소 시킴.
(3) 반복문 끝에서 cnt 값이 0 이면 R 과 L 이 최소 단위로 조화를 이룬 것이므로 answer 값을 하나 증가시키고 cnt 값은 0으로 초기화 시킴
*/

문제 2️⃣ (프로그래머스_구명보트)

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

프로그래머스

programmers.co.kr

IDEA : 가장 무거운 사람부터 탑승한다. 이 때 가장 가벼운 사람과 갈 수 있으면 함께 간다.

import java.util.Arrays;

class Solution {
    public int solution(int[] people, int limit) {
        int answer = 0;
        
        Arrays.sort(people); // 오름차순 정렬
        
        int size = people.length;
        
        int bigIdx = people.length-1;
        int smallIdx = 0;
        
        while (size != 0) { // 모두 탑승할 때까지 반복
            if (size == 1) { // 한명 남은 경우 : 바로 탑습
                answer++; 
                break;
            }
            
            // 가장 무거운 사람 + 가장 가벼운 사람 <= 무게 제한 (limit) 인지 확인
            if (people[bigIdx] + people[smallIdx] <= limit) { // 둘 다 타는 경우
                smallIdx++;
                size-=2;
            }
            else { // 가장 무거운 사람만 타는 경우
                size-=1;
            }
            
            bigIdx--;
            answer++;
            
        }
        
        return answer;
    }
}
/*
조건
(1) 최대 2명
(2) 무게 제한 존재 (limit)
(3) 최대한 적게 사용하여 모든 사람 구출

풀이 [70, 50, 80, 50]
-> 가장 무거운 사람과 가장 가벼운 사람이 함께 할 수 있으면 best 아니면 가장 무거운 사람 혼자
(1) sort : [50, 50, 70, 80]
(2) 
*/

문제 3️⃣ (프로그래머스_단속카메라)

IDEA : Car 객체를 생성하여 Car 의 종료 시점을 기준으로 오름 차순 정렬 되도록 PriorityQueue 를 생성한 뒤 Queue 가 빌 때 까지 반복문을 수행한다. 단속카메라의 지점은 무조건 car 객체의 end 지점으로 한다. 다음 차의 시작지점이 카메라의 마지막 지점보다 전이라면 특별한 작동없이 그대로 넘어가고, 마지막 지점 뒤에 있다면 해당 차량의 end 값을 단속카메라의 새로운 지점으로 설정한다.

import java.util.PriorityQueue;

class Car implements Comparable<Car> {
    int start;
    int end;
    
    public Car (int start, int end) {
        this.start = start;
        this.end = end;
    }
    
    @Override
    public int compareTo(Car other) {        
        return this.end - other.end;
    }
}

class Solution {
    public int solution(int[][] routes) {    
        PriorityQueue<Car> pq = new PriorityQueue<>();
        
        for (int[] route : routes) {
            pq.add(new Car(route[0], route[1]));
        }
        
//         // // 주의! : 이 방식은 pq 에 담겨있는 순서대로 나오지 않음
//         // for (Car car : pq) {
//         //     System.out.printf("%d / %d \n", car.start, car.end);
//         // }
        
        
//         // pq 에 담겨있는 순서대로 출력하는 방법
//         while (!pq.isEmpty()) {
//             Car car = pq.poll();  // pq에서 요소를 제거하면서 출력
//             System.out.printf("%d / %d \n", car.start, car.end);
//         }
        
        Car car = pq.poll();
        // System.out.printf("%d / %d\n", car.start, car.end);
        int answer = 1;
        
        int camIdx = car.end;
        // System.out.printf("%d 에 cctv 설치\n", camIdx);
        
        while (!pq.isEmpty()) {
            car = pq.poll();
            // System.out.printf("%d / %d\n", car.start, car.end);
            
            if (car.start <= camIdx) continue;
            
            answer++;
            camIdx = car.end;
            // System.out.printf("%d 에 cctv 설치\n", camIdx);
        }
        
        return answer;
    }
}

/*
- 조건
(1) 단속 카메라를 한 번은 만나야함
(2) 최소 카메라 개수

[[-20,-15], [-14,-5], [-18,-13], [-5,-3]]
A : [-20,-15]
B : [-14,-5]
C : [-18,-13]
D : [-5,-3]]

A C A* B C* D&B* D*

- 풀이
(1) 나가는 것이 중요하므로 종료가 빠른 순
(2) PriorityQueue 에 담기
(3) 차가 모두 지나갈 때 까지 마지막 cctv 의 지점을 저장하면서 진행
    -> 무조건 차의 맨 끝을 cctv 지점으로 설정
        -> 다음 차의 시작이 cctv 지점 전이면 다음 차를 확인
        -> 다음 차의 시작이 cctv 지점 다음이면 해당 차량의 마지막을 새로운 cctv 지점으로 설정

*/

참고 : Comparable 과 Comparator 의 차이 (https://st-lab.tistory.com/243)

자바 [JAVA] - Comparable 과 Comparator의 이해

아마 이 글을 찾아 오신 분들 대개는 Comparable과 Comparator의 차이가 무엇인지 모르거나 궁금해서 찾아오셨을 것이다. 사실 알고보면 두 개는 그렇게 어렵지 않으나 아무래도 자바를 학습하면서 객

st-lab.tistory.com

Young

TIL (2024.06.20)

문제 1️⃣ ( 리트 코드 _ 최대도 최소도 아닌 값 찾기)

문제 2️⃣ ( 리트코드 _ Top 빈도수 k 개 구하기)

문제 3️⃣ ( 리트 코드 _ 그래프를 표현하기 위한 최소 선의 갯수)

① 초기 IDEA

② 수정된 IDEA

③ 개선 전 코드

④ 개선 및 최종 코드

TIL (2024.06.16)

문제 1️⃣ ( 리트 코드 _ 특정 문자를 포함한 문자열 찾기)

문제 2️⃣ ( 리트 코드 _ 사이즈 그룹에 맞게 팀원 구성하기)

TIL (2024.06.15)

문제 1️⃣ ( 리트 코드 _ 좋은 짝의 수)

코드 개선 사항 ① : HashMap 값 추가

코드 개선 사항 ② : HashMap 값 하나씩 꺼내기

최종 코드

문제 2️⃣ ( 리트 코드 _ XOR 연산을 통한 원래 배열 찾기)

TIL (2024.06.14)

문제 1️⃣ ( 리트 코드 _ 배열 섞기)

문제 2️⃣ ( 리트 코드 _ 직사각형 쿼리들)

문제 3️⃣ ( 프로그래머스 _ H-Index)

① H 후보값 범위 설정

② 이분 탐색 수행

③ isPossible 전역함수 생성

TIL (2024.06.13)

문제 1️⃣ ( 리트 코드 _ 학생 최소 이동값)

문제 2️⃣ ( 프로그래머스 _ 순위)

TIL (2024.06.12)

문제 1️⃣ ( 리트 코드 _ 정렬된 이차원 배열에서 음수찾기)

문제 2️⃣ ( 리트 코드 _ 짐 옮기기)

TIL (2024.06.11) _ (Programmers) 입국 심사

문제 1️⃣ ( 리트 코드_조건에 맞는 짝 찾기)

문제 2️⃣ ( 프로그래머스_입국 심사)

문제

제한 사항

입출력 예

풀이 방법

STEP ① : 탐색해야할 최대 범위를 설정

STEP ② : 이분 탐색 수행

STEP ③ : minTime 값 반환

풀이 코드

TIL (2024.06.08)

문제 1️⃣ (리트 코드_모음 문자열 정렬)

풀이 (1)

풀이 (2)

문제 2️⃣ (리트 코드_파스칼 삼각형)

문제 3️⃣ (프로그래머스_정수 삼각형)

➕ 추가로 확인해보면 좋은 문제

TIL (2024.06.06)

문제 1️⃣ (리트코드_비트 세기)

TIL (2024.06.05)

문제 1️⃣ (리트 코드_문자열 밸런싱)

문제 2️⃣ (프로그래머스_구명보트)

문제 3️⃣ (프로그래머스_단속카메라)

참고 : Comparable 과 Comparator 의 차이 (https://st-lab.tistory.com/243)

주의 ⚠️ : PriorityQueue 의 순서를 확인하고 싶을 때는 향상된 for 문이 아닌, poll 을 통해 확인하는 방식으로 진행해야한다.