๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
Code/Coding Test

[์ด์ฝ”ํ…Œ] 4์ผ์ฐจ Greedy _ ๋งŒ๋“ค ์ˆ˜ ์—†๋Š” ๊ธˆ์•ก, ๋ณผ๋ง๊ณต ๊ณ ๋ฅด๊ธฐ

by hyelog 2022. 5. 9.

๐Ÿ†Today Code Test


[1] ๋งŒ๋“ค ์ˆ˜ ์—†๋Š” ๊ธˆ์•ก ๐Ÿ”ด

๋™๋„ค ํŽธ์˜์ ์˜ ์ฃผ์ธ์ธ ๋™๋นˆ์ด๋Š” N๊ฐœ์˜ ๋™์ „์„ ๊ฐ€์ง€๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ด๋•Œ N๊ฐœ์˜ ๋™์ „์„ ์ด์šฉํ•˜์—ฌ ๋งŒ๋“ค ์ˆ˜ ์—†๋Š” ์–‘์˜ ์ •์ˆ˜ ๊ธˆ์•ก ์ค‘ ์ตœ์†Ÿ๊ฐ’์„ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์„ธ์š”

์ž…๋ ฅ ์กฐ๊ฑด

  • ์ฒซ์งธ ์ค„์—๋Š” ๋™์ „์˜ ๊ฐœ์ˆ˜๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์–‘์˜ ์ •์ˆ˜ N์ด ์ฃผ์ €์ง‘๋‹ˆ๋‹ค. (1 ≤ N ≤ 1,000)
  • ๋‘˜์งธ ์ค„์—๋Š” ๊ฐ ๋™์ „์˜ ํ™”ํ ๋‹จ์œ„๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” N๊ฐœ์˜ ์ž์—ฐ์ˆ˜๊ฐ€ ์ฃผ์–ด์ง€๋ฉฐ, ๊ฐ ์ž์—ฐ์ˆ˜๋Š” ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•ฉ๋‹ˆ๋‹ค. ์ด๋•Œ, ๊ฐ ํ™”ํ ๋‹จ์œ„๋Š” 1,000,000 ์ดํ•˜์˜ ์ž์—ฐ์ˆ˜ ์ž…๋‹ˆ๋‹ค.

์ถœ๋ ฅ ์กฐ๊ฑด

  • ์ฒซ์งธ ์ค„์— ์ฃผ์–ด์ง„ ๋™์ „๋“ค๋กœ ๋งŒ๋“ค ์ˆ˜ ์—†๋Š” ์–‘์˜ ์ •์ˆ˜ ๊ธˆ์•ก ์ค‘ ์ตœ์†Ÿ๊ฐ’์„ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

๐Ÿ› Problem Approach

โœ… ํ•  ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ์กฐํ•ฉ์„ ๊ตฌํ•จ → ์กฐํ•ฉ ์•ˆ ์ˆ˜๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ์ฒดํฌํ•จ → ์ฒดํฌ ์•ˆ๋˜๋Š” ์ˆ˜ ์ถœ๋ ฅ

๐Ÿ”‘Solution

#25'
n = int(input())
coins = list(map(int, input().split()))[:n]
coins.sort()

per = set(coins)
for i in range(len(coins)):
  make = coins[i]
  for j in range(i+1,len(coins)):
    make += coins[j]
    per.add(make)

cnt = 1

while True:
  if cnt not in per:
    print(cnt)
    break
  cnt += 1

# ์œ„์˜ ์ฝ”๋“œ๋Š” ํ‹€๋ฆผ
์˜ˆ์‹œ ) input : 1 2 3 9 output : 7์ด ๋‹ต

๋‚ด ์ฝ”๋“œ๋Š” 4๊ฐ€ ๋‚˜์˜ด; ํ•ฉ์ด ์•„๋‹Œ ๋ชจ๋“  ์กฐํ•ฉ์„ ์ฐพ์ง€ ๋ชป ํ•˜๊ธฐ ๋•Œ๋ฌธ

 

๋”๋ณด๊ธฐ

