๐Ÿšถโ€โ™‚๏ธRoad to ์ฝ”ํ…Œ(2) - ๋ฐฐ์—ด

์•ˆํƒœํ˜„ยท2024๋…„ 12์›” 11์ผ

Algorithm

๋ชฉ๋ก ๋ณด๊ธฐ
2/15

๋ณธ ๊ฒŒ์‹œ๋ฌผ์€ BaaarkingDog๋‹˜์˜ ์‹ค์ „ ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ฐ•์˜๋ฅผ ํ†ตํ•ด ๊ณต๋ถ€ํ•œ ๊ฒƒ์„ ์ •๋ฆฌํ•ฉ๋‹ˆ๋‹ค.

[์ถ”๊ฐ€] ์šฉ๊ฐํ•˜๊ฒŒ ์‹œ์ž‘ํ•˜๋Š” ์ฝ”๋”ฉํ…Œ์ŠคํŠธ

[์ถ”๊ฐ€] ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ ํ•ฉ๊ฒฉ์ž ๋˜๊ธฐ - ํŒŒ์ด์ฌ ํŽธ

๋ฉ”๋ชจ๋ฆฌ ์ƒ์— ์›์†Œ ์—ฐ์† ๋ฐฐ์น˜ ๊ตฌ์กฐ๋ผ k๋ฒˆ์งธ ์›์†Œ ์œ„์น˜๋ฅผ ๋ฐ”๋กœ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๋‹ค. ์‹œ๊ฐ„ ๋ณต์žก๋„๋Š” O(1)
์ถ”๊ฐ€์ ์œผ๋กœ ์†Œ๋ชจ๋˜๋Š” ๋ฉ”๋ชจ๋ฆฌ ์–‘์ด ๊ฑฐ์˜ ์—†๋‹ค.

๋งจ ๋’ค๊ฐ€ ์•„๋‹Œ ์ž„์˜์˜ ์œ„์น˜์— ์›์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๋Š” ๊ณผ์ •์€ O(n). ์›์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ๋‚˜๋จธ์ง€ ๋ฐ์ดํ„ฐ๋“ค์„ ๋’ค๋กœ ํ•œ ์นธ์”ฉ ๋ฏธ๋ค„์•ผํ•˜๊ธฐ ๋•Œ๋ฌธ์—.
์˜ˆ๋ฅผ ๋“ค์–ด ๊ทธ๋ž˜ํ”„๋ฅผ ํ‘œํ˜„ํ•  ๋•Œ ๋ฐฐ์—ด์„ ํ™œ์šฉํ•˜๋ฉด ์ž„์˜ ์ ‘๊ทผ์„ ํ•  ์ˆ˜ ์žˆ์œผ๋ฏ€๋กœ ๊ฐ„์„  ์—ฌ๋ถ€๋„ ์‹œ๊ฐ„ ๋ณต์žก๋„ O(1)๋กœ ํŒ๋‹จํ•  ์ˆ˜ ์žˆ\๋‹ค. ํ•˜์ง€๋งŒ ๋ฐฐ์—ด์€ ๋ฉ”๋ชจ๋ฆฌ ๊ณต๊ฐ„์„ ์ถฉ๋ถ„ํžˆ ํ™•๋ณดํ•ด์•ผ ํ•˜๋Š” ๋‹จ์ ๋„ ์žˆ๋‹ค.
์ž„์˜ ์ ‘๊ทผ์ด๋ผ๋Š” ํŠน์ง•์ด ์žˆ์–ด ๋ฐ์ดํ„ฐ์— ๋นˆ๋ฒˆํ•˜๊ฒŒ ์ ‘๊ทผํ•˜๋Š” ๊ฒฝ์šฐ ๋ฉ”๋ชจ๋ฆฌ ๋‚ญ๋น„๊ฐ€ ๋ฐœ์ƒ ๊ฐ€๋Šฅ.

๋ฌธ์ œ 1

