개발 공부 기록

[프로그래머스/Java] K번째수 : Arrays.copyOfRange()

데메즈 — Tue, 14 Jul 2026 12:26:00 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

★ Queue를 초기화하지 않으면 찌꺼기 데이터가 들어갈 수 있음

1. for문이 시작하자마자 큐를 매번 새로 만들어주거나(queue = new PriorityQueue<>();)

2. 루프가 끝날 때 큐를 비워주(queue.clear();)

★ 정답의 배열의 크기를 아는 상황에서는 stream() 대신 일반배열 쓰기! (효율성 테스트)

import java.util.*;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        ArrayList<Integer> list = new ArrayList<>();
        
        for(int cnt=0; cnt<commands.length; cnt++){
            PriorityQueue<Integer> queue = new PriorityQueue<>();
            
            int i = commands[cnt][0]-1;
            int j = commands[cnt][1]-1;
            int k = commands[cnt][2]-1;

            for(int num = i; num<=j; num++){
                queue.offer(array[num]);
            }
            
            while(k>0){
                k--;
                queue.poll();
            }
            list.add(queue.poll());
        }
        
        return list.stream().mapToInt(i->i).toArray();
    }
}

★ Arrays.copyOfRange() : 자바가 제공하는 배열 자르기 메서드

1. 가독성

2. 압도적인 성능차이

3. 인덱스 계산의 단순

import java.util.Arrays;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
        // 1. 정답을 담을 배열을 commands 개수만큼 미리 만듭니다.
        int[] answer = new int[commands.length];
        
        for (int cnt = 0; cnt < commands.length; cnt++) {
            int i = commands[cnt][0];
            int j = commands[cnt][1];
            int k = commands[cnt][2];
            
            // 2. [핵심] array의 i-1번째부터 j번째 직전까지 슥삭 잘라냅니다.
            // (i-1은 포함, j는 미포함이라 딱 문제 조건만큼 잘립니다.)
            int[] slicedArray = Arrays.copyOfRange(array, i - 1, j);
            
            // 3. 잘라낸 배열을 오름차순으로 정렬합니다. (듀얼 피벗 퀵소트라 엄청 빠릅니다.)
            Arrays.sort(slicedArray);
            
            // 4. 정렬된 배열에서 k-1 번째 수를 정답 배열에 바로 꽂아 넣습니다.
            answer[cnt] = slicedArray[k - 1];
        }
        
        return answer;
    }
}

[프로그래머스/Java] 올바른 괄호 Queue ( +charAt() )

데메즈 — Mon, 13 Jul 2026 18:20:43 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

Queue 사용

import java.util.*;

class Solution {
    boolean solution(String s) {
        boolean answer = true;
        char[] arr = s.toCharArray();
        Queue<Character> queue = new LinkedList<>();
        
        for(char c : arr){
                    
            if(c == '('){
                queue.offer(c);
            } else {
                if(queue.isEmpty()) return false;
                queue.poll();
            }
        }
        

        return queue.isEmpty();
    }
}

charAt() 사용

class Solution {
    boolean solution(String s) {
        int count = 0;
        int len = s.length(); // 반복문 안에서 매번 호출하지 않도록 미리 변수화
        
        for (int i = 0; i < len; i++) {
            if (s.charAt(i) == '(') {
                count++;
            } else {
                // 닫는 괄호가 나왔는데 열린 괄호가 없다면 바로 false
                if (count == 0) return false; 
                count--;
            }
        }
        
        // 최종적으로 모든 괄호의 짝이 맞아서 0이 되어야 true
        return count == 0;
    }
}

[프로그래머스/Java] 프로세스 Queue (+PriorityQueue)

데메즈 — Mon, 13 Jul 2026 18:07:13 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

내 풀이

import java.util.*;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0, result = -1;
        Queue<int[]> queue = new LinkedList<>();
        
        for(int i=0; i<priorities.length; i++){
            queue.offer(new int[]{i, priorities[i]});
        }
        
        while(result != location){
            
            int[] current = queue.poll();
            boolean flag = false;
            
            for(int[] q : queue){
                if(q[1] > current[1]){
                    flag = true;
                    break;
                }
            }
            
            if(flag){
                queue.offer(current);
            } else {
                result = current[0];
                answer++;
            }
        }
        
        
        return answer;
    }
}

PriorityQueue를 활용한 최적화 코드

