-
[Algorithm] ์ฌ๋ผ์ด๋ฉ ์๋์ฐAlgorithm 2023. 5. 9. 09:14
์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋?
๊ณ ์ ๋ ๊ธธ์ด์ 2๊ฐ์ ํฌ์ธํฐ (์ปค์)๋ฅผ ๊ฐ์ด ์์ง์ด๋ฉด์ O(N)์ ๋ฐฐ์ด์ ํ์ํ๋ ํ ํฌ๋
N๊ฐ์ ์์๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ด ์๊ณ , W์ ๋์ด๋ฅผ ๊ฐ๋ ์ฐฝ๋ฌธ์ด ์๋ค๊ณ ๊ฐ์ ํ์. (N, W๋ ๊ณ ์ ๋ ์์)
- ์ฐฝ๋ฌธ์ ์ผ์ชฝ๋ถํฐ ์์ํด์ ํ ์นธ์ฉ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋์์ผ์ผ ํ๋ค.
- ์ด๋์ํฌ ๋๋ง๋ค ์ฐฝ๋ฌธ ์์์์ ์ ๋ณด ์ ์ถ (ex. ํฉ)์ด ํ์ํ๋ค.
์๋ ์์๋ ์์์ ๊ฐ์๊ฐ 10๊ฐ์ด๋ฉด์ ์๋์ฐ ํฌ๊ธฐ๊ฐ 3์ผ ๋์ด๋ค.




๋ฌธ์ ์์ ๋๋๊ณ ์ฌ๋ผ์ด๋ฉ ์๋์ฐ๋ผ๊ณ ์ธ๊ธํ ๋๋ ์์ง๋ง, ๋ช๋ช ๋ฌธ์ ๋ค์ ์ธ๊ธ ์์ด ์ฌ๋ผ์ด๋ฉ ์๋์ฐ ํ ํฌ๋์ ์จ์ผํ ๋๊ฐ ์๋ค.
๐ก ์ฌ๋ผ์ด๋ฉ ์๋์ฐ์ ๊ธฐ๋ณธ ์์ด๋์ด

- ์๋์ฐ๋ฅผ ํ ์นธ ์ฎ๊ธฐ๋ฉด (W-1)์นธ์ ๊ฒน์น๋ค.
- ์ด์ ์ ๋ด๊ฐ ๊ตฌํด์ผ ํ๋ ์ฐฝ๋ฌธ์ ํํ์ ๋ค์ ์ํ ์ฌ์ด์์ ์ค๋ณต๋ ์ ๋ณด๊ฐ W-1๊ฐ ์์ผ๋ฏ๋ก ์ด๋ฅผ ์ต๋ํ ํ์ฉํ์!
์๋๋๋ก๋ผ๋ฉด, ์๋์ฐ๋ฅผ ์ฎ๊ธธ ๋๋ง๋ค 3๊ฐ์ ์ซ์๋ฅผ ์ผ์ผํ ๋ํด์ผ ํ๋ค.
๊ทธ๋ ๊ฒ ํ์ง ์๊ณ , ๊ฒน์น๋ ๊ตฌ๊ฐ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ์ต๋ํ ์ฌ์ฉํ๋๋ก ํ์.
์ด๋ ๊ฒ ํ๋ฉด O(1)๋ง์ ๋๋ฒ์งธ ์๋์ฐ์ ๋ํ ๊ฒฐ๊ณผ๋ฅผ ์ ์ ์๋ค.

๊ธฐ์กด์๋ ๋ชจ๋ ์๋์ฐ๋ง๋ค O(W)์ ํฉ์ ๊ตฌํด์ ์ ์ฒด๊ฐ O(NW)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ก๋ค.
์ฌ๋ผ์ด๋ฉ ์๋์ฐ ์์ด๋์ด๋ฅผ ์ ์ฉํ๋ฉด,
๋งจ ์ฒ์ ์ฐฝ๋ฌธ์ ๋ํด์๋ง O(W)์ด๊ณ , ์ดํ์ ํ ์นธ์ฉ ๋ฐ ๋์๋ O(1)์ ๊ตฌ๊ฐ ํฉ์ ๊ตฌํ ์ ์๋ค.
๊ฒฐ๊ตญ ์ ์ฒด ์๊ฐ ๋ณต์ก๋๋ O(N)์ด ๋๋ค.
์์) ์ฐ์๋ 3๊ฐ์ ํฉ ์ค ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ ์์ฑํ๊ธฐ
7๊ฐ์ a0, a1, a2, … , a6์ผ๋ก ์ด๋ฃจ์ด์ง ์์ด์ด ์๋ค. ์ด ์์ด์์ ์ฐ์๋ 3๊ฐ์ ๊ฐ์ ํฉ ์ค ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.

