Эффективно получить все делители заданного числа

Вы действительно должны проверять до получения квадратного корня из num как sqrt (num) * sqrt (num) = num:

Что-то на этих линиях:

int square_root = (int) sqrt(num) + 1;
for (int i = 1; i < square_root; i++) {
if (num % i == 0&&i*i!=num)
cout << i << num/i << endl;
if (num % i == 0&&i*i==num)
cout << i << '\n';
}

В настоящее время в науке нет эффективного способа в смысле алгоритмической сложности (алгоритма с полиномиальной сложностью). Так что итерация до получения квадратного корня, как уже было предложено, в основном настолько хороша, насколько это возможно.

Главным образом из-за этого большая часть используемой в настоящее время криптографии основана на предположении, что для вычисления простой факторизации любого заданного целого числа требуется очень много времени.

Вот мой код:

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

#define pii pair<int, int>

#define MAX 46656
#define LMT 216
#define LEN 4830
#define RNG 100032

unsigned base[MAX / 64], segment[RNG / 64], primes[LEN];

#define sq(x) ((x)*(x))
#define mset(x,v) memset(x,v,sizeof(x))
#define chkC(x,n) (x[n>>6]&(1<<((n>>1)&31)))
#define setC(x,n) (x[n>>6]|=(1<<((n>>1)&31)))

// http://zobayer.blogspot.com/2009/09/segmented-sieve.html
void sieve()
{
unsigned i, j, k;
for (i = 3; i<LMT; i += 2)
if (!chkC(base, i))
for (j = i*i, k = i << 1; j<MAX; j += k)
setC(base, j);
primes[0] = 2;
for (i = 3, j = 1; i<MAX; i += 2)
if (!chkC(base, i))
primes[j++] = i;
}//http://www.geeksforgeeks.org/print-all-prime-factors-of-a-given-number/
vector <pii> factors;
void primeFactors(int num)
{
int expo = 0;
for (int i = 0; primes[i] <= sqrt(num); i++)
{
expo = 0;
int prime = primes[i];
while (num % prime == 0){
expo++;
num = num / prime;
}
if (expo>0)
factors.push_back(make_pair(prime, expo));
}

if ( num >= 2)
factors.push_back(make_pair(num, 1));

}

vector <int> divisors;
void setDivisors(int n, int i) {
int j, x, k;
for (j = i; j<factors.size(); j++) {
x = factors[j].first * n;
for (k = 0; k<factors[j].second; k++) {
divisors.push_back(x);
setDivisors(x, j + 1);
x *= factors[j].first;
}
}
}

int main() {

sieve();
int n, x, i;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
primeFactors(x);
setDivisors(1, 0);
divisors.push_back(1);
sort(divisors.begin(), divisors.end());
cout << divisors.size() << "\n";
for (int j = 0; j < divisors.size(); j++) {
cout << divisors[j] << " ";
}
cout << "\n";
divisors.clear();
factors.clear();
}
}

Первая часть, sieve () используется для поиска простых чисел и помещения их в массив primes []. Перейдите по ссылке, чтобы узнать больше об этом коде (побитовое сито).

Вторая часть primeFactors (x) принимает целое число (x) в качестве входных данных, находит его простые множители и соответствующий показатель степени и помещает их в векторные факторы []. Например, primeFactors (12) будет заполнять факторы [] следующим образом:

factors[0].first=2, factors[0].second=2
factors[1].first=3, factors[1].second=1

как 12 = 2 ^ 2 * 3 ^ 1

Третья часть setDivisors () рекурсивно вызывает себя для вычисления всех делителей x, используя векторные множители [], и помещает их в векторные делители [].

Он может вычислять делители любого числа, которое вписывается в int. И это довольно быстро.

Существует множество хороших решений для нахождения всех основных факторов не слишком большого числа. Я просто хотел отметить, что, как только они у вас есть, не требуется никаких вычислений, чтобы получить все факторы.

если N = p_1^{a}*p_{2}^{b}*p_{3}^{c}.....

Тогда число факторов явно (a+1)(b+1)(c+1).... поскольку каждый фактор может равняться нулю до одного раза.

например 12 = 2^2*3^1 так оно и есть 3*2 = 6 факторы. 1,2,3,4,6,12

======

Первоначально я думал, что вы просто хотели количество различных факторов. Но та же логика применима. Вы просто перебираете набор чисел, соответствующих возможным комбинациям показателей.

Итак, в приведенном выше примере:

00
01
10
11
20
21

дает вам 6 факторы.

//Try this,it can find divisors of verrrrrrrrrry big numbers (pretty efficiently :-))
#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<conio.h>

using namespace std;

vector<double> D;

void divs(double N);
double mod(double &n1, double &n2);
void push(double N);
void show();

int main()
{
double N;
cout << "\n Enter number: "; cin >> N;

divs(N); // find and push divisors to D

cout << "\n Divisors of "<<N<<": "; show(); // show contents of D (all divisors of N)

_getch(); // used visual studio, if it isn't supported replace it by "getch();"return(0);
}

void divs(double N)
{
for (double i = 1; i <= sqrt(N); ++i)
{
if (!mod(N, i)) { push(i); if(i*i!=N) push(N / i); }
}
}

double mod(double &n1, double &n2)
{
return(((n1/n2)-floor(n1/n2))*n2);
}

void push(double N)
{
double s = 1, e = D.size(), m = floor((s + e) / 2);
while (s <= e)
{
if (N==D[m-1]) { return; }
else if (N > D[m-1]) { s = m + 1; }
else { e = m - 1; }
m = floor((s + e) / 2);
}
D.insert(D.begin() + m, N);
}

void show()
{
for (double i = 0; i < D.size(); ++i) cout << D[i] << " ";
}

int result_num;
bool flag;

cout << "Number          Divisors\n";

for (int number = 1; number <= 35; number++)
{
flag = false;
cout << setw(3) << number << setw(14);

for (int i = 1; i <= number; i++)
{
result_num = number % i;

if (result_num == 0 && flag == true)
{
cout << "," << i;
}

if (result_num == 0 && flag == false)
{
cout << i;
}

flag = true;
}

cout << endl;
}
cout << "Press enter to continue.....";
cin.ignore();
return 0;
}

Вот реализация Java этот подход:

public static int countAllFactors(int num)
{
TreeSet<Integer> tree_set = new TreeSet<Integer>();
for (int i = 1; i * i <= num; i+=1)
{
if (num % i == 0)
{
tree_set.add(i);
tree_set.add(num / i);
}
}
System.out.print(tree_set);
return tree_set.size();
}