c++ 正整数拆分成素因子的乘积

#include<string>
//设计算法，将某个大于1的数分成素因子的乘积 6=2*3  7=7 8=2*2*2
//1.判断当前数是不是素数，是直接返回
//2.否则，循环直到第一个它能整除的素数，当前数变为除以素数后的商，继续大循环。
//判断一个数是不是素数
#include <math.h>
bool isPrime(int x){
	if (x <= 1)
		return false;
	if (x == 2)
		return true;
	if (x % 2 == 0)
		return false;
	int tmax = (int)sqrt(x) + 1; //sqrt（9）返回的是浮点数，有可能是2.9999或3.00001等，确保正确性，多比较一次
	int i = 3;
	while (i < tmax){
		if (x%i == 0)
			return false;
		i+=2;
	}
	return true;
}

string primeMulti(int x){
	string s = "";
	s+= to_string(x)+"=";
	while (x != 1){
		if (isPrime(x)){
			s =s+ to_string(x);
			return s;
		}
		if (x % 2 == 0){
			s += "2*";
			x /= 2;
		}
		for (int i = 3; i <= x; i += 2){
			if (isPrime(i) && x%i == 0){
				s += to_string(i) + "*";
				x /= i;
				break;
			}
		}
	}
	if (x == 1)  //若最终x为1，需去掉尾上多余的乘号
		s = s.substr(0,s.size()-1);
	return s;
}

改进：先把小于该数的素数求出来，保存在vector中，可以减少素数的重复判断

#include <iostream>
#include <string>
#include <vector>
#include <math.h>

using namespace std;
bool isPrime(long n){
	if (n <= 1)
		return false;
	else if (n == 2)
		return true;
	else if (n % 2 == 0)
		return false;
	else{
		int maxsqr = (long)sqrt(n) + 1;
		for (long i = 3; i<maxsqr; i = i + 2){
			if (n%i == 0)
				return false;
		}
	}
	return true;
}
void prime(long n, vector<long>& vec){
	if (n <= 1)
		return;
	for (long i = 2; i <= n; ++i){
		if (isPrime(i))
			vec.push_back(i);
	}
	return;
}

int main(){
	vector<long> v = {};
	long n;
	cin >> n;
	prime(n, v);
	while (n != 1){
		long i = 0;
		while (v[i] <= n){
			if (n%v[i] == 0){
				cout << v[i] << " ";
				n = n / v[i];
				break;
			}
			++i;
		}
	}
    cout << endl;
	return 0;
}

发现一个更简单的，不用判断是不是素数，直接除以比n小的数即可。

void primeFactor(long n){
    if(n<=1)
        return;
    while(n!=1){
        for(int i=2;i<=n;++i){
            if(n%i==0){
                cout << i << " ";
                n=n/i;
                break;
            }
        }
    }
}

加一个其它习题：

//设计算法，求二项式c(n,k)的系数
//c(n,k)=c(n,k-1)+c(n-1,k-1)
int er(int n,int k){
	if (k == 0 || k==n)
		return 1;
	if (k > n / 2)
		k = n - k;
	return er(n- 1, k) + er(n - 1, k - 1);
}

再加一个汉诺塔问题，都是用递归实现的。递归可以让代码更简洁，甚至解决一些循环不能解决或解决起来超级复杂的问题

void move(int n,char from, char to){
	cout <<n<<":"<< from << "->" << to << endl;
}
//实现汉诺塔盘子移动
//关键点：只有一个盘子，直接把它从from移动到to，否则，先移动n-1个盘子，以to为临时柱子
//移动到tmp；再移动第n个盘子到to；最后将那n-1个盘子从tmp以from为临时柱子移动到to
void hanuota(int n, char from, char tmp, char to){
	if (n == 1)
		move(n,from, to);
	else{
		hanuota(n - 1, from, to, tmp);
		move(n,from, to);
		hanuota(n - 1, tmp, from, to);
	}
}

运行hanuota(3,'A','B','C');得到的输出：