행복한 B+

[프로그래머스, 17687] [3차] n진수 게임 (java)

행B — Sat, 10 Jan 2026 09:00:15 +0900

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

프로그래머스

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

programmers.co.kr

728x90

메모리: 98.2 MB, 시간: 45.20 ms

사용 알고리즘: 구현

import java.util.*;

class Solution {
    
    LinkedList<Character> list;
    
    public String solution(int n, int t, int m, int p) {
        
        StringBuilder answer = new StringBuilder();
        
        list = new LinkedList<>();
        list.add('0');
        list.add('0');
        
        int now = 1;
        while(list.size() < t * m + 1) {
            change(n, now++);
        }
        
        for(int i = p; i <= t * m; i += m)
            answer.append(list.get(i));
        
        return answer.toString();
    }
    
    private void change(int n, int num) {
        
        int k = 1;
        while(k * n <= num) k *= n;
        
        int tmp;
        while(k != 0) {
            tmp = num / k;
            num %= k;
            k /= n;
            
            if(tmp <= 9) list.add((char)(tmp + '0'));
            else list.add((char)('A' + (tmp - 10)));
        }
    }
}

[프로그래머스, 92335] k진수에서 소수 개수 구하기 (java)

행B — Fri, 9 Jan 2026 09:00:30 +0900

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

프로그래머스

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

programmers.co.kr

728x90

메모리: 73.6 MB, 시간: 6.52 ms

사용 알고리즘: 구현

import java.util.*;

class Solution {
    public int solution(int n, int k) {
        
        // n을 k진수로 변환
        List<Integer> toK = change(n, k);
        
        // 처음 나오는 0과 마지막에 나오는 0 구하기
        int firstZero = -1, lastZero = -1;
        for(int i = 0; i < toK.size(); i++) {
            if(toK.get(i) == 0) {
                firstZero = i;
                break;
            }
        }
        for(int i = toK.size() - 1; i >= 0; i--) {
            if(toK.get(i) == 0) {
                lastZero = i;
                break;
            }
        }
        
        // 조건에 맞는 소수 구하기
        int answer;
        if(firstZero == -1) return isP(toK);
        else return is0P0(toK, firstZero, lastZero) + isP0(toK, firstZero) + is0P(toK, lastZero);
    }
    
    // n을 k진수로 변환
    private List<Integer> change(int n, int k) {
        
        List<Integer> ret = new ArrayList<>();
        
        // n보다 작은 k의 제곱 중 가장 큰 수 찾기
        int max = k;
        while(max * k <= n) max *= k;
        
        // k진수 구하기
        while(n != 0) {
            ret.add(n / max);
            n %= max;
            max /= k;
        }
        
        return ret;
    }
    
    private int is0P0(List<Integer> numList, int firstZero, int lastZero) {
        
        int ret = 0, p = 0;
        for(int i = firstZero + 1; i <= lastZero; i++) {
            if(numList.get(i) == 0) {
                if(isPrime(p)) ret++;
                p = 0;
            }
            
            p = p * 10 + numList.get(i);
        }
        
        return ret;
    }
    
    private int isP0(List<Integer> numList, int firstZero) {
        
        if(firstZero == -1) return 0;
        
        int p = 0;
        for(int i = 0; i < firstZero; i++) {
            p = p * 10 + numList.get(i);
        }
        
        if(isPrime(p)) return 1;
        else return 0;
    }
    
    private int is0P(List<Integer> numList, int lastZero) {
 
        if(lastZero == -1) return 0;
        
        int p = 0;
        for(int i = lastZero + 1; i < numList.size(); i++) {
            p = p * 10 + numList.get(i);
        }
        
        if(isPrime(p)) return 1;
        else return 0;
    }
    
    private int isP(List<Integer> numList) {
        
        long p = 0;
        
        for(int i = 0; i < numList.size(); i++) {
            p = p * 10 + numList.get(i);
        }
        
        if(isPrime(p)) return 1;
        else return 0;
    }
    
    private boolean isPrime(long n) {
        
        if(n < 2) return false;
        if(n % 2 == 0) return n == 2;

        for(long i = 3; i * i <= n; i += 2)
            if(n % i == 0) return false;
        
        return true;
    }
}

[프로그래머스, 17677] [1차] 뉴스 클러스터링 (java)

행B — Thu, 8 Jan 2026 09:00:42 +0900

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

프로그래머스

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

programmers.co.kr

728x90

메모리: 79.4 MB, 시간: 1.86 ms

사용 알고리즘: 구현

import java.util.*;

class Solution {
    public int solution(String str1, String str2) {
        
        // str1의 다중집합
        Map<String, Integer> set1 = new HashMap<>();
        getSet(str1, set1);
        
        // str2의 다중집합
        Map<String, Integer> set2 = new HashMap<>();
        getSet(str2, set2);
        
        // 교집합 갯수 구하기
        int andSet = 0;
        for(String key : set1.keySet()) {
            andSet += Math.min(set1.getOrDefault(key, 0), set2.getOrDefault(key, 0));
        }
        
        // 합집합 갯수 구하기
        int orSet = 0;
        for(String key : set1.keySet()) {
            orSet += Math.max(set1.getOrDefault(key, 0), set2.getOrDefault(key, 0));
        }
        for(String key : set2.keySet()) {
            if(set1.get(key) == null)
                orSet += set2.get(key);
        }
        
        // 다중집합 구하기
        int answer;
        if(orSet == 0) answer = 65536;
        else answer = andSet * 65536 / orSet;
        return answer;
    }
    
    private void getSet(String str, Map<String, Integer> set) {
        
        String tmp;
        for(int i = 1; i < str.length(); i++) {
            // 알파벳이 아닐 경우 넘어가기
            if(!(str.charAt(i - 1) >= 'a' && str.charAt(i - 1) <= 'z')
               && !(str.charAt(i - 1) >= 'A' && str.charAt(i - 1) <= 'Z')) continue;
            if(!(str.charAt(i) >= 'a' && str.charAt(i) <= 'z')
               && !(str.charAt(i) >= 'A' && str.charAt(i) <= 'Z')) continue;
            
            tmp = str.substring(i - 1, i + 1).toUpperCase();
            
            set.put(tmp, set.getOrDefault(tmp, 0) + 1);
        }
    }
}

[프로그래머스, 284530] 연도 별 평균 미세먼지 농도 조회하기 (mysql)

행B — Wed, 7 Jan 2026 09:00:23 +0900

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

프로그래머스

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

programmers.co.kr

728x90

select
    year(ym) as 'YEAR',
    round(avg(pm_val1), 2) as 'PM10',
    round(avg(pm_val2), 2) as 'PM2.5'
from air_pollution
where location2 = '수원'
group by 1
order by 1;

[프로그래머스, 150369] 택배 배달과 수거하기 (java)

행B — Tue, 6 Jan 2026 09:00:29 +0900

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

프로그래머스

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

programmers.co.kr

728x90

메모리: 83.4 MB, 시간: 20.63 ms

사용 알고리즘: 구현

class Solution {
    public long solution(int cap, int n, int[] deliveries, int[] pickups) {
        long answer = 0;
        
        // 가장 뒤에 있는 배달지
        int lastDelivery = -1;
        for(int i = n - 1; i >= 0; i--) {
            if(deliveries[i] != 0) {
                lastDelivery = i;
                break;
            }
        }
        
        // 가장 뒤에 있는 수거지
        int lastPickup = -1;
        for(int i = n - 1; i >= 0; i--) {
            if(pickups[i] != 0) {
                lastPickup = i;
                break;
            }
        }
        
        // 맨 뒤 집부터 cap만큼 배달 & 수거
        int dCap, pCap;
        while(lastDelivery >= 0 || lastPickup >= 0) {
            
            answer += Math.max(lastDelivery + 1, lastPickup + 1) * 2;
            
            dCap = cap;
            pCap = cap;
            
            for(int i = lastDelivery; i >= 0; i--) {
                if(deliveries[i] <= dCap) {
                    dCap -= deliveries[i];
                    lastDelivery--;
                }
                else {
                    deliveries[i] -= dCap;
                    break;
                }
            }
            
            for(int i = lastPickup; i >= 0; i--) {
                if(pickups[i] <= pCap) {
                    pCap -= pickups[i];
                    lastPickup--;
                }
                else {
                    pickups[i] -= pCap;
                    break;
                }
            }
        }
        
        return answer;
    }
}

