Language/C++

[C++ / Algorithm] ์ˆœ์—ด(next_permutation) ์‚ฌ์šฉ ๋ฐฉ๋ฒ•๊ณผ ์กฐํ•ฉ(Combination) ๊ตฌํ•˜๊ธฐ

meeeeejin 2020. 6. 26. 02:07

 

์ˆœ์—ด์„ ๊ตฌํ•˜๋Š” 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์„ ์‚ฌ์šฉํ•  ๋•Œ๋Š” ๋ช‡ ๊ฐ€์ง€ ์ฃผ์˜ํ•  ์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค. 

  1. ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌ๋œ ๊ฐ’์„ ๊ฐ€์ง„ ์ปจํ…Œ์ด๋„ˆ๋กœ๋งŒ ์‚ฌ์šฉ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.
  2. default๋กœ operator < ๋ฅผ ์‚ฌ์šฉํ•ด ์ˆœ์—ด์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. ์ฆ‰ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ˆœ์—ด์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค. 
  3. ์ค‘๋ณต์ด ์žˆ๋Š” ์›์†Œ๋“ค์€ ์ค‘๋ณต์„ ์ œ์™ธํ•˜๊ณ  ์ˆœ์—ด์„ ๋งŒ๋“ค์–ด์ค๋‹ˆ๋‹ค. 

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{ 123};
 
    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๊ฐœ์˜ ์›์†Œ๋ฅผ ํƒํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค. 

 

  1. ์šฐ์„  ํฌ๊ธฐ๊ฐ€ n์ธ ๋ฐฐ์—ด temp๋ฅผ ๋งŒ๋“ค์–ด r๊ฐœ์˜ ์›์†Œ๋Š” 1๋กœ, (n-r)๊ฐœ์˜ ์›์†Œ๋Š” 0์œผ๋กœ ์ดˆ๊ธฐํ™”ํ•ฉ๋‹ˆ๋‹ค. 
  2. temp์˜ ๋ชจ๋“  ์ˆœ์—ด์„ ๊ตฌํ•ฉ๋‹ˆ๋‹ค. 
  3. 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{ 1234 };
    vector<int> temp{ 1100 };
 
    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

 

 

 

๊ณต๋ถ€ํ•œ ๊ฒƒ์„ ์ •๋ฆฌํ•œ ๋‚ด์šฉ์ž…๋‹ˆ๋‹ค. ์ˆ˜์ •ํ•  ๋ถ€๋ถ„์ด ์žˆ๋‹ค๋ฉด ์•Œ๋ ค์ฃผ์‹œ๋ฉด ๊ฐ์‚ฌํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค :)

 

 

728x90

'Language > C++' ์นดํ…Œ๊ณ ๋ฆฌ์˜ ๋‹ค๋ฅธ ๊ธ€

C++ STL ๋ฒกํ„ฐ(vector) ์„ค๋ช… ๋ฐ ์‚ฌ์šฉ๋ฒ•  (0) 2020.06.02