반복해야 쌓인다

백준 15654 : N과 M (5)

hyunlulu — Wed, 8 Oct 2025 01:27:56 +0900

백준 15654 : N과 M (5)

알고리즘 : 백트래킹

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

문제

N개의 자연수와 자연수 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램을 작성해라.

N개의 자연수는 모두 다른 자연수이고, 수열은 사전 순으로 증가하는 순서로 출력

코드

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {

    static int n, m;
    static int[] arr;
    static ArrayList<int[]> result;
    static int[] temp;
    static boolean[] visited;
    
    public static void main(String[] args) throws IOException{
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        
        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());

        arr = new int[n+1];

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

        for(int i=1; i<=n; i++){
            arr[i] = Integer.parseInt(st.nextToken());
        }

        Arrays.sort(arr, 1, n+1);

        result = new ArrayList<>();
        temp = new int[m];
        visited = new boolean[n+1];

        dfs(0,1);


        // 출력
        for(int i=0; i<result.size(); i++){
            for(int j=0; j<m; j++){
                if(j == m-1){
                    System.out.print(result.get(i)[j]);
                }else{
                    System.out.print(result.get(i)[j] + " ");
                }
            }
            System.out.println();
        }
    }

    static void dfs(int depth, int start){
        if(depth == m){
            result.add(Arrays.copyOf(temp, m));
            return;
        }

        for(int i=1; i<=n; i++){
            if(visited[i] == true){
                continue;
            }
            visited[i] = true;
            temp[depth] = arr[i];
            dfs(depth+1, i);
            visited[i] = false;
        }
        
    }
}

백준 15652 : N과 M (4)

hyunlulu — Tue, 7 Oct 2025 01:47:16 +0900

백준 15652 : N과 M (4)

알고리즘 : 백트래킹

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

문제

자연수 N과 M이 주어졌을 때, 아래 조건을 만족하는 길이가 M인 수열을 모두 구하는 프로그램 작성해라.

조건은 비내림차순이므로 An>An+1인 경우는 제외함

만약에 비내림차순이라는 조건 없이 모든 경우를 다 구한다면 완전탐색(브루트포스) 문제지만, 이건 조건이 존재하므로 백트래킹이라고 볼 수 있다.

코드

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {

    static int n, m;
    static List<int[]> result;
    static int[] temp;
    
    public static void main(String[] args) throws IOException {

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

        n = Integer.parseInt(st.nextToken());
        m = Integer.parseInt(st.nextToken());


        // 정답 배열 선언
        result = new ArrayList<>();
        temp = new int[m];

        // 로직
        dfs(0,1);


        // 출력
        for(int i=0; i<result.size(); i++){
            
            for(int j=0; j<m; j++){
                if(j==m-1){
                    System.out.println(result.get(i)[j]);
                }else{
                    System.out.print(result.get(i)[j] + " ");
                }
            }
            
        }

    }

    static void dfs(int depth, int start){
        if(depth == m){
            result.add(Arrays.copyOf(temp, m));
            return;
        }

        for(int i=start; i<=n; i++){
            temp[depth] = i;
            dfs(depth+1,i);
        }
    }
}

[MySQL] 프로그래머스 273712 - 업그레이드 할 수 없는 아이템 구하기

hyunlulu — Sat, 30 Aug 2025 00:03:22 +0900

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

프로그래머스

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

programmers.co.kr

코드 자체는 크게 복잡하지 않지만 처음에 문제 이해가 한번에 되지 않았던 점, 풀이 방식을 기억하고자 글을 남긴다.

프로그래머스 273712 - 업그레이드 할 수 없는 아이템 구하기

문제

더 이상 업그레이드할 수 없는 아이템의 아이템 ID(ITEM_ID), 아이템 명(ITEM_NAME), 아이템의 희귀도(RARITY)를 출력하는 SQL 문을 작성해라. 결과는 아이템 ID를 기준으로 내림차순 정렬 필요

풀이

문제를 해석해보면

'ITEM_A'->'ITEM_B'와 같이 업그레이드가 가능할 때 'ITEM_A'를 'ITEM_B'의 PARENT 아이템이라 한다.

즉 더이상 업그레이드 할 수 없는 => ROOT 아이템을 구하여라 라는 의미이다.

PARENT_ITEM_ID가 ITEM_ID로 업그레이드 되는 것이라는 순서를 헷갈리면 안된다.

두 개의 테이블 ITME_INFO와 ITEM_TREE가 주어지는데 두개를 join할 필요는 없다. where절에서 서브 쿼리로 처리하면 된다.

코드

