Minjeong / 7월 1주차 / 3문제

[Mingguriguri]

푼 문제가 여러 개라면 아래 폼 형식 복사해서 넣어주시면 됩니다 :D

🌱WIL

이번 한 주의 소감을 작성해주세요!

• 이번 한 주간은 면접도 보러 다니느라 조금 정신없었다. 그래도 그 와중에 코테 문제 조금이라도 풀어서 다행이다. 이중우선순위큐 문제는 어려운 것으느 알고 있었지만 생각보다 잘 안 풀리고 2개의 힙을 동기화하는 아이디어를 생각해내기가 어려웠다. 하지만 문제를 풀고 나서 리스트나 딕셔너리를 이용해 동기화할 수 있다는 것을 알게 된 것 같다
• 이번 주에는 자바로도 문제를 풀이하려고 노력했다. 하지만 좀 복잡한 구현의 경우는 자바로 하는 것이 어려워서 파이썬으로 했다. 하지만 그래도 앞으로는 자바로 풀이하는 것까지 해보는 습관을 들이고 싶다.

🚀주간 목표 문제 수: 3개

푼 문제

• 프로그래머스 #42885. 구명보트(java): 그리디 / Level2
• 프로그래머스 #42576. 완주하지 못한 선수(java): 구현 / Level1
• 프로그래머스 #42628. 이중우선순위큐: 우선순위큐 / Level3
• 프로그래머스 #17679. 프렌즈4블록: 구현 / Level2

---

프로그래머스 #42885. 구명보트: 그리디 / Level2

정리한 링크: (바로가기)

🚩플로우 (선택)

코드를 풀이할 때 적었던 플로우가 있나요?

• 투포인터를 하기 위해서는 “정렬”되어 있어야 한다. 따라서 람들의 몸무게 배열 people을 오름차순으로 정렬한다.
• 가장 가벼운 사람을 가리키는 포인터 left와, 가장 무거운 사람을 가리키는 포인터 right를 선언한다.
• 아래 과정을 반복한다.

  1. people[left] + people[right] 의 값이 limit보다 작거나 같다면 ⇒ 두 사람 모두 태울 수 있다.

     따라서 boat + 1 해야 한다. 그 다음, left를 오른쪽으로 한 칸 옮기고(left++), right를 왼쪽으로 한 칸 옮겨야 한다(right—-).

  2. people[left] + people[right] 의 값이 limit보다 크다면 ⇒ 몸무게가 더 많이 나가는 people[right] 한 사람만 태울 수 있다.

     따라서 boat + 1한 후 right만 왼쪽으로 한 칸 옮겨야 한다.(right--)

  3. 이를 left 포인터와 right 포인터가 서로 교차할 때까지 반복한다.

🚩제출한 코드

import java.util.*;

class Solution {
    public int solution(int[] people, int limit) {
        int boat = 0;
        int left = 0;
        int right = people.length - 1;
        
        Arrays.sort(people);
        
        while (left <= right) {
            if (people[left] + people[right] <= limit) {
                left += 1;
                right -= 1;
            } else {
                right -= 1;
            }
            boat += 1;

        }
        return boat;
    }
}

💡TIL

배운 점이 있다면 입력해주세요

• 이미 여러 번 풀었던 문제라 큰 어려움이 없었다.
• Array보다는 ArrayList를 더 자주 쓰다보니 Array에 사용할 수 있는 메소드를 많이 까먹었다. 자바 문법을 다시 리마인드할 수 있는 문제였다.

---

프로그래머스 #42576. 완주하지 못한 선수(java): 구현 / Level1

정리한 링크: (바로가기)

🚩제출한 코드

해시맵 풀이

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        String answer = "";
        
        HashMap<String, Integer> dict = new HashMap<>();
        
        for (String p : participant) dict.put(p, dict.getOrDefault(p, 0) + 1);
        for (String c : completion) dict.put(c, dict.get(c) - 1);
        
        for (String key: dict.keySet()) {
            if (dict.get(key) != 0) {
                answer = key;
            }
		}
        
        return answer;
    }
}

정렬을 이용한 풀이

import java.util.*;

class Solution {
    public String solution(String[] participant, String[] completion) {
        Arrays.sort(participant);
        Arrays.sort(completion);
        
        for (int i = 0; i < completion.length; i++) {
            if (!participant[i].equals(completion[i])) {
                return participant[i];
            }
        }
        
        return participant[participant.length - 1];
    }
}

💡TIL

배운 점이 있다면 입력해주세요

---

프로그래머스 #42628. 이중우선순위큐: 우선순위큐 / Level3

정리한 링크: (바로가기)

🚩플로우 (선택)

코드를 풀이할 때 적었던 플로우가 있나요?

1. 삽입(I)
   • min_heap: 원래 값 넣기
   • max_heap: 부호를 반전시킨 값 넣기(파이썬의 heapq 모듈은 최소힙 기반이기 때문)
   • number_count[num](num이 큐에 나온 횟수) 을 +1, size(큐에 잇는 원소 개수)를 +1 해주기
