๐ 1. ๋ฌธ์ ์ค๋ช

์
์ถ๋ ฅ ์
balls | share | result |
3 | 2 | 3 |
5 | 3 | 10 |
์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
- ์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 3๊ฐ ์ค 2๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 3์ ๋๋ค.

์
์ถ๋ ฅ ์ #2
- ์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 5๊ฐ ์ค 3๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 10์ ๋๋ค.
๐ก 2. ์ ๊ทผ๋ฐฉ์
์ด ๋ฌธ์ ๋ ์กฐํฉ(combination) ๋ฌธ์ ์ด๋ค. ์กฐํฉ์ ๋ฐฐ์ด ์ง ์ค๋๋์ ๊ฒ์ํ๋ฉด์ ํ์๋ค.
์ฃผ์ด์ง balls๊ฐ์ ๊ตฌ์ฌ ์ค์์ share๊ฐ์ ๊ตฌ์ฌ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
์กฐํฉ์ ๊ตฌํ๋ ๊ณต์์ด ๋ฌธ์ ํํธ๋ก ์ฃผ์ด์ ธ ์๋ค.

- n์ ์ ์ฒด ๊ฐ์ (balls)
- m๋ ๊ณ ๋ฅผ ๊ฐ์ (share)
์ด๊ฒ์ ๋ฌธ์ ์์ ์ฃผ์ด์ง ๋งค๊ฐ๋ณ์๋ก ๋ณํํ๋ฉด ์๋์ ๊ฐ๋ค.

ํฉํ ๋ฆฌ์ผ ํจ์๋ฅผ ๋ง๋ค์ด์ ๊ณต์์ ์ฝ๋๋ก ๊ตฌํํ๋ฉด ๋๋ค. ์กฐํฉ ๊ณ์ฐ์ ํ ๋ ํฉํ ๋ฆฌ์ผ ๊ฐ์ด ์ปค์ง๋ฉด ๋งค์ฐ ํฐ ์๊ฐ ๋์์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ int๋ก ์ง์ ๊ณ์ฐํ์ง ์๊ณ BigInteger๋ฅผ ์ฌ์ฉํ๋ค.
import java.math.BigInteger;
class Solution {
public int solution(int balls, int share) {
return (int) (factorial(balls).divide(factorial(share).multiply(factorial(balls - share))).longValue());
}
// ํฉํ ๋ฆฌ์ผ์ ๊ณ์ฐํ๋ ํจ์
public BigInteger factorial(int n) {
BigInteger result = BigInteger.ONE;
for (int i = 1; i <= n; i++) {
result = result.multiply(BigInteger.valueOf(i));
}
return result;
}
}
ํ ํธ, ์ด ๋ฌธ์ ๋ ์์ด ๊ณต์์ ์กฐํฉ๊ณต์์ผ๋ก ๋ฐ๊พธ๋ ๋ฒ์ ์จ๋ ๋๋ค.
์์ด๊ณผ ์กฐํฉ์ ์ฐจ์ด
- ์กฐํฉ(Combination) ์ด๋ "์์ ์๊ด์์ด ๋ช ๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ"
- ์์ด(Permutaion) ์ด๋ "์์๋ฅผ ๊ณ ๋ คํด์ ๋ช ๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ"
โญ ์์ด(Permutation) ๊ณต์์ ์กฐํฉ(Combination) ๊ณต์์ผ๋ก ๋ณํํ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ์ฝ๊ฒ ํ ์ ์๋ค.


= ์กฐํฉ์ ์์ด์ ๋จผ์ ๊ตฌํ ํ, ์ค๋ณต์ผ๋ก ์ธ์ด์ง ๊ฒฝ์ฐ๋ฅผ ๋๋์ด์ ๊ตฌํ ์ ์๋ค.
์๋ํ๋ฉด ์กฐํฉ ๊ณต์์ ๋ถ๋ชจ์ r!์ด ํ ๋ฒ ๋ ๋ค์ด๊ฐ๋ฏ๋ก ์์ด ๊ณต์์ r!๋ก ํ๋ฒ ๋ ๋๋๋ฉด ์กฐํฉ ๊ณ์ฐ์์ด ๋๋ค.
๐ ์๋ฅผ ๋ค์ด์ ์
์ถ๋ ฅ ์ #2 ์ฒ๋ผ 5๊ฐ์ค 3๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ ๋ํด ์๊ฐ ํด ๋ณด์.