SELECT ITEM_ID, ITEM_NAME, RARITY
FROM ITEM_INFO
WHERE ITEM_ID NOT IN (
    SELECT PARENT_ITEM_ID
    FROM ITEM_TREE
    WHERE PARENT_ITEM_ID IS NOT NULL
)
ORDER BY ITEM_ID DESC;

WHERE 절은 NOT IN 으로 처리하기

[코테 챌린지 6일차] TIL 프로그래머스 JadenCase 문자열 만들기

hyunlulu — Mon, 11 Aug 2025 09:49:39 +0900

프로그래머스 12951 : JadenCase 문자열 만들기

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

프로그래머스

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

programmers.co.kr

문제

문자열의 각 단어를 "JadenCase" 형태로 바꾸는 문자열 처리 문제

시간 복잡도: O(N)

풀이

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

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String s = br.readLine(); // 문자열 입력받기
        System.out.println(new Solution().solution(s));
    }

    public String solution(String s) {
        // 결과를 저장할 StringBuilder
        StringBuilder result = new StringBuilder();
        
        // 문자열의 각 문자에 대해 처리
        boolean isNewWord = true;
        for (char ch : s.toCharArray()) {
            if (Character.isWhitespace(ch)) {
                // 공백이면 결과에 추가
                result.append(ch);
                isNewWord = true; // 다음 문자가 단어의 시작일 수 있음을 나타냄
            } else {
                if (isNewWord) {
                    // 새 단어의 첫 문자일 때
                    result.append(Character.toUpperCase(ch));
                    isNewWord = false;
                } else {
                    // 단어의 나머지 문자일 때
                    result.append(Character.toLowerCase(ch));
                }
            }
        }
        
        return result.toString();
    }
}

[코테 챌린지 4일차] TIL 백준 18126 : 너구리 구구

hyunlulu — Thu, 7 Aug 2025 23:28:35 +0900

백준 18126 : 너구리 구구

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

문제

입구를 포함한 모든 방은 1부터 N까지의 번호가 있고, 입구는 1번이다.
구구의 집으로 들어가는 입구는 한 개이며 입구과 모든 방들은 총 N-1개의 길로 서로 오고 갈 수 있다.
구구는 무더운 여름 햇살을 피해 최대한 입구에서 먼 방에 아이스크림을 숨기려고 한다.

구구가 집 입구에서 멜론아 아이스크림을 숨기려고 하는 방까지 이동하는 거리를 구하여라.

*입력조건*
첫째 줄에 정수 N(1 ≤ N ≤ 5,000)이 주어진다.
다음 N-1개의 줄에 구구의 집의 모든 길의 정보가 정수 A, B, C(1 ≤ A, B ≤ N, 1 ≤ C ≤ 1,000,000,000)로 주어진다.
A번 방과 B번 방 사이를 양방향으로 연결하는 길의 길이가 C임을 의미한다.

접근 방법

방이 연결되어있다는 건 결국 그래프 형태로 볼 수 있다. 그리고 최대한 먼 방에 숨긴다고 했으니 DFS가 효과적일 것이라고 생각을 했다. 나는 visited 배열을 선언하고 2차원 배열을 탐색하는 방식을 선택했다. 이런 방식이 직관적이기도 하고 편해서 많이 선택하는 편이다.

위와 같은 방식으로 채점해보면 480ms 정도 나온다.

+) 다른 풀이

문제 풀 때는 이 방식을 선택했지만, 애초에 완전한 map 형태로 주어진 것이 아니기 때문에 노드형식이면 인접리스트로 판단하는 편이 더 풀이가 간단할 수 있다. 실제로 이렇게 푼 분들 코드를 보니 시간이 200ms 이하로 나온다.

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {

    static int[][] arr;
    static int n;
    static boolean[] visited;
    static long distance = 0;
    
    public static void main(String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

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

        arr = new int[n-1][3];
        visited = new boolean[n+1]; // 인덱스와 방 숫자 일치시키기 위해 n+1

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

        dfs(1, 0);

        System.out.println(distance);
    }

    public static void dfs(int node, long sum){
        visited[node] = true;
        distance = Math.max(distance, sum);

        for(int i=0; i< n-1; i++){
            if(arr[i][0] == node && !visited[arr[i][1]]){
                dfs(arr[i][1], sum + arr[i][2]);
            }else if(arr[i][1] == node && !visited[arr[i][0]]){
                dfs(arr[i][0], sum + arr[i][2]);
            }
           
        }
    }
}

[코테 챌린지 3일차] TIL 백준 2437 : 저울

hyunlulu — Wed, 6 Aug 2025 11:09:28 +0900

3일차 2025.08.06 (수)

