빙글빙글 돌아가는 Debug 하루

[PlantiFy] MSA 환경에서 JWKS 기반 분산 인증 구현 - RS256 전환 + common-auth-lib

aeongg — Mon, 1 Jun 2026 16:21:06 +0900

전체 구조 요약

auth-service
  → RSA 개인키로 JWT 서명 (RS256)
  → /.well-known/jwks.json 으로 공개키 노출

각 서비스
  → JWKS 엔드포인트에서 공개키 캐싱
  → Auth 호출 없이 로컬에서 JWT 검증

설계 배경과 기존 `/validate-token` 구조의 문제점
[PlantiFy] MSA 환경에서 Kakao Social Login 구현하기 - 서비스 개요 / Auth 병목 문제와 JWKS 기반 분산 인증 구조 개선

[PlantiFy] MSA 환경에서 Kakao Social Login 구현하기 - 서비스 개요 / Auth 병목 문제와 JWKS 기반 분산 인증

서비스 개요 및 상황Gateway 병목 피하려고 Auth 서버 분리Gateway 중앙화: 인증, 라우팅, 로깅, rate limit 등 공통 책임이 과도하게 집중되면 병목 지점이 될 수 있음특히 Gateway 단에서만 인증하고 내부

debug.tistory.com

1. auth-service: RS256 전환

RSA 키 로딩 (`RsaKeyProvider`)

PEM 파일이 있으면 로드하고, 없으면 로컬 실험용 키 쌍 자동 생성

키가 새로 생성될 때마다 `kid`도 `UUID`로 새로 발급해서 리소스 서비스가 stale 캐시 키를 사용하는 문제 방지

@Component
public class RsaKeyProvider {

    public RsaKeyProvider(@Value("${jwt.private-key}") Resource privateKeyResource,
                          @Value("${jwt.public-key}") Resource publicKeyResource,
                          @Value("${jwt.key-id}") String keyId) {
        KeyPair fallbackKeyPair = null;
        if (!privateKeyResource.exists() || !publicKeyResource.exists()) {
            fallbackKeyPair = generateLocalExperimentKeyPair();
        }
        this.privateKey = fallbackKeyPair == null
                ? loadPrivateKey(privateKeyResource)
                : (RSAPrivateKey) fallbackKeyPair.getPrivate();
        this.publicKey = fallbackKeyPair == null
                ? loadPublicKey(publicKeyResource)
                : (RSAPublicKey) fallbackKeyPair.getPublic();
        this.keyId = fallbackKeyPair == null
                ? keyId
                : "local-generated-" + UUID.randomUUID();
    }
}

JWT 발급 (`JwtAuthProvider`)

HS256에서 RS256으로 전환하면서 변경된 2가지

`signWith(secretKey)` → `signWith(rsaKeyProvider.getPrivateKey(), SignatureAlgorithm.RS256)`
`role`이 하드코딩 "USER"였던 것 → 실제 사용자 `role`을 클레임에 포함
- `role`이 클레임에 없으면 리소스 서비스는 ROLE_* 권한을 매핑할 수 없음
- HS256: `/validate-token`은 DB에서 `role`을 조회했지만,
  JWKS 로컬 검증으로 전환하면 Auth 호출이 없으므로 반드시 토큰 발급 시점에 role이 포함되어야 함

public String createAccessToken(long userId, Role role) {
    return createToken(userId, role, "Access", accessTokenExpiration);
}

private String createToken(Long userId, Role role, String type, long tokenValidTime) {
    Claims claims = Jwts.claims().setSubject(type);
    claims.put("userId", userId);
    if (role != null) {
        claims.put("role", role.name());  // 실제 role 클레임 포함
    }

    return Jwts.builder()
            .setClaims(claims)
            .setIssuedAt(new Date(System.currentTimeMillis()))
            .setExpiration(new Date(System.currentTimeMillis() + tokenValidTime))
            .setHeaderParam("kid", rsaKeyProvider.getKeyId())  // kid 포함
            .signWith(rsaKeyProvider.getPrivateKey(), SignatureAlgorithm.RS256)
            .compact();
}

JWKS 엔드포인트 (`JwksController`)

리소스 서비스들이 공개키를 가져갈 수 있도록 표준 JWKS 형식으로 노출

@RestController
@RequiredArgsConstructor
public class JwksController {

    private final RsaKeyProvider rsaKeyProvider;

    @GetMapping("/.well-known/jwks.json")
    public Map<String, Object> jwks() {
        RSAKey rsaKey = new RSAKey.Builder(rsaKeyProvider.getPublicKey())
                .keyID(rsaKeyProvider.getKeyId())
                .algorithm(JWSAlgorithm.RS256)
                .keyUse(KeyUse.SIGNATURE)
                .build();
        return new JWKSet(rsaKey).toJSONObject();
    }
}

응답 예시

{
  "keys": [
    {
      "kty": "RSA",
      "kid": "plantify-local-rsa-key-1",
      "use": "sig",
      "alg": "RS256",
      "n": "...",
      "e": "AQAB"
    }
  ]
}

2. common-auth-lib: 공통 인증 모듈

`JwtFilter`를 서비스마다 복붙하는 대신 Spring Boot AutoConfiguration으로 의존성 추가만으로 동작하도록 구성

자동 설정 (`PlantifyResourceServerAutoConfiguration`)

`NimbusJwtDecoder`: 내부적으로 JWKS 캐싱/ `kid`가 캐시에 없으면 자동으로 JWKS 엔드포인트 재조회

@AutoConfiguration
@EnableConfigurationProperties(PlantifyAuthProperties.class)
public class PlantifyResourceServerAutoConfiguration {

    @Bean
    @ConditionalOnProperty(prefix = "auth", name = "jwk-set-uri")
    JwtDecoder jwtDecoder(PlantifyAuthProperties properties) {
        return NimbusJwtDecoder.withJwkSetUri(properties.getJwkSetUri()).build();
    }

    @Bean
    JwtAuthenticationConverter jwtAuthenticationConverter() {
        Converter<Jwt, Collection<GrantedAuthority>> authoritiesConverter = jwt -> {
            String role = jwt.getClaimAsString("role");
            if (role == null || role.isBlank()) return List.of();
            return List.of(new SimpleGrantedAuthority("ROLE_" + role));
        };

        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(authoritiesConverter);
        converter.setPrincipalClaimName("userId");  // principal = userId
        return converter;
    }

    @Bean
    SecurityFilterChain securityFilterChain(HttpSecurity http,
                                            PlantifyAuthProperties properties,
                                            JwtAuthenticationConverter jwtAuthenticationConverter) throws Exception {
        String[] permitAll = properties.getPermitAll().toArray(String[]::new);

        return http
                .csrf(AbstractHttpConfigurer::disable)
                .sessionManagement(s -> s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
                .authorizeHttpRequests(r -> r
                        .requestMatchers(permitAll).permitAll()
                        .anyRequest().authenticated()
                )
                .oauth2ResourceServer(o -> o.jwt(j -> j.jwtAuthenticationConverter(jwtAuthenticationConverter)))
                .build();
    }
}

AutoConfiguration으로 등록하려면 파일 필요

// resources/META-INF/spring/org.springframework.boot.autoconfigure.AutoConfiguration.imports
com.plantify.authlib.PlantifyResourceServerAutoConfiguration

설정 프로퍼티 (`PlantifyAuthProperties`)

@ConfigurationProperties(prefix = "auth")
public class PlantifyAuthProperties {
    private String jwkSetUri;
    private List<String> permitAll = new ArrayList<>(List.of("/actuator/**", "/health"));
}

3. 리소스 서비스 적용

의존성 추가 + `yml` 설정

build.gradle

dependencies {
    implementation 'com.plantify:common-auth-lib'
}

settings.gradle

includeBuild '../common-auth-lib'

application.yml

auth:
  jwk-set-uri: ${AUTH_JWK_SET_URI:http://localhost:8081/.well-known/jwks.json}
  permit-all:
    - /actuator/**
    - /health

시퀀스 다이어그램

JWKS 발견 흐름 (최초 1회)

보호된 API 흐름 (이후 매 요청)

테스트

환경: MacBook, Docker Compose, k6 v0.53.0, 20 VU, 1분

1) 베이스라인 부하 테스트

Main

1. `main` 브랜치 이동

git checkout main

2. Auth + demo 서버 실행

docker compose up --build auth-service demo-resource-service

3. 다른 터미널에서 k6 실행

docker compose run --rm k6 run /scripts/baseline-auth-call.js

테스트 목적

k6가 Auth 서버의 실험용 토큰 발급 API를 호출
받은 JWT를 들고 demo 서버의 `/api/demo/me` 호출
demo 서버는 매 요청마다 Auth 서버의 `/v1/auth/validate-token`을 호출
Auth가 토큰을 검증하고 userId, role을 반환
demo 서버가 응답
k6가 latency, 실패율, p95 같은 지표 확인

결과

k6 -> Auth `/v1/auth/validate-token` 직접 호출
- `auth_call_duration` 측정용
k6 -> demo `/api/demo/me` 호출
- demo 내부에서 다시 Auth `/v1/auth/validate-token` 호출

=> `iterations`보다 `http_reqs`가 약 2배

`checks: 100.00%`
`http_req_failed: 0.00%`
- HTTP 요청 실패 X
- basline 정상 상태에서는 안정적으로 동작함
`iterations: 1160`
- `/api/demo/me` 테스트 루프가 1160번 수행됨
- 보호 API를 약 1160번 호출
`http_reqs: 2321`
- 총 HTTP 요청 수
- 계산: 1160 iterations * 2 requests + setup dev-token 1 = 2321
`http_req_duration p95: 52.3ms`
- 전체 HTTP 요청 중 95%가 52.3ms 안에 끝남
`auth_call_duration p95: 40.02ms`
- Auth `/validate-token` 직접 호출만 따로 측정한 p95
- basline에서 인증 검증 네트워크 호출이 어느 정도 비중을 가지는지 보여줌

Refactor

1. `refactor/jwks-local-validation` 브랜치 이동

git checkout refactor/jwks-local-validation

2. Auth + demo 서버 실행

docker compose up --build auth-service demo-resource-service

3. 다른 터미널에서 k6 실행

docker compose run --rm k6 run /scripts/baseline-auth-call.js

테스트 목적

Auth가 RS256 JWT 발급
Auth가 JWKS endpoint 제공
demo-resource-service가 Auth `/validate-token`을 매번 호출하지 않음
demo-resource-service가 JWKS 공개키로 JWT를 로컬 검증
`/api/demo/me` 요청 latency, 실패율, p95 확인

결과

`checks: 100.00%`
`http_req_failed: 0.00%`
`iterations: 1200`
`http_reqs: 1201`
- 계산: 1200 iterations * 1 requests + setup dev-token 1 = 1201
`http_req_duration p95: 17.77ms`

요약

`main`에서는 한 `iteration`마다 k6가 요청 2번 보냄
`refactor`에서는 한 `iteration`마다 k6가 요청 1번 보냄
- `iterations`와 `http_reqs`가 거의 동일

=> `refactor`에서는 demo가 매 요청마다 Auth `/validate-token` 호출 X, JWKS로 로컬 검증

2) 장애 테스트

docker compose run --rm k6 run /scripts/auth-failure-window.js

실행한 상태에서 다른 터미널에서 Auth 멈추기

docker stop plantify-auth-service

테스트 목적

JWKS가 이미 캐시된 상태라면 Auth가 내려가도 demo-resource-service의 `/api/demo/me`는 계속 200 반환

결과

`checks: 100.00%`
`http_req_failed: 0.00%`
`iterations: 2380`
`http_reqs: 2381`
- 계산: 2380 iterations + setup dev-token 1 = 1201
`http_req_duration p95: 17.54ms`

참고

GitHub - seunzu/plantify-msa-auth-refactor: JWKS 기반 분산 인증 설계 및 Auth SPOF 제거

JWKS 기반 분산 인증 설계 및 Auth SPOF 제거. Contribute to seunzu/plantify-msa-auth-refactor development by creating an account on GitHub.

github.com

[LeetCode 75/Graphs - BFS] 1926 - Nearest Exit from Entrance in Maze / 994 - Rotting Oranges

aeongg — Thu, 5 Mar 2026 17:28:10 +0900

1926 - Nearest Exit from Entrance in Maze

풀이

2차원, 정점 (r, c), 상하좌우 이동
`.`: 이동 가능 / `+`: 벽 (이동 불가)
출구: 가장자리에 있는 `.` (!= 시작점)

int[] dr = {1, -1, 0, 0};
int[] dc = {0, 0, 1, -1};

`q.offer(new int[]{r, c, dist})`: (행, 열, 거리)
`maze[nr][nc] = '+'`: 지나간 곳을 벽으로 바꿈

코드

class Solution {
    int m, n;
    int[] dr = {1, -1, 0, 0};
    int[] dc = {0, 0, 1, -1};

    int bfs(char[][] maze, int[] entrance) {
        Queue<int[]> q = new ArrayDeque<>();
        q.offer(new int[]{entrance[0], entrance[1], 0});

        maze[entrance[0]][entrance[1]] = '+';

        while (!q.isEmpty()) {
            int[] cur = q.poll();
            int r = cur[0];
            int c = cur[1];
            int dist = cur[2];

            for (int i = 0; i < 4; i++) {
                int nr = r + dr[i];
                int nc = c + dc[i];

                if (nr < 0 || nc < 0 || nr >= m || nc >= n) continue;

                if (maze[nr][nc] == '+') continue;

                if (nr == 0 || nr == m - 1 || nc == 0 || nc == n - 1) {
                    return dist + 1;
                }

                maze[nr][nc] = '+';
                q.offer(new int[]{nr, nc, dist + 1});
            }
        }

        return -1;
    }

    public int nearestExit(char[][] maze, int[] entrance) {
        m = maze.length;
        n = maze[0].length;

        return bfs(maze, entrance);
    }
}

994 - Rotting Oranges

풀이

0: 빈 공간 / 1: 신선한 오렌지 / 2: 썩은 오렌지
상하좌우 이동
썩은 오렌지(2) -> 신선한 오렌지(1)로 퍼짐
=> 신선한 오렌지가 썩은 오렌지로 변하는 데 걸리는 최소 시간
- 모든 썩은 오렌지 -> 동시에 시작점으로 넣음
- `fresh`: 남은 신선한 오렌지 개수 카운트

if (grid[r][c] == 2) {
    q.offer(new int[]{r, c});
}

if (grid[r][c] == 1) fresh++;

`!q.isEmpty() && fresh > 0`: 더 이상 퍼질 게 없거나 다 썩었으면 종료
현재 큐에 있는 것들 = 같은 시간(`minute`)에 있는 상태

while (!q.isEmpty() && fresh > 0) {
	int size = q.size();
    
    for (int i = 0; i < size; i++) {
        int[] cur = q.poll();

        for (int d = 0; d < 4; d++) {
            int nr = cur[0] + dr[d];
            int nc = cur[1] + dc[d];

            if (nr < 0 || nc < 0 || nr >= m || nc >= n) continue;

            if (grid[nr][nc] != 1) continue;

            grid[nr][nc] = 2;
            fresh--;

            q.offer(new int[]{nr, nc});
        }
    }

    minutes++;
}

코드

class Solution {
    int m, n;
    int[] dr = {1, -1, 0, 0};
    int[] dc = {0, 0, 1, -1};

    int bfs(int[][] grid, Queue<int[]> q, int fresh) {
        int minutes = 0;

        while (!q.isEmpty() && fresh > 0) {
            int size = q.size();

            for (int i = 0; i < size; i++) {
                int[] cur = q.poll();

                for (int d = 0; d < 4; d++) {
                    int nr = cur[0] + dr[d];
                    int nc = cur[1] + dc[d];

                    if (nr < 0 || nc < 0 || nr >= m || nc >= n) continue;

                    if (grid[nr][nc] != 1) continue;

                    grid[nr][nc] = 2;
                    fresh--;

                    q.offer(new int[]{nr, nc});
                }
            }

            minutes++;
        }

        return fresh == 0 ? minutes : -1;
    }

    public int orangesRotting(int[][] grid) {
        m = grid.length;
        n = grid[0].length;

        Queue<int[]> q = new ArrayDeque<>();
        int fresh = 0;

        for (int r = 0; r < m; r++) {
            for (int c = 0; c < n; c++) {
                if (grid[r][c] == 2) {
                    q.offer(new int[]{r, c});
                }

                if (grid[r][c] == 1) fresh++;
            }
        }

        return bfs(grid, q, fresh);
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Binary Search Tree] 700 - Search in a Binary Search Tree / 450 - Delete Node in a BST (Java)

aeongg — Wed, 4 Mar 2026 14:08:12 +0900

700 - Search in a Binary Search Tree

풀이

BST에서 값이 val과 같은 노드 찾고 그 노드를 root로 하는 subtree

BST: 왼쪽 subtree < 현재 노드 < 오른쪽 subtree

node.val > val -> 왼쪽으로 이동
node.val < val -> 오른쪽으로 이동

코드

class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        if (root == null) return null;

        if (root.val == val) return root;

        if (val < root.val) return searchBST(root.left, val);
        else return searchBST(root.right, val);
    }
}

450 - Delete Node in a BST

풀이

BST에서 값 key 가진 노드 찾아 삭제하고 삭제 후에도 BST 성질 유지

BST: 왼쪽 subtree < 현재 노드 < 오른쪽 subtree

node.val > val -> 왼쪽으로 이동
node.val < val -> 오른쪽으로 이동

삭제 3가지 경우

자식 X (leaf) -> `return null`
자식 하나 -> `return node.left` or `return node.right`
자식 둘 -> 오른쪽 subtree에서 가장 작은 값 or 왼쪽 subtree에서 가장 작은 값으로 대체

// case 1,2: 자식 0개 또는 1개
if (root.left == null) return root.right;
if (root.right == null) return root.left;

// case 3: 자식 2개
TreeNode min = findMin(root.right);
root.val = min.val;
root.right = deleteNode(root.right, min.val);

코드

class Solution {
    TreeNode findMin(TreeNode node) {
        while (node.left != null) {
            node = node.left;
        }

        return node;
    }

    public TreeNode deleteNode(TreeNode root, int key) {
        if (root == null) return null;

        if (key < root.val) {
            root.left = deleteNode(root.left, key);
        } else if (key > root.val) {
            root.right = deleteNode(root.right, key);
        } else {
            if (root.left == null) return root.right;
            if (root.right == null) return root.left;

            TreeNode min = findMin(root.right);
            root.val = min.val;
            root.right = deleteNode(root.right, min.val);
        }

        return root;
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Binary Tree - BFS] 199 - Binary Tree Right Side View / 1161 - Maximum Level Sum of a Binary Tree (Java)

aeongg — Tue, 3 Mar 2026 19:45:43 +0900

199 - Binary Tree Right Side View

풀이

이진 트리의 루트 노드가 주어졌을 때, 트리를 오른쪽에서 바라봄

-> 각 높이(level)마다 맨 오른쪽 노드만 보임

=> 각 레벨에서 마지막 노드 찾기

BFS로 트리를 레벨 순서로 탐색

ex. root = [1, 2, 3, , null, 5, null, 4]

level 0 / [1] => 1
level 1 / [2, 3] => 3
level 2 / [5, 4] => 4

=> [1, 3, 4]

코드

class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> arr = new ArrayList<>();
        if (root == null) return arr;

        Queue<TreeNode> q = new ArrayDeque<>();
        q.offer(root);
        
        while (!q.isEmpty()) {
            int size = q.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();

                if (i == size - 1) {
                    arr.add(node.val);
                }

                if (node.left != null) q.offer(node.left);
                if (node.right != null) q.offer(node.right);
            }
        }

        return arr;
    }
}

1161 - Maximum Level Sum of a Binary Tree

풀이

각 레벨 노드 값 합 계산해서 합이 가장 큰 레벨 번호 반환

-> `sum += node.val`

class Solution {
    public int maxLevelSum(TreeNode root) {
        Queue<TreeNode> q = new ArrayDeque<>();
        q.offer(root);

        int level = 1;
        int maxLevel = 1;
        int maxSum = Integer.MIN_VALUE;

        while (!q.isEmpty()) {
            int size = q.size();
            int sum = 0;

            for (int i = 0; i < size; i++) {
                TreeNode node = q.poll();
                sum += node.val;

                if (node.left != null) q.offer(node.left);
                if (node.right != null) q.offer(node.right);
            }

            if (sum > maxSum) {
                maxSum = sum;
                maxLevel = level;
            }

            level++;
        }

        return maxLevel;        
    }
}

코드

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Binary Tree - DFS] 437 - Path Sum 3 / 1372 - Longest ZigZag Path in a Binary Tree / 236 - Lowest Common Ancestor of a Binary Tree (Java)

aeongg — Mon, 2 Mar 2026 20:03:31 +0900

437 - Path Sum 3

풀이

부모 -> 자식 경로 중 합이 `targetSum`인 경로 개수

=> 모든 노드를 시작점으로 생각

`int dfs(TreeNode node, long target)`: 현재 node에서 시작해서 아래로 내려가며 합이 `target`이 되는 경로 개수
`int pathSum(TreeNode root, int targetSum)`: 모든 노드를 시작점으로 고려
- `dfs(root, targetSum)`: root에서 시작하는 경로 개수
- `pathSum(root.left, targetSum)`: 왼쪽 subtree에서 시작하는 경로 개수
- `pathSum(root.right, targetSum)`: 오른쪽 subtree에서 시작하는 경로 개수

코드

class Solution {
    int dfs(TreeNode node, long target) {
        if (node == null) return 0;

        int cnt = 0;
        if (node.val == target) cnt++;

        cnt += dfs(node.left, target - node.val);
        cnt += dfs(node.right, target - node.val);

        return cnt;
    }
    
    public int pathSum(TreeNode root, int targetSum) {
        if (root == null) return 0;

        return dfs(root, targetSum)
            + pathSum(root.left, targetSum)
            + pathSum(root.right, targetSum);
    }
}

1372 - Longest ZigZag Path in a Binary Tree

풀이

아무 노드에서 시작 -> 방향 선택(left/right) -> 한 번 이동 -> 방향 변경 => 반복

지그재그 길이 = 방문한 노드 수 - 1 (노드 1개 -> 길이 0)

매번 방향을 바꿔줘야 함
- 현재 노드, 현재 방향, 현재 길이
각 노드에서 왼쪽/오른쪽 시작 경우 모두 고려

dfs(root, true, 0);
dfs(root, false, 0);

`goLeft == true`: 왼쪽으로 가야 함

왼쪽으로 간 뒤 오른쪽으로 가야 함
현재 노드에서 새 zigzag 시작

dfs(node.left, false, len + 1);
dfs(node.right, true, 1);

코드

class Solution {
    int max = 0;

    void dfs(TreeNode node, boolean goLeft, int len) {
        if (node == null) return;

        max = Math.max(max, len);
        
        if (goLeft) {
            dfs(node.left, false, len + 1);
            dfs(node.right, true, 1);
        } else {
            dfs(node.right, true, len + 1);
            dfs(node.left, false, 1);
        }
    }

    public int longestZigZag(TreeNode root) {
        dfs(root, true, 0);
        dfs(root, false, 0);

        return max;
    }
}

236 - Lowest Common Ancestor of a Binary Tree

풀이

LCA: 두 노드 p, q를 모두 포함하는 가장 낮은 공통 조상

lowest: root에서 가장 먼(가장 깊은) 공통 조상

=> 어떤 노드에서 왼쪽 subtree에 p, q 있고, 오른쪽 subtree에 p, q 있으면 그 노드가 LCA

왼쪽, 오른쪽 찾은 경우(`lt != null && rt != null`) -> 현재 root가 LCA
한쪽만 찾은 경우 -> 그 결과를 위로 전달

코드

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if (root == null || root == p || root == q) return root;

        TreeNode lt = lowestCommonAncestor(root.left, p, q);
        TreeNode rt = lowestCommonAncestor(root.right, p, q);

        if (lt != null && rt != null) return root;
        
        return lt != null ? lt : rt;
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Binary Tree - DFS] 104 - Maximum Depth of Binary Tree / 872 - Leaf-Similar Trees / 1448 - Count Good Nodes in Binary Tree (Java)

aeongg — Mon, 2 Mar 2026 19:23:18 +0900

104 - Maximum Depth of Binary Tree

풀이

이진 트리 노드 정의 클래스

`val`: 자기 값
`left`: 왼쪽 자식
`right`: 오른쪽 자식

class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;

    TreeNode() {}
    
    TreeNode(int val) {
        this.val = val;
    }

    TreeNode(int val, TreeNode left, TreeNode right) {
        this.val = val;
        this.left = left;
        this.right = right;
    }
}

최대 깊이: 루트에서 가장 먼 리프 노드까지의 가장 긴 경로에 있는 노드의 개수

ex. root = [3, 9, 20, null, null, 15, 7]

-> 가장 긴 경로: 3 -> 20 -> 15 / 3 -> 20 -> 7 => 3개

현재 노드 깊이 = 1 + max(왼쪽 깊이, 오른쪽 깊이)

root가 null이면 깊이 0

코드

class Solution {
    public int maxDepth(TreeNode root) {
        if (root == null) return 0;

        int lt = maxDepth(root.left);
        int rt = maxDepth(root.right);

        return 1 + Math.max(lt, rt);
    }
}

872 - Leaf-Similar Trees

풀이

List<Integer> leaves1 = new ArrayList<>();
List<Integer> leaves2 = new ArrayList<>();

dfs(root1, leaves1);
dfs(root2, leaves2);

두 트리에서 리프 노드만 왼쪽부터 순서대로 모아서 비교

리프(leaf): 자식이 없는 노드

node.left == null && node.right == null

코드

class Solution {
    void dfs(TreeNode node, List<Integer> leaves) {
        if (node == null) return;

        if (node.left == null && node.right == null) {
            leaves.add(node.val);
            return;
        }

        dfs(node.left, leaves);
        dfs(node.right, leaves);
    }

    public boolean leafSimilar(TreeNode root1, TreeNode root2) {
        List<Integer> leaves1 = new ArrayList<>();
        List<Integer> leaves2 = new ArrayList<>();

        dfs(root1, leaves1);
        dfs(root2, leaves2);

        return leaves1.equals(leaves2);
    }
}

1448 - Count Good Nodes in Binary Tree

풀이

good node: root -> x 경로에서 x보다 큰 값이 없어야 함

=> x >= 경로에서 최대값

-> 지금까지 경로에서 최대값 같이 전달해서 현재 노드 값과 비교, 최대값 갱신

코드

class Solution {
    int dfs(TreeNode node, int max) {
        if (node == null) return 0;

        int cnt = 0;
        if (node.val >= max) cnt = 1;

        max = Math.max(max, node.val);

        cnt += dfs(node.left, max);
        cnt += dfs(node.right, max);
        
        return cnt;
    }

    public int goodNodes(TreeNode root) {
        return dfs(root, root.val);
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Linked List] 2095 - Delete the Middle Node of a Linked List / 328 - Odd Even Linked List / 206 - Reverse Linked List / 2130 - Maximum Twin Sum of a Linked List (Java)

aeongg — Sun, 1 Mar 2026 20:04:17 +0900

2095 - Delete the Middle Node of a Linked List

풀이

길이 n인 리스트에서 인덱스 ⌊n/2⌋ (0-based) 노드 삭제

ex. [1, 3, 4, 7, 1, 2, 6] -> n = 7, ⌊7/2⌋ = 3 => 7 삭제

`head.next == null`: 노드 1개 == middle -> 삭제 => null

리스트 길이 모름 -> `fast`: 2칸씩 이동 / `slow`: 1칸씩 이동

`fast`가 끝에 도달하면 `slow`는 middle에 있음

(`prev`: `slow`의 이전 노드 저장)

ListNode slow = head;
ListNode fast = head;
ListNode prev = null;

while (fast != null && fast.next != null) {
    prev = slow;
    slow = slow.next;
    fast = fast.next.next;
}

prev.next = slow.next;

코드

class Solution {
    public ListNode deleteMiddle(ListNode head) {
        if (head.next == null) return null;

        ListNode slow = head;
        ListNode fast = head;
        ListNode prev = null;

        while (fast != null && fast.next != null) {
            prev = slow;
            slow = slow.next;
            fast = fast.next.next;
        }

        prev.next = slow.next;

        return head;
    }
}

328 - Odd Even Linked List

풀이

인덱스 기준으로 홀수 노드 먼저, 그 다음 짝수 노드들

`odd`: 홀수 체인 포인터 / `even`: 짝수 체인 포인터

(`evenHead`: 짝수 시작점 저장)

ListNode odd = head;
ListNode even = head.next;
ListNode evenHead = even;

while (even != null && even.next != null) {
    odd.next = even.next;
    odd = odd.next;

    even.next = odd.next;
    even = even.next;
}

odd.next = evenHead;

코드

class Solution {
    public ListNode oddEvenList(ListNode head) {
        if (head == null || head.next == null) return head;

        ListNode odd = head;
        ListNode even = head.next;
        ListNode evenHead = even;

        while (even != null && even.next != null) {
            odd.next = even.next;
            odd = odd.next;

            even.next = odd.next;
            even = even.next;
        }

        odd.next = evenHead;

        return head;
    }
}

206 - Reverse Linked List

풀이

포인터 방향 뒤집기

-> 현재 노드 방향 뒤집고 앞으로 한 칸 이동

=> `prev`: 이전 노드 / `cur`: 현재 노드 / `next`: 다음 노드

코드

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = prev;         
            prev = cur;              
            cur = next;              
        }

        return prev; 
    }
}

2130 - Maximum Twin Sum of a Linked List

풀이

양쪽 끝끼리 짝 만들어서 가장 큰 합 구하기

=> i번째 노드 <-> (n - 1 - i)번째 노드

ex. [5, 3, 2, 1] -> (0 <-> 3) -> 5 + 1 = 6 / (1 <-> 2) -> 4 + 2 = 6 => max = 6

중간 찾기

`fast`: 2칸씩 이동 / `slow`: 1칸씩 이동

`fast`가 끝에 도달하면 `slow`는 middle에 있음

ListNode slow = head;
ListNode fast = head;

while (fast != null && fast.next != null) {
    slow = slow.next;
    fast = fast.next.next;
}

5 → 4 → 2 → 1
        ↑
      slow

뒤 절반 reverse

`slow`: 뒤 절반 시작점 -> `ListNode cur = slow`

ListNode prev = null;
ListNode cur = slow;

while (cur != null) {
    ListNode next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
}

5 → 4     1 → 2
           ↑
         prev

twin sum 계산

`prev`: 뒤집한 리스트의 시작점 -> `ListNode second = prev`

int max = 0;
ListNode first = head;
ListNode second = prev;

while (second != null) {
    max = Math.max(max, first.val + second.val);
    first = first.next;
    second = second.next;
}

first  = head  → 5 → 4
second = prev  → 1 → 2

코드

class Solution {
    public int pairSum(ListNode head) {
        ListNode slow = head;
        ListNode fast = head;

        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }

        ListNode prev = null;
        ListNode cur = slow;

        while (cur != null) {
            ListNode next = cur.next;
            cur.next = prev;
            prev = cur;
            cur = next;
        }

        int max = 0;
        ListNode first = head;
        ListNode second = prev;

        while (second != null) {
            max = Math.max(max, first.val + second.val);
            first = first.next;
            second = second.next;
        }

        return max;
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Stack] 2390 - Removing Stars From a String / 735 - Asteroid Collision / 394 - Decode String (Java)

aeongg — Fri, 27 Feb 2026 22:32:40 +0900

2390 - Removing Stars From a String

풀이

*를 만나면 왼쪽에서 가장 가까운 문자 하나 삭제

-> 마지막에 들어온 문자(LIFO) 지움 => 스택

일반 문자 -> 스택에 push
* -> 스택에서 pop

코드

class Solution {
    public String removeStars(String s) {
        StringBuilder sb = new StringBuilder();
        Stack<Character> stack = new Stack<>();

        for (char c : s.toCharArray()) {
            if (c == '*') stack.pop();
            else stack.push(c);
        }

        for (char c : stack) sb.append(c);

        return sb.toString();
    }
}

735 - Asteroid Collision

풀이

부호: 방향 (양수 - 오른쪽/음수 - 왼쪽)

두 소행성 충돌하면 작은 소행성 폭발/ 크기 같으면 둘 다 폭발/ 같은 방향으로 움직이는 소행성 충돌 X

왼쪽에서 오른쪽으로 진행하면서 살아있는 이전 운석 관리

충돌 조건: `stack`이 비어 있지 않고, 현재 운석이 왼쪽(-), 스택 top이 오른쪽(+)
- top이 더 작음: 스택에서 pop
- 같은 크기 -> 둘 다 폭발
- top이 더 큼 -> a만 파괴, 스택 유지
`destroyed`: 현재 운석이 살아남았는지
- 충돌에서 살아남았거나 충돌 없었으면 push

else if (c == '[') {
    cntStack.push(k);
    stringStack.push(cur);

    cur = new StringBuilder();
    k = 0;
} else if (c == ']') {
    int repeat = cntStack.pop();
    StringBuilder prev = stringStack.pop();
    for (int i = 0; i < repeat; i++) {
        prev.append(cur);
    }
    cur = prev;
} else cur.append(c);

코드

class Solution {
    public int[] asteroidCollision(int[] asteroids) {
        Stack<Integer> stack = new Stack<>();

        for (int a : asteroids) {
            boolean destroyed = false;

            while (!stack.isEmpty() && a < 0 && stack.peek() > 0) {
                if (stack.peek() < -a) stack.pop();
                else if (stack.peek() == -a) {
                    stack.pop();
                    destroyed = true;
                    break;
                } else {
                    destroyed = true;
                    break;
                }
            }

            if (!destroyed) stack.push(a);
        }

        int n = stack.size();
        int[] result = new int[n];
        for (int i = n - 1; i >= 0; i--) {
            result[i] = stack.pop();
        }

        return result;
    }
}

394 - Decode String

풀이

ex. 3[a2[c]] -> a2[c] = acc -> 3[acc] = accaccacc

=> 중첩 구조로 닫는 괄호 ] 만날 때마다 계산

-> Stack 2개 사용 (숫자 스택: 반복 횟수 저장 / 문자열 스택: 이전까지 문자열 저장)

Stack<Integer> cntStack = new Stack<>();
Stack<StringBuilder> stringStack = new Stack<>();

숫자 처리

if (Character.isDigit(c)) {
    k = k * 10 + (c - '0');  
}

'[' 만났을 때
- 현재 반복 숫자 저장
- 현재까지 만든 문자열 저장
- 새로운 내부 문자열 시작
']' 만났을 때 -> 이전 상태 복원
- 현재 문자열 `repeat`(`cntStack.pop()`)만큼 붙여서 이전 문자열 뒤에 연결

else if (c == '[') {
    cntStack.push(k);
    stringStack.push(cur);

    cur = new StringBuilder();
    k = 0;
} else if (c == ']') {
    int repeat = cntStack.pop();
    StringBuilder prev = stringStack.pop();
    for (int i = 0; i < repeat; i++) {
        prev.append(cur);
    }
    cur = prev;
} else cur.append(c);

코드

class Solution {
    public String decodeString(String s) {
        Stack<Integer> cntStack = new Stack<>();
        Stack<StringBuilder> stringStack = new Stack<>();
        
        StringBuilder cur = new StringBuilder();
        int k = 0;
        
        for (char c : s.toCharArray()) {
            if (Character.isDigit(c)) {
                k = k * 10 + (c - '0');  
            } else if (c == '[') {
                cntStack.push(k);
                stringStack.push(cur);
                
                cur = new StringBuilder();
                k = 0;
            } else if (c == ']') {
                int repeat = cntStack.pop();
                StringBuilder prev = stringStack.pop();
                for (int i = 0; i < repeat; i++) {
                    prev.append(cur);
                }
                cur = prev;
            } else cur.append(c);
        }
        
        return cur.toString();
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Queue] 993 - Number of Recent Calls / 649 - Dota2 Senate (Java)

aeongg — Fri, 27 Feb 2026 18:44:19 +0900

993 - Number of Recent Calls

풀이

`RecentCounter()`: 최근 요청 수 0으로 초기화
`int ping(int t)`: 시간 t에 새로운 요청 추가, 지난 3000밀리초 동안 발생한 요청 수(새로운 요청 포함) 반환
/ [t - 3000, t ] 범위 내에서 발생한 요청 수 반환

=> 시간 t 계속 증가 -> 최근 3000ms 안에 있는 요청만 유지

=> Sliding Window + Queue (새로운 요청 뒤에 추가, 오래된 요청 앞에서 제거: FIFO)

Queue<Integer> q;

생성자

public RecentCounter() {
    q = new LinkedList<>();
}

`ping(int t)`: t 기준으로 지난 3000ms 안에 있는 요청 수 반환

q.offer(t)
[t - 3000, t] -> `q.peek() < t - 3000` => 범위 밖 -> 제거 => 오래된 요청 제거: `q.poll()`

public int ping(int t) {
    q.offer(t);

    while (!q.isEmpty() && q.peek() < t - 3000) {
        q.poll();
    }

    return q.size();
}

ex. ping(1)
- 범위: [-2999, 1]
- 요청: [1] => 1개
ex. ping(100)
- 범위: [-2900, 100]
- 요청: [1, 100] => 2개
ex. ping(3001)
- 범위: [1, 3001]
- 요청: [1, 100, 3001] => 3개
ex. ping(3002)
- 범위: [2, 3002]
- 요청: [1, 100, 3001, 3002] => 3개

코드

class RecentCounter {
    Queue<Integer> q;

    public RecentCounter() {
        q = new LinkedList<>();
    }
    
    public int ping(int t) {
        q.offer(t);

        while (!q.isEmpty() && q.peek() < t - 3000) {
            q.poll();
        }

        return q.size();
    }
}

649 - Dota2 Senate

풀이

Doat2 세계에 Radiant/Dire 두 진영 존재, 두 가지 권한 중 하나 행사

R - 상원의원 한 명 권리 박탈: 이번 및 이후
D - 승리 선언: 투표권 가진 상원의원 모두 같은 당 소속 -> 승리 선언

=> 각 사람은 자기 턴이 오면 상대 한 명 제거

-> 누가 더 빨리 등장하는지 중요 => 위치(index) 저장

Queue<Integer> radiant = new LinkedList<>();
Queue<Integer> dire = new LinkedList<>();

for (int i = 0; i < n; i++) {
    if (senate.charAt(i) == 'R') radiant.offer(i);
    else dire.offer(i);
}

현재 가장 앞에 있는 R과 D 대결

rIdx < dIdx: R이 먼저 등장 = R이 먼저 행동 -> D 제거, R 남음
- `radiant.offer(rIdx + n)`: 다음 라운드의 맨 뒤에서 다시 등장 -> 라운드 순환 구조

while (!radiant.isEmpty() && !dire.isEmpty()) {
    int rIdx = radiant.poll();
    int dIdx = dire.poll();

    if (rIdx < dIdx) radiant.offer(rIdx + n);
    else dire.offer(dIdx + n);
}

코드

class Solution {
    public String predictPartyVictory(String senate) {
        int n = senate.length();

        Queue<Integer> radiant = new LinkedList<>();
        Queue<Integer> dire = new LinkedList<>();

        for (int i = 0; i < n; i++) {
            if (senate.charAt(i) == 'R') radiant.offer(i);
            else dire.offer(i);
        }

        while (!radiant.isEmpty() && !dire.isEmpty()) {
            int rIdx = radiant.poll();
            int dIdx = dire.poll();

            if (rIdx < dIdx) radiant.offer(rIdx + n);
            else dire.offer(dIdx + n);
        }

        return radiant.isEmpty() ? "Dire" : "Radiant";
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com

[LeetCode 75/Hash Map & Set] 2215 - Find the Difference of Two Arrays / 1207 - Unique Number of Occurrences / 1657 - Determine if Two String Are Close / 2352 - Equal Row and Column Pairs (Java)

aeongg — Thu, 26 Feb 2026 00:54:05 +0900

2215 - Find the Difference of Two Arrays

풀이

두 배열 nums1, nums2

`answer[0]`: nums1에만 있고 nums2에는 없는 값들
`answer[1]:` nums2에만 있고 nums1에는 없는 값들

-> 중복 없이(distinct) 반환 => `Set`

코드

class Solution {
    public List<List<Integer>> findDifference(int[] nums1, int[] nums2) {
        Set<Integer> set1 = new HashSet<>();
        Set<Integer> set2 = new HashSet<>();

        for (int n : nums1) set1.add(n);
        for (int n : nums2) set2.add(n);

        List<Integer> diff1 = new ArrayList<>();
        List<Integer> diff2 = new ArrayList<>();

        for (int s : set1) {
            if (!set2.contains(s)) {
                diff1.add(s);
            }
        }

        for (int s : set2) {
            if (!set1.contains(s)) {
                diff2.add(s);
            }
        }

        return Arrays.asList(diff1, diff2);
    }
}

1207 - Unique Number of Occurrences

풀이

배열 arr에서 각 숫자의 등장 횟수(빈도) 구한 뒤 같은 빈도 2개 이상 있으면 false

=> 등장 횟수 모두 서로 달라야 함

코드

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        Map<Integer, Integer> HM = new HashMap<>();

        for (int a : arr) {
            HM.put(a, HM.getOrDefault(a, 0) + 1);
        }

        Set<Integer> set = new HashSet<>(HM.values());

        return set.size() == HM.size();
    }
}

1657 - Determine if Two String Are Close

풀이

문자 위치 바꾸기(swap): abcde -> aecdb
문자 전체 교환: aacabb -> bbcbaa

-> 두 문자열 close하려면 문자 종류 같음 + 문자 빈도 집합 같음

/ 리스트 추출 -> 정렬 후 비교

코드

class Solution {
    public boolean closeStrings(String word1, String word2) {
        if (word1.length() != word2.length()) return false;

        Map<Character, Integer> map1 = new HashMap<>();
        for (char c : word1.toCharArray()) {
            map1.put(c, map1.getOrDefault(c, 0) + 1);
        }

        Map<Character, Integer> map2 = new HashMap<>();
        for (char c : word2.toCharArray()) {
            map2.put(c, map2.getOrDefault(c, 0) + 1);
        }

        if (!map1.keySet().equals(map2.keySet())) {
            return false;
        }

        List<Integer> freq1 = new ArrayList<>(map1.values());
        List<Integer> freq2 = new ArrayList<>(map2.values());

        Collections.sort(freq1);
        Collections.sort(freq2);

        return freq1.equals(freq2);
    }
}

2352 - Equal Row and Column Pairs

풀이

n x n 행렬 -> (ri, cj) 쌍 중 row i와 column j가 완전히 같은 배열인 경우 개수

ex. grid = [[3, 2, 1],[1, 7, 6],[2, 7, 7]]

-> Row 0: [3, 2, 1], Row 1: [1, 7, 6], Row 2: [2, 7, 7]

/ Column 0: [3, 1, 2], Column 1: [2, 7, 7], Column 2: [1, 6, 7]

-> Row 2 == Column 1 => 1개

각 행 문자열로 변환 후 key로 저장, 빈도 저장

-> 열(column)을 배열(`arr`)로 만든 뒤 그 배열과 동일한 행(row) 몇 개 있는지 `HM`에서 찾음

코드

class Solution {
    public int equalPairs(int[][] grid) {
        int n = grid.length;
        Map<String, Integer> HM = new HashMap<>();

        for (int[] g : grid) {
            String key = Arrays.toString(g);
            HM.put(key, HM.getOrDefault(key, 0) + 1);
        }

        int cnt = 0;
        for (int col = 0; col < n; col++) {
            int[] arr = new int[n];
            for (int row = 0; row < n; row++) {
                arr[row] = grid[row][col];
            }

            String key = Arrays.toString(arr);
            cnt += HM.getOrDefault(key, 0);
        }

        return cnt;
    }
}

출처

LeetCode 75 - Study Plan - LeetCode

Ace Coding Interview with 75 Qs

leetcode.com