๋ฐ์ํ
์์ฐจ ํ์(Sequential Search)
- ๋ฆฌ์คํธ ์์ ์๋ ํน์ ํ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ์์์๋ถํฐ ํ๋์ฉ ์ฐจ๋ก๋๋ก ํ์ธํ๋ ๋ฐฉ๋ฒ
- ์ ๋ ฌ ์ฌ๋ถ์ ์๊ด์์ด ๊ฐ์ฅ ์์์๋ถํฐ ํ๋์ฉ ํ์ธ
- ์ ๋ ฌ๋์ง ์์ ๋ฆฌ์คํธ์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์์ผ ํ ๋ ์ฌ์ฉ
- ๋ฆฌ์คํธ ๋ด์ ๋ฐ์ดํฐ๊ฐ ์๋ฌด๋ฆฌ ๋ง์๋ ์๊ฐ๋ง ์ถฉ๋ถํ๋ค๋ฉด ํญ์ ์ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ์ ์์
- ์๊ฐ ๋ณต์ก๋ → O(N)
์ด์ง ํ์(Binary Search)
- ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ขํ๊ฐ๋ฉฐ ๋ฐ์ดํฐ๋ฅผ ํ์
- ์ฐพ์ผ๋ ค๋ ๋ฐ์ดํฐ์ ์ค๊ฐ์ ์์น์ ์๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ๋น๊ตํ์ฌ ์ํ๋ ๋ฐ์ดํฐ ํ์
- ์์น๋ฅผ ๋ํ๋ด๋ ์์์ , ๋์ , ์ค๊ฐ์ 3๊ฐ์ ๋ณ์ ์ฌ์ฉ
- ๋ฐฐ์ด ๋ด๋ถ์ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋์ด ์์ด์ผ๋ง ์ฌ์ฉ ๊ฐ๋ฅ
- ์๊ฐ ๋ณต์ก๋ → O(logN)
ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ
๋๋ณด๊ธฐ
ํธ๋ฆฌ(Tree) ๊ตฌ์กฐ
- ๋ ธ๋์ ๋ ธ๋์ ์ฐ๊ฒฐ๋ก ํํ ( ๋ ธ๋: ์ ๋ณด์ ๋จ์, ์ด๋ ํ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฐ์ฒด)
- ๊ทธ๋ํ ์๋ฃ๊ตฌ์กฐ์ ์ผ์ข ์ผ๋ก ๋ฐ์ดํฐ ๋ฒ ์ด์ค ์์คํ ์ด๋ ํ์ผ ์์คํ ๊ณผ ๊ฐ์ ๊ณณ์์ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉ
ํธ๋ฆฌ ๊ตฌ์กฐ์ ํน์ง
- ํธ๋ฆฌ๋ ๋ถ๋ชจ ๋ ธ๋์ ์์ ๋ ธ๋์ ๊ด๊ณ๋ก ํํ
- ํธ๋ฆฌ์ ์ต์๋จ ๋ ธ๋๋ ๋ฃจํธ ๋ ธ๋
- ํธ๋ฆฌ์ ์ตํ๋จ ๋ ธ๋๋ ๋จ๋ง ๋ ธ๋
- ํธ๋ฆฌ์์ ์ผ๋ถ๋ฅผ ๋ผ์ด๋ด๋ ํธ๋ฆฌ ๊ตฌ์กฐ์ด๋ฉฐ ์ด๋ฅผ ์๋ธ ํธ๋ฆฌ๋ผ๊ณ ํจ
- ํธ๋ฆฌ๋ ํ์ผ ์์คํ ๊ณผ ๊ฐ์ด ๊ณ์ธต์ ์ด๊ณ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃจ๊ธฐ์ ์ ํฉ
โ ํฐ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ์ํํธ์จ์ด๋ ๋๋ถ๋ถ ๋ฐ์ดํฐ๋ฅผ ํธ๋ฆฌ ๊ตฌ์กฐ๋ก ์ ์ฅํด ์ด์ง ํ์๊ณผ ๊ฐ์ ํ์ ๊ธฐ๋ฒ์ ์ด์ฉํด ๋น ๋ฅด๊ฒ ํ์ ๊ฐ๋ฅ
์ด์ง ํ์ ํธ๋ฆฌ
- ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ ์ค์์ ๊ฐ์ฅ ๊ฐ๋จํ ํํ
- ์ด์ง ํ์์ด ๋์ํ ์ ์๋๋ก ๊ณ ์๋, ํจ์จ์ ์ด๊ณ ํ์์ด ๊ฐ๋ฅํ ์๋ฃ๊ตฌ์กฐ
- ๋ฃจํธ ๋ ธ๋๋ถํฐ ๋ฐฉ๋ฌธํ์ฌ ์ฐพ๋ ๋ฐ์ดํฐ๊ฐ ๋ฃจํธ ๋ ธ๋ ๊ฐ ๋ณด๋ค ํฌ๋ค๋ฉด ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๊ณ , ์๋ค๋ฉด ์ผ์ชฝ ์์ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ
- ๋ฐฉ๋ฌธํ ์์ ๋ ธ๋๊ฐ ๋ถ๋ชจ ๋ ธ๋๊ฐ ๋์ด ํฌ๊ธฐ๋ฅผ ๋น๊ตํ์ฌ ๋ค์ ๋ฐฉ๋ฌธํ ๋ ธ๋ ์ ํ
- ์ฐพ์ผ๋ ค๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ๋๊น์ง ๋ฐ๋ณต
์ด์ง ํ์ ํธ๋ฆฌ ํน์ง
- ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์ผ์ชฝ ์์ ๋ ธ๋๊ฐ ์๋ค
- ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๊ฐ ํฌ๋ค
์ด์ง ํ์ ๋ฌธ์
๋ถํ ์ฐพ๊ธฐ
๋๋น์ด๋ค ์ ์ ๋งค์ฅ์๋ ๋ถํ์ด N๊ฐ ์๋ค. ๊ฐ ๋ถํ์ ์ ์ ํํ์ ๊ณ ์ ํ ๋ฒํธ๊ฐ ์๋ค.
์ด๋ ๋ ์๋์ด M๊ฐ ์ข ๋ฅ์ ๋ถํ์ ๋๋์ผ๋ก ๊ตฌ๋งคํ๊ฒ ๋ค๋ฉฐ ๋น์ผ๋ ๊ฒฌ์ ์๋ฅผ ์์ฒญํ๋ค.
๋๋น์ด๋ ๋๋ฅผ ๋์น์ง ์๊ณ ์๋์ด ๋ฌธ์ํ ๋ถํ M๊ฐ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ํ์ธํด์ ๊ฒฌ์ ์๋ฅผ ์์ฑํด์ผ ํ๋ค.
์ด๋ ๊ฐ๊ฒ ์์ ๋ถํ์ด ๋ชจ๋ ์๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ด์ง ํ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ ์์ค ์ฝ๋
// ์ด์ง ํ์
func binary_search(_ arr: [Int], _ target: Int, _ start: Int, _ end: Int) -> Bool{
var s = start, e = end
while s <= e{
var mid = (s+e)/2
if arr[mid] == target{ return true }
else if arr[mid] > target{ e = mid-1 }
else { s = mid + 1 }
}
return false
}
var n = Int(readLine()!)!
var n_arr = readLine()!.split(separator: " ").map{Int(String($0))!}
n_arr = n_arr.sorted()
var m = Int(readLine()!)!
var m_arr = readLine()!.split(separator: " ").map{Int(String($0))!}
for i in m_arr{
binary_search(n_arr, i, 0, n-1) ? print("yse", terminator: " ") : print("no", terminator: " ")
}
๊ณ์ ์ ๋ ฌ ๊ฐ๋ ์ ์ฌ์ฉํ ์์ค์ฝ๋
- ๋ชจ๋ ์์์ ๋ฒํธ๋ฅผ ํฌํจํ ์ ์๋ ํฌ๊ธฐ์ ๋ฐฐ์ด์ ๋ง๋ ํ, ๋ฐฐ์ด ์ธ๋ฑ์ค์ ์ง์ ์ ๊ทผํ์ฌ ํน์ ๋ฒํธ์ ๋ถํ์ด ์กด์ฌํ๋์ง ํ์ธ
// ๊ณ์ ์ ๋ ฌ
var n = Int(readLine()!)!
var n_arr: [Int] = Array(repeating: 0, count: 1000001)
for i in readLine()!.split(separator: " ").map{Int(String($0))!}{
n_arr[i] = 1
}
var m = Int(readLine()!)!
var m_arr = readLine()!.split(separator: " ").map{Int(String($0))!}
for i in m_arr{
if n_arr[i] == 1 { print("yes", terminator: " ") }
else { print("no", terminator: " ") }
}
์งํฉ ์๋ฃํ์ ์ด์ฉํ ์์ค ์ฝ๋
// Set(์งํฉ)์๋ฃํ ์ฌ์ฉ
var n = Int(readLine()!)!
var n_arr = Set(readLine()!.split(separator: " ").map{Int(String($0))!})
var m = Int(readLine()!)!
var m_arr = readLine()!.split(separator: " ").map{Int(String($0))!}
for i in m_arr{
if n_arr.contains(i) { print("yes", terminator: " ") }
else { print("no", terminator: " ") }
}
๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
์ค๋ ๋๋น์ด๋ ์ฌํ ๊ฐ์ ๋ถ๋ชจ๋์ ๋์ ํด์ ๋ก์ง ์ผ์ ํ๊ธฐ๋ก ํ๋ค. ์ค๋์ ๋ก๋ณถ์ด ๋ก์ ๋ง๋๋ ๋ ์ด๋ค.
๋๋น์ด๋ค ๋ก๋ณถ์ด ๋ก์ ์ฌ๋ฐ๊ฒ๋ ๋ก๋ณถ์ด ๋ก์ ๊ธธ์ด๊ฐ ์ผ์ ํ์ง ์๋ค. ๋์ ํ ๋ด์ง ์์ ๋ค์ด๊ฐ๋ ๋ก์ ์ด ๊ธธ์ด๋ ์ ๋จ๊ธฐ๋ก ์๋ผ์ ๋ง์ถ๋ค.
์ ๋จ๊ธฐ ๋์ด(H)๋ฅผ ์ง์ ํ๋ฉด ์ค์ง์ด์ง ๋ก์ ํ ๋ฒ์ ์ ๋จํ๋ค. ๋์ด๊ฐ H๋ณด๋ค ๊ธด ๋ก์ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋ก์ ์๋ฆฌ์ง ์๋๋ค.
์๋์ด ์์ ๋ ์์ฒญํ ์ด ๊ธธ์ด๊ฐ M ์ผ ๋, ์ ์ด๋ M ๋งํผ์ ๋ก์ ์ป๊ธฐ ์ํด ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ์ต๋ ๋์ด๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํ๋ผ๋ฉํธ๋ฆญ ์์น(Parametric Search) ์ ํ ๋ฌธ์
- ์ต์ ํ ๋ฌธ์ ๋ฅผ ๊ฒฐ์ ๋ฌธ์ ๋ก ๋ฐ๊พธ์ด ํด๊ฒฐํ๋ ๊ธฐ๋ฒ
- ๊ฒฐ์ ๋ฌธ์ - "์" ํน์ "์๋์ค"๋ก ๋ตํ๋ ๋ฌธ์
- ์ํ๋ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ์๋ง์ ๊ฐ์ ์ฐพ๋ ๋ฌธ์ ์ ์ฃผ๋ก ์ฌ์ฉ
- ex) ๋ฒ์ ๋ด์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ๋ ๋ฌธ์
var input_data = readLine()!.split(separator: " ").map{Int(String($0))!}
var n = input_data[0], m = input_data[1]
var arr = readLine()!.split(separator: " ").map{Int(String($0))!}
var start = 0, end = arr.max()!
var re = 0
while start <= end{
var total = 0
var mid = (start+end)/2
for x in arr{
if x > mid { total += x - mid }
}
if total < m { end = mid - 1}
else{
re = mid
start = mid + 1
}
}
print(re)
๋ฐ์ํ
'๐ Computer Science > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ต๋จ ๊ฒฝ๋ก(Shortest Path) (0) | 2022.03.31 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ๋ค์ด๋๋ฏน ํ๋ก๊ทธ๋๋ฐ(Dynamic Programming) (0) | 2022.03.30 |
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ(Sorting) (0) | 2022.03.24 |
[์๊ณ ๋ฆฌ์ฆ] DFS/ BFS (0) | 2022.03.23 |
[์๊ณ ๋ฆฌ์ฆ] ๊ตฌํ(Implementation) (0) | 2022.03.22 |