์ด ๊ธ์์๋ Next Permutation ์๊ณ ๋ฆฌ์ฆ์ ์๋ฆฌ์ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ํด ์ค๋ช ํฉ๋๋ค. ์ด ์๊ณ ๋ฆฌ์ฆ์ ์ฃผ์ด์ง ๋ฐฐ์ด์์ ์ฌ์ ์์ผ๋ก ๋ค์ ์์ด์ ์์ฑํ๋ ๋ฐ ์ฌ์ฉ๋ฉ๋๋ค. ์ฃผ๋ก ๋ฉ๋ชจ๋ฆฌ์ ์๊ฐ ํจ์จ์ฑ์ ๊ณ ๋ คํ ๋ฌธ์ ํด๊ฒฐ์ ํ์ฉ๋ฉ๋๋ค.
pivot์ด๋ผ๊ณ ๋ถ๋ฅด๋ฉฐ, ๋ฐฐ์ด์์ ๋ ํฐ ์์ด์ ๋ง๋ค ์ ์๋ ์ต์ ์์น๊ฐ ๋ฉ๋๋ค. pivot ๋ค์ ์ซ์๋ค์ ๋ด๋ฆผ์ฐจ์์ด๋ฏ๋ก ์ด๋ฏธ ๊ฐ์ฅ ํฐ ์์ด ์ํ์
๋๋ค. ๋ฐ๋ผ์, pivot์ ๋ฐ๊พธ์ด์ผ ๋ ํฐ ์์ด์ ๋ง๋ค ์ ์์ต๋๋ค.pivot์ ๊ธฐ์ค์ผ๋ก ๊ทธ ์ค๋ฅธ์ชฝ์์ pivot๋ณด๋ค ํฐ ์ฒซ ๋ฒ์งธ ์๋ฅผ ์ฐพ์ต๋๋ค. ์ด ์๋ฅผ successor๋ผ๊ณ ํฉ๋๋ค. ์ด๋, pivot ๋ค์ ์๋ ์ซ์๋ค์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ผ๋ฏ๋ก, ๋ค์์๋ถํฐ ํ์ํ์ฌ ๊ฐ์ฅ ์์ successor๋ฅผ ์ฐพ๊ฒ ๋ฉ๋๋ค. ์ด๋ ๊ฒ ์ฐพ์ successor์ pivot์ ๊ตํํ์ฌ ์ฌ์ ์์ผ๋ก ๋ ํฐ ์์ด์ ๋ง๋ค ์ ์์ต๋๋ค.pivot๊ณผ successor๋ฅผ ๊ตํํ์ฌ ์์ด์ ์
๋ฐ์ดํธํฉ๋๋ค.pivot ๋ค์ ์๋ ์ซ์๋ค์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌ๋์ด ์์ผ๋ฏ๋ก, ์ด๋ฅผ ๋ค์ง์ด ์ค๋ฆ์ฐจ์์ผ๋ก ๋ง๋ญ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๊ฐ์ฅ ์์ ์์ด์ด ๋์ด, ์ ์ฒด ๋ฐฐ์ด์ ๋ค์ ์์ด์ด ๋ฉ๋๋ค.์๋๋ Java๋ก ๊ตฌํ๋ Next Permutation ์๊ณ ๋ฆฌ์ฆ์
๋๋ค:
import java.util.*;
import java.lang.*;
import java.io.*;
class Main {
public static void main(String[] args) {
// Example usage
}
public void nextPermutation(int[] arr) {
int n = arr.length;
int i = n - 2;
while (i >= 0 && arr[i] >= arr[i + 1]) i--;
if (i >= 0) {
int j = n - 1;
while (j >= 0 && arr[j] <= arr[i]) j--;
swap(arr, i, j);
}
reverse(arr, i + 1, n - 1);
}
public static void swap(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
public static void reverse(int[] arr, int start, int end) {
while (start < end) {
swap(arr, start, end);
start++;
end--;
}
}
}
Next Permutation์ ์ฌ์ ์์ผ๋ก ๋ค์ ์์ด์ ์์ฑํ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก, 0๊ณผ 1๋ก ์ด๋ฃจ์ด์ง ์์ด์ ํตํด ๋ชจ๋ ์กฐํฉ์ ์์ฑํ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด 00011์ด๋ผ๋ ๋ฐฐ์ด์ด ์๋ค๋ฉด, ์ด๋ฅผ ํตํด 5๊ฐ์ ์์์ 2๊ฐ๋ฅผ ์ ํํ๋ ๋ชจ๋ ์กฐํฉ์ Next Permutation์ ์ด์ฉํด ๊ตฌํ ์ ์์ต๋๋ค.
์ด ๊ธ์์๋ Next Permutation ์๊ณ ๋ฆฌ์ฆ์ ์๋ฆฌ์ ๊ทธ ์ฌ์ฉ ์ด์ , ๊ทธ๋ฆฌ๊ณ ์ค์ ์ฝ๋ ์์๋ฅผ ์ดํด๋ณด์์ต๋๋ค. ์ด๋ฅผ ํตํด ๋ ํจ์จ์ ์ธ ์์ด ๋ฐ ์กฐํฉ ์์ฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์ ๊ฒ์ ๋๋ค! ๐