์ ๋ ฌ๋์ด ์๋(์ด๋ถ ํ์์ ์ฃผ์ ์กฐ๊ฑด) ๋ฐฐ์ด
์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ผ๋ ค ์๋ํ ๋,
์์ฐจํ์์ฒ๋ผ ์ฒ์๋ถํฐ ๋๊น์ง ํ๋์ฉ ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒดํฌํ์ฌ ๊ฐ์ ์ฐพ๋ ๊ฒ์ด ์๋๋ผ
ํ์ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ค์ฌ๊ฐ๋ฉฐ ์ฐพ์๊ฐ๋ Search ๋ฐฉ๋ฒ์ ๋๋ค.
- ์ฐ์ ์ ๋ ฌ๋์ด ์๋ ๋ฐฐ์ด์ด์ด์ผ ํฉ๋๋ค.
low
์high
๋กmid
๊ฐ์ ์ค์ ํฉ๋๋ค.mid
์ ๋ด๊ฐ ๊ตฌํ๊ณ ์ ํ๋ ๊ฐ๊ณผ ๋น๊ตํฉ๋๋ค.- ๊ตฌํ ๊ฐ์ด
mid
๋ณด๋ค ๋์ผ๋ฉด :low
=mid + 1
๊ตฌํ ๊ฐ์ดmid
๋ณด๋ค ๋ฎ์ผ๋ฉด :high
=mid - 1
low
>high
๊ฐ ๋ ๋๊น์ง ๊ณ์ ๋ฐ๋ณตํฉ๋๋ค.
- ์๊ฐ๋ณต์ก๋
์ ํ ์ ๋ ฌ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ N์ด๋ผ ํ๋ฉด,
๋ฐฐ์ด ๋ด์ ํ์ ๊ฐ์ด ์๋ ์ต์ ์ ๊ฒฝ์ฐ,
N 1/2 1/2 * 1/2... ์ผ๋ก ๋ฒ์ ๋ด ์์๊ฐ ํ๋๊ฐ ๋ ๋๊น์ง ์งํํ๋ฏ๋ก
N*(1/2)K = 1 -> K = log2N
์ผ๋ก ์์ํ ํ ์ ์๊ณ ,
์ ๋ณ์ 2K๋ฅผ ๊ณฑํ๊ณ log2๋ฅผ ์ทจํ์ฌ ์ ๋ฆฌํ๋ฉด
O(log2N)
์ผ๋ก ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
ํ์ด
n๊ฐ์ ์ ์๊ฐ ๋ค์ด์๋ ์งํฉ A์์
๋ค๋ฅธ m๊ฐ์ ์ ์๊ฐ ํฌํจ๋์ด ์๋์ง ํ์ธํ๋ ๋ฌธ์ ์
๋๋ค.
์งํฉ ์๋ฃํ์ ์ฌ์ฉํ๋ฉด ๊ฐ๋จํ๊ฒ ํ ์ ์์ง๋ง, ์ด๋ถํ์์ ์ฌ์ฉํ์ฌ ํด๊ฒฐํด๋ณด๊ฒ ์ต๋๋ค.
def binary(l, nList, low, high):
if low > high:
return 0
mid = (low + high) // 2
if l == nList[mid]:
return 1
elif l < nList[mid]:
return binary(l, nList, low, mid - 1)
else:
return binary(l, nList, mid + 1, high)
n = int(input())
A = sorted(map(int, input().split()))
m = input()
M = map(int, input().split())
for l in M:
low = 0
high = len(A) - 1
print(binary(l, A, low, high))
index๋ฅผ ๊ธฐ์ค์ผ๋ก low high๋ฅผ ๋๋๊ณ
์ด๋ถํ์์ ํ์ ์ข ๋ฃ ์กฐ๊ฑด์
mid ๊ฐ์ด ์ฐพ์ผ๋ ค๋ ์๋ ๊ฐ์ผ๋ฉด return ์ ํด์ฃผ๊ณ
์ฐพ๋ ๊ฐ์ด ์์๋ low๊ฐ high๋ณด๋ค ์ปค์ง๊ฒฝ์ฐ ์ข ๋ฃํฉ๋๋ค.