[백준, BOJ 1717] 집합의 표현 (java)

행B — Mon, 5 Jan 2026 09:00:17 +0900

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

메모리: 53,188 KB , 시간: 332 ms

사용 알고리즘: 유니온-파인드

728x90

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

public class Main {

    static int[] parent;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int n = Integer.parseInt(st.nextToken());
        int m = Integer.parseInt(st.nextToken());

        parent = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            parent[i] = i;
        }

        StringBuilder result = new StringBuilder();

        int p, a, b;
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            p = Integer.parseInt(st.nextToken());
            a = Integer.parseInt(st.nextToken());
            b = Integer.parseInt(st.nextToken());

            if (p == 0) {
                union(a, b);
            } else {
                a = find(a);
                b = find(b);
                if(a == b) result.append("YES\n");
                else result.append("NO\n");
            }
        }

        System.out.print(result);
    }

    static private void union(int a, int b) {
        a = find(a);
        b = find(b);

        if(a < b) parent[b] = a;
        else parent[a] = b;
    }

    static private int find(int num) {
        if(parent[num] == num) return num;

        return parent[num] = find(parent[num]);
    }
}

[백준, BOJ 14425] 문자열 집합 (java)

행B — Sun, 4 Jan 2026 09:00:40 +0900

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

메모리: 38,936 KB , 시간: 288 ms

사용 알고리즘: 자료 구조, 문자열, 집합과 맵, 해시를 사용한 집합과 맵, 트리를 사용한 집합과 맵

728x90

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        StringTokenizer st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        HashSet<String> S = new HashSet<>();
        for (int i = 0; i < N; i++) {
            S.add(br.readLine());
        }

        int result = 0;

        String s;
        for (int i = 0; i < M; i++) {
            s = br.readLine();

            if(S.contains(s)) result++;
        }

        System.out.println(result);
    }
}

[프로그래머스, 293261] 물고기 종류 별 대어 찾기 (mysql)

행B — Sat, 3 Jan 2026 09:00:48 +0900

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

프로그래머스

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

programmers.co.kr

728x90

select fi.id as id, fni.fish_name as fish_name, length
from fish_info as fi
left join fish_name_info as fni
on fi.fish_type = fni.fish_type
where (fi.fish_type, length) in (
    select fish_type, max(length)
    from fish_info
    group by fish_type
);

[백준, BOJ 7682] 틱택토 (java)

행B — Fri, 2 Jan 2026 09:00:58 +0900

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

메모리: 11,672 KB , 시간: 68 ms

사용 알고리즘: 구현, 많은 조건 분기

728x90

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.LinkedList;

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        LinkedList<String> graphs = new LinkedList<>();

        String input;
        while(true) {
            input = br.readLine();

            if(input.equals("end")) break;
            graphs.add(input);
        }

        StringBuilder answer = new StringBuilder();
        for(String g : graphs) {
            if(play(g)) answer.append("valid\n");
            else answer.append("invalid\n");
        }
        System.out.print(answer);
    }

    static private boolean play(String graph) {

        int emptyPlace = 0, xPlace = 0, oPlace = 0;
        for (int i = 0; i < 9; i++) {
            if(graph.charAt(i) == '.') emptyPlace++;
            else if(graph.charAt(i) == 'X') xPlace++;
            else oPlace++;
        }

        // X가 먼저 말을 놓기 때문에, O의 개수가 더 많을 수는 없음
        if((oPlace != xPlace) && (oPlace != xPlace - 1)) return false;

        // 가로, 세로, 대각선이 동일한 줄이 몇 개인지 확인
        int xWin = 0, oWin = 0;

        // 가로줄 확인
        if(graph.substring(0, 3).equals("XXX")) xWin++;
        if(graph.substring(3, 6).equals("XXX")) xWin++;
        if(graph.substring(6, 9).equals("XXX")) xWin++;
        if(graph.substring(0, 3).equals("OOO")) oWin++;
        if(graph.substring(3, 6).equals("OOO")) oWin++;
        if(graph.substring(6, 9).equals("OOO")) oWin++;

        // 세로줄 확인
        if(graph.charAt(0) == 'X' && graph.charAt(3) == 'X' && graph.charAt(6) == 'X') xWin++;
        if(graph.charAt(1) == 'X' && graph.charAt(4) == 'X' && graph.charAt(7) == 'X') xWin++;
        if(graph.charAt(2) == 'X' && graph.charAt(5) == 'X' && graph.charAt(8) == 'X') xWin++;
        if(graph.charAt(0) == 'O' && graph.charAt(3) == 'O' && graph.charAt(6) == 'O') oWin++;
        if(graph.charAt(1) == 'O' && graph.charAt(4) == 'O' && graph.charAt(7) == 'O') oWin++;
        if(graph.charAt(2) == 'O' && graph.charAt(5) == 'O' && graph.charAt(8) == 'O') oWin++;

        // 대각선 확인
        if(graph.charAt(0) == 'X' && graph.charAt(4) == 'X' && graph.charAt(8) == 'X') xWin++;
        if(graph.charAt(2) == 'X' && graph.charAt(4) == 'X' && graph.charAt(6) == 'X') xWin++;
        if(graph.charAt(0) == 'O' && graph.charAt(4) == 'O' && graph.charAt(8) == 'O') oWin++;
        if(graph.charAt(2) == 'O' && graph.charAt(4) == 'O' && graph.charAt(6) == 'O') oWin++;

        if(xWin == 1 && oWin == 0 && (xPlace - 1 == oPlace)) return true;
        if(xWin == 0 && oWin == 1 && (xPlace == oPlace)) return true;
        if(emptyPlace == 0) {
            if(xWin == 0 && oWin == 0) return true;
            if(xWin == 2) return true;
        }
        return false;
    }
}

[프로그래머스, 132265] 롤케이크 자르기 (java)

행B — Tue, 16 Dec 2025 09:00:17 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 119 MB, 시간: 27.84 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int[] topping) {
        
        int answer = 0;
        
        // 형과 동생의 각 토핑 개수
        int[] t1 = new int[10_001];
        int[] t2 = new int[10_001];
        
        // 형과 동생의 토핑 가짓수
        int t1Count = 0;
        int t2Count = 0;
        
        // 모든 토핑을 형이 가졌을 때, 각 토핑 개수와 가짓수 구하기
        for(int i = 0; i < topping.length; i++) {
            if(t1[topping[i]] == 0) t1Count++;
            t1[topping[i]]++;
        }
        
        // 하나씩 동생 주기
        for(int i = 0; i < topping.length; i++) {
            if(t1[topping[i]] == 1) t1Count--;
            t1[topping[i]]--;
            
            if(t2[topping[i]] == 0) t2Count++;
            t2[topping[i]]++;
            
            if(t1Count == t2Count) answer++;
        }
        
        return answer;
    }
}

[프로그래머스, 64065] 튜플 (java)

행B — Mon, 15 Dec 2025 23:15:39 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 111 MB, 시간: 45.90 ms

사용 알고리즘: 자료구조, 문자열

import java.util.*;

class Solution {
    public int[] solution(String s) {
        
        int start, end;
        StringTokenizer st;
        ArrayList<Integer> list;
        Map<Integer, ArrayList> map = new HashMap<>();
        for(int i = 1; i < s.length() - 1; i++) {
            if(s.charAt(i) == '{') {
                start = i;
                while(s.charAt(++i) != '}');
                end = i;
                // {} 안의 수들을 ","를 기준으로 분할
                st = new StringTokenizer(s.substring(start + 1, end), ",");
                // 분할한 수들을 리스트에 담기
                list = new ArrayList<>();
                while(st.hasMoreTokens()) list.add(Integer.parseInt(st.nextToken()));
                // 리스트 길이를 key값으로 Map에 담기
                map.put(list.size(), list);
            }
        }
        
        int[] answer = new int[map.size()];
        Set<Integer> set = new HashSet<>();
        for(int i = 1; i <= map.size(); i++) {
            // 리스트 길이가 짧은 순으로 가져오기
            list = map.get(i);
            for(int j = 0; j < list.size(); j++) {
                // 이미 확인한 수는 넘어가기
                if(!set.contains(list.get(j))) {
                    set.add(list.get(j));
                    answer[i - 1] = list.get(j);
                    break;
                }
            }
            
        }
        return answer;
    }
}

