精华内容
下载资源
问答
  • next_permutation

    2021-06-22 08:54:30
    next_permutation 参数介绍: Next_permutation(place-begin,place_end) 第一个参数是,全排列的首地址,第二个是尾地址。 返回值: 当place这个东西(数组,字符串)存在下一个更大排列的时候返回true,(按照字符...

    next_permutation
    参数介绍:
    Next_permutation(place-begin,place_end)
    第一个参数是,全排列的首地址,第二个是尾地址。
    返回值:
    当place这个东西(数组,字符串)存在下一个更大排列的时候返回true,(按照字符顺序)
    例如
    输入一个字符串,打印出该字符串中字符的所有排列。

    你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。

    例题

    输入一个字符串,打印出该字符串中字符的所有排列。

    你可以以任意顺序返回这个字符串数组,但里面不能有重复元素。

    字符串排列

    class Solution {
    public:
        vector<string> permutation(string s) {
            sort(s.begin(),s.end());
            vector<string> ans;
            do
            {
                ans.push_back(s);
            }while(next_permutation(s.begin(),s.end()));
            return ans;
        }
    };
    
    展开全文
  • 一:next_permutation(start,end,//cmp) 使用默认排序方法:按照字典序从小到大 int arr[3]={1,2,3}; do{ for(int num:arr){ cout<<num<< ; } cout<<endl; }while(next_permutation...
  • next_permutation、prev_permutation以及is_permutation使用next_permutationprev_permutationis_permutation next_permutation、prev_permutation以及is_permutation均为全排列相关的函数,调用时需要加入头文件#...

    next_permutation、prev_permutation以及is_permutation使用


    next_permutation、prev_permutation以及is_permutation均为全排列相关的函数,调用时需要加入头文件#include <algorithm>

    next_permutation

    next_permutation的函数原型:

    //default
    template <class BidirectionalIterator>
    	bool next_permutation (BidirectionalIterator first, BidirectionalIterator last);
    
    //custom 
    template <class BidirectionalIterator, class Compare>
    	bool next_permutation (BidirectionalIterator first, BidirectionalIterator last, Compare comp);
    

    next就是下一个的意思,其中文直译过来就是下一个全排列,因此在使用next_permutation函数的时候切记要对全排列的对象进行升序排列,不然结果只会出现比当前排列大的排列,依据ASCII计算。
    next_permutation(a, b)表示只对[a, b)区间的数据进行全排列,其余位置不变化

    #include <iostream>
    #include <algorithm>
    #include <vector>
    using namespace std;
    #define SORT
    
    int main()
    {
    	vector<int> V = {3, 2, 1 };
    #ifdef SORT
    	sort(V.begin(), V.end());//sort
    #endif
    	do
    	{
    		for (int i = 0; i < V.size(); i++)
    		{
    			cout << V[i] << " ";
    		}
    		cout << endl;
    	} while (next_permutation(V.begin(), V.end()));
    	return 0;
    }
    //result
    /*
    #define SORT
    1 2 3
    1 3 2
    2 1 3
    2 3 1
    3 1 2
    3 2 1
    */
    
    /*
    没有进行sort排序
    3 2 1
    */
    

    prev_permutation

    prev_permutation和next_permutation功能一样,唯一的区别是next_permutation下一个全排列,而prev_permutation是上一个全排列,所以运用prev_permutation的时候必须降序排列,不然只会出现比结果小的排列

    #include <iostream>
    #include <algorithm>
    #include <vector>
    using namespace std;
    
    //#define SORT
    #define RSORT
    
    int main()
    {
    	vector<int> V = {3, 4, 2, 1};
    #ifdef SORT
    	sort(V.begin(), V.end());
    #else
    	sort(V.rbegin(), V.rend());
    #endif
    	do
    	{
    		for (int i = 0; i < V.size(); i++)
    		{
    			cout << V[i] << " ";
    		}
    		cout << endl;
    	} while (prev_permutation(V.begin() + 1, V.end() - 1));
    	return 0;
    }
    //result
    /*
    #define RSORT
    4 3 2 1
    4 2 3 1
    */
    
    /*
    #define RSORT
    1 2 3 4
    */
    

    is_permutation

    template <class ForwardIterator1, class ForwardIterator2>
       bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2);
                            
    template <class ForwardIterator1, class ForwardIterator2, class BinaryPredicate>
       bool is_permutation (ForwardIterator1 first1, ForwardIterator1 last1,
                            ForwardIterator2 first2, BinaryPredicate pred);
    

    is_permutation用来判断两个全排列是否相等,哪怕顺序不同,只要元素一样就返回true

    #include <iostream>
    #include <algorithm>
    #include <vector>
    using namespace std;
    int main()
    {
    	vector<int> V1 = { 3, 4, 2, 1 };
    	vector<int> V2 = { 1, 3, 2, 4 };
    	vector<int> V3 = { 1, 3, 2, 4, 1};
    	vector<float> V4 = { 1.0, 3.0, 2.0, 4.0 };
    	vector<float> V5 = { 1.0000001, 3.0, 2.0, 4.0 };
    	if (is_permutation(V1.begin(), V1.end(), V2.begin()))
    	{
    		cout << "V1 and V2 is equal" << endl;
    	}
    	if (is_permutation(V1.begin(), V1.end(), V3.begin()))
    	{
    		cout << "V1 and V3 is equal" << endl;
    	}
    	if (is_permutation(V1.begin(), V1.end(), V4.begin()))
    	{
    		cout << "V1 and V4 is equal" << endl;
    	}
    	if (is_permutation(V1.begin(), V1.end(), V5.begin()))
    	{
    		cout << "V1 and V5 is equal" << endl;
    	}
    	return 0;
    }
    
    //result
    /*
    V1 and V2 is equal
    V1 and V3 is equal
    V1 and V4 is equal
    */
    

    is_permutation单纯的比较值的大小,但是需要注意的是序列1重复的必须在序列2中展现,也就是count sequence1[i] <= count sequence2[i]。

    展开全文
  • 当我们要求一个排列,从当前排列开始的所有全排列时,可以使用algorithm包的next_permutation与prev_permutation函数,具体的用法如下: ll num[n] = {...}; do { cout << num[0] << " " << num...

    当我们要求一个排列,从当前排列开始的所有全排列时,可以使用algorithm包的next_permutation与prev_permutation函数,具体的用法如下:

    ll num[n] = {...};
    do {
        cout << num[0] << " " << num[1] << " " << num[2] << ... << endl;
    }while (next_permutation(num, num + n));
    

    其中,next_permutation()函数的下标指向于sort()相同,next_permutation()表示从当前位置开始向后的全排列
    具体实例:

    ll num[3] = {2, 1, 3};
    do {
        cout << num[0] << " " << num[1] << " " << num[2] << endl;
    }while (next_permutation(num, num + 3));
    /*
    2 1 3
    2 3 1
    3 1 2
    3 2 1
    */
    

    由输出结果可以看到,枚举的是从当前排列开始的所有全排列,而如果想要枚举所有的全排列,直接对原排列排序后再permutation即可。prev_permutation()表示枚举从当前位置开始向前的所有全排列。

    展开全文
  • next_permutation指下一个排列,prev_permutation指前一个排列next_permutation在进行全排列时必须保证待排序数组升序,这样才能得到全部n!种排列方式。同理,prev_permutation在进行全排列时必须保证待排序数组降序...

    next_permutation指下一个排列,prev_permutation指前一个排列

    next_permutation在进行全排列时必须保证待排序数组升序,这样才能得到全部n!种排列方式。同理,prev_permutation在进行全排列时必须保证待排序数组降序,这样才能得到全部n!种排列方式。

    next_permutation得到的排列使得后一个排列一定大于前一个排列,如果此时的排列已是最后一个排列,则返回false

    prev_permutation得到的排列使得后一个排列一定小于前一个排列,如果此时排列已是最后一个排列,返回false

    //next_permutation,prev_permutation的运用
    #include<bits/stdc++.h>         //万能头文件,包含c++所有头文件
    using namespace std;
    int main()
    {
        char s[100];
        while(scanf("%s",s)==1)
        {
            int len=strlen(s);
            sort(s,s+len);
            do{
                printf("%s\n",s);
            }while(next_permutation(s,s+len));
            printf("\n");
            sort(s,s+len,greater<char>());
            do{
                printf("%s\n",s);
            }while(prev_permutation(s,s+len));
        }
        return 0;
    }
    

    展开全文
  • next_permutation 、prev_permutation 函数 next_permutation、prev_permutation是STL提供的计算排列组合关系的算法。 next_permutation(first,last)是将序列中[first,last)区间按照全排列的思想,根据字典序...
  • next_permutation和prev_permutation函数用法举例求排列
  • next_permutation用于生成当前序列的下一个排列组合,如果当前序列是最大值则返回false; prev_permutation用于生成当前序列的上一个排列组合,如果当前序列是最小值则返回false。 #include <algorithm> #...
  • next_permutation和prev_permutation区别 用法举例 对结构体num按照自定义的排序方式cmp进行排序 char 类型的next_permutation string 类型的next_permutation next_permutation作用 产生全排列。 f(n...
  • STL封装了特别高效的排列组合函数:next_permutation和pre_permutation,理解它们实现的思想,才能更好地运用。 1.next_permutation 实现思想:首先,从最尾端开始往前寻找两个相邻元素,令第一元素为*i,第二元素...
  • 关于next_permutation函数 next_permutation和prev_permutation函数都是C++STL中的全排列函数。 函数原型: #include < algorithm > bool next_permutation(iterator start,iterator end) bool prev_...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 30,090
精华内容 12,036
关键字:

next_permutation