GCD等于K的四倍数

给定两个整数N和K ，任务是找到(i，j，k，l)的四倍数，使得1≤i l≤N且gcd(i，j，k，l) = K。
例子：

Input: N = 10, K = 2 
Output: 5 
Valid quadruples are (2, 4, 6, 8), (2, 4, 6, 10), 
(2, 4, 8, 10), (2, 6, 8, 10) and (4, 6, 8, 10)
Input: N = 8, K = 1 
Output: 69 
 

方法：

• 如果序列的gcd为K，那么当我们将所有这些数字除以K时，剩余数字的gcd将为1 。
• 现在，为了满足最大数量为N的四足动物的约束，如果我们找出最大数量小于或等于N / K且gcd为1的所有四足动物的计数，则可以简单地将所有四足动物与K相乘得到答案。
• 要使用gcd 1查找四倍计数，必须使用包含和排除原理。取N / K = M。
• ^M C ₄总数可能是四倍。 ^{(M / 2)} C _4个四联体的gcd是2的倍数。 (使用2的M / 2倍数)。同样， ^{(M / 3)} C _4个四倍体的gcd是3的倍数。但是，如果我们同时减去两个数量，则gcd是6的倍数被减去两次，因此我们必须包括^{(M / 6)} C ₄才能将它们相加一次。
• 因此，从2迭代到M ，如果一个数字的奇数除数的奇数(例如2，3、5、11)，则减去gcd倍数该数的四倍数，如果它的奇数除数为偶数除数(例如6、10、33)，然后将四倍数加到该数字的gcd倍数上。 (Number不能重复像4这样的素数除数)。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Function to calculate NC4
int nCr(int n)
{
    // Base case to calculate NC4
    if (n < 4)
        return 0;
 
    int answer = n * (n - 1) * (n - 2) * (n - 3);
    answer /= 24;
    return answer;
}
 
// Function to return the count of required
// quadruples using Inclusion Exclusion
int countQuadruples(int N, int K)
{
    // Effective N
    int M = N / K;
 
    int answer = nCr(M);
 
    // Iterate over 2 to M
    for (int i = 2; i < M; i++) {
        int j = i;
 
        // Number of divisors of i till M
        int temp2 = M / i;
 
        // Count stores the number of prime
        // divisors occurring exactly once
        int count = 0;
 
        // To prevent repetition of prime divisors
        int check = 0;
        int temp = j;
 
        while (j % 2 == 0) {
            count++;
            j /= 2;
            if (count >= 2)
                break;
        }
 
        if (count >= 2) {
            check = 1;
        }
 
        for (int k = 3; k <= sqrt(temp); k += 2) {
            int cnt = 0;
 
            while (j % k == 0) {
                cnt++;
                j /= k;
                if (cnt >= 2)
                    break;
            }
 
            if (cnt >= 2) {
                check = 1;
                break;
            }
            else if (cnt == 1)
                count++;
        }
 
        if (j > 2) {
            count++;
        }
 
        // If repetition of prime divisors present
        // ignore this number
        if (check)
            continue;
        else {
 
            // If prime divisor count is odd
            // subtract it from answer else add
            if (count % 2 == 1) {
                answer -= nCr(temp2);
            }
            else {
                answer += nCr(temp2);
            }
        }
    }
 
    return answer;
}
 
// Driver code
int main()
{
    int N = 10, K = 2;
 
    cout << countQuadruples(N, K);
 
    return 0;
}

Java

// Java implementation of the approach
import java.util.*;
 
class GFG
{
 
// Function to calculate NC4
static int nCr(int n)
{
    // Base case to calculate NC4
    if (n < 4)
        return 0;
 
    int answer = n * (n - 1) * (n - 2) * (n - 3);
    answer /= 24;
    return answer;
}
 
// Function to return the count of required
// quadruples using Inclusion Exclusion
static int countQuadruples(int N, int K)
{
    // Effective N
    int M = N / K;
 
    int answer = nCr(M);
 
    // Iterate over 2 to M
    for (int i = 2; i < M; i++)
    {
        int j = i;
 
        // Number of divisors of i till M
        int temp2 = M / i;
 
        // Count stores the number of prime
        // divisors occurring exactly once
        int count = 0;
 
        // To prevent repetition of prime divisors
        int check = 0;
        int temp = j;
 
        while (j % 2 == 0)
        {
            count++;
            j /= 2;
            if (count >= 2)
                break;
        }
 
        if (count >= 2)
        {
            check = 1;
        }
 
        for (int k = 3; k <= Math.sqrt(temp); k += 2)
        {
            int cnt = 0;
 
            while (j % k == 0)
            {
                cnt++;
                j /= k;
                if (cnt >= 2)
                    break;
            }
 
            if (cnt >= 2)
            {
                check = 1;
                break;
            }
            else if (cnt == 1)
                count++;
        }
 
        if (j > 2)
        {
            count++;
        }
 
        // If repetition of prime divisors present
        // ignore this number
        if (check==1)
            continue;
        else
        {
 
            // If prime divisor count is odd
            // subtract it from answer else add
            if (count % 2 == 1)
            {
                answer -= nCr(temp2);
            }
            else
            {
                answer += nCr(temp2);
            }
        }
    }
 
    return answer;
}
 
// Driver code
public static void main(String[] args)
{
 
    int N = 10, K = 2;
 
    System.out.println(countQuadruples(N, K));
}
}
 
// This code is contributed by Princi Singh

Python3

# Python3 implementation of the approach
from math import sqrt
 
