stquokka

VS Code 원격 개발 환경 구성: SSH 키로 원격 서버 접속하기

quokkaST — Mon, 1 Sep 2025 14:25:34 +0900

이번에는 VS Code의 Remote - SSH 확장 기능을 사용하여,
비밀번호 대신 SSH 키를 통해 원격 컴퓨터에 안전하고 편리하게 접속하는 방법을 단계별로 정리하였다.

1. 왜 비밀번호 대신 SSH 키를 사용해야 할까?

단순 비밀번호 입력 방식은 간단하지만 보안에 취약하다.
SSH 키 인증은 비대칭 키 암호화를 기반으로 하여 보안성과 편의성을 동시에 제공한다.

항목	비밀번호 인증	SSH 키 인증
보안 수준	낮음 (유출, 무차별 대입 공격에 취약)	높음 (개인 키 없이는 접속 불가)
편의성	매번 입력 필요	최초 1회 등록 후 비밀번호 없이 접속
활용성	수동 접속에 적합	자동화, 반복 작업에 유리

2. SSH 키 생성 (로컬 PC)

터미널(Windows는 PowerShell 또는 Git Bash)에서 다음을 실행한다:

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

-t rsa : RSA 알고리즘 사용
-b 4096 : 4096비트 키 생성 → 보안 강화
-C : 키 설명(식별용, 보통 이메일)

생성이 완료되면 ~/.ssh/ 폴더에

id_rsa (개인 키, 절대 외부 유출 금지)
id_rsa.pub (공개 키)
파일이 생성된다.

3. 공개 키를 원격 서버에 등록

ssh-copy-id 명령어를 사용하면 편리하다:

ssh-copy-id [사용자명]@[원격서버_IP]

마지막으로 비밀번호를 1회 입력
공개 키가 원격 서버 ~/.ssh/authorized_keys에 자동 추가됨

만약 ssh-copy-id를 사용할 수 없다면:

로컬에서 cat ~/.ssh/id_rsa.pub 실행 → 공개 키 내용 복사
원격 서버 ~/.ssh/authorized_keys 파일에 수동으로 붙여넣기

4. VS Code에서 원격 접속

VS Code 실행 후 좌측 메뉴에서 Remote Explorer 클릭
상단 메뉴에서 SSH 선택
ssh [사용자명]@[원격서버_IP] 입력 → Enter
SSH 설정 파일(config) 저장 (기본값 추천)
SSH Targets 목록에 서버가 나타나면 연결 아이콘 클릭

새 창이 열리면서 원격 서버와 연결됨.
→ 원격 파일 편집, 터미널 사용 가능.

학습 정리

SSH 키 기반 접속은 단순한 설정 이상의 가치가 있다.

보안성 강화 : 비밀번호 노출 위험 감소
작업 효율성 향상 : 반복 로그인 불필요, 자동화 작업 가능
개발 생산성 증대 : VS Code 원격 기능을 통해 로컬 제약 없이 개발 환경을 확장

OAuth2 기반 Google & Kakao 로그인 구축 방법

quokkaST — Mon, 30 Jun 2025 23:47:09 +0900

✅ 사전 준비

공통

Spring Boot (spring-boot-starter-oauth2-client)
Redirect URI: https://yourdomain.com/login/oauth2/code/{provider}

1. Google OAuth2 로그인 구축

Google Cloud 설정

Google Cloud Console 접속
OAuth 동의 화면 구성 (앱 이름, 사용자 이메일 등)
OAuth 2.0 클라이언트 ID 생성
- 애플리케이션 유형: 웹 애플리케이션
- 승인된 리디렉션 URI:
  https://yourdomain.com/login/oauth2/code/google
클라이언트 ID, 클라이언트 시크릿 발급

⚙️ application.yml 설정

spring:
  security:
    oauth2:
      client:
        registration:
          google:
            client-id: YOUR_GOOGLE_CLIENT_ID
            client-secret: YOUR_GOOGLE_CLIENT_SECRET
            scope: profile, email
        provider:
          google:
            authorization-uri: https://accounts.google.com/o/oauth2/v2/auth
            token-uri: https://oauth2.googleapis.com/token
            user-info-uri: https://www.googleapis.com/oauth2/v3/userinfo
            user-name-attribute: sub

