2020. 8. 28. 16:45ใ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค/ํ์
๋ถํ ์ฐพ๊ธฐ(Python) - ์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค
๋ฌธ์ : ๋๋น์ด๋ค ์ ์ ๋งค์ฅ์๋ ๋ถํ์ด N๊ฐ ์๋ค. ๊ฐ ๋ถํ์ ์ ์ ํํ์ ๊ณ ์ ํ ๋ฒํธ๊ฐ ์๋ค. ์ด๋ ๋ ์๋์ด M๊ฐ์ข ๋ฅ์ ๋ถํ์ ๋๋์ผ๋ก ๊ตฌ๋งคํ๊ฒ ๋ค๋ฉฐ ๋น์ผ ๋ ๊ฒฌ์ ์๋ฅผ ์์ฒญํ๋ค. ๋๋น์ด๋ ๋๋ฅผ ๋์น์ง ์๊ณ ์๋์ด ๋ฌธ์ํ ๋ถํ M๊ฐ ์ข ๋ฅ๋ฅผ ๋ชจ๋ ํ์ธํด์ ๊ฒฌ์ ์๋ฅผ ์์ฑํด์ผ ํ๋ค. ์ด๋ ๊ฐ๊ฒ ์์ ๋ถํ์ด ๋ชจ๋ ์๋์ง ํ์ธํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์๋ฅผ ๋ค์ด ๊ฐ๊ฒ์ ๋ถํ์ด ์ด 5๊ฐ์ผ ๋ ๋ถํ ๋ฒํธ๊ฐ ๋ค์๊ณผ ๊ฐ๋ค๊ณ ํ์.
N = 5
[8, 3, 7, 9, 2]
์๋์ ์ด 3๊ฐ์ ๋ถํ์ด ์๋์ง ํ์ธ ์์ฒญํ๋๋ฐ ๋ถํ๋ฒํธ๋ ๋ค์๊ณผ ๊ฐ๋ค.
M = 3
[5, 7, 9]
์ด๋ ์๋์ด ์์ฒญํ ๋ถํ ๋ฒํธ์ ์์๋๋ก ๋ถํ์ ํ์ธํด ๋ถํ์ด ์์ผ๋ฉด yes๋ฅผ, ์์ผ๋ฉด no๋ฅผ ์ถ๋ ฅํ๋ค. ๊ตฌ๋ถ์ ๊ณต๋ฐฑ์ผ๋ก ํ๋ค.
์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ ์ N์ด ์ฃผ์ด์ง๋ค. (1<=N<=1,000,000)
- ๋์งธ ์ค์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ N๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ณ 1,000,000 ์ดํ์ด๋ค.
- ์ ์งธ ์ค์๋ ์ ์ M์ด ์ฃผ์ด์ง๋ค.
- ๋ท์งธ ์ค์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ M๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ณ 10์ต ์ดํ์ด๋ค.
์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ๊ฐ ๋ถํ์ด ์กด์ฌํ๋ฉด yes๋ฅผ, ์์ผ๋ฉด no๋ฅผ ์ถ๋ ฅํ๋ค.
ํด๊ฒฐ๋ฐฉ๋ฒ
1. ์ ๋ ฅ๊ฐ์ด N๊ฐ -> 100๋ง๊ฐ , M๊ฐ ->10๋ง๊ฐ, ๋ฐ์ดํฐ์ ๋ฒ์๋ 10์ต์ดํ์ด๋ค.
2. M๊ฐ์ ๋ฐฐ์ด์์ target์ ๊ฐ์ ธ์ค๊ณ , ์ด๋ฅผ ์ด์งํ์์ ๋ฃ๋๋ค.
3. ์ฐพ์ผ๋ฉด yes๋ฅผ ํธ์ถํ๊ณ ๋ชป์ฐพ์ผ๋ฉด no๋ฅผ ํธ์ถํ๋ค.
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= int(input())
a = list(map(int, input().split()))
m = int(input())
b = list(map(int, input().split()))
a.sort()
for i in range(m):
target = b[i]
result = binary_search(a, target, 0, n-1)
if result == None:
print("No", end = ' ')
else :
print("Yes", end = ' ')
๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์๊ฒ ๋ ๊ฐ๋
1. sortํจ์๋ฅผ ์ด์ฉํ ๋๋ a = a.sort()๊ฐ ์๋ a.sort()๋ก ํด์ผํ๋ค.
2. print()์์ ๋ณ์๋ฅผ ์ผ์ ๋๋ ๋ค์ , ์์ด end = ' '๊ฐ ๊ฐ๋ฅํ๋๋ฐ, ๋ณ์๊ฐ ์๋ค๋ฉด ,์ ๋ถ์ฌ์ฃผ๋๋ก ํ์.
๋ฌธ์ ํด์ค
- ๋ฐ์ดํฐ์ ๊ฐ์๊ฐ 100,000๊ฐ์ 1,000,000๊ฐ ์ธ ๊ฒ์ผ๋ก ๋ณด์ ์์ฐจํ์์ผ๋ก ๊ณ์ฐ์ ํ๋ค๋ฉด ์ต๋ 1,000,000 X 100,000์ ์ฐ์ฐํ์๊ฐ ๋์จ๋ค๋ ๊ฒ์ ์ ์ ์๋ค. ์ด๋ 1000์ต์ ๊ฐ๊น์ด ์์ด๋ฏ๋ก ์์ฐจ์ ์ผ๋ก ํ์์ ํด๊ฒฐ๋ฐฉ๋ฒ์ด ์๋๋ค.
- ๋ค์์ผ๋ก ์๊ฐํ ๊ฑด ์ด์ง ํ์์ด๋ค. ์ด์ง ํ์์ ์ ๋ ฌ์ด ๋์ด์๋ ์ซ์์์๋ง ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ๋จผ์ a์ ๋ฐฐ์ด์ sort๋ก ์ ๋ ฌ์ ํด์ค๋ค. ์ด๋ ๋ณํฉ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๋ฐ๋ฅด๊ธฐ์ O(NlogN)์ด๋ค. ์ด ์ซ์๋ ์ฝ 2,000๋ง์ ๊ฐ๊น์ด ์๊ฐ ๋๋ค. ๊ทธ๋ฆฌ๊ณ 100,000 ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ๋ ๊ฐ์ ธ์์ ์ด์งํ์์ ์ํํ๋ค๋ฉด logN๋งํผ ํ๊ธฐ์ ์ด๋ O(MlogN)์ด ๋ ๋ค๊ณ ํ ์ ์๋ค. ๊ทธ๋ ๊ธฐ์ ์์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก ์ ๊ทผํ๋ฉด ๋ฌธ์ ๋ฅผ ํด๊ฒฐ ํ ์ ์๋ค.
์ด ๋ฌธ์ ๋ฅผ ๊ณ์์ ๋ ฌ์ ์ด์ฉํด์๋ ํ ์ ์๋ค. ์ด๊ฒ์ด ๊ฐ๋ฅํ ์ด์ ๋ N๊ฐ ๊ฐ๊ฐ์ ๊ฐ์ด 1๋ถํฐ 100๋ง ์ฌ์ด์ด๊ธฐ ๋๋ฌธ์ด๋ค.
- 1,000,000๊ฐ์ ๋ฐฐ์ด์ ์ ์ธํ ๋ค 0์ผ๋ก ์ด๊ธฐํ ์ํค๊ณ , N๊ฐ์ ๋ฐฐ์ด์ ํด๋นํ๋ ๊ฐ๋ง count๋ฅผ 1 ์ฆ๊ฐ์ํจ๋ค.
- m๊ฐ์ b๋ฐฐ์ด์ ์ ๋ ฅ๋ฐ๋๋ค.
- b ๋ฐฐ์ด์์ ํ๋์ฉ ๋นผ์์ ์ด๋ฅผ a์์ ์ธ๋ฑ์ค๋ก ์ทจ๊ธํด ๊ฐ์ด 1 ์ด ๋์จ๋ค๋ฉด yes ์๋๋ผ๋ฉด no๋ฅผ ์ถ๋ ฅํ๋๋ก ํ๋ค.
n = int(input())
a = [0] * 1000000
for i in input().split():
a[int(i)] = 1
m = int(input())
x = list(map(int,input().split()))
for i in x :
if a[i] == 1 :
print('yes', end = ' ')
else :
print('no', end =' ')
๊ณ์์ ๋ ฌ์ ์ฒ์์ 1,000,000๋งํผ์ ์ด๊ธฐํ, x๋ฆฌ์คํธ์ ์ต๋ ๊ฐ์๊ฐ 100,000๋งํผ๋ง ์ํ์ด ์ด๋ฃจ์ด์ง๋ค. ๊ทธ๋ ๊ธฐ์ ์์ ์ด์งํ์๋ณด๋ค ๋์ฑ๋ ํจ๊ณผ์ ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค. ์ฝ๋๋ฅผ ์์ฑํ๋ฉด์ ์๋ก์ด ์ฌ์ค์ ์๊ฒ ๋์๋๋ฐ ํ์ด์ฌ์์๋ ๋ฐ์ดํฐ์ ๊ฐ์์ ๋ฌด๊ดํ๊ฒ ์ ๋ ฅ๊ณผ ๋์์ ๋ฐ๋ก ๋ณ์๋ก ์ธ ์ ์๊ธฐ ๋๋ฌธ์ range(๊ฐ์)ํ๊ณ ๊ฐ์์ ๋ฐ๋ผ ๊ฐ์ ์ถ๊ฐํ๋ค๋ ์ผ์ด ๋ฑํ ํ์๊ฐ ์๋ค. ์ด์ ๋นจ๋ฆฌ ์ต์ํด์ ธ์ผ๊ฒ ๋ค.
for i in input().split() ๊ณผ for i in ๋ฐฐ์ด์ ์ฒดํ ์ํค๋ ๊ฒ ์ข์ ๋ฏํ๋ค.
๋ง์ง๋ง์ผ๋ก set()ํจ์๋ฅผ ์ด์ฉํ ํ์ด๋ฅผ ์ดํด๋ณด์
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 =' ')
if i in array๋ ์งํฉ ์๋ฃํ์ผ ๋ ์ฐ๋ ๊ฒ์ผ๋ก ๋ณด์ธ๋ค. ํน์ ํ ์๊ฐ ์๋์ง ์๋์ง๋ง ๊ฒ์ฌํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ ํจ์จ์ ์ผ๋ก ๋ณด์ธ๋ค.
'์ด๊ฒ์ด ์ฝ๋ฉํ ์คํธ๋ค > ํ์' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ก๋ณถ์ด ๋ก ๋ง๋ค๊ธฐ(Python) (0) | 2020.08.31 |
---|---|
์ด์ง ํ์(Python) (0) | 2020.08.28 |