์ฌ๊ธฐ๊น์ง๊ฐ `answer *= (balls - (share - i));` ๋ถ๋ถ์ด๋ค.
- 1ํ์ฐจ (i = 1) โ answer = 5
- 2ํ์ฐจ (i = 2) โ answer = 5 ร 4 = 20
- 3ํ์ฐจ (i = 3) โ answer = 5 ร 4 ร 3 = 60
โ๏ธ ์ฆ ์ฌ๊ธฐ๊น์ง ์์ด ๊ณต์์ผ๋ก ๊ณ์ฐํ ๊ฒฐ๊ณผ๋ 60์ด๋ค. ์ด๊ฒ์ ์กฐํฉ์ผ๋ก ๋ฐ๊พธ๋ ค๋ฉด ์ค๋ณต๋ ๊ฒฝ์ฐ(3!)๋ก ๋๋๋ค. ๊ทธ๋ผ ๊ฒฐ๊ณผ๊ฐ Combination ๊ฒฐ๊ณผ๊ฐ์ธ 10์ ์ป์ ์ ์๋ค.

๐จโ๐ป 3. ์ ๋ต์ฝ๋
class Solution {
public int solution(int balls, int share) {
int answer = 1;
for(int i = 1; i <= share; i++) {
answer *= balls - (share - i); // ๋ถ์
answer /= i; // ๋ถ๋ชจ
}
return answer;
}
}
ํ๋ ธ๋ ใ
ใ
์ค๋์ ์๊ณ ๋ด์ผ ๋ค์ ํ๊ธฐ



๐ฆ4. ์ค๋ต์ ๋ฆฌ
์ด ๋ฌธ์ ์์ `balls`์ `share`์ ๋ฒ์๊ฐ 1๋ถํฐ 30 ์ฌ์ด์ฌ์ ๋น๊ต์ ์์ ์ซ์๋ก ๋ณด์ผ ์ ์์ง๋ง, ์กฐํฉ ๊ณ์ฐ ๊ณผ์ ์์ ์ ์ ์ค๋ฒํ๋ก์ฐ(Integer Overflow)๊ฐ ๋ฐ์ํ์ฌ ์ ํ๋๊ฐ 100%๊ฐ ๋์ง ์๋ ๊ฒ์ด๋ค.

์๋ฅผ ๋ค์ด, `balls = 30`, `share = 15`์ธ ๊ฒฝ์ฐ

ํฉํ ๋ฆฌ์ผ์ ์ํํ๋ฉด์ ๊ณฑ์ ๊ณผ์ ์์ `answer *= (balls - (share - i))`์์ answer๊ฐ ์ ์ ์ปค์ง๊ธฐ ๋๋ฌธ์ `int(32๋นํธ, ์ฝ 21์ต)` ๋ฒ์๋ฅผ ์ด๊ณผํ๋๋ฐ ์ด ๋, ์๋ฐ์ int๋ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํด๋ ์ค๋ฅ๋ฅผ ๋ด์ง ์๊ณ ์๋ชป๋ ๊ฐ์ผ๋ก ๋ณํ๋๋ค. ๋ง์ฝ ์ค๋ฒํ๋ก์ฐ๋ก ์ธํด answer ๊ฐ์ด ์๋ชป๋๋ฉด, ์ดํ answer /= i;์ ๊ณ์ฐํ ๋ ๋๋์ ์๋ ๊ฐ์ด ์ ํํ๊ฒ ๋ฐ์๋์ง ์์์ ์ ์์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์๊ฐ ์๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด long์ ์ฌ์ฉํ๊ฑฐ๋, BigInteger๋ฅผ ํ์ฉํด์ผ ํ๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ
1. int๋ฅผ long์ผ๋ก ๋ฐ๊พธ๊ธฐ
class Solution {
public long solution(int balls, int share) {
long answer = 1;
for (int i = 1; i <= share; i++) {
answer *= (balls - (share - i));
answer /= i;
}
return answer;
}
}
2. ( ์์ ํ ๋ฐฉ๋ฒ) int๋ฅผ BigInteger๋ก ๋ฐ๊พธ๊ธฐ
import java.math.BigInteger;
class Solution {
public BigInteger solution(int balls, int share) {
BigInteger answer = BigInteger.ONE;
for (int i = 1; i <= share; i++) {
answer = answer.multiply(BigInteger.valueOf(balls - (share - i)));
answer = answer.divide(BigInteger.valueOf(i));
}
return answer;
}
}
BigInteger๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ฒํ๋ก์ฐ ๊ฑฑ์ ์์ด ํฐ ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๋ค.
'Algorithm > JAVAํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๐ 1. ๋ฌธ์ ์ค๋ช