2. Kakao OAuth2 로그인 구축

Kakao 개발자 설정

Kakao Developers 접속
애플리케이션 생성
플랫폼 > 웹 사이트 도메인 등록: https://yourdomain.com
Redirect URI 등록:
https://yourdomain.com/login/oauth2/code/kakao
REST API 키 획득

⚙️ application.yml 설정

spring:
  security:
    oauth2:
      client:
        registration:
          kakao:
            client-id: YOUR_KAKAO_REST_API_KEY
            redirect-uri: "{baseUrl}/login/oauth2/code/{registrationId}"
            client-authentication-method: POST
            authorization-grant-type: authorization_code
            scope:
              - profile_nickname
              - account_email
            client-name: Kakao
        provider:
          kakao:
            authorization-uri: https://kauth.kakao.com/oauth/authorize
            token-uri: https://kauth.kakao.com/oauth/token
            user-info-uri: https://kapi.kakao.com/v2/user/me
            user-name-attribute: id

커스터마이징

✅ 사용자 정보 매핑 (OAuth2UserService)

@Service
public class CustomOAuth2UserService extends DefaultOAuth2UserService {

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);
        String registrationId = userRequest.getClientRegistration().getRegistrationId();

        Map<String, Object> attributes = oAuth2User.getAttributes();
        if (registrationId.equals("kakao")) {
            attributes = (Map<String, Object>) attributes.get("kakao_account");
        }

        return new DefaultOAuth2User(
            Collections.singleton(new SimpleGrantedAuthority("ROLE_USER")),
            attributes,
            "email"
        );
    }
}

✅ Security 설정

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeHttpRequests()
                .requestMatchers("/", "/login/**", "/oauth2/**").permitAll()
                .anyRequest().authenticated()
            .and()
                .oauth2Login()
                .userInfoEndpoint()
                    .userService(customOAuth2UserService);
        return http.build();
    }

    @Autowired
    private CustomOAuth2UserService customOAuth2UserService;
}

실무 팁

Redirect URI는 반드시 https 기반이어야 함
HttpOnly + Secure 쿠키 사용 고려
JWT 발급 연동 시 OAuth 로그인 후 accessToken 생성하도록 구현 가능
회원가입 연동 시 이메일 중복 처리 / 닉네임 생성 로직 필요

백준 2615: 소형기관차(Java)

quokkaST — Sun, 29 Jun 2025 21:23:56 +0900

백준 2616번: 소형기관차

문제 요약

N개의 객차(1 ≤ N ≤ 50,000)가 수직선 상에 있다.
각 객차에는 손님이 타고 있다 (최대 100명).
소형 기관차는 최대 K칸까지 끌 수 있으며, 총 3대가 존재한다.
3개의 소형 기관차가 서로 겹치지 않게 총합 손님 수가 최대가 되도록 운행할 때의 최대 손님 수를 구하라.

문제 접근

✅ 핵심 개념

3개의 기관차가 끌 수 있는 객차를 비중복으로 선택 → 구간 합 최적화
누적합 + DP 사용
dp[i][j]: i번째 기관차까지 사용해서, j번째 객차까지 탐색했을 때 최댓값

알고리즘 설계

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());

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

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

        int[] total = new int[N + 1];
        for (int i = 1; i <= N; i++) {
            total[i] = total[i - 1] + people[i];
        }

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

        for (int i = 1; i <= 3; i++) {
            for (int j = K * i; j <= N; j++) {
                int curtotal = total[j] - total[j - K];
                dp[i][j] = Math.max(dp[i][j - 1], dp[i - 1][j - K] + curtotal);
            }
        }

        System.out.println(dp[3][N]);
    }
}

✅ 시간 복잡도

누적합 계산: O(N)
DP 테이블 채우기: O(N)
전체 시간복잡도: O(N) → N ≤ 50,000 이므로 충분히 통과 가능