백준 2437 : 저울 (골드 2)

문제 : 여러개의 추를 입력받아, 추들로 측정할 수 없는 양의 정수 무게 중 최솟값을 구해라

딱 보고 그리디?라는 생각이 들긴했는데 처음에 접근한 방식은 추의 합으로 만들 수 있는 최대 값(maxSum)을 구해고, for문 돌면서 1부터 maxSum까지 탐색하면서 합을 만들 수 있는지 판단하는 방식이었다. 이렇게 되면 최악의 경우 10억 번 연산이 되어버린다.

그렇다면 판단하는 로직을 백트래킹으로 바꾸면 가능한가? 이것도 시간 초과다.

그냥 그리디 알고리즘에 집중해서 푸는게 맞다. 그리고 풀이도 엄청 간단해진다.

시간 복잡도 : O(N log N)

만들 수 없는 첫 번째 무게는 그 시점의 누적합보다 큰 추를 만났을 때 결정

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {

    static int N;
    static long result;
    static int maxSum;
    static int[] arr; // 추들의 무게를 저장 할 배열
    static boolean makeSum;
    
    public static void main(String[] args) throws IOException {

        // 배열로 추들을 입력받기
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());

        arr = new int[N];

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

        Arrays.sort(arr); // 오름차순 정렬

        result = 1; // 만들 수 없는 최소값

        for (int i = 0; i < N; i++) {
            if (arr[i] > result) {
                break;
            }
            result += arr[i];
        }

        // 출력
        System.out.println(result);
    }    
}

[코테 챌린지 2일차] TIL 백준 2468 : 안전 영역

hyunlulu — Tue, 5 Aug 2025 14:43:18 +0900

2일차 2025.08.05(화)

백준 2468 : 안전 영역

dfs로 덩어리를 조사하면 된다. 풀다가 좀 헷갈려서 dfs 구현을 해당 풀이처럼 직관적으로 보이게 작성했다.

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {

    static int[][] map;
    static boolean[][] visited;
    static int N;
    static int max; // 결과값
    static int count;
    
    public static void main(String[] args) throws IOException {
        // 비가 올 수 있는 양은 1부터 9. 각 경우의 안전지대 개수를 탐색하면서 최대값이 나오면 갱신
        // N은 2 이상 100 이하의 정수

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

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

        map = new int[N][N];
        int maxHeight = 0;

        for(int i=0; i<N; i++){
            StringTokenizer st = new StringTokenizer(br.readLine());
            for(int j=0; j<N; j++){
                map[i][j] = Integer.parseInt(st.nextToken());
                maxHeight = Math.max(maxHeight, map[i][j]);
            }
        }

        max = 1;

        for(int h=1; h<=maxHeight; h++){ // 비가 오는 정도
            visited = new boolean[N][N]; // 이 안에서 항상 초기화
            count = 0;

            for (int i = 0; i < N; i++) {
                for (int j = 0; j < N; j++) {
                    if (!visited[i][j] && map[i][j] > h) {
                        dfs(i, j, h);
                        count++;
                    }
                }
            }

            max = Math.max(max, count);
        }

        System.out.println(max);
        
    }

    public static void dfs(int x, int y, int h){ // 덩어리를 조사하면서 count++
         visited[x][y] = true;

        if (x-1 >= 0 && !visited[x-1][y] && map[x-1][y] > h) {
            dfs(x - 1, y, h);
        }

        if (x+1 < N && !visited[x+1][y] && map[x+1][y] > h) {
            dfs(x+1, y, h);
        }

        if (y-1 >= 0 && !visited[x][y-1] && map[x][y-1] > h) {
            dfs(x, y-1, h);
        }

        if (y+1 < N && !visited[x][y+1] && map[x][y+1] > h) {
            dfs(x, y+1, h);
        }
    }
}

[코테 챌린지 1일차] TIL 백준 1929 : 소수 구하기

hyunlulu — Mon, 4 Aug 2025 23:50:39 +0900

챌린지 기간 : 2025.08.04(월) ~ 2025.08.15(금)

작심큰일 챌린지는 스파르타 코딩클럽에서 하는 하루에 하나씩 코테를 푸는 챌린지이다. 2주라는 기간은 짧지만 부담 없이 참여할 수 있을 것 같아 풀이도 남겨둘 겸 신청하게 되었다.

비기너, 미들러, 챌린저 중에 미들러를 선택했다. 목표는 꾸준히 풀고, 내 풀이에 대한 개념을 잘 정리하기다!

1일차 2025.08.04(월)

백준 1929 : 소수 구하기 (실버3)

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

