I. Số nguyên tố và Hợp số

1. Giới thiệu

    Số nguyên tố là số nguyên dương lớn hơn $1$ và chỉ có đúng hai ước là $1$ và chính nó.

    Hợp số, là các số nguyên dương lớn hơn $1$ và có nhiều hơn hai ước.

    Lấy ví dụ: $5$ là một số nguyên tố, vì nó chỉ có đúng hai ước là $1$ và $5$. Ngược lại $10$ là một hợp số vì nó có bốn ước là $1, 2, 5$ và $10$. Số nguyên tố và các vấn đề xoay quanh nó luôn là một chủ đề được yêu thích trong Toán học nói chung và lập trình thi đấu nói riêng.

2. Kiểm tra tính nguyên tố của một số

2.1. Giải thuật cơ sở

    Ý tưởng ban đầu rất đơn giản: Ta duyệt qua tất cả các số nguyên từ $2$ tới $n - 1,$ nếu như có số nào là ước của $N$ thì kết luận $n$ không phải số nguyên tố. Giải thuật có độ phức tạp $O(n)$.

bool is_prime(int n)
{
    if (n < 2)
        return false;

    for (int i = 2; i < n; ++i)
        if (N % i == 0)
            return false;

    return true;
}

2.2. Cải tiến:

    Xuất phát từ nhận xét sau: Giả sử số nguyên dương $n$ có ước là $d \ (0 < d \le \sqrt{n}),$ khi đó $n$ sẽ có thêm một ước là $\frac{n}{d} \ \left(\sqrt{n} \le \frac{n}{d} \le n\right)$. Như vậy ta chỉ cần kiểm tra các số nguyên từ $2$ tới $\sqrt{n}$ xem $n$ có chia hết cho số nào không, nếu không thì kết luận $n$ là số nguyên tố. Giải thuật có độ phức tạp chỉ là $O(\sqrt{n})$.

bool is_prime(int n)
{
    if (n < 2)
        return false;

    for (int i = 2; i * i <= n; ++i)
        if (n % i == 0)
            return false;

    return true;
}

II. Sàng lọc số nguyên tố Eratosthenes

1. Giới thiệu

    Sàng Eratosthenes là một giải thuật cổ xưa do nhà Toán học người Hy Lạp Eratosthenes phát minh ra để tìm các số nguyên tố nhỏ hơn $100$. Tương truyền, khi tìm ra thuật toán, ông đã lấy lá cọ và ghi tất cả các số từ $2$ cho đến $100$ lên đó, sau đó chọc thủng các hợp số và giữ nguyên các số nguyên tố. Bảng số nguyên tố còn lại trông rất giống một cái sàng. Do đó, nó có tên là sàng Eratosthenes.

    Với sự phát triển của máy tính, sàng Eratosthenes trở thành một công cụ rất hữu dụng để tìm ra các số nguyên tố trong một khoảng nhất định, với điều kiện bộ nhớ có thể lưu trữ được.

2. Cài đặt giải thuật

    Nguyên lý hoạt động của sàng Eratosthenes như sau: Xét các số nguyên tố từ $2$ tới $\sqrt{n},$ với mỗi số nguyên tố ta sẽ đánh dấu các bội của nó mà lớn hơn nó đều là hợp số. Sau khi duyệt xong, tất cả các số chưa được đánh dấu sẽ là số nguyên tố. Dưới đây cài đặt sàng lọc các số nguyên tố từ $1$ tới $n$.

bool is_prime[n + 1];

void eratosthenes_sieve(int n)
{    
    // Mảng đánh dấu một số có phải số nguyên tố không.
    // Ban đầu giả sử mọi số đều là nguyên tố.
    for (int i = 0; i <= n; ++i)
       is_prime[i] = true;
    // 0 và 1 không phải số nguyên tố.
    is_prime[0] = is_prime[1] = false; 
    
    for (int i = 2; i * i <= n; ++i)
        if (is_prime[i]) // Nếu i là số nguyên tố
            for (int j = i * i; j <= n; j += i) // Loại bỏ các bội của i lớn hơn i
                is_prime[j] = false;
}

    Bạn đọc có thể thắc mắc tại sao các bội của $i$ lại không bắt đầu từ $2.i$. Lí do là vì, vòng lặp duyệt các số nguyên tố tăng dần, khi tới số nguyên tố $i$ thì các bội $2.i, 3.i,..., (i - 1).i$ đều đã bị loại đi trước đó bởi các số nguyên tố nhỏ hơn $i$ rồi. Cũng chính nhờ điều này nên vòng lặp bên ngoài chỉ cần duyệt từ $2$ tới $\sqrt{n}$, giúp giảm độ phức tạp của giải thuật đi nhiều.

