2932๋ฒ: ํ ํ์
์๊ทผ์ด๋ N×N ํ๋ฅผ ๋ง๋ค์๋ค. ํ์๋ 1๋ถํฐ N2๊น์ง์ ์๊ฐ ํ ์ฐ์ ์์(row-major order)์ ๋ฐ๋ผ ์ฐ์ฌ์ ธ ์๋ค. ํ๊ฐ ์ํํ ์ ์๋ ์ฐ์ฐ์ ์๋์ ๊ฐ์ด ๋ ๊ฐ์ง์ด๋ค. ํ์ ํ์ ์ํจ๋ค - ํ ํ์ ๊ณจ๋ผ
www.acmicpc.net
๋ฐฑ์ค์ ํ ํ์ ๋ฌธ์ ์ ๋๋ค.
์ด ๋ฌธ์ ...๋ถ๋ช ํ์์ ๋๋ ์ค๋ฒ 3์ด์๋ ๊ฒ ๊ฐ์๋ฐ ์ค๋ฒ 2๊ฐ ๋์๋ค์. ์ฌ์ค ๋ฐ๋ ์ ์ ํผ ๋ฌธ์ ์ธ๋ฐ ์์ง๋ ํ์ด๋ฐฉ๋ฒ์ ์์ ์ ์๋... ๊ทธ๋ฐ ๋งค์ฝคํ ์ถ์ต์ด ์๋ ๋ฌธ์ ๋๋๋ค.
์ ์ถ 300, ์ ๋ต 98, ๋งํ ์ฌ๋ 73์ผ๋ก ์ ๋ต ๋น์จ์ด 35%์ ๋๋ค. ๊ทธ๋ฐ๋ฐ ๋ฐฑ์ค์์ ๋งํ ์ฌ๋ 200๋ช ์๋์ผ๋ฉด ํฐ์ด๋ฅผ ๋ฏฟ์ผ์๋ฉด ์ ๋ฉ๋๋ค. ๋ณดํต ๊ณ ์๋ค์ด ์๋ก์ด ๋ฌธ์ ๋์๋ค๊ณ ์ฐ๋จนํด๋ณด๊ฑฐ๋ ์๋ฌด๊ฒ๋ ๋ชจ๋ฅด๋ ๋ด๋น๋ค์ด ๋๋ค๋ฝ๊ธฐ๋ก ํ๊ฒ ๋๊ฑฐ๋ ์. ๋ด๋น๋ค์ด ๋๋ฝ์ผ๋ก ๋ฌธ์ ์ ์ ๊ทผํ๋ ๊ฒฝ์ฐ๋ ๋๋ฌผ๊ณ , ๊ณ ์๋ค์ด ๋๋ถ๋ถ ๊ธฐ๋ฏธ๋ฅผ ํด๋ณด์๋๋ฐ์.
๊ทธ๋ฐ๋ฐ ์ ๋ต๋ฅ ์ด 35%...?
์ ์ ๊ฑด๊ฐ์ ์ํด ์ ๊ฑด๋๋ ํธ์ด ์ข์ต๋๋ค. ์ด๋ฐ ์ฌ์ค์ ๋ชฐ๋๋ ์ ๋ ํฐ์ด ๋ณด๊ณ ์ฌ์ด ๋ฌธ์ ์ธ ์ค ์์๋๋ฐ ๋ฉฐ์น ๋๋ฌผ๋ฝ์์ต๋๋ค.
๋ง์ถ ์ฌ๋ 100 ๋ฐ์ธ๋ฐ ํฐ์ด๊ฐ ์ค๋ฒ? ๊ทธ๋ผ ๊ทธ๋ฅ ๊ณจ๋ ์ ๋ ๋ฌธ์ ๋ก ์์ ํ๊ณ ๋จ๋จํ ๊ฐ์คํ์ ์ผ ํฉ๋๋ค.
๋ฌธ์ ์ค๋ช
๋ฌธ์
์๊ทผ์ด๋ N×N ํ๋ฅผ ๋ง๋ค์๋ค. ํ์๋ 1๋ถํฐ N2๊น์ง์ ์๊ฐ ํ ์ฐ์ ์์(row-major order)์ ๋ฐ๋ผ ์ฐ์ฌ์ ธ ์๋ค. ํ๊ฐ ์ํํ ์ ์๋ ์ฐ์ฐ์ ์๋์ ๊ฐ์ด ๋ ๊ฐ์ง์ด๋ค.
- ํ์ ํ์ ์ํจ๋ค - ํ ํ์ ๊ณจ๋ผ ์ค๋ฅธ์ชฝ์ผ๋ก ํ ์นธ ํ์ ์ํจ๋ค. ๋ง์ง๋ง ์ด์ ์๋ ์๊ฐ ๊ฐ์ฅ ์ฒซ ์ด์ ์ค๊ฒ ๋๋ค.
- ์ด์ ํ์ ์ํจ๋ค - ํ ์ด์ ๊ณจ๋ผ ์๋๋ก ํ ์นธ ํ์ ์ํจ๋ค. ๋ง์ง๋ง ํ์ ์๋ ์๊ฐ ๊ฐ์ฅ ์ฒซ ํ์ ์ค๊ฒ ๋๋ค.
์๊ทผ์ด๋ ์ X๋ฅผ (R,C)๋ก ์ด๋์ํค๋ ค๊ณ ํ๋ค. ์ด๋, ์๊ทผ์ด๋ ๋ค์๊ณผ ๊ฐ์ ๊ณผ์ ์ ๊ฑฐ์ณ์ ์๋ฅผ ์ฐพ๋๋ค.
- X์ ์์น๊ฐ C์ด์ด ๋ ๋ ๊น์ง, X๊ฐ ์๋ ํ์ ํ์ ์ํจ๋ค.
- X์ ์์น๊ฐ Rํ์ด ๋ ๋ ๊น์ง, X๊ฐ ์๋ ์ด์ ํ์ ์ํจ๋ค.
์๋ ๊ทธ๋ฆผ์ 6์ (3,4)์ ์ด๋์ํค๋ ๋ฐฉ๋ฒ์ด๋ค.
์๊ทผ์ด๋ ์ซ์ K๊ฐ๋ฅผ ์ด๋์ํค๋ ค๊ณ ํ๋ค. ํ ์ซ์๋ฅผ ์ด๋์ํค๊ณ ๋ ํ์, ๋ฐ๋ก ๊ทธ ๋ค์ ์ซ์๋ฅผ ์ด๋์ํค๋ฉฐ, ๋ค์ ์ซ์๋ฅผ ์ด๋์ํฌ ๋, ํ์ ๋ค์ด์๋ ์๋ฅผ ์ฒ์ ์ํ๋ก ๋๋๋ฆฌ์ง ์๋๋ค. ์ซ์ K๊ฐ๋ฅผ ์ด๋์ํค๋๋ฐ ํ์ํ ํ์ ์ ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํ์ ํฌ๊ธฐ N(2 ≤ N ≤ 10000)๊ณผ ์ด๋์ํค๋ ค๊ณ ํ๋ ์ซ์์ ์ K(1 ≤ K ≤ 1000)์ด ์ฃผ์ด์ง๋ค.
๋ค์ K๊ฐ ์ค์๋ ์ด๋์ํค๋ ค๊ณ ํ๋ ์ซ์ X์ ์์น R, C๊ฐ ์ฃผ์ด์ง๋ค. (1 ≤ X ≤ N2, 1 ≤ R,C ≤ N)
ํญ์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์์๋๋ก ํ๋์ฉ ์ด๋์์ผ์ผ ํ๋ค.
์ถ๋ ฅ
์ด K๊ฐ ์ค์ ๊ฐ๊ฐ์ ์ซ์๋ฅผ ์ด๋์ํค๋๋ฐ ํ์ํ ํ์ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
ํ์ด
๊ฐ์ธ์ ์ผ๋ก ์ด ๋ฌธ์ ์ ํคํฌ์ธํธ๋ ๋ค์ ๋ ๊ฐ์ง๋ผ๊ณ ์๊ฐํฉ๋๋ค.
1. ํ์์ ํน์ ์ซ์์ ์ด๊ธฐ ์์น๋ ๊ณ์ฐ์ผ๋ก ์ ์ ์๋ค.
2. ๊ทธ๋ฌ๋ฏ๋ก ์ด๋ํ์ง ์๋ ์๋ ์ถ์ ํ์ง ์์๋ ๋๋ค.
๋ฌธ์ ์ ์ ๋ ฅ์ ํ์ ์ ๊น ๋ณผ๊น์.
ํ๊ฐ NxN, ์ฆ ์ ์ฌ๊ฐํ์ผ๋ก ๋ค์ด์ค๋๋ฐ N์ด 1๋ง์ผ๋ก ๋ค์ด์ต๋๋ค.
์ต์ ์ ๊ฒฝ์ฐ Array(10000){IntArray(10000)}์ด ๋๋๋ฐ, ์ฆ 4byte์ง๋ฆฌ Int๋ฅผ 1์ต ๊ฐ ์ ์ฅํด์ผ ํ๋ค๋ ๊ฑด๋ฐ์.
๊ทธ๋ฌ๋ฉด 400000000byte๊ฐ ๋๋๋ฐ...์ด๊ฒ 400MB์ ๋๋ค.
๋ฉ๋ชจ๋ฆฌ ์ ํ์ ํ์ฐธ ๋์ด๊ฐ์ฃ ...
๊ทธ๋์ ์ ์ฒด ์์ด์ ์ ์ฅํด์ ์๋ฎฌ๋ ์ด์ ๋ฐฉ์์ผ๋ก ํธํ๊ฒ ํ์ด๋ณด๊ฒ ๋ค๋ ์๊ฐ์ ์ง์์ ์ ์ผ์ ์ผ ํฉ๋๋ค.(์ ๋ ๋ชฐ๋ผ์ ์ด ๋ฐฉ์์ผ๋ก 3ํธ ํ์ต๋๋ค)
๊ทธ๋ฌ๋ฉด ์ด์ ์๊ณ ๋ฆฌ์ฆ์ ์ข ํ์ด๋ณด์ ๋ถ๋ค์ด๋ฉด ์์ง์ผ ์ ๋ค๋ง ์ ์ฅํด์ผ๊ฒ ๋ค๋ ์๊ฐ์ ํ์๊ฒ ๋ ๊ฒ๋๋ค.
์ด๋ป๊ฒ...?
๋ฐ๋ก ๊ทธ ์ด๋ป๊ฒ๋ฅผ ๊ตฌํํ๋ ๊ฒ์ด ๋ฌธ์ ์ ๋๋ค.
๋คํํ๋ ์ซ์๋ฅผ ์์ง์ด๋ ๋ฐฉ์์ ์ ํด์ ธ ์์ต๋๋ค. 1. ํ ํ์ , 2. ์ด ํ์ ์ ๋๋ค. ๊ทธ๋ผ ์์์ ๋ง๊ฒ ์ฎ๊ธฐ๊ธฐ๋ง ํ๋ฉด ๋๋๋ฐ์.
๋ฌธ์ ์์ ์๊ตฌํ๋ ๊ฒ์ ๊ฐ ์ซ์๋ฅผ ์ด๋์ํค๋ ๋ฐ ํ์ํ ํ์ ์์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด๋ค ์ซ์๋ฅผ ์ฎ๊ธธ ๊ฒ์ธ์ง๋ ์ฒ์์ ๋ค ์๋ ค์ฃผ์ฃ . ๊ทธ๋์ ์ด ๋ฌธ์ ๋ ์ ๋ ฅ ํ๋ ๋ฐ์์ ํ์ ์์ผ๋ณด๊ณ ํ์ ์ ์ถ๋ ฅํ๊ณ ... ์ด๋ฐ ๋ฐฉ์์ผ๋ก ํ๋ฉด ์ ๋ฉ๋๋ค.
์ด๋ค ์๋ฅผ ์์ง์ฌ์ผ ํ๋์ง ์ฒ์์ ๋ค ์ ์ฅํด์, ํ๋์ ์๋ฅผ ์ฎ๊ธธ ๋ ์ ์ฅ๋์ด ์๋ ๋ค๋ฅธ ์์ ์์น๊ฐ ๋ณ๊ฒฝ๋๋์ง๋ฅผ ์ถ์ ํด์ผ ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ฆ ์ฒซ๋ฒ์งธ ์๋ฅผ ์ฎ๊ธธ ๋ ๋๋ฒ์งธ ์์ ์์น๊ฐ ๋ฌ๋ผ์ง ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด์ผ ํ๋ค๋ ๋ป์ด์ฃ .
์ต์ข ๋ก์ง
1. ์ฎ๊ฒจ์ง๋ ์์ ์ด๊ธฐ ์์น๋ฅผ ์ ์ฅํ๋ค.
2. ์๋ฅผ ์ฎ๊ธฐ๋, ์ฎ๊ธฐ๋ ๊ณผ์ ์์ ๋ค๋ฅธ ์์ ์์น๊ฐ ๋ณ๊ฒฝ๋ ๊ฒฝ์ฐ ์ถ์ ํ๋ค.
๊ฐ ๋์ ๋๋ค.
๊ทธ๋์ ๋ชฉํ ์์น๋ฅผ ์ ์ฅํ๋ array์ ์์ ํ์ฌ ์์น๋ฅผ ์ ์ฅํ๋ array, ์ด ๋ ๊ฐ๊ฐ ํ์ํฉ๋๋ค.
์ ๋ต
package silver2
fun main() = with(System.`in`.bufferedReader()) {
val (N, M) = readLine().split(" ").map { it.toInt() }
// ๋ชฉํ ์์น ์ ์ฅ(์ต์ข
์ ์ผ๋ก ์ด๋๋ก ๋ณด๋ด์ผ ํ๋์ง)
var RClist = Array(M) { shortArrayOf(0, 0) }
var matrix_r = IntArray(1000)
var matrix_c = IntArray(1000)
for (i in 0 until M) {
val (X, R, C) = readLine().split(" ").map { it.toInt() }
RClist[i] = shortArrayOf((R - 1).toShort(), (C - 1).toShort())
// ์
๋ ฅ๋ฐ์ ๊ฐ์ ์ด๊ธฐ r์์น ์ ์ฅ
matrix_r[i] = (X - 1) / N
// ์
๋ ฅ๋ฐ์ ๊ฐ์ ์ด๊ธฐ c์์น ์ ์ฅ
matrix_c[i] = (X - 1) % N
}
// r๊ฐ์ ๊ธฐ์ค์ผ๋ก ํ๋ ฌ์ ํ์ ์ํฌ ๋ ์ํฅ์ ๋ฐ๋ ๋ค๋ฅธ ์๊ฐ ์๋์ง ํ์ธํด์ผ ํ๋ค
// ์์ ๊ฒฝ์ฐ ๊ทธ ์๋ ํ์ ์์ผ์ฃผ๊ณ ์ต์ข
์์น๋ฅผ ์ ์ฅํด ์ฃผ์ด์ผ ํจ
fun RotateRow(r: Int, p: Int) {
for (i in 0 until M) {
if (matrix_r[i] == r) {
matrix_c[i] = (matrix_c[i] + p) % N
}
}
}
// RotateRow()์ ๋์ผ
fun RotateColumn(c: Int, p: Int) {
for (i in 0 until M) {
if (matrix_c[i] == c) {
matrix_r[i] = (matrix_r[i] + p) % N
}
}
}
for (i in 0 until M) {
// ๋ชฉํ ์์น๊น์ง ์ผ๋ง๋ ์์ง์ฌ์ผ ํ๋์ง ์ ์ฅ
var r_move = RClist[i][0] - matrix_r[i]
var c_move = RClist[i][1] - matrix_c[i]
// OutOfRange์ผ ๋ N์ ๋ํด์ ๋ฒ์ ์์ผ๋ก ๋ฃ์ด์ค๋ค(ํ์ ํ๊ธฐ ๋๋ฌธ)
if (r_move < 0) r_move += N
if (c_move < 0) c_move += N
RotateRow(matrix_r[i], c_move)
RotateColumn(matrix_c[i], r_move)
println(r_move + c_move)
}
}
'๐ ๊ณต๋ถ > ๐ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ Kotlin ํ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค ๊ผฌ์ธ ์ ๊น์ค - boj1365 (0) | 2023.07.27 |
---|---|
๋ฐฑ์ค N๊ณผ M (9) - boj15663 (1) | 2023.04.24 |
ํ๋ก๊ทธ๋๋จธ์ค - Lv2. ํ๋ณดํค Kotlin (0) | 2023.04.08 |
์ฒซ ๊ธ (0) | 2023.04.07 |