Notice
Recent Posts
Link
Today
Total
10-06 00:17
๊ด€๋ฆฌ ๋ฉ”๋‰ด

dingdong coding

[ ์ด๊ฒƒ์ด ์ฝ”๋”ฉํ…Œ์ŠคํŠธ๋‹ค with ํŒŒ์ด์ฌ ] ์ด์ง„ ํƒ์ƒ‰ ๋ณธ๋ฌธ

๐Ÿ”ตCoding Test/Algorithm

[ ์ด๊ฒƒ์ด ์ฝ”๋”ฉํ…Œ์ŠคํŠธ๋‹ค with ํŒŒ์ด์ฌ ] ์ด์ง„ ํƒ์ƒ‰

๐Ÿถ ๊ฐœ๋ฐœ๊ฐœ๋ฐœ ๐Ÿพ 2022. 3. 23. 15:45

โ€ฃ ์ˆœ์ฐจํƒ์ƒ‰(Sequential Search) : ๋ฆฌ์ŠคํŠธ ์•ˆ์— ์žˆ๋Š” ํŠน์ •ํ•œ ๋ฐ์ดํ„ฐ๋ฅผ ์ฐพ๊ธฐ ์œ„ํ•ด ์•ž์—์„œ ๋ฐ์ดํ„ฐ๋ฅผ ํ•˜๋‚˜์”ฉ ํ™•์ธํ•˜๋Š” ๋ฐฉ๋ฒ•

# ์ˆœ์ฐจ ํƒ์ƒ‰ ์†Œ์Šค์ฝ”๋“œ ๊ตฌํ˜„
def sequential_search(n, target, array):
    # ๊ฐ ์›์†Œ๋ฅผ ํ•˜๋‚˜์”ฉ ํ™•์ธํ•˜๋ฉฐ
    for i in range(n):
        # ํ˜„์žฌ์˜ ์›์†Œ๊ฐ€ ์ฐพ๊ณ ์ž ํ•˜๋Š” ์›์†Œ์™€ ๋™์ผํ•œ ๊ฒฝ์šฐ
        if array[i] == target:
            return i + 1# ํ˜„์žฌ์˜ ์œ„์น˜ ๋ฐ˜ํ™˜(์ธ๋ฑ์Šค๋Š” 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋ฏ€์˜ค 1๋”ํ•˜๊ธฐ)

print("์ƒ์„ฑํ•  ์›์†Œ ๊ฐœ์ˆ˜๋ฅผ ์ž…๋ ฅํ•œ ๋‹ค์Œ ํ•œ ์นธ ๋„๊ณ  ์ฐพ์„ ๋ฌธ์ž์—ด์„ ์ž…๋ ฅํ•˜์„ธ์š”.")
input_data = input().split()
n = int(input_data[0]) # ์›์†Œ์˜ ๊ฐœ์ˆ˜
target = input_data[1] # ์ฐพ๊ณ ์ž ํ•˜๋Š” ๋ฌธ์ž์—ด

print("์•ž์„œ ์ ์€ ์›์†Œ ๊ฐœ์ˆ˜๋งŒํผ ๋ฌธ์ž์—ด์„ ์ž…๋ ฅํ•˜์„ธ์š”. ๊ตฌ๋ถ„์€ ๋„์–ด์“ฐ๊ธฐ ํ•œ ์นธ์œผ๋กœ ํ•œ๋‹ค.")
array = input().split()

# ์ˆœ์ฐจ ํƒ์ƒ‰ ์ˆ˜ํš… ๊ฒฐ๊ณผ ์ถœ๋ ฅ
print(sequential_search(n, target, array))

 

โ€ฃ ์ด์ง„ํƒ์ƒ‰(Binary Search) : ์ •๋ ฌ๋˜์–ด ์žˆ๋Š” ๋ฆฌ์ŠคํŠธ์—์„œ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์ ˆ๋ฐ˜์”ฉ ์ขํ˜€๊ฐ€๋ฉฐ ๋ฐ์ดํ„ฐ๋ฅผ ํƒ์ƒ‰ํ•˜๋Š” ๋ฐฉ๋ฒ• 