์
์ถ๋ ฅ ์
balls | share | result |
3 | 2 | 3 |
5 | 3 | 10 |
์
์ถ๋ ฅ ์ ์ค๋ช
์
์ถ๋ ฅ ์ #1
- ์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 3๊ฐ ์ค 2๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 3์ ๋๋ค.

์
์ถ๋ ฅ ์ #2
- ์๋ก ๋ค๋ฅธ ๊ตฌ์ฌ 5๊ฐ ์ค 3๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ 10์ ๋๋ค.
๐ก 2. ์ ๊ทผ๋ฐฉ์
์ด ๋ฌธ์ ๋ ์กฐํฉ(combination) ๋ฌธ์ ์ด๋ค. ์กฐํฉ์ ๋ฐฐ์ด ์ง ์ค๋๋์ ๊ฒ์ํ๋ฉด์ ํ์๋ค.
์ฃผ์ด์ง balls๊ฐ์ ๊ตฌ์ฌ ์ค์์ share๊ฐ์ ๊ตฌ์ฌ์ ๊ณ ๋ฅด๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
์กฐํฉ์ ๊ตฌํ๋ ๊ณต์์ด ๋ฌธ์ ํํธ๋ก ์ฃผ์ด์ ธ ์๋ค.

- n์ ์ ์ฒด ๊ฐ์ (balls)
- m๋ ๊ณ ๋ฅผ ๊ฐ์ (share)
์ด๊ฒ์ ๋ฌธ์ ์์ ์ฃผ์ด์ง ๋งค๊ฐ๋ณ์๋ก ๋ณํํ๋ฉด ์๋์ ๊ฐ๋ค.