[프로그래머스, 12949] 행렬의 곱셈 (java)

행B — Mon, 15 Dec 2025 22:31:02 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 76.8 MB, 시간: 11.13 ms

사용 알고리즘: 배열

class Solution {
    public int[][] solution(int[][] arr1, int[][] arr2) {
        
        int[][] answer = new int[arr1.length][arr2[0].length];
        
        for(int i = 0; i < arr1.length; i++) {
            for(int j = 0; j < arr2[0].length; j++) {
                for(int k = 0; k < arr2.length; k++) {
                    answer[i][j] += arr1[i][k] * arr2[k][j];
                }
            }
        }
        
        return answer;
    }
}

[프로그래머스, 87390] n^2 배열 자르기 (java)

행B — Sat, 13 Dec 2025 09:00:17 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 111 MB, 시간: 8.38 ms

사용 알고리즘: 구현

class Solution {
    public int[] solution(int n, long left, long right) {
        
        int[] answer = new int[(int)(right - left) + 1];
        
        long x, y, num;
        for(long i = left; i <= right; i++) {
            // 3차원 배열이었을 때의 좌표
            x = i / n;
            y = i % n;
            
            // x, y 중 더 큰 수에 +1 한 값이 저장되어 있음
            answer[(int)(i - left)] = (int)Math.max(x, y) + 1;
        }
        
        return answer;
    }
}

[프로그래머스, 76502] 괄호 회전하기 (java)

행B — Fri, 12 Dec 2025 09:00:26 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 87 MB, 시간: 569.57 ms

사용 알고리즘: 스택

import java.util.*;

class Solution {
    public int solution(String s) {
        
        int answer = 0;
        
        List<Character> sList = new LinkedList<>();
        for(int i = 0; i < s.length(); i++) {
            sList.add(s.charAt(i));
        }
        
        Stack<Character> stack = new Stack<>();
        boolean flag;
        for(int i = 0; i < s.length(); i++) {
            flag = true;
            
            for(int j = 0; j < sList.size(); j++) {
                if(sList.get(j) == '(' || sList.get(j) == '{' || sList.get(j) == '[')
                    stack.push(sList.get(j));
                else if((sList.get(j) == ')' && !stack.isEmpty() && stack.peek() == '(') ||
                        (sList.get(j) == '}' && !stack.isEmpty() &&  stack.peek() == '{') ||
                        (sList.get(j) == ']' && !stack.isEmpty() &&  stack.peek() == '['))
                            stack.pop();
                else {
                    flag = false;
                    break;
                }
            }
            
            if(stack.size() != 0) flag = false;
            
            if(flag) answer++;
            
            sList.add(sList.get(0));
            sList.remove(0);
        }
        
        return answer;
    }
}

[프로그래머스, 131701] 연속 부분 수열 합의 개수 (java)

행B — Thu, 11 Dec 2025 09:00:04 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 135 MB, 시간: 1471.99 ms

사용 알고리즘: 구현

import java.util.*;

class Solution {
    public int solution(int[] elements) {
        
        // 중복 제거를 위한 맵
        Set<Integer> set = new HashSet<>();
        
        int sum, idx;
        for(int i = 1; i <= elements.length; i++) { // 수열의 길이
            for(int j = 0; j < elements.length; j++) { // 시작 부분
                sum = 0;
                for(int k = 0; k < i; k++) {
                    sum += elements[(j + k) % elements.length];
                }
                set.add(sum);
            }
        }
        
        return set.size();
    }
}

[백준, BOJ 2166] 다각형의 면적 (java)

행B — Wed, 10 Dec 2025 09:00:58 +0900

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

메모리: 17,176 KB , 시간: 132 ms

사용 알고리즘: 기하학, 다각형의 넓이

기하학의 신발끈 공식이라는 개념이 필요한 문제이다.

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

        long[][] points = new long[N + 1][2];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            points[i][0] = Long.parseLong(st.nextToken());
            points[i][1] = Long.parseLong(st.nextToken());
        }
        points[N] = points[0];

        long sum1 = 0L, sum2 = 0L;
        for (int i = 0; i < N; i++) {
            sum1 += points[i][0] * points[i + 1][1];
            sum2 += points[i][1] * points[i + 1][0];
        }

        System.out.printf("%.1f", Math.round(Math.abs(sum1 - sum2) / 2.0 * 10) / 10.0);
    }
}

[백준, BOJ 16967] 배열 복원하기 (java)

행B — Tue, 9 Dec 2025 09:00:41 +0900

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

메모리: 41,804 KB , 시간: 308 ms

사용 알고리즘: 구현

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int H = Integer.parseInt(st.nextToken());
        int W = Integer.parseInt(st.nextToken());
        int X = Integer.parseInt(st.nextToken());
        int Y = Integer.parseInt(st.nextToken());

        int[][] B = new int[H + X][W + Y];
        for (int i = 0; i < B.length; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < B[i].length; j++) {
                B[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        int[][] A = new int[H][W];
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                if(i - X < 0 || j - Y < 0) A[i][j] = B[i][j];
                else A[i][j] = B[i][j] - A[i - X][j - Y];
            }
        }

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < H; i++) {
            for (int j = 0; j < W; j++) {
                result.append(A[i][j]).append(" ");
            }
            result.append("\n");
        }
        System.out.print(result);
    }
}

[프로그래머스, 301647] 부모의 형질을 모두 가지는 대장균 찾기 (mysql)

행B — Mon, 8 Dec 2025 09:00:35 +0900

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

프로그래머스

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

programmers.co.kr

select my.id as id, my.genotype as genotype, p.genotype as parent_genotype
from ecoli_data as my
left join ecoli_data as p
on my.parent_id = p.id
where bin(my.genotype & p.genotype) = bin(p.genotype)
order by my.id;

[프로그래머스, 389480] 완전범죄 (java)

행B — Sun, 7 Dec 2025 23:42:11 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 93.7 MB, 시간: 12.69 ms

사용 알고리즘: 자료구조

import java.util.*;

class Solution {
    public int solution(int[][] info, int n, int m) {
        
        Queue<int[]> q = new LinkedList();
        if(info[0][0] < n) q.add(new int[] {info[0][0], 0});
        if(info[0][1] < m) q.add(new int[] {0, info[0][1]});
        
        Queue<int[]> next;
        boolean[][] visited;
        
        int[] tmp;
        for(int i = 1; i < info.length; i++) {
            next = new LinkedList();
            visited = new boolean[n + 1][m + 1];
            while(!q.isEmpty()) {
                tmp = q.poll();
                
                if(tmp[0] + info[i][0] < n && !visited[tmp[0] + info[i][0]][tmp[1]]) {
                    next.add(new int[] {tmp[0] + info[i][0], tmp[1]});
                    visited[tmp[0] + info[i][0]][tmp[1]] = true;
                }
                if(tmp[1] + info[i][1] < m && !visited[tmp[0]][tmp[1] + info[i][1]]) {
                    next.add(new int[] {tmp[0], tmp[1] + info[i][1]});
                    visited[tmp[0]][tmp[1] + info[i][1]] = true;
                }
            }
            q = next;
        }
        
        int answer = n;
        while(!q.isEmpty()) {
            tmp = q.poll();
            answer = Math.min(answer, tmp[0]);
        }
        
        if(answer == n) return -1;
        else return answer;
    }
}

[백준, BOJ 1072] 게임 (java)

행B — Sun, 7 Dec 2025 23:36:31 +0900

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

메모리: 11,516 KB , 시간: 72 ms

사용 알고리즘: 이분 탐색

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        int x = Integer.parseInt(st.nextToken());
        int y = Integer.parseInt(st.nextToken());
        int z = (int)(((long)y * 100) / x);

        if(x == y) {
            System.out.println(-1);
            return;
        }

        // 이분탐색
        int s = 1, e = x, m;
        int answer = -1;
        while(s <= e) {
            m = (s + e) / 2;

            if(z < (int)(((long)(y + m) * 100) / (x + m))) {
                e = m - 1;
                answer = m;
            }
            else s = m + 1;
        }

        System.out.println(answer);

    }
}

[프로그래머스, 67260] [카카오 인턴] 동굴 탐험 (java)

행B — Sun, 10 Aug 2025 01:56:49 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 143 MB, 시간: 285.11 ms

사용 알고리즘: 그래프, 스택, DFS