import java.util.*;

class Solution {
    public int solution(int[] priorities, int location) {
        int answer = 0;
        
        // 1. 일반 큐: [처음 위치, 우선순위] 저장
        Queue<int[]> queue = new LinkedList<>();
        // 2. 우선순위 큐: 높은 숫자(우선순위) 순으로 자동 정렬 (내림차순)
        PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
        
        for (int i = 0; i < priorities.length; i++) {
            queue.offer(new int[]{i, priorities[i]});
            pq.offer(priorities[i]);
        }
        
        while (!queue.isEmpty()) {
            int[] current = queue.poll();
            
            // pq.peek()은 현재 남아있는 프로세스 중 '가장 높은 우선순위'를 말합니다.
            if (current[1] < pq.peek()) {
                // 더 높은 우선순위가 존재하므로 맨 뒤로 보냅니다.
                queue.offer(current);
            } else {
                // 현재 꺼낸 것이 가장 높은 우선순위이므로 실행(인쇄)합니다.
                pq.poll(); // 실행되었으므로 우선순위 큐에서도 제거
                answer++;  // 차례 카운트
                
                // 실행한 프로세스가 내가 찾던 위치(location)라면 종료!
                if (current[0] == location) {
                    break;
                }
            }
        }
        
        return answer;
    }
}

[프로그래머스/Java] 기능개발

데메즈 — Mon, 13 Jul 2026 06:47:22 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

import java.util.*;

class Solution {
    public int[] solution(int[] progresses, int[] speeds) {
        Queue<Integer> queue = new LinkedList<>();
        List<Integer> result = new ArrayList<>();
        
        for(int i=0; i<progresses.length; i++){
            int remain = 100 - progresses[i];
            int day = remain / speeds[i];
            
            if(remain % speeds[i] != 0){
                day++;
            }
            
            queue.offer(day);
        }
        
        while(!queue.isEmpty()){
            int first = queue.poll();
            int count = 1;
            
            while(!queue.isEmpty() && queue.peek() <= first){
                queue.poll();
                count++;
            }
            
            result.add(count);
        }
        
        int[] answer = new int[result.size()];
        
        for(int i=0; i<result.size(); i++){
            answer[i] = result.get(i);
        }
        
        return answer;
    }
}

[프로그래머스/Java] 게임 맵 최단거리 (BFS)

데메즈 — Fri, 10 Jul 2026 22:48:29 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

★ Queue는 q.add() 대기열에 넣는 순간 visited = true 방문체크 해주기!!!!

import java.util.LinkedList;
import java.util.Queue;

class Node{
    int x, y, cost;
    
    Node(int x, int y, int cost){
        this.x = x;
        this.y = y;
        this.cost = cost;
    }
}

class Solution {
    Queue<Node> q = new LinkedList<>();
    boolean[][] visited;
    int[] dx = {-1, 1, 0, 0}; //상하좌우
    int[] dy = {0, 0, -1, 1};
    
    public int solution(int[][] maps) { // 0:벽 1:길
        int answer = 0;
        int n = maps.length, m = maps[0].length;
        
        visited = new boolean[n+1][m+1];
                
        q.add(new Node(1,1,1));
        visited[1][1] = true;
        
        return bfs(maps, n, m);
    }
    
    private int bfs(int[][] maps, int n, int m){
        while(!q.isEmpty()){
            Node current = q.poll();
            
            
            if(current.x == n && current.y == m){
                return current.cost;
            }
            
            for(int i=0; i<4; i++){
                int x = current.x + dx[i];
                int y = current.y + dy[i];
                
                if(x>=1 && x<=n && y>=1 && y<=m && maps[x-1][y-1]==1 && !visited[x][y]){
                    Node item = new Node(x,y,current.cost+1);
                    q.add(item);
                    visited[x][y]=true;
                }
            }
        }
        return -1;
    }
}

BFS 공부 - 최단 거리 (최소 시간)

데메즈 — Fri, 10 Jul 2026 21:34:10 +0900

★BFS는 Queue 자료구조 사용

: 먼저 온 사람이 먼저 나간다 (First In, First Out)

★BFS 실전 뼈대 코드

import java.util.LinkedList;
import java.util.Queue;

class Solution{
	static boolean[] visited;
    
