์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- binarySearch
- BFS
- HAVIT
- SwiftUI Tutorials
- ํ๋ก๊ทธ๋๋จธ์ค
- SwiftUI
- SQL
- 0์ด๋์ด์๋๊ธธ
- SOPT
- URLSession
- concurrency
- Til
- GroupBy
- duno
- algorithm
- ์ฐ์ํ์ค๋ถ๋ถ์์ด์ํฉ
- discardableResult
- algoritm
- ๊ณ ๋์ kit
- SwiftUI ํํ ๋ฆฌ์ผ
- APPJAM
- GCD
- dfs
- ๋์ ๊ณํ๋ฒ
- Swift
- DynamicProgramming
- IOS
- ๋ค์ด๋๋ฏนํ๋ก๊ทธ๋๋ฐ
- ์ด์งํ์
- ๊ธฐ์ด๋ฌธ๋ฒ
- Today
- Total
suvera-dev ๐ฅฆ
Algorithm ) Binary Search ๋ฌธ์ ๋ณธ๋ฌธ
ํ์ด์ฌ ์ด์ง ํ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
bisect_left(a,x) : ์ ๋ ฌ๋ ์์๋ฅผ ์ ์งํ๋ฉด์ ๋ฐฐ์ด a์ x๋ฅผ ์ฝ์ ํ ๊ฐ์ฅ ์ผ์ชฝ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
bisect_right(a,x) : ์ ๋ ฌ๋ ์์๋ฅผ ์ ์งํ๋ฉด์ ๋ฐฐ์ด a์ x๋ฅผ ์ฝ์ ํ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ
from bisect import bisect_left, bisect_right
=> ๊ฐ์ด ํน์ ๋ฒ์์ ์ํ๋ ๋ฐ์ดํฐ ๊ฐ์ ๊ตฌํ๊ธฐ
from bisect import bisect_left, bisect_right
# ๊ฐ์ด left_value, right_value์ธ ๋ฐ์ดํฐ ๊ฐ์๋ฅผ ๋ฐํํ๋ ํจ์
def count_by_range(a, left_value, rignt_value):
right_index = bisect_right(a, right_value)
left_index = bisect_left(a, left_value)
return right_index - left_index
ํ๋ผ๋ฉํธ๋ฆญ ์์น
์ต์ ํ ๋ฌธ์ ๋ฅผ ๊ฒฐ์ ๋ฌธ์ ๋ก ๋ฐ๊พธ์ด ํด๊ฒฐํ๋ ๊ฒ
=> ์ด์งํ์์ผ๋ก ํด๊ฒฐํด๋ณด์ !
๋ฌธ์ 1. ๋ถํ ์ฐพ๊ธฐ
์ ์ ๋งค์ฅ์๋ ๋ถํ์ด N๊ฐ ์๋ค. ๊ฐ ๋ถํ์ ์ ์ ํํ์ ๊ณ ์ ํ ๋ฒํธ๊ฐ ์๋ค.
์ด๋ ๋ ์๋์ด M๊ฐ์ ์ข ๋ฅ์ ๋ถํ์ ๋๋์ผ๋ก ๊ตฌ๋งคํ๊ฒ ๋ค๋ฉฐ ๋น์ผ ๋ ๊ฒฌ์ ์๋ฅผ ์์ฒญํ๋ค.
์๋์ด ๋ฌธ์ํ ๋ถํ M๊ฐ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ํ์ธํด์ ๊ฒฌ์ ์๋ฅผ ์์ฑํด์ผ ํ๋ค.
์ด๋ ๊ฐ๊ฒ ์์ ๋ถํ์ด ๋ชจ๋ ์๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์๋ฅผ ๋ค์ด ๊ฐ๊ฒ์ ๋ถํ์ด ์ด 5๊ฐ์ผ ๋ ๋ถํ ๋ฒํธ๊ฐ ๋ค์๊ณผ ๊ฐ๋ค๊ณ ํ์.
N=5 [8, 3, 7, 9, 2]
์๋์ ์ด 3๊ฐ์ ๋ถํ์ด ์๋์ง ํ์ธ ์์ฒญํ๋๋ฐ ๋ถํ ๋ฒํธ๋ ๋ค์๊ณผ ๊ฐ๋ค.
M=3 [5, 7, 9]
์ด๋ ์๋์ด ์์ฒญํ ๋ถํ ๋ฒํธ์ ์์๋๋ก ๋ถํ์ ํ์ธํด ๋ถํ์ด ์์ผ๋ฉด yes๋ฅผ,
์์ผ๋ฉด no๋ฅผ ์ถ๋ ฅํ๋ค. ๊ตฌ๋ถ์ ๊ณต๋ฐฑ์ผ๋ก ํ๋ค.
์์ค์ฝ๋
# ์ด์ง ํ์ ์์ค์ฝ๋ ๊ตฌํ
def binary_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())
shop_array = list(map(int, input().split()))
shop_array.sort() # ์ด์งํ์์ ์ํํ๊ธฐ ์ํด์ ์ ๋ ฌํ์ !
# ์๋์ด ์์ฒญํ ๋ถํ๊ฐ์, ์์ฒญํ ๋ถํ ๋ฒํธ
m = int(input())
want_array = list(map(int, input().split()))
# ์๋์ด ์์ฒญํ ๋ถํ ๋ฒํธ๋ฅผ ํ๋์ฉ ํ์ธ
for i in want_array:
#ํด๋น ๋ถํ์ด ์กด์ฌํ๋์ง ํ์ธ
result = binary_search(shop_array, i, 0, n-1)
if result != None:
print("yes", end= ' ')
else:
print('no', end= ' ')
๋ฌธ์ 2. ๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ
์ ๋จ๊ธฐ์ ๋์ด H๋ฅผ ์ง์ ํ๋ฉด ์ค์ง์ด์ง ๋ก์ ํ๋ฒ์ ์ ๋จํฉ๋๋ค.
๋์ด๊ฐ H๋ณด๋ค ๊ธด ๋ก์ H ์์ ๋ถ๋ถ์ด ์๋ฆด ๊ฒ์ด๊ณ , ๋ฎ์ ๋ก์ ์๋ฆฌ์ง ์์ต๋๋ค.
์๋ฅผ ๋ค์ด 19 14 10 17cm ์ธ ๋ก์ด ๋๋ํ ์๊ณ
์ ๋จ๊ธฐ ๋์ด๋ฅผ 15cm๋ก ์ง์ ํ๋ฉด ์๋ฅธ ๋ค ๋ก์ ๋์ด๋
15, 14, 10, 15cm ๊ฐ ๋ ๊ฒ ์ ๋๋ค.
์๋ฆฐ ๋ก์ ๊ธธ์ด๋ ์ฐจ๋ก๋๋ก 4,0,0,2 cm ์ ๋๋ค.
์๋์ 6cm ๋งํผ์ ๊ธธ์ด๋ฅผ ๊ฐ์ ธ๊ฐ๋๋ค.
์๋์ด ์์ ๋ ์์ฒญํ ์ด ๊ธธ์ด๊ฐ M์ผ ๋ ์ ์ด๋ M๋งํผ์ ๋ก์ ์ป๊ธฐ ์ํด
์ ๋จ๊ธฐ์ ์ค์ ํ ์ ์๋ ๋์ด์ ์ต๋๊ฐ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ ์์ฑ
๋ฌธ์ ํด๊ฒฐ ์์ด๋์ด
=> ์ ์ ํ ๋์ด๋ฅผ ์ฐพ์ ๋๊น์ง ์ด์งํ์์ ์ํํ์ฌ ๋์ด๋ฅผ ๋ฐ๋ณตํด์ ์กฐ์ ํ๋ค.
ํ์ฌ ์ด ๋์ด๋ก ์๋ฅด๋ฉด ์กฐ๊ฑด์ ๋ง์กฑํ ์ ์๋๊ฐ๋ฅผ ํ์ธํ ๋ค์
์กฐ๊ฑด์ ๋ง์กฑ ์ฌ๋ถ์ ๋ฐ๋ผ์ ํ์ ๋ฒ์๋ฅผ ์ขํ์ ํด๊ฒฐ !
์ฌ๊ธฐ์ ์ ๋จ๊ธฐ์ ๋์ด๋ 0๋ถํฐ 10์ต๊น์ง์ ์ ์ ์ค ํ๋ ?
์ด๋ ๊ฒ ํฐ ํ์๋ฒ์๋ฅผ ๋ณด๋ฉด ๊ฐ์ฅ ๋จผ์ ์ด์ง ํ์์ ๋ ์ฌ๋ฆฌ์ !
์ ๋ ฅ ์์ :
๋ก์ ๊ฐ์ 4 ์์ฒญํ ๊ธธ์ด 6
๋ก์ ๊ธธ์ด 19 15 10 17
[1๋จ๊ณ] ์์์ : 0, ๋์ : 19 , ์ค๊ฐ์ : 9
์ค๊ฐ์ ์ผ๋ก ์๋ฅด๋ฉด, 10, 6, 1, 8 - ๊ฒฐ๊ณผ์ ์ฅ
=> ์กฐ๊ฑด ์ถฉ์กฑ : ์ค๊ฐ์ + 1 ์ ์์์ ์ผ๋ก ์ค์ ํ๋ค.
[2๋จ๊ณ] ์์์ : 10 , ๋์ : 19, ์ค๊ฐ์ : 14
์ค๊ฐ์ ์ผ๋ก ์๋ฅด๋ฉด, 5, 1, 0, 3 - ๊ฒฐ๊ณผ์ ์ฅ
=> ์กฐ๊ฑด ์ถฉ์กฑ : ์ค๊ฐ์ +1 ์ ์์์ ์ผ๋ก ์ค์ ํ๋ค.
[3๋จ๊ณ] ์์์ : 15, ๋์ : 19 , ์ค๊ฐ์ : 17
์ค๊ฐ์ ์ผ๋ก ์๋ฅด๋ฉด, 2,0 ,0 ,0 - ๊ฒฐ๊ณผ ์ ์ฅ ใดใด
=> ์กฐ๊ฑด ์ถฉ์กฑ ๋ชปํจ : ๋์ ์ ์ค๊ฐ์ -1 ๋ก ์ค์
[4๋จ๊ณ] ์์์ : 15, ๋์ : 16, ์ค๊ฐ์ : 15
์ค๊ฐ์ ์ผ๋ก ์๋ฅด๋ฉด, 4,0,0,2
=> ์กฐ๊ฑด ์ถฉ์กฑ ! ๋์ด์ ํ์ ๋ฒ์๊ฐ ์ค์ด๋ค ์ ์์ !
์ค๊ฐ์ ์ ๊ฐ์ ์๊ฐ์ด ์ง๋ ์๋ก ์ต์ ํ๋ ๊ฐ์ด ๋๊ธฐ ๋๋ฌธ์,
๊ณผ์ ์ ๋ฐ๋ณตํ๋ฉด์ ์ป์ ์ ์๋ ๋ก์ ๊ธธ์ด ํฉ์ด
ํ์ํ ๋ก์ ๊ธธ์ด๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ๋๋ง๋ค ์ค๊ฐ์ ์ ๊ฐ์ ๊ธฐ๋กํ์ !
# ๋ก์ ๊ฐ์์ ์์ฒญํ ๋ก์ ๊ธธ์ด๋ฅผ ์
๋ ฅ
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:
# ์์ฒญํ ๋ก ๊ธธ์ด๋ณด๋ค ์์ผ๋ฉด? ๋ ์๋ผ์ผ๊ฒ ์ง ? ์ ๋จ๊ธฐ๋ฅผ ๋ ์์ผ๋ก, ์ข
๋ฃ์ ์ ์ค๊ฐ์ -1 ๋ก
end = mid -1
else: # ํ์ํ ๋ก์ ๊ธธ์ด๊ฐ ์์ฒญํ ๊ธธ์ด๋ณด๋ค ํด ๊ฒฝ์ฐ - ์ต๋ํ ๋ ์๋ผ์ผํจ ์์์ ์ ์ค๊ฐ์ +1 ๋ก
result = mid # ์ต๋ํ ๋ ์๋์ ๋๊ฐ ์ ๋ต์ด๋ฏ๋ก, ์ฌ๊ธฐ์ ๊ธฐ๋กํด์ฃผ๊ธฐ
start = mid + 1
print(result)
'Algorithm > CodingTest - Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
Algorithm) Dynamic Programming ๋ฌธ์ (1) | 2022.05.03 |
---|---|
Algorithm) Dynamic programming (0) | 2022.04.09 |
Algorithm) Binary Search (0) | 2022.04.07 |
Algorithm) Sorting ๊ธฐ๋ณธ๋ฌธ์ (0) | 2022.04.07 |
Algorithm) Sorting (0) | 2022.04.03 |