โญ๏ธโญ๏ธ 10811 ๋ฐ๊ตฌ๋ ๋ค์ง๊ธฐ
๋ฌธ์
๋ํ์ด๋ ๋ฐ๊ตฌ๋๋ฅผ ์ด N๊ฐ ๊ฐ์ง๊ณ ์๊ณ , ๊ฐ๊ฐ์ ๋ฐ๊ตฌ๋์๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ์์๋๋ก ์ ํ์ ธ ์๋ค. ๋ฐ๊ตฌ๋๋ ์ผ๋ ฌ๋ก ๋์ฌ์ ธ ์๊ณ , ๊ฐ์ฅ ์ผ์ชฝ ๋ฐ๊ตฌ๋๋ฅผ 1๋ฒ์งธ ๋ฐ๊ตฌ๋, ๊ทธ ๋ค์ ๋ฐ๊ตฌ๋๋ฅผ 2๋ฒ์งธ ๋ฐ๊ตฌ๋, ..., ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋ฐ๊ตฌ๋๋ฅผ N๋ฒ์งธ ๋ฐ๊ตฌ๋๋ผ๊ณ ๋ถ๋ฅธ๋ค.
๋ํ์ด๋ ์์ผ๋ก M๋ฒ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋ค๋ ค๊ณ ํ๋ค. ๋ํ์ด๋ ํ ๋ฒ ์์๋ฅผ ์ญ์์ผ๋ก ๋ฐ๊ฟ ๋, ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋ค ๋ฒ์๋ฅผ ์ ํ๊ณ , ๊ทธ ๋ฒ์์ ๋ค์ด์๋ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋ ๋ค.
๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ด๋ป๊ฒ ๋ฐ๊ฟ์ง ์ฃผ์ด์ก์ ๋, M๋ฒ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋ ๋ค์, ๋ฐ๊ตฌ๋์ ์ ํ์๋ ๋ฒํธ๋ฅผ ๊ฐ์ฅ ์ผ์ชฝ ๋ฐ๊ตฌ๋๋ถํฐ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ N (1 ≤ N ≤ 100)๊ณผ M (1 ≤ M ≤ 100)์ด ์ฃผ์ด์ง๋ค.
๋์งธ ์ค๋ถํฐ M๊ฐ์ ์ค์๋ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋๋ ๋ฐฉ๋ฒ์ด ์ฃผ์ด์ง๋ค. ๋ฐฉ๋ฒ์ i j๋ก ๋ํ๋ด๊ณ , ์ผ์ชฝ์ผ๋ก๋ถํฐ i๋ฒ์งธ ๋ฐ๊ตฌ๋๋ถํฐ j๋ฒ์งธ ๋ฐ๊ตฌ๋์ ์์๋ฅผ ์ญ์์ผ๋ก ๋ง๋ ๋ค๋ ๋ป์ด๋ค. (1 ≤ i ≤ j ≤ N)
๋ํ์ด๋ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ์์๋๋ก ๋ฐ๊ตฌ๋์ ์์๋ฅผ ๋ฐ๊พผ๋ค.
5 4
1 2
3 4
1 4
2 2
์ถ๋ ฅ
๋ชจ๋ ์์๋ฅผ ๋ฐ๊พผ ๋ค์์, ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ๋ฐ๊ตฌ๋๋ถํฐ ๋ฐ๊ตฌ๋์ ์ ํ์๋ ์์๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค.
3 4 1 2 5
๋๋ ๊ฐ์ธ์ ์ผ๋ก ์ด ๋ฌธ์ ๊ฐ ์กฐ๊ธ ์ด๋ ค์ ๋ค.
๊ทธ๋ฆฌ๊ณ ์ฌ๋๋ค์ ๋ฐ๋ผ ์ฌ๋ฌ๊ฐ์ง ๋ฌธ์ ํ์ด๋ค๋ ์กด์ฌํ ๊ฒ์ด๋ผ ์๊ฐํด์!
ํฌ์คํ ์ ๋ฐ๋ก ๋นผ๋์๋ค.
๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ ๋ณด๋ฉด์ ๊ณต๋ถํด์ผํ ๋ฌธ์ ..
์ฃผ์ด์ง ๋ฒ์๋งํผ์ ์ญ์์ผ๋ก ์ ๋ ฌํ๋๊ฒ์ด๋ค.
๋จธ๋ฆฟ์์ผ๋ก๋ ๊ทธ๋ ค์ง๋๋ฐ ์๋ฐ๋ก ์๊ณ ๋ฆฌ์ฆ์ ํผ์ ์ด ์์ด์
์ด๋ป๊ฒ ํด์ผํ ์ง ๋ชฐ๋๋ค.
๊ทธ๋์ reverse๋ผ๋ ํจ์๋ฅผ ํ๋ ๋ง๋ค์๋ค.
import java.io.*;
import java.util.StringTokenizer;
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int N = Integer.parseInt(st.nextToken());
int M = Integer.parseInt(st.nextToken());
int[] basket = new int[N];
for (int n= 0; n < N; n++) {
basket[n] = n + 1;
}
for (int l = 0; l < M; l++) {
StringTokenizer range = new StringTokenizer(br.readLine());
int i = Integer.parseInt(range.nextToken()) - 1;
int j = Integer.parseInt(range.nextToken()) - 1;
reverse(basket, i, j);
}
for (int k = 0; k < N; k++) {
System.out.print(basket[k]+" ");
}
}
public static void reverse(int[] array, int start, int end) {
while (start < end) {
int temp = array[start];
array[start] = array[end];
array[end] = temp;
start++;
end --;
}
}
}
์ญ์์ผ๋ก ์ ๋ ฌํ ๋ถ๋ถ์ ์์์ง์ , ๊ทธ๋ฆฌ๊ณ ๋์ง์ ์ ์ธ์๋ก ๋ฐ๋๋ค.
์์ ๋ฌธ์ ์์ ํ๋๊ฒ์ฒ๋ผ, ์์ ๋ถ๋ถ์ ๊ฐ์ temp์ ๋ด๊ณ
๋งจ ๋ค์ ๊ฐ๊ณผ
๊ตํ!
ํด์ค๋ค.
๊ทธ๋ฆฌ๊ณ start๋ฅผ ๋๋ฆฌ๊ณ end๊ฐ์ ์ค์ด๋ฉด์.. ์งํํ๋ค.
๊ทธ๋ฆผ์ผ๋ก ๋ด๋ณผ๊น?
์ด๊ฑฐ ํ๊ต ์์ ์๊ฐ์ ์ด๋ ๊ฒ ๊ตฌํํ๋ ใด๊ธฐ์ต์ด ์๋๋..
๋ ๋ฉ์ง ๋ฐฉ๋ฒ์ด ์์ง ์์๊น ์ถ๋ค
๋ค๋ฅธ ๋ฐฉ๋ฒ๋ค์ ๋ค์ ํฌ์คํ ์..
์ ๋๋กํ๊ฒ ๋ค.