* ์ด์ง„ํƒ์ƒ‰์€ ์‹œ์ž‘์ , ๋์ , ์ค‘๊ฐ„์ ์„ ์ด์šฉํ•˜์—ฌ ํƒ์ƒ‰ ๋ฒ”์œ„๋ฅผ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค.

 

์ด์ง„ํƒ์ƒ‰์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„ : O(logN)

 

์ด์ง„ ํƒ์ƒ‰์˜ ๊ตฌํ˜„๋ฐฉ๋ฒ•  1) ์žฌ๊ท€ํ•จ์ˆ˜ ์ด์šฉ 2) ๋ฐ˜๋ณต๋ฌธ ์ด์šฉ

 

1) ์žฌ๊ท€ํ•จ์ˆ˜ ์ด์šฉ

# ์ด์ง„ ํƒ์ƒ‰ ์†Œ์Šค์ฝ”๋“œ ๊ตฌํ˜„(์žฌ๊ท€ํ•จ์ˆ˜)
def binary_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 binary_search(array, target, start, mid - 1)
    # ์ค‘๊ฐ„์ ์˜ ๊ฐ’๋ณด๋‹ค ์ฐพ๊ณ ์ž ํ•˜๋Š” ๊ฐ’์ด ํฐ ๊ฒฝ์šฐ ์˜ค๋ฅธ์ชฝ ํ™•์ธ
    else:
        return binary_search(array, target, mid + 1, end)

# n(์›์†Œ์˜ ๊ฐœ์ˆ˜)๊ณผ target(์ฐพ๊ณ ์ž ํ•˜๋Š” ๋ฌธ์ž์—ด)์„ ์ž…๋ ฅ๋ฐ›๊ธฐ
n, target = list(map(int, input().split()))
# ์ „์ฒด์›์†Œ ์ž…๋ ฅ๋ฐ›๊ธฐ
array = list(map(int, input().split()))

# ์ด์ง„ ํƒ์ƒ‰ ์ˆ˜ํ–‰ ๊ฒฐ๊ณผ ์ถœ๋ ฅ
result = binary_search(array, target, 0, n - 1)
if result == None:
    print("์›์†Œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.")
else:
    print(result + 1)

2) ๋ฐ˜๋ณต๋ฌธ ์ด์šฉ

