数的分解（素数幂的乘积）。不用STL的map。算法入门经典183页例题10-4。

最新推荐文章于 2022-09-12 11:30:02 发布

ertcmmy

最新推荐文章于 2022-09-12 11:30:02 发布

阅读量448

点赞数

分类专栏：算法实例

本文链接：https://blog.csdn.net/ertcmmy/article/details/94775607

版权

算法实例专栏收录该内容

2 篇文章 0 订阅

订阅专栏

#include <iostream>
#include <cmath>
#include <cstring>
#include <map>
#include <utility>
#include <ctime>

using namespace std;

struct DisaNode{
	DisaNode(int prime, int power){
		this->prime = prime;
		this->power = power;
		this->next = NULL;
	}
	int prime;
	int power;
	DisaNode *next;
};

struct Disa{
	Disa(){
		head = NULL;
	}
	DisaNode *head;
};

void insert(Disa *disa, int prime, int power){
	DisaNode *dn = new DisaNode(prime, power);

	DisaNode *p = disa->head;
	if(!p){
		disa->head = dn;
	}else{
		while(p->next != NULL){
			p = p->next;
		}
		p->next = dn;
	}
}

DisaNode *find(Disa *disa, int prime){
	DisaNode *p = disa->head;
	while(p != NULL && p->prime != prime){
		p = p->next;
	}
	
	return p;
}

int n, m; // 数的数量，除数

 获取n的分解
//Disa *getDisa(int n){
//	Disa *disa = new Disa;
//	for(int k = 2; k <= n; k++){
//		while(n % k == 0){
//			DisaNode *dn = find(disa, k);
//			if(dn != NULL){
//				dn->power++;
//			}else{
//				insert(disa, k, 1);
//			}
//			n /= k;
//		}
//		if(n == 1){
//			break;
//		}
//	}
//	return disa;
//}

// 获取n的分解，效率大大提升
Disa *getDisa(int n){
	Disa *disa = new Disa;
	int m = sqrt(n + 0.5);
	for(int k = 2; k <= m; k++){ // 计算到根n就行
		int power = 0;
		while(n % k == 0){
			power++;
			n /= k;
		}
		if(power != 0){
			DisaNode *dn = find(disa, k);
			if(dn != NULL){
				dn->power += power;
			}else{
				insert(disa, k, power);
			}
		}
		if(n == 1){ // 分解完毕
			break;
		}
	}
	if(n != 1){ // n是素数
		insert(disa, n, 1);
	}
	return disa;
}

// 合并两个数的分解（相乘）
void getMerge(Disa *d1, Disa *d2){
	DisaNode *p = d2->head;
	while(p != NULL){
		int prime = p->prime, power = p->power; // 素数和幂
		DisaNode *q = find(d1, prime);
		if(q != NULL){
			q->power += power;
		}else{
			insert(d1, prime, power);
		}

		p = p->next;
	}
}

// 数d1减去数d2的分解（相除），在本题中调用此函数的两个数，一定可以减去
void getCut(Disa *d1, Disa *d2){
	DisaNode *p = d2->head;
	while(p != NULL){
		int prime = p->prime, power = p->power; // 素数和幂
		DisaNode *q = find(d1, prime);
		q->power -= power;

		p = p->next;
	}
}

// 判断c能不能整除m
bool judge(Disa *c, Disa *m){
	DisaNode *p = m->head;
	while(p != NULL){
		int prime = p->prime, power = p->power; // 素数和幂
		DisaNode *q = find(c, prime);
		if(!q || power > q->power){
			return false;
		}
		p = p->next;
	}
	return true;
}

int main(){
	freopen("in.txt", "r", stdin);

	cin >> n >> m;

	// m的素数分解
	Disa *disa_m = getDisa(m);

	// 系数公式C的素数分解，开始为C1，因为C0不行
	Disa *disa_c = getDisa(n - 1);
	// 判断C1可不可行
	if(judge(disa_c, disa_m)){
		cout << 1 << " ";
	}

	// 计算Ck，之后判断Ck可不可行，注意C下标为n - 1
	for(int k = 2; k < n - 1; k++){
		// 根据递推公式计算Ci
		// step1: 计算n - k + 1的分解
		Disa *disa_t1 = getDisa(n - 1 - k + 1);
		// step2: 计算k的分解
		Disa *disa_t2 = getDisa(k);
		// step3: 计算Ci
		getMerge(disa_c, disa_t1);
		getCut(disa_c, disa_t2);

		// 判断Ci可行与否
		if(judge(disa_c, disa_m)){
			//cout << k << " ";
		}
	}

	// n：51158，m：515484151
	// 测试运行时间，判断效率（已注释以上输出语句，时间3s）
	cout << endl << (double)clock() / CLOCKS_PER_SEC << endl;

	return 0;
}