You are an expert competitive programmer. You will be given a problem statement, test case constraints and example test inputs and outputs. Please reason step by step about the solution (that must respect memory and time limits), then provide a complete implementation in c++17.

Your solution must read input from standard input (cin), write output to standard output (cout).
Do not include any debug prints or additional output.

Put your final solution within a single code block:
```cpp
<your code here>
```

Execution time limit: 1.0 seconds
Memory limit: 256.0 MB

# Problem
You are given a permutation$$$^\dagger$$$ $$$p$$$ of length $$$n$$$ and a positive integer $$$k \le n$$$.

In one operation, you:

- Choose $$$k$$$ distinct elements $$$p_{i_1}, p_{i_2}, \ldots, p_{i_k}$$$.
- Remove them and then add them sorted in increasing order to the end of the permutation.

For example, if $$$p = [2,5,1,3,4]$$$ and $$$k = 2$$$ and you choose $$$5$$$ and $$$3$$$ as the elements for the operation, then $$$[2, \color{red}{5}, 1, \color{red}{3}, 4] \rightarrow [2, 1, 4, \color{red}{3},\color{red}{5}]$$$.

Find the minimum number of operations needed to sort the permutation in increasing order. It can be proven that it is always possible to do so.

$$$^\dagger$$$ A permutation of length $$$n$$$ is an array consisting of $$$n$$$ distinct integers from $$$1$$$ to $$$n$$$ in arbitrary order. For example, $$$[2,3,1,5,4]$$$ is a permutation, but $$$[1,2,2]$$$ is not a permutation ($$$2$$$ appears twice in the array), and $$$[1,3,4]$$$ is also not a permutation ($$$n=3$$$ but there is $$$4$$$ in the array).

## Input Format
The first line contains a single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. The description of test cases follows.

The first line of each test case contains two integers $$$n$$$ and $$$k$$$ ($$$2 \le n \le 10^5$$$, $$$1 \le k \le n$$$).

The second line of each test case contains $$$n$$$ integers $$$p_1,p_2,\ldots, p_n$$$ ($$$1 \le p_i \le n$$$). It is guaranteed that $$$p$$$ is a permutation.

It is guaranteed that the sum of $$$n$$$ over all test cases does not exceed $$$10^5$$$.

## Output Format
For each test case output a single integer — the minimum number of operations needed to sort the permutation. It can be proven that it is always possible to do so.

## Examples
```input
4
3 2
1 2 3
3 1
3 1 2
4 2
1 3 2 4
4 2
2 3 1 4
```
```output
0
1
1
2
```

## Note
In the first test case, the permutation is already sorted.

In the second test case, you can choose element $$$3$$$, and the permutation will become sorted as follows: $$$[\color{red}{3}, 1, 2] \rightarrow [1, 2, \color{red}{3}]$$$.

In the third test case, you can choose elements $$$3$$$ and $$$4$$$, and the permutation will become sorted as follows: $$$[1, \color{red}{3}, 2, \color{red}{4}] \rightarrow [1, 2, \color{red}{3},\color{red}{4}]$$$.

In the fourth test case, it can be shown that it is impossible to sort the permutation in $$$1$$$ operation. However, if you choose elements $$$2$$$ and $$$1$$$ in the first operation, and choose elements $$$3$$$ and $$$4$$$ in the second operation, the permutation will become sorted as follows: $$$[\color{red}{2}, 3, \color{red}{1}, 4] \rightarrow [\color{blue}{3}, \color{blue}{4}, \color{red}{1}, \color{red}{2}] \rightarrow [1,2, \color{blue}{3}, \color{blue}{4}]$$$.

Now solve the problem and return the code.