ํฉํ ๋ฆฌ์ผ ํจ์๋ฅผ ๋ง๋ค์ด์ ๊ณต์์ ์ฝ๋๋ก ๊ตฌํํ๋ฉด ๋๋ค. ์กฐํฉ ๊ณ์ฐ์ ํ ๋ ํฉํ ๋ฆฌ์ผ ๊ฐ์ด ์ปค์ง๋ฉด ๋งค์ฐ ํฐ ์๊ฐ ๋์์ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ int๋ก ์ง์ ๊ณ์ฐํ์ง ์๊ณ BigInteger๋ฅผ ์ฌ์ฉํ๋ค.
import java.math.BigInteger; class Solution { public int solution(int balls, int share) { return (int) (factorial(balls).divide(factorial(share).multiply(factorial(balls - share))).longValue()); } // ํฉํ ๋ฆฌ์ผ์ ๊ณ์ฐํ๋ ํจ์ public BigInteger factorial(int n) { BigInteger result = BigInteger.ONE; for (int i = 1; i <= n; i++) { result = result.multiply(BigInteger.valueOf(i)); } return result; } }
ํ ํธ, ์ด ๋ฌธ์ ๋ ์์ด ๊ณต์์ ์กฐํฉ๊ณต์์ผ๋ก ๋ฐ๊พธ๋ ๋ฒ์ ์จ๋ ๋๋ค.
์์ด๊ณผ ์กฐํฉ์ ์ฐจ์ด
- ์กฐํฉ(Combination) ์ด๋ "์์ ์๊ด์์ด ๋ช ๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ"
- ์์ด(Permutaion) ์ด๋ "์์๋ฅผ ๊ณ ๋ คํด์ ๋ช ๊ฐ๋ฅผ ๊ณ ๋ฅด๋ ๋ฐฉ๋ฒ"
โญ ์์ด(Permutation) ๊ณต์์ ์กฐํฉ(Combination) ๊ณต์์ผ๋ก ๋ณํํ๋ฉด ์ด ๋ฌธ์ ๋ฅผ ์ฝ๊ฒ ํ ์ ์๋ค.


= ์กฐํฉ์ ์์ด์ ๋จผ์ ๊ตฌํ ํ, ์ค๋ณต์ผ๋ก ์ธ์ด์ง ๊ฒฝ์ฐ๋ฅผ ๋๋์ด์ ๊ตฌํ ์ ์๋ค.
์๋ํ๋ฉด ์กฐํฉ ๊ณต์์ ๋ถ๋ชจ์ r!์ด ํ ๋ฒ ๋ ๋ค์ด๊ฐ๋ฏ๋ก ์์ด ๊ณต์์ r!๋ก ํ๋ฒ ๋ ๋๋๋ฉด ์กฐํฉ ๊ณ์ฐ์์ด ๋๋ค.
๐ ์๋ฅผ ๋ค์ด์ ์
์ถ๋ ฅ ์ #2 ์ฒ๋ผ 5๊ฐ์ค 3๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ ๋ํด ์๊ฐ ํด ๋ณด์.


์ฌ๊ธฐ๊น์ง๊ฐ answer *= (balls - (share - i));
๋ถ๋ถ์ด๋ค.
- 1ํ์ฐจ (i = 1) โ answer = 5
- 2ํ์ฐจ (i = 2) โ answer = 5 ร 4 = 20
- 3ํ์ฐจ (i = 3) โ answer = 5 ร 4 ร 3 = 60
โ๏ธ ์ฆ ์ฌ๊ธฐ๊น์ง ์์ด ๊ณต์์ผ๋ก ๊ณ์ฐํ ๊ฒฐ๊ณผ๋ 60์ด๋ค. ์ด๊ฒ์ ์กฐํฉ์ผ๋ก ๋ฐ๊พธ๋ ค๋ฉด ์ค๋ณต๋ ๊ฒฝ์ฐ(3!)๋ก ๋๋๋ค. ๊ทธ๋ผ ๊ฒฐ๊ณผ๊ฐ Combination ๊ฒฐ๊ณผ๊ฐ์ธ 10์ ์ป์ ์ ์๋ค.

๐จโ๐ป 3. ์ ๋ต์ฝ๋
class Solution { public int solution(int balls, int share) { int answer = 1; for(int i = 1; i <= share; i++) { answer *= balls - (share - i); // ๋ถ์ answer /= i; // ๋ถ๋ชจ } return answer; } }
ํ๋ ธ๋ ใ
ใ
์ค๋์ ์๊ณ ๋ด์ผ ๋ค์ ํ๊ธฐ



๐ฆ4. ์ค๋ต์ ๋ฆฌ
์ด ๋ฌธ์ ์์ balls
์ share
์ ๋ฒ์๊ฐ 1๋ถํฐ 30 ์ฌ์ด์ฌ์ ๋น๊ต์ ์์ ์ซ์๋ก ๋ณด์ผ ์ ์์ง๋ง, ์กฐํฉ ๊ณ์ฐ ๊ณผ์ ์์ ์ ์ ์ค๋ฒํ๋ก์ฐ(Integer Overflow)๊ฐ ๋ฐ์ํ์ฌ ์ ํ๋๊ฐ 100%๊ฐ ๋์ง ์๋ ๊ฒ์ด๋ค.

์๋ฅผ ๋ค์ด, balls = 30
, share = 15
์ธ ๊ฒฝ์ฐ

ํฉํ ๋ฆฌ์ผ์ ์ํํ๋ฉด์ ๊ณฑ์
๊ณผ์ ์์ answer *= (balls - (share - i))
์์ answer๊ฐ ์ ์ ์ปค์ง๊ธฐ ๋๋ฌธ์ int(32๋นํธ, ์ฝ 21์ต)
๋ฒ์๋ฅผ ์ด๊ณผํ๋๋ฐ ์ด ๋, ์๋ฐ์ int๋ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํด๋ ์ค๋ฅ๋ฅผ ๋ด์ง ์๊ณ ์๋ชป๋ ๊ฐ์ผ๋ก ๋ณํ๋๋ค. ๋ง์ฝ ์ค๋ฒํ๋ก์ฐ๋ก ์ธํด answer ๊ฐ์ด ์๋ชป๋๋ฉด, ์ดํ answer /= i;์ ๊ณ์ฐํ ๋ ๋๋์
์๋ ๊ฐ์ด ์ ํํ๊ฒ ๋ฐ์๋์ง ์์์ ์ ์์ ์ธ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์๊ฐ ์๋ค.
์ด๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด long์ ์ฌ์ฉํ๊ฑฐ๋, BigInteger๋ฅผ ํ์ฉํด์ผ ํ๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ
1. int๋ฅผ long์ผ๋ก ๋ฐ๊พธ๊ธฐ
class Solution { public long solution(int balls, int share) { long answer = 1; for (int i = 1; i <= share; i++) { answer *= (balls - (share - i)); answer /= i; } return answer; } }
2. ( ์์ ํ ๋ฐฉ๋ฒ) int๋ฅผ BigInteger๋ก ๋ฐ๊พธ๊ธฐ
import java.math.BigInteger; class Solution { public BigInteger solution(int balls, int share) { BigInteger answer = BigInteger.ONE; for (int i = 1; i <= share; i++) { answer = answer.multiply(BigInteger.valueOf(balls - (share - i))); answer = answer.divide(BigInteger.valueOf(i)); } return answer; } }
BigInteger๋ฅผ ์ฌ์ฉํ๋ฉด ์ค๋ฒํ๋ก์ฐ ๊ฑฑ์ ์์ด ํฐ ์ ์ฐ์ฐ์ด ๊ฐ๋ฅํ๋ค.