| Consider two horizontal lines and a set of **N** trapezoids. A trapezoid | |
| **T[i]** between these lines has two vertices situated on the upper line and | |
| the other two vertices on the lower line. We will denote by **a[i], b[i], | |
| c[i]** and **d[i]** the upper left, upper right, lower left and respectively | |
| lower right vertices of the trapezoid **T[i]**. Assume that no two trapezoids | |
| share a common vertex (meaning that all **a [i]** and **b [i]** coordinates on | |
| the upper line are different, and the same holds for the bottom line and | |
| coordinates **c [i]** and **d [i]**). A trapezoid set is called | |
| **disconnected** if one can separate the trapezoids in two or more groups such | |
| that no two trapezoids from different groups intersect. Determine the smallest | |
| number of trapezoids to remove, such that the remaining trapezoids form a | |
| disconnected set. If the solution does not exist, output **-1**. | |
| ### Input | |
| The first line of the input file contains an integer **T**, and this is | |
| followed by **T** test cases. Each test case is given in the compressed | |
| format. | |
| The first line of each test case contains the number of trapezoids **N**, an | |
| integer **K**, and integer parameters **X, A, B, M, p, q**. In the next **K** | |
| lines are given integer numbers **aa[i], bb[i], cc[i], dd[i]**. The following | |
| code is used for generating the next random number using linear congruential | |
| generator with the starting value **X** and parameters **A, B** and modulo | |
| **M**: | |
| long long prior = X; | |
| long long next() { | |
| prior = (A * prior + B) % M; | |
| return prior; | |
| } | |
| The following code is used for extending the auxiliary sequences **aa, bb, | |
| cc** and **dd**: | |
| for (int i = K; i < N; i++) { | |
| aa [i] = aa [i - K] + next() % (2 * p) - p; | |
| bb [i] = aa [i] + 1 + next() % (2 * (bb [i % K] - aa [i % K])); | |
| cc [i] = cc [i - K] + next() % (2 * q) - q; | |
| dd [i] = cc [i] + 1 + next() % (2 * (dd [i % K] - cc [i % K])); | |
| } | |
| The final coordinates of the trapezoids are given by: | |
| for (int i = 0; i < N; i++) { | |
| a [i] = aa [i] * 1000000 + i; | |
| b [i] = bb [i] * 1000000 + i; | |
| c [i] = cc [i] * 1000000 + i; | |
| d [i] = dd [i] * 1000000 + i; | |
| } | |
| Note that above code generates trapezoids that satisfy all conditions of the | |
| problem, and '%' denotes the remainder of division. | |
| ## Output | |
| For each of the test cases numbered in order from **1** to **T**, output "Case | |
| #i: " followed by a single integer, the minimum number of trapezoids that need | |
| to be removed such that the remaining trapezoids form a disconnected set. | |
| ## Constraints | |
| 1 ≤ **T** ≤ 20 | |
| 1 ≤ **N** ≤ 300,000 | |
| 1 ≤ **K** ≤ **N** | |
| 0 ≤ **X, A, B** ≤ 2,000,000,000 | |
| -2,000,000,000 ≤ **aa [i], bb [i], cc [i], dd [i]** ≤ 2,000,000,000 | |
| 1 ≤ **p, q, M** ≤ 2,000,000,000 | |
| ### Examples | |
| In the first example, one can remove trapezoids 5 and 6 leaving two | |
| disconnected sets with trapezoids (1, 2, 3, 4) and (7, 8). | |
| In the second example, the coordinates of ten trapezoids are | |
| 1000000 4000000 3000000 5000000 | |
| 7000001 8000001 2000001 6000001 | |
| 2000002 7000002 2000002 5000002 | |
| 5000003 7000003 2000003 6000003 | |
| 4 6000004 2000004 3000004 | |
| 4000005 5000005 3000005 8000005 | |
| -999994 6 6 2000006 | |
| 4000007 6000007 1000007 7000007 | |
| -999992 8 -999992 2000008 | |
| 5000009 6000009 9 7000009 | |