โ 2012 ๋ฑ์ ๋งค๊ธฐ๊ธฐ โ
import sys
input=sys.stdin.readline
N=int(input())
ans,i=0,1
for x in sorted([int(input()) for _ in range(N)]):
ans+=abs(x-i)
i+=1
print(ans)
๐ฒ greedy ์๊ณ ๋ฆฌ์ฆ์ ์ง๊ด์ ์ผ๋ก optimal solution์ ๋ชจ์ → ์ ์ฒด ์ต์ solution์ด๋ผ ์๊ฐํ๊ณ ์งํํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
๐ฒ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ๊ฐ์ ์์ํ ๋ฑ์์ ์ค์ ๋ฑ์ ๋ถ์ฌ, ๊ทธ๋ฆฌ๊ณ ๋ถ๋ง๋ ๊ตฌํ๊ธฐ
: ์ข ํฉ ์ํฉ) ๋ถ๋ง๋์ ํฉ / ์ต์ ์ ์ข ํฉ ์ํฉ) ๋ถ๋ง๋์ ํฉ์ด ์ต์
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ , ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ ์ ๋จผ์ ์์ํ ๋ฑ์๋ฅผ ascending order ์ ๋ ฌ / ์ค์ ๋ฑ์๋ฅผ 1๋ถํฐ ascending order์ ๋ง๊ฒ ๋ถ์ฌํ๋ฉด ๋ถ๋ง๋์ ํฉ์ด ์ต์
โ 1049 ๊ธฐํ์ค โ
import sys
input=sys.stdin.readline
N,M=map(int,input().split())
six,one=map(min, zip(*(map(int, input().split()) for _ in range(M))))
ans=0
if six > one*6: print(N*one)
else:
ans+=(N//6)*six
if (N%6)*one > six: ans+=six
else: ans+=(N%6)*one
print(ans)
๐ฒ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ํจํค์ง๋ก ์ด ์ง, ๋ฑ๊ฐ๋ก ์ด ์ง ๊ฒฐ์
: ์ข ํฉ ์ํฉ) ๊ฒฐ์ ๊ฒฐ๊ณผ์ ํฉ๊ณ / ์ต์ ์ ์ข ํฉ ์ํฉ) ํฉ๊ณ ๊ฐ๊ฒฉ์ด ์ต์
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ , ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ ์ (1) ๋ฑ๊ฐ๋ฅผ 6๊ฐ ๋ชจ์ ๊ฒ๋ณด๋ค ํจํค์ง๊ฐ ๋ ๋น์ธ๋ค๋ฉด, ๋ฑ๊ฐ๋ก๋ง ๋ฌด์กฐ๊ฑด ๊ตฌ๋งค / (2) ํจํค์ง๊ฐ ๋ ์ธ๋ค๋ฉด ์ผ๋จ ํจํค์ง๋ก 6์ผ๋ก ๋๋ ๋ชซ๋งํผ ์ฌ๊ณ , ํจํค์ง๋ก ์ด ์ ์๋ ๋ฑ๊ฐ์ธ ๊ฒฝ์ฐ ํจํค์ง 1๊ฐ๋ก ์ฌ๋ ๊ฒ ์ด๋์ผ์ง, ๋ฑ๊ฐ๋ก ์ฌ๋ ๊ฒ ์ด๋์ผ์ง ๊ฒฐ์ (์ (1)๊ณผ (2) ๊ตฌ๋ณ์ greedy ์๋ฆฌ)
โ 2847 ๊ฒ์์ ๋ง๋ ๋์ค์ด โ
import sys
input=sys.stdin.readline
N=int(input())
levels=[int(input()) for _ in range(N)]
cnt,cur=0,levels[-1]-1
for level in levels[::-1][1:]:
if level < cur:
cur = level-1
else:
cnt+=(level-cur)
cur=cur-1
print(cnt)
๐ฒ greedy ๊ด์ ๋ถ์
: ๊ฐ๋ณ ์ํฉ) ๊ฐ ์ซ์๋ณ๋ก ์ผ๋ง๋งํผ ๊ฐ์์ํฌ์ง ๊ฒฐ์
: ์ข ํฉ ์ํฉ) ์ด ๊ฐ์ ์นด์ดํธ ํฉ๊ณ / ์ต์ ์ ์ข ํฉ ์ํฉ) ๊ฐ์ ์นด์ดํธ ํฉ๊ณ ์ต์๊ฐ
โ ์ต์ ์ ์ข ํฉ ์ํฉ์ ์ต์ ์ ๊ฐ๋ณ ์ํฉ์ ๋ชจ์์ผ๋ก ๋ง๋ค ์ ์๊ณ , ๊ฐ๋ณ ์ํฉ์ ์ต์ greedy ์๋ฃจ์ ์ ๊ฑฐ๊พธ๋ก ์ค๋ฅธ์ชฝ๋ถํฐ ๋งจ ์ค๋ฅธ์ชฝ ์ซ์๋ ๋๋ ์ฑ๋ก ๊ทธ ์๋ถํฐ 1์ฉ๋ง ๊ฐ์ํ ์ซ์๋ก๋ง ๊ตฌ์ฑ๋๊ฒ๋, ๋ง์ฝ 1๋ณด๋ค ๊ฐ์ํ ์ซ์๋ณด๋ค๋ ๋ ์๋ค๋ฉด ๊ทธ ์ซ์๋ฅผ ๊ธฐ์ค์ผ๋ก 1์ฉ ๊ฐ์ํ๋ฉฐ ์ผ์ชฝ์ผ๋ก ๊ณ์ ์งํ(์ค๋ฅธ์ชฝ๋ถํฐ ๊ฑฐ๊พธ๋ก ์งํํ๋ฉด์ if๋ฌธ์ผ๋ก ํ์ฌ cur๊ณผ level ๋น๊ต: cur์ ๊ทธ ๋ค์ ๋์ ์ซ์)
โ 23895 Allocation โ
import sys
input=sys.stdin.readline
T=int(input())
for i in range(1,T+1):
N,B=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
ans=0
for a in A:
if a<=B:
B-=a
ans+=1
if B<=0:
break
print(f'Case #{i}: {ans}')
๐ฒ๋ง์ ๊ฐ์์ ์ง์ ์ฌ๋ ค๋ฉด ์ผ๋จ ์ผ ์ง๋ถํฐ ๋จผ์ get
โ 1439 ๋ค์ง๊ธฐ โ
import math
S,x=input(),0
for i in range(1,len(S)):
if S[i]!=S[i-1]:x+=1
print(math.ceil(x/2))
๐ฒ1๊ณผ 0 ์ด๋ ๊ฒ ๋ค๋ฅธ ๋ถ๋ถ์ ๊ฐ์๋ฅผ ๊ตฌํ๊ณ math.ceil(๋ค๋ฅธ ๋ถ๋ถ์ ๊ฐ์/2)๋ฅผ ๊ตฌํ๋ฉด ๋. ์๋ฅผ ๋ค์ด 101์ด ์์ ๋ ๋ฐ๋ ๋ถ๋ถ์ 2๊ฐ ์ด๋ฏ๋ก ์ ๋ฐ ํ์๋งํผ ๋ฐ๊พธ์ด ์ฃผ์ด์ผ ์ํ๋ ๋๋ก ๋ฐ๋. ๋ฐ๋ผ์ ์ ๋ฐ์ผ๋ก ๋๋์ด์ผ ํ๋ค.
โ 30457 ๋จ์ฒด ์ค๋๊ธฐ โ
import sys
input=sys.stdin.readline
N=int(input())
A=list(map(int,input().split()))
A.sort()
B=[]
a,b=1,0
for x in range(1,len(A)):
if A[x]>A[x-1]: a+=1
else:
B.append(A[x])
if len(B)!=0:
b=1
for x in range(1,len(B)):
if B[x]>B[x-1]: b+=1
print(a+b)
๐ฒ์ ๋ฐฉํฅ์ ๋ฐ๋ผ๋ณผ๋ ํค๊ฐ ์์ ์ฌ๋ ์ชฝ๋ง ๋ฐ๋ผ๋ณผ ์ ์์ผ๋ฏ๋ก ๊ฐ์ ํค๋ฅผ ๊ฐ์ง ์ฌ๋์ ์ ์ชฝ ์ต๋ 2์๋ฆฌ๋ง ๋์ ์ ์๋ค๋ ์ฌ์ค๋ง ์๋ฉด ๋๋ค! ๋จผ์ ์ค๋ฆ์ฐจ์์ผ๋ก ์ญ ์ ๋ ฌ. ๊ฐ์ ํค๋ฅผ ๊ฐ์ง ๋๋จธ์ง ์ฌ๋๋ค์ ์ค๋ฅธ์ชฝ ๋๋ถํฐ ๋ฐฐ์นํ๋ ์ฌ๊ธฐ์๋ ๋์ผํ ํค๊ฐ ์์ผ๋ฉด ์ ์ธ.
โ 30873 Hanyang Popularity Exceeding Competition โ
import sys
input=sys.stdin.readline
N=int(input())
popularity=0
for _ in range(N):
P,C=map(int,input().split())
if abs(P-popularity)<=C:
popularity+=1
print(popularity)
๐ฒ๋จ์ํ๊ฒ ์ง์ ์ต๋ํ ๋ง์ด ๋ง๋๋ ๊ฒ์ด ์ค์ํ๋ฏ๋ก, ๋ง๋ ๋๋ง๋ค (์์๋ ์ฐจ๋ก๋๋ก ์ด๋ฏธ ์ ํด์ ธ ์์) abs(P-popularity)<=C ์ ๋ง๋ ์ง ์ ๊ฒ. ๋ง๋๋ ์ฌ๋๋ง๋ค์ ๊ฐ์ค์น๋ ๋ชจ๋ ๋์ผํ๋ฏ๋ก ๋จ์ํ๊ฒ popularity += 1์ฉ ์ฆ๊ฐํ๋ฉด์ ์ต์ข popularity ์ถ๋ ฅ
โ 14655 ์ฑ์ ๋ ๋๋ฐ์์ด์ผ!! โ
import sys
input=sys.stdin.readline
N=int(input())
round1=list(map(int,input().split()))
r1=[-x if x < 0 else x for x in round1]
round2=list(map(int,input().split()))
r2=[-x if x > 0 else x for x in round2]
print(sum(r1)-sum(r2))
๐ฒ ์ฒซ๋ฒ์งธ ๋ผ์ด๋์์ ์ต๋๊ฐ์ ๊ฐ์ง๋ ค๋ฉด ๋ชจ๋ ๊ฐ์ ์ต๋ํ ์์๊ฐ ์๋ ์์์ชฝ / ๋๋ฒ์งธ ๋ผ์ด๋๋ ๊ทธ ๋ฐ๋
๐ฒ ์ ์ผ ๋์ 1๊ฐ ๋๋ 2๊ฐ๋ง ๋ค์ง์ด๋ ๋๋ฏ๋ก, ๊ณง ๋ชจ๋ ๋์ ์ ์ํ๋ ๋๋ก ์์์ชฝ์ด๋ ์์์ชฝ์ผ๋ก ๋ค์ง์ ์ ์๋ค๋ ๋ป. ๋ฐ๋ผ์ ๋ชจ๋ ์์ - ๋ชจ๋ ์์์ผ๋ ๋ฐ๋ก ์ฐ์ฐํด์ฃผ๋ฉด ๋๋ค.
โ 20937 ๋ก๊ตญ โ
import sys
input=sys.stdin.readline
from collections import Counter
N=int(input())
cs=list(map(int,input().split()))
cs=sorted(cs,reverse=True)
ans=0
x=Counter(cs)
x_freq=x.values()
print(max(x_freq))
๐ฒ ๋ก๊ตญ ๊ทธ๋ฆ ํ์ ๋ด๋ฆผ์ฐจ์ ์์ด ๊ทธ ์์ฒด๋ฅผ ๋ปํ๋ค. ์๋ฅผ ๋ค์ด [5, 4, 3, 2, 2, 1, 1]์ด ์๋ค๋ฉด, ํ์ ๊ฐ์๋ฅผ ์ต์ํํ ๋ ค๋ฉด [5, 4, 3, 2, 1] [2, 1] ์ด๋ ๊ฒ 2๊ฐ๋ก ๋ง๋ค ์ ์๋ค. ์ฆ ํ ๊ฐ์ ํ ๋ด์ ๋ด๋ฆผ์ฐจ์ ์ซ์ ๊ฐ์๋ฅผ ๋ง์ด ๋ฃ์ผ๋ฉด ๋๋ค. ์ฆ, ํ์ ๊ฐ์๋ Counter() ํ์ฉํ์ฌ ์ต๋น๊ฐ์ ์ต๋๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
โ 31066 ๋น ์ค๋ ๋ โ
import sys
input=sys.stdin.readline
for _ in range(int(input())):
N,M,K=map(int,input().split())
if N!=1 and (M,K)==(1,1):
print(-1)
continue
status=[N,M,0,0]
ans=0
while status[1]!=0:
#1st go
ans+=1
if (status[0]-status[1]*K)<=0:
print(ans)
break
else:
status=[status[0]-status[1]*K,0,status[1]*K,status[1]]
#2nd come back again
ans+=1
status[2] -= 1
status[0] += 1
status[1] += status[3]
status[3] = 0
๐ฒ๋ชจ๋ ํ์์ด ๊ฑด๋๊ฐ๊ธฐ ์ํ ์ํ ์ต์ ํ์. ์ฐ์ฐ ๊ฐ์ * ๋ค๊ณ ๊ฐ ์ ์๋ ์ฌ๋์ ์๋งํผ ๋ชจ๋ ๊ฐ๊ณ , ๋ชจ๋ ๊ฐ์ ธ๊ฐ์ง ๋ชปํ๋ฉด ํ ๋ช ๋ชจ๋ ์ฐ์ฐ ๋ค๊ณ ์ค๊ฒ๋ ์ง์ ์๋ฎฌ๋ ์ด์ ๋๋ฆฌ๋ฉด ๋๋ค.
โ 30796 gahui and sousenkyo 4 โ
import sys
input=sys.stdin.readline
v,k=map(int,input().split())
cnt=0
start=v
l1,ans=[],[]
while start>0:
if (start-k)<=0:
ans+=[x for x in range(start,0,-1)]
else:
ans+=[x for x in range(start,start-k,-1)]
start=(start-k-k)
ans.sort(reverse=True)
print(len(ans))
print(*ans,sep='\n')
๐ฒ๊ทธ๋ฆฌ๋ ๊ด์ ์ผ๋ก start๋ถํฐ ์ ๋ฐ์ดํธ๋ฅผ ํด๋๊ฐ๋ฉฐ ์ ๊ฑฐ์ ์ถ๋งํ๋ ์บ๋ฆญํฐ ๊ฐ์ ์ถ๋ ฅ
'BOJ > ๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ Tree Upper-Intermediate I - 3 Solvedโ (0) | 2023.12.19 |
---|---|
โ BF Upper-Intermediate I - 2 Solvedโ (0) | 2023.10.26 |
โ Combinatorics Upper-Intermediate I - 4 Solvedโ (0) | 2023.08.16 |
โ Regular Expression Upper + Intermediate - 3 Solvedโ (0) | 2023.08.14 |
โ Set/Map Upper-Intermediate I - 3 Solvedโ (0) | 2023.08.11 |
๋๊ธ