โ 10162 ์ ์๋ ์ธ์ง โ
T=int(input())
a=T//300
flag=0
for i in range(a,-1,-1):
after_A=T-i*300
b=after_A//60
for j in range(b,-1,-1):
after_B=after_A-j*60
if after_B%10==0:
flag+=1
k=after_B//10
print(i,j,k)
break
if flag==1:
break
if flag==0:print(-1)
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) A / B / C ๋ฒํผ์ ๋๋ฅด๋ ์ํฉ
: ์ข ํฉ ์ํฉ) A / B / C ๋ฒํผ์ ์ฌ๋ฌ ๋ฒ ๋๋ฌ T time์ ๋ฑ ๋ง๊ฒ ์๋ฆฌํ๊ธฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ , ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ ์ A๋ฒํผ์ ์ฐ์ ์ ์ผ๋ก → B๋ฒํผ → C๋ฒํผ์ ๋๋ฅธ๋ค. (์๊ฐ ํจ์จ์ ์ํด ๊ตฌํ๋ฉด ๋ฐ๋ก break๋ฌธ)
๐ ๋จผ์ 300์ด๋ก ๋๋ ์ง๋ค๋ฉด, ๊ทธ๋ค์ 100์ด๋ก ๋๋ ์ง๋ ์ง ํ์ธํ๊ณ , ๋ง์ง๋ง์ผ๋ก 10์ผ๋ก ๋๋ ์ง๋ ์ง ์ฐจ๋ก๋๋ก ํ์ธ.
→ greedyํ ๋ฌธ์ ์ด๋ฏ๋ก, 300์ด๋ก ๋๋ ๋ชซ์ด ํฐ ๊ฒ๋ถํฐ 0๊น์ง ๊ฑฐ๊พธ๋ก ์ฐจ๋ก๋๋ก ํ์ธํ๋ค๊ฐ ๋ต์ด ๋์ค๋ฉด print()ํ๊ณ ๋ฐ๋ก break!
โ 3578 Holes โ
h=int(input())
if h==0:print(1)
elif h==1:print(0)
else:
if h%2==0:print('8'*(h//2))
else:print('4'+'8'*(h//2))
๐ greedy ๊ด์ ๋ถ์ (๊ฐ๋ณ ์ํฉ์ด ๋ถ๊ธฐ๋ฌธ์ผ๋ก ๋๋์ด์ง)
: ๊ฐ๋ณ ์ํฉ) hole์ ๋ง๋ค๊ธฐ ์ํด 0/4/6/9/8์ค ํ ๊ฐ ์ซ์๋ฅผ ๋๋ฅด๋ ์ํฉ
: ์ข ํฉ ์ํฉ) ์ซ์๋ฅผ ์ฌ๋ฌ ๋ฒ ๋๋ฌ ๋ง๋ ์ซ์๊ฐ ์ต์๊ฐ์ผ๋ก ๋์ค๊ณ / ๋๋ฅด๋ ๊ฐ์ h๊ฐ ์ต์๊ฐ์ด ๋๊ฒ๋ ๋ง๋ค๊ธฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ๋๋ฅผ ๋ 8์ ์ฐ์ ์ ์ผ๋ก ๋๋ฅด๋, h๊ฐ ํ์์ผ ๊ฒฝ์ฐ 4๋ฅผ ๋จผ์ ๋๋ฅด๊ณ ์ดํ 8 ๋๋ฅด๊ธฐ (h๊ฐ 0๊ณผ 1๋ง ์์ธ)
๐ ๊ตฌ๋ฉ์ด ์๊ธฐ๋ ์ซ์ 0,4,6,9,8์ ์กฐํฉ์ผ๋ก๋ง ๋ง๋ค์ด์ผ ํ๊ณ , ๋งจ ์์ 0์ด ๋ ๋ฒ ์ฐ์ ์ฌ ์ ์๋ค.
๐ ์ต์๊ฐ์ผ๋ก ๋ง๋ค์ด์ผ ํ๋ฏ๋ก ์๋ฆฟ์๊ฐ ์ต์์ฌ์ผ ํ๋ค. ๋ฐ๋ผ์ 8๋ก ์ต๋ํ ๊ตฌ์ฑ์ด ๋์ด์ผ ํจ (greedy)
โ ํ์๊ฐ์์ hole์ ๋ง๋ค์ด์ผ ํ๋ค๋ฉด 8์ ์ต๋ํ ์ฑ์ฐ๊ณ , ๋ง์ง๋ง ๊ฐ์ 1๊ฐ๋ ๊ฐ์ฅ ์ต์๊ฐ์ธ 4 - ์ฆ 48888~ ํํ์ฌ์ผ ํ๋ค.
โก ์ง์๊ฐ์์ hole์ ๋ง๋ค์ด์ผ ํ๋ค๋ฉด 8๋ก๋ง ๊ตฌ์ฑ๋์ด์ผ ํ๋ค.
โขโฃ hole์ด ์๋ค๋ฉด 1, hole์ด 1๊ฐ ์๋ค๋ฉด 1
โ 2720 ์ธํ์ ์ฌ์ฅ ๋ํ โ
for _ in range(int(input())):
C=int(input())
print(C//25,(C%25)//10,((C%25)%10)//5,C%5)
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ์ฟผํฐ / ๋ค์ / ๋์ผ / ํ๋ ์ค ํ ํํ์ ์ข ๋ฅ๋ฅผ ์ ํํด ๋์ ๊ฑฐ์ฌ๋ฌ ์ฃผ๋ ์ํฉ
: ์ข ํฉ ์ํฉ) ์ฃผ์ด์ง ๋์ ์ฌ๋ฌ ํํ๋ก ๊ฑฐ์ฌ๋ฌ ์ฃผ๋ ์ํฉ / ๋๋ฅด๋ ๊ฐ์ h๊ฐ ์ต์๊ฐ์ด ๋๊ฒ๋ ๋ง๋ค๊ธฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ์ฟผํฐ - ๋ค์ - ๋์ผ - ํ๋ ์์ผ๋ก ๋จผ์ ์ข ๋ฅ๋ฅผ ์ ํ
๐ ๋์ ์ ๊ฐ์๋ฅผ ์ต์ํ ํด์ผํ๋ฏ๋ก ์ฟผํฐ - ๋ค์ - ๋์ผ - ํ๋ ์์ผ๋ก greedyํ๊ฒ ์ ์ผ ํฐ ๊ธ์ก๋ถํฐ ๊ฐ์๋ฅผ countํ๋ค
โ 14720 ์ฐ์ ์ถ์ โ
import sys
input=sys.stdin.readline
N=int(input())
l=list(map(int,input().split()))
t=0
direction=0
for i in l:
if direction==0 and i==0:
t+=1
direction+=1
elif direction==1 and i==1:
t+=1
direction+=1
elif direction==2 and i==2:
t+=1
direction-=2
print(t)
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ๊ฐ ์ฐ์ ๊ฐ๊ฒ์์ ๋ธ๊ธฐ / ์ด์ฝ / ๋ฐ๋๋ / x(์ ๋ง์ฌ) ์ค ํ ๊ฐ๋ฅผ ์ ํํด ๋ง์๋ ์ํฉ
: ์ข ํฉ ์ํฉ) ๋ชจ๋ ์ฐ์ ๊ฐ๊ฒ์์ ๊ฐ๊ฐ์ ์ฐ์ ๋ฅผ ๋ค์ํ๊ฒ ์ ํํด ๋ง์๋ ์ํฉ / ๋ง์๋ ์ฐ์ ๊ฐ์๊ฐ ์ต๋๊ฐ์ด ๋๊ฒ๋ ๋ง๋ค๊ธฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ๊ฐ ๊ฐ๊ฒ์์๋ ์ฐ์ ๋ฅผ 1๋ฒ๋ง ๋ง์ค ์ ์์ผ๋ฏ๋ก ๋ง์๋ ๊ท์น์ด ์ฑ๋ฆฝํ๋ค๋ฉด '๋ฐ๋ก' ๊ทธ ๊ฐ๊ฒ์์ ๋ง์ฌ. (X๋ฅผ ์ ํํ์ง ์๊ณ ๋ง์๋ ์๋ฃจ์ )
๐ ๋ง์ค ์ ์๋ค๋ฉด ๋ฐ๋ก ๋ง์๋, greedy ์ ํ! direction ๋ฐฉํฅ ๋ณ์๋ฅผ ์ฌ์ฉํด, direction ๋ณ์์ ๋ง๋ ๊ฐ์ด๋ผ๋ฉด ๋ฐ๋ก ๋ง์๊ฒ๋ ์ฝ๋ ์งฌ
๐ ๋ฐฉํฅ๋ณ์๋ฅผ ์ฌ์ฉํ ์ฝ๋ ๊ธฐ์ตํ์!
โ 17931 Greedily Increasing Subsequence โ
import sys
input=sys.stdin.readline
N=int(input())
A=list(map(int,input().split()))
ans=[A[0]]
l=1
cur=A[0]
for ai in A[1:]:
if ai>cur:
ans.append(ai)
l+=1
cur = ai
print(l)
print(*ans)
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) Subsequence๋ฅผ ๋ง๋ค๊ธฐ ์ํด ํ์ฌ์ ์ซ์๋ฅผ subsequence์ ๋ฃ์ ์ง ์ ๋ฃ์ ์ง ๊ฒฐ์ ํ๋ ์ํฉ
: ์ข ํฉ ์ํฉ) Greedily Increasing Subsequence๋ฅผ ๋ง๋๋ ์ํฉ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ํ์ฌ Cur ๊ฐ๋ณด๋ค ํฐ ๊ฐ์ด๋ฉด subsequence์ ๋ฃ๊ธฐ๋ฅผ ์ ํ
โ 5585 ๊ฑฐ์ค๋ฆ๋ โ
n=0
money=1000-int(input())
for x in [500,100,50,10,5,1]:
n+=(money//x)
money%=x
print(n)
๐ greedyํ๊ฒ ํฐ ํํ ๋จ์๋ถํฐ ๋จผ์ ์นด์ดํธ. ๊ทธ๋์ผ ์ต์ข ํํ ์งํ ๊ฐ์ ์ต์ํ ๊ฐ๋ฅ
โ 4796 ์บ ํ โ
import sys
input=sys.stdin.readline
i=0
while 1:
i+=1
L,P,V=map(int,input().split())
if (L,P,V)==(0,0,0):break
print(f'Case {i}: {(V//P)*L+min(L,V%P)}')
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ๊ฐ ์ผ์ ๋ณ๋ก ์บ ํ์ ๊ฐ ์ง, ๋ง ์ง ๊ฒฐ์
: ์ข ํฉ ์ํฉ) ์บ ํ์ฅ์ ๊ฐ๋ ๋ ์ ์ด ๋ํ๊ธฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ์บ ํ์ฅ ๊ฐ๋ ์ต๋ ์ผ์(์ต๋ํ ๊ฐ P์ผ ์ค 1์ผ๋ถํฐ L์ผ๊น์ง ์ญ ๊ฐ ๋ค์, ๊ทธ ๋ค์ P์ผ์์๋ 1์ผ์์ L์ผ๊น์ง ๊ฐ ์ ์๊ฒ ํ๋ค. ์ฃผ์ด์ง P์ผ์์ ์ต๋ L์ผ์ ๊ฝ๊ฝ ์ฑ์ฐ๋ ๊ฒ ๊ฐ P์ผ์์์ greedyํ ๊ฒฐ์ . ํ๋ฐ์ ๊ฐ๋ค๋ฉด ๋ค์ P์ผ์์์ L์ผ๊ณผ ๊ฒน์ณ ์บ ํ์ ๋ชป ๊ฐ ์ ์์ผ๋ฏ๋ก 1์ผ๋ถํฐ ๋ชฐ์ ๊ฐ๊ฒ ํด์ผ ์ต๋ L์ผ์ ๊ฝ๊ฝ ์ฑ์ + ๋๋จธ์ง๋ L์ผ๊ณผ ๋น๊ตํด์ min๊ฐ ์ถ๊ฐ)
โ 2864 5์ 6์ ์ฐจ์ด โ
A,B=input().split()
a1,b1=A.replace('6','5'),B.replace('6','5')
a2,b2=A.replace('5','6'),B.replace('5','6')
print(int(a1)+int(b1),int(a2)+int(b2))
๐ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) 5์ 6์ ๋ง๋๋ฉด ๊ฐ๊ฐ 5๋ก ๋ฐ๊ฟ ์ง, 6์ผ๋ก ๋ฐ๊ฟ ์ง ๊ฒฐ์
: ์ข ํฉ ์ํฉ) ๋ ์์ ํฉ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ
→ ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ : ์ต์๊ฐ์ ๋ชจ๋ 6์ 5๋ก, ์ต๋๊ฐ์ ๋ชจ๋ 5๋ฅผ 6์ผ๋ก (replace()๋ก ํ๋ฒ์)
โ 30019 ๊ฐ์์ค ์์ฝ ์์คํ โ
๐ ํ์ฌ ์์ ์์ ๋น์ฅ ๊ฐ์๊ฐ ๋จผ์ ์ด๋ฆฌ๋ ๊ฐ์๋ฅผ ์ ํํ๋ฏ๋ก greedy์ ์ ๊ทผ. cur list์ ๊ฐ ๊ฐ์์ค์ ๋ ์๊ฐ์ update. s๊ฐ ์๋ฐํ ์์ผ๋ก ์ฃผ์ด์ง๋ฏ๋ก ๊ฐ line ์งํํ๋ฉด์ ํ์ฌ์ e์ ๋น๊ตํด YES / NO ์ถ๋ ฅ
import sys
input=sys.stdin.readline
N,M=map(int,input().split())
cur = [0 for _ in range(N)]
for _ in range(M):
k,s,e=map(int,input().split())
if s >= cur[k-1]:
print('YES')
cur[k-1]= e
else:
print('NO')
'BOJ > ๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ Math & Geometry Upper-Beginner II - 19 Solvedโ (0) | 2023.04.06 |
---|---|
โ Math Beginner IV - 23 Solvedโ (0) | 2023.01.16 |
โ Math Beginner III - 30 Solvedโ (1) | 2022.11.18 |
โ Sorting Upper-Beginner I - 8 Solvedโ (0) | 2022.11.14 |
โ Implementation&Simulation Upper-Beginner I - 25 Solvedโ (0) | 2022.11.03 |
๋๊ธ