import java.util.*;

class Solution {
    
    public boolean solution(int n, int[][] path, int[][] order) {
        // 인접한 동굴 정보를 담을 리스트
        ArrayList<Queue<Integer>> edges = new ArrayList<>();
        for(int i = 0; i < n; i++)
            edges.add(new LinkedList<>());
        for(int i = 0; i < n - 1; i++) {
            edges.get(path[i][0]).add(path[i][1]);
            edges.get(path[i][1]).add(path[i][0]);
        }
        
        // 먼저 방문해야 하는 동굴 리스트
        int[] preVisit = new int[n];
        for(int i = 0; i < order.length; i++) {
            // 0번 방보다 먼저 방문해야 하는 방이 있으면 절대 모든 방을 탐험할 수 없음
            if(order[i][1] == 0) return false;
            
            preVisit[order[i][1]] = order[i][0];
        }
        
        // 방문 완료한 동굴 리스트
        boolean[] visited = new boolean[n];
        
        // dfs 대신, 방문 경로를 담을 스택
        ArrayDeque<Integer> stack = new ArrayDeque<>();
        stack.addLast(0);
        visited[0] = true;
        
        int answer = 0;
        
        int now, next;
        while(!stack.isEmpty()) {        
            now = stack.peekLast();
            
            // 연결된 방 중, 더 이상 확인할 방이 없는 경우
            if(edges.get(now).size() == 0) {
                answer++;
                stack.pollLast();
                continue;
            }
            
            next = edges.get(now).poll();
            // 역행 방지
            if(visited[next]) continue;
            
            // 아직 선행 방이 미방문 상태라면
            if(!visited[preVisit[next]])
                // 선행 방에 임의의 간선 연결
                // 선행 방에 방문 후, 방문할 수 있게 하기
                edges.get(preVisit[next]).add(next);
            else {
                // 다음 방 방문하기
                stack.addLast(next);
                visited[next] = true;
            }
        }
        
        if(answer == n) return true;
        else return false;
    }
}

[프로그래머스, 49189] 가장 먼 노드 (java)

행B — Sat, 9 Aug 2025 23:46:44 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 119 MB, 시간: 31.81 ms

사용 알고리즘: 그래프, 다익스트라

import java.util.*;

class Solution {
    public int solution(int n, int[][] edge) {
        int answer = 0;
        int maxLength = 0;
        
        // 최단거리를 저장할 배열
        int[] minLength = new int[n + 1];
        Arrays.fill(minLength, n);
        minLength[1] = 0;
        
        // 간선 정보를 저장할 리스트
        ArrayList<ArrayList<Integer>> edges = new ArrayList<>();
        for(int i = 0; i <= n; i++)
            edges.add(new ArrayList<>());
        
        // 간선 정보 저장
        for(int i = 0; i < edge.length; i++) {
            edges.get(edge[i][0]).add(edge[i][1]);
            edges.get(edge[i][1]).add(edge[i][0]);
        }
        
        // 다익스트라
        PriorityQueue<int[]> pq = new PriorityQueue<>(
                                        (o1, o2) -> o1[1] - o2[1]);
        pq.add(new int[] {1, 0});
        
        int[] now;
        ArrayList<Integer> e;
        int next;
        while(!pq.isEmpty()) {
            now = pq.poll();
            
            // 이미 최단거리를 구했다면 넘어가기
            if(minLength[now[0]] < now[1]) continue;
            
            // 가장 멀리 떨어진 노드인지 확인
            if(maxLength < now[1]) {
                maxLength = now[1];
                answer = 1;
            }
            else if(maxLength ==  now[1])
                answer++;
            
            // now에서 연결된 간선 이동
            e = edges.get(now[0]);
            for(int i = 0; i < e.size(); i++) {
                next = e.get(i);
                if(minLength[next] > now[1] + 1) {
                    minLength[next] = now[1] + 1;
                    pq.add(new int[] {next, now[1] + 1});
                }
            }
        }
        
        return answer;
    }
}

[백준, BOJ 13302] 리조트 (java)

행B — Sat, 26 Jul 2025 21:54:30 +0900

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

메모리: 14,376 KB , 시간: 76 ms

사용 알고리즘: 다이나믹 프로그래밍, 백트래킹

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

public class Main {

    static final int MAX = 100 * 10_000;

    static int N;
    static boolean[] visited;
    static int[][] dp;
    static int result;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        // true := 리조트에 갈 수 있는 날
        // false := 리조트에 갈 수 없는 날
        visited = new boolean[N + 1];
        Arrays.fill(visited, true);

        if(M != 0) {
            st = new StringTokenizer(br.readLine());
            for (int i = 0; i < M; i++) {
                visited[Integer.parseInt(st.nextToken())] = false;
            }
        }

        // DP -> 같은 경우를 다시 계산하지 않기 위해 최소값 저장
        dp = new int[N + 6][N + 2];
        for (int i = 1; i < N + 6; i++) {
           Arrays.fill(dp[i], MAX);
        }

        result = MAX;
        backTracking(1, 0, 0);

        System.out.println(result);
    }

    private static void backTracking(int day, int coupon, int price) {

        // 리조트에 갈 수 있는 날로 이동
        while(day <= N && !visited[day]) day++;
        // 방학이 끝난 경우 답 갱신하고 리턴
        if(day > N) {
            result = Math.min(result, price);
            return;
        }

        // 쿠폰 이용하는 경우
        if(coupon >= 3 && dp[day + 1][coupon - 3] > price) {
            dp[day + 1][coupon - 3] = price;
            backTracking(day + 1, coupon - 3, price);
        }

        // 하루 이용권 이용하는 경우
        if(dp[day + 1][coupon] > price + 10_000) {
            dp[day + 1][coupon] = price + 10_000;
            backTracking(day + 1, coupon, price + 10_000);
        }

        // 연속 3일권 이용하는 경우
        if(dp[day + 3][coupon + 1] > price + 25_000) {
            dp[day + 3][coupon + 1] = price + 25_000;
            backTracking(day + 3, coupon + 1, price + 25_000);
        }

        // 연속 5일권 이용하는 경우
        if(dp[day + 5][coupon + 2] > price + 37_000) {
            dp[day + 5][coupon + 2] = price + 37_000;
            backTracking(day + 5, coupon + 2, price + 37_000);
        }
    }
}

[프로그래머스, 120807] 숫자 비교하기 (java)

행B — Mon, 7 Jul 2025 23:45:51 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 88.6 MB, 시간: 0.02 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int num1, int num2) {
        return num1 == num2 ? 1 : -1;
    }
}

[프로그래머스, 120803] 두 수의 차 구하기 (java)

행B — Fri, 4 Jul 2025 23:46:29 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 83.1 MB, 시간: 0.02 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int num1, int num2) {
        return num1 - num2;
    }
}

[백준, BOJ 2661] 좋은수열 (java)

행B — Wed, 2 Jul 2025 22:48:33 +0900

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

메모리: 303,776 KB , 시간: 1,632 ms

사용 알고리즘: 그래프 이론, 브루트포스 알고리즘, 그래프 탐색, 트리, 깊이 우선 탐색

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.StringTokenizer;

public class Main {

    static ArrayList<ArrayList<int[]>> edges;
    static int[][] edgesInfo;
    static long maxlen;

    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