정리

핵심은 비중복 구간 합 최적화 문제를 DP + 누적합으로 해결하는 것
상태 전이: dp[i][j] = max(dp[i][j - 1], dp[i - 1][j - K] + sum(j-K+1 ~ j))
알고리즘 구현 난이도는 낮지만, 상태 정의를 이해하는 것이 중요하다

백준 2306: 유전자(Java)

quokkaST — Thu, 12 Jun 2025 23:29:36 +0900

목표

주어진 DNA 문자열에서 KOI 유전자 조건을 만족하는 최장 유효 부분 문자열의 길이를 구한다.
KOI 유전자 정의:
- at, gc는 KOI 유전자.
- KOI 유전자 X → aXt, gXc도 KOI 유전자.
- X, Y가 KOI 유전자 → XY도 KOI 유전자.

✅ 핵심 아이디어

DP[i][j]: i~j까지 KOI 유전자 중 최장 길이
두 가지 전이 방식:
1. 경계 조건: (i,j) 가 a,t or g,c로 감싸진다면 → 내부 + 2
2. 분할 결합: dp[i][j] = max(dp[i][k] + dp[k+1][j])

알고리즘 설계

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

public class Main {
    static int[][] dp;
    static char[] dna;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        dna = br.readLine().toCharArray();
        int n = dna.length;

        dp = new int[n][n];

        for (int len = 2; len <= n; len++) {
            for (int i = 0; i + len - 1 < n; i++) {
                int j = i + len - 1;

                if (isPair(dna[i], dna[j])) {
                    dp[i][j] = Math.max(dp[i][j], 2 + (i + 1 <= j - 1 ? dp[i + 1][j - 1] : 0));
                }

                for (int k = i; k < j; k++) {
                    dp[i][j] = Math.max(dp[i][j], dp[i][k] + dp[k + 1][j]);
                }
            }
        }

        System.out.println(dp[0][n - 1]);
    }

    static boolean isPair(char a, char b) {
        return (a == 'a' && b == 't') || (a == 'g' && b == 'c');
    }
}

⏱ 시간복잡도

O(N³): i, j, k 세중 루프
N ≤ 500이므로 Java에서도 통과 가능

정리

이 문제는 전형적인 문자열 DP 문제이며, 분할 정복적 사고와 경계 조건 처리가 핵심
dp[i][j] = max(경계 포함, 분할) 형태를 잘 이해하자

백준 1557: 도로의 개수(Java)

quokkaST — Wed, 11 Jun 2025 22:05:46 +0900

✅ 문제 요약

N×M 격자 도시에 도로가 건설됨.
도로는 격자의 가로선 또는 세로선에 해당.
일부 도로는 공사 중이므로 통행 불가.
(0,0)에서 (N,M)까지 이동하는 경로의 수를 구하라.
오른쪽 또는 아래쪽 방향으로만 이동 가능.

알고리즘 설계

DP[i][j] = (0,0)부터 (i,j)까지 가는 경로 수
인접한 두 좌표 사이의 도로가 막혀있다면 그 방향으로 이동 불가.
공사 중 도로는 (i1, j1, i2, j2)로 주어짐 → Set으로 관리.

import java.util.*;

public class Main {
    static int N, M;
    static long[][] dp;
    static Set<String> block = new HashSet<>();

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        M = sc.nextInt();
        N = sc.nextInt();
        int K = sc.nextInt();
        dp = new long[N + 1][M + 1];

        for (int k = 0; k < K; k++) {
            int i1 = sc.nextInt();
            int j1 = sc.nextInt();
            int i2 = sc.nextInt();
            int j2 = sc.nextInt();
            block.add(i1 + " " + j1 + " " + i2 + " " + j2);
            block.add(i2 + " " + j2 + " " + i1 + " " + j1);
        }

