Zero Remainder Array
Contest: Codeforces Round 653 (Div. 3)
Difficulty rating: 1400
Tags: math, sortings, two pointers

You are given an array $$$a$$$ consisting of $$$n$$$ positive integers.

Initially, you have an integer $$$x = 0$$$. During one move, you can do one of the following two operations:

1. Choose exactly one $$$i$$$ from $$$1$$$ to $$$n$$$ and increase $$$a_i$$$ by $$$x$$$ ($$$a_i := a_i + x$$$), then increase $$$x$$$ by $$$1$$$ ($$$x := x + 1$$$).
2. Just increase $$$x$$$ by $$$1$$$ ($$$x := x + 1$$$).

The first operation can be applied no more than once to each $$$i$$$ from $$$1$$$ to $$$n$$$.

Your task is to find the minimum number of moves required to obtain such an array that each its element is divisible by $$$k$$$ (the value $$$k$$$ is given).

You have to answer $$$t$$$ independent test cases.

Input format:
The first line of the input contains one integer $$$t$$$ ($$$1 \le t \le 2 \cdot 10^4$$$) — the number of test cases. Then $$$t$$$ test cases follow.

The first line of the test case contains two integers $$$n$$$ and $$$k$$$ ($$$1 \le n \le 2 \cdot 10^5; 1 \le k \le 10^9$$$) — the length of $$$a$$$ and the required divisior. The second line of the test case contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 10^9$$$), where $$$a_i$$$ is the $$$i$$$-th element of $$$a$$$.

It is guaranteed that the sum of $$$n$$$ does not exceed $$$2 \cdot 10^5$$$ ($$$\sum n \le 2 \cdot 10^5$$$).

Output format:
For each test case, print the answer — the minimum number of moves required to obtain such an array that each its element is divisible by $$$k$$$.

Constraints:
Time limit: 2.0 s
Memory limit: 256.0 MB

Note:
Consider the first test case of the example:

1. $$$x=0$$$, $$$a = [1, 2, 1, 3]$$$. Just increase $$$x$$$;
2. $$$x=1$$$, $$$a = [1, 2, 1, 3]$$$. Add $$$x$$$ to the second element and increase $$$x$$$;
3. $$$x=2$$$, $$$a = [1, 3, 1, 3]$$$. Add $$$x$$$ to the third element and increase $$$x$$$;
4. $$$x=3$$$, $$$a = [1, 3, 3, 3]$$$. Add $$$x$$$ to the fourth element and increase $$$x$$$;
5. $$$x=4$$$, $$$a = [1, 3, 3, 6]$$$. Just increase $$$x$$$;
6. $$$x=5$$$, $$$a = [1, 3, 3, 6]$$$. Add $$$x$$$ to the first element and increase $$$x$$$;
7. $$$x=6$$$, $$$a = [6, 3, 3, 6]$$$. We obtained the required array.

Note that you can't add $$$x$$$ to the same element more than once.

Example input:
5
4 3
1 2 1 3
10 6
8 7 1 8 3 7 5 10 8 9
5 10
20 100 50 20 100500
10 25
24 24 24 24 24 24 24 24 24 24
8 8
1 2 3 4 5 6 7 8

Example output:
6
18
0
227
8

Editorial:
Firstly, we can understand that during each full cycle of $$$x$$$ from $$$0$$$ to $$$k-1$$$ we can fix each remainder only once. Notice that when we add some $$$x$$$ then we fix the remainder $$$k-x$$$ (and we don't need to fix elements which are already divisible by $$$k$$$). So, let $$$cnt_i$$$ be the number of such elements for which the condition $$$k - a_i \bmod k = i$$$ holds (i.e. the number of such elements that we can fix if we add the value $$$i \bmod k$$$ to them). We can count this using some logarithmic data structure (like std::map in C++).
So, what's the number of full cycles? It equals to the amount of most frequent element in $$$cnt$$$ minus one. So, the answer is at least $$$k \cdot (max(cnt) - 1)$$$. And there can be one last cycle which will be incomplete. So what is the remanining number of moves? It equals to the maximum possible $$$i$$$ among all $$$cnt_i = max(cnt)$$$. So if $$$key$$$ is the maximum such $$$i$$$ that $$$cnt_{key} = max(cnt)$$$ then the answer is $$$k \cdot (cnt_{key} - 1) + key + 1$$$.
Time complexity: $$$O(n \log{n})$$$.