# Function to calculate NC4
def nCr(n) :
 
    # Base case to calculate NC4
    if (n < 4) :
        return 0;
 
    answer = n * (n - 1) * (n - 2) * (n - 3);
    answer //= 24;
     
    return answer;
 
# Function to return the count of required
# quadruples using Inclusion Exclusion
def countQuadruples(N, K) :
 
    # Effective N
    M = N // K;
 
    answer = nCr(M);
 
    # Iterate over 2 to M
    for i in range(2, M) :
        j = i;
 
        # Number of divisors of i till M
        temp2 = M // i;
 
        # Count stores the number of prime
        # divisors occurring exactly once
        count = 0;
 
        # To prevent repetition of prime divisors
        check = 0;
        temp = j;
 
        while (j % 2 == 0) :
            count += 1;
            j //= 2;
            if (count >= 2) :
                break;
 
        if (count >= 2) :
            check = 1;
 
        for k in range(3, int(sqrt(temp)), 2) :
            cnt = 0;
 
            while (j % k == 0) :
                cnt += 1;
                j //= k;
                if (cnt >= 2) :
                    break;
     
            if (cnt >= 2) :
                check = 1;
                break;
            elif (cnt == 1) :
                count += 1;
 
        if (j > 2) :
            count += 1;
 
        # If repetition of prime divisors present
        # ignore this number
        if (check) :
            continue;
        else :
             
            # If prime divisor count is odd
            # subtract it from answer else add
            if (count % 2 == 1) :
                answer -= nCr(temp2);
            else :
                answer += nCr(temp2);
 
    return answer;
 
# Driver code
if __name__ == "__main__" :
 
    N = 10; K = 2;
 
    print(countQuadruples(N, K));
 
# This code is contributed by AnkitRai01

C#

// C# implementation of the approach
using System;
     
class GFG
{
 
// Function to calculate NC4
static int nCr(int n)
{
    // Base case to calculate NC4
    if (n < 4)
        return 0;
 
    int answer = n * (n - 1) * (n - 2) * (n - 3);
    answer /= 24;
    return answer;
}
 
// Function to return the count of required
// quadruples using Inclusion Exclusion
static int countQuadruples(int N, int K)
{
    // Effective N
    int M = N / K;
 
    int answer = nCr(M);
 
    // Iterate over 2 to M
    for (int i = 2; i < M; i++)
    {
        int j = i;
 
        // Number of divisors of i till M
        int temp2 = M / i;
 
        // Count stores the number of prime
        // divisors occurring exactly once
        int count = 0;
 
        // To prevent repetition of prime divisors
        int check = 0;
        int temp = j;
 
        while (j % 2 == 0)
        {
            count++;
            j /= 2;
            if (count >= 2)
                break;
        }
 
        if (count >= 2)
        {
            check = 1;
        }
 
        for (int k = 3; k <= Math.Sqrt(temp); k += 2)
        {
            int cnt = 0;
 
            while (j % k == 0)
            {
                cnt++;
                j /= k;
                if (cnt >= 2)
                    break;
            }
 
            if (cnt >= 2)
            {
                check = 1;
                break;
            }
            else if (cnt == 1)
                count++;
        }
 
        if (j > 2)
        {
            count++;
        }
 
        // If repetition of prime divisors present
        // ignore this number
        if (check==1)
            continue;
        else
        {
 
            // If prime divisor count is odd
            // subtract it from answer else add
            if (count % 2 == 1)
            {
                answer -= nCr(temp2);
            }
            else
            {
                answer += nCr(temp2);
            }
        }
    }
 
    return answer;
}
 
// Driver code
public static void Main(String[] args)
{
 
    int N = 10, K = 2;
 
    Console.WriteLine(countQuadruples(N, K));
}
}
 
// This code is contributed by 29AjayKumar

Javascript

 
// Javascript implementation of the approach
 
// Function to calculate NC4
function nCr(n)
{
    // Base case to calculate NC4
    if (n < 4)
        return 0;
 
    let answer = n * (n - 1) * (n - 2) * (n - 3);
    answer = parseInt(answer / 24);
    return answer;
}
 
// Function to return the count of required
// quadruples using Inclusion Exclusion
function countQuadruples(N, K)
{
    // Effective N
    let M = parseInt(N / K);
 
    let answer = nCr(M);
 
    // Iterate over 2 to M
    for (let i = 2; i < M; i++) {
        let j = i;
 
        // Number of divisors of i till M
        let temp2 = parseInt(M / i);
 
        // Count stores the number of prime
        // divisors occurring exactly once
        let count = 0;
 
        // To prevent repetition of prime divisors
        let check = 0;
        let temp = j;
 
        while (j % 2 == 0) {
            count++;
            j = parseInt(j / 2);
            if (count >= 2)
                break;
        }
 
        if (count >= 2) {
            check = 1;
        }
 
        for (let k = 3; k <= Math.sqrt(temp); k += 2)
        {
            let cnt = 0;
 
            while (j % k == 0) {
                cnt++;
                j = parseInt(j / k);
                if (cnt >= 2)
                    break;
            }
 
            if (cnt >= 2) {
                check = 1;
                break;
            }
            else if (cnt == 1)
                count++;
        }
 
        if (j > 2) {
            count++;
        }
 
        // If repetition of prime divisors present
        // ignore this number
        if (check)
            continue;
        else {
 
            // If prime divisor count is odd
            // subtract it from answer else add
            if (count % 2 == 1) {
                answer -= nCr(temp2);
            }
            else {
                answer += nCr(temp2);
            }
        }
    }
 
    return answer;
}
 
// Driver code
    let N = 10, K = 2;
 
    document.write(countQuadruples(N, K));
 

输出：

5