[BOJ][๐ก5][๋ฐฑ์ค#02170] ์ ๊ธ๊ธฐ
์์ฑ:    
์ ๋ฐ์ดํธ:
์นดํ ๊ณ ๋ฆฌ: BOJ Gold V
๋ฌธ์ ์ถ์ฒ
๋ฌธ์
๋งค์ฐ ํฐ ๋ํ์ง์ ์๋ฅผ ๋๊ณ ์ ์ ๊ทธ์ผ๋ ค๊ณ ํ๋ค. ์ ์ ๊ทธ์ ๋์๋ ์์ ํ ์ ์์ ๋ค๋ฅธ ํ ์ ๊น์ง ๊ธ๊ฒ ๋๋ค. ์ ์ ๊ทธ์ ๋์๋ ์ด๋ฏธ ์ ์ด ์๋ ์์น์ ๊ฒน์ณ์ ๊ทธ๋ฆด ์๋ ์๋๋ฐ, ์ฌ๋ฌ ๋ฒ ๊ทธ์ ๊ณณ๊ณผ ํ ๋ฒ ๊ทธ์ ๊ณณ์ ์ฐจ์ด๋ฅผ ๊ตฌ๋ณํ ์ ์๋ค๊ณ ํ์. ์ด์ ๊ฐ์ ์์ผ๋ก ์ ์ ๊ทธ์์ ๋, ๊ทธ๋ ค์ง ์ (๋ค)์ ์ด ๊ธธ์ด๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ์ ์ด ์ฌ๋ฌ ๋ฒ ๊ทธ๋ ค์ง ๊ณณ์ ํ ๋ฒ์ฉ๋ง ๊ณ์ฐํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ ์ ๊ทธ์ ํ์ N(1 โค N โค 1,000,000)์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ ์ ์ ๊ทธ์ ๋ ์ ํํ ๋ ์ ์ ์์น x, y(-1,000,000,000 โค x < y โค 1,000,000,000)๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๊ทธ์ ์ ์ ์ด ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค.
์์
์ ๋ ฅ
4
1 3
2 5
3 5
6 7
์ถ๋ ฅ
5
My Sol
import sys
input = sys.stdin.readline
N = int(input())
d = {}
for _ in range(N):
s, e = map(int, input().split())
v = d.get(s, 1e10)
if v == 1e10 or v < e:
d[s] = e
arr = sorted([(k, v) for k, v in d.items()])
ret = 0
tmps, tmpe = arr[0]
for s, e in arr[1:]:
if tmpe < s:
ret += tmpe - tmps
tmps, tmpe = s, e
continue
tmpe = max(tmpe, e)
ret += tmpe - tmps
print(ret)
์ ๋ ฅ ์ฒ๋ฆฌ
- ๋์ ๋๋ฆฌ๋ฅผ ์ด์ฉํด ์์์ ์ key๋ก, ๋์ฐฉ์ ์ value๋ก ๋์๋ค.
- ๋ง์ฝ ์ ๋ ฅ์ ํด๋นํ๋ ์์์ ์ด ์ด๋ฏธ ์์๋ค๋ฉด ๋ ๊ธด ๋ฒ์๋ฅผ ์ ์ฅ
- ์ ๋ ฅ์ ํด๋นํ๋ ์์์ ์ด ์์๋ค๋ฉด ํด๋น ๋์ฐฉ์ ์ ์ ์ฅํด์ค๋ค.
- ๋ชจ๋ ์ ๋ ฅ์ ๋ง์น๋ฉด key ์์ผ๋ก ์ ๋ ฌํด ๊ฐ๊ณผ ํจ๊ป arr ๋ฐฐ์ด์ ๋ด์์ค๋ค.
๊ฐ ๋ํ๊ธฐ
- ๊ธฐ์ค ์์์ ๊ณผ ๋์ฐฉ์ ์ arr์ ์ฒซ ๋ฐฐ์ด๋ก ๋๋ค.
- ๋ง์ฝ ๊ธฐ์ค ๋์ฐฉ์ ์ด ๋ค์ ์กฐํํ๋ ์์์ ๋ณด๋ค ์ ๋ค๋ฉด ์ด์ด์ง์ง ์๋ ๊ฒ์ด๋ค.
- ๊ธฐ์ค ์์์ ๊ณผ ๋์ฐฉ์ ์ ๊ธธ์ด๋ฅผ ret์ ๋ํด์ฃผ๊ณ ์๋ก ๋ง์ดํ ์์์ ๊ณผ ๋์ฐฉ์ ์ ๊ธฐ์ค ์์์ ๊ณผ ๋์ฐฉ์ ์ผ๋ก ์ฌ์ค์ ํ๋ค.
- ๋ง์ฝ ๊ธฐ์ค ๋์ฐฉ์ ์ด ๋ค์ ์กฐํํ ์์์ ์ ๋์ด์ ๋ค๋ฉด ๊ธธ์ด๋ฅผ ์ฐ์ฅํ๊ฑฐ๋ ๋ฎ์ด์์ธ ์ ์์ผ๋ฏ๋ก ๊ธฐ์ค ๋์ฐฉ์ ๊ณผ ๋์ฐฉ์ ์ค ํฐ ๊ฐ์ ๊ธฐ์ค ๋์ฐฉ์ ์ผ๋ก ์ค์ ํ๋ค.
- ์ด ๊ณผ์ ์ ๋ชจ๋ ๊ฑฐ์น๋ฉด ret์ ํ์ฌ ์ ์ฅ์ค์ธ ๊ธฐ์ค ์์์ ๊ณผ ๋์ฐฉ์ ๊ฐ ๊ฑฐ๋ฆฌ๋ฅผ ๋ํ๊ณ ์ถ๋ ฅํ๋ค.
๊ฒฐ๊ณผ
๋ง์์ต๋๋ค!!
๋ชจ๋ฒ๋ต์
from sys import stdin, stdout
N = int(stdin.readline())
line = [tuple(map(int, stdin.readline().split())) for _ in range(N)]
line.sort(key=lambda x:x[0])
ans = 0
limit = -1000000001
for i in range(N):
if limit < line[i][0]:
ans += line[i][1] - line[i][0]
limit = line[i][1]
elif limit < line[i][1]:
ans += line[i][1] - limit
limit = line[i][1]
stdout.write(f"{ans}")
ํฐ ์ฐจ์ด๋ ์๋์ง๋ง ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด๋ ์๊ฐ๋ฉด์์ ์ํญ ๋์ ์ฝ๋๋ฅผ ๋ถ์ํด๋ณด๋ ค ํ๋ค. ๋น์ทํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ๊ฒ ๊ฐ๋ค๋ง tuple์ ์ฌ์ฉํ๊ณ , ์ค๋ณต์ ๊ฑธ๋ฌ๋ด์ง ์๊ณ ๊ทธ๋ฅ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
์ดํ limit์ ๊ฐฑ์ ํด๋๊ฐ๋ฉฐ ๊ธธ์ด๋ฅผ ๋งค๋ฒ ์๋ก ๋ํด๊ฐ๋ฉฐ ์ ์ฅํ๋ค.
๋๊ธ๋จ๊ธฐ๊ธฐ