# ๋ถ๋ ๊ฐ๊ธฐ # 250137 # lv1 # Python
# ๋ฌธ์
์ด๋ค ๊ฒ์์๋ ๋ถ๋ ๊ฐ๊ธฐ๋ผ๋ ๊ธฐ์ ์ด ์์ต๋๋ค.
๋ถ๋ ๊ฐ๊ธฐ๋ t์ด ๋์ ๋ถ๋๋ฅผ ๊ฐ์ผ๋ฉด์ 1) 1์ด๋ง๋ค x๋งํผ์ ์ฒด๋ ฅ์ ํ๋ณตํฉ๋๋ค. t์ด ์ฐ์์ผ๋ก ๋ถ๋๋ฅผ ๊ฐ๋ ๋ฐ ์ฑ๊ณตํ๋ค๋ฉด y๋งํผ์ ์ฒด๋ ฅ์ ์ถ๊ฐ๋ก ํ๋ณตํฉ๋๋ค. ๊ฒ์ ์บ๋ฆญํฐ์๋ ์ต๋ ์ฒด๋ ฅ์ด ์กด์ฌํด ํ์ฌ ์ฒด๋ ฅ์ด ์ต๋ ์ฒด๋ ฅ๋ณด๋ค ์ปค์ง๋ ๊ฒ์ ๋ถ๊ฐ๋ฅํฉ๋๋ค.
2) ๊ธฐ์ ์ ์ฐ๋ ๋์ค ๋ชฌ์คํฐ์๊ฒ ๊ณต๊ฒฉ์ ๋นํ๋ฉด ๊ธฐ์ ์ด ์ทจ์๋๊ณ , ๊ณต๊ฒฉ์ ๋นํ๋ ์๊ฐ์๋ ์ฒด๋ ฅ์ ํ๋ณตํ ์ ์์ต๋๋ค. ๋ชฌ์คํฐ์๊ฒ ๊ณต๊ฒฉ๋นํด ๊ธฐ์ ์ด ์ทจ์๋นํ๊ฑฐ๋ ๊ธฐ์ ์ด ๋๋๋ฉด ๊ทธ ์ฆ์ ๋ถ๋ ๊ฐ๊ธฐ๋ฅผ ๋ค์ ์ฌ์ฉํ๋ฉฐ, ์ฐ์ ์ฑ๊ณต ์๊ฐ์ด 0์ผ๋ก ์ด๊ธฐํ๋ฉ๋๋ค. ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ์ ๋ฐ์ผ๋ฉด 3) ์ ํด์ง ํผํด๋๋งํผ ํ์ฌ ์ฒด๋ ฅ์ด ์ค์ด๋ญ๋๋ค. ์ด๋, ํ์ฌ ์ฒด๋ ฅ์ด 0 ์ดํ๊ฐ ๋๋ฉด ์บ๋ฆญํฐ๊ฐ ์ฃฝ์ผ๋ฉฐ ๋ ์ด์ ์ฒด๋ ฅ์ ํ๋ณตํ ์ ์์ต๋๋ค.
๋น์ ์ ๋ถ๋๊ฐ๊ธฐ ๊ธฐ์ ์ ์ ๋ณด, ์บ๋ฆญํฐ๊ฐ ๊ฐ์ง ์ต๋ ์ฒด๋ ฅ๊ณผ ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ ํจํด์ด ์ฃผ์ด์ง ๋ ์บ๋ฆญํฐ๊ฐ ๋๊น์ง ์์กดํ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค.
๋ถ๋ ๊ฐ๊ธฐ ๊ธฐ์ ์ ์์ ์๊ฐ, 1์ด๋น ํ๋ณต๋, ์ถ๊ฐ ํ๋ณต๋์ ๋ด์ 1์ฐจ์ ์ ์ ๋ฐฐ์ด bandage์ ์ต๋ ์ฒด๋ ฅ์ ์๋ฏธํ๋ ์ ์ health, ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ ์๊ฐ๊ณผ ํผํด๋์ ๋ด์ 2์ฐจ์ ์ ์ ๋ฐฐ์ด attacks๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ๋ชจ๋ ๊ณต๊ฒฉ์ด ๋๋ ์งํ ๋จ์ ์ฒด๋ ฅ์ return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์. ๋ง์ฝ ๋ชฌ์คํฐ์ ๊ณต๊ฒฉ์ ๋ฐ๊ณ ์บ๋ฆญํฐ์ ์ฒด๋ ฅ์ด 0 ์ดํ๊ฐ ๋์ด ์ฃฝ๋๋ค๋ฉด -1์ return ํด์ฃผ์ธ์.
# ์ ํ์ฌํญ
- bandage๋ [์์ ์๊ฐ, ์ด๋น ํ๋ณต๋, ์ถ๊ฐ ํ๋ณต๋] ํํ์ ๊ธธ์ด๊ฐ 3์ธ ์ ์ ๋ฐฐ์ด์
๋๋ค.
- 1 ≤ ์์ ์๊ฐ = t ≤ 50
- 1 ≤ ์ด๋น ํ๋ณต๋ = x ≤ 100
- 1 ≤ ์ถ๊ฐ ํ๋ณต๋ = y ≤ 100
- 1 ≤ health ≤ 1,000
- 1 ≤ attacks์ ๊ธธ์ด ≤ 100
- attacks[i]๋ [๊ณต๊ฒฉ ์๊ฐ, ํผํด๋] ํํ์ ๊ธธ์ด๊ฐ 2์ธ ์ ์ ๋ฐฐ์ด์ ๋๋ค.
- attacks๋ ๊ณต๊ฒฉ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌ๋ ์ํ์ ๋๋ค.
- attacks์ ๊ณต๊ฒฉ ์๊ฐ์ ๋ชจ๋ ๋ค๋ฆ ๋๋ค.
- 1 ≤ ๊ณต๊ฒฉ ์๊ฐ ≤ 1,000
- 1 ≤ ํผํด๋ ≤ 100
# ํ์ด
[์กฐ๊ฑด ๊ฐ๋จ ์ ๋ฆฌ]
1. t์ด ๋์ x * t ๋งํผ ์ฒด๋ ฅ ํ๋ณต (์ฐ์ ์ฑ๊ณต ์ฌ๋ถ๋ฅผ ๋ฐ์ ธ์ผ ํจ.)
2. t์ด ์ฐ์ ์ฒด๋ ฅ ํ๋ณต ์ + y ๋งํผ ์ถ๊ฐ ํ๋ณต. ๋จ, ์ต๋ ์ฒด๋ ฅ ์กด์ฌ. ๊ทธ ์ด์ x
3. ๊ณต๊ฒฉ์ ๋ฐ์ผ๋ฉด ์ฒด๋ ฅ ํ๋ณต ์ทจ์. ์ฑ๊ณต ์๊ฐ 0์ผ๋ก ์ด๊ธฐํ
4. 'ํ์ฌ ์ฒด๋ ฅ - ๊ณต๊ฒฉ' ์ด 0 ์ดํ๋ฉด ์ฌ๋ง์ผ๋ก ๊ฐ์ฃผ. (์๋๋ฉด ๊ทธ๋ฅ ๋นผ๊ธฐ)
- ์ฃผ์ด์ง๋ ๋ณ์ : t (์์ ์๊ฐ) , x (์ด๋น ํ๋ณต๋) , y (์ถ๊ฐ ์ฒด๋ ฅ ํ๋ณต๋) == {bandage[0], [1], [2]}
- ์๋ก ์ ์ธํ๋ ๋ณ์ : cur_time (ํ์ฌ ์๊ฐ) , success (์ฐ์์ผ๋ก ์ฑ๊ณตํ ์๊ฐ) , first_health (์ด๊ธฐ ์ฒด๋ ฅ = ์ต๋ ์ฒด๋ ฅ)
๋ด ํ์ด)
def solution(bandage, health, attacks):
attack = 0
success = 0 # ์ฐ์ ์น๋ฃ ์ฑ๊ณต ํ์
first_health = health # ํ์ฌ(์ต๋)์ฒด๋ ฅ
whole_time = attacks[len(attacks) - 1][0] # ์ด ์๊ฐ
for i in range(whole_time):
cur_time = i + 1
if cur_time == attacks[attack][0]: # ๊ณต๊ฒฉ์ ๋ฐ๋ ๊ฒฝ์ฐ
health -= attacks[attack][1]
success = 0 # ์ฐ์ ์ฑ๊ณต ์๊ฐ ์ด๊ธฐํ
attack += 1
else:
success += 1
if success == bandage[0]: # t (์์ ์๊ฐ)
health += bandage[2] # y
success = 0 # ์ฐ์ ์ฑ๊ณต ์๊ฐ ์ด๊ธฐํ
health += bandage[1] # x (์ด๋น ํ๋ณต๋)
if health > first_health:
health = first_health
if health <= 0: # ์ฒด๋ ฅ์ด 0์ดํ๊ฐ ๋๋ค๋ฉด
return -1
return health
๋จ์ ํ์ด. ์ฐธ๊ณ ์ฉ)
def solution(bandage, health, attacks):
# <์์ด๋์ด>
# ํ์ฌ ์๊ฐ์์ ๊ณต๊ฒฉ์ด ๋ค์ด์๋์ง ํ์ธ [cur_time, attacks[i][0] -> ๋น๊ต]
# ์๋ค์ด์์ผ๋ฉด success += 1, health += x, ๊ณต๊ฒฉ์ด ๋ค์ด์์ผ๋ฉด [health-attack[i][1] # -> 0 ๋ณด๋ค ์์ผ๋ฉด ์ฌ๋ง -1 return, ํฌ๋ฉด ๊ณ์]
# ์ ๊ณผ์ ๋ฐ๋ณต (์ต๋ ์ฒด๋ ฅ๋ณด๋ค ์ปค์ง๋ฉด ์ทจ์)
# ๋ง์ฝ success == t ๋ฉด y ๋งํผ health ์ถ๊ฐ ํ๋ณต. ๊ทธ๋ฆฌ๊ณ success = 0์ด๊ธฐํ
# t = ์์ ์๊ฐ, x = ์ด๋น ํ๋ณต๋, y = ์ถ๊ฐ ํ๋ณต๋
t, x, y = bandage[0], bandage[1], bandage[2]
cur_time, success = 0, 0
# last_attack = attacks[-1][0] > ๊ตณ์ด ํ์์์!
first_health = health
for i in range(len(attacks)):
if health <= 0:
break
while True:
cur_time += 1
success += 1
if cur_time == attacks[i][0]:
health -= attacks[i][1]
success = 0
break
else:
if health != first_health:
if success == t:
health = health + x + y
success = 0
if health > first_health:
health = first_health
else:
health += x
if health > first_health:
health = first_health
if health <= 0:
health = -1
return health