๐ŸŽˆ๊ตฌ์กฐ ์ดํ•ด ํ•˜๊ธฐ

step 0 1์› ๋ถ€ํ„ฐ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด target = 1
step 1 target์ด ์žˆ๋‹ค๋ฉด, target์„ 1 + 1๋กœ ์—…๋ฐ์ดํŠธ (→ 2์›๊นŒ์ง€ ๋ชจ๋“  ๊ธˆ์•ก์„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค)
step 2 ๋‹ค์Œ ๋™์ „์œผ๋กœ ํ˜„์žฌ target์„ ๋งŒ์กฑ ์‹œํ‚ฌ ์ˆ˜ ์žˆ๋Š”์ง€ ํ™•์ธ(ํ˜„์žฌ ๋™์ „ ๊ฐ’๋ณด๋‹ค target์ด ์ž‘์•„์•ผ ํ•œ๋‹ค) → ๊ฐ€๋Šฅํ•˜๋‹ค๋ฉด,
target update
step 3 ๊ณ„์† ๋ฐ˜๋ณตํ•˜๋‹ค๊ฐ€, ๋™์ „ ๊ฐ’์ด target๋ณด๋‹ค ํฌ๋‹ค๋ฉด, ํ˜„์žฌ target์€ ๋งŒ๋“ค ์ˆ˜ ์—†๋‹ค๋Š” ๋ง์ด๋ฏ€๋กœ ์ข…๋ฃŒ
step 4 target์ด ๋งŒ๋“ค ์ˆ˜ ์—†๋Š” ๊ธˆ์•ก์ด ๋œ๋‹ค.