        dp[0][0] = 1;
        for (int i = 0; i <= N; i++) {
            for (int j = 0; j <= M; j++) {
                if (i > 0 && !block.contains((i - 1) + " " + j + " " + i + " " + j)) {
                    dp[i][j] += dp[i - 1][j];
                }
                if (j > 0 && !block.contains(i + " " + (j - 1) + " " + i + " " + j)) {
                    dp[i][j] += dp[i][j - 1];
                }
            }
        }
        System.out.println(dp[N][M]);
    }
}

핵심 포인트

DP를 활용하여 각 좌표까지의 경로 수를 누적
공사 중 도로는 Set<String>으로 관리하여 양방향 차단
좌표 인덱스를 (i, j) 형식으로 명확하게 관리

⏱ 시간 복잡도 분석

시간 복잡도: O(N × M)
공간 복잡도: O(N × M)
N, M ≤ 100 이므로 충분히 처리 가능

GitHub 대용량 파일 관리를 위한 Lens 사용법

quokkaST — Mon, 9 Jun 2025 23:38:04 +0900

목표

대용량 파일로 인한 GitHub 제한 해결
- Git 저장소의 용량 및 속도 문제 해결
Lens CLI를 통한 대체 Git LFS 관리
- 대용량 파일을 별도 스토리지에 분리 관리

✅ 왜 대용량 파일 관리가 필요한가?

문제점	설명
Git 저장소 용량 한계	GitHub는 기본적으로 파일당 100MB, 전체 1GB 저장소 제한이 있음
커밋 내역 무거움	바이너리/미디어 파일을 자주 커밋하면 기록이 빠르게 커짐
클론/푸시 속도 저하	저장소 크기가 커지면 협업 속도 저하

이를 해결하기 위해 Git LFS 또는 대체 도구 Lens를 사용

Git LFS의 한계

GitHub에서 공식 지원하지만 무료 저장소는 용량/트래픽 제한이 있음
1GB 저장, 월 1GB 트래픽 → 초과 시 유료 플랜 필요
커스텀 파이프라인(CI/CD) 연동 어려움

Lens란?

Lens는 대용량 파일을 Git 히스토리에 포함시키지 않고도 GitHub에서 관리 가능한 클라우드 기반 대용량 버전 관리 시스템입니다.

핵심 특징

항목	설명
히스토리 분리	Git에는 메타데이터만 기록, 실제 파일은 별도 저장
GitHub Actions 통합	자동으로 대용량 파일을 관리
비용 효율적	자체 요금제 사용
확장성 우수	AI 모델, 이미지, 동영상 등 대규모 파일 관리에 적합

Lens 설치 및 설정

1️⃣ Lens CLI 설치

npm install -g @uselens/cli

또는

yarn global add @uselens/cli

2️⃣ 프로젝트 초기화

lens init

3️⃣ 추적할 파일 등록

lens track "*.mp4"
lens track "*.safetensors"

4️⃣ 커밋 및 푸시

git add .
git commit -m "Add large model files"
git push origin main

GitHub 연동 구조

[로컬 Git] → [GitHub 저장소] + [Lens 서버 연동] → [대용량 파일 Lens 클라우드 저장]

.lenskeep 파일에 대용량 추적 경로 정의
GitHub Actions로 Lens 전송 자동화

Lens vs Git LFS

항목	Git LFS	Lens
저장 방식	Git 히스토리에 LFS 포인터 기록	해시 기반 별도 클라우드 저장
GitHub 연동	공식 지원	GitHub App 필요
무료 플랜	제한적	사용량 기반 확장
파일 크기 제한	100MB 제한	상대적으로 자유
활용 분야	이미지, 사운드	AI 모델, 3D 파일, .safetensors 등

실무 적용 팁

팀원들도 lens install 필요
GitHub 저장소 설정에서 Lens 앱 등록 필수
lens push, lens pull 자동화 가능 (GitHub Actions)

백준 2248 - 이진수 찾기(Java)

quokkaST — Sat, 7 Jun 2025 22:38:39 +0900

문제 요약

길이가 N인 이진수 중에서 1의 개수가 L 이하인 이진수들을 사전 순으로 정렬했을 때, K번째 이진수를 구하는 문제.

문제 접근

