123 × 456 = ?
ํ์์ ์ผ์์ ์ผ๋ก ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ ๋ถ์์ ์ผ๋ก ํ์ด์จ๋ณด๋ฉด ์ด๋ ๋ค.
์ฐ๋ฆฌ๋ ํ์ ํ ์๋ฆฌ์ 0๋ถํฐ 9๊น์ง์ ์ซ์๋ง ์ฌ์ฉํ๋ ์ญ์ง๋ฒ์ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์, ๊ฐ ์๋ฆฌ๋ณ๋ก ์ญ์ ์๋ฆฌ ์๋ ๋ค์ ์นธ์ผ๋ก ๋๊ฒจ์ค๋ค(์๋ฅผ ๋ค์ด 10์ ์๋ฆฌ 27์ (20 + 7)์ด๋ฏ๋ก 100์ ์๋ฆฌ๋ก 2๋ฅผ ๋๊ฒจ์ค๋ค).
(4 * 10000) + (13 * 1000) + (28 * 100) + (27 * 10) + (18 * 1)
= (5 * 10000) + (6 * 1000) + (0 * 100) + (8 * 10) + (8 * 1)
= 56088
์ต์ข
์ ์ผ๋ก ๊ฐ์ ์ด๋ ๊ฒ ๊ณ์ฐํด ๋ผ ์์๋ค.
456์ ๊ฐฏ์๋งํผ, 123์ ๊ฐ ์์(1, 2, 3)๊ณผ ํ ๋ฒ์ฉ ๊ณฑ์
์ฐ์ฐ์ ํด์ผํจ์ ์ ์์๋ค.
๋ฐ๋ผ์ ์ ํต์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก๋ ๋ง์ฝ (n ์๋ฆฟ์) × (n ์๋ฆฟ์)์ ์ํฉ์์๋ n2 ๋ฒ์ ๊ณฑ์
์ ์ํํด์ผ ํ๋ค.
โ
์นด๋ผ์ถ๋ฐ์ ๋น ๋ฅธ ๊ณฑ์
์นด๋ผ์ถ๋ฐ(Karatsuba)๋ ๋ถํ ์ ๋ณต์ ์ด์ฉํด, ์ด๋ฌํ ๊ณผ์ ์ ํจ์จ์ ํฌ๊ฒ ๊ฐ์ ํ ์ ์์์ ๋ณด์๋ค.
์๋ฅผ ๋ค์ด,1234 × 5678 ์ ๊ณ์ฐ์ ์นด๋ผ์ถ๋ฐ์ ๋น ๋ฅธ ๊ณฑ์
์ ์ด์ฉํด๋ณด์.
1234 = 12 × 100 + 34,
5678 = 56 × 100 + 78๋ก ๋๋ ์ ์๋ค.โ
1234 × 5678
= (12 × 100 + 34) × (56 × 100 + 78)
= (12 × 56) × 10000 + (12 × 78 + 34 × 56) × 100 + 34 × 78โ
์ฌ๊ธฐ์ 10์ ๊ฑฐ๋ญ์ ๊ณฑ์ ๊ณ์๋ฅผ z0, z1, z2๋ก ๋๋๋ค.
z0 = 34 × 78
z1 = 12 × 78 + 34 × 56
z2 = 12 × 56โ
z1์ ๋ค์ ์ฐ๋ฉด ๋ค์๊ณผ ๊ฐ์ด ์ธ ์ ์๋ค. ๊ณ์ฐ ๊ฒฐ๊ณผ๊ฐ ๊ฐ์์ง๋ง ํ์ธํด๋ณด์.
z1 = (34 + 12) × (56 + 78) - z0 - z2
์ด์ z0, z1, z2๋ฅผ ์ด์ฉํ๋ฉด, ๋จ 3๋ฒ์ ๊ณฑ์
์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ํ ์ ์๋ค!
๊ฐ ๊ณฑ์
์ ๋ํ์ฌ ์ฌ๊ท ํธ์ถ์ ํ ๊ฒ์ด๋ฏ๋ก, 3log n ( = nlog 3)์ ํจ์จ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๊ฒ ๋๋ค!
log 3 = 0.4 ์ ๋์ด๋ฏ๋ก ํจ์ฌ ์ข์ ํจ์จ์ ๋ณด์ธ๋ค. ๋ค๋ง ์ฝ๋์ ๊ธธ์ด ์ ํฌ๊ธฐ๊ฐ ํฐ ๊ณฑ์
์์๋ง ๋ ๋น ๋ฅธ ์คํ์ ๋ณด์ธ๋ค. โ์ด๋ฅผ ์ฝ๋๋ก ๊ตฌํํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
#include <iostream>
#include <algorithm>
#include <math.h>
using namespace std;
int karatsuba(int num1, int num2) {
// ํ ์๋ฆฟ์๊ฐ ๋๋ฉด ๊ทธ๋ฅ ์ฐ์ฐ
if (num1 < 10 || num2 < 10)
return num1 * num2;
// ์ซ์๋ฅผ ๋ถํ ํ m์ ๋ ์ค ๋ ์์ ์๋ฆฟ์์ ์ ๋ฐ์ผ๋ก ์ค์
int m;
m = min((int)(log10(num1) + 1), (int)(log10(num2) + 1));
m /= 2;
// num์ high(์๋ถ๋ถ), low(๋ท๋ถ๋ถ)์ผ๋ก ๋ถํ
int high1, low1;
high1 = num1 / pow(10, m);
low1 = num1 % (int)pow(10, m);
int high2, low2;
high2 = num2 / pow(10, m);
low2 = num2 % (int)pow(10, m);
// z0, z1, z2๋ฅผ ๊ฐ๊ฐ ์ฌ๊ทํธ์ถ
int z0 = karatsuba(low1, low2);
int z1 = karatsuba((low1 + high1), (low2 + high2));
int z2 = karatsuba(high1, high2);
return (z2 * pow(10 , (m * 2)) + ((z1 - z2 - z0) * pow(10 , m)) + z0);
}
int main() {
int A, B;
cin >> A >> B;
cout << karatsuba(A, B) << endl;
return 0;
}
์๋ฃํ์ด int๋ผ์ ํฐ ์ฐ์ฐ์ ๋ถ๊ฐ๋ฅํ๊ฒ ์ง๋ง, ์๋ฆฌ๋ฅผ ๋ณด์ด๊ธฐ ์ํด ์ต๋ํ ๊ฐ๋จํ๊ฒ ๊ตฌํํ๋ค.
'๐ > ์ฝ๋ฉํ ์คํธ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ ์ ์ผ๊ฐํ (๋ฐฑ์ค, 1932) (0) | 2020.11.20 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] N-Queen (๋ฐฑ์ค, 9663) (0) | 2020.11.20 |
[์๊ณ ๋ฆฌ์ฆ] ๋ถํ ์ ๋ณต(Divide & Conquer) (0) | 2020.07.28 |
[์๊ณ ๋ฆฌ์ฆ] ์์ ํ์(CLOCKSYNC) (0) | 2020.07.28 |
[์๊ณ ๋ฆฌ์ฆ] ์์ ํ์(BOARDCOVER) (0) | 2020.07.28 |