23-Seol-Munhyeok

[Seol-Munhyeok]

🔗 문제 링크

책 페이지
https://www.acmicpc.net/problem/1019

✔️ 소요된 시간

1시간

✨ 수도 코드

주의 : 이 문제는 풀이를 봐도 어려우니 도저히 안 풀리면 바로 풀이를 보는 것을 권장합니다.

문제 자체는 초등학생도 이해할 정도로 쉽지만 상당히 어려운 문제입니다. 일단 입력이 $N=10^9$ 이므로 $O(N)$으로 탐색해도 시간초과가 발생합니다. 이 문제를 풀기 위해서는 뭔가 수학적인 발상이 하나 필요합니다.

풀이는 백준 온라인 저지를 만드신 최백준 님께서 올린 슬라이드를 참고했습니다.
https://www.slideshare.net/slideshow/baekjoon-online-judge-1019/52810015

아이디어는 A부터 B까지 각 숫자가 몇 번 나오는지를 찾는 문제로 바꿔서 생각하는 것입니다.
이때 A의 일의자리가 0이고, B의 일의자리가 9인 경우, A와 B사이의 수의 0-9가 일의 자리에 각각 몇 번씩 나오는지를 바로 계산할 수 있습니다.

예를 들어 A=10, B=39인 경우, 일의 자리에는 0-9가 총 3번씩 나오는 걸 볼 수 있습니다.

자리수가 늘어서 A=110, B=130인 경우도, 일의 자리에서는 0-9가 13-11+1=3번씩 나오는 걸 볼 수 있습니다.

따라서 우리는 A의 끝 자리를 0, B의 끝자리를 9로 맞춘 범위안에서는 A와 B사이에 0-9가 총 몇 번 나오는지를 바로 계산할 수 있습니다. A의 끝 자리를 0, B의 끝자리를 9로 맞출 때까지 A는 +1, B는 -1하면서 그 때의 A, B는 따로 숫자가 나오는 횟수를 계산하면 됩니다.

코드로 구현할 때는 A % 10 을 하면 수의 일의 자리수가 나오고, A // 10을 하면 일의 자리 수를 뗀 숫자가 나온다는 점을 사용합니다.

이때 주의할 점은 십의 자리에 위치한 0-9의 개수를 구할 때는 원래 공식에서 *10을 해주어야합니다.
위 그림처럼 우리가 11이라고 보는 거는 사실 뒤에 0-9가 붙은 110, 111, 112, 113, 114, ... 가 한 덩어리로 되어있다고 보는 겁니다.
마찬가지로 백의 자리에 위치한 0-9의 개수를 구할 때는 원래 공식에서 *100을 해주면 됩니다.

소스 코드

answer = [0] * 10  # 0~9 각 숫자의 총 등장 횟수를 담을 배열

start = 1  # 왼쪽 포인터: 아직 세지 않은 최소 숫자
end = int(input())    # 오른쪽 포인터: 아직 세지 않은 최대 숫자(입력 N)
ten = 1  # 현재 바라보는 자릿값(일=1, 십=10, 백=100, ...)

# 숫자 n이 지금 바라보는 자릿값(ten=1,10,100,...)에서
# '접두사'로서 기여하는 고정 등장 횟수를 answer에 더한다.
# 예를들어 calc(12345, 1)은 answer[5], answer[4], ... answer[1]에 +1
# +ten을 하는 이유는 현재 자리 아래쪽에는 항상 ten가지(0..ten-1)의 조합이 깔리므로,
# 그 자리의 같은 숫자 d가 블록 안에서 정확히 ten번 등장하기 때문.
def calc(n, ten):
    while n > 0:
        answer[n % 10] += ten
        n //= 10