Đánh giá độ phức tạp

    Quan sát cài đặt, ta nhận thấy:

• Với $i = 2$, vòng lặp bên trong lặp $\frac{n}{2}$ lần.
• Với $i = 3$, vòng lặp bên trong lặp $\frac{n}{3}$ lần.
• Với $i = 5$, vòng lặp bên trong lặp $\frac{n}{5}$ lần. $...$

    Tổng số lần lặp sẽ là $n.\left(\frac{1}{2}+\frac{1}{3}+\frac{1}{5}+ \cdots\right)$, độ phức tạp sẽ tiến tới $O\big(n. \log n\big)$.

3. Sàng số nguyên tố trên đoạn

    Ở một số trường hợp, người ta cần tìm các số nguyên tố trên đoạn $[L, R]$ cho trước và $R$ có thể lên tới $10^{12},$ với điều kiện có thể tạo được một mảng có độ dài $(R - L + 1)$.

    Ý tưởng giải thuật như sau: Sàng lọc trước một mảng gồm các số nguyên tố trong đoạn $\big[2...\sqrt{R}\big],$ sau đó duyệt qua các số nguyên tố này, loại bỏ các bội của chúng nằm trong đoạn $[L, R]$. Code dưới đây cải tiến một chút để bỏ bớt bước tạo mảng số nguyên tố trong đoạn $\big[2...\sqrt{R}\big],$ nhằm tiết kiệm thời gian chạy.

bool is_prime[R + 1];

void range_eratosthenes(int L, int R)
{
    int range = R - L + 1;
    for (int i = 2; i <= range; ++i)
        is_prime[i] = true;
    
    // Duyệt các bội của i từ bội nhỏ nhất thuộc đoạn [L, R].
    for (long long i = 2; i * i <= R; ++i)
        if (is_prime[i])
            for (long long j = max(i * i, (L + i - 1) / i * i); j <= R; j += i)
                is_prime[j - L] = false;

    if (L == 1)
        is_prime[0] = false;
}

    Như vậy với một số $X$ trong đoạn $[L, R], X$ là số nguyên tố khi và chỉ khi $\text{is\_prime}[X - L]=true$. Thuật toán có độ phức tạp là $O\big((R - L + 1).log(R) + \sqrt{R}\big)$. Trên thực tế nó chạy khá nhanh.

III. Phân tích thừa số nguyên tố

    Vấn đề phân tích thừa số nguyên tố cũng khá được quan tâm trong lập trình thi đấu, và nó còn có một số ứng dụng khác trong số học. Dưới đây chúng ta sẽ xem xét vài phương pháp phân tích thừa số nguyên tố thường dùng.

1. Giải thuật cơ sở

    Ta xét mọi số nguyên tố bắt đầu từ $2,$ nếu $n$ chia hết cho số nguyên tố $p$ thì chia $n$ cho $p$ tới khi không thể chia hết nữa, rồi tăng $p$ lên và lặp lại công việc tới khi $n=1$. Trên thực tế thừa số nguyên tố chính là thành phần cấu tạo nên một ước của $n,$ do đó khi tách hết một thừa số nguyên tố $x$ khỏi $n$ thì $n$ sẽ không thể chia hết cho các bội lớn hơn $x$ nữa.

Cài đặt

vector < int > extract(int n)
{
    int p = 2;
    vector < int > prime_factor; // Lưu thừa số nguyên tố vào vector.

    while (n > 1)
    {
        while (N % p == 0)
        {
            prime_factor.push_back(p);
            n /= p;
        }

        ++p;
    }

    return prime_factor;
}

2. Cải tiến lần 1

    Xuất phát từ nhận xét sau: Không thể xảy ra trường hợp mọi thừa số nguyên tố của $n$ đều lớn hơn $\sqrt{n},$ do đó chúng ta chỉ cần xét các ước của $n$ từ $2$ tới $\sqrt{n}$ và chia dần $n$ cho các ước của nó tới khi $n$ bằng $1$. Nếu không thể tìm được ước nào từ $2$ tới $\sqrt{n}$ thì $n$ phải là một số nguyên tố. Độ phức tạp giải thuật là $O(\sqrt{n})$.