        edges = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            edges.add(new ArrayList<>());
        }

        edgesInfo = new int[N - 1][3];

        int from, to, cost;
        for (int i = 0; i < N - 1; i++) {
            st = new StringTokenizer(br.readLine());
            from = Integer.parseInt(st.nextToken());
            to = Integer.parseInt(st.nextToken());
            cost = Integer.parseInt(st.nextToken());

            edges.get(from).add(new int[] {i, to, cost});
            edges.get(to).add(new int[] {i, from, cost});

            edgesInfo[i] = new int[] {from, to, cost};
        }

        /**
         * 간선을 하나씩 끊어본다.
         * 간선을 끊음으로써 생긴 두 개의 트리의 지름을 구하고,
         * 두 트리 지름을 합친다.
         */
        long answer = 0, tmp;
        for (int i = 0; i < N - 1; i++) {
            from = edgesInfo[i][0];
            to = edgesInfo[i][1];
            cost = edgesInfo[i][2];
            tmp = 0;

            maxlen = 0;
            getChildrenCosts(to, from, 0);
            tmp = maxlen;

            maxlen = 0;
            getChildrenCosts(from, to, 0);
            tmp += maxlen;

            answer = Math.max(answer, tmp + cost);
        }

        System.out.println(answer);
    }

    private static long getChildrenCosts (int parent, int node, int cost) {

        ArrayList<int[]> edge = edges.get(node);

        if(edge.size() == 1) { // 리프 노드인 경우
            return cost;
        }

        int[] next;
        List<Long> children = new ArrayList<>();
        for (int i = 0; i < edge.size(); i++) {
            next = edge.get(i);
            if(parent != next[1]) { // 역행 방지
                children.add(getChildrenCosts(node, next[1], next[2]));
            }
        }

        if(children.size() == 1) { // 자식이 하나라면 바로 리턴
            maxlen = Math.max(maxlen, children.get(0));
            return children.get(0) + cost;
        } else { // 아니라면 가장 긴 두 개의 자식으로 대소비교 후 리턴
            Collections.sort(children, Collections.reverseOrder());
            maxlen = Math.max(maxlen, children.get(0) + children.get(1));
            return children.get(0) + cost;
        }
    }
}

[프로그래머스, 120810] 나머지 구하기 (java)

행B — Wed, 2 Jul 2025 22:45:05 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 85.9 MB, 시간: 0.03 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int num1, int num2) {
        return num1 % num2;
    }
}

[프로그래머스, 160586] 대충 만든 자판 (java)

행B — Fri, 27 Jun 2025 21:50:42 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 91.5 MB, 시간: 2.39 ms

사용 알고리즘: 자료구조, 문자열

import java.util.*;

class Solution {
    public int[] solution(String[] keymap, String[] targets) {
        
        HashMap<Character, Integer> km = new HashMap<>();
        
        // 각 키별로 가장 적게 누를 수 있는 횟수 저장
        String key; char k;
        for(int i = 0; i < keymap.length; i++) {
            key = keymap[i];
            for(int j = 0; j < key.length(); j++) {
                k = key.charAt(j);
                if(km.get(k) == null || km.get(k) > j + 1)
                    km.put(k, j + 1);
            }
        }
        
        int[] answer = new int[targets.length];
        
        for(int i = 0; i < targets.length; i++) {
            key = targets[i];
            for(int j = 0; j < key.length(); j++) {
                k = key.charAt(j);
                if(km.get(k) == null) {
                    answer[i] = -1;
                    break;
                }
                else answer[i] += km.get(k);
            }
        }
        
        return answer;
    }
}

[백준, BOJ 2661] 좋은수열 (java)

행B — Tue, 24 Jun 2025 16:16:13 +0900

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

메모리: 11,524 KB , 시간: 68 ms

사용 알고리즘: 백트래킹

import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Main {

    static int N;
    static int[] arr;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        N = Integer.parseInt(br.readLine());
        arr = new int[N];

        combi(0);

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < N; i++) {
            result.append(arr[i]);
        }
        System.out.println(result);
    }

    private static boolean combi(int n) {

        if(n == N)
            return true;

        for(int i = 1; i <= 3; i++) {
            arr[n] = i;

            // 좋은 수열인지 확인
            if(isGood(n)) {
                if(combi(n + 1)) return true;
            }
        }

        return false;
    }

    private static boolean isGood(int n) {

        boolean flag;
        for (int i = 1; i <= (n + 1) / 2; i++) {

            flag = false;

            for (int j = 0; j < i; j++) {
                if(arr[n - i - j] != arr[n - j]) {
                    flag = true;
                    break;
                }
            }

            if(!flag) return false;
        }

        return true;
    }
}

[백준, BOJ 2212] 센서 (java)

행B — Mon, 23 Jun 2025 22:16:29 +0900

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

메모리: 14,884 KB , 시간: 116 ms

사용 알고리즘: 그리디 알고리즘, 정렬

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

        int[] arr = new int[N];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < N; i++) {
            arr[i] = Integer.parseInt(st.nextToken());
        }

        // 정렬
        Arrays.sort(arr);

        // 센서 간 거리
        int[] len = new int[N - 1];
        for (int i = 0; i < N - 1; i++) {
            len[i] = arr[i + 1] - arr[i];
        }

        // 정렬
        Arrays.sort(len);

        int answer = 0;

        // 센서 간 거리가 가까운 것부터 하나의 집중국이 처리할 수 있도록 합치기
        // 집중국을 K개만 설치할 수 있으므로 N - K개만큼 합치기
        for (int i = 0; i < N - K; i++) {
            answer += len[i];
        }

        System.out.println(answer);
    }
}

[프로그래머스, 155652] 둘만의 암호 (java)

행B — Sat, 21 Jun 2025 23:45:46 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 77.4 MB, 시간: 0.09 ms

사용 알고리즘: 문자열

class Solution {
    public String solution(String s, String skip, int index) {
        
        // 각 알파벳이 skip에 포함되는지 여부 확인
        boolean[] inSkip = new boolean['z' - 'a' + 1];
        for(int i = 0; i < skip.length(); i++) {
            inSkip[skip.charAt(i) - 'a'] = true;
        }
        
        StringBuilder answer = new StringBuilder();
        
        int now;
        for(int i = 0; i < s.length(); i++) {
            now = s.charAt(i) - 'a';
            for(int j = 0; j < index; j++) {
                now = now == 'z' - 'a' ? 0 : now + 1;
                while(inSkip[now]) {
                    now = now == 'z' - 'a' ? 0 : now + 1;
                }
            }
            answer.append((char)('a' + now));
        }
        
        
        return answer.toString();
    }
}

[프로그래머스, 133499] 옹알이 (2) (java)

행B — Fri, 20 Jun 2025 00:24:32 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 84.5 MB, 시간: 0.26 ms

사용 알고리즘: 문자열, 구현

class Solution {
    public int solution(String[] babbling) {
        int answer = 0;
        
        int pre; // 1: aya, 2: ye, 3: woo, 4: ma
        int idx;
        String s;
        for(int i = 0; i < babbling.length; i++) {
            s = babbling[i];
            pre = 0;
            idx = 0;
            
            while(true) {
                if(pre != 1 && s.length() - idx >= 3 
                   && s.substring(idx, idx + 3).equals("aya")) {
                    idx += 3;
                    pre = 1;
                }
                else if(pre != 2 && s.length() - idx >= 2
                        && s.substring(idx, idx + 2).equals("ye")) {
                    idx += 2;
                    pre = 2;
                }
                else if(pre != 3 && s.length() - idx >= 3
                        && s.substring(idx, idx + 3).equals("woo")) {
                    idx += 3;
                    pre = 3;
                }
                else if(pre != 4 && s.length() - idx >= 2
                        && s.substring(idx, idx + 2).equals("ma")) {
                    idx += 2;
                    pre = 4;
                }
                else break;
                
                if(idx == s.length()) {
                    answer++;
                    break;
                }
            }
        }
        return answer;
    }
}

[프로그래머스, 120805] 몫 구하기 (java)

행B — Fri, 20 Jun 2025 00:02:35 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 71.8 MB, 시간: 0.02 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int num1, int num2) {
        return num1 / num2;
    }
}

[백준, BOJ 11780] 플로이드 2 (java)

행B — Tue, 17 Jun 2025 23:15:10 +0900

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

메모리: 54,436 KB , 시간: 412 ms

사용 알고리즘: 그래프 이론, 최단 경로, 플로이드–워셜

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

public class Main {

    static int MAX = 10_000_001;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        int n = Integer.parseInt(br.readLine());
        int m = Integer.parseInt(br.readLine());

        // 최단 비용 저장할 배열
        int[][] weight = new int[n + 1][n + 1];
        for (int i = 1; i <= n; i++) {
            Arrays.fill(weight[i], MAX);
            weight[i][i] = 0;
        }

