【算法】阶乘相关

https://mp.weixin.qq.com/s/qtdSnjSBZdP64YhpQIy0HA

1、输入一个非负整数n，请你计算阶乘n!的结果末尾有几个 0。

比如说输入n = 5，算法返回 1，因为5! = 120，末尾有一个 0。

函数签名如下：

int trailingZeroes(int n);

首先，两个数相乘结果末尾有 0，一定是因为两个数中有因子 2 和 5，因为 10 = 2 x 5。

也就是说，问题转化为：n!最多可以分解出多少个因子 2 和 5？

比如说n = 25，那么25!最多可以分解出几个 2 和 5 相乘？这个主要取决于能分解出几个因子 5，因为每个偶数都能分解出因子 2，因子 2 肯定比因子 5 多得多。

25!中 5 可以提供一个，10 可以提供一个，15 可以提供一个，20 可以提供一个，25 可以提供两个，总共有 6 个因子 5，所以25!的结果末尾就有 6 个 0。

现在，问题转化为：n!最多可以分解出多少个因子 5？

这样，我们假设n = 125，来算一算125!的结果末尾有几个 0：

首先，125 / 5 = 25，这一步就是计算有多少个像 5，15，20，25 这些 5 的倍数，它们一定可以提供一个因子 5。

然后，像 25，50，75 这些 25 的倍数，可以提供两个因子 5，那么我们再计算出125!中有 125 / 25 = 5 个 25 的倍数，它们每人可以额外再提供一个因子 5。

最后，像 125，250 这些 125 的倍数，可以提供 3 个因子 5，那么我们还得再计算出125!中有 125 / 125 = 1 个 125 的倍数，它还可以额外再提供一个因子 5。

如此这般，

125!最多可以分解出 20 + 5 + 1 = 26 个因子 5，也就是说阶乘结果的末尾有 26 个 0。

理解了这个思路，就可以理解解法代码了：

int trailingZeroes(int n) {
    int res = 0;
    long divisor = 5;
    while (divisor <= n) {
        res += n / divisor;
        divisor *= 5;
    }
    return res;
}

这里divisor变量使用 long 型，因为假如n比较大，考虑 while 循环的结束条件，divisor可能出现整型溢出。

或者

int trailingZeroes(int n) {
    int res = 0;
    for (int d = n; d / 5 > 0; d = d / 5) {
        res += d / 5;
    }
    return res;
}

 

 

2、输入一个非负整数K，请你计算有多少个n，满足n!的结果末尾恰好有K个 0。

比如说输入K = 1，算法返回 5，因为5!,6!,7!,8!,9!这 5 个阶乘的结果最后只有一个 0，即有 5 个n满足条件。

函数签名如下：

int preimageSizeFZF(int K);

因为随着n的增加，n!肯定是递增的，trailingZeroes(n!)肯定也是递增的

对于这种具有单调性的函数，用 for 循环遍历，可以用二分查找进行降维打击

搜索有多少个n满足trailingZeroes(n) == K，其实就是在问，满足条件的n最小是多少，最大是多少，最大值和最小值一减，就可以算出来有多少个n满足条件了。

那不就是二分查找「搜索左侧边界」和「搜索右侧边界」这两个事儿嘛？

 

注意为了避免整型溢出的问题，trailingZeroes函数需要把所有数据类型改成 long

#include<iostream>
using namespace std;


long trailingZeroes(long n) {
	long res = 0;
	for (long d = n; d / 5 > 0; d = d / 5) {
		res += d / 5;
	}
	return res;
}
int left_bound(int target) {
	long l = 0;
	long r = LONG_MAX;
	while (l < r) {
		long mid = (l + r) / 2;
		if (trailingZeroes(mid) < target) {
			l = mid + 1;
		}
		else if (trailingZeroes(mid) > target) {
			r = mid;
		}
		else {
			r = mid;
		}
	}
	return l;
}

int right_bound(int target) {
	long l = 0;
	long r = LONG_MAX;
	while (l < r) {
		long mid = (l + r) / 2;
		if (trailingZeroes(mid) < target) {
			l = mid + 1;
		}
		else if (trailingZeroes(mid) > target) {
			r = mid;
		}
		else {
			l= mid+1;
		}
	}
	return l - 1;
}

int problem(int K) {
	return right_bound(K) - left_bound(K) + 1;
}

int main() {

	int K;
	while (cin >> K) {
		cout << problem(K) << endl;
	}
	return 0;
}