CodeForces 763C. Timofey and remoduling

Little Timofey likes integers a lot. Unfortunately, he is very young and can't work with very big integers, so he does all the operations modulo his favorite prime m. Also, Timofey likes to look for arithmetical progressions everywhere.

One of his birthday presents was a sequence of distinct integers a1, a2, ..., an. Timofey wants to know whether he can rearrange the elements of the sequence so that is will be an arithmetical progression modulo m, or not.

Arithmetical progression modulo m of length n with first element x and difference d is sequence of integersx, x + d, x + 2d, ..., x + (n - 1)·d, each taken modulo m.

Input
The first line contains two integers m and n (2 ≤ m ≤ 109 + 7, 1 ≤ n ≤ 105, m is prime) — Timofey's favorite prime module and the length of the sequence.

The second line contains n distinct integers a1, a2, ..., an (0 ≤ ai < m) — the elements of the sequence.

Output
Print -1 if it is not possible to rearrange the elements of the sequence so that is will be an arithmetical progression modulo m.

Otherwise, print two integers — the first element of the obtained progression x (0 ≤ x < m) and its difference d (0 ≤ d < m).

If there are multiple answers, print any of them.

Examples
input
17 5
0 2 4 13 15
output
13 2
input
17 5
0 2 4 13 14
output
-1
input
5 3
1 2 3
output
3 4

题意：给定n,m和序列a，构造一个等差数列，使得它所有元素%m之后重排能够变成a，输出首项和公差
题解：

先考虑2*n<=m的情况

考虑a中的两个元素之差，假设它们在最后序列的位置为i,i+k，那么它们之差为k*d%m

由于保证2*n<=m所以这样的差只会出现n-k次，nlogn统计这个差出现的次数，于是我们就求出了k，从而求出了d，然后check即可

因为差最大的两组数是(s[1],s[n]),(s[1],s[n-1]) 差之和为(2n-3)*d 如果2n-3溢出了m,那么就会存在两个差，它们之和%m=0，就会多统计 否则没有两个差%m=0，就能保证之前的性质了

如果2*n>m

之前提到的差不会只出现n-k次，因为可能经过多遍，

那么把m内a的补集做一次，然后首项加上公差*项数即可（保证m是质数）

因为d与m互质，m个以内的等差数不会相同，所以只要给出的能等差，接上补集也能是等差（因为都不会相同），

反过来，如果补集是等差，那么剩下的也能是

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>

using namespace std;

long long m;
long long n;

long long a[100005];
long long b[100005];

long long ans,ansd;

long long powd(long long aa,long long bb)
{
    long long anss=1;
    while(bb>0)
    {
        if(bb%2==1)
        {
            anss=anss*aa%m;
        }
        aa=aa*aa%m;
        bb/=2;
    }
    return anss;
}

bool fd(long long* c,long long tar,int len)
{
    int id=lower_bound(c+1,c+len+1,tar)-c;
    return c[id]==tar;
}

void solve(long long* c,int len,long long dis)
{
    int cnt=0;
    for(int i=1;i<=len;i++)
    {
        cnt+=fd(c,(c[i]+dis)%m,len);
    }
    long long k=len-cnt;

    ansd=dis*powd(k,m-2)%m;

    //cout<<ansd<<" : "<<k<<endl;
    ans=-1;
    for(int i=1;i<=len;i++)
    {
        if(fd(c,(c[i]-ansd+m)%m,len)==0)
        {
            if(ans==-1)
            {
                ans=c[i];
            }
            else
            {
                ans=-1;
                return;
            }
        }
    }
    return;
}

int main()
{
    while(~scanf("%lld%lld",&m,&n))
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%lld",&a[i]);
        }

        sort(a+1,a+1+n);

        if(n==1)
        {
            printf("%lld 0\n",a[1]);
            return 0;
        }
        else if(n==2 || n==m)
        {
            printf("%lld %lld\n",a[1],(a[2]-a[1]+m)%m);
            return 0;
        }
        else
        {
            if(2*n < m)
            {
                long long dis=(a[2]-a[1]+m)%m;
                solve(a,n,dis);
                if(ans!=-1)
                {
                    printf("%lld %lld\n",ans,ansd);
                }
                else
                {
                    printf("-1\n");
                }
            }
            else
            {
                int t=1;
                for(long long i=0;i<m;i++)
                {
                    if(fd(a,i,n)==0)
                    {
                        b[t]=i;
                        t++;
                    }
                }
                t--;
                sort(b+1,b+1+t);
                if(t==1)
                {
                    printf("%lld %lld\n",a[1],(a[1]-b[1]+m)%m);
                    return 0;
                }
                else if(t==2)
                {
                    ansd=(b[2]-b[1]+m)%m;
                    printf("%lld %lld\n",(b[2]+ansd)%m,ansd);
                    return 0;
                }
                else
                {
                    solve(b,t,(b[2]-b[1]+m)%m);
                    if(ans!=-1)
                    {
                        printf("%lld %lld\n",(ans+ansd*t%m)%m,ansd);
                    }
                    else
                    {
                        printf("-1\n");
                    }
                }
            }
        }
    }
}