์ฐธ๊ณ ์๋ฃ : ์ด๊ฒ์ด ์ฝ๋ฉ ํ ์คํธ๋ค (๋๋๋น ์ )
1. ๋ฒ์๋ฅผ ๋ฐ์ฉ ์ขํ๊ฐ๋ ํ์
์์ฐจํ์
- ์์ฐจํ์ : ๋ฆฌ์คํธ ์์ ์๋ ํน์ ํ ใด๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ์์์๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ์ฐจ๋ก๋๋ก ํ์ธํ๋ ๋ฐฉ๋ฒ
def seq_search(n, target, array):
for i in range(n):
if array[i] == target:
return i+1
input_data = input().split()
n = int(input_data[0])
target = input_data[1]
array = input().split()
print(seq_search(n, target, array))
- ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ N๊ฐ์ผ ๋ ์ต๋ N๋ฒ์ ๋น๊ต ์ฐ์ฐ์ด ํ์ํ๋ฏ๋ก ์์ฐจ ํ์์ ์๊ฐ๋ณต์ก๋๋ O(N)์ด๋ค.
์ด์งํ์
- ์ด์ง ํ์์ ๋ฐฐ์ด ๋ด๋ถ์ ๋ฐ์ดํฐ๊ฐ ์ ๋ ฌ๋์ด ์์ ๋ ๋ฒ์๋ฅผ ์ ๋ฐ์ฉ ์ขํ๊ฐ๋ฉฐ ๋ฐ์ดํฐ๋ฅผ ํ์ํ๋ ์๊ณ ๋ฆฌ์ฆ
- ์ด๋ฏธ ์ ๋ ฌ๋์ด ์๋ ๊ฒฝ์ฐ ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋ฐ์ดํฐ๋ฅผ ์ฐพ์ ์ ์๋ค.
- ์์น๋ฅผ ๋ํ๋ด๋ ๋ณ์ 3๊ฐ
์์์
๋์
์ค๊ฐ์
์ ์ฌ์ฉํ๋ค. - ์๊ฐ๋ณต์ก๋
O(logN)
์ฌ๊ท๋ฅผ ์ฌ์ฉํ ์ฝ๋
def bin_search(array, target, start, end):
if start > end: return None
mid = (start + end) // 2
if array[mid] == target: return mid
elif array[mid] > target :
return bin_search(array, target, start, mid-1)
else :
return bin_search(array, target, mid+1, end)
๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ ์ฝ๋
def bin_search(array, target, start, end):
while start <= end:
mid = (start + end) // 2
if array[mid] == target: return mid
elif array[mid] > target :
end = mid - 1
else :
start = mid + 1
return None
์ฝํ ์์์ ์ด์งํ์
- ์ฌ๋ฌ ์ฐจ๋ก ์ฝ๋๋ฅผ ์ ๋ ฅํ๋ฉฐ ์์ฐ์ค๋ฝ๊ฒ ์ธ์ฐ์! ์ค์์ค์~
- ํ์ ๋ฒ์๊ฐ ํด ๋๋ ์ด์งํ์์ผ๋ก ์ ๊ทผํ์.
ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ
- ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ๋ ๋ ธ๋์ ๋ ธ๋์ ์ฐ๊ฒฐ๋ก ํํํ๋ฉฐ ๋ง์ ์์ ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ ์ํ ๋ชฉ์ ์ผ๋ก ์ฌ์ฉ๋๋ค.
- ํธ๋ฆฌ๋ ์ผ๋ถ๋ฅผ ๋ผ์ด๋ด๋ ํธ๋ฆฌ ๊ตฌ์กฐ์ด๋ฉฐ ์ด๋ฅผ ์๋ธ ํธ๋ฆฌ๋ผ ํ๋ค.
์ด์ง ํ์ํธ๋ฆฌ
- ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ ์ค์์ ๊ฐ์ฅ ๊ฐ๋จํ ํํ๊ฐ ์ด์ง ํ์ ํธ๋ฆฌ์ด๋ค.
- ์ด์ง ํ์ ํธ๋ฆฌ : ์ด์ง ํ์์ด ๋์ํ ์ ์๋๋ก ๊ณ ์๋, ํจ์จ์ ํ์์ด ๊ฐ๋ฅํ ์๋ฃ๊ตฌ์กฐ
- ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์ผ์ชฝ ์์ ๋ ธ๋๊ฐ ์๋ค.
- ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๊ฐ ํฌ๋ค
๋น ๋ฅด๊ฒ ์ ๋ ฅ๋ฐ๊ธฐ
- Python
input()
ํจ์๋ ๋์ ์๋๊ฐ ๋๋ฆฌ๋ค. - ํ ์ค ์
๋ ฅ๋ฐ๊ณ
rstrip()
ํจ์๋ฅผ ๊ผญ ํธ์ถํด์ผ ํ๋ค.
import sys
input_data = sys.stdin.readline().rstrip()
print(input_data)
2. ๋ถํ์ฐพ๊ธฐ
๋์ด๋ ์คํ
๋ฌธ์
์ ์ ๋งค์ฅ์๋ ๋ถํ์ด N๊ฐ ์๊ณ ๊ฐ ๋ถํ์๋ ์ ์ ํํ์ ๊ณ ์ ๋ฒํธ๊ฐ ์๋ค. ์ด๋ ๋ ์๋์ด M๊ฐ ์ข ๋ฅ์ ๋ถํ์ ๋๋์ผ๋ก ๊ตฌ๋งคํ๊ฒ ๋ค๋ฉฐ ๋น์ผ ๋ ๊ฒฌ์ ์๋ฅผ ์์ฒญํ๋ค. ์๋์ด ๋ฌธ์ํ ๋ถํ M๊ฐ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ํ์ธํด์ ๊ฒฌ์ ์๋ฅผ ์์ฑํด์ผ ํ๋ค. ์ด๋ ๊ฐ๊ฒ ์์ ๋ถํ์ด ๋ชจ๋ ์๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
ํด์ค
๋จผ์ ๋งค์ฅ ๋ด N๊ฐ์ ๋ถํ์ ๋ฒํธ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ณ M๊ฐ์ ๋ถํ์ ๊ฐ๊ฐ ์ด์งํ์์ ์ํํ๋ค.
์ฝ๋
def bin_search(array, target, start, end):
while start <= end:
mid = (start + end) // 2
if array[mid] == target:
return mid
elif array[mid] > target:
end = mid - 1
else:
start = mid + 1
return None
n = int(input())
array = list(map(int, input().split()))
array.sort()
m = int(input())
x = list(map(int, input().split()))
for i in x :
result = bin_search(array, i, 0, n-1)
if result != None : print('yes', end=' ')
else : print('no', end=' ')
๊ณ์ ์ ๋ ฌ์ ์ฌ์ฉํ ์ ์๋ค
n = int(input())
array = [0] * 1000001
for i in input().split():
array[int(i)] += 1
m = int(input())
x = list(map(int, input().split()))
for i in x :
if array[i] == 1 : print('yes', end=' ')
else : print('no', end=' ')
๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋์ง ๊ฒ์ฌํ ๋๋ ์งํฉ ์๋ฃํ์ด ์ข๋ค.
n = int(input())
array = set(map(int, input().split()))
m = int(input())
x = list(map(int, input().split()))
for i in x :
if i in array : print('yes', end=' ')
else : print('no', end=' ')
3. ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
๋์ด๋ ์ค
๋ฌธ์
๋๋น์ด๋ค ๋ก๋ณถ์ด ๋ก์ ๋ก์ ๊ธธ์ด๊ฐ ์ผ์ ํ์ง ์๊ณ ๋์ ์ ํ ๋ด์ง ์์ ๋ค์ด๊ฐ๋ ๋ก์ ์ด ๊ธธ์ด๋ ์ ๋จ๊ธฐ๋ก ์๋ผ์ ๋ง์ถฐ์ค๋ค. ์ ๋ค๊ธฐ์ ๋์ด(H)๋ฅผ ์ง์ ํ๋ฉด ์ค์ง์ด์ง ๋ก์ ํ ๋ฒ์ ์ ๋จํ๋ค. ๋์ด H๋ณด๋ค ๊ธด ๋ก์ ์๋ฆฌ๊ณ , ๋ฎ์ ๋ก์ ์๋ฆฌ์ง ์๋๋ค. ์๋์ด ์์ ๋ ์์ฒญํ ์ด ๊ธธ์ด๊ฐ M์ผ ๋ ์ ์ด๋ M๋งํผ์ ๋ก์ ์ป๊ธฐ ์ํด ์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
ํด์ค
์ ํ์ ์ธ ์ด์ง ํ์ ๋ฌธ์ ์ด์, ํ๋ผ๋ฉํธ๋ฆญ ์์น์ ํ์ด๋ค. ํ๋ผ๋ฉํธ๋ฆญ ์์น๋ ์ต์ ํ ๋ฌธ์ ๋ฅผ ๊ฒฐ์ ๋ฌธ์ ๋ก ๋ฐ๊พธ์ด ํด๊ฒฐํ๋ ๊ธฐ๋ฒ์ด๋ค. ์ด ๋ฌธ์ ์ ํ์ด ์์ด๋์ด๋ ์์ธ๋ก ๊ฐ๋จํ๋ฐ ์ ์ ํ ๋์ด๋ฅผ ์ฐพ์ ๋๊น์ง ์ ๋จ๊ธฐ์ ๋์ด H๋ฅผ ๋ฐ๋ณตํด์ ์กฐ์ ํ๋ ๊ฒ์ด๋ค.
์ฝ๋
n, m = map(int, input().split())
array = list(map(int, input().split()))
start = 0
end = max(array)
result = 0
while(start<=end):
total = 0
mid = (start+end) // 2
for x in array:
if x > mid:
total += x - mid
if total < m:
end = mid - 1
else:
result = mid
start = mid + 1
print(result)