蓝桥杯

最新推荐文章于 2022-05-10 18:36:26 发布

Cyclo-

最新推荐文章于 2022-05-10 18:36:26 发布

阅读量266

点赞数

本文链接：https://blog.csdn.net/weixin_46709007/article/details/114603406

版权

20210301代码学习

全排列 next_permutation() 函数

#include<iostream>
#include<algorithm> //sort和全排序 函数的头文件 
using namespace std;
int main()
{
	int a[]={1,0,2};
	sort(a,a+3);
//全排序前，需要数据有序 
do{
	for(int i=0;i<3;i++)
	printf("%d ",a[i]);
	printf("\n"); 
} while(next_permutation(a,a+3));
return 0;
}

输出为

sort()

一.sort函数

1.sort函数包含在头文件为#include的c++标准库中，调用标准库里的排序方法可以实现对数据的排序，但是sort函数是如何实现的，我们不用考虑！

2.sort函数的模板有三个参数：

void sort (RandomAccessIterator first, RandomAccessIterator last, Compare comp);
（1）第一个参数first：是要排序的数组的起始地址。

（2）第二个参数last：是结束的地址（最后一个数据的后一个数据的地址）

（3）第三个参数comp是排序的方法：可以是从升序也可是降序。如果第三个参数不写，则默认的排序方法是从小到大排序。

int a[]={45,12,34,77,90,11,2,4,5,55};
sort(a,a+10);   //从小到大排序

#include<iostream>
#include<algorithm>
using namespace std;
bool cmp(int a,int b);
main(){
　　//sort函数第三个参数自己定义，实现从大到小
　　int a[]={45,12,34,77,90,11,2,4,5,55};
　　sort(a,a+10,cmp);
　　for(int i=0;i<10;i++)
　　　　cout<<a[i]<<" ";
}
//自定义函数
bool cmp(int a,int b){
　　return a>b;
}

公约数公倍数

void myfunc(int a,int b)
{
	int m,n,tr;
	if(a<b) swap(&a,&b);//把大的放前面
	m=a;n=b;
	tr=a%b; //   除数/余数 
	while(tr!=0)
	{
		a=b;//除数 
		b=tr;   //余数 
		tr=a%b;
	}
	printf("%d\n",b); //最大公约数 
	printf("%d\n",m*n/b);//最小公倍数 x*y/gcd（x，y）

字符串减去’0’

    字符‘0’在ASCII中对应的值是48，
所以如果字符‘1’减去‘0’的话得出的值就是数字类型的1
，其他的可以用来转换大写或者数字和和字符。

include <sstream> 
//int 类型转换为 string 类型的过程
stringstream ss;
string str;
int n = 1000;

ss << n;        // 将int类型的值放入输入流中
ss >> str;      // 从sstream中抽取前面插入的int类型的值，赋给string类型

cout << "[cout]str is: " << str << endl;
printf("[printf]str is: %s\n", str.c_str());

2.2 多个字符串拼接

stringstream sstream;

// 将多个字符串放入 sstream 中
sstream << "first" << " " << "string,";
sstream << " second string";
cout << "strResult is: " << sstream.str() << endl;

// 清空 sstream
sstream.str("");
sstream << "third string";
cout << "After clear, strResult is: " << sstream.str() << endl;

return 0;

memset置零

如果要把一个char a[20]清零, 一定是 memset(a, 0, 20)

#include<string.h>
memset(a, 0, sizeof(a));

快速幂

3^10=3*3*3*3*3*3*3*3*3*3

//尽量想办法把指数变小来，这里的指数为10

3^10=(3*3)*(3*3)*(3*3)*(3*3)*(3*3)

3^10=(3*3)^5

3^10=9^5

//此时指数由10缩减一半变成了5，而底数变成了原来的平方，求3^10原本需要执行10次循环操作，求9^5却只需要执行5次循环操作，但是3^10却等于9^5,我们用一次（底数做平方操作）的操作减少了原本一半的循环量，特别是在幂特别大的时候效果非常好，例如2^10000=4^5000,底数只是做了一个小小的平方操作，而指数就从10000变成了5000，减少了5000次的循环操作。

//现在我们的问题是如何把指数5变成原来的一半，5是一个奇数，5的一半是2.5，但是我们知道，指数不能为小数，因此我们不能这么简单粗暴的直接执行5/2，然而，这里还有另一种方法能表示9^5

9^5=（9^4）*（9^1）

//此时我们抽出了一个底数的一次方，这里即为9^1，这个9^1我们先单独移出来,剩下的9^4又能够在执行“缩指数”操作了，把指数缩小一半，底数执行平方操作

9^5=（81^2）*(9^1)

//把指数缩小一半，底数执行平方操作

9^5=（6561^1）*(9^1)

//此时，我们发现指数又变成了一个奇数1，按照上面对指数为奇数的操作方法，应该抽出了一个底数的一次方，这里即为6561^1，这个6561^1我们先单独移出来，但是此时指数却变成了0，也就意味着我们无法再进行“缩指数”操作了。

9^5=（6561^0）*(9^1)*(6561^1)=1*(9^1)*(6561^1)=(9^1)*(6561^1)=9*6561=59049

我们能够发现，最后的结果是9*6561，而9是怎么产生的？是不是当指数为奇数5时，此时底数为9。那6561又是怎么产生的呢？是不是当指数为奇数1时，此时的底数为6561。所以我们能发现一个规律：最后求出的幂结果实际上就是在变化过程中所有当指数为奇数时底数的乘积。

算法1

long long fastPower(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 0) {
//如果指数为偶数
power = power / 2;//把指数缩小为一半
base = base * base % 1000;//底数变大成原来的平方
} else {
//如果指数为奇数
power = power - 1;//把指数减去1，使其变成一个偶数
result = result * base % 1000;//此时记得要把指数为奇数时分离出来的底数的一次方收集好
power = power / 2;//此时指数为偶数，可以继续执行操作
base = base * base % 1000;
}
}
return result;
}