        // 경로를 저장할 리스트
        ArrayList<Integer>[][] routes = new ArrayList[n + 1][n + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                routes[i][j] = new ArrayList<>();
            }
        }

        // 버스 정보 입력
        int s, e, w;
        for (int i = 0; i < m; i++) {
            st = new StringTokenizer(br.readLine());
            s = Integer.parseInt(st.nextToken());
            e = Integer.parseInt(st.nextToken());
            w = Integer.parseInt(st.nextToken());

            weight[s][e] = Math.min(weight[s][e], w);
        }

        // 플로이드-워셜
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                for (int k = 1; k <= n; k++) {
                    // i를 거쳐가는게 최소비용이라면
                    if(weight[j][i] + weight[i][k] < weight[j][k]) {
                        // 최소비용 갱신
                        weight[j][k] = weight[j][i] + weight[i][k];

                        // 거쳐가는 도시 리스트 갱신
                        routes[j][k].clear(); // 기존 리스트 삭제
                        routes[j][k].addAll(routes[j][i]); // j -> i까지의 도시 리스트 추가
                        routes[j][k].add(i);
                        routes[j][k].addAll(routes[i][k]); // i -> k까지의 도시 리스트 추가
                    }
                }
            }
        }

        // 출력
        StringBuilder result = new StringBuilder();
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                result.append(weight[i][j] == MAX ? 0 : weight[i][j]).append(" ");
            }
            result.append("\n");
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if(weight[i][j] == 0 || weight[i][j] == MAX) {
                    result.append("0\n");
                }
                else {
                    result.append(routes[i][j].size() + 2).append(" ").append(i).append(" ");
                    for (int k = 0; k < routes[i][j].size(); k++) {
                        result.append(routes[i][j].get(k)).append(" ");
                    }
                    result.append(j).append("\n");
                }
            }
        }
        System.out.println(result);
    }
}

[백준, BOJ 2213] 트리의 독립집합 (java)

행B — Fri, 6 Jun 2025 16:10:53 +0900

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

메모리: 23,316 KB , 시간: 224 ms

사용 알고리즘: 다이나믹 프로그래밍, 트리, 트리에서의 다이나믹 프로그래밍, 역추적, DFS

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class Main {

    // DFS에서 리턴 값으로 사용할 클래스
    private static class Node {
        int o; // 현재 노드를 포함했을 때 최댓값
        ArrayList<Integer> oList; // o의 경우에 포함되는 정점 리스트

        int x; // 혅재 노드를 포함하지 않았을 때 최솟값
        ArrayList<Integer> xList; // x의 경우에 포함되는 정점 리스트

        Node(int w, int n) { // 현재 노드의 가중치와 정점 번호 입력
            this.o = w;
            this.oList = new ArrayList<>();
            oList.add(n);

            this.x = 0;
            this.xList = new ArrayList<>();
        }
    }

    static int[] weight;
    static ArrayList<ArrayList<Integer>> edges;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

        // 정점의 가중치
        weight = new int[n + 1];
        st = new StringTokenizer(br.readLine());
        for (int i = 1; i <= n; i++) {
            weight[i] = Integer.parseInt(st.nextToken());
        }

        // 긴선 정보
        edges = new ArrayList<>();
        for (int i = 0; i <= n; i++) {
            edges.add(new ArrayList<>());
        }
        int u, v;
        for (int i = 0; i < n - 1; i++) {
            st = new StringTokenizer(br.readLine());
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());

            edges.get(u).add(v);
            edges.get(v).add(u);
        }

        // 1번 정점부터 DFS
        Node ret = dfs(0, 1);

        // 1번 노드를 포함시킨 경우와 포함시키지 않은 경우 중 더 큰 수를 담으로 출력
        StringBuilder result = new StringBuilder();
        if(ret.o > ret.x) {
            result.append(ret.o).append("\n");

            Collections.sort(ret.oList);
            for (int i = 0; i < ret.oList.size(); i++) {
                result.append(ret.oList.get(i)).append(" ");
            }
        }
        else {
            result.append(ret.x).append("\n");

            Collections.sort(ret.xList);
            for (int i = 0; i < ret.xList.size(); i++) {
                result.append(ret.xList.get(i)).append(" ");
            }
        }

        System.out.println(result);
    }

    static Node dfs(int parent, int node) {

        Node ret = new Node(weight[node], node);

        // node에 연결된 간선 정보
        ArrayList<Integer> edge = edges.get(node);

        int next;
        Node child;
        for (int i = 0; i < edge.size(); i++) {
            next = edge.get(i);

            if(next != parent) { // 역행 방지
                child = dfs(node, next); // 자식 노드의 최댓값 구해오기

                // 현재 노드를 포함하는 경우, 자식 노드는 무조건 포함시킬 수 없음
                ret.o += child.x;
                ret.oList.addAll(child.xList);

                // 현재 노드를 포함하지 않는 경우, 자식 노드를 포함시키건 시키지 않건 상관 없음
                // 더 큰 경우를 선택
                if(child.o > child.x) {
                    ret.x += child.o;
                    ret.xList.addAll(child.oList);
                }
                else {
                    ret.x += child.x;
                    ret.xList.addAll(child.xList);
                }
            }
        }

        return ret;
    }
}

[백준, BOJ 2580] 스도쿠 (java)

행B — Thu, 5 Jun 2025 19:48:25 +0900

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

메모리: 89,044 KB , 시간: 280 ms

사용 알고리즘: 구현, 백트래킹

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

public class Main {

    static int[][] sudoku;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        sudoku = new int[9][9];
        for (int i = 0; i < 9; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 0; j < 9; j++) {
                sudoku[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        backTracking(0, 0);

        StringBuilder result = new StringBuilder();
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                result.append(sudoku[i][j]).append(" ");
            }
            result.append("\n");
        }
        System.out.print(result);
    }

    static boolean backTracking(int x, int y) {

        // 현재 위치에서 올 수 있는 숫자들
        boolean[] isPossible = new boolean[10];
        Arrays.fill(isPossible, true);

        for (int i = x; i < 9; i++) {
            for (int j = i == x ? y : 0; j < 9; j++) {
                if(sudoku[i][j] == 0) { // 아직 채우지 않은 수를 발견했다면

                    // 현재 위치에 올 수 있는 숫자들 구하기
                    for (int k = 0; k < 9; k++) {
                        // 가로줄 확인
                        isPossible[sudoku[i][k]] = false;
                        // 세로줄 확인
                        isPossible[sudoku[k][j]] = false;
                        // 3x3 칸 확인
                        isPossible[sudoku[i / 3 * 3 + k / 3][j / 3 * 3 + k % 3]] = false;
                    }

                    for (int k = 1; k <= 9; k++) {
                        if(isPossible[k]) { // 가능한 수를 발견했다면
                            sudoku[i][j] = k;

                            if(backTracking(i, j)) { // 다음 자리까지 모두 완료되면
                                return true;
                            }

                        }
                    }

                    // 채울 수 있는 수를 발견하지 못한 경우, 뒤로 되돌아감
                    sudoku[i][j] = 0;
                    return false;
                }
            }
        }

        return true;
    }
}

[프로그래머스, 12977] 소수 만들기 (java)

행B — Mon, 2 Jun 2025 01:05:09 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 92.2 MB, 시간: 1.48 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int[] nums) {
        
        // 1 이상 3,000 이하의 수 중, 소수인 것들 구하기
        boolean[] isNotPrimeNumber = new boolean[3_001];
        isNotPrimeNumber[1] = true;
        
        for(int i = 2; i * i < 3_001; i++) {
            if(!isNotPrimeNumber[i]) {
                for(int j = i * i; j < 3_001; j += i) {
                    isNotPrimeNumber[j] = true;
                }
            }
        }
        
        
        int answer = 0;

        // nums에서 3개를 골랐을 때 소수이면 answer + 1
        int sum;
        for(int i = 0; i < nums.length - 2; i++) {
            for(int j = i + 1; j < nums.length - 1; j++) {
                for(int l = j + 1; l < nums.length; l++) {
                    sum = nums[i] + nums[j] + nums[l];
                    if(!isNotPrimeNumber[sum]) answer++;
                }
            }
        }

        return answer;
    }
}

[백준, BOJ 2982] 국왕의 방문 (java)

행B — Fri, 30 May 2025 17:33:46 +0900

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

메모리: 25,212 KB , 시간: 336 ms

