Count triplets (a, b, c) such that a + b, b + c and a + c are all divisible by K | Set 2

Given two positive integers N and K, the task is to count the number of triplets (a, b, c) such that 0 < a, b, c < N and (a + b), (b + c) and (c + a) are all multiples of K.

Examples:

Input: N = 2, K = 2
Output: 2
Explanation: All possible triplets that satisfy the given property are (1, 1, 1) and (2, 2, 2).
Therefore, the total count is 2.

Input: N = 3, K = 2
Output: 9

Naive Approach: Refer to the previous post for the simplest approach to solve this problem. 
Time Complexity: O(N³)
Auxiliary Space: O(1)

Efficient Approach: The above approach can also be optimized based on the following observations:

• The given condition is expressed by a congruence formula:

=> a + b ≡ b + c ≡ c + a ≡ 0(mod K)
=> a+b ≡ b+c (mod K)
=> a ≡ c(mod K)

• The above relation can also be observed without using the congruence formula as:
  • As (a + b) is a multiple of K and (c + b) is a multiple of K. Therefore, (a + b) − (c + b) = a – c is also a multiple of K, i.e., a ≡ b ≡ c (mod K).
  • Therefore, the expression can be further evaluated to:

=> a + b ≡ 0 (mod K)
=> a + a ≡ 0 (mod K) (since a is congruent to b)
=> 2a ≡ 0 (mod K)

From the above observations, the result can be calculated for the following two cases:

• If K is odd, then a ≡ b ≡ c ≡ 0(mod K) since all three are congruent and the total number of triplets can be calculated as (N / K)³.
• If K is even, then K is divisible by 2 and a ≡ 0 (mod K), b ≡ 0 (mod K), and c ≡ 0 (mod K). Therefore, the total number of triplets can be calculated as (N / K)³ ((N + (K/2)) / K)³.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include "bits/stdc++.h"
using namespace std;

// Function to count the number of
// triplets from the range [1, N - 1]
// having sum of all pairs divisible by K
int countTriplets(int N, int K)
{
    // If K is even
    if (K % 2 == 0) {
        long long int x = N / K;
        long long int y = (N + (K / 2)) / K;

        return x * x * x + y * y * y;
    }

    // Otherwise
    else {
        long long int x = N / K;
        return x * x * x;
    }
}

// Driver Code
int main()
{
    int N = 2, K = 2;
    cout << countTriplets(N, K);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

class GFG{

// Function to count the number of
// triplets from the range [1, N - 1]
// having sum of all pairs divisible by K
static int countTriplets(int N, int K)
{

    // If K is even
    if (K % 2 == 0)
    {
        int x = N / K;
        int y = (N + (K / 2)) / K;

        return x * x * x + y * y * y;
    }

    // Otherwise
    else
    {
        int x = N / K;
        return x * x * x;
    }
}

// Driver Code
public static void main(String[] args)
{
    int N = 2, K = 2;

    System.out.print(countTriplets(N, K));
}
}

// This code is contributed by Kingash

Python3

# Python3 program for the above approach

# Function to count the number of
# triplets from the range [1, N - 1]
# having sum of all pairs divisible by K
def countTriplets(N, K):

    # If K is even
    if (K % 2 == 0):
        x = N // K
        y = (N + (K // 2)) // K

        return x * x * x + y * y * y

    # Otherwise
    else:
        x = N // K
        return x * x * x

# Driver Code
if __name__ == "__main__":

    N = 2
    K = 2

    print(countTriplets(N, K))

# This code is contributed by ukasp

Javascript

<script>

// Javascript program for the above approach

// Function to count the number of
// triplets from the range [1, N - 1]
// having sum of all pairs divisible by K
function countTriplets(N, K)
{

    // If K is even
    if (K % 2 == 0)
    {
        var x = parseInt(N / K);
        var y = parseInt((N + (K / 2)) / K);

        return x * x * x + y * y * y;
    }

    // Otherwise
    else
    {
        var x = parseInt(N / K);
        return x * x * x;
    }
}

// Driver Code
var N = 2, K = 2;

document.write(countTriplets(N, K));

// This code is contributed by Ankita saini

</script>

C#

// C# program for the above approach

using System;

class GFG{

// Function to count the number of
// triplets from the range [1, N - 1]
// having sum of all pairs divisible by K
static int countTriplets(int N, int K)
{

    // If K is even
    if (K % 2 == 0)
    {
        int x = N / K;
        int y = (N + (K / 2)) / K;

        return x * x * x + y * y * y;
    }

    // Otherwise
    else
    {
        int x = N / K;
        return x * x * x;
    }
}

// Driver Code
    static void Main() {
       int N = 2, K = 2;

       Console.Write(countTriplets(N, K));
    }
}

// This code is contributed by SoumikMondal

Javascript

<script>

    // JavaScript program for the above approach
    // Function to count the number of
    // triplets from the range [1, N - 1]
    // having sum of all pairs divisible by K
    function countTriplets(N,K)
    {
        // If K is even
        if (K % 2 == 0) {
            let x = parseInt(N / K, 10);
            let y = parseInt((N + parseInt(K / 2, 10)) / K, 10);

            return x * x * x + y * y * y;
        }

        // Otherwise
        else {
            let x = parseInt(N / K, 10);
            return x * x * x;
        }
    }

    // Driver Code

    let N = 2, K = 2;
    document.write(countTriplets(N, K));

</script>

Output:

2

Time Complexity: O(1)
Auxiliary Space: O(1)