2. 삭제(D)
   • size가 0이면 무시.
   • D 1(최댓값 삭제)일 때는 max_heap에서 팝(pop)하면서 number_count> 0인 첫 값을 찾아 카운트를 –1, size도 –1.
   • D -1(최솟값 삭제)일 때는 min_heap에서 동일하게 처리.
3. 최종 결과
   • size == 0인 경우, [0, 0] 반환
   • 아닌 경우, min_heap과 max_heap 각각에서 유효한(=number_count[x] > 0) 최댓값과 최솟값을 각각 찾아서 반환

🚩제출한 코드

import heapq

def solution(operations):
    min_heap = []
    max_heap = []
    number_count = {}   # 각 숫자가 큐에 몇 번 남았는지 카운트
    size = 0            # 현재 큐에 남아있는 총 원소 수

    for op in operations:
        cmd, num_str = op.split(' ')
        num = int(num_str)

        if cmd == 'I':
            # 삽입
            heapq.heappush(min_heap, num)
            heapq.heappush(max_heap, -num)
            number_count[num] = number_count.get(num, 0) + 1
            size += 1
        else: # cmd == 'D'
            if size == 0:
                # 큐가 비어있다면 연산 무시
                continue
            
            if num == 1:
                # 최댓값 삭제
                while max_heap:
                    x = -heapq.heappop(max_heap)
                    if number_count.get(x, 0) > 0: 
                        # num이 1번 이상 등장했다면, 카운트 반영
                        number_count[x] -= 1
                        size -= 1
                        break
            else:
                # num == -1, 최솟값 삭제  
                while min_heap:
                    x = heapq.heappop(min_heap)
                    if number_count.get(x, 0) > 0: 
                        # num이 1번 이상 등장했다면, 카운트 반영
                        number_count[x] -= 1
                        size -= 1
                        break
                        
    # 연산 후 큐가 비어있다면 [0, 0]
    if size == 0:
        return [0, 0]
    
    # 남아있는 최댓값 찾기
    max_value = 0
    while max_heap:
        x = -heapq.heappop(max_heap)
        if number_count.get(x, 0) > 0: 
            max_value = x
            break
            
    # 남아있는 최솟값 찾기
    min_value = 0
    while min_heap:
        x = heapq.heappop(min_heap)
        if number_count.get(x, 0) > 0: 
            min_value = x
            break
            

    return [max_value, min_value]

💡TIL

배운 점이 있다면 입력해주세요

• 처음에 초기에 들어가야 하는 값을 min_heap과 max_heap에 각각 어떻게 저장하는 게 좋을지 고민이 됐다. 이 min_heap과 max_heap 을 동기화 처리하는 부분도 헷갈렸다. 이번 문제를 통해서 2개의 힙을 동기화하는 방법을 위해 리스트나 딕셔너리를 사용하면 된다는 것을 알게 되었다.
• 또한 heapq를 오랜만에 풀다 보니, heap이 최소 힙 기반이었다는 것도 까먹었다. 다시 리마인드하게 되었다.

---

프로그래머스 #17679. 프렌즈4블록: 구현 / Level2

정리한 링크: (바로가기)

🚩플로우 (선택)

코드를 풀이할 때 적었던 플로우가 있나요?

🚩제출한 코드

def check(m, n, board):
    filter = [[0 for _ in range(n)] for _ in range(m)]
    count = 0

    for i in range(m - 1):
        for j in range(n - 1):
            a = board[i][j]
            b = board[i][j + 1]
            c = board[i + 1][j]
            d = board[i + 1][j + 1]
            if a == b == c == d and a != '0':
                filter[i][j], filter[i][j + 1], filter[i + 1][j], filter[i + 1][j + 1] = 1, 1, 1, 1

    for i in range(m):
        for j in range(n):
            if filter[i][j] == 1:
                count += 1
                board[i][j] = '0'

    if count == 0:
        return 0

    for i in range(m - 2, -1, -1):
        for j in range(n):
            k = i
            while 0 <= k + 1 < m and board[k + 1][j] == '0':
                k += 1
            if k != i:
                board[k][j] = board[i][j]
                board[i][j] = '0'

    return count


def solution(m, n, board):
    answer = 0
    board = list(map(list, board))

    while True:
        temp = check(m, n, board)
        if temp == 0:
            break
        answer += temp

    return answer

💡TIL

배운 점이 있다면 입력해주세요

[github-actions]

🔥2025-07 챌린지 진행 상황

👉 그래프

• Mingguriguri: 0개 ❌

👉 구현

• Mingguriguri: 2개 ❌

[github-actions]

🔥2025-07 챌린지 진행 상황

👉 그리디

• Mingguriguri: 1개 ❌

👉 구현

• Mingguriguri: 2개 ❌