C. Ray Tracing

C. Ray Tracing
time limit per test2 seconds
memory limit per test256 megabytes
inputstandard input
outputstandard output
There are k sensors located in the rectangular room of size n × m meters. The i-th sensor is located at point (xi, yi). All sensors are located at distinct points strictly inside the rectangle.

Opposite corners of the room are located at points (0, 0) and (n, m). Walls of the room are parallel to coordinate axes.

At the moment 0, from the point (0, 0) the laser ray is released in the direction of point (1, 1). The ray travels with a speed of meters per second. Thus, the ray will reach the point (1, 1) in exactly one second after the start.

When the ray meets the wall it’s reflected by the rule that the angle of incidence is equal to the angle of reflection. If the ray reaches any of the four corners, it immediately stops.

For each sensor you have to determine the first moment of time when the ray will pass through the point where this sensor is located. If the ray will never pass through this point, print  - 1 for such sensors.

Input
The first line of the input contains three integers n, m and k (2 ≤ n, m ≤ 100 000, 1 ≤ k ≤ 100 000) — lengths of the room’s walls and the number of sensors.

Each of the following k lines contains two integers xi and yi (1 ≤ xi ≤ n - 1, 1 ≤ yi ≤ m - 1) — coordinates of the sensors. It’s guaranteed that no two sensors are located at the same point.

Output
Print k integers. The i-th of them should be equal to the number of seconds when the ray first passes through the point where the i-th sensor is located, or  - 1 if this will never happen.

Examples
input
3 3 4
1 1
1 2
2 1
2 2
output
1
-1
-1
2
input
3 4 6
1 1
2 1
1 2
2 2
1 3
2 3
output
1
-1
-1
2
5
-1
input
7 4 5
1 3
2 2
5 1
5 3
4 3
output
13
2
9
5
-1
Note
In the first sample, the ray will consequently pass through the points (0, 0), (1, 1), (2, 2), (3, 3). Thus, it will stop at the point (3, 3) after 3 seconds.

In the second sample, the ray will consequently pass through the following points: (0, 0), (1, 1), (2, 2), (3, 3), (2, 4), (1, 3), (0, 2), (1, 1), (2, 0), (3, 1), (2, 2), (1, 3), (0, 4). The ray will stop at the point (0, 4) after 12 seconds. It will reflect at the points (3, 3), (2, 4), (0, 2), (2, 0) and (3, 1).

這個題比較好玩
把這個矩形對稱展開然後把所有的按照直線畫出來最後把所有的鏈接到一條線上我們會發現最後到達最終點的x值是n和m的最小公倍數maxx=mn/gcd(m,n)
然後 所有點的座標就是(2kn±x,2sm±y),） 然後用擴展歐幾里得求出最小的k就可以 2kn±x不超出maxx值就是那2kn±x就是最少時間。 畫個圖理解一下

#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
LL x,y;
LL EXGCD(LL a,LL b){
    if(b==0){
        x=1;y=0;
        return a;
    }
    LL r=EXGCD(b,a%b);
    LL t=x;
    x=y;
    y=t-a/b*y;
    return r;
}
int main(){
    LL n,m;
    int t;
    scanf("%lld %lld %d",&n,&m,&t);
    LL g=EXGCD(n,m);
    LL maxx=1LL*m/g*n;
    LL a=2*n; LL b=-2*m;
    LL G=EXGCD(a,b);
    while(t--){
        LL p,q;
        scanf("%lld %lld",&p,&q);
        LL xi[5];
        LL xt[5];
        xi[1]=p+q;  xi[2]=p-q; xi[3]=-p+q; xi[4]=-p-q;
        xt[1]=-p;  xt[2]=-p; xt[3]=p; xt[4]=p;
        if((xi[1]%G)&&(xi[2]%G)&&(xi[3]%G)&&(xi[4]%G))
            printf("-1\n");
        else{
            LL tx=maxx+1;
            for(int i=1;i<=4;i++){
 //               printf("%lld======%lld\n",x,G);
                if(xi[i]%G!=0)
                    continue;
                LL ran=b/G;
                LL ans=x*xi[i]/G;
                if(ran<0) ran=-ran;
                ans=(ans%ran+ran)%ran;
 //               printf("%lld___%lld____%lld___%lld__%lld\n",x,b,xi[i],ran,G);
                if(2*ans*n+xt[i]<=0)
                    tx=tx;
                else
                    tx=min(tx,2*ans*n+xt[i]);
                //printf("%lld====%lld\n",2*ans*n+xt[i],xt[i]);
            }
            if(tx<maxx&&tx>0)
                printf("%lld\n",tx);
            else
                printf("-1\n");
        }
    }
    return 0;
}