Cài đặt

vector < int > extract(int n)
{
    vector < int > prime_factor;

    for (int i = 2; i * i <= n; ++i)
        while (n % i == 0)
        {
            prime_factor.push_back(i);
            n /= i;
        }

    if (n > 1)
        prime_factor.push_back(i);

    return prime_factor;
}

3. Phân tích thừa số nguyên tố bằng sàng Eratosthenes

    Từ hai giải thuật trên ta thấy: Ở mỗi bước phân tích cần tìm ra ước nguyên tố nhỏ nhất của $n$ rồi chia $n$ cho ước đó. Ta sẽ thay đổi sàng Eratosthenes đi một chút để lấy được ngay ước nguyên tố nhỏ nhất của $n$ trong $O(1)$ ở mỗi bước phân tích, điều này sẽ giúp giảm thời gian chạy đi đáng kể.

Cài đặt

int smallest_divisor[max_value + 1];
bool is_prime[max_value + 1];

void eratosthenes_sieve(int max_value)
{
    // Mảng lưu ước nguyên tố nhỏ nhất của các số trong đoạn [1, max_value].
    fill(smallest_divisor + 1, smallest_divisor + max_value + 1, 0); 
    fill(is_prime, is_prime + max_value + 1, true);
    is_prime[0] = is_prime[1] = false;

    for (int i = 2; i * i <= max_value; ++i)
        if (is_prime[i]) // Nếu i là số nguyên tố
            for (int j = i * i; j <= max_value; j += i)
            {
                is_prime[j] = false;
                    
                // Ước nguyên tố nhỏ nhất của j là i.
                if (smallest_divisor[j] == 0)
                    smallest_divisor[j] = i; 
            }

    // Xét riêng các trường hợp i là số nguyên tố,
    // ước nguyên tố nhỏ nhất là chính nó.
    for (int i = 2; i <= max_value; ++i)
        if (is_prime[i])
            smallest_divisor[i] = i;
}

vector < int > extract(int n)
{
    // Sàng số nguyên tố tới một giá trị max_value nào đó. 
    eratosthenes_sieve(max_value); 

    vector < int > prime_factor;

    while (n > 1)
    {
        int p = smallest_divisor[n];
        prime_factor.push_back(p);
        n /= p;
    }

    return prime_factor;
}

    Mặc dù việc thực hiện sàng Eratosthenes vẫn mất $O\big(n.\log n \big),$ tuy nhiên thao tác phân tích một số $p$ thành thừa số nguyên tố chỉ mất độ phức tạp $O(\log p)$. Điều này sẽ rất có lợi trong các bài toán phải phân tích thừa số nguyên tố nhiều lần.

4. Đếm số ước của một số nguyên

    Giả sử ta phân tích được $n$ thành các thừa số nguyên tố ở dạng:

    $$n=p_1^{k_1}\times p_2^{k_2}\times ... \times p_m^{k_m}$$

    Các ước số của $n$ sẽ phải có dạng:

    $$p_1^{r_1}\times p_2^{r_2}\times ...\times p_m^{r_m}$$

    Theo nguyên lý nhân, ta thấy: $r_1$ có $k_1 + 1$ cách chọn, $r_2$ có $k_2 + 2$ cách chọn,..., $r_m$ có $k_m + 1$ cách chọn. Như vậy số lượng ước của $n$ sẽ được tính theo công thức:

    $$F_n=(k_1+1)\times (k_2+1) \times ... \times (k_m+1)$$

    Từ đây, ta có ý tưởng đếm số ước của một số nguyên dương $n$ như sau:

• Phân tích $n$ thành thừa số nguyên tố.
• Đặt một biến $\text{cnt\_x}$ là số lần xuất hiện của thừa số nguyên tố $x$ trong phân tích của $n$. Ta vừa phân tích $n$ vừa cập nhật số lượng thừa số nguyên tố lên biến $\text{cnt\_x}$.

Cài đặt 1

    Tính số lượng ước nguyên dương của số $n$ bằng phân tích nguyên tố trong $O(\sqrt{n})$:

int count_divisors(int n)
{
    int total_divisor = 1; // Chắc chắn n có ước là 1.
    for (int i = 2; i * i <= n; ++i)
    {
        int cnt = 0; // Đếm số lượng thừa số nguyên tố i trong phân tích của N.
        while (n % i == 0)
        {
            ++cnt;
            N /= i;
        }

        total_divisors *= (cnt + 1);
    }

    if (n > 1)
        total_divisors *= 2;

    return total_divisors;
}

    Trong trường hợp cần đếm ước của nhiều số (khoảng $10^6$ số chẳng hạn), và mỗi số đều có giá trị nhỏ hơn hoặc bằng $10^7,$ thì giải thuật trên sẽ bị Time Limit Exceeded. Khi đó, ta có thể cải tiến thuật toán bằng cách áp dụng luôn việc phân tích thừa số nguyên tố sử dụng Sàng Eratosthenes, khi đó việc đếm ước của mỗi số sẽ chỉ còn độ phức tạp là $O(\log n)$.

Cài đặt 2

    Trong cài đặt này, ta sẽ tái sử dụng lại code Sàng số nguyên tố Eratosthenes và mảng $\text{smallest\_divisor}$ ở phần phân tích thừa số nguyên tố bằng Sàng Eratosthenes bên trên.

    Tính số lượng ước nguyên dương của số $n$ bằng phân tích nguyên tố trong $O(\log n)$:

int count_divisors(int n)
{
    int total_divisors = 1;
    
    while (n > 1)
    {
        int d = smallest_divisor[n], power = 0;
        while (n % d == 0)
        {
            ++power;
            n /= d;
        }
        
        total_divisors *= (power + 1);    
    }
    
    return total_divisors;
}

5. Tính tổng các ước số nguyên dương của một số nguyên dương

Định lý

    Nếu một số nguyên dương $n$ khi phân tích ra thừa số nguyên tố có dạng:

    $$n=p_1^{k_1}\times p_2^{k_2}\times ... \times p_m^{k_m} \text{ } (k_i \ne 0; \forall i: 1 \le i \le m)$$

    thì tổng các ước nguyên dương của nó được tính theo công thức:

    $$\sigma(n) = \prod_{i = 1}^m \left(\frac{p_i^{k_i + 1} - 1}{p_i - 1}\right)$$

    Chứng minh: Các ước số của $n$ sẽ phải có dạng:

    $$p_1^{r_1}\times p_2^{r_2}\times ...\times p_m^{r_m}$$

    $\rightarrow$ Tổng các ước của $n$ là:

    $$\sigma(N) = \sum_{r_1=0}^{k_1} \sum_{r_2=0}^{k_2} \cdots \sum_{r_m = 0}^{k_m} (p_1^{r_1} \times p_2^{r_2} \times \cdots \times p_m^{r_m})$$

    $$= \sum_{r_1=0}^{k_1} p_1^{r_1} \times \sum_{r_2=0}^{k_2} p_2^{r_2} \times \cdots \times \sum_{r_m=0}^{k_m} p_m^{r_m} \ (1)$$

    Mà ta có công thức dãy cấp số nhân sau:

    $$p^0 + p^1 + p^2 + \cdots + p^n = \frac{p^{n + 1} - 1}{p - 1} \ (2)$$

    Từ $(1)$ và $(2)$, ta có:

    $$\sigma(n) = \frac{p_1^{k_1 + 1} - 1}{p_1 - 1} \times \frac{p_2^{k_2 + 1} - 1}{p_2 - 1} \times \cdots \times \frac{p_m^{k_m + 1} - 1}{p_m - 1}$$

Cài đặt 1

    Để tránh tràn số, ở đây tôi đặt luôn tất cả các số mang kiểu dữ liệu long long. Tùy vào bài toán mà các bạn sẽ điều chỉnh lại cho phù hợp.

    Tuy nhiên, giải thuật này có sử dụng tới kĩ thuật tính nhanh lũy thừa $a^b$ trong $O(\log b)$ bằng giải thuật Bình phương và Nhân. Các bạn có thể đọc trước về giải thuật này tại đây.

    Tính tổng các ước của một số nguyên dương $n$ trong $O(\sqrt{n} \times \log n)$:

long long exponentiation(long long A, long long B)
{
    if (B == 0)
        return 1LL;

    long long half = exponentiation(A, B / 2LL);

    if (B & 1)
        return half * half * A;
    else 
        return half * half;
}

