- ํผ์ง์ปฌ๋ก ์น๋ถํ๊ธฐ โ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฌธ๋ฒ์ ๋ฅ์ํ๊ณ ์ฝ๋ ์์ฑ ์๋๊ฐ ๋น ๋ฅธ ์ฌ๋
- ๊ตฌํ : ๋จธ๋ฆฟ์์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ ์์ค์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ณผ์
- ๊ตฌํ ๋ฌธ์ ์ ํ์ ๋ชจ๋ ๋ฒ์์ ์ฝ๋ฉ ํ ์คํธ ๋ฌธ์ ์ ํ์ ํฌํจํ๋ ๊ฐ๋
- ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ์ฉ ๊ฒฝํ์ ์ต์ํ๊ฒ ํ์
- ์๊ฐํด๋ธ ๋ฌธ์ ํ์ด ๋ฐฉ๋ฒ์ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์ ํํ ๊ตฌํ
- ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฌธ๋ฒ์ ์ ํํ ์๊ณ ์์ด์ผ ํจ
- ํ์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋ ๊ฒ์ ์ฌ์ฐ๋ ์์ค์ฝ๋๋ก๋ ์ฎ๊ธฐ๊ธฐ ์ด๋ ค์ด ๋ฌธ์
- ์๊ณ ๋ฆฌ์ฆ์ ๊ฐ๋จํ๋ฐ ์ฝ๋๊ฐ ์ง๋์น ๋งํผ ๊ธธ์ด์ง๋ ๋ฌธ์
- ์ค์ ์ฐ์ฐ์ ๋ค๋ฃจ๊ณ , ํน์ ์์์ ์๋ฆฌ๊น์ง ์ถ๋ ฅํด์ผ ํ๋ ๋ฌธ์
- ์ ์ ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐพ์์ ์ฌ์ฉํด์ผ ํ๋ ๋ฌธ์
- ์์ ํ์ :
๋ชจ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ์ฃผ์ ์์ด ๋ค ๊ณ์ฐํ๋ ํด๊ฒฐ๋ฐฉ๋ฒ - ์๋ฎฌ๋ ์ด์
: ๋ฌธ์ ์์ ์ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ํ ๋จ๊ณ์ฉ
์ฐจ๋ก๋ก์ง์ ์ํ โ ๋ฐฉํฅ ๋ฒกํฐ๊ฐ ์์ฃผ ํ์ฉ
- 2์ฐจ์ ๊ณต๊ฐ(๋ฐ๋ณต์ ์ผ๋ก ์บ๋ฆญํฐ ์ด๋ ๋ฌธ์ )
- ์ด๊ณผ ํ์ด ์์
| (0, 0) | (0,1) | (0, 2) | (0, 3) |
|---|---|---|---|
| (1, 0) | (1, 1) | (1, 2) | (1, 3) |
| (2, 0) | (2, 1) | (2, 2) | (2, 3) |
for i in range(5):
for j in range(5):
print('(', i, ',', j ')', end=' ')
print()# ๋ ๋ถ ์ ๋จ
dx = [0, -1, 0, 1] # ์ธ๋ก์ถ ๊ธฐ์ค์ผ๋ก
dy = [1, 0, -1, 0]
# ํ์ฌ ์์น
x, y =1, 2
for i in range(4):
# ๋ค์ ์์น
nx = x + dx[i]
ny = y + dy[i]
print(nx, ny) ๋ถ๊ฐ์ค๋ช : ๋์ชฝ์ผ๋ก ๋ด๋ ค๊ฐ๋ฉด ์ด์ ์ฆ๊ฐํ์ง ์๊ณ ํ์ ์ฆ๊ฐํจ
EX. (1, 0) โ (2, 0)
1. C/C++์์ ๋ณ์์ ํํ ๋ฒ์ - ์ ์ํ int(4๋ฐ์ดํธ) < int๋ณด๋ค ํฐ long long(8๋ฐ์ดํธ) < BigInteger(ํด๋์ค) : ๊ฐ๋ณ์ ์ด๋ฉฐ, ์๋ฃํ์ ๋ฒ์๋ ์ ํ ์์ - ํ์ง๋ง c++์ ๊ฒฝ์ฐ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํฌํจ๋์ด ์์ง ์๊ธฐ ๋๋ฌธ์ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํํ๋ฅผ ๊ฐ์ ธ์ ์ฌ์ฉ
2. ํ์ด์ฌ - ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ์๋ฃํ ์ง์ ํ ํ์ ์์, ๋งค์ฐ ํฐ ์์ ์ฐ์ฐ ๋ํ ๊ธฐ๋ณธ์ผ๋ก ์ง์ - ์ ์ํ ๋ณ์์ ์ฐ์ฐ ๋๋ฌธ์ ๊ณ ๋ฏผ No! - but, ์ค์ํ ๋ณ์๋ ๋ค๋ฅธ ์ธ์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ํจ์ซ์์ ๋ฐ๋ผ์ ์ฐ์ฐ ๊ฒฐ๊ณผ๊ฐ ์ํ๋ ๊ฐ์ด ๋์ค์ง ์์ ์ ์์
- ํ์ด์ฌ์์
๋ฆฌ์คํธ์ ๊ณ ๋ ค์ฌํญโจ-
ํ์ด์ฌ์์๋ ์ฌ๋ฌ ๊ฐ์ ๋ณ์ ์ฌ์ฉ์ ๋ฆฌ์คํธ ์ด์ฉ
-
๋ฉ๋ชจ๋ฆฌ ์ฌํญ ๊ณ ๋ ค
- ์ฝ๋ฉํ ์คํธ์์ 128~512MB๋ก ๋ฉ๋ชจ๋ฆฌ ์ ํ ์ผ๋์ ๋๊ณ ํ์ด์ผ ํจ
- ํฌ๊ธฐ๊ฐ 1,000๋ง ์ด์ ๋ฆฌ์คํธ๊ฐ ์๋ค๋ฉด, ๋ฉ๋ชจ๋ฆฌ ์ฉ๋ ์ ํ์ผ๋ก ํ์ง ๋ชปํจ
- int ์๋ฃํ ๋ฐ์ดํฐ์ ๊ฐ์์ ๋ฐ๋ฅธ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
๋ฐ์ดํฐ์ ๊ฐ์(๋ฆฌ์คํธ์ ๊ธธ์ด) ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ 1,000 ์ฝ 4KB 1,000,000 ์ฝ 4MB 10,000,000 ์ฝ 40MB
-
-
์๊ฐ ์ ํ : 1์ด
-
๋ฉ๋ชจ๋ฆฌ ์ ํ : 128MB
โ ํ์ด์ฌ์ ๊ฒฝ์ฐ 1์ด์ 2,000๋ง๋ฒ์ ์ฐ์ฐ ์ํ ๊ฐ๋ฅํ ๊ฒ๋ง ์๋ฉด ๋จ
-
์๊ฐ ์ ํ : 1์ด, ๋ฐ์ดํฐ์ ๊ฐ์ : 100๋ง๊ฐ
โ ์๊ฐ ๋ณต์ก๋
O(NlogN)์ด๋ด์ ์๊ณ ๋ฆฌ์ฆ ์ด์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํจ
๐ก TIP) ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ ๋๋ ์๊ฐ ์ ํ๊ณผ ๋ฐ์ดํฐ์ ๊ฐ์๋ฅผ ๋จผ์ ํ์ธ ํ ๋ค, ์ด ๋ฌธ์ ๋ฅผ ์ด๋ ์ ๋์ ์๊ฐ๋ณต์ก๋์ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ์์ฑํด์ผ ํ ์ ์์ ๊ฒ์ธ์ง ์์ธก
- ์ฌ์ํ ์ ๋ ฅ ์กฐ๊ฑด ๋ฑ ๋ฌธ์ ์์ ๋ช ์ํด์ฃผ๋ฉฐ, ๋ฌธ์ ์ ๊ธธ์ด ํฐ ํธ
- ํ์ด์ฌ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ํ ์ ์ข์ ์ ๋ค๋ฅธ ์ธ์ด์ ๋น๊ต
| ๊ตฌํ ๋์ด๋ | ํ๋ก๊ทธ๋จ ์คํ ์๊ฐ | |
|---|---|---|
| ํ์ด์ฌ | ์ฌ์ด ํธ | ๊ธด ํธ |
| PyPy | ์ฌ์ด ํธ | ๋ค์ ์งง์ ํธ |
| C/C++ | ์ด๋ ค์ด ํธ | ์งง์ ํธ |
-
ํ์ด์ฌ์ผ๋ก ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐ์, ๊ทธ๋ํฝ ์ฒ๋ฆฌ ์ฅ์น(GPU)๋ฅผ ์ฐ๋ํ๋ฉฐ, ๋ฐ๋ณต์ ์ธ ํ๋ ฌ ๊ณ์ฐ์ ์๊ตฌํ๋ ๋ณต์กํ ์ํ ๋ฌธ์ ์ C์ธ์ด๋ก ์์ฑ๋ ํ์ด์ฌ ์ฝ์ด ์ํํธ์จ์ด ๋์
-
BUT, ์๊ณ ๋ฆฌ์ฆ ํ๊ฒฝ์์๋ GPU ์ฐ์ฐ ์ฐ๋ ๊ฒฝ์ฐ๊ฐ ์์
-
์๋ ์ฑ์ ๋ฐฉ์ ์ฝ๋ฉ ํ ์คํธ ํ๊ฒฝ์์๋ PyPy3๋ฅผ ์ง์ํ๋ ๊ณณ์ด ์ฆ๊ฐ
โ PyPy3๋ ํ์ด์ฌ 3์ ๋ฌธ๋ฒ์ ๊ทธ๋๋ก ์ง์, ํ์ด์ฌ3๋ณด๋ค ์คํ ์๋๊ฐ ๋น ๋ฅด๋ค
-
ํ์ด์ฌ ์ด์ฉ์ API ๊ฐ๋ฐ ๋ฌธ์ ๋ฅผ ๋ณด๋๋ผ๋ ์๋์ ์ผ๋ก ๋ฌด๋ํ๊ฒ ๋์ฒ ๊ฐ๋ฅ
- ๋ฌธ์ p.110 - ์ฌํ์ A๋ N*N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ ์ ์ ์์ - ๊ฐ์ฅ ์ผ์ชฝ ์ ์ขํ (1,1), ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์๋ ์ขํ**(N, N)** - ์์ ์ขํ๋ ํญ์ (1,1) ์,ํ,์ข,์ฐ ์ด๋ ๊ฐ๋ฅ - ๊ณํ์ : ํ๋์ ์ค์ ๋์ด์ฐ๊ธฐ ๊ธฐ์ค์ผ๋ก L,R,U,D ์ค ํ๋์ ๋ฌธ์๊ฐ ๋ฐ๋ณต์ ์ผ๋ก ์ ํ ์์
-
L : ์ผ์ชฝ์ผ๋ก ํ ์นธ ์ด๋, R : ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ์ด๋, U : ์๋ก ํ ์นธ ์ด๋, D : ์๋๋ก ํ ์นธ ์ด๋
- N*N ํฌ๊ธฐ์ ์ ์ฌ๊ฐํ ๊ณต๊ฐ์ ๋ฒ์ด๋๋ ์์ง์์ ๋ฌด์
- ๊ณํ์๊ฐ ์ฃผ์ด์ก์ ๋ ์ฌํ์ A๊ฐ ์ต์ข ์ ์ผ๋ก ๋์ฐฉํ ์ง์ ์ ์ขํ
โ ์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค ๊ณต๊ฐ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๋ N์ด ์ฃผ์ด์ง๋ค$(1\leq N \leq 100)$
- ๋์งธ ์ค์ ์ฌํ์ A๊ฐ ์ด๋ํ ๊ณํ์ ๋ด์ฉ์ด ์ฃผ์ด์ง๋ค (
$1 \leq ์ด๋ํ์ \leq 100)$
โ ์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ฌํ๊ฐ A๊ฐ ์ต์ข ์ ์ผ๋ก ๋์ฐฉํ ์ง์ ์ ์ขํ(X,Y)๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ถ๋ ฅ
๐ ๋ฌธ์ ํด๊ฒฐ
-
์๊ฐ ๋ณต์ก๋ : O(N) ์๊ฐ ๋ณต์ก๋๊ฐ ๋๋ํ ํธ
-
์ผ๋ จ์ ๋ช ๋ น์ ๋ฐ๋ผ์ ๊ฐ์ฒด๋ฅผ
์ฐจ๋ก๋๋ก์ด๋์ํจ๋ค๋ ์ : ์๋ฎฌ๋ ์ด์ ์ ํ -
์ฐธ๊ณ for๋ฌธ
- ํ์ด์ฌ์์ for๋ฌธ์ ๋ค์ฌ์ฐ๊ธฐ๊ฐ ์ค์
- for**[๋ณ์1]** in [๋ฌธ์์ด1, ๋ฆฌ์คํธ1, ํํ1]:
arr = [1, 2, 3, 4, 5] for i in arr: print(i)
# N์ ์
๋ ฅ๋ฐ๊ธฐ
n = int(input())
x, y = 1, 1 # ํ์ฌ ์์น
plans = input().split()
# L,R,U,D ๋ฐฉํฅ์ ๋ฐ๋ฅธ ์ด๋ ์ด๋, **๋ฐฉํฅ ๋ฒกํฐ**
dx = [0,0,-1,1] # x์ขํ๋ ์ข์ฐ
dy = [-1,1,0,0] # y์ขํ๋ ์์๋
move_types=['L', 'R', 'U', 'D']
# ์ด๋ ๊ณํ์ ํ๋์ฉ ํ์ธ
for plan in plans :
# ์ด๋ ํ ์ขํ ๊ตฌํ๊ธฐ
for i in range(len(move_types)):
if plan == move_types[i]:
nx = x + dx[i]
ny = y + dy[i]
# ์์ญ์ ๋ฒ์ด๋๋ ๊ฒฝ์ฐ ๋ฌด์
if nx<1 or ny<1 or nx>n or ny>n:
countinue # ์ค๊ฐ์ ๋ฉ์ถ๊ณ ์ฒ์์ผ๋ก ๋์๊ฐ์
# ์ด๋ ์ํ
x, y = nx, ny
print(x, y)โ ์ ๋ ฅ๋ฐ์ ๊ฒ ๋ฌด์์ธ์ง ์๊ฐํด๋ณด๊ณ ์ฐจ๋ก๋ก ์ํํด ๋๊ฐ๊ธฐ
-
๋ฌธ์ p.113
- ์ ์ N์ด ์ ๋ ฅ๋๋ฉด 00์ 00๋ถ 00์ด๋ถํฐ N์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ์๊ฐ ์ค 3์ด ํ๋๋ผ๋ ํฌํจ๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ
โ ์ ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ์ ์ N์ด ์ ๋ ฅ๋๋ค$(0 \leq N \leq 23)$
โ ์ถ๋ ฅ์กฐ๊ฑด
- 00์ 00๋ถ 00์ด๋ถํฐ N์ 59๋ถ 59์ด๊น์ง์ ๋ชจ๋ ์๊ฐ ์ค 3์ด ํ๋๋ผ๋ ํฌํจ๋๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ๊ตฌํ๊ธฐ
๐ ๋ฌธ์ ํด๊ฒฐ
-
๋ชจ๋ ์๊ฐ์ ๊ฒฝ์ฐ๋ฅผ ํ๋์ฉ ๋ชจ๋ ์
-
๋ชจ๋ ๊ฒฝ์ฐ์ ์๊ฐ 100,000๊ฐ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ๋ฌธ์์ด ์ฐ์ฐ ์ด์ฉํด๋ ์๊ฐ ์ ํ 2์ด์์ ๋ฌธ์ ํด๊ฒฐ ๊ฐ๋ฅ
-
๋จ์ํ ์๊ฐ์ 1์ฉ ์ฆ๊ฐ์ํค๋ฉด์ ํ์ธ โ ์์ ํ์ ์ ํ(๋นํจ์จ์ ์ด๋ผ ๋ฐ์ดํฐ ๊ฐ์๊ฐ ํฐ ๊ฒฝ์ฐ ์๋ ์ํ ์ ์์)
-
๊ฒฝ์ฐ์ ์ **24(์๊ฐ)60(๋ถ)60(์ด) โ
3์ค ๋ฐ๋ณต๋ฌธ์ด์ฉ -
๋ฌธ์์ด๋ก ๋ฐ๊ฟ์ ํ์ธ โ EX. 03์20๋ถ23์ด๋ผ๋ฉด โ032023โ๋ก ๋ง๋ค์ด์ ํ์ธ -
์ฐธ๊ณ str
ํ์ด์ฌ ๋ฌธ์์ด ๋ณํ - str()
# H๋ฅผ ์
๋ ฅ๋ฐ๊ธฐ
h = int(input())
count = 0
# h๋ถํฐ 1์ฉ ์ฆ๊ฐ
for i in range(h + 1):
for j in range(60): # ์
๋ ฅ๋ฐ๋ ๊ฒ์ ์๊ฐ ๋ฟ์ด๊ธฐ ๋๋ฌธ์ ๋ถ, ์ด๋ 0๋ถํฐ 60๊น์ง๋ก **๋ฒ์ ์ค์ ๋ฐ ์ฆ๊ฐ ํ๊ฒ**
for k in range(60):
# ๋งค ์๊ฐ ์์ 3์ด ํฌํจ๋์ด ์๋ค๋ฉด ์นด์ดํธ ์ฆ๊ฐ
if '3' in str(i) + str(j) + str(k): # ์๊ฐ์ **๋ฌธ์์ด ๋ฐ๊พผ ๋ค์** ๋ฌธ์์ด์ '3'์ด ํฌํจ๋๋์ง ํ์ธ
count+=1
print(count)
- ๋ฌธ์ p.115 - ์์ค ์ ์ 8*8 ์ขํ ํ๋ฉด - ๋์ดํธ๋ ๋ง์ ํ๊ณ ์๊ธฐ์ ์ด๋์, L์ ํํ๋ก๋ง ์ด๋ ๊ฐ๋ฅ, ์ ์ ๋ฐ์ผ๋ก ์ด๋ ๋ถ๊ฐ 1. ์ํ์ผ๋ก ๋ ์นธ ์ด๋ํ ๋ค์ ์์ง์ผ๋ก ํ ์นธ ์ด๋ 2. ์์ง์ผ๋ก ๋ ์นธ ์ด๋ํ ๋ค์ ์ํ์ผ๋ก ํ ์นธ ์ด๋
โ ์
๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ 8*8 ์ขํ ํ๋ฉด์์์ ํ์ฌ ๋์ดํธ๊ฐ ์์นํ ๊ณณ์ ์ขํ๋ฅผ ๋ํ๋ด๋ ๋ ๋ฌธ์๋ก ๊ตฌ์ฑ๋ ๋ฌธ์์ด์ด ์
๋ ฅ๋๋ค. ์
๋ ฅ ๋ฌธ์๋ a1์ฒ๋ผ ์ด๊ณผ ํ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค
โ ์ถ๋ ฅ์กฐ๊ฑด
- ์ฒซ์งธ ์ค์ ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ ๊ฒฝ์ฐ์ ์ ์ถ๋ ฅ
๐ ๋ฌธ์ ํด๊ฒฐ
- ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ ๊ฒฝ๋ก๋ฅผ ํ๋์ฉ ํ์ธํ์ฌ ์ด๋
- ๋ค๋ง, 8*8ํ๋ฉด์ ๋ฒ์ด๋์ง ์๋๋ก ๊ผผ๊ผผํ ๊ฒ์ฌ
- ๋์ดํธ ์ด๋ ๊ฒฝ๋ก๋ฅผ steps ๋ณ์์ ๋ฃ๋๋ค๋ฉด
steps = [(-2, -1), (-1, -2), (1, -2), (-2, 1), (2, 1), (1, 2), (-1, 2), (-2, 1)]- <์ฝ๋>
# ํ์ฌ ๋์ดํธ ์์น ๋ฐ๊ธฐ
input_data = input()
# ๋ ๋ฒ์งธ ์์น์ ์ซ์๋ฅผ ๋ฐ๊พผ ๊ฒ์ด ํ
row = int(input_data[1])
# ๋ฌธ์๋ก ๋ค์ด์จ ๊ฐ์ ์์คํค ์ฝ๋๋ก ๋ฐ๊พธ๊ณ
column = int(ord(input_data[0]))-int(ord('a')) + 1
# ๋์ดํธ๊ฐ ์ด๋ํ ์ ์๋ 8๊ฐ์ง ๋ฑกํฅ ์ ์, dx, dy์ฌ์ฉํด๋ ๊ฐ๋ฅ
steps = [(-2, -1), (-1, -2), (1, -2), (-2, 1), (2, 1), (1, 2), (-1, 2), (-2, 1)]
# 8๊ฐ์ง ๋ฐฉํฅ์ ๋ํ์ฌ ๊ฐ ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ์ง ํ์ธ
result = 0
for step in steps:
# ์ด๋ํ๊ณ ์ ํ๋ ์์น ํ์ธ
next_row = row + step[0]
next_column = column + step[1]
# ํด๋น ์์น๋ก ์ด๋์ด ๊ฐ๋ฅํ๋ค๋ฉด ์นด์ดํธ ๋ค์ด
if next_row >=1 and next_row < =8 and next_column >=1 and next_column <= 8:
result +=1
print(result) 