Problem:
Score : 300 points

Problem Statement

There is a circular pond with a perimeter of K meters, and N houses around them.

The i-th house is built at a distance of A_i meters from the northmost point of the pond, measured clockwise around the pond.

When traveling between these houses, you can only go around the pond.

Find the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses.

Constraints

2 \leq K \leq 10^6

2 \leq N \leq 2 \times 10^5

0 \leq A_1 < ... < A_N < K

All values in input are integers.

Input

Input is given from Standard Input in the following format:

K N
A_1 A_2 ... A_N

Output

Print the minimum distance that needs to be traveled when you start at one of the houses and visit all the N houses.

Sample Input 1

20 3
5 10 15

Sample Output 1

10

If you start at the 1-st house and go to the 2-nd and 3-rd houses in this order, the total distance traveled will be 10.

Sample Input 2

20 3
0 5 15

Sample Output 2

10

If you start at the 2-nd house and go to the 1-st and 3-rd houses in this order, the total distance traveled will be 10.

Solution in C# (Mono 4.6.2.0) (judge verdict: Accepted)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Diagnostics;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading.Tasks;
using System.Numerics;
using System.IO;
using System.Runtime.InteropServices;
using static System.Math;
using static Math2;
using static io;
using static utils;


class Program
{
    static void Main(string[] args)
    {
        var wrong_answer = new wrong_answer();
        wrong_answer.Solve();
    }
}

public class wrong_answer
{
    const int INF = 1 << 29;
    const long INFL = 1L << 60;
    const int MOD = 1000000007;
    const int MOD2 = 998244353;



    public void Solve()
    {
        var o = intm;
        var a = intm;
        var b = new int[o[1]];
        for (int i = 0; i < o[1] - 1; ++i)
        {
            b[i] = Abs(a[i] - a[i + 1]);
        }
        b[o[1] - 1] = o[0] - b.Sum();
        write(o[0] - b.Max());
    }


}




public static class utils
{
    public static void swap<T>(ref T a, ref T b)
    {
        T x = a;
        a = b;
        b = x;
    }
    public static int digitsum(int n)
    {
        string s = n.ToString();
        int ret = 0;
        for (int i = 0; i < s.Length; ++i) ret += s[i] - '0';
        return ret;
    }
    public static int[] zaaku(long[] a)
    {
        var dic = new Dictionary<long, int>();
        long[] ar = new long[a.Length];
        a.CopyTo(ar, 0);
        Array.Sort(ar);
        int z = 0;
        foreach (var x in ar)
        {
            if (!dic.ContainsKey(x))
                dic[x] = z++;
        }
        return a.Select(c => dic[c]).ToArray();
    }

    public static int[] getranking(long[] A)
    {
        var dic = new Dictionary<long, int>();
        A.OrderByDescending(_ => _).Where(w => !dic.ContainsKey(w)).Select((x, i) => dic[x] = i + 1).ToList();
        return A.Select(i => dic[i]).ToArray();
    }
    public static List<Tuple<T, int>> compress<T>(T[] A) where T : IComparable
    {
        int i = 0;
        var ret = new List<Tuple<T, int>>();
        while (i < A.Length)
        {
            T x = A[i];
            int num = 0;
            while (i < A.Length && x.CompareTo(A[i]) == 0)
            {
                num++;
                i++;
            }
            ret.Add(new Tuple<T, int>(x, num));
        }
        return ret;
    }
}

public static class Math2
{
    public static long pow(long i, long n, long MOD = 1000000007)
    {
        long res = 1;
        while (n > 0)
        {
            if ((n & 1) != 0) res = res * i % MOD;
            i = i * i % MOD;
            n >>= 1;
        }
        return res;
    }
    public static int pow(int i, int n, int MOD = 1000000007)
    {
        int res = 1;
        while (n > 0)
        {
            if ((n & 1) != 0) res = res * i % MOD;
            i = i * i % MOD;
            n >>= 1;
        }
        return res;
    }

    public static long gcd(long i, long y)
    {
        while (y != 0)
        {
            var r = i % y;
            i = y;
            y = r;
        }
        return i;
    }
    public static long comb(long n, long r, int MOD = 1000000007)
    {
        long ret = 1;
        long x = 1;
        for (long i = n; i >= n - r + 1; --i)
        {
            ret = ret / x * i;
            ret %= MOD;
            x++;
        }
        return ret;
    }

    public static long lcm(long i, long y)
    {
        return i * y / gcd(i, y);
    }


    public static Dictionary<long, int> primefactorization(long N)
    {

        var ret = new Dictionary<long, int>();

        for (long i = 2; i * i <= N; ++i)
        {
            int cnt = 0;
            while (N % i == 0)
            {
                cnt++;
                N /= i;
            }
            if (cnt != 0) ret[i] = cnt;

        }
        if (N >= 2) ret[N] = 1;

        return ret;

    }

    public static List<long> divisorenumrate(long N)
    {
        var ret = new List<long>();

        for (long i = 1; i * i <= N; ++i)
        {

            if (N % i == 0)
            {
                ret.Add(i);
                ret.Add(N / i);
            }

        }

        return ret;

    }

    public static void swap<T>(ref T a, ref T b)
    {
        var i = a;
        a = b;
        b = i;
    }
    public static void chmin<T>(ref T a, T b) where T : IComparable
    {
        if (a.CompareTo(b) > 0) a = b;
    }
    public static void chmax<T>(ref T a, T b) where T : IComparable
    {
        if (a.CompareTo(b) < 0) a = b;
    }

}

public static class io
{
    //in
    public static string str => Console.ReadLine();

    public static string[] strm => str.Split(' ');

    public static long[] longm => strm.Select(long.Parse).ToArray();
    public static int[] intm => strm.Select(int.Parse).ToArray();
    public static char[] charm => str.ToArray();
    public static double[] doublem => strm.Select(double.Parse).ToArray();
    public static long long1 => longm[0];
    public static int int1 => intm[0];
    public static char char1 => charm[0];
    public static double double1 => doublem[0];
    public static long[] horizontalread(int N) { long[] A = new long[N]; for (int i = 0; i < N; ++i) A[i] = long1; return A; }
    public static void write(string a) => Console.WriteLine(a);
    public static void write(params object[] i) => write(string.Join(" ", i));
    public static void write<T>(IEnumerable<T> a) => write(string.Join(" ", a));
    public static void horizontalwrite<T>(IEnumerable<T> a) { foreach (var z in a) write(z); }
    public static void yn(bool i) { if (i) write("Yes"); else write("No"); }

}