    public void bfs(int startNode, int[][] graph, int n){
    	// 대기 명단을 준비한다
        Queue<Integer> queue = new LinkedList<>();
        
        // 시작점을 큐에 넣고 방문 도장을 찍는다
        queue.add(startNode);
        visited[startNode] = true;
        
        // 대기명단이 텅 빌 때까지 무한 반복
        while(!queue.isEmpty()){
        	// 대기 명단 맨 앞줄에 있는 사람을 꺼낸다
            int current = queue.poll();
            
            // 꺼낸 사람의 이웃들을 전부 살펴본다
            for(int nextNode = 1; nextNode <= n; nextNode++){
            	// 연결되어있고 한번도 방문 안한 친구라면?
                if(graph[current][nextNode]==1 && !visited[nextNode]){
                	// 대기 명단 맨 뒤에 줄을 세우고 방문 도장 찍는다
                    queue.add(nextNode);
                    visited[nextNode] = true;
                }
            }
        }
    }
}

★ 2차원 배열 격자판에서의 상하좌우

// 상하좌우 순서대로 x와 y의 변화량
int[] dx = {-1, 1, 0, 0};
int[] dy = {0, 0, -1, 1};

// for문을 4번 돌리면서 현재 좌표 (x,y)에 더해주면 사방 찔러보기 가능
for(int i=0; i<4; i++){
	int nx = currentX + dx[i];
    int ny = currentY + dy[i];
}

★ Queue에 좌표 두개(x,y)를 같이 넣는 법

class Node{
	int x, y, cost;
    
    Node(int x, int y, int cost){
    	this.x = x;
        this.y = y;
        this.cost = cost;
    }
}

Queue<Node> q = new LinkedList<>();
q.add(new Node(0, 0, 1)); // 0,0 좌표에서 시작 거리 1로 출발

[프로그래머스/Java] 네트워크 (DFS)

데메즈 — Fri, 10 Jul 2026 20:41:21 +0900

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

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

import java.util.Stack;

class Solution {
    boolean[] visited;
    Stack<Integer> stack = new Stack<>();
    public int solution(int n, int[][] computers) {
        int answer = 0;
        visited = new boolean[n];
        
        for(int i=0; i<n; i++){
            if(!visited[i]){
                answer += 1;
                stack.push(i);
                dfs(n, computers);
            }
        }
        
        
        return answer;
    }
    
    private void dfs(int n, int[][] computers){
        if(stack.isEmpty()){
            return;
        }
        int current = stack.pop();
        visited[current] = true;
        
        for(int i=0; i<n; i++){
            if(computers[current][i]==1 && !visited[i]){
                stack.push(i);
            }
        }
        dfs(n, computers);
    }
}

[프로그래머스/Java] 타겟 넘버 (DFS)

데메즈 — Thu, 9 Jul 2026 22:04:10 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/43165?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

1. 기저 조건 (탈출 조건)

- 숫자를 다 골랐을 때( index == numbers.length ) 바닥에 도착한 것

- 이때 sum == target 이라면 정답 카운트 올린다

2. 재귀 단계 (갈래길 탐색)

- 현재 숫자를 더하는 경우 : dfs(index+1, sum+현재숫자)

- 현재 숫자를 빼는 경우 : dfs(index+1, sum-현재숫자)

class Solution {
    int answer = 0;
    public int solution(int[] numbers, int target) {
        // 0번째 인덱스부터, 시작 총합은 0부터 탐색 시작
        dfs(numbers, target, 0, 0);
        return answer;
    }
    
    public void dfs(int[] numbers, int target, int index, int sum){
        // 기저조건 : 모든 숫자를 다 사용해서 바닥에 도달
        if(index == numbers.length){
            // 지금까지의 총합이 타겟넘버와 같다면 정답 카운트 증가
            if(sum == target){
                answer++;
            }
            return;
        }
        
        // 재귀 단계 : 현재 숫자를 더하거나 빼는 두 갈래길 탐색
        dfs(numbers, target, index+1, sum+numbers[index]); // 더하기 선택
        dfs(numbers, target, index+1, sum-numbers[index]); // 빼기 선택
    }
}

DFS 공부

데메즈 — Thu, 9 Jul 2026 21:56:46 +0900

★DFS (깊이 우선 탐색) : 한 우물만 파고 끝까지 내려가는 탐색. 스택(Stack)의 원리나 재귀함수 사용