이 문제는 모든 이진수를 직접 만들어서 K번째를 찾기에는 비효율적

핵심 아이디어는 조합을 이용해 가능한 경우의 수를 계산하며 자릿수를 결정

알고리즘 설계

✅ 조합 미리 계산

comb[n][k] = nCk (n개 중 k개를 고르는 경우의 수)

파스칼 삼각형을 활용하여 조합을 미리 계산합니다.

for (int i = 0; i <= 32; i++) {
    comb[i][0] = comb[i][i] = 1;
    for (int j = 1; j < i; j++) {
        comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
    }
}

✅ 자리수 별 분기

i번째 자리를 '0'으로 채울 경우 → 나머지 자리에서 1이 L개 이하인 경우의 수 = comb[i - 1][0] + ... + comb[i - 1][L]
만약 이 값보다 K가 작거나 같다면 현재 자리는 '0'
아니라면 현재 자리는 '1', K에서 해당 경우의 수만큼 빼고, L--

전체 코드

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

public class Main {
    static int N, L;
    static long K;
    static long[][] comb = new long[33][33];

    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()); // 이진수 길이
        L = Integer.parseInt(st.nextToken()); // 1의 개수 제한
        K = Long.parseLong(st.nextToken());   // K번째 이진수

        initComb(); // 조합 테이블 초기화

        StringBuilder result = new StringBuilder();
        int onesLeft = L;
        long order = K;

        for (int i = N; i > 0; i--) {
            long zeroCount = countValid(i - 1, onesLeft); // 앞자리를 0으로 시작할 수 있는 경우의 수

            if (order <= zeroCount) {
                result.append('0');
            } else {
                result.append('1');
                order -= zeroCount;
                onesLeft--;
            }
        }

        System.out.print(result);
    }

    // 조합 계산 (nCk)
    static void initComb() {
        for (int i = 0; i <= 32; i++) {
            comb[i][0] = 1;
            comb[i][i] = 1;
        }

        for (int i = 1; i <= 32; i++) {
            for (int j = 1; j < i; j++) {
                comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
                if (comb[i][j] > 1_000_000_000) comb[i][j] = 1_000_000_000; // overflow 방지
            }
        }
    }

    // i자리 이하에서 1이 max개 이하인 이진수 개수
    static long countValid(int digit, int maxOne) {
        long sum = 0;
        for (int i = 0; i <= maxOne; i++) {
            sum += comb[digit][i];
        }
        return sum;
    }
}

✅ 시간복잡도

단계	복잡도
조합 계산	O(N^2)
이진수 생성	O(N)

정리

단순하게 모든 경우를 만드는 것이 아니라, 조합으로 경우의 수를 세며 사전 순으로 결정해야 하는 문제
이진수 생성 문제에서 자주 쓰이는 대표 패턴

collect(Collectors.toList()) vs Stream.toList()

quokkaST — Sat, 7 Jun 2025 21:11:14 +0900

Java 16 이후, 자바에서는 Stream.toList()라는 새로운 메서드를 제공하여 기존의 collect(Collectors.toList()) 방식을 대체할 수 있게 되었습니다.

✅ 핵심 차이점 요약

항목	`collect(Collectors.toList())`	`Stream.toList()`
도입 버전	Java 8 이상	Java 16 이상
반환 타입	`ArrayList` or other mutable list	불변 리스트 (Immutable List)
외부 라이브러리 의존	필요 (`Collectors`)	불필요
변경 가능 여부	가능 (mutable)	불가능 (immutable)
스레드 안정성	불안정	불안정 (불변이지만 thread-safe 아님)

예시 코드 비교

1. Java 8 방식 - `Collectors.toList()`

import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;

List<String> list = Stream.of("a", "b", "c")
                          .collect(Collectors.toList());

list.add("d"); // 가능
System.out.println(list); // [a, b, c, d]

2. Java 16 방식 - `Stream.toList()`

import java.util.List;
import java.util.stream.Stream;

List<String> list = Stream.of("a", "b", "c")
                          .toList();

