๋ฌธ์
ํด๋น ํฌ์คํ ์ ๋ฐฑ์ค์ 10973๋ฒ ์ด์ ์์ด ์ ์ ๊ทผ๊ณผ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ค๋ช ํ ๊ธ ์ ๋๋ค.
์ ๋ต ์์ค ์ฝ๋๋ฅผ ํ์ธํ์๋ ค๋ฉด solve url ์์ ํ์ธ ๊ฐ๋ฅํฉ๋๋ค.
์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ์ด๋ค ๋ฐฉ์์ผ๋ก ์ ๊ทผํด์ผ ํ๋์ง๋ฅผ ๋จผ์ ์๊ฐํด๋ณด์.
๋ฌธ์ ์ ๊ทผ
์ด๋ฒ ๋ฌธ์ ๋ ์์ด์ ๊ตฌํ๊ธฐ ์ํ Prev Permutation์ ๊ตฌํํ๋ ๋ฌธ์ ์ด๋ค.
์ง๋ 10972๋ฒ ๋ค์ ์์ด ๋ฌธ์ ์ ๊ฐ์ ์ทจ์ง์ ๋ฌธ์ ๋ผ๊ณ ํ ์ ์๋ค.
STL ์์๋ next_permutation๊ณผ prev_permutation ์ด ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณต๋์ด ๊ทธ๋๋ก ์ฌ์ฉํ๋ฉด ๋์ง๋ง, ์๋ฐ์์๋ ์ด๋ฅผ ์ง์ ๊ตฌํํด์ค์ผ ํ๋ค.
๋ค์ ์์ด์ ๊ตฌํ๊ธฐ ์ํด์๋ 4๊ฐ์ง ์์๋ฅผ ๋ฐ๋ผ์ผ ํ๋ค๊ณ ํ๋๋ฐ, ์ด์ ์์ด์ ๊ตฌํ๋ ค๋ฉด ๋ค์ ์์ด์ ๊ตฌํ๋ ๋ถ๋ฑํธ์ ๋ฐ๋๋ง ํด์ฃผ๋ฉด ๋๋ค.
A[i-1] < A[i]
๋ฅผ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ i๋ฅผ ์ฐพ๋๋ค.j >= 1
์ด๋ฉด์A[j] > A[i-1]
์ ๋ง์กฑํ๋ ๊ฐ์ฅ ํฐ j๋ฅผ ์ฐพ๋๋ค.A[i-1]
๊ณผA[j]
๋ฅผ Swap ํ๋ค.A[i]
๋ถํฐ ์์ด์ ๋ค์ง๋๋ค.
์์ ๊ณผ์ ์ ํ ๋ฒ ์ํํ๋ฉด ํ์ฌ ์์ด์์ ๋ฐ๋ก ์ด์ ์์ด์ ์ฐพ์ ์ ์๋ค.
์ด ๊ณผ์ ์ ๋ ์ด์ ์ํํ ์ ์์ ๋งํผ ๋ฐ๋ณตํ๋ค๋ฉด ๋ชจ๋ ์์ด์ ๊ตฌํ๋ ์๊ณ ๋ฆฌ์ฆ์ด ๋๋ค.
์ ๋ต ์ฝ๋
private static boolean nextPermutation(int[] arr) {
int i = arr.length-1;
while(i > 0 && arr[i-1] <= arr[i]) i--;
if(i <= 0) return false;
int j = arr.length-1;
while(arr[j] >= arr[i-1]) j--;
swap(arr, i-1, j);
j = arr.length - 1;
while(i < j) {
swap(arr, i, j);
i++;
j--;
}
return true;
}
private static void swap(int[] arr, int index1, int index2) {
int temp = arr[index1];
arr[index1] = arr[index2];
arr[index2] = temp;
}
๋๊ธ