백준 루트

문제

내가 생각했을때 문제에서 원하는부분

입력은 여러 테스트 케이스로 이루어져 있다.
각 테스트 케이스는 한 줄로 이루어져 있고, B와 N이 주어진다. (1 ≤ B ≤ 1,000,000, 1 ≤ N ≤ 9)
입력의 마지막 줄에는 0이 2개 주어진다.

각 테스트 케이스에 해당하는 A를 출력한다.

내가 이 문제를 보고 생각해본 부분

BufferedReader 및 StringBuilder 사용:
BufferedReader는 대량의 입력을 읽기 위해 사용된다.
StringBuilder는 여러 테스트 케이스의 결과를 한 번에 모아서 출력한다.
입력 처리 루프:
while ((line = br.readLine()) != null)을 사용하여 한 줄씩 입력을 읽는다.
읽은 줄을 공백 기준으로 분리하여 B와 N 값을 파싱한다.
B와 N이 모두 0이면 입력의 끝이므로 루프를 종료한다.
A 값 탐색:
a 변수를 1부터 시작하여 증가시킨다.
prevPow 변수는 (a-1)^N 값을 저장하며, a가 1일 때는 0으로 초기화된다.
내부 for 루프를 통해 a^N 값을 currentPow에 계산한다.
가장 가까운 값 찾기 로직:
currentPow == B: a^N이 정확히 B와 같으면 a가 답이므로 바로 출력하고 다음 테스트 케이스로 넘어간다.
currentPow > B: a^N이 B보다 커진 경우, (a-1)^N과 a^N 중 B에 더 가까운 값을 찾는다.
diffPrev: B와 (a-1)^N의 차이 (B - prevPow)
diffCurrent: B와 a^N의 차이 (currentPow - B)
diffPrev <= diffCurrent 조건으로 두 차이를 비교한다.
만약 (a-1)^N이 더 가깝거나, 두 차이가 같다면 a-1을 답으로 선택한다.
이는 일반적으로 차이가 같을 때 더 작은 값을 선호하는 규칙을 따른다.
그렇지 않으면 a를 답으로 선택한다.
답을 찾으면 break를 통해 현재 테스트 케이스의 while 루프를 종료하고 다음 테스트 케이스로 넘어간다.
prevPow 업데이트: 다음 a 값을 계산하기 전에 현재 currentPow 값을 prevPow에 저장한다.

코드로 구현

package baekjoon.baekjoon_29;

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

// 백준 4619번 문제
public class Main1066 {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb = new StringBuilder();
        String line;

        // 입력이 "0 0"이 될 때까지 반복합니다.
        while((line = br.readLine()) != null) {
            String[] parts = line.split(" ");
            int B = Integer.parseInt(parts[0]);
            int N = Integer.parseInt(parts[1]);

            // B와 N이 모두 0이면 반복을 종료합니다.
            if(B == 0 && N == 0) {
                break;
            }

            int a = 1; // A는 1부터 시작합니다.
            int prevPow = 0; // (A-1)^N 값을 저장합니다. A가 1일 때는 0^N이므로 0으로 초기화합니다.

            // A를 1부터 증가시키면서 B에 가장 가까운 A^N을 찾습니다.
            while(true) {
                int currentPow = 1; // 현재 A에 대한 A^N 값을 계산합니다.

                // A^N을 계산합니다.
                for(int i = 0; i < N; i++) {
                    currentPow *= a;
                    // currentPow가 int의 최대값을 초과할 가능성이 있지만,
                    // 문제의 B와 N 제약 조건(B <= 1,000,000, N <= 9) 하에서는
                    // A^N이 B를 크게 초과하기 전에 답을 찾게 되므로 int 범위 내에 있습니다.
                    // 예를 들어, 16^5 = 1,048,576 이나 32^4 = 1,048,576 등은 int 범위에 들어갑니다.
                }

                // 현재 계산된 A^N이 B와 같으면 바로 A가 답입니다.
                if(currentPow == B) {
                    sb.append(a).append("\n");
                    break;
                }
                // 현재 계산된 A^N이 B보다 커지면, 이전 A-1의 N승 값과 현재 A의 N승 값 중
                // 어느 것이 B에 더 가까운지 비교합니다.
                else if(currentPow > B) {
                    // B와 이전 A^N 값의 차이 (B - (A-1)^N)
                    int diffPrev = B - prevPow;
                    // B와 현재 A^N 값의 차이 (A^N - B)
                    int diffCurrent = currentPow - B;

                    // 이전 A^N 값이 B에 더 가깝거나, 두 차이가 같으면 A-1이 답입니다.
                    // (차이가 같을 경우 더 작은 A를 선택하는 일반적인 규칙을 따릅니다.)
                    if(diffPrev <= diffCurrent) {
                        sb.append(a - 1).append("\n");
                    }
                    // 그렇지 않으면 현재 A가 답입니다.
                    else {
                        sb.append(a).append("\n");
                    }
                    break; // 답을 찾았으므로 반복을 종료합니다.
                }

                // 다음 반복을 위해 현재 A^N 값을 prevPow에 저장하고 A를 증가시킵니다.
                prevPow = currentPow;
                a++;
            }
        }

        // 모든 테스트 케이스의 결과를 한 번에 출력합니다.
        System.out.print(sb.toString());
        br.close(); // BufferedReader를 닫습니다.
    }
}

마무리

코드와 설명이 부족할수 있습니다. 코드를 보시고 문제가 있거나 코드 개선이 필요한 부분이 있다면 댓글로 말해주시면 감사한 마음으로 참고해 코드를 수정 하겠습니다.