์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | ||||
4 | 5 | 6 | 7 | 8 | 9 | 10 |
11 | 12 | 13 | 14 | 15 | 16 | 17 |
18 | 19 | 20 | 21 | 22 | 23 | 24 |
25 | 26 | 27 | 28 | 29 | 30 | 31 |
- ๋ฐ์ผ๋ฆฌ์ฝ๋ฉ
- HTML
- spring data jpa
- ๊นํ๋ธ
- java
- ์ธํ ๋ฆฌ์ ์ด
- ํ๊ณ
- ์ ๋ค๋ฆญ์ค
- Spring Security
- ์๋ฐ
- ์๋ฃ๊ตฌ์กฐ
- Publishing
- ๊ณ์ฐ๊ธฐ๋ง๋ค๊ธฐ
- ๋ฐฑ์๋
- ๋ฌธ์์ด๋ค์ง๊ธฐ
- ๋ฐฑ์ค์๊ณ ๋ฆฌ์ฆ
- Spring Data JDBC
- FilterChain
- CLI๋ช ๋ น์ด
- CSS
- ์ปฌ๋ ์ ํ๋ ์์ํฌ
- ์ฒซ๊ธ์๋๋ฌธ์
- ์คํ๋ง
- testing
- ๋ถํธ์บ ํ
- ๊ทธ๋ฆฌ๋
- ๊ฑฐ๋ญ์ ๊ณฑ
- fibonacci
- ์๊ณ ๋ฆฌ์ฆ
- ํ์ดํ๋ก๊ทธ๋๋ฐ
- Today
- Total
๋์ ๋ชจ์
026 | Greedy, Brute-Force, Binary Search Algorithm ๋ณธ๋ฌธ
๐ Greedy Algorithm
- ์ ํ์ ์๊ฐ๋ง๋ค ๋น์ฅ ๋์์ ๋ณด์ด๋ ์ต์ ์ ์ํฉ์ผ๋ก ์ต์ข ์ ์ธ ํด๋ต์ ๋๋ฌํ๋ ๋ฐฉ๋ฒ
- ์ ํ ์ ์ฐจ(Selection Procedure): ํ์ฌ ์ํ์์์ ์ต์ ์ ํด๋ต์ ์ ํ
- ์ ์ ์ฑ ๊ฒ์ฌ(Feasibility Check): ์ ํ๋ ํด๊ฐ ๋ฌธ์ ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ๊ฒ์ฌ
- ํด๋ต ๊ฒ์ฌ(Solution Check): ์๋์ ๋ฌธ์ ๊ฐ ํด๊ฒฐ๋์๋์ง ๊ฒ์ฌํ๊ณ , ํด๊ฒฐ๋์ง ์์๋ค๋ฉด ์ ํ ์ ์ฐจ๋ก ๋์๊ฐ ์์ ๊ณผ์ ๋ฐ๋ณต
๐ค ํ์ ์๊ณ ๋ฆฌ์ฆ ์กฐ๊ฑด
- ํ์์ ์ ํ ์์ฑ(Greedy Choice Property): ์์ ์ ํ์ด ์ดํ์ ์ ํ์ ์ํฅ์ ์ฃผ์ง ์์
- ์ต์ ๋ถ๋ถ ๊ตฌ์กฐ(Optimal Substructure): ๋ฌธ์ ์ ๋ํ ์ต์ข ํด๊ฒฐ ๋ฐฉ๋ฒ์, ๋ถ๋ถ ๋ฌธ์ ์ ๋ํ ์ต์ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌ์ฑ
⇒ ํญ์ ์ต์ ์ ๊ฒฐ๊ณผ๋ฅผ ๋์ถํ๋ ๊ฒ์ ์๋์ง๋ง, ์ด๋ ์ ๋ ์ต์ ์ ๊ทผ์ฌํ ๊ฐ์ ๋น ๋ฅด๊ฒ ๋์ถํ ์ ์๋ ์ฅ์ ๋๋ฌธ์ ํ์ ์๊ณ ๋ฆฌ์ฆ์ ๊ทผ์ฌ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์ฌ์ฉํ ์ ์์
๐ Brute-Force Algorithm
- ๋ชจ๋ ์๊ณ ๋ฆฌ์ฆ์ ์์์ ์ผ๋ก, ๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์๋ํ๋ ๋งํผ ์ง๊ด์ ์ด๊ณ ๋ช ํํ์ง๋ง, ์ ๋ ฅ๊ฐ์ด ํด์๋ก ์ค๋ ๊ฑธ๋ฆผ
- ์ํธํ์์ Brute Force Attack: ํน์ ํ ์ํธ๋ฅผ ํ๊ธฐ ์ํด์ ๋ชจ๋ ๊ฐ์ ๋์
ํ๋ ๋ฐฉ๋ฒ
- ์๋ง์ ์ํ์ฐฉ์ค๋ฅผ ํตํด ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ฅผ ํดํนํ๋ ๋ฐฉ๋ฒ์ผ๋ก, ์ฌ๋ฐ๋ฅธ ์กฐํฉ์ ์ฐพ์ ๋๊น์ง ๋ค์ํ ์กฐํฉ์ ์๋
- ๋ฌด์ฐจ๋ณ ๋์ ๊ณต๊ฒฉ์ด ๋ค๋ฅธ ํดํน ๋ฐฉ๋ฒ๊ณผ ๋ค๋ฅธ ์ ์ ์ง๋ฅํ ์ ๋ต์ ์ฌ์ฉํ์ง ์์
๐ค ๋ฌด์ฐจ๋ณ ๋์ ๋ฐฉ๋ฒ
- ์ปดํจํฐ ์ฑ๋ฅ์๋ง ์์กดํ์ฌ ๋ชจ๋ ๊ฐ๋ฅ์ฑ์ ์๋ํ์ฌ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ
- Brute Force๋ ๊ณต๊ฐ๋ณต์ก๋์ ์๊ฐ๋ณต์ก๋์ ์์๋ฅผ ๊ณ ๋ คํ์ง ์๊ณ ์ต์ ์ ์๋๋ฆฌ์ค๋ฅผ ์ทจํ๋๋ผ๋ ์๋ฃจ์ ์ ์ฐพ์ผ๋ ค๊ณ ํ๋ ๋ฐฉ๋ฒ ์ด๊ธฐ ๋๋ฌธ์ ์ต์ ์ ์๋ฃจ์ ์ด ์๋
๐ค When Using of the Brute-Force Algorithm
- ํ๋ก์ธ์ค ์๋๋ฅผ ๋์ด๋๋ฐ ์ฌ์ฉํ ์ ์๋ ๋ค๋ฅธ ์๊ณ ๋ฆฌ์ฆ์ด ์์ ๋
- ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ฌ๋ฌ ์๋ฃจ์ ์ด ์๊ณ ๊ฐ ์๋ฃจ์ ์ ํ์ธํด์ผ ํ ๋
- ๋ฌธ์ ์ ๊ท๋ชจ๊ฐ ํ์ฌ ์์์ผ๋ก ์ถฉ๋ถํ ์ปค๋ฒ๊ฐ ๊ฐ๋ฅํ ๋
⇒ Brute Force Algorithm์ ๋ฌธ์ ์ ๋ ์ ์ ํ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ฐพ๊ธฐ ์ ์ ์๋ํ๋ ๋ฐฉ๋ฒ์ด์ง๋ง ๋ฐ์ดํฐ์ ๋ฒ์๊ฐ ์ปค์ง์๋ก ๋นํจ์จ์ ์ด๋ฏ๋ก, ํ๋ก์ ํธ์ ๊ท๋ชจ๊ฐ ์ปค์ง๋ค๋ฉด ๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํด์ผ ํจ
๐ค Limit of the Brute Force Algorithm
Brute Force Algorithm์ ๋ฌธ์ ์ ๋ณต์ก๋์ ๋งค์ฐ ๋ฏผ๊ฐํ ๋จ์ ์ ๊ฐ์ง๊ณ ์์ด์, ๋ฌธ์ ๊ฐ ๋ณต์กํด์ง์๋ก ๊ธฐํ๊ธ์์ ์ผ๋ก ๋ง์ ์์์ ํ์๋ก ํ๋ ๋นํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด ๋ ์ ์์ (์ฌ๊ธฐ์ ์์์ ์๊ฐ์ด ๋ ์๋, ์ปดํจํ ์์์ด ๋ ์๋ ์์). ๋ง์ฝ ์ด๋ฅผ ๋ฒ์ด๋ ๊ฒฝ์ฐ๋ ์ ํ๋๋ฅผ ์กฐ๊ธ ํฌ์ํ๊ณ ๋ ํจ์จ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉ
๐ค Where to Use Binary Search Algorithm
๐ซ ์์ฐจ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ(Sequential Search)
- ๋ฐฐ์ด ์์ ํน์ ๊ฐ์ด ์กด์ฌํ๋์ง ๊ฒ์ํ ๋ ์ธ๋ฑ์ค 0๋ถํฐ ๋ง์ง๋ง ์ธ๋ฑ์ค๊น์ง ์ฐจ๋ก๋๋ก ๊ฒ์
public boolean SequentialSearch2(int[] arr, int K) {
int n = arr.length;
boolean result = false;
for(int i = 0; i < n; i++) {
if(arr[i] == K) {
result = true;
}
}
return result;
}
// ๋ฐฐ์ด์ ์ํํ๋ ๋์ค์, ํด๋นํ๋ ๊ฐ์ด ๋ฐ๊ฒฌ๋๋๋ผ๋ ๋ฐฐ์ด์ ๋ชจ๋ ์ํํ ์ดํ์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฆฌํด
๐ซ ๋ฌธ์์ด ๋งค์นญ ์๊ณ ๋ฆฌ์ฆ(Brute-Force String Matching)
- ๊ธธ์ด๊ฐ n์ธ ์ ์ฒด ๋ฌธ์์ด๊ณผ ๊ธธ์ด๊ฐ m์ธ ๋ฌธ์์ด ํจํด์ ํฌํจํ๋์ง๋ฅผ ๊ฒ์
public boolean BruteForceStringMatch(int[] arr, int[] patternArr) {
// Brute Force ๋ฌธ์์ด ๋งค์นญ์ ๊ตฌํ
int n = arr.length;
int m = patternArr.length;
for (int i = 0; i < n - m; i++) {
// ์ ์ฒด ์์๊ฐ์์์ ํจํด๊ฐ์๋ฅผ ๋บ ๋งํผ๋ง ๋ฐ๋ณต -> ๊ทธ ์๊ฐ ๋ง์ง๋ง ๋น๊ต์์์ด๊ธฐ ๋๋ฌธ
// i ๋ฐ๋ณต๋ฌธ์ ํจํด๊ณผ ๋น๊ต์ ์์น๋ฅผ ์ก์
int j = 0;
// j๋ ์ ์ฒด์ ํจํด์ ์์ ํ๋ํ๋๋ฅผ ๋น๊ต
while (j < m && patternArr[j] == arr[i + j]) {
// j๊ฐ ํจํด์ ๊ฐ์๋ณด๋ค ์ปค์ง๋ฉด ์๋๊ธฐ๋๋ฌธ์ ๊ฐ์๋งํผ๋ง ๋ฐ๋ณต
// ํจํด์์๋ j์ธ๋ฑ์ค์ ์ ์ฒด์์๋ i + j ์ธ๋ฑ์ค์ ๊ฐ์ด ๊ฐ์์ง ํ๋จ
// ๊ฐ์๋ j์ +1
j = j + 1;
}
if (j == m) {
// j์ ํจํด ์๊ฐ ๊ฐ๋ค๋ ๊ฒ์ ํจํด์ ๋ฌธ์์ด๊ณผ ์์ ํ ๊ฐ์ ๋ถ๋ถ์ด ์กด์ฌ
// ์ด ๋์ ๋น๊ตํ๋ ์์น๋ฅผ ๋ฐํ
return true;
}
}
return false;
}
๐ซ ์ ํ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ(Selection Sort)
- ์ ์ฒด ๋ฐฐ์ด์ ๊ฒ์ํ์ฌ ํ์ฌ ์์์ ๋น๊ตํ๊ณ ์ปฌ๋ ์ ์ด ์์ ํ ์ ๋ ฌ๋ ๋๊น์ง ํ์ฌ ์์๋ณด๋ค ๋ ์๊ฑฐ๋ ํฐ ์์(์ค๋ฆ์ฐจ์ ๋๋ ๋ด๋ฆผ์ฐจ์์ ๋ฐ๋ผ)๋ฅผ ๊ตํํ๋ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ
public int[] SelectionSort(int[] arr) {
// ์ฃผ์ด์ง ๋ฐฐ์ด์ Selection Sort๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
for (int i = 0; i < arr.length - 1; i++) {
// ๋ฐฐ์ด์ 0๋ฒ์งธ ์ธ๋ฑ์ค๋ถํฐ ๋ง์ง๋ง์ธ๋ฑ์ค๊น์ง ๋ฐ๋ณต
// ํ์ฌ ๊ฐ ์์น์ ๊ฐ์ฅ ์์ ๊ฐ์ ๋ฃ์
int min = i;
// ํ์ฌ ์ธ๋ฑ์ค๋ฅผ ์ต์๊ฐ์ ์ธ๋ฑ์ค๋ฅผ ๋ํ๋ด๋ ๋ณ์์ ํ ๋น
for (int j = i + 1; j < arr.length; j++) {
// ํ์ฌ i์ +1์ j๋ก ๋ฐ๋ณต๋ฌธ์ ์ด๊ธฐํํ๊ณ i ์ดํ์ ๋ฐฐ์ด์์๊ณผ ๋น๊ตํ๋ ๋ฐ๋ณต๋ฌธ ๊ตฌ์ฑ
if (arr[j] < arr[min]) {
// j์ธ๋ฑ์ค์ ๋ฐฐ์ด ๊ฐ์ด ํ์ฌ ์ธ๋ฑ์ค์ ๋ฐฐ์ด ๊ฐ๋ณด๋ค ์๋ค๋ฉด
min = j;
// j ์ธ๋ฑ์ค๋ฅผ ์ต์๋ฅผ ๋ํ๋ด๋ ์ธ๋ฑ์ค๋ก ํ ๋น
}
}
// ๋ฐ๋ณต๋ฌธ์ด ๋๋ฌ์ ๋ min์๋ ์ต์๊ฐ์ ์ธ๋ฑ์ค๊ฐ ๋ค์ด์์
// i๊ฐ๊ณผ ์ต์๊ฐ์ ๋ฐ๊ฟ ํ ๋น
int temp = arr[i];
arr[i] = arr[min];
arr[min] = temp;
}
// ๋ชจ๋ ๋ฐ๋ณต๋ฌธ์ด ๋๋๋ฉด ์ ๋ ฌ๋ ๋ฐฐ์ด ๋ฐํ
return arr;
}
๐ Binary Search Algorithm
- ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋ ์ํ์์ ์ ๋ฐ์ฉ ๋ฒ์๋ฅผ ๋๋ ๋ถํ ์ ๋ณต๊ธฐ๋ฒ์ผ๋ก ํน์ ํ ๊ฐ์ ์ฐพ์๋ด๋ ์๊ณ ๋ฆฌ์ฆ
๐ค ๋์ ๊ณผ์
- Step 1. ์ ๋ ฌ๋ ๋ฐฐ์ด์ ๊ฐ์ฅ ์ค๊ฐ ์ธ๋ฑ์ค๋ฅผ ์ง์ ํ๋ค.
- Step 2. ์ฐพ์ผ๋ ค๊ณ ํ๋ ๊ฐ์ด ์ง์ ํ ์ค๊ฐ ์ธ๋ฑ์ค์ ๊ฐ์ด๋ผ๋ฉด ํ์์ ์ข ๋ฃํ๊ณ , ์๋๋ผ๋ฉด Step 3์ผ๋ก ๊ฐ๋ค.
- Step 3. ์ฐพ์ผ๋ ค๊ณ ํ๋ ๊ฐ์ด ์ค๊ฐ ์ธ๋ฑ์ค์ ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ธ์ง, ์์ ๊ฐ์ธ์ง ํ์ธํ๋ค.
- Step 4. ๊ฐ์ด ์๋ ๋ถ๋ถ๊ณผ ๊ฐ์ด ์๋ ๋ถ๋ถ์ผ๋ก ๋ถ๋ฆฌํ๋ค.
- Step 5. ๊ฐ์ด ์๋ ๋ถ๋ถ์์ ๋ค์ 1๋จ๊ณ๋ถํฐ ๋ฐ๋ณตํ๋ค.
๐ค When Using of the Binary Search Algorithm
- ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์์๊ฐ์ ๋ ํจ์จ์ ์ผ๋ก ๊ฒ์ํ ๋
- ๋ฐ์ดํฐ์ ์์ด ๋ง์ผ๋ฉด ๋ง์์๋ก ํจ์จ์ด ๋์์ ์ ๋ ฌ๋ ๋ฐ์ดํฐ์ ์์ด ๋ง์ ๋
⇒ ํ์์ ๋ฐ๋ณตํ ๋๋ง๋ค ํ์ ๋ฒ์๊ฐ ์ ๋ฐ์ผ๋ก ์ค์ด๋ค๊ฒ ๋์ด, ๋ฐ์ดํฐ ์์ด ๋ง์์๋ก ๋ ๋์ ํจ์จ์ ๊ฐ์ง
๐ค Limit of the Binary Search Algorithm
- ์ ๋ ฌ๋ ๋ฐฐ์ด์๋ง ๊ตฌํ ๊ฐ๋ฅ
- ๊ท๋ชจ๊ฐ ์์ ๋ฐฐ์ด์ด๋ผ๋ ์ ๋ ฌ์ด ๋์ด ์์ง ์๋ค๋ฉด ์ ๋ ฌ์ ํ ํ Binary Search Algorithm์ ์ฌ์ฉํด๋ ํจ์จ์ด ๋ฎ์
๐ค Where to Use Binary Search Algorithm
๋๊ท๋ชจ์ ๋ฐ์ดํฐ ๊ฒ์์ ์ฃผ๋ก ์ฌ์ฉ
- ์ฌ์ ๊ฒ์, ๋์๊ด ๋์ ๊ฒ์, ๋๊ท๋ชจ ์์คํ ์ ๋ํ ๋ฆฌ์์ค ์ฌํญ ํ์ , ๋ฐ๋์ฒด ํ ์คํธ ํ๋ก๊ทธ๋จ์์ ๋์งํธ, ์๋ ๋ก๊ทธ ๋ ๋ฒจ์ ์ธก์
'SEB > TIL' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
029 | ๋คํธ์ํฌ - ์น์ ๊ตฌ์ฑํ๋ ๊ธฐ์ (0) | 2022.08.02 |
---|---|
027 | Permutation & Combination, Greedy Implementation (0) | 2022.07.29 |
026 | Time Complexity (0) | 2022.07.28 |
024 | Data Structure - Tree, Graph (0) | 2022.07.26 |
023 | Data Structure - Stack & Queue (0) | 2022.07.25 |