问题描述:求全由小写字母组成的不超过200个字符序列的全排列
如输入序列bbjd,排列结果为:
bbdj
bbjd
bdbj
bdjb
bjbd
bjdb
dbbj
dbjb
djbb
jbbd
jbdb
jdbb
 
方法一:递归法
 
代码如下:
 
#include <stdio.h>

int t[];
char s[];
int n = ; void permutation(int i)
{
int k; // a~z的ASCII码在97到122之间
for(k = ; k < ; k++)
{
if(t[k])
{
t[s[i] = k]--;
permutation(i + );
t[k]++;
}
} // 只有n个字母全部排好了才输出
n - i || puts(s);
} int main()
{
int i; puts("Please Input letter sequence: ");
gets(s); // t[]记录每个字母的出现频率
// n为待排序列的长度
for(i = ; s[i] != '\0'; i++)
{
t[s[i]]++;
n++;
} puts("Permutation result: ");
permutation(); return ;
}

运行结果如下:

aaarticlea/png;base64,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" alt="" />

方法二:STL法

C++的STL有一个函数可以方便地生成全排列,这就是next_permutation

在C++ Reference中查看了一下next_permutation的函数声明:

#include <algorithm>
bool next_permutation( iterator start, iterator end );

The next_permutation()
function attempts to transform the given range of elements [start,end)
into the next lexicographically greater permutation of elements. If it
succeeds, it returns true, otherwise, it returns false.

从说明中可以看到 next_permutation 的返回值是布尔类型。按照提示写了一个标准C++程序:

其中用到了 sort 函数,如果不先排序,则完成不了全排列。

#include <iostream>
#include <string>
#include <algorithm> using namespace std; int main()
{
string str; cout << "Please Input letter sequence: \n";
cin >> str; // 必须先排序
sort(str.begin(), str.end());
cout << str << endl; cout << "Permutation result: \n"; while(next_permutation(str.begin(), str.end()))
{
cout << str << endl;
} return ;
}

运行结果如下:

aaarticlea/png;base64,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" alt="" />

在使用稍大数据测试的时候,发现标准C++的效率很差,换成C函数写一下,效率提升了许多倍,比如我用字符序列“aabbddef”作为测试,上面C++代码用了6s,而下面的C代码只用了0.918s。所以,平时写代码时能用C就用C。

#include <stdio.h>
#include <algorithm> using namespace std; int main()
{
char str[];
int len; puts("Please Input letter sequence: ");
gets(str); len = strlen(str); // 必须先排序
sort(str, str + len); puts("Permutation result: ");
puts(str); while(next_permutation(str, str + len))
{
puts(str);
} return ;
}

简单的字母全排列问题—递归法和STL法的更多相关文章

  1. codevs http://www.codevs.cn/problem/?problemset_id=1 循环、递归、stl复习题

    12.10高一练习题 1.要求: 这周回顾复习的内容是循环.递归.stl. 不要因为题目简单就放弃不做,现在就是练习基础. 2.练习题: (1)循环   题目解析与代码见随笔分类  NOI题库 htt ...

  2. n个整数全排列的递归实现(C++)

    全排列是很经常使用的一个小算法,以下是n个整数全排列的递归实现,使用的是C++ #include <iostream> using namespace std; int n = 0; vo ...

  3. 集成学习的不二法门bagging、boosting和三大法宝<结合策略>平均法,投票法和学习法(stacking)

    单个学习器要么容易欠拟合要么容易过拟合,为了获得泛化性能优良的学习器,可以训练多个个体学习器,通过一定的结合策略,最终形成一个强学习器.这种集成多个个体学习器的方法称为集成学习(ensemble le ...

  4. dp的刷表法和填表法

    dp的刷表法和填表法 参考: 动态规划刷表法 - acmer_xue的博客 - CSDN博客http://blog.csdn.net/qq_30241305/article/details/52198 ...

  5. TINY语言采用递归下降分析法编写语法分析程序

    目录 自顶向下分析方法 TINY文法 消左提左.构造first follow 基本思想 python构造源码 运行结果 参考来源:聊聊编译原理(二) - 语法分析 自顶向下分析方法 自顶向下分析方法: ...

  6. 全排列问题(递归&非递归&STL函数)

    问题描述: 打印输出1-9的所有全排序列,或者打印输出a-d的全排列. 思路分析: 将每个元素放到余下n-1个元素组成的队列最前方,然后对剩余元素进行全排列,依次递归下去. 比如:1 2 3 为例首先 ...

  7. 生成n个数的全排列【递归、回溯】

    下面讨论的是n个互不相同的数形成的不同排列的个数.毕竟,假如n个数当中有相同的数,那n!种排列当中肯定会有一些排列是重复的,这样就是一个不一样的问题了. /*===================== ...

  8. 全排列算法--递归实现(Java)

    求一个n阶行列式,一个比较简单的方法就是使用全排列的方法,那么简述以下全排列算法的递归实现. 首先举一个简单的例子说明算法的原理,既然是递归,首先说明一下出口条件.以[1, 2]为例 首先展示一下主要 ...

  9. iOS简单排序--字母排序、NSDictionary排序

    // 数组用系统方法compare做字母的简单排序 NSArray *oldArray = @[@"bac",@"bzd",@"azc",@ ...

随机推荐

  1. 20145232 韩文浩 《Java程序设计》第4周学习总结

    教材学习内容总结 · Chapter 继承与多态 继承:避免多个类间重复定义共同行为.继承可以理解为一个对象从另一个对象获取属性的过程. 所有Java的类均是由java.lang.Object类继承而 ...

  2. 从npm到vue和nodejs

    https://www.npmjs.com.cn/ vue和nodejs Windows 下安装NPM:https://www.cnblogs.com/interdrp/p/6779973.html ...

  3. inline-block 引发的间隙原因与解决方法

    这是一个常见的问题,但是一些新人没遇到过可能不会发现,现在我对这种现在进行了分析与总结 设置一些元素为块级元素时一般这么写 li{display:inline-block; *display:inli ...

  4. Qt_模块简介

    Qt4 和 Qt5最大的区别之一就是底层架构有了修改.Qt5引入了模块化的概念,讲众多功能细分到几个模块之中.需要达到,用什么模块知道到哪个模块去寻找. Qt5模块分为Essentials Modul ...

  5. (记忆化搜索) FatMouse and Cheese(hdu 1078)

    题目大意:   给n*n地图,老鼠初始位置在(0,0),它每次行走要么横着走要么竖着走,每次最多可以走出k个单位长度,且落脚点的权值必须比上一个落脚点的权值大,求最终可以获得的最大权值   (题目很容 ...

  6. HDU2444 The Accomodation of Students

    The Accomodation of Students Time Limit: 5000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K ( ...

  7. hdu 2642 Stars 【二维树状数组】

    题目 题目大意:Yifenfei是一个浪漫的人,他喜欢数天上的星星.为了使问题变得更容易,我们假设天空是一个二维平面,上面的星星有时会亮,有时会发暗.最开始,没有明亮的星星在天空中,然后将给出一些信息 ...

  8. [转载]DevOps建立全生命周期管理

    全生命周期管理(ALM)领域作为企业DevOps实践的总体支撑,应该说是DevOps领域中最为重要的实践领域,也是所有其他实践的基础设施.现在很多企业都非常重视CI/CD自动化工具的引入和推广,但是对 ...

  9. Django:model中的ForeignKey理解

    有两个数据模型栏目模型和文章模型ArticleColumn和ArticlePost ArticleColumn: class ArticleColumn(models.Model): # 用户与栏目是 ...

  10. 记录一次BUG修复-Entity Framwork SaveChanges()失效

    目录 一. 前言 二.问题背景 三.问题描述 四.问题解决步骤 六.总结 一. 前言 这是笔者在参与一个小型项目开发时所遇到的一个BUG,因为项目经验不足对Entity Framwork框架认识不足导 ...