★BFS (너비 우선 탐색) : 내 주변부터 가까운 곳을 넓게 퍼져나가며 탐색. 큐(Queue)의 자료구조 사용. 최단거리는 무조건 BFS

대표 유형 : 경로탐색, 네트워크, 조합 만들기

DFS : 재귀함수

BFS : Queue / LinkedList

★ 재귀 함수의 필수 2대 조건★

1. 기저 조건(Base Case) : "언제 멈출 것인가?" 를 정하는 탈출 조건 (if 문으로 구현)

2. 재귀 단계 (Recursive Case) : 문제를 더 작은 단위로 쪼개서 자기 자신을 다시 호출

<그래프를 코드로 표현하는 방법>

1. 인접 행렬

노드가 총 3개 있고, 1-2, 1-3 연결된 그래프 (인덱스를 번호와 맞추기 위해 크기를 N+1로 잡는게 팁)

int[][] graph = new int[4][4]; // 0번은 안쓰고 1~3번 노드 사용

graph[1][2] = 1; graph[2][1] = 1; // 1번과 2번이 연결됨(양방향)
graph[1][3] = 1; graph[3][1] = 1; // 1번과 3번이 연결됨

장점 : graph[1][3] = 1 인지만 확인하면 되니까 빛의 속도로 확인 가능

단점 : 노드가 1만개인데 연결된 선은 고작 2개라면, 메모리를 엄청나게 낭비

2. 인접 리스트 ★실전 빈출

각 노드마다 바구니(ArrayList) 를 하나씩 주고, 연결된 이웃 번호를 담아두는 방법

- 1번 바구니 : [2,3] (2,3번과 연결)

- 2번 바구니 : [1] (1번과 연결)

import java.util.ArrayList;

// 노드 개수만큼 ArrayList 공간(바구니 배열)을 만든다
ArrayList<Integer>[] graph = new ArrayList[4];

// 각 방마다 진자 바구니를 채워 초기화한다
for(int i=1; i<=3; i++){
	graph[i] = new ArrayList<>();
}

// 연결 정보 입력하기
graph[1].add(2); graph[2].add(1); // 1번 바구니에 2 넣고, 2번 바구니에 1 넣기
graph[1].add(3); graph[3].add(10; // 1번 바구니에 3 넣고, 3번 바구니에 1 넣기

장점 : 연결된 만큼만 숫자를 저장해서 메모리를 효율적으로 사용

단점 : 코드 모양이 복잡해보인다

★실전에서 뭘 써야할까?

1. 바둑판, 미로찾기, 모눈종이 맵 : 고민도 하지말고 1번 인접행렬(2차원 배열)

2. 트리구조, 컴퓨터 네트워크, 친구 관계 맵 : 2번 인접리스트

DFS의 실전 뼈대 코드와 방문(visited) 체크 개념

★DFS 실전 뼈대 코드 ★

import java.util.ArrayList;

class Solution{
	// 전역 변수로 그래프 도화지와 방문체크 배열 선언
    static ArrayList<Integer>[] graph;
    static boolean[] visited;
    
    public void dfs(int node){
    	// [체크인] 현재 노드에 방문 도장을 찍는다
        visited[node] = true;
        System.out.print(node + "->");
        
        // [이웃 탐색] 현재 노드와 연결된 친구(이웃)들을 한놈씩 꺼낸다
        for(int nextNode : graph[node]){
        	// [방어 조건] 만약 방문한적이 없다면?
            if(!visited[nextNode]){
            	dfs(nextNode);
            }
        }
    }
}

[프로그래머스/Java] 의상

데메즈 — Thu, 9 Jul 2026 20:48:00 +0900

https://school.programmers.co.kr/learn/courses/30/lessons/42578?language=java

프로그래머스

SW개발자를 위한 평가, 교육의 Total Solution을 제공하는 개발자 성장을 위한 베이스캠프

programmers.co.kr

조합 까먹음 ㅠㅠ

import java.util.HashMap;

class Solution {
    public int solution(String[][] clothes) {
        HashMap<String, Integer> map = new HashMap<>();
        
        for(String[] cloth : clothes){
            String kind = cloth[1];
            map.put(kind, map.getOrDefault(kind, 0)+1);
        }
        int answer = 1;
        for(String key : map.keySet()){
            int num = map.get(key);
            answer *= (num+1);
        }
        
        return answer-1;
    }
}