๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
์ฝ”๋”ฉํ…Œ์ŠคํŠธ(Baekjoon)

[python] Baekjoon 1010 : ๋‹ค๋ฆฌ ๋†“๊ธฐ

by Seop๐Ÿ˜€ 2024. 3. 9.
๋ฐ˜์‘ํ˜•

๋ฌธ์ œ - Baekjoon 1010 : ๋‹ค๋ฆฌ ๋†“๊ธฐ

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

 

1010๋ฒˆ: ๋‹ค๋ฆฌ ๋†“๊ธฐ

์ž…๋ ฅ์˜ ์ฒซ ์ค„์—๋Š” ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค์˜ ๊ฐœ์ˆ˜ T๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ๊ทธ ๋‹ค์Œ ์ค„๋ถ€ํ„ฐ ๊ฐ๊ฐ์˜ ํ…Œ์ŠคํŠธ์ผ€์ด์Šค์— ๋Œ€ํ•ด ๊ฐ•์˜ ์„œ์ชฝ๊ณผ ๋™์ชฝ์— ์žˆ๋Š” ์‚ฌ์ดํŠธ์˜ ๊ฐœ์ˆ˜ ์ •์ˆ˜ N, M (0 < N ≤ M < 30)์ด ์ฃผ์–ด์ง„๋‹ค.

www.acmicpc.net

ํ•ต์‹ฌ

์„œ์ชฝ ์‚ฌ์ดํŠธ N๊ฐœ์™€ ๋™์ชฝ ์‚ฌ์ดํŠธ M๊ฐœ๋ฅผ ์—ฐ๊ฒฐํ•˜๋Š” ๋‹ค๋ฆฌ๋ฅผ ์ง€์„ ์ˆ˜ ์žˆ๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜ ๊ณ„์‚ฐ.

๋‚ด์šฉ

์ด ๋ฌธ์ œ๋Š” ๋™์ชฝ๊ณผ ์„œ์ชฝ์— ์žˆ๋Š” ์‚ฌ์ดํŠธ๋ฅผ ์—ฐ๊ฒฐํ•˜๋Š” ๋‹ค๋ฆฌ๋ฅผ ์ง€์„ ๋•Œ, ๊ฒน์น˜์ง€ ์•Š๊ฒŒ ๋‹ค๋ฆฌ๋ฅผ ์ง€์„ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ตฌํ•˜๋Š” ์กฐํ•ฉ ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค. ๋‹ค๋ฆฌ๋Š” ๊ฐ ์‚ฌ์ดํŠธ์— ์ตœ๋Œ€ ํ•œ ๊ฐœ๋งŒ ์—ฐ๊ฒฐ๋˜๋ฉฐ, ์„œ์ชฝ์˜ N๊ฐœ ์‚ฌ์ดํŠธ๋ฅผ ๋ชจ๋‘ ์‚ฌ์šฉํ•˜์—ฌ ๋™์ชฝ์˜ M๊ฐœ ์‚ฌ์ดํŠธ์™€ ์—ฐ๊ฒฐํ•ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์ฝ”๋“œ ํ™”๋ฉด - (DALLE)

์ ‘๊ทผ ๋ฐฉ๋ฒ•

์ด ๋ฌธ์ œ๋Š” ๋‹ค๋ฆฌ๋ฅผ ์ง“๋Š” ๋ฐฉ๋ฒ•์˜ ์ˆ˜๋ฅผ ๊ตฌํ•˜๋Š” ๊ฒƒ๊ณผ ๊ฐ™์œผ๋ฉฐ, ๊ฐ„๋‹จํžˆ ๋งํ•ด ์กฐํ•ฉ(combinations) ๋ฌธ์ œ์ž…๋‹ˆ๋‹ค. ์„œ์ชฝ์˜ N๊ฐœ ์‚ฌ์ดํŠธ์™€ ๋™์ชฝ์˜ M๊ฐœ ์‚ฌ์ดํŠธ๊ฐ€ ์žˆ๋‹ค๊ณ  ํ•  ๋•Œ, ๋™์ชฝ์˜ M๊ฐœ ์‚ฌ์ดํŠธ ์ค‘์—์„œ N๊ฐœ๋ฅผ ๊ณ ๋ฅด๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