list.add("d"); // UnsupportedOperationException 발생

⚠️ 주의할 점

toList()로 생성된 리스트는 불변(immutable) 이므로 add, remove 등의 조작이 불가능합니다.
Collectors.toList()는 매번 새로운 ArrayList를 생성하며, 수정 가능한 리스트를 원할 때 사용합니다.
프로젝트에서 Java 16 이상을 사용한다면, 불변 리스트가 필요한 경우에만 toList()를 활용하세요.

정리

Java 8 이하: 무조건 collect(Collectors.toList()) 사용
Java 16 이상:
- 리스트 수정이 필요하면 Collectors.toList()
- 불변 리스트가 필요하면 toList() 추천
코드 가독성 면에서는 toList()가 간결하고 선언적입니다.

백준 10800번: 컬러볼 (Java)

quokkaST — Wed, 4 Jun 2025 23:50:01 +0900

문제 목표

각 공은 색과 크기를 가진다.
모든 공 쌍에 대해 서로 다른 색이면서 작은 공의 크기만큼 점수를 획득한다.
각 공이 얻을 수 있는 총 점수를 출력한다.

✅ 풀이 전략 요약

Ball 객체 정의
→ color, size, index를 저장하는 클래스 생성
정렬 기반 누적합 알고리즘
→ 공을 크기 기준으로 정렬하고, 같은 크기까지는 점수 계산을 미뤄둔다
→ 누적합을 활용해 총합과 색상별 합을 미리 관리한다
투 포인터
→ 현재 공보다 작은 공들을 전부 포함시키는 방식으로 점수 누적
색이 같은 경우 제외
→ 같은 색의 합은 제외하여 점수 계산

핵심 개념

변수	의미
`total`	지금까지 본 공 중 크기가 현재 공보다 작은 공들의 전체 크기 합
`colorSum[color]`	특정 색상 공의 누적 크기 합
`result[i]`	i번 공이 얻을 수 있는 점수 (조건 만족하는 다른 공들의 크기 합)

전체 코드

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

public class Main {
    static class Ball implements Comparable<Ball> {
        int color, size, index;
        Ball(int color, int size, int index) {
            this.color = color;
            this.size = size;
            this.index = index;
        }

        @Override
        public int compareTo(Ball o) {
            return this.size - o.size;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        Ball[] balls = new Ball[n];
        int maxColor = 0;

        for (int i = 0; i < n; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int c = Integer.parseInt(st.nextToken());
            int s = Integer.parseInt(st.nextToken());
            balls[i] = new Ball(c, s, i);
            maxColor = Math.max(maxColor, c);
        }

        Arrays.sort(balls);  // 크기 기준 정렬

        int[] result = new int[n];
        int[] colorSum = new int[maxColor + 1];
        int total = 0, j = 0;

        for (int i = 0; i < n; i++) {
            Ball cur = balls[i];

            // 현재 공보다 작은 크기 공들의 누적합 업데이트
            while (balls[j].size < cur.size) {
                total += balls[j].size;
                colorSum[balls[j].color] += balls[j].size;
                j++;
            }

            // 총합 - 같은 색상 누적합
            result[cur.index] = total - colorSum[cur.color];
        }

        for (int r : result) System.out.print(r + "\n");
    }
}

정리

정렬 후 투 포인터 방식으로 누적합을 갱신하면서 탐색
같은 색은 점수에 포함하지 않도록 색상별 합을 따로 관리
복잡한 브루트포스보다 훨씬 효율적인 누적합 전략

백준 2294: 동전2(Java)

quokkaST — Mon, 2 Jun 2025 21:33:07 +0900

문제 요약

n가지 종류의 동전을 가지고 있음
각각의 동전은 중복해서 사용할 수 있음
이 동전들을 이용해 총합이 k원이 되도록 할 때,
필요한 동전의 최소 개수를 구하라
불가능한 경우 -1을 출력하라

문제 분석

전형적인 동전 최소 개수 DP 문제
점화식 기반으로 1차원 DP 테이블을 구성하여 풀이

알고리즘 설계

1️⃣ DP 배열 정의

dp[j] = j원을 만들기 위한 최소 동전 개수
초기값: dp[0] = 0, 나머지는 INF (큰 값)

2️⃣ 점화식

각 동전 금액 c에 대해
dp[j] = min(dp[j], dp[j - c] + 1)

3️⃣ 최종 정답

dp[k]가 INF이면 만들 수 없는 금액 → -1 출력
아니면 dp[k] 출력

✅ 코드 구현 (Java)

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

public 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[] coin = new int[n];
        for (int i = 0; i < n; i++) {
            coin[i] = Integer.parseInt(br.readLine());
        }