์ •์ˆ˜ ๋ฐฐ์—ด์„ ์ •๋ ฌํ•ด์„œ ๋ฐ˜ํ™˜ํ•˜๋Š” solution( ) ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•˜์„ธ์š”.
์ œ์•ฝ์กฐ๊ฑด

  • ์ •์ˆ˜ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋Š” 2 ์ด์ƒ 105 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • ์ •์ˆ˜ ๋ฐฐ์—ด์˜ ๊ฐ ๋ฐ์ดํ„ฐ ๊ฐ’์€ -100,000 ์ด์ƒ 100,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
from sys import stdin, stdout

def solution(arr):
  arr.sort()
  print(arr)
  
input = stdin.readline 
arr=list(map(int,input().split()))
solution(arr)

sort()๋Š” ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ NlogN์ด๋‹ค. ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜๋Š” ์ตœ๋Œ€ 105๊ฐœ์ด๊ธฐ ๋•Œ๋ฌธ์—, O(n2)์ธ ๋ฒ„๋ธ” ์ •๋ ฌ์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค.

๋ฌธ์ œ 2

์ •์ˆ˜ ๋ฐฐ์—ด์„ ํ•˜๋‚˜ ๋ฐ›์Šต๋‹ˆ๋‹ค. ๋ฐฐ์—ด์˜ ์ค‘๋ณต๊ฐ’์„ ์ œ๊ฑฐํ•˜๊ณ  ๋ฐฐ์—ด ๋ฐ์ดํ„ฐ๋ฅผ ๋‚ด๋ฆผ์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌํ•ด์„œ ๋ฐ˜ํ™˜ํ•˜๋Š” solution( ) ํ•จ์ˆ˜๋ฅผ ๊ตฌํ˜„ํ•˜์„ธ์š”.

์ œ์•ฝ์กฐ๊ฑด

  • ๋ฐฐ์—ด ๊ธธ์ด๋Š” 2 ์ด์ƒ 1,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • ๊ฐ ๋ฐฐ์—ด์˜ ๋ฐ์ดํ„ฐ ๊ฐ’์€ -100,000 ์ด์ƒ 100,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
from sys import stdin, stdout

def solution(arr):
  arr=list(set(arr))
  arr.sort(reverse=True)
  print(arr)
  
input = stdin.readline 
arr=list(map(int,input().split()))
solution(arr)

๋งˆ์ฐฌ๊ฐ€์ง€๋กœ sort()๋Š” ์‹œ๊ฐ„ ๋ณต์žก๋„๊ฐ€ NlogN์ด๋‹ค. ๋ฐ์ดํ„ฐ ๊ฐœ์ˆ˜๋Š” ์ตœ๋Œ€ 1000๊ฐœ์ด๊ธฐ ๋•Œ๋ฌธ์—, O(n2)์ธ ๋ฒ„๋ธ” ์ •๋ ฌ์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์—†๋‹ค.
set()ํ•จ์ˆ˜๋กœ O(n)์˜ ์‹œ๊ฐ„ ๋ณต์žก๋„๋กœ ์ค‘๋ณต์„ ์ œ๊ฑฐํ•  ์ˆ˜ ์žˆ๋‹ค.

ํŒŒ์ด์ฌ์—๋Š” ์ฝ”๋”ฉ ํ…Œ์ŠคํŠธ์— ์œ ์šฉํ•œ ํ•จ์ˆ˜๊ฐ€ ๋งŽ๋‹ค. ๊ตณ์ด ์ง์ ‘ ์ž‘์„ฑํ•˜๋ ค ํ•˜์ง€ ๋งˆ๋ผ

๋ฌธ์ œ 3

์ •์ˆ˜ ๋ฐฐ์—ด numbers๊ฐ€ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. numbers์—์„œ ์„œ๋กœ ๋‹ค๋ฅธ ์ธ๋ฑ์Šค์— ์žˆ๋Š” 2๊ฐœ์˜ ์ˆ˜๋ฅผ ๋ฝ‘์•„ ๋”ํ•ด ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ์ˆ˜๋ฅผ ๋ฐฐ์—ด์— ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ๋‹ด์•„ ๋ฐ˜ํ™˜ํ•˜๋Š” solution( ) ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•˜์„ธ์š”.