ํŒฉํ† ๋ฆฌ์–ผ์„ ๊ณ„์‚ฐํ•˜๋Š” ํ•จ์ˆ˜์™€ ์กฐํ•ฉ์„ ๊ตฌํ•˜๋Š” ๊ณต์‹์„ ์‚ฌ์šฉํ•˜์—ฌ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜๋Š” ์ฃผ์–ด์ง„ ์ˆ˜์—์„œ๋ถ€ํ„ฐ 1๊นŒ์ง€ ๋ชจ๋“  ์ˆ˜๋ฅผ ๊ณฑํ•˜๋Š” ํ•จ์ˆ˜์ž…๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค์–ด, 5!=5×4×3×2×15!=5×4×3×2×1. ์กฐํ•ฉ ํ•จ์ˆ˜๋Š” ์ด ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•ด, ์ฃผ์–ด์ง„ M๊ฐœ ์ค‘ N๊ฐœ๋ฅผ ์„ ํƒํ•˜๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค.

์ฝ”๋“œ

1. ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋ฏธ์‚ฌ์šฉ

def factorial(n):
    if n == 0:
        return 1
    return n * factorial(n-1)

def combination(m, n):
    return factorial(m) // (factorial(n) * factorial(m-n))

T = int(input())  # ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค ๊ฐœ์ˆ˜
for _ in range(T):
    N, M = map(int, input().split())
    print(combination(M, N))

2. ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์‚ฌ์šฉ

from math import comb

T = int(input()) # ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค์˜ ์ˆ˜
for _ in range(T):
N, M = map(int, input().split())
print(comb(M, N))

ํ’€์ด

๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ๋ฏธ์‚ฌ์šฉ ํ’€์ด

ํŒฉํ† ๋ฆฌ์–ผ ํ•จ์ˆ˜ factorial์€ ์žฌ๊ท€๋ฅผ ์ด์šฉํ•ด ๊ตฌํ˜„ํ•ฉ๋‹ˆ๋‹ค.

์„œ์ชฝ ์‚ฌ์ดํŠธ N๊ฐœ์™€ ๋™์ชฝ ์‚ฌ์ดํŠธ M๊ฐœ๋ฅผ ์—ฐ๊ฒฐํ•˜๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋Š” C(M,N)์œผ๋กœ ๊ณ„์‚ฐํ•ฉ๋‹ˆ๋‹ค.

์žฌ๊ท€ ํ˜ธ์ถœ์„ ํ†ตํ•ด ํŒฉํ† ๋ฆฌ์–ผ์„ ๊ณ„์‚ฐํ•˜๊ณ , ์ด๋ฅผ ํ†ตํ•ด ์กฐํ•ฉ์˜ ๊ฐ’์„ ๊ตฌํ•˜์—ฌ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ ์‚ฌ์šฉ ํ’€์ด

`comb(M, N)` ํ•จ์ˆ˜๋Š” M๊ฐœ ์ค‘์—์„œ N๊ฐœ๋ฅผ ์„ ํƒํ•˜๋Š” ์กฐํ•ฉ์˜ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค์— ๋Œ€ํ•ด ์ฃผ์–ด์ง„ N๊ณผ M์— ๋Œ€ํ•œ ์กฐํ•ฉ์˜ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•˜์—ฌ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

 

์ฑ…์ฝ๋Š” ์‚ฌ๋žŒ

์ฐธ๊ณ  ์ž๋ฃŒ

- ํŒŒ์ด์ฌ ์กฐํ•ฉ ๊ณ„์‚ฐ ๋ฐฉ๋ฒ•: [Python math.comb](https://docs.python.org/3/library/math.html#math.comb))
- ์กฐํ•ฉ๊ณผ ์ˆœ์—ด์˜ ๊ธฐ๋ณธ ๊ฐœ๋…: [Combinations and Permutations](https://en.wikipedia.org/wiki/Combination))

๋Œ“๊ธ€