๋ฌธ์
N ๊ฐ์ ๋ง๋ ๊ธฐ๋ฅ์ด ์ผ๋ ฌ๋ก ์ธ์์ ธ ์๋ค. ๊ธฐ๋ฅ๋ค์ ํญ์ ๋ชจ๋ 1 m์ด๋ฉฐ ๋์ด๋ ๋ค๋ฅผ ์ ์๋ค. ์ด ๊ธฐ๋ฅ๋ค์ ์ด์ฉํ์ฌ ์์ฒ ๋ก ๋ ์ฐฝ๊ณ ๋ฅผ ์ ์ํ๋ ค๊ณ ํ๋ค. ์ฐฝ๊ณ ์๋ ๋ชจ๋ ๊ธฐ๋ฅ์ด ๋ค์ด๊ฐ๋ค. ์ด ์ฐฝ๊ณ ์ ์ง๋ถ์ ๋ค์๊ณผ ๊ฐ์ด ๋ง๋ ๋ค.
1. ์ง๋ถ์ ์ํ ๋ถ๋ถ๊ณผ ์์ง ๋ถ๋ถ์ผ๋ก ๊ตฌ์ฑ๋๋ฉฐ, ๋ชจ๋ ์ฐ๊ฒฐ๋์ด์ผ ํ๋ค.
2. ์ง๋ถ์ ์ํ ๋ถ๋ถ์ ๋ฐ๋์ ์ด๋ค ๊ธฐ๋ฅ์ ์๋ฉด๊ณผ ๋ฟ์์ผ ํ๋ค.
3. ์ง๋ถ์ ์์ง ๋ถ๋ถ์ ๋ฐ๋์ ์ด๋ค ๊ธฐ๋ฅ์ ์๋ฉด๊ณผ ๋ฟ์์ผ ํ๋ค.
4. ์ง๋ถ์ ๊ฐ์ฅ์๋ฆฌ๋ ๋
์ ๋ฟ์์ผ ํ๋ค.
5. ๋น๊ฐ ์ฌ ๋ ๋ฌผ์ด ๊ณ ์ด์ง ์๋๋ก ์ง๋ถ์ ์ด๋ค ๋ถ๋ถ๋ ์ค๋ชฉํ๊ฒ ๋ค์ด๊ฐ ๋ถ๋ถ์ด ์์ด์ผ ํ๋ค.
๊ทธ๋ฆผ 1์ ์ฐฝ๊ณ ๋ฅผ ์์์ ๋ณธ ๋ชจ์ต์ ๊ทธ๋ฆฐ ๊ฒ์ด๋ค. ์ด ๊ทธ๋ฆผ์์ ๊ตต์ ์ ์ผ๋ก ํ์๋ ๋ถ๋ถ์ด ์ง๋ถ์ ํด๋น๋๊ณ , ์ง๋ถ๊ณผ ๋
์ผ๋ก ๋๋ฌ์ธ์ธ ๋ค๊ฐํ์ด ์ฐฝ๊ณ ๋ฅผ ์์์ ๋ณธ ๋ชจ์ต์ด๋ค. ์ด ๋ค๊ฐํ์ ์ฐฝ๊ณ ๋ค๊ฐํ์ด๋ผ๊ณ ํ์.
์ฐฝ๊ณ ์ฃผ์ธ์ ์ฐฝ๊ณ ๋ค๊ฐํ์ ๋ฉด์ ์ด ๊ฐ์ฅ ์์ ์ฐฝ๊ณ ๋ฅผ ๋ง๋ค๊ธฐ๋ฅผ ์ํ๋ค. ๊ทธ๋ฆผ 1์์ ์ฐฝ๊ณ ๋ค๊ฐํ์ ๋ฉด์ ์ 98 ใก์ด๊ณ , ์ด ๊ฒฝ์ฐ๊ฐ ๊ฐ์ฅ ์์ ์ฐฝ๊ณ ๋ค๊ฐํ์ด๋ค.
๊ธฐ๋ฅ๋ค์ ์์น์ ๋์ด๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ์ฅ ์์ ์ฐฝ๊ณ ๋ค๊ฐํ์ ๋ฉด์ ์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ ์ค์๋ ๊ธฐ๋ฅ์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ ์ N์ด ์ฃผ์ด์ง๋ค. N์ 1 ์ด์ 1,000 ์ดํ์ด๋ค. ๊ทธ ๋ค์ N ๊ฐ์ ์ค์๋ ๊ฐ ์ค์ ๊ฐ ๊ธฐ๋ฅ์ ์ผ์ชฝ ๋ฉด์ ์์น๋ฅผ ๋ํ๋ด๋ ์ ์ L๊ณผ ๋์ด๋ฅผ ๋ํ๋ด๋ ์ ์ H๊ฐ ํ ๊ฐ์ ๋น ์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. L๊ณผ H๋ ๋ ๋ค 1 ์ด์ 1,000 ์ดํ์ด๋ค.
์ถ๋ ฅ
์ฒซ ์ค์ ์ฐฝ๊ณ ๋ค๊ฐํ์ ๋ฉด์ ์ ๋ํ๋ด๋ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ ์์
7
2 4
11 4
15 8
4 6
5 3
8 10
13 6
์ถ๋ ฅ ์์
98
ํด๊ฒฐ ๋ฐฉ๋ฒ
์์ด๋์ด 1. ์์ ํ์์ผ๋ก ๊ตฌํ๊ธฐ
1๋ถํฐ ๊ธฐ๋ฅ์ ์ต๋ ๋์ด์ ๋ํด
ํ์ฌ ํ์์ค์ธ ๊ธฐ๋ฅ์ ๋์ด๋ณด๋ค ํฐ ๊ฐ์ฅ ์ผ์ชฝ ๊ธฐ๋ฅ๊ณผ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๊ธฐ๋ฅ์ ์์น๋ฅผ ๊ตฌํด์ ๋ ๊ธฐ๋ฅ์ ์์น ์ฐจ + 1์ ์ ๋ต์ ๋ํด์ฃผ๋ ๋ฐฉ์์ผ๋ก ํ์ํด ๋๊ฐ๋ฉด ์ฐฝ๊ณ ์ ๋์ด๋ฅผ ๊ตฌํ ์ ์๋ค.
n = int(input())
columns = []
for _ in range(n):
columns.append(tuple(map(int,input().split())))
columns.sort()
max_height = max([t[1] for t in columns])
answer = 0
for i in range(1, max_height+1):
left = 0
right = 0
for j in range(n):
# ๊ธฐ๋ฅ ๋์ด๊ฐ i ์ด์์ธ ๊ฐ์ฅ ์ผ์ชฝ ๊ธฐ๋ฅ ์ฐพ๊ธฐ
column = columns[j]
if column[1] >= i:
left = column[0]
break
for k in range(n-1,-1,-1):
column = columns[k]
# ๊ธฐ๋ฅ ๋์ด๊ฐ i ์ด์์ธ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๊ธฐ๋ฅ ์ฐพ๊ธฐ
if column[1] >= i:
right = column[0]
break
if right != 0:
# ์์์ ๊ตฌํ ์์น๋ฅผ ๋ฐํ์ผ๋ก ๋์ด i์ ํด๋นํ๋ ๋ฉด์ ๊ตฌํ๊ธฐ
answer += (right-left+1)
print(answer)
์์ด๋์ด2. ํฌ ํฌ์ธํฐ๋ก ์ ๊ทผํ๊ธฐ
์ด ๋ฌธ์ ๋ฅผ ์ฒ์ ๋ดค์ ๋ ์ฐฝ๊ณ ์ ๋์ด๊ฐ ๋์์ง๋ ๋ฐฉํฅ์ ์ฝ๊ฒ ์๊ฐ ๋ฌ์ง๋ง, ์ฐฝ๊ณ ์ ๋ฐฉํฅ์ด ๋ฎ์์ง๋ ์ชฝ์ ์ ์๊ฐ์ด ๋์ง ์์๋ค.
๊ทธ๋์ ์ฐฝ๊ณ ์ ์ ์ผ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ์์ ๋๋ฒ ์ ๊ทผํ๋ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ์๋ค.
์ผ์ชฝ์์ ์ ๊ทผํ ๋๋ ์ด๋ฒ์ ์ ๊ทผํ ๋์ด๊ฐ ๊ธฐ์กด ๋์ด๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ์ฌํ๊น์ง์ ๋์ ํฉ์ ํตํด ์ฐฝ๊ณ ์ ๋์ด๋ฅผ ๊ฐฑ์ ํ๊ณ , ์ฐฝ๊ณ ์ ์ต๋ ๋์ด ๊น์ง ๋ฐ๋ณต๋๋๋ก ํ์๋ค.
์ค๋ฅธ์ชฝ์์ ์ ๊ทผํ ๋๋ "ํฌ๊ฑฐ๋ ๊ฐ๋ค"์์ "๊ฐ๋ค"์ ์กฐ๊ฑด์ ๋นผ์ ์๋ฅผ ๋ค๋ฉด ์ฐฝ๊ณ ๋์ด์ ์ต๋ ๋์ด๊ฐ ์ฐ์์ผ๋ก 3๋ฒ ๋์์ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์ ๊ทผ์์ ๊ฒน์น๋ ๋ถ๋ถ์ ์ ๊ฑฐํ์๋ค.
n = int(input())
columns = []
for _ in range(n):
columns.append(tuple(map(int,input().split())))
columns.sort()
max_height = max([t[1] for t in columns])
current = 0
index = 0
answer = 0
for column in columns:
pos,height = column
if current <= height:
answer += (pos-index)*current
current = height
index = pos
columns.reverse()
current = 0
index = 0
for column in columns:
pos,height = column
if current < height:
answer += (index-pos)*current
current = height
index = pos
if height == max_height:
current = height
break
answer += current
print(answer)
'๐์ฝ๋ฉํ ์คํธ > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 3020 - ๊ฐ๋ฅ๋ฒ๋ (0) | 2024.11.06 |
---|---|
[๋ฐฑ์ค] 14719 - ๋น๋ฌผ (Python) (0) | 2024.10.31 |
[๋ฐฑ์ค] 1912 - ์ฐ์ํฉ (Python) (0) | 2024.10.27 |
[๋ฐฑ์ค] 3055 - ํ์ถ (Python) (0) | 2024.10.17 |
[๋ฐฑ์ค] 14252 - ๊ณต์ฝ์์ด (Python) (0) | 2024.10.13 |