์ œ์•ฝ์กฐ๊ฑด

  • numbers์˜ ๊ธธ์ด๋Š” 2 ์ด์ƒ 100 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • numbers์˜ ๋ชจ๋“  ์ˆ˜๋Š” 0 ์ด์ƒ 100 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
from sys import stdin, stdout

def solution(arr):
  ans=[]
  for i in range(len(arr)):
    for j in range(i+1,len(arr)):
      ans.append(arr[i]+arr[j])
      
  ans=sorted(list(set(ans)))
  print(ans)
  
input = stdin.readline 
arr=list(map(int,input().split()))
solution(arr)

๋ฌธ์ œ 4

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

  • 1๋ฒˆ ์ˆ˜ํฌ์ž๊ฐ€ ์ฐ๋Š” ๋ฐฉ์‹ : 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
  • 2๋ฒˆ ์ˆ˜ํฌ์ž๊ฐ€ ์ฐ๋Š” ๋ฐฉ์‹ : 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
  • 3๋ฒˆ ์ˆ˜ํฌ์ž๊ฐ€ ์ฐ๋Š” ๋ฐฉ์‹ : 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4,5,
    1๋ฒˆ ๋ฌธ์ œ๋ถ€ํ„ฐ ๋งˆ์ง€๋ง‰ ๋ฌธ์ œ๊นŒ์ง€์˜ ์ •๋‹ต์ด ์ˆœ์„œ๋Œ€๋กœ ์ €์žฅ๋œ ๋ฐฐ์—ด answers๊ฐ€ ์ฃผ์–ด์กŒ์„ ๋•Œ ๊ฐ€์žฅ ๋งŽ์€ ๋ฌธ์ œ๋ฅผ ๋งžํžŒ ์‚ฌ๋žŒ์ด ๋ˆ„๊ตฌ์ธ์ง€ ๋ฐฐ์—ด์— ๋‹ด์•„ ๋ฐ˜ํ™˜ํ•˜๋„๋ก solution( ) ํ•จ์ˆ˜๋ฅผ ์ž‘์„ฑํ•˜์„ธ์š”.

์ œ์•ฝ์กฐ๊ฑด

  • ์‹œํ—˜์€ ์ตœ๋Œ€ 10,000 ๋ฌธ์ œ๋กœ ๊ตฌ์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.
  • ๋ฌธ์ œ์˜ ์ •๋‹ต์€ 1, 2, 3, 4, 5 ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค.
  • ๊ฐ€์žฅ ๋†’์€ ์ ์ˆ˜๋ฅผ ๋ฐ›์€ ์‚ฌ๋žŒ์ด ์—ฌ๋Ÿฟ์ด๋ผ๋ฉด ๋ฐ˜ํ™˜ํ•˜๋Š” ๊ฐ’์„ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌํ•˜์„ธ์š”.
from sys import stdin

def solution(answers):
  scores=[0]*3
  patterns=[
    [1,2,3,4,5],
    [2,1,2,3,2,4,2,5],
    [3,3,1,1,2,2,4,4,5,5]
  ]
  for i, answer in enumerate(answers):
    for j, pattern in enumerate(patterns):
      if answer==pattern[i%len(pattern)]:
        scores[j]+=1
  
  max_score=max(scores)
  result=[]      
  for i,score in enumerate(scores):
    if score==max_score:
      result.append(i+1)
  
  return result    

  
input = stdin.readline 
answers=list(map(int,input().split()))

solution(answers)

enumerate๋กœ ์ˆœํšŒํ•œ๋‹ค.

profile
๊ณ ๊ฐ์—๊ฒŒ ์‹ ๋ขฐ๋ฅผ ๋งŒ๋“œ๋Š” ๋ฐฑ์—”๋“œ ๊ฐœ๋ฐœ์ž ์•ˆํƒœํ˜„์ž…๋‹ˆ๋‹ค.

0๊ฐœ์˜ ๋Œ“๊ธ€