        int INF = k + 1;
        int[] dp = new int[k + 1];
        Arrays.fill(dp, INF);
        dp[0] = 0;

        for (int i = 0; i < n; i++) {
            int c = coin[i];
            for (int j = c; j <= k; j++) {
                dp[j] = Math.min(dp[j], dp[j - c] + 1);
            }
        }

        System.out.println(dp[k] > k ? -1 : dp[k]);
    }
}

⏱️ 시간 복잡도

O(N × K)
N: 동전 종류 수 (최대 100), K: 금액 (최대 10,000)
10^6 이내이므로 충분히 가능

정리

각 금액마다 최소 동전 개수를 메모이제이션 방식으로 저장
모든 동전으로 K까지 누적 계산하여 최솟값을 구하는 방식
2중 for문이지만 내부 연산이 매우 작고 빠름

stquokka

VS Code 원격 개발 환경 구성: SSH 키로 원격 서버 접속하기

1. 왜 비밀번호 대신 SSH 키를 사용해야 할까?

2. SSH 키 생성 (로컬 PC)

3. 공개 키를 원격 서버에 등록

4. VS Code에서 원격 접속

학습 정리

OAuth2 기반 Google & Kakao 로그인 구축 방법

✅ 사전 준비

공통

1. Google OAuth2 로그인 구축

Google Cloud 설정

⚙️ application.yml 설정

2. Kakao OAuth2 로그인 구축

Kakao 개발자 설정

⚙️ application.yml 설정

커스터마이징

✅ 사용자 정보 매핑 (OAuth2UserService)

✅ Security 설정

실무 팁

백준 2615: 소형기관차(Java)

백준 2616번: 소형기관차

문제 요약

문제 접근

✅ 핵심 개념

알고리즘 설계

✅ 시간 복잡도

정리

백준 2306: 유전자(Java)

목표

✅ 핵심 아이디어

알고리즘 설계

⏱ 시간복잡도

정리

백준 1557: 도로의 개수(Java)

✅ 문제 요약

알고리즘 설계

핵심 포인트

⏱ 시간 복잡도 분석

GitHub 대용량 파일 관리를 위한 Lens 사용법

목표

✅ 왜 대용량 파일 관리가 필요한가?

Git LFS의 한계

Lens란?

핵심 특징

Lens 설치 및 설정

1️⃣ Lens CLI 설치

2️⃣ 프로젝트 초기화

3️⃣ 추적할 파일 등록

4️⃣ 커밋 및 푸시

GitHub 연동 구조

Lens vs Git LFS

실무 적용 팁

백준 2248 - 이진수 찾기(Java)

문제 요약

문제 접근

알고리즘 설계

✅ 조합 미리 계산

✅ 자리수 별 분기

전체 코드

✅ 시간복잡도

정리

collect(Collectors.toList()) vs Stream.toList()

✅ 핵심 차이점 요약

예시 코드 비교

1. Java 8 방식 - Collectors.toList()

2. Java 16 방식 - Stream.toList()

⚠️ 주의할 점

정리

백준 10800번: 컬러볼 (Java)

문제 목표

✅ 풀이 전략 요약

핵심 개념

전체 코드

정리

백준 2294: 동전2(Java)

문제 요약

문제 분석

알고리즘 설계

✅ 코드 구현 (Java)

1. Java 8 방식 - `Collectors.toList()`

2. Java 16 방식 - `Stream.toList()`