趣味演算法：返回完全冪的絕對差

BingWay原創作品，轉載請註明作者和出處。
之前寫過一篇趣味演算法，返回不重複數，引得園子裡很多演算法高手技癢，我看到的關於返回不重複數的文章有好幾篇。這使我更堅信，園子是個很好的技術交流平台。前兩天又寫了一道演算法，原題是英文的，本人英文不是太好，初步翻譯了一下，效果自認為還過得去，但怕翻譯出來誤導了大家，特請坤坤和他那邊的英語牛人幫忙翻譯，在此，我要特別感謝他們。好了，廢話少說，上題目：原：A number is called a perfect power if it can be written in the form m^k, where m and k are positive integers, and k > 1. Given two positive integers A and B, find the two perfect powers between A and B, inclusive, that are closest to each other, and return the absolute difference between them. If less than two perfect powers exist in the interval, return -1 instead.A will be between 1 and 10^18, inclusive.B will be between A+1 and 10^18, inclusive.譯：如果一個數是以m^k這種格式，當m和k都是正整數，而且k大於1，這個數就可以被稱為完全冪。給出兩個正整數A和B，發現兩個完全冪包含在A和B之間，而且這兩個數字最接近。並返回一個他們之間的絕對差。如果在區間記憶體在的完全冪小於兩個，就返回-1.A的範圍是1至10^18，B的範圍是A+1至10^18。測試資料：1,4                           Returns: 38,9                           Returns: 1(1是完全冪)10,15                      Returns: -11,1000000000000000000         Returns: 1 (最大測試範圍)80000,90000                   Returns: 80測試資料及返回結果有一定的規律，看看哪位能找出運算規律。我的演算法：演算法
        static long INF = 2000000000000000000;
        static long nearestCouple(long A, long B)
        {
            long res = INF;
            List<long> all = new List<long>();
            if(B == A + 1)
            {
                 return  res=1;
            }
            for (int k = 2; ; ++k)
            {
                long left = Math.Abs(root(A, k)); //返回絕對值
                long right = Math.Abs(root(B + 1, k)) - 1;
                if (right < 2)
                    break;
                if (k == 2)
                {
                    if (left < right)
                    {
                        res = Math.Min(res, 2 * left + 1);
                    }
                    continue;
                }
                for (long x = left; x <= right; ++x)
                {
                    long v = pow(x, k);
                    if (v < A || v > B)
                        throw new Exception();
                    all.Add(v);
                    long u = Math.Abs(root(v, 2));
                    long u2 = pow(u, 2);
                    long uu2 = pow(Math.Max(1, u - 1), 2);
                    long uuu2 = pow(u + 1, 2);
                    if (u2 > A && u2 < B && u2 != v)
                        res = Math.Min(res, Math.Abs(u2 - v));
                    if (uu2 > A && uu2 < B && uu2 != v)
                        res = Math.Min(res, Math.Abs(uu2 - v));
                    if (uuu2 > A && uuu2 < B && uuu2 != v)
                        res = Math.Min(res, Math.Abs(uuu2 - v));
                }
            }
            all.Sort();
            for (int i = 0; i < all.Count - 1; ++i)
                if (all[i] != all[i + 1])
                    res = Math.Min(res, Math.Abs(all[i] - all[i + 1]));//得到絕對差
            return res == INF ? -1 : res;//判斷是否小於完全冪，小於完全冪返回-1，否則返回res
        }
        static long root(long n, long p)
        {
            long z = Math.Max(1, (long)Math.Pow(n, 1.0 / p) - 2);//比較返回較大的數
            while (pow(z, p) < n)//z的p次冪是否小於n
            {
                ++z;
            }
            if (pow(z, p) > n)
            {
                return -z;
            }
            else
                return z;

        }
        static long pow(long a, long k)
        {
            if (k == 0)
            {
                 return 1;
            }
            else if (k % 2 == 0)
            {
                long z = pow(a, k / 2);
                return mul(z, z);
            }
            else
            {
                return mul(a, pow(a, k - 1));
            }

        }
        static long mul(long a, long b)
        {
            if (INF / a < b)
                return INF;
            else
                return a * b;
         }