 Open in App
Not now

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

• Difficulty Level : Hard
• Last Updated : 06 Jul, 2021

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(N3)
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)3.
• 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)3 ((N + (K/2)) / K)3.

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

 ``

## 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

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up
Related Articles