์์ด์ ๊ตฌํ๋ next_permutation ํจ์
์์ด
์ํ์ ์ผ๋ก ์์ด(permutation)์ด๋ ์๋ก ๋ค๋ฅธ n๊ฐ์ ์์์์ r๊ฐ๋ฅผ ๋ฝ์ ํ ์ค๋ก ์ธ์ฐ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋งํฉ๋๋ค. ์์๋ฅผ ํ ์ค๋ก ์ธ์ฐ๊ธฐ ๋๋ฌธ์ ์์์ ์กฐํฉ์ด ๊ฐ๋๋ผ๋ ์์๊ฐ ๋ค๋ฅด๋ฉด ๋ค๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ๋ด ๋๋ค.
์๋ฅผ ๋ค์ด ์งํฉ {1, 2, 3}์ ์์๋ค์ ๋ชจ๋ ์์ด์ ๊ตฌํ๋ค๋ฉด
{1, 2, 3}
{1, 3, 2}
{2, 1, 3}
{2, 3, 1}
{3, 1, 2}
{3, 2, 1}
๋ก ์ด 6๊ฐ์ง๊ฐ ๋์ค๊ฒ ๋ฉ๋๋ค.
next_permutation
C++์ algorithm ํค๋์๋ n๊ฐ์ ์์์ ์์ด์ ๊ตฌํ ์ ์๋ next_permutation์ด๋ผ๋ ํจ์๊ฐ ์์ต๋๋ค. ๊ธฐ๋ณธ์ ๋ฌธ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1
2
3
4
5
6
7
|
// default
bool next_permutation (BidirectionalIterator first,
BidirectionalIterator last);
// custom
bool next_permutation (BidirectionalIterator first,
BidirectionalIterator last, Compare comp);
|
cs |
next_permutation์ ์์ด์ ๊ตฌํ ์ปจํ ์ด๋(์ฝ๊ฒ ๋งํด ๋ฐฐ์ด)์ ์์๊ณผ ๋ iterator๋ฅผ ์ธ์๋ก ๋ฐ์ต๋๋ค. ๋ง์ฝ ํด๋น ์ปจํ ์ด๋์ ๋ค์ ์์ด์ด ์กด์ฌํ๋ฉด ๊ทธ ์ปจํ ์ด๋์ ์์๋ฅผ ํด๋น ์์ด ์์๋ก ๋ฐ๊พธ๊ณ true๋ฅผ ๋ฐํํ๊ณ , ๋ค์ ์์ด์ด ์๋ค๋ฉด false๋ฅผ ๋ฐํํฉ๋๋ค. ์ ์ฝ๋์ custom์์ ๋ณผ ์ ์๋ฏ์ด ๋น๊ต ํจ์ comp๋ฅผ ์ธ์๋ก ๋๊ธฐ๋ ๊ฒ๋ ๊ฐ๋ฅํฉ๋๋ค.
next_permutation์ ์ฌ์ฉํ ๋๋ ๋ช ๊ฐ์ง ์ฃผ์ํ ์ ์ด ์์ต๋๋ค.
- ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋ ๊ฐ์ ๊ฐ์ง ์ปจํ ์ด๋๋ก๋ง ์ฌ์ฉ๊ฐ๋ฅํฉ๋๋ค.
- default๋ก operator < ๋ฅผ ์ฌ์ฉํด ์์ด์ ์์ฑํฉ๋๋ค. ์ฆ ์ค๋ฆ์ฐจ์์ผ๋ก ์์ด์ ์์ฑํฉ๋๋ค.
- ์ค๋ณต์ด ์๋ ์์๋ค์ ์ค๋ณต์ ์ ์ธํ๊ณ ์์ด์ ๋ง๋ค์ด์ค๋๋ค.
3๋ฒ์ ์์๋ฅผ ๋ค์๋ฉด {0, 0, 1}๊ณผ ๊ฐ์ ๋ฐฐ์ด์ ์์ด์ ๊ตฌํ๋ค๋ฉด ์ค๋ณต์ ์ ์ธํ
{0, 0, 1}, {0, 1, 0}, {1, 0, 0}์ด ๋ฉ๋๋ค. ์ด๋ฅผ ์ด์ฉํด ์กฐํฉ(Combination)์ ๊ตฌํ ์ ์์ต๋๋ค.
next_permutation ์ฌ์ฉ์์ - {1, 2, 3}์ ๋ชจ๋ ์์ด ์ถ๋ ฅํ๊ธฐ
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> v{ 1, 2, 3};
sort(v.begin(), v.end());
do {
for (auto it = v.begin(); it != v.end(); ++it)
cout << *it << ' ';
cout << endl;
} while (next_permutation(v.begin(), v.end()));
}
|
cs |
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
|
cs |
์์ด์ ์ด์ฉํ ์กฐํฉ(Combination) ๊ตฌํ๊ธฐ
์กฐํฉ(Combination)์ด๋ n๊ฐ์ ์์ ์ค์์ r๊ฐ๋ฅผ ๋ฝ๋ ๊ฒฝ์ฐ์ ์๋ฅผ ๋งํฉ๋๋ค. ์์ด์ ์์๊ฐ ์ค์ํ์ง๋ง, ์กฐํฉ์ ์์ r๊ฐ๋ฅผ ๋ฝ๊ธฐ๋ง ํ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ์์๋ ์ค์ํ์ง ์์ต๋๋ค.
์กฐํฉ(Combination) ๊ตฌํ๊ธฐ
๋ฐฐ์ด s์ n๊ฐ์ ์์ ์ค์์ r๊ฐ์ ์์๋ฅผ ํํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์ฐ์ ํฌ๊ธฐ๊ฐ n์ธ ๋ฐฐ์ด temp๋ฅผ ๋ง๋ค์ด r๊ฐ์ ์์๋ 1๋ก, (n-r)๊ฐ์ ์์๋ 0์ผ๋ก ์ด๊ธฐํํฉ๋๋ค.
- temp์ ๋ชจ๋ ์์ด์ ๊ตฌํฉ๋๋ค.
- temp์ ์์ด์์ ์์๊ฐ์ด 1์ธ ์ธ๋ฑ์ค๋ง ๋ฐฐ์ด s์์ ๊ฐ์ ธ์ต๋๋ค.
temp์์ 1์ด ์๋ ์๋ฆฌ์ ์์๋ ํฌํจํ๊ณ 0์ด ์๋ ์๋ฆฌ์ ์์๋ ๋ฏธํฌํจํ๋ค๊ณ ์๊ฐํ๋ฉด ์ฝ์ต๋๋ค. ์ด๋ next_permutaion์ ์ฌ์ฉํ๋ฉด ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌ๋๊ธฐ ๋๋ฌธ์, ์กฐํฉ์ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ถ๋ ฅ๋ฉ๋๋ค. ํ์ง๋ง prev_permutation์ ์ฐ๋ฉด ๋ชจ๋ ์กฐํฉ์ ๊ฒฝ์ฐ์ ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ถ๋ ฅ ๊ฐ๋ฅํฉ๋๋ค.
โป prev_permutation์ ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๋ฐ์์ ์ด์ ์์ด๋ก ๋ฐ๊ฟ์ค๋๋ค.
์ฌ์ฉ ์์ - {1, 2, 3, 4} ์ค 2๊ฐ์ ์์๋ฅผ ๊ณ ๋ฅด๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์ ์ถ๋ ฅํ๊ธฐ
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> s{ 1, 2, 3, 4 };
vector<int> temp{ 1, 1, 0, 0 };
do {
for (int i = 0; i < s.size(); ++i) {
if (temp[i] == 1)
cout << s[i] << ' ';
}
cout << endl;
} while (prev_permutation(temp.begin(), temp.end()));
}
|
cs |
1 2
1 3
1 4
2 3
2 4
3 4
|
cs |
์ฐธ๊ณ ์ฌ์ดํธ : http://www.cplusplus.com/reference/algorithm/
https://twpower.github.io/90-combination-by-using-next_permutation
๊ณต๋ถํ ๊ฒ์ ์ ๋ฆฌํ ๋ด์ฉ์ ๋๋ค. ์์ ํ ๋ถ๋ถ์ด ์๋ค๋ฉด ์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค :)
'Language > C++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
C++ STL ๋ฒกํฐ(vector) ์ค๋ช ๋ฐ ์ฌ์ฉ๋ฒ (0) | 2020.06.02 |
---|