์ด๋ฅผ ์์ ํ์์ผ๋ก ํผ๋ค๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
int answer = 0; for (int i = 0; i <= n - m; i++) { int sum = 0; for (int j = 0; j < m; j++) { sum += a[i + j]; answer = max(answer, sum); } }์๊ฐ ๋ณต์ก๋๋ N๊ฐ์ ์์ด์์ ์ฐ์๋ M๊ฐ์ ๊ฐ ์ค ์ต๋๊ฐ์ ์ฐพ์ ๊ฒฝ์ฐ๋ผ๋ฉด O(NM)์ด๋ค.
์ฌ๋ผ์ด๋ฉ ์๋์ฐ ํ๋ ๋ฐฉ๋ฒ
- ์๋์ฐ์ ์ฌ์ด์ฆ๋ฅผ ์ ํ๋ค.
- ์ฒซ๋ฒ์งธ ์๋์ฐ์์ ๊ฐ์ ๊ณ์ฐํ๋ค.
- ์ฒซ๋ฒ์งธ ๊ณ์ฐ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ์๋์ฐ๋ฅผ ์ฎ๊ฒจ๊ฐ๋ฉฐ ๊ฐ์ ๊ฐฑ์ ํ๋ค.
์ ๋ฐฉ๋ฒ์ ์์ ์์ ์ ์ ์ฉํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
1. ์๋์ฐ์ ์ฌ์ด์ฆ๋ฅผ ์ ํ๋ค. ⇒ ์ฐ์๋ 3๊ฐ์ ๊ฐ์ ๋ด์ผํ๋ฏ๋ก, ์๋์ฐ ํฌ๊ธฐ = 3
2. ์ฒซ๋ฒ์งธ ์๋์ฐ์์ ๊ฐ์ ๊ณ์ฐํ๋ค. ⇒ a[0] + a[1] + a[2] = 9์ด๋ค.

3. ์ฒซ๋ฒ์งธ ๊ณ์ฐ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ์๋์ฐ๋ฅผ ์ฎ๊ฒจ๊ฐ๋ฉฐ ๊ฐ์ ๊ฐฑ์ ํ๋ค.
- ํ์ฌ ๊ฐ์์ a[leftPointer]๋ฅผ ๋นผ์ฃผ๊ณ left๋ฅผ ์ฆ๊ฐ์ํจ๋ค.
- right๋ฅผ ์ฆ๊ฐ์ํจ ํ, ํ์ฌ ๊ฐ์ a[rightPointer]๋ฅผ ๋ํด์ค๋ค.
answer = max(answer, current); current -= a[leftPointer]; leftPointer += 1; rightPointer += 1; current += a[rightPointer];์์ธํ ๊ณผ์ ์ ๋ค์๊ณผ ๊ฐ๋ค.





leftPointer rightPointer a[leftPointer] + a[rightPointer] 0 2 9 1 3 13 2 4 10 3 5 13 4 6 7 5 7 ์ข ๋ฃ! ์๊ฐ ๋ณต์ก๋ ๋ถ์
์์์ ๊ฐ์๊ฐ n๊ฐ์ธ ๋ฐฐ์ด์์ ์๋์ฐ์ ํฌ๊ธฐ๊ฐ m์ผ ๋, rightPointer๊ฐ m-1๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ n๋ฒ์งธ ์ธ๋ฑ์ค๊น์ง ์์ง์ธ๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ O(N-M)์ด๊ณ , ๋ณดํต N > M์ด๋ฏ๋ก O(N)์ด๋ผ๊ณ ํ๋ค.
int leftPointer = 0; int rightPointer = m - 1; int answer = 0; int current = 0; while (rightPointer < N) { answer = max(answer, current); current -= a[leftPointer]; leftPointer += 1; rightPointer += 1; current += a[rightPointer]; }ํฌํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ๊ณผ์ ์ฐจ์ด
- ํฌํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ → ๊ตฌ๊ฐ์ด ๊ฐ๋ณ์ ๊ธธ์ด
- ์ฌ๋ผ์ด๋ฉ ์๋์ฐ → ๊ตฌ๊ฐ์ด ๊ณ ์ ์ ๊ธธ์ด
๊ด๋ จ ๋ฌธ์ ๋ค
์ถ๊ฐ๋ก ์ ๋ฐ์ดํธ ์์ ~!
[์๊ณ ๋ฆฌ์ฆ ๊ฐ์] Sliding Window, ์ฌ๋ผ์ด๋ฉ ์๋์ฐ
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] ์ฌ๊ท (0) 2023.05.05 [Algorithm] ๋์ ํฉ (0) 2023.05.04 [Algorithm] ํฌ ํฌ์ธํฐ ์๊ณ ๋ฆฌ์ฆ (Two Pointer Algorithm) (0) 2023.05.02 [Algorithm] ๋ฐฑ์ค 2003 ์๋ค์ ํฉ 2 (C++) (0) 2023.05.01 [Algorithm] BFS & DFS (0) 2022.03.15