蓝桥杯 试题 算法训练 数的潜能 C++ 详解

题目：

问题描述：

　　将一个数N分为多个正整数之和，即N=a1+a2+a3+…+ak，定义M=a1*a2*a3*…*ak为N的潜能。
　　给定N，求它的潜能M。
　　由于M可能过大，只需求M对5218取模的余数。

输入格式：

　　输入共一行，为一个正整数N。

输出格式：

　　输出共一行，为N的潜能M对5218取模的余数。

样例输入：

10

样例输出：

36

数据规模和约定：

　　1<=N<10^18

---

前言：

参考文章：蓝桥杯 ALGO-999 数的潜能_Xuuuuuuuuuuuuuuuuuuu的博客-CSDN博客

思路是一样的，这篇文章我着重一下 对过程的解释。

---

开始：

看到题目，直接举几个例子以找规律。

N = 1 , M = 1；        N = 2 , M = 2；        N = 3 , M = 3；        N = 4 , M = 4；

         

其规律在于：将N拆分为 3 和 2 。（只保留 3 和 2 这两个数字，相乘得到的潜能数最大）

 共有三种情况：(余数和2 相关，商和3 相关)

N = 6 , 分为 3+3        【6%3=0，6/3=2】两个3

N = 7 , 分为 3+2+2        【7%3=1，7/3=2】若余数为1，则商-1，即减去一个3，与1凑成4，2+2

N = 8 , 分为 3+3+2        【8%3=2，8/3=2】若余数为2，直接+2

(再之后9则分为3+3+3，就和6类似了)

---

所以：

输入N，我们直接对其取模三(%3)，(结果必为：0、1、2)再根据结果来决定3和2的数量即可。

思路有了，开始写代码。

重点在于：如何快速地进行"幂运算"? (因为2最多只有两个，所以只用对3进行幂运算)

例如求3的10000000次方，从1到10000000逐个乘肯定是不行的，得优化。

我所知的快速幂运算有两种：迭代和递归。(估计也没有其他的了)

但我习惯性用的递归，导致递归层数过多，栈溢出导致内存超限。。。

(印象深刻，我还记得上学期初学编程时课本提过：递归调用对栈内存的"劫掠"十分严重)

改用迭代的方式就没有这样的问题。

---

递归求幂的代码：（不可取）

//返回 3^x  %5218 - 递归 - 不超时，但内存超出
int func(long long int x)
{
	if (x == 0)
		return 1;
	else if (x == 1)
		return 3;
	else if (x == 2)
		return 9;
	else if (x == 3)
		return 27;
    //……

	long long int x1 = x >> 1;//除以2的意思，位运算

	int temp = func(x1);

	if (x & 1)
		temp = temp * temp * 3;
	else
		temp = temp * temp;

	temp %= 5218;

	return temp;
}

迭代求幂的代码：

//返回 3^x  %5218 - 迭代
int func02(long long int x)
{
	int y = 1;
	int sum = 3;//3为底数

	while (x)
	{
		if (x & 1)//若y是奇数
			y = y * sum % 5218;

		sum = sum * sum % 5218;
		x /= 2;
	}
	return y;
}

---

这里我讲一下快速幂运算的迭代形式。(无论递归还是)迭代 快速求幂，都是以拆分的方式是以提高效率的。

例如：3的8次方，拆分为两个3的4次方，再拆分为四个3的2次方，如此这般。

当我要求8次方时，只需求4次方，又只需求2次方……

跳跃式地求解，可以快速地求出幂来。(尤其时 次方数 特别大的时候)

10000 >> 5000 >> 2500 >> 1250 >> 625 >> 312 >> 156 >> 78 >> 39 >> 20 >> 10 >> 5 >> 2

"近似二分"来计算，只需13或14次操作即可得出结果。

没有接触过算法优化的同学可以去了解一下时间复杂度，O(N^2)和O(logN)差别巨大……

看代码：

若 x 为偶数，直接二分，增底，降幂即可。例如：3的4次方 化为 9的2次方。

若 x 为奇数，单独将 底数 乘给 结果即可。

每次 幂都会 /2，最后必得1，再将 底 乘给 结果 ，然后 幂 /2，得0，退出循环，返回结果。

---

附上代码：

#include<iostream>
using namespace std;

//返回 3^x  %5218 - 递归 - 不超时，但内存超出
int func01(long long int x)
{
	if (x == 0)
		return 1;
	else if (x == 1)
		return 3;
	else if (x == 2)
		return 9;
	else if (x == 3)
		return 27;

	long long int x1 = x >> 1;

	int temp = func01(x1);

	if (x & 1)
		temp = temp * temp * 3;
	else
		temp = temp * temp;

	temp %= 5218;

	return temp;
}

//返回 3^x  %5218 - 迭代
int func02(long long int x)
{
	int y = 1;
	int sum = 3;//3为底数

	while (x)
	{
		if (x & 1)//若y是奇数
			y = y * sum % 5218;

		sum = sum * sum % 5218;
		x /= 2;
	}
	return y;
}

int main()
{
	long long int N; cin >> N;

	long long int x = N % 3;//判断2的数量

	long long int y = N / 3;//判断3的数量

	int z;

	if (N == 1) //保险，如无此判断，N = 1 时 ，M = 12
	{
		cout << 1;
		return 0;
	}

	if (x == 0)
	{
		z = func02(y);
	}
	else if (x == 1)
	{
		z = func02(y - 1) * 4;
	}
	else // x == 2
	{
		z = func02(y) * 2;
	}

	z %= 5218;

	cout << z;

	return 0;

}

---

结束：

…………