Given an array of integers A of length N. For each index i, find number of indices j(j!=i) such that gcd(A[i],A[j])>1.
Constraints:
N<=1e5
1<=A[i]<=N
Example:
A = [4,3,2,4] output = [2,0,2,2]
A = [2,3,6,4,6,5] output = [3,2,4,3,4,0]
# | User | Rating |
---|---|---|
1 | tourist | 4009 |
2 | jiangly | 3823 |
3 | Benq | 3738 |
4 | Radewoosh | 3633 |
5 | jqdai0815 | 3620 |
6 | orzdevinwang | 3529 |
7 | ecnerwala | 3446 |
8 | Um_nik | 3396 |
9 | ksun48 | 3390 |
10 | gamegame | 3386 |
# | User | Contrib. |
---|---|---|
1 | cry | 167 |
2 | Um_nik | 163 |
3 | maomao90 | 162 |
3 | atcoder_official | 162 |
5 | adamant | 159 |
6 | -is-this-fft- | 158 |
7 | awoo | 157 |
8 | TheScrasse | 154 |
9 | Dominater069 | 153 |
9 | nor | 153 |
Given an array of integers A of length N. For each index i, find number of indices j(j!=i) such that gcd(A[i],A[j])>1.
Constraints:
N<=1e5
1<=A[i]<=N
Example:
A = [4,3,2,4] output = [2,0,2,2]
A = [2,3,6,4,6,5] output = [3,2,4,3,4,0]
Name |
---|
Problem source?
It's standard practice to ask for a problem link to not give solutions to ongoing contests.
Q-4 of this
I think this might work.
Because each $$$A[i] \leq 100,000$$$, there can be at most 6 distinct prime factors for each $$$A[i]$$$ (notice that $$$2 \cdot 3 \cdot 5 \cdot 7 \cdot 11 \cdot 13 \cdot 17 > 100,000$$$).
This means that the total number of subsets of distinct prime factors is $$$\leq 2^6$$$ for each $$$A[i]$$$. Thus, for each $$$A[i]$$$, we can use inclusion-exclusion principle to compute the number of elements that are divisible by at least one of the prime factors of $$$A[i]$$$.
What is inclusion-exclusion principle?
Read this for understanding inclusion-exclusion principle
Thank you
Nice observation! It works.
Here is my implementation: https://ideone.com/YCHh96
This problem is similar to this one CSES — Counting Coprime Pairs
You can apply principle of inclusion and exclusion with Möbius function to solve it.
It's Möbing time
Make a counting array — cnt[i] -> number of occurrences of number i in array.
For each number num in array, iterate over all max(A[i]) / num possible divisors, and add their sum — 1 to the answer (-1 represents your own number being removed). If you counted the answer for number num, memoize it -> let dp[num] be the answer.
Then, the complexity is as follows -> iterating for(int i = 1; i <= N; ++i) up to max A / i is O(A log A), and if you meet a number you met before, you retrieve the answer in O(1) -> O(AlogA)