# ์ด์ง„ ํƒ์ƒ‰ ์†Œ์Šค์ฝ”๋“œ ๊ตฌํ˜„(๋ฐ˜๋ณต๋ฌธ)
def binary_serach(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(์›์†Œ์˜ ๊ฐœ์ˆ˜)๊ณผ target(์ฐพ๊ณ ์ž ํ•˜๋Š” ๋ฌธ์ž์—ด)์„ ์ž…๋ ฅ๋ฐ›๊ธฐ
n, target = list(map(int, input().split()))
# ์ „์ฒด ์›์†Œ ์ž…๋ ฅ๋ฐ›๊ธฐ
array = list(map(int, input().split()))

# ์ด์ง„ ํƒ์ƒ‰ ์ˆ˜ํ–‰๊ฒฐ๊ณผ ์ถœ๋ ฅ
result = binary_serach(array, target, 0, n-1)
if result == None:
    print("์›์†Œ๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.")
else:
    print(result+1)

1. ๋ถ€ํ’ˆ ์ฐพ๊ธฐ (์‹ค์ „๋ฌธ์ œ)

2. ๋–ก๋ณถ์ด ๋–ก ๋งŒ๋“ค๊ธฐ (์‹ค์ „๋ฌธ์ œ)

 

[ ์‹ค์ „๋ฌธ์ œ ] ๋ถ€ํ’ˆ ์ฐพ๊ธฐ

โ€ป ๋ฌธ์ œ

๋™๋นˆ์ด๋„ค ์ „์ž ๋งค์žฅ์—๋Š” ๋ถ€ํ’ˆ์ด N๊ฐœ ์žˆ๋‹ค. ๊ฐ ๋ถ€ํ’ˆ์€ ์ •์ˆ˜ ํ˜•ํƒœ์˜ ๊ณ ์œ ํ•œ ๋ฒˆํ˜ธ๊ฐ€ ์žˆ๋‹ค. ์–ด๋Š ๋‚  ์†๋‹˜์ด M๊ฐœ์˜ ์ข…๋ฅ˜์˜ ๋ถ€ํ’ˆ์„ ๋Œ€๋Ÿ‰์œผ๋กœ ๊ตฌ๋งคํ•˜๊ฒ ๋‹ค๋ฉฐ ๋‹น์ผ ๋‚  ๊ฒฌ์ ์„œ๋ฅผ ์š”์ฒญํ–ˆ๋‹ค.  ๋™๋นˆ์ด๋Š” ๋•Œ๋Š” ๋†“์น˜์ง€ ์•Š๊ณ  ์†๋‹˜์ด ๋ฌธ์˜ํ•œ ๋ถ€ํ’ˆ M๊ฐœ ์ข…๋ฅ˜๋ฅผ ๋ชจ๋‘ ํ™•์ธํ•ด์„œ ๊ฒฌ์ ์„œ๋ฅผ ์ž‘์„ฑํ•ด์•ผ ํ•œ๋‹ค. ์ด ๋•Œ ๊ฐ€๊ฒŒ ์•ˆ์— ๋ถ€ํ’ˆ์ด ๋ชจ๋‘ ์žˆ๋Š”์ง€ ํ™•์ธํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž 

 

์ž…๋ ฅ์กฐ๊ฑด 

- ์ฒซ์งธ ์ค„์— ์ •์ˆ˜ N์ด ์ฃผ์–ด์ง„๋‹ค.

- ๋‘˜์งธ ์ค„์—๋Š” ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•˜์—ฌ N๊ฐœ์˜ ์ •์ˆ˜๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ด๋•Œ ์ •์ˆ˜๋Š” 1๋ณด๋‹ค ํฌ๊ณ  1,000,000 ์ดํ•˜์ด๋‹ค.

- ์…‹์งธ ์ค„์—๋Š” ์ •์ˆ˜ M์ด ์ฃผ์–ด์ง„๋‹ค.

- ๋„ท์งธ ์ค„์—๋Š” ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•˜์—ฌ M๊ฐœ์˜ ์ •์ˆ˜๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ด๋•Œ ์ •์ˆ˜๋Š” 1๋ณด๋‹ค ํฌ๊ณ  1,000,000 ์ดํ•˜์ด๋‹ค.

 

์ถœ๋ ฅ์กฐ๊ฑด 

- ์ฒซ์งธ ์ค„์— ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•˜์—ฌ ๊ฐ ๋ถ€ํ’ˆ์ด ์กด์žฌํ•˜๋ฉด yes๋ฅผ ์—†์œผ๋ฉด no๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

# ๋ถ€ํ’ˆ ์ฐพ๊ธฐ

def binary_serach(array, target, start, end):
    if start > end:
        return None
    mid = (start + end) // 2
    if array[mid] == target:
        return mid
    elif array[mid] > target:
        return binary_serach(array, target, start, mid - 1)
    else:
        return binary_serach(array, target, mid + 1, end)

n = int(input())
arr = []
arr = list(map(int, input().split()))

m = int(input())
arr2 = []  # ์ฐพ๊ณ ์ž ํ•˜๋Š” target
arr2 = list(map(int, input().split()))

for i in arr2:
    result = binary_serach(arr, i, 0, n - 1)
    if result == None:
        print("no", end=' ')
    else:
        print("yes", end=' ')

[ ์‹ค์ „๋ฌธ์ œ ] ๋–ก๋ณถ์ด ๋–ก ๋งŒ๋“ค๊ธฐ

โ€ป ๋ฌธ์ œ

์˜ค๋Š˜ ๋™๋นˆ์ด๋Š” ์—ฌํ–‰ ๊ฐ€์‹  ๋ถ€๋ชจ๋‹˜์„ ๋Œ€์‹ ํ•ด์„œ ๋–ก์ง‘ ์ผ์„ ํ•˜๊ธฐ๋กœ ํ–ˆ๋‹ค. ์˜ค๋Š˜์€ ๋–ก๋ณถ์ด ๋–ก์„ ๋งŒ๋“œ๋Š” ๋‚ ์ด๋‹ค. ๋™๋นˆ์ด๋„ค ๋–ก๋ณถ์ด ๋–ก์€ ์žฌ๋ฐŒ๊ฒŒ๋„ ๋–ก๋ณถ์ด ๋–ก์˜ ๊ธธ์ด๊ฐ€ ์ผ์ •ํ•˜์ง€ ์•Š๋‹ค. ๋Œ€์‹ ์— ํ•œ ๋ด‰์ง€ ์•ˆ์— ๋“ค์–ด๊ฐ€๋Š” ๋–ก์˜ ์ด ๊ธธ์ด๋Š” ์ ˆ๋‹จ๊ธฐ๋กœ ์ž˜๋ผ์„œ ๋งž์ถฐ์ค€๋‹ค.

์ ˆ๋‹จ๊ธฐ ๋†’์ด(H)๋ฅผ ์ง€์ •ํ•˜๋ฉด ์ค„์ง€์–ด ๋–ก์„ ํ•œ ๋ฒˆ์— ์ ˆ๋‹จํ•œ๋‹ค. ๋†’์ด๊ฐ€ H๋ณด๋‹ค ๊ธด ๋–ก์€ H ์œ„์˜ ๋ถ€๋ถ„์ด ์ž˜๋ฆด ๊ฒƒ์ด๊ณ , ๋‚ฎ์€ ๋–ก์€ ์ž˜๋ฆฌ์ง€ ์•Š๋Š”๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด ๋†’์ด๊ฐ€ 19, 14, 10, 17cm์ธ ๋–ก์ด ๋‚˜๋ž€ํžˆ ์žˆ๊ณ  ์ ˆ๋‹จ๊ธฐ ๋†’์ด๋ฅผ 15cm๋กœ ์ง€์ •ํ•˜๋ฉด ์ž๋ฅธ ๊ท€ ๋–ก์˜ ๋†’์ด๋Š” 15, 14, 10, 15cm๊ฐ€ ๋  ๊ฒƒ์ด๋‹ค. ์ž˜๋ฆฐ ๋–ก์˜ ๊ธธ์ด๋Š” ์ฐจ๋ก€๋Œ€๋กœ 4, 0, 0, 2cm์ด๋‹ค. ์†๋‹˜์€ 6cm๋งŒํผ์˜ ๊ธธ์ด๋ฅผ ๊ฐ€์ ธ๊ฐ„๋‹ค.

์†๋‹˜์ด ์™”์„ ๋•Œ ์š”์ฒญํ•œ ์ด ๊ธธ์ด๊ฐ€ M์ผ ๋•Œ ์ ์–ด๋„ M๋งŒํผ์˜ ๋–ก์„ ์–ป๊ธฐ ์œ„ํ•ด ์ ˆ๋‹จ๊ธฐ์— ์„ค์ •ํ•  ์ˆ˜ ์žˆ๋Š” ๋†’์ด์˜ ์ตœ๋Œ“๊ฐ’์„ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

 

์ž…๋ ฅ์กฐ๊ฑด 

- ์ฒซ์งธ ์ค„์— ๋–ก์˜ ๊ฐœ์ˆ˜ N์™€ ์š”์ฒญํ•œ ๋–ก์˜ ๊ธธ์ด M์ด ์ฃผ์–ด์ง„๋‹ค. 

- ๋‘˜์งธ ์ค„์—๋Š” ๋–ก์˜ ๊ฐœ๋ณ„ ๋†’์ด๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ๋–ก ๋†’์ด์˜ ์ดํ•ฉ์€ ํ•ญ์ƒ M ์ด์ƒ์ด๋ฏ€๋กœ, ์†๋‹˜์€ ํ•„์š”ํ•œ ์–‘๋งŒํผ ๋–ก์„ ์‚ฌ๊ฐˆ ์ˆ˜ ์žˆ๋‹ค. ๋†’์ด๋Š” 10์–ต๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ์–‘์˜ ์ •์ˆ˜ ๋˜๋Š” 0์ด๋‹ค.

 

์ถœ๋ ฅ์กฐ๊ฑด 

- ์ ์–ด๋„ M๋งŒํผ์˜ ๋–ก์„ ์ง‘์— ๊ฐ€์ ธ๊ฐ€๊ธฐ ์œ„ํ•ด ์ ˆ๋‹จ๊ธฐ์— ์„ค์ •ํ•  ์ˆ˜ ์žˆ๋Š” ๋†’์ด์˜ ์ตœ๋Œ“๊ฐ’์„ ์ถœ๋ ฅํ•œ๋‹ค.

# ๋–ก๋ณถ์ด ๋–ก ๋งŒ๋“ค๊ธฐ

# ๋–ก์˜ ๊ฐœ์ˆ˜ (N)์™€ ์š”์ฒญํ•œ ๋–ก์˜ ๊ธธ์ด (M)์„ ์ž…๋ ฅ๋ฐ›๊ธฐ
n, m = list(map(int, input().split()))
# ๊ฐ ๋–ก์˜ ๊ฐœ๋ณ„ ๋†’์ด ์ •๋ณด ์ž…๋ ฅ๋ฐ›๊ธฐ
arr = list(map(int, input().split()))

# ์ด์ง„ ํƒ์ƒ‰์„ ์œ„ํ•œ ์‹œ์ž‘์ ๊ณผ ๋์  ์„ค์ •
start = 0
end = max(arr)

# ์ด์ง„ ํƒ์ƒ‰ ์ˆ˜ํ–‰(๋ฐ˜๋ณต์ )
result = 0
while start <= end:
    total = 0
    mid = (start + end) // 2
    for x in arr:
        # ์ž˜๋ž์„ ๋•Œ ๋–ก์˜ ์–‘ ๊ณ„์‚ฐ
        if x > mid:
            total += x - mid
    # ๋–ก์˜ ์–‘์ด ๋ถ€์กฑํ•œ ๊ฒฝ์šฐ ๋” ๋งŽ์ด ์ž๋ฅด๊ธฐ(์™ผ์ชฝ ๋ถ€๋ถ„ ํƒ์ƒ‰)
    if total < m:
        end = mid - 1
    # ๋–ก์˜ ์–‘์ด ์ถฉ๋ถ„ํ•œ ๊ฒฝ์šฐ ๋œ ์ž๋ฅด๊ธฐ(์˜ค๋ฅธ์ชฝ ๋ถ€๋ถ„ ํƒ์ƒ‰)
    else:
        result = mid # ์ตœ๋Œ€ํ•œ ๋œ ์ž˜๋ž์„ ๋•Œ๊ฐ€ ์ •๋‹ต์ด๋ฏ€๋กœ, ์—ฌ๊ธฐ์—์„œ result์— ๊ธฐ๋ก
        start = mid + 1

print(result)

 

 

๊ฐ•์˜ ๋ฐ ์ถœ์ฒ˜

 

 

Comments