n = int(input())
data = list(map(int, input().split())
data.sort()

target = 1
for x in data:
	if target < x: 
		break
	target += x

print target

[2] ๋ณผ๋ง๊ณต ๊ณ ๋ฅด๊ธฐ ๐ŸŸข

A, B ๋‘ ์‚ฌ๋žŒ์ด ๋ณผ๋ง์„ ์น˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ๋‘ ์‚ฌ๋žŒ์€ ์„œ๋กœ ๋ฌด๊ฒŒ๊ฐ€ ๋‹ค๋ฅธ ๋ณผ๋ง๊ณต์„ ๊ณ ๋ฅด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค. ๋ณผ๋ง๊ณต์€ ์ด N๊ฐœ๊ฐ€ ์žˆ์œผ๋ฉฐ ๊ฐ ๋ณผ๋ง๊ณต๋งˆ๋‹ค ๋ฌด๊ฒŒ๊ฐ€ ์ ํ˜€ ์žˆ๊ณ , ๊ณต์˜ ๋ฒˆํ˜ธ๋Š” 1๋ฒˆ๋ถ€ํ„ฐ ์ˆœ์„œ๋Œ€๋กœ ๋ถ€์—ฌ๋ฉ๋‹ˆ๋‹ค. ๋˜ํ•œ ๊ฐ™์€ ๋ฌด๊ฒŒ์˜ ๊ณต์ด ์—ฌ๋Ÿฌ ๊ฐœ ์žˆ์„ ์ˆ˜ ์žˆ์ง€๋งŒ, ์„œ๋กœ ๋‹ค๋ฅธ ๊ณต์œผ๋กœ ๊ฐ„์ฃผํ•ฉ๋‹ˆ๋‹ค. ๋ณผ๋ง๊ณต์˜ ๋ฌด๊ฒŒ๋Š” 1๋ถ€ํ„ฐ M๊นŒ์ง€์˜ ์ž์—ฐ์ˆ˜์˜ ํ˜•ํƒœ๋กœ ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.

  1. N๊ฐœ์˜ ๊ณต์˜ ๋ฌด๊ฒŒ๊ฐ€ ๊ฐ๊ฐ ์ฃผ์–ด์งˆ ๋•Œ, ๋‘ ์‚ฌ๋žŒ์ด ๋ณผ๋ง๊ณต์„ ๊ณ ๋ฅด๋А ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์„ธ์š”.

์ž…๋ ฅ ์กฐ๊ฑด

  • ์ฒซ์งธ ์ค„์— ๋ณผ๋ง๊ณต์˜ ๊ฐœ์ˆ˜ N, ๊ณต์˜ ์ตœ๋Œ€ ๋ฌด๊ฒŒ M์ด ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋˜์–ด ๊ฐ๊ฐ ์ž์—ฐ์ˆ˜ ํ˜•ํƒœ๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค.(1 ≤ N ≤ 1,000 , 1 ≤ M ≤ 10)
  • ๋‘˜์งธ ์ค„์— ๊ฐ ๋ณผ๋ง๊ณต์˜ ๋ฌด๊ฒŒ K๊ฐ€ ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋˜์–ด ์ˆœ์„œ๋Œ€๋กœ ์ž์—ฐ์ˆ˜ ํ˜•ํƒœ๋กœ ์ฃผ์–ด์ง‘๋‹ˆ๋‹ค. (1 ≤ K ≤ M)

์ถœ๋ ฅ ์กฐ๊ฑด

  • ์ฒซ์งธ ์ค„์— ๋‘ ์‚ฌ๋žŒ์ด ๋ณผ๋ง๊ณต์„ ๊ณ ๋ฅด๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ์ถœ๋ ฅํ•ฉ๋‹ˆ๋‹ค.

๐Ÿ› Problem Approach

โœ… ์กฐํ•ฉ ๊ฒฝ์šฐ์˜ ์ˆ˜ ์ถœ๋ ฅํ•˜๊ธฐ → ์กฐํ•ฉ ๊ฒฝ์šฐ์˜ ์ˆ˜ ์ค‘์—์„œ ๊ฐ™์€ ๋ฌด๊ฒŒ๋ฅผ ๊ฐ€์ง„ ์•  ๋นผ์ค˜์•ผ → ์กฐ๊ฑด๋ฌธ์œผ๋กœ ๊ฑธ๊ธฐ → ๊ฒฝ์šฐ์˜ ์ˆ˜๋‹ˆ๊นŒ ํšŸ์ˆ˜๋งŒ ์„ธ๊ณ , ์ €์žฅ์†Œ ๋‚ญ๋น„ํ•˜์ง€ ๋ง๊ธฐ!

๐Ÿ”‘Solution

# 10'21"
n, m = map(int, input().split())
weights = list(map(int, input().split()))[:n]

cur = 0
cnt = 0

for i in range(len(weights)):
   cur = weights[i]
   for j in range(i+1,len(weights)):
     if cur != weights[j]:
       cnt += 1

print(cnt)
๋”๋ณด๊ธฐ

$O(n)$์œผ๋กœ ํ’€๊ธฐ

n, m = map(int, input().split())
data = list(map(int, input().split()))

array = [0] * 11 # 1๋ถ€ํ„ฐ 10๊นŒ์ง€์˜ ๋ฌด๊ฒŒ๋ฅผ ๋‹ด์„ ์ˆ˜ ์žˆ๋Š” ๋ฆฌ์ŠคํŠธ

for x in data:
	array[x] += 1 # ๊ฐ ๋ฌด๊ฒŒ์— ํ•ด๋‹นํ•˜๋Š” ๋ณผ๋ง๊ณต ๊ฐœ์ˆ˜ ์นด์šดํŠธ
result = 0

#1๋ถ€ํ„ฐ m๊นŒ์ง€์˜ ๊ฐ ๋ฌด๊ฒŒ์— ๋Œ€ํ•˜์—ฌ ์ฒ˜๋ฆฌ
for i in range(1, m+1):
	n -= array[i] # ๋ฌด๊ฒŒ๊ฐ€ i ์ธ ๋ณผ๋ง๊ณต์˜ ๊ฐœ์ˆ˜ ์ œ์™ธ (A์„ ํƒ)
	result += array[i] * n # B๊ฐ€ ์„ ํƒํ•˜๋Š” ๊ฒฝ์šฐ์˜ ์ˆ˜์™€ ๊ณฑํ•˜๊ธฐ

print(result)

๋Œ“๊ธ€