๐ค๋ฌธ์ ํด๊ฒฐ
1.
๐จ
๐ป์์ค ์ฝ๋
from itertools import chain
# ๋ต์ ์ถ๋ ฅํ๊ธฐ ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ chain
# ์ด์ค ๋ฆฌ์คํธ๋ฅผ ๋จ์ผ๋ฆฌ์คํธ๋ก ๋ฐ๊ฟ์ค๋ค.
def findSqure(sx, sy):
i, j = sx, sy
# ์๋๋ก ์ญ ๋ด๋ ค๊ฐ์ ์ฐพ๊ณ
while i < n and maps[i][j]:
i += 1
else:
i -= 1
# ์ค๋ฅธ์ชฝ์ผ๋ก ๊ฐ์ ์ฐพ๊ณ
while j < n and maps[i][j]:
j += 1
else:
j -= 1
# ํ๋ ฌ์ ๋๊ฐ์ ์ฐพ์์ผ๋ฉด ๊ทธ ํ๋ ฌ์ ๊ฐ์ ์ ๋ถ 0์ผ๋ก ๋ง๋ค์ด์ค๋ค.
changeZero(sx, i+1, sy, j+1)
result.append([i-sx+1,j-sy+1])
def changeZero(a,b,c,d):
# ํ a - b, ์ด c - d
for i in range(a,b):
for j in range(c,d):
maps[i][j] = 0
for tc in range(1, 1+int(input())):
n = int(input())
maps = [list(map(int, input().split())) for _ in range(n)]
result= []
for x in range(n):
for y in range(n):
# ํ๋ ฌ์ด ์์๋๋ ์ ์ฐพ๊ธฐ
if maps[x][y]:
findSqure(x, y)
answer = sorted(result, key=lambda x: (x[0]*x[1], x[0]))
ordered_answer = list(chain.from_iterable(answer))
print('#{} {} {}'.format(tc, len(answer), ' '.join(list(map(str, ordered_answer)))))
๐๋ฌธ์ ํ์ธ
์ถ์ฒ: SW Expert Academy
SW Expert Academy
SW ํ๋ก๊ทธ๋๋ฐ ์ญ๋ ๊ฐํ์ ๋์์ด ๋๋ ๋ค์ํ ํ์ต ์ปจํ ์ธ ๋ฅผ ํ์ธํ์ธ์!
swexpertacademy.com
์ ์ ํํ ๋ฌด๊ธฐ ์กฐ์ฌ๋จ์ด ๋๋ ์ด์ ํํ ๋ฌด๊ธฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํด ํํ ๋ฌผ์ง๋ค์ด ์ ์ฅ๋ ์ฐฝ๊ณ ๋ฅผ ์กฐ์ฌํ๊ฒ ๋์๋ค.
์ฐฝ๊ณ ์๋ ํํ ๋ฌผ์ง ์ฉ๊ธฐ n2๊ฐ๊ฐ n x n์ผ๋ก ๋ฐฐ์ด๋์ด ์์๋ค.
์ ์ ์กฐ์ฌ๋จ์ ๊ฐ ์ฉ๊ธฐ๋ฅผ ์กฐ์ฌํ์ฌ 2์ฐจ์ ๋ฐฐ์ด์ ๊ทธ ์ ๋ณด๋ฅผ ์ ์ฅํ์๋ค.
๋น ์ฉ๊ธฐ์ ํด๋นํ๋ ์์๋ ‘0’์ผ๋ก ์ ์ฅํ๊ณ , ํํ ๋ฌผ์ง์ด ๋ค์ด ์๋ ์ฉ๊ธฐ์ ํด๋นํ๋ ์ฉ๊ธฐ๋ ํํ ๋ฌผ์ง์ ์ข
๋ฅ์ ๋ฐ๋ผ ‘1’์์ ‘9’์ฌ์ด์ ์ ์๋ฅผ ์ ์ฅํ์๋ค.
๋ค์ ๊ทธ๋ฆผ์ ์ฐฝ๊ณ ์ ํํ ๋ฌผ์ง ํํฉ์ 9x9 ๋ฐฐ์ด์ ์ ์ฅํ ์๋ฅผ ๋ณด์ฌ์ค๋ค.
์ ์ ์กฐ์ฌ๋จ์ ํํ ๋ฌผ์ง์ด ๋ด๊ธด ์ฉ๊ธฐ๋ค๋ก๋ถํฐ 3๊ฐ์ง ์ฌํญ์ ๋ฐ๊ฒฌํ์๋ค.
1. ํํ ๋ฌผ์ง์ด ๋ด๊ธด ์ฉ๊ธฐ๋ค์ด ์ฌ๊ฐํ์ ์ด๋ฃจ๊ณ ์๋ค. ๋ํ, ์ฌ๊ฐํ ๋ด๋ถ์๋ ๋น ์ฉ๊ธฐ๊ฐ ์๋ค.
์๋ฅผ ๋ค์ด, ์์ ๊ทธ๋ฆผ์๋ 3๊ฐ์ ํํ ๋ฌผ์ง์ด ๋ด๊ธด ์ฉ๊ธฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฌ๊ฐํ A, B, C๊ฐ ์๋ค.
2. ํํ ๋ฌผ์ง์ด ๋ด๊ธด ์ฉ๊ธฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฌ๊ฐํ๋ค์ ๊ฐ๊ฐ ์ฐจ์(๊ฐ๋ก์ ์ฉ๊ธฐ ์ x ์ธ๋ก์ ์ฉ๊ธฐ ์)์ด ๋ค๋ฅด๋ค.
์๋ฅผ ๋ค์ด, ์์ ๊ทธ๋ฆผ์์ A๋ 3x4, B๋ 2x3, C๋ 4x5์ด๋ค.
3. 2๊ฐ์ ํํ ๋ฌผ์ง์ด ๋ด๊ธด ์ฉ๊ธฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฌ๊ฐํ๋ค ์ฌ์ด์๋ ๋น ์ฉ๊ธฐ๋ค์ด ์๋ค.
์๋ฅผ ๋ค์ด, ์์ ๊ทธ๋ฆผ์์ A์ B ์ฌ์ด์ B์ C ์ฌ์ด๋ฅผ ๋ณด๋ฉด, ๋น ์ฉ๊ธฐ๋ฅผ ๋ํ๋ด๋ ‘0’ ์์๋ค์ด 2๊ฐ์ ์ฌ๊ฐํ ์ฌ์ด์ ์๋ ๊ฒ์ ์ ์ ์๋ค.
๋จ, A์ C์ ๊ฒฝ์ฐ์ ๊ฐ์ด ๋๊ฐ์ ์์ผ๋ก๋ ๋น ์ฉ๊ธฐ๊ฐ ์์ ์๋ ์๋ค.
์ ์ ์กฐ์ฌ๋จ์ ์ฐฝ๊ณ ์ ์ฉ๊ธฐ๋ค์ ๋ํ 2์ฐจ์ ๋ฐฐ์ด์์ ํ๋ ฌ(ํํ ๋ฌผ์ง์ด ๋ ์ฉ๊ธฐ๋ค๋ก ์ด๋ฃจ์ด์ง ์ฌ๊ฐํ)๋ค์ ์ฐพ์๋ด๊ณ ์ ๋ณด๋ฅผ ์์งํ๊ณ ์ ํ๋ค.
์ฐพ์๋ธ ํ๋ ฌ๋ค์ ์ ๋ณด๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
[์ ์ฝ ์ฌํญ]
n์ 100 ์ดํ์ด๋ค.
๋ถ๋ถ ํ๋ ฌ์ ์ด์ ๊ฐ์๋ ์๋ก ๋ค๋ฅด๋ฉฐ ํ๋ ฌ์ ํ์ ๊ฐ์๋ ์๋ก ๋ค๋ฅด๋ค.
์๋ฅผ ๋ค์ด, 3๊ฐ์ ๋ถ๋ถํ๋ ฌ ํ๋ ฌ (A(3x4), B(2x3), C(4x5))์ด ์ถ์ถ๋์๋ค๋ฉด, ๊ฐ ๋ถ๋ถ ํ๋ ฌ์ ํ์ ์๋ 3, 2, 4๋ก ์๋ก ๋ค๋ฅด๋ค.
๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ ๋ถ๋ถ ํ๋ ฌ์ ์ด์ ์๋ 4, 3, 5๋ก ์๋ก ๋ค๋ฅด๋ค.
ํ
์คํธ ์ผ์ด์ค๋ ์ฌ๋ฌ ๊ฐ์ ๊ทธ๋ฃน์ผ๋ก ๊ตฌ์ฑ๋๋ฉฐ ์๋์ ๊ฐ๋ค.
๊ทธ๋ฃน 1. n <= 10 ์ด๊ณ sub matrix์ ๊ฐ์ 5๊ฐ ์ดํ
๊ทธ๋ฃน 2. n <= 40 ์ด๊ณ 5 < sub matrix <= 10
๊ทธ๋ฃน 3. 40 < n <=80 ์ด๊ณ 5 < sub matrix <= 10
๊ทธ๋ฃน 4. 40 < n <=80 ์ด๊ณ 10 < sub matrix <= 15
๊ทธ๋ฃน 5. 80 < n<=100 ์ด๊ณ 15 < sub matrix <= 20
[์
๋ ฅ]
๋งจ ์ฒซ ์ค์๋ ํ
์คํธ ์ผ์ด์ค์ ๊ฐ์๊ฐ ์ฃผ์ด์ง๋ค.
๊ทธ๋ฆฌ๊ณ ํ
์คํธ ์ผ์ด์ค๊ฐ ๊ฐ ๋ผ์ธ์ ์ฃผ์ด์ง๋ค.
๊ฐ ํ
์คํธ ์ผ์ด์ค๋ (n+1) ์ค๋ก ๊ตฌ์ฑ๋๋ฉฐ, ์ฒซ ์ค์๋ ์์ ์ ์์ธ n์ด ์ฃผ์ด์ง๊ณ , ๋ค์ n์ค์๋ n x n ํ๋ ฌ์ด (๊ฐ ํ์ด ํ ์ค์) ์ฃผ์ด์ง๋ค.
[์ถ๋ ฅ]
๊ฐ ํ
์คํธ ์ผ์ด์ค ๊ฐ๊ฐ์ ๋ํ ๋ต์ ์ถ๋ ฅํ๋ค.
๊ฐ ์ค์ ‘#x’๋ก ์์ํ๊ณ ๊ณต๋ฐฑ์ ํ๋ ๋ ๋ค์, ๊ฐ ํ
์คํธ ์ผ์ด์ค์ ์ฃผ์ด์ง ํ๋ ฌ์์ ์ถ์ถ๋ ๋ถ๋ถ ํ๋ ฌ๋ค์ ๊ฐ์์ ๊ทธ ๋ค๋ฅผ ์ด์ด ํ๋ ฌ๋ค์ ํ๊ณผ ์ด์ ํฌ๊ธฐ๋ฅผ ์ถ๋ ฅํ๋ค.
ํฌ๊ธฐ๋ ํ๊ณผ ์ด์ ๊ณฑํ ๊ฐ์ผ๋ก, ํฌ๊ธฐ๊ฐ ์์ ์์๋๋ก ์ถ๋ ฅํ๋ค.
์๋ฅผ ๋ค์ด 3x4 ํ๋ ฌ์ ํฌ๊ธฐ๋ 3*4 = 12 ์ด๋ค.
ํฌ๊ธฐ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ํ์ด ์์ ์์ผ๋ก ์ถ๋ ฅํ๋ค.
์๋ฅผ ๋ค์ด 12x4, 8x6 ๋ ๊ฐ์ ํ๋ ฌ์ ๊ฐ์ ํฌ๊ธฐ์ด๊ณ ํ์ ๊ฐ๊ฐ 12, 8 ์ด๋ฏ๋ก 8 6 12 4 ์์ผ๋ก ์ถ๋ ฅํ๋ค.
'Algorithm Problem > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[python] SWEA - 1219. [S/W ๋ฌธ์ ํด๊ฒฐ ๊ธฐ๋ณธ] 4์ผ์ฐจ - ๊ธธ์ฐพ๊ธฐ (0) | 2020.08.15 |
---|---|
[python] SWEA - 1861. ์ ์ฌ๊ฐํ ๋ฐฉ (0) | 2020.08.14 |
[python] SWEA - 1251. [S/W ๋ฌธ์ ํด๊ฒฐ ์์ฉ] 4์ผ์ฐจ - ํ๋๋ก (0) | 2020.08.12 |
[python] SWEA - 1218. [S/W ๋ฌธ์ ํด๊ฒฐ ๊ธฐ๋ณธ] 4์ผ์ฐจ - ๊ดํธ ์ง์ง๊ธฐ (0) | 2020.08.11 |
[python] SWEA - 1226. [S/W ๋ฌธ์ ํด๊ฒฐ ๊ธฐ๋ณธ] 7์ผ์ฐจ - ๋ฏธ๋ก1 (2) | 2020.08.10 |