M과 N을 입력받고 M이상 N이하의 소수를 모두 출력하는 문제다. 소수 찾기 문제는 간단하지만서도 꼭 기억해둬야 할만한 부분인 것 같다.

핵심은 소수 탐색 범위이다.

입력값 범위 : (1 ≤ M ≤ N ≤ 1,000,000)

시간 제한 : 2초

100만인 경우에 1부터 100만 까지 탐색하는 건 굉장히 비효율적이다. 100만 * 100만인 경우, 시간초과 가능성도 존재한다. 그러므로 소수를 탐색하되, 1부터 제곱근까지의 값을 탐색하는 것이다. Math.sqrt() 를 써서 제곱근까지 탐색하면 소수 여부를 확인할 수 있다.

import java.util.*;
import java.lang.*;
import java.io.*;

// M이상 N이하의 소수를 모두 출력
class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());

        int M = Integer.parseInt(st.nextToken());
        int N = Integer.parseInt(st.nextToken());

        ArrayList<Integer> list = new ArrayList<>();

        for(int i=M; i<=N; i++){
            if(i<2)
                continue;
            boolean isPrime = true;

            for(int j=2; j<=Math.sqrt(i); j++){
                if(i % j == 0){
                    isPrime = false;
                    break;
                }
            }

            if(isPrime){
                list.add(i);
            }
        }

        for(int i=0; i<list.size(); i++){
            System.out.println(list.get(i));
        }

    }
}

그리고 List를 활용해서 추가와 출력을 해주면 된다~

[백준/JAVA] 12865_평범한 배낭

hyunlulu — Mon, 28 Jul 2025 15:43:35 +0900

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

배낭 문제라고 알려져 있는 매우 유명한 문제다.

*유튜브에서 발견한 상세한 풀이

https://www.youtube.com/watch?v=V2vJp0GY-Fg

문제와 접근

물품의 수 N(1 ≤ N ≤ 100)와 버틸 수 있는 무게 K(1 ≤ K ≤ 100,000)가 주어지고,
N개의 줄에 거쳐 각 물건의 무게 W(1 ≤ W ≤ 100,000)와 해당 물건의 가치 V(0 ≤ V ≤ 1,000)가 주어진다.

배낭에 넣을 수 있는 물건들의 가치합의 최댓값을 출력해라

조합을 구하는 문제라고 생각했기에 완전탐색, 그리디, DP를 고려해봤다.

1. 완전탐색 - 불가능

우선 물품 N개의 수가 100개라 하더라도 1개 구하는 경우, 2개 구하는 경우 ~ 100개 구하는 경우까지 늘어난다면 엄청난 수가 될 것이고 시간 초과 문제가 발생할 것이다.

2. 그리디 - 불가능

그리디로 접근하면 여러가지 조합의 경우를 고려할 수가 없다. 무게 합이 7인 경우 1,6 / 2,5 이런 경우들을 다 구해서 비교할 수가 없다.

3. DP(다이나믹 프로그래밍) - 가능

이차원 dp 배열을 선언해서 가능한 경우를 비교해간다.

배낭에 담을 수 있는 최대 무게를 넘지 않으면서, 총 가치의 합이 최대가 되도록 선택해야 한다.

➡️ 최적해(최대 가치)를 구하는 문제

dp 배열 - 행은 i(무게와 가치 배열의 인덱스), 열은 만들어야 할 무게

	0	1	2	3	4	5	6	7
0
1 무게 6 가치 13		0	0	0	0	0	13	13
2 무게 4 가치 8		0	0	0	8	8	13	13
3 무게 3 가치 6		0	0	6	8	8	13	14
4 무게 5 가치 12		0	0	6	8	12	13	14

점화식

dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-w[i]]+v[i])

코드

import java.util.*;
import java.lang.*;
import java.io.*;

class Main {
    public static void main(String[] args) throws IOException {

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

        int n = Integer.parseInt(st.nextToken());
        int k = Integer.parseInt(st.nextToken());

        int[] w = new int[n+1];
        int[] v = new int[n+1];

        for(int i=0; i<n; i++){
            st = new StringTokenizer(br.readLine());
            w[i+1] = Integer.parseInt(st.nextToken());
            v[i+1] = Integer.parseInt(st.nextToken());
        }

        int[][] dp = new int[n+1][k+1];

        for(int i=1; i<n+1; i++){
            for(int j=1; j<k+1; j++){
                if(w[i] <= j){
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-w[i]]+v[i]);
                }else{
                    dp[i][j] = dp[i-1][j];
                }
                
            }
        }

        System.out.println(dp[n][k]);

        
    }
}