사용 알고리즘: 그래프 이론, 최단 경로, 데이크스트라

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        st = new StringTokenizer(br.readLine());
        int A = Integer.parseInt(st.nextToken());
        int B = Integer.parseInt(st.nextToken());
        int K = Integer.parseInt(st.nextToken());
        int G = Integer.parseInt(st.nextToken());

        // 고둘라가 방문하는 교차로
        int[] gRoot = new int[G];
        st = new StringTokenizer(br.readLine());
        for (int i = 0; i < G; i++) {
            gRoot[i] = Integer.parseInt(st.nextToken());
        }

        // 도로 정보
        ArrayList<ArrayList<int[]>> edges = new ArrayList<>();
        for (int i = 0; i <= N; i++) {
            edges.add(new ArrayList<>());
        }

        int U, V, L;
        for (int i = 1; i <= M; i++) {
            st = new StringTokenizer(br.readLine());
            U = Integer.parseInt(st.nextToken());
            V = Integer.parseInt(st.nextToken());
            L = Integer.parseInt(st.nextToken());

            // 도로 번호, 도착 지점, 걸리는 시간 순으로 저장
            edges.get(U).add(new int[] {i, V, L});
            edges.get(V).add(new int[] {i, U, L});
        }

        // 고둘라가 시간대별 지나가는 도로의 번호 저장
        ArrayList<Integer> times = new ArrayList<>();

        // 고둘라가 시간대별 지나가는 도로의 번호 구하기
        int s, e;
        ArrayList<int[]> edge;
        for (int i = 0; i < G - 1; i++) {
            s = gRoot[i];
            e = gRoot[i + 1];

            // s에서 e로 가기 위한 도로 번호 찾기
            edge = edges.get(s);
            for (int j = 0; j < edge.size(); j++) {
                if(edge.get(j)[1] == e) {
                    for (int k = 1; k <= edge.get(j)[2]; k++) {
                        times.add(edge.get(j)[0]);
                    }
                    break;
                }
            }
        }

        // 상근이가 A에서 B로 가는 최단 루트 구하기
        // 현재 위치, 현재 시각, 걸린 시간 순으로 저장
        PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2) -> o1[2] - o2[2]);
        pq.add(new int[] {A, K, 0});

        // 각 교차로에 도착할 수 있는 최단 시간 저장
        int[] visited = new int[N + 1];
        Arrays.fill(visited, 1_000_001);
        visited[A] = K;

        int[] now, tmp;
        while(!pq.isEmpty()) {
            now = pq.poll();

            // B까지 가는 최단거리를 찾은 경우
            if(now[0] == B) {
                System.out.println(now[2]);
                return;
            }

            // 이미 더 최단거리를 찾은 경로인 경우, 넘어가기
            if(visited[now[0]] < now[1]) continue;

            // now로부터 연결된 도로를 통해 다른 곳까지 이동
            edge = edges.get(now[0]);
            for (int[] next : edge) {
                tmp = new int[] {next[1], now[1] + next[2], now[2] + next[2]};

                // 만약 고둘라가 next 도로를 지나가는 중이라면 기다려야 함
                for (int i = now[1]; i < times.size(); i++) {
                    if(times.get(i) == next[0]) {
                        tmp[1]++;
                        tmp[2]++;
                    }
                    else break;
                }

                // 현재 경로가 최단경로일 경우에만 큐에 넣어줌
                if(visited[next[1]] > tmp[1]) {
                    visited[next[1]] = tmp[1];
                    pq.add(tmp);
                }
            }
        }
    }
}

[백준, BOJ 2073] 수도배관공사 (java)

행B — Thu, 29 May 2025 23:04:29 +0900

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

메모리: 19,168 KB , 시간: 200 ms

사용 알고리즘: 배낭 문제

DP로 좀 더 간단히 풀 수 있는 문제였는데, 복잡하게 생각해서 복잡하게 풀었다...

시간복잡도 계산하는 습관 다시 들여서, 간단하게 풀 수 있으면 간단하게 풀어야겠다!

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int D = Integer.parseInt(st.nextToken());
        int P = Integer.parseInt(st.nextToken());

        // 파이프 정보
        int[][] pipes = new int[P][2];
        for (int i = 0; i < P; i++) {
            st = new StringTokenizer(br.readLine());
            pipes[i][0] = Integer.parseInt(st.nextToken());
            pipes[i][1] = Integer.parseInt(st.nextToken());
        }

        // 파이프 용량을 기준으로 내림차순 정렬
        Arrays.sort(pipes, (o1, o2) -> o2[1] - o1[1]);

        // 최대 용량
        int[] max_size = new int[D + 1];

        // 이전 파이프까지 사용했을 때의 경우의 수들을 담은 큐
        ArrayDeque<int[]> queue = new ArrayDeque<>();
        // 이번 파이프까지 사용했을 때의 경우의 수들을 담은 큐
        ArrayDeque<int[]> tmp;

        int[] pipe, t;
        for (int i = 0; i < P; i++) {

            pipe = pipes[i];
            if(pipe[0] > D) continue;
            if(pipe[0] == D) {
                System.out.println(pipe[1]);
                return;
            }

            tmp = new ArrayDeque<>();

            // 이전 파이프까지 사용했을 때의 경우의 수들을 하나씩 확인
            while(!queue.isEmpty()) {
                t = queue.pollFirst();

                // 현재 파이프를 사용했을 때, D 길이의 파이프를 조합할 수 있는 경우
                if(t[0] + pipe[0] == D) {
                    System.out.println(pipe[1]);
                    return;
                }

                // 큐에서도 용량이 큰 파이프 순으로 담길 수 있도록 넣어준다
                tmp.add(t);

                // 현재 파이프를 연결했을 때, 최대 용량인 경우라면 큐에 넣어줌
                if(t[0] + pipe[0] < D && max_size[t[0] + pipe[0]] == 0) {
                    max_size[t[0] + pipe[0]] = pipe[1];
                    tmp.add(new int[] {t[0] + pipe[0], pipe[1]});
                }
            }

            // 현재 파이프가 처음 나온 길이일 때
            if(max_size[pipe[0]] == 0) {
                max_size[pipe[0]] = pipe[1];
                tmp.add(pipe);
            }

            queue = tmp;
        }
    }
}

[백준, BOJ 17485] 진우의 달 여행 (Large) (java)

행B — Wed, 28 May 2025 21:52:12 +0900

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

메모리: 114,232 KB , 시간: 540 ms

사용 알고리즘: 다이나믹 프로그래밍

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

public class Main {

    static final int MAX = 100_001;

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int M = Integer.parseInt(st.nextToken());

        // 소모되는 연료의 양
        int[][] cost = new int[N][M + 2];
        for (int i = 0; i < N; i++) {
            st = new StringTokenizer(br.readLine());
            for (int j = 1; j <= M; j++) {
               cost[i][j] = Integer.parseInt(st.nextToken());
            }
        }

        // dp[i][j][0]: (i - 1, j - 1) 공간에서 (i, j)로 넘어왔을 때의 최솟값
        // dp[i][j][1]: (i - 1, j) 공간에서 (i, j)로 넘어왔을 때의 최솟값
        // dp[i][j][2]: (i - 1, j + 1) 공간에서 (i, j)로 넘어왔을 때의 최솟값
        int[][][] dp = new int[N][M + 2][3];
        for (int i = 1; i <= M; i++) {
            Arrays.fill(dp[0][i], cost[0][i]);
        }
        for (int i = 0; i < N; i++) {
            Arrays.fill(dp[i][0], MAX);
            Arrays.fill(dp[i][M + 1], MAX);
        }

        for (int i = 1; i < N; i++) {
            for (int j = 1; j <= M; j++) {
                // (i - 1, j - 1)에서 올 수 있는 최솟값
                dp[i][j][0] = Math.min(dp[i - 1][j - 1][1], dp[i - 1][j - 1][2]) + cost[i][j];

                // (i - 1, j)에서 올 수 있는 최솟값
                dp[i][j][1] = Math.min(dp[i - 1][j][0], dp[i - 1][j][2]) + cost[i][j];

                // (i - 1, j + 1)에서 올 수 있는 최솟값
                dp[i][j][2] = Math.min(dp[i - 1][j + 1][0], dp[i - 1][j + 1][1]) + cost[i][j];
            }
        }

        // dp[N] 중 최솟값 구하기
        int result = MAX;
        for (int i = 1; i <= M; i++) {
            for (int j = 0; j < 3; j++) {
                result = Math.min(result, dp[N - 1][i][j]);
            }
        }

        System.out.println(result);
    }
}

[프로그래머스, 17681] [1차] 비밀지도 (java)

행B — Mon, 26 May 2025 17:25:07 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 79.8 MB, 시간: 0.11 ms

사용 알고리즘: 문자열, 구현

class Solution {
    public String[] solution(int n, int[] arr1, int[] arr2) {
        String[] answer = new String[n];
        
        StringBuilder sb;
        
        for(int i = 0; i < n; i++) {
            sb = new StringBuilder();
            
            for(int j = 0; j < n; j++) {
                if(arr1[i] % 2 == 0 && arr2[i] % 2 == 0)
                    sb.append(' ');
                else
                    sb.append('#');
                
                arr1[i] /= 2;
                arr2[i] /= 2;
            }
            
            answer[i] = sb.reverse().toString();
        }
        
        return answer;
    }
}

[백준, BOJ 15732] 도토리 숨기기 (java)

행B — Fri, 23 May 2025 16:37:24 +0900

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

메모리: 18,928 KB , 시간: 192 ms

사용 알고리즘: 이분 탐색

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

public class Main {

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

        st = new StringTokenizer(br.readLine());
        int N = Integer.parseInt(st.nextToken());
        int K = Integer.parseInt(st.nextToken());
        long D = Long.parseLong(st.nextToken());

        // 규칙
        int[][] rules = new int[K][3];
        for (int i = 0; i < K; i++) {
            st = new StringTokenizer(br.readLine());
            rules[i][0] = Integer.parseInt(st.nextToken());
            rules[i][1] = Integer.parseInt(st.nextToken());
            rules[i][2] = Integer.parseInt(st.nextToken());
        }

        // 이분탐색
        int s = 1, e = N, m;
        long d;
        int result = 0;
        while(s <= e) {
            m = (s + e) / 2;

            // m번 상자까지 몇 개의 도토리를 넣을 수 있는지 확인
            d = 0;
            for (int i = 0; i < K; i++) {
                if(rules[i][0] <= m) {
                    d += (Math.min(m, rules[i][1]) - rules[i][0]) / rules[i][2] + 1;
                }
            }

            if(d < D) { // 뒷 상자까지 도토리를 담을 수 있다면
                s = m + 1;
            }
            else {// m번 상자까지 도토리를 담을 수 없다면
                result = m;
                e = m - 1;
            }
        }

        System.out.println(result);
    }
}

[백준, BOJ 12978] 스크루지 민호 2 (java)

행B — Thu, 22 May 2025 16:46:15 +0900

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

메모리: 64,084 KB , 시간: 572 ms

사용 알고리즘: 다이나믹 프로그래밍, 트리에서의 다이나믹 프로그래밍, 트리

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;

public class Main {

    static ArrayList<ArrayList<Integer>> edges;
    static int[][] dp;

    public static void main(String[] args) throws Exception {

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st;

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

        // 도시 연결 상태 저장 리스트
        edges = new ArrayList<>();
        for(int i = 0; i <= N; i++)
            edges.add(new ArrayList<>());

        int u, v;
        for (int i = 0; i < N - 1; i++) {
            st = new StringTokenizer(br.readLine());
            u = Integer.parseInt(st.nextToken());
            v = Integer.parseInt(st.nextToken());

            edges.get(u).add(v);
            edges.get(v).add(u);
        }

        dp = new int[N + 1][2];

        // 1번 도시부터 시작
        dfs(1, 0);

        System.out.println(Math.min(dp[1][0], dp[1][1]));
    }

    private static void dfs(int now, int parent) {

        ArrayList<Integer> edge = edges.get(now);

        for(int next : edge) {
            if(next != parent) {
                dfs(next, now);

                // now에 경찰서를 건설할 경우, next에는 건설하든 하지 않든 상관 없음
                dp[now][0] += Math.min(dp[next][0], dp[next][1]);
                // now에 경찰서를 건설하지 않을 경우, next에는 무조건 건설해야 함
                dp[now][1] += dp[next][0];
            }
        }

        // now에 경찰서 건설
        dp[now][0] += 1;
    }
}

[프로그래머스, 12918] 문자열 다루기 기본 (java)

행B — Wed, 21 May 2025 23:17:46 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 86.2 MB, 시간: 0.04 ms

사용 알고리즘: 문자열

class Solution {
    public boolean solution(String s) {
        
        // 길이 체크
        if(s.length() != 4 && s.length() != 6)
            return false;
        
        // 문자 체크
        for(char c : s.toCharArray()) {
            if(c < '0' || c > '9') return false;
        }
        
        return true;
    }
}

[프로그래머스, 70128] 내적 (java)

행B — Tue, 20 May 2025 13:38:47 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 75.1 MB, 시간: 0.04 ms

사용 알고리즘: 구현

class Solution {
    public int solution(int[] a, int[] b) {
        int answer = 0;
        
        for(int i = 0; i < a.length; i++)
            answer += a[i] * b[i];
        
        return answer;
    }
}

[프로그래머스, 12903] 가운데 글자 가져오기 (java)

행B — Mon, 19 May 2025 17:35:12 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 82.7 MB, 시간: 0.03 ms

사용 알고리즘: 문자열

class Solution {
    public String solution(String s) {
        
        int len = s.length();

        return len % 2 == 0
            ? s.substring(len / 2 - 1, len / 2 + 1)
            : s.substring(len / 2, len / 2 + 1);
    }
}

[프로그래머스, 12948] 핸드폰 번호 가리기 (java)

행B — Fri, 16 May 2025 22:35:03 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 82.2 MB, 시간: 2.45 ms

사용 알고리즘: 구현

class Solution {
    public String solution(String phone_number) {
        
        int length = phone_number.length();
        
        String answer = "*".repeat(length - 4)
            + phone_number.substring(length - 4, length);
        
        return answer;
    }
}

[프로그래머스, 12901] 2016년 (java)

행B — Wed, 14 May 2025 18:49:10 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 85.4 MB, 시간: 0.03 ms

사용 알고리즘: 구현

class Solution {
    public String solution(int a, int b) {
        
        // 각 월의 일수
        int[] count = new int[] {0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
        
        // 요일(1월 1일이 금요일이므로 금요일부터 저장)
        String[] day = new String[] {"FRI", "SAT", "SUN", "MON", "TUE", "WED", "THU"};
        
        // 월 -> 일로 변경
        int days = 0;
        for(int i = 1; i < a; i++)
            days += count[i];
        days += b;
        
        return day[(days - 1) % 7];
    }
}

[프로그래머스, 42883] 큰 수 만들기 (java)

행B — Wed, 14 May 2025 18:23:27 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 93.1 MB, 시간: 4951.01 ms

사용 알고리즘: 탐욕법

class Solution {
    public String solution(String number, int k) {
        
        StringBuilder answer = new StringBuilder();
        
        // 현재 지울 수 있는 개수
        int count = k;
        
        int now = 0, next;
        while(now < number.length()) {
            // 현재 위치에서 가장 가까운 자신보다 큰 수 찾기
            next = now + 1;
            while(next < number.length() && number.charAt(now) >= number.charAt(next))
                next++;
            
            // 자신보다 큰 수까지 모두 지울 수 있으면 지우기
            if(count >= next - now) {
                count -= next - now;
                now = next;
            }
            else {
                answer.append(number.charAt(now));
                now++;
            }
        }
        
        return answer.toString();
    }
}

[프로그래머스, 42860] 조이스틱 (java)

행B — Wed, 14 May 2025 00:54:02 +0900

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

프로그래머스

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

programmers.co.kr

메모리: 78.3 MB, 시간: 0.06 ms

사용 알고리즘: 탐욕법

class Solution {
    public int solution(String name) {
        
        int answer = 0;
        int dist = name.length() - 1; // dist의 최대길이는 오른쪽 커서만으로 모든 문자를 이동하는 것
        
        int next;
        for(int i = 0; i < name.length(); i++) {
            
            // i번째 글자의 알파벳 조작
            answer += Math.min(name.charAt(i) - 'A', 'Z' - name.charAt(i) + 1);
            
            // 다음으로 등장하는 'A'가 아닌 위치 찾기
            next = i + 1;
            while(next < name.length() && name.charAt(next) == 'A')
                next++;

            // 현재 위치에서 다음 위치로 가는 최단 거리
            dist = Math.min(dist, (i * 2) + name.length() - next); // 현재 위치에서 next로 왼쪽 커서로 이동하는 경우
            dist = Math.min(dist, (name.length() - next) * 2 + i); // next에서 현재 위치로 오른쪽 커서로 이동하는 경우
        }
        
        // 최소 경로의 길이 더하기
        answer += dist;
        
        return answer;
    }
}