https://www.acmicpc.net/problem/1201
์ด ๋ฌธ์ ๋ ์์ด๋์ด๋ฅผ ๋ ์ฌ๋ฆฌ๋ ๊ฒ์ด ์ค์ํ๋ค, 1 ~ N๊น์ง ๋์ด๋ ์์ด์ ์๊ฐํด๋ณด์
M๊ฐ์ ์ค๋ฆ์ฐจ์์ ๋ง๋ค์ด์ผ ํ๋ค. 1 ~ N๊น์ง ๋์ด๋ ์๋ค์ ์ต๋ํ ์ ์งํ๋ฉด์ ๋ง๋ค ์ ์์๊น? M๊ฐ ๊ทธ๋ฃน์ ๋๋ ์, ๊ทธ๋ฃน ๋ด์์ ํ ์ซ์์ฉ ๋ฝ์ผ๋ฉด M๊ฐ์ ์ค๋ฆ์ฐจ์์ ๋ง๋ค ์ ์๋ค.
ํ์ง๋ง, ๊ทธ๋ฃน ๋ด์์ ํ ์ซ์์ฉ ๋ฝ๋ ๊ฑด ๋ฌธ์ ๊ฐ ์ํ๋ ๊ฒ์ด ์๋๋ค.
๊ทธ๋ฃน์ ๋ชจ๋ ์ซ์๋ค์ ์ญ์์ํค๋ฉด, ๊ทธ๋ฃน ๋ด์์ ํ ์ซ์์ฉ ๋ฝ์์ M๊ฐ์ ์ค๋ฆ ์ฐจ์์ ๋ง๋๋๊ฑด ์ ํจํ๋ค.
K๊ฐ์ ๋ด๋ฆผ์ฐจ์์ ์ด๋ป๊ฒ ๋ง๋ค๊น?
๊ทธ๋ฃน์ ์ญ์ํ ๊ฒฐ๊ณผ๋ฅผ ๋ณด๋ฉด, ๊ทธ๋ฃน ๊ฐ์๊ฐ K๊ฐ๊ฐ ๋๋ค๋ฉด K๊ฐ์ ๋ด๋ฆผ์ฐจ์์ด ์กด์ฌํ ์ ์๋ค.
๊ทธ๋ฃน๋ด์ K๊ฐ๊ฐ ๋ค์ด๊ฐ๊ฒ ํ๋ ๊ฒ์ ์ฌ์ด๋ฐ, ์ด๋ป๊ฒ M๊ฐ์ ๊ทธ๋ฃน์ ๋ณด์ฅ์์ผ์ค์ ์์๊น?
N = 13, M =5, K = 4์ธ ๋ฌธ์ ๋ฅผ ์ดํดํด๋ณด์. ์ฌ๊ธฐ์ ์ต๋ K๊ฐ๋ฅผ ๊ฐ์ง ์ ์๋๋ก ๊ทธ๋ฃน์ ๋ง๋ค์ด์ค๋ค.
1 ~ 4๊น์ง 1๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์๋ค.
5 ~ 8๊น์ง 1๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์๋ค.
9 ~ 12๊น์ง 1๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์์ง๋ง, ๋ฌธ์ ๊ฐ ๋ฐ์ํ๋ค. M๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์ด์ผ ํ๋๋ฐ, ํ์ฌ ๋๋จธ์ง ๊ฒ์ ํฌํจํ๋ค๊ณ ํด๋ M๊ฐ๋ฅผ ๋ง๋ค ์ ์๋ค.
M๊ฐ๋ฅผ ๋ง๋ค๊ธฐ ์ํด์๋, 9 ~ 11๊น์ง 1๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค๋๋ก ํด์ผ ํ๋ค.
K๊ฐ๋ฅผ ์ ํํ ์ง OR K๊ฐ๋ณด๋ค ์์ ์๋ฅผ ์ ํํด์ M๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์ง ๊ฒฐ์
๊ณ์ K๊ฐ๋ฅผ ๊ฐ์ง ๊ทธ๋ฃน๋ค์ ๋ง๋ค๋ฉด ์ํ๋ M๊ฐ์ ๊ทธ๋ฃน์ ๋ง๋ค์ง ๋ชปํ๋ค. K๊ฐ๋ฅผ ๊ฐ์ง ๊ทธ๋ฃน๋ค์ ๋ง๋๋ ๊ฒ์ ๋ฉ์ถฐ์ผ ํ๋ ์๊ฐ์ด ์กด์ฌํ๋ค.
K๊ฐ ์ซ์๋ฅผ ๊ฐ์ง ๊ทธ๋ฃน์ ๋ง๋๋ ๊ฒ์ ๋ฉ์ถฐ์ผ ํ๋ ์๊ฐ?
i๋ฒ์งธ ๊ทธ๋ฃน์ ๋ง์ง๋ง ์๋ฅผ ๊ฐ๋ฆฌํค๋ ์ธ๋ฑ์ค๊ฐ N - M + i ์ธ๋ฑ์ค๋ณด๋ค ์ปค์ง๋ ์๊ฐ ๋ฉ์ถฐ์ผ ํ๋ค. N - M + i + 1์ธ๋ฑ์ค๋ 1๊ฐ ์ซ์๋ฅผ ๊ฐ์ง ๊ทธ๋ฃน M - i๊ฐ๋ฅผ ๋ง๋ค ์ ์๋ ์์ ์ธ๋ฑ์ค์ด๋ค.
N - M + i ์ธ๋ฑ์ค๋ณด๋ค ํฐ ๊ฐ์ด ์ ํ๋๋ฉด ์ด๋ป๊ฒ ๋ ๊น?
1๊ฐ์ฉ ๋ด์ ์ ์๋ ์ต๋ ๊ฐ์์ธ M - i๋ณด๋ค ์์์ง๋ฏ๋ก, ํ์ฌ ๋ง๋ค์ด์ง i๊ฐ์ ๊ทธ๋ฃน์์ M - i - @๋ฅผ ๋ํ๋ฉด M - @์ด๋ฏ๋ก M๋ณด๋ค ์์์ง ์ ๋ฐ์ ์๋ค.
import java.util.*;
import java.lang.*;
import java.io.*;
class Main
{
static void rotate(int[] arr, int start, int end){
while(start < end){
int tmp = arr[start];
arr[start] = arr[end];
arr[end] = tmp;
start++;
end--;
}
}
public static void main (String[] args) throws java.lang.Exception
{
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
String[] sArr = br.readLine().split(" ");
int[] arr;
int N, M, K;
N = Integer.valueOf(sArr[0]);
M = Integer.valueOf(sArr[1]);
K = Integer.valueOf(sArr[2]);
arr = new int[N + 1];
for(int i = 1; i <= N; i++) arr[i] = i;
if(!((M - 1) <= (N - K) && (N - K) <= K * (M - 1))){
System.out.println("-1");
return;
}
int idx = 1;
for(int i = 1; i <= M; i++){
int tmp = Math.min(idx + K, (N + 1) - M + i);
rotate(arr, idx, tmp - 1);
if(tmp != idx + K) break;
idx = tmp;
}
for(int i = 1; i < arr.length; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
}