[K8S] CKA 주요 개념 / 헷갈리는 개념 정리

hyunlulu — Sat, 14 Jun 2025 13:09:54 +0900

Deployment와 Pod의 관계

Pod

쿠버네티스에서 가장 작은 배포 단위

자체적으로 복구 불가

커맨드 : kubectl run <Pod이름> --image=<이미지>

Deployment

Pod를 생성하고 관리하는 상위 추상 개념 (일반적으로 많이 사용하는 개념!)

Pod의 수명 주기를 관리해주는 운영 자동화 도구라고 볼 수 있다.

원하는 개수(Replica)의 Pod를 유지해주며, 장애 복구, 롤링 업데이트, 버전 관리 등의 기능을 제공

커맨드 : kubectl create deployment <이름> --image=<이미지>

kubectl을 통해서 Deployment를 만들면 내부적으로 이렇다.

Deployment
ㄴ-- ReplicaSet
ㄴ-- Pod(s)

Deployment는 목표 상태(desired state) 를 정의

ReplicaSet은 Pod의 수를 보장하고 Pod를 실제로 생성하는 역할

➡️ 결국 kubectl get pod는 Deployment로 생성한 Pod를 보여주는 것

관련 커맨드

kubectl get deploy   # Deploy 목록
kubectl get rs  # ReplicaSet 목록
kubectl get pod   # Pod 목록

Deployment 생성하기

--dry-o=client는 실제 deployment가 적용되지 않는다.

kubectl apply -f <yaml 파일 이름> 을 실행하면 Deployment가 만든 Pod들이 보여진다.

Replica의 크기를 변경하고 싶다면

kubectl scale deployment <deploy 이름> --replicas=<개수>

Create Deployment

Create a new deployment called myproject, with iamge nginx:1.16 and 1 replica. Next upgrade the deployment to version 1.17 using rolling update.
Make sure that the version upgrade is rcorded in the resource annotation.

kubectl create deployment myproject --image=nginx:1.16 --replicas=1
kubectl describe deployment myproject

버전 Upgrade를 위해 kubectl Cheat Sheet에서 set image 찾기

# version upgrade is rcorded in the resource annotation 조건 존재, --record도 포함 필요
kubectl set image deployment/myproject nginx=nginx:1.17 --record

# history 확인
Kubectl rollout history deployment myproject

Deploy a web-nginx pod using the nginx:1.17 image with the labels set to tier=web-app.

kubectl run web-nginx --image=nginx:1.17 --labels tier=web-app

kubectl get pods --show-labels

Static Pod

Static pod는 특정 node또는 특정 kubelet에 바인딩된 pod

Static Pod는 쿠버네티스(Kubernetes)에서 kubelet이 직접 관리하는 Pod를 말합니다. 일반적인 Pod는 API 서버를 통해 생성되지만, Static Pod는 API 서버 없이도 kubelet이 직접 실행하고 관리

Deployment나 ReplicaSet과 무관함. 컨트롤러가 없다.

Static Pod는 Control Plane이 아니라 Node의 kubelet이 직접 관리하기 때문에, kubectl apply를 하지 않아도 해당 노드에 정의된 YAML 파일만 있으면 자동으로 실행됩니다.

Static Pod 문제

Create a static pod on node01 called static-pod with image image nginx and you have to make sure that it is recreated/restarted automatically of any failure happens.

ssh node01
vi /etc/kubernetes/manifests/static-pod.yaml

apiVersion: v1
kind: Pod
metadata:
  name: static-pod
  labels:
    app: nginx
spec:
  restartPolicy: Always
  containers:
  - name: nginx
    image: nginx
# kubelet이 이 파일을 감지하고 해당 Pod 실행, 별도의 apply 커맨드 필요가 없음

# 다시 controlplane으로 돌아와서
kubectl get pods -o wide

Kustomize

# 디렉토리 구조 확인
ls -R /root/kustomize

# 예시

my-kustomize/
├── base/
│   ├── deployment.yaml
│   ├── service.yaml
│   └── kustomization.yaml
└── overlays/
    └── prod/
        ├── kustomization.yaml
        └── deployment-patch.yaml

# base 폴더 안의 파일들은 이미 존재한다.

vi /root/kustomize/overlays/dev/deployment-patch.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app    # base에 있는 Deployment 이름과 일치해야 함
spec:
  replicas: 5

vi /root/kustomize/overlays/dev/kustomization.yaml

resources:
  - ../../base

patchesStrategicMerge:
  - deployment-patch.yaml


# 적용
kubectl apply -k overlays/prod

# 제출용
kubectl kustomize overlays/prod > /root.final.yaml