long long get_sum_divisors(long long n)
{
    if (n == 1)
        return 1;

    long long x = 1, y = 1;
    for (int i = 2; i * i <= n; ++i)
    {
        long long cnt = 0; // Đếm số lượng thừa số nguyên tố i trong phân tích của n.
        while (n % i == 0)
        {
            ++cnt;
            n /= i;
        }

        if (cnt != 0)
        {
            x *= (exponentiation(i, cnt + 1) - 1);
            y *= (i - 1);
        }
    }

    if (n > 1)
        x *= n * n - 1, y *= (n - 1);

    return x / y;
}

    Cũng tương tự như khi đếm ước, ta có thể sử dụng sàng Eratosthene để tính tổng các ước của một số nguyên dương $n,$ phương pháp này sẽ rất hữu dụng trong các bài toán cần tính nhanh tổng các ước của $n$.

Cài đặt 2

    Trong cài đặt này, ta sẽ tái sử dụng lại code Sàng số nguyên tố Eratosthenes và mảng $\text{smallest\_divisor}$ ở phần phân tích thừa số nguyên tố bằng Sàng Eratosthenes bên trên.

    Tuy nhiên, do dùng tới Sàng nguyên tố nên giải thuật này chỉ có thể phân tích các số có giá trị khoảng $10^7$ trở xuống. Các bạn cần lựa chọn thuật toán cho phù hợp với ràng buộc đề bài.

    Tính tổng các ước nguyên dương của một số $n$ trong $O(\log^2 n)$:

long long exponentiation(long long A, long long B)
{
    if (B == 0)
        return 1LL;

    long long half = exponentiation(A, B / 2LL);

    if (B & 1)
        return half * half * A;
    else 
        return half * half;
}

long long get_sum_divisors(int n)
{
    long long x = 1, y = 1;
    
    while (n > 1)
    {
        int d = smallest_divisor[n], power = 0;
        while (n % d == 0)
        {
            ++power;
            n /= d;
        }

        x *= (exponentiation(d, power + 1) - 1);
        y *= (d - 1);
    }

    return x / y;
}

IV. Bài tập minh họa

1. Số nguyên tố đặc biệt

Đề bài

    Một số nguyên dương $X$ được gọi là số nguyên tố đặc biệt khi và chỉ khi nó có đúng $3$ ước nguyên dương phân biệt.

    Yêu cầu: Cho trước số nguyên dương $N$. Hãy đếm số lượng số nguyên tố đặc biệt từ $1$ tới $N?$

    Input:

• Chứa duy nhất số nguyên dương $N$.

    Ràng buộc:

• $1 \le N \le 10^9$.

    Subtasks

• Subtask $1$ ($50\%$ số điểm): $1 \le N \le 10^3$.
• Subtask $2$ ($50\%$ số điểm): Không có ràng buộc gì thêm.

    Output:

• In ra danh sách các số nguyên tố đặc biệt từ $1$ tới $N,$ mỗi số trên một dòng.

    Sample Input:

5

    Sample Output:

4

Ý tưởng

Subtask 1

    Duyệt tất cả các số và đếm ước của chúng.

    Độ phức tạp: $O\big(n \times \sqrt{n}\big)$.

Subtask 2

    Nhận thấy, số có $3$ ước nguyên dương phân biệt chắc chắn phải là bình phương của một số nguyên tố. Vậy ta sẽ đi tìm số lượng số $x$ là số nguyên tố thỏa mãn: $1 \le x \le \sqrt{n},$ khi đó $x^2$ chính là một số nguyên tố đặc biệt.

    Độ phức tạp: $O(\sqrt{n})$.

Cài đặt

#include <bits/stdc++.h>

using namespace std;

bool is_prime(int N)
{
    if (N < 2) return false;

    for (int i = 2; i * i <= N; ++i)
        if (N % i == 0)
            return false;

    return true;
}

void solution(int N)
{
    for (int i = 1; i * i <= N; ++i)
        if (is_prime(i))
            cout << i * i << endl;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;

    solution(N);

    return 0;
}

2. Tìm số mũ

Đề bài

    Cho trước hai số nguyên $N$ và $P$.

    Yêu cầu: Xác định giá trị $M$ nguyên dương lớn nhất để $P^M$ là ước số của $N!$

    Input:

• Một dòng duy nhất chứa hai số nguyên $N$ và $P$.

    Ràng buộc:

• $1 \le N, P \le 30000$.

    Output:

• Đưa ra số $M$ tìm được. Dữ liệu đảm bảo luôn tồn tại giá trị $M$ nguyên dương thỏa mãn yêu cầu.

    Sample Input:

7 3

    Sample Output:

2

Ý tưởng

    Giả sử $n!$ có phân tích nguyên tố là:

    $$p_1^{k_1} \times p_2^{k_2} \times \cdots \times p_x^{k_x}$$

    Thì các ước số của $n!$ phải có dạng:

    $$p_1^{k'_1} \times p_2^{k'_2} \times \cdots \times p_x^{k'_x)}$$

    Suy ra để $P^m$ là ước của $n!$ thì $P^m$ cũng phải có dạng như trên. Giả sử phân tích nguyên tố của $P$ là:

    $$q_1^{r_1} \times q_2^{r_2} \times \cdots \times q_l^{r_l}$$

    Thì $P^m$ có phân tích là:

    $$q_1^{r_1.m} \times q_2^{r_2.m} \times \cdots \times q_l^{r_l.m}$$

    Nếu trong phân tích của $P^m$ tồn tại một số nguyên tố không xuất hiện trong phân tích của $n!$ thì chắc chắn không tìm được giá trị $m$. Tuy nhiên đề bài nói rằng chắc chắn luôn luôn tìm được $m$. Do đó, phân tích nguyên tố của $P^m$ sẽ chỉ bao gồm các thừa số nguyên tố trong phân tích của $n!$:

    $$p_1^{r_1.m} \times p_2^{r_2.m} \times \cdots \times p_x^{r_x.m}$$

    Vì $P^m$ là ước của $n!$ nên:

    $$r_1.m \le k_1; r_2.m \le k_2; \dots; r_x.m \le k_x$$

    $$\Leftrightarrow m \le \left\lfloor{\frac{k_1}{r_1}}\right\rfloor; m \le \left\lfloor{\frac{k_2}{r_2}}\right\rfloor; \cdots; m \le \left\lfloor{\frac{k_x}{r_x}}\right\rfloor$$

    $$\Leftrightarrow m \text{ max}= \text{min}\left(\left\lfloor{\frac{k_i}{r_i}}\right\rfloor\right); \forall i: 1 \le i \le x$$

    Vì $n, p \le 30000$ nên chỉ cần áp dụng phân tích thừa số nguyên tố trong $O(\sqrt{n})$ là có thể vượt qua ràng buộc thời gian $1$s.

Cài đặt

#include <bits/stdc++.h>

using namespace std;

void extract(int n, vector < int > &power) 
{
    for (int i = 2; i * i <= n; i++) 
    {
        while (n % i == 0) 
        {
            n /= i;
            power[i]++;
        }
    }

    if (n > 1)
        power[n]++;
}

void solution(int n, int p)
{
    vector < int > power1(n + 1);
    for (int i = 1; i <= n; i++)
        extract(i, power1);

    vector < int > power2(n + 1);
    extract(p, power2);

    int res = INT_MAX;
    for (int i = 2; i <= n; i++)
        if (power1[i] != 0 && power2[i] != 0)
            res = min(res, power1[i] / power2[i]);

    cout << res;
}

int main() 
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    int n, p;
    cin >> n >> p;

    solution(n, p);

    return 0;
}

3. Quà sinh nhật

Đề bài

    Nguyên nhận được món quà sinh nhật thú vị. Đó là một dãy số nguyên dương. Anh ta quyết định biến đổi dãy số nhận được thành dãy toàn số $1$.

    Tại mỗi bước, anh ta chọn ra một tập hợp các số có cùng một ước số là số nguyên tố $p$ nào đó, chia tất cả các số trong tập hợp này cho số $p$.

    Yêu cầu: Hỏi rằng Nguyên phải thực hiện tối thiểu bao nhiêu bước biến đổi để thu được dãy toàn số $1?$

    Input:

• Dòng đầu tiên ghi số nguyên dương $T$ là số bộ dữ liệu. Tiếp theo là $T$ nhóm dòng, mỗi nhóm dòng mô tả một bộ dữ liệu theo qui cách sau:
  • Dòng đầu tiên ghi số nguyên dương $N$ - số lượng số của dãy số.
  • Dòng thứ hai chứa $N$ số nguyên $a_1,a_2,\dots ,a_N$ phân tách nhau bởi dấu cách - dãy số được cho.

    Ràng buộc:

• $1 \le T \le 5$.
• $1 \le N \le 10^5$.
• $1 \le a_i \le 10^6; \forall i: 1 \le i \le N$.

    Output:

• Với mỗi bộ dữ liệu in ra trên một dòng số nguyên - số lượng tối thiểu các bước cần thực hiện để thu được dãy chỉ chứa toàn số $1$.

    Sample Input:

1
3
1 2 4

    Sample Output:

2

Ý tưởng

    Mỗi lần ta chọn một số nguyên tố $p$ và chia mọi số trong mảng $A$ có chứa $p$ cho nó, vì vậy ta có thể hiểu ý tưởng của bài là xét mọi thừa số nguyên tố xuất hiện trong phân tích nguyên tố của các $a_i,$ và lần lượt đếm số bước cần thực hiện để loại bỏ mỗi thừa số đó ra khỏi mọi số trong mảng $A$.

    Ta sẽ phân tích ước nguyên tố ra với mỗi số $a_i$ trong $O\big(\log(a_i)\big)$ sử dụng sàng số nguyên tố. Với mỗi thừa số nguyên tố $p,$ giả sử nó xuất hiện trong $k$ số của mảng $A$ là $a_{i_1}, a_{i_2}, \dots, a_{i_k}$ với số lần xuất hiện lần lượt là $c_1, c_2, \dots, c_k;$ thì tổng số lần chia cần thiết để loại bỏ $p$ khỏi toàn bộ $k$ số đó sẽ là $\text{max}(c_1, c_2, \dots, c_k)$ lần, bởi vì mỗi khi ta chia một số $a_i$ cho $p$ thì các số khác cũng chứa $p$ cũng sẽ được gom nhóm cùng $a_i$ để chia một lần.

    Vậy dùng một mảng $\text{max\_power}[p]$ để lưu số mũ cao nhất của thừa số nguyên tố $p$ trong phân tích nguyên tố của tất cả các $a_i$. Sau đó, lưu một mảng $\text{primes}$ chứa mọi số nguyên tố khác nhau trong quá trình phân tích các $a_i$. Kết quả cuối cùng sẽ là:

    $$\sum \text{max\_power}[p]; \forall p \in \text{primes}$$

    Độ phức tạp: $\big(T \times n.\log(n)\big)$.

Cài đặt

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1e5, max_value = 1e6;
int a[maxn + 1], smallest_divisor[max_value + 1];

void eratosthenes_sieve(int max_value)
{
    vector < bool > is_prime(max_value + 1, true);
    is_prime[0] = is_prime[1] = false;

    for (int i = 2; i * i <= max_value; ++i)
        if (is_prime[i])
            for (int j = i * i; j <= max_value; j += i)
            {
                is_prime[j] = false;

                if (smallest_divisor[j] == 0)
                    smallest_divisor[j] = i;
            }

    for (int i = 2; i <= max_value; ++i)
        if (is_prime[i])
            smallest_divisor[i] = i;
}

void solution(int n, int a[])
{
    vector < int > max_power(max_value + 1, 0);
    vector < int > appear(max_value + 1, false);
    vector < int > primes;

    for (int i = 1; i <= n; ++i)
    {
        int x = a[i];
        while (x > 1)
        {
            int p = smallest_divisor[x], power = 0;
            while (x % p == 0)
            {
                ++power;
                x /= p;
            }

            max_power[p] = max(max_power[p], power);
            if (!appear[p])
                appear[p] = true, primes.push_back(p);
        }
    }

    int res = 0;
    for (int p: primes)
        res += max_power[p];

    cout << res << endl;
}

main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    
    eratosthenes_sieve(max_value);

    int t;
    cin >> t;

    while (t--)
    {
        int n;
        cin >> n;

        for (int i = 1; i <= n; ++i)
            cin >> a[i];

        solution(n, a);
    }

    return 0;
}

V. Tài liệu tham khảo

• https://cp-algorithms.com/algebra/sieve-of-eratosthenes.html
• https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
• https://vnoi.info/wiki/translate/he/Number-Theory-2.md
• https://cp-algorithms.com/algebra/factorization.html
• https://www.geeksforgeeks.org/segmented-sieve-print-primes-in-a-range/?ref=rp
• https://www.mathvn.com/2020/01/chung-minh-inh-li-ve-ham-tong-cac-uoc.html
• https://www.mathvn.com/2020/01/cong-thuc-tinh-tong-cac-uoc-nguyen.html