简化

虽然上面的快速幂算法效率已经很高了，但是我们仍然能够再一次的对其进行“压榨级别”的优化。我们上面的代码看起来仍然有些地方可以再进一步地进行简化，例如在if和else代码块中仍然有重复性的代码：

        power = power / 2;
        base = base * base % 1000;

而

        power = power - 1;//把指数减去1，使其变成一个偶数
        power = power / 2;

可以压缩成一句：
power = power / 2;
因为power是一个整数，例如当power是奇数5时,power-1=4,power/2=2；而如果我们直接用power/2=5/2=2。在整型运算中得到的结果是一样的，因此，我们的代码可以压缩成下面这样：

long long fastPower(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power % 2 == 1) {
result = result * base % 1000;
}
power = power / 2;
base = (base * base) % 1000;
}
return result;
}

终极优化

在C语言中，power%2==1可以用更快的“位运算”来代替，例如：power&1。因为如果power为偶数，则其二进制表示的最后一位一定是0；如果power是奇数，则其二进制表示的最后一位一定是1。将他们分别与1的二进制做“与”运算，得到的就是power二进制最后一位的数字了，是0则为偶数，是1则为奇数。例如5是奇数，则5&1=1；而6是偶数，则6&1=0；因此奇偶数的判断就可以用“位运算”来替换了。

同样，对于power=power/2来说，也可以用更快的“位运算”进行替代，我们只要把power的二进制表示向右移动1位就能变成原来的一半了。

优化后的代码
long long fastPower(long long base, long long power) {
long long result = 1;
while (power > 0) {
if (power & 1) {//此处等价于if(power%2==1)
result = result * base % 1000;
}
power >>= 1;//此处等价于power=power/2
base = (base * base) % 1000;
}
return result;
}

参考资料

部分内容转载自作者：刘扬俊文章：快速幂算法（全网最详细地带你从零开始一步一步优化）

Cyclo-

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
蓝桥杯

20210301代码学习全排列 next_permutation() 函数#include<iostream>#include<algorithm> //sort和全排序函数的头文件 using namespace std;int main(){ int a[]={1,0,2}; sort(a,a+3);//全排序前，需要数据有序 do{ for(int i=0;i<3;i++) printf("%d ",a[i]); printf("\n");
复制链接

扫一扫