# 바깥 while 한 바퀴 = 자릿값 'ten' 하나를 완전히 처리
while start <= end:
    # [1] 왼쪽 모서리 정리: start를 '...0'으로 맞출 때까지 개별 처리
    while start % 10 != 0 and start <= end:
        calc(start, ten)
        start += 1
    if start > end: break  # 다 끝나면 종료

    # [2] 오른쪽 모서리 정리: end를 '...9'로 맞출 때까지 개별 처리
    while end % 10 != 9 and start <= end:
        calc(end, ten)
        end -= 1

    # 여기까지 오면 [start, end]는 현재 자리에서
    # 정확히 '...0 ~ ...9'가 반복되는 '완전 주기 구간'이 됨.

    # [3] 가운데 완전 주기 한 번에 더하기
    # cnt = 현재 자리에서 서로 다른 '접두사' 개수
    # (접두사 하나마다 0~9 각 숫자가 하위 ten가지와 결합하므로
    # 각 숫자가 정확히 'ten'번씩 등장)
    cnt = (end // 10) - (start) // 10 + 1
    for d in range(0, 10):
        answer[d] += cnt * ten

    # [4] 한 자리 올림: 현재 자리 처리를 끝냈으니 윗자리로 이동
    start //= 10
    end //= 10
    ten *= 10

# 결과 출력
for d in range(0, 10):
    print(answer[d], end=' ')

저 역시 이해가 쉽지않아서 주석을 정말 자세히 작성했습니다.
주석 중 '접두사'라는 의미는 앞에서 설명한 십의 자리에 위치한 0-9의 개수를 구할 때는 원래 공식에서 *10, 백의 자리는 *100 을 해야한다는 것과 같은 의미입니다.

📚 새롭게 알게된 내용

사실 N=9, 99, 999, 9999 같은 수일 때는 다음과 같은 규칙이 있습니다.

이러한 규칙을 이용해서 내가 찾는 수를 000...0 부터 x999..9 까지의 범위로 좁히는 방법을 반복해서 푸는 풀이도 있습니다. 아래 링크를 참고하세요!
https://dorianyellow.tistory.com/120

[hyeokbini]

뭔가 될 것 같은데 안 돼서 아쉽네요. 1시간정도 고민해봤는데 결국 로직 정리 자체부터 실패하고 풀이를 찾아봤습니다. 풀이를 보니 실패했던 게 납득이 되기도 하네요...

참고 풀이 링크

문혁님이 가져와주신 풀이는 기준점을 직접 늘려서 xx..0 ~ xx..9로 맞춘 다음 카운팅을 하는 방식이라면, 이분 풀이는 아예 0부터 시작하고 9에서 끝나도록 반복문을 구성하되, 현재 자릿수의 숫자 왼쪽 / 오른쪽을 따로 카운팅하는 방식인 것 같습니다. 두 풀이 모두 결국 기준점 단위로 한 열을 살펴본다 라는 아이디어는 비슷한 것 같아요.

언젠가 다시 풀어보고 싶기도 하고, 답만 보고 이해한 문제인 것 같아서 코드 제출은 하지 않았습니다. 푸시느라 고생하셨어요! 😄

[Seol-Munhyeok]

다른 풀이가 있어서 추가합니다.
이 문제를 단순한 방법으로 풀면 대략 시간 복잡도가 $O(N)$ 인데 이 경우 $10^8$까지는 깡 구현으로 풀립니다.
또한 1e8, 2e8, … 1e9 같은 특징적인 수에 대해서는 규칙성이 있으므로, 이 경우는 전부 하드코딩으로 작성하여 미리 값(cnt)을 넣어 두고, 그 뒤 꼬리 구간만 마저 세는 방식으로도 풀 수 있습니다.

def solve(n: int):
    x = 1
    s = 1
    cnt = [0] * 10

    if n == 1_000_000_000:
        x = 10
        s = 1_000_000_001
        cnt = [788888898, 900000001, 900000000, 900000000, 900000000,
               900000000, 900000000, 900000000, 900000000, 900000000]
    elif n >= 900_000_000:
        x = 9
        s = 900_000_001
        cnt = [708888897, 820000000, 820000000, 820000000, 820000000,
               820000000, 820000000, 820000000, 820000000, 720000001]
    elif n >= 800_000_000:
        x = 9
        s = 800_000_001
        cnt = [628888897, 740000000, 740000000, 740000000, 740000000,
               740000000, 740000000, 740000000, 640000001, 640000000]
    elif n >= 700_000_000:
        x = 9
        s = 700_000_001
        cnt = [548888897, 660000000, 660000000, 660000000, 660000000,
               660000000, 660000000, 560000001, 560000000, 560000000]
    elif n >= 600_000_000:
        x = 9
        s = 600_000_001
        cnt = [468888897, 580000000, 580000000, 580000000, 580000000,
               580000000, 480000001, 480000000, 480000000, 480000000]
    elif n >= 500_000_000:
        x = 9
        s = 500_000_001
        cnt = [388888897, 500000000, 500000000, 500000000, 500000000,
               400000001, 400000000, 400000000, 400000000, 400000000]
    elif n >= 400_000_000:
        x = 9
        s = 400_000_001
        cnt = [308888897, 420000000, 420000000, 420000000, 320000001,
               320000000, 320000000, 320000000, 320000000, 320000000]
    elif n >= 300_000_000:
        x = 9
        s = 300_000_001
        cnt = [228888897, 340000000, 340000000, 240000001, 240000000,
               240000000, 240000000, 240000000, 240000000, 240000000]
    elif n >= 200_000_000:
        x = 9
        s = 200_000_001
        cnt = [148888897, 260000000, 160000001, 160000000, 160000000,
               160000000, 160000000, 160000000, 160000000, 160000000]
    elif n >= 100_000_000:
        x = 9
        s = 100_000_001
        cnt = [68888897, 80000001, 80000000, 80000000, 80000000,
               80000000, 80000000, 80000000, 80000000, 80000000]

    for i in range(s, n + 1):
        if i in (10, 100, 1000, 10000, 100000,
                 1000000, 10000000, 100000000, 1000000000):
            x += 1
        b = i
        for _ in range(x):
            cnt[b % 10] += 1
            b //= 10

    return cnt


# 실행 예시
n = int(input().strip())
result = solve(n)
print(*result)

무려 4초나 걸리지만... 아무튼 풀리긴 풀립니다. 이런 방식을 런타임 전의 전처리라고 한다고 합니다.
미리 하드코딩으로 처리할 수 있는 부분은 처리하고, 나머지 부분만 계산한다는 아이디어를 얻어가시면 좋을 거 같습니다.

[flydongwoo]

너무 어렵네요 ㅜㅜ 지선생님 도움 받아 양 끝을 조정해 예외를 처리하고, 가운데 구간은 자리수 반복 패턴을 이용해 한 번에 카운트하는 방식으로 문제를 풀었습니다.

책 페이지

#include <iostream>
#include <vector>
using namespace std;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    long long N;
    cin >> N;

    vector<long long> cnt(10, 0);

    long long a = 1;
    long long b = N;
    long long digit = 1;

    while (a <= b) {
        while (a % 10 != 0 && a <= b) {
            long long x = a;
            for ( ; x > 0; x /= 10) {
                cnt[x % 10] += digit;
            }
            a++;
        }
        if (a > b) {
            break;
        }
        while (b % 10 != 9 && a <= b) {
            long long x = b;
            for ( ; x > 0; x /= 10) {
                cnt[x % 10] += digit;
            }
            b--;
        }
        long long groups = (b / 10 - a / 10 + 1);
        for (int d = 0; d < 10; d++) {
            cnt[d] += groups * digit;
        }
        a /= 10;
        b /= 10;
        digit *= 10;
    }

    for (int d = 0; d < 10; d++) {
        cout << cnt[d];
        if (d < 9) {
            cout << ' ';
        }
    }
    cout << endl;

    return 0;
}

문제 푸느라 고생 많으셨습니다~!