大整数的模到大整数的幂 c#

如何解决大整数的模到大整数的幂 c#

我们在 uni 被分配了一项任务，为他编写的一个大整数类的幂模 ((b^p) mod m) 编写一个算法。 测试用例之一是 正文：3268740452599842251800072850 电源：10728788472479767015096759639 模组：3425216029116239798519821463 有可能吗？

我的代码适用于较小的测试用例，但在这种情况下很挣扎。

起初我得到堆栈溢出错误，因为我调用递归函数太多

我试图使它尾递归，但我想我不确定

但现在它不输出大测试用例的答案所以我写了一个 console.writeline()

要知道还剩下多少步才能完成计算 我得到了 1072878847247976701509675793，它以每秒 1 次的速度移动

那是示例测试用例文件，还有一个更大的 我在这里做错了什么？ 我的代码：

public static BigInteger ModOfP(BigInteger B,BigInteger P,BigInteger M)
        {
            int lenb = B.GetDigitsCount(),lenm = M.GetDigitsCount();
            BigInteger q = new BigInteger(new byte[lenb]);
            BigInteger r = new BigInteger(new byte[lenm]);

            var gg = new Tuple<BigInteger,BigInteger>(q,r);
            var ez = new Tuple<BigInteger,r);


            if (P.Equals(zero))
            {

                return one;
            }
            else if (P.Equals(one))
            {

                return B;

            }
            else if (BigInteger.Is_Even(P))
            {

                ez = DivMod(P,two);
                gg = DivMod(ModOfP(B*B,ez.Item1,M),M);               
                return gg.Item2;

            }
            else
            {

                ez = DivMod(P-one,two);
                gg = DivMod(B * ModOfP(B*B,M);
                return gg.Item2;
            }
        }

        public static int Bounce(BigInteger B,BigInteger M,BigInteger T)
        {
            int lenb = B.GetDigitsCount(),r);
            Console.WriteLine("T:  " + T.Number_getter());
            if (T.Equals(zero))
            {
                return 0;
            }


            else
            {

                BigInteger.safe2 = BigInteger.safe2* ModOfP(B,P,M);               
                return Bounce(B,M,T - one);
            }
        }

 public static Tuple<BigInteger,BigInteger> DivMod(BigInteger A,BigInteger B)
        {
            int lena = A.GetDigitsCount(),lenb = B.GetDigitsCount();
            BigInteger q = new BigInteger(new byte[lena]);
            BigInteger r = new BigInteger(new byte[lenb]);

            if (A.CompareTo(B) == -1)
            {

                return Tuple.Create(zero,A);
            }

            var gg = new Tuple<BigInteger,r);

            
            gg = DivMod(A,B+B);            
            gg = new Tuple<BigInteger,BigInteger>(gg.Item1 + gg.Item1,gg.Item2);
            if (gg.Item2.CompareTo(B) == -1)
            {

                return gg;
            }
            else
            {
                return Tuple.Create(gg.Item1 + one,gg.Item2 - B);
            }
        }

        

        //====================
        //Your Code is Here:
        //===================
        /// <summary>
        /// TODO: Write an efficient algorithm that calculates Mod of Power
        /// The function should calculates the result of the equation (B ^ P) mod M
        /// </summary>
        /// <param name="B">the base,non-negative BigInteger</param>
        /// <param name="P">the exponent,non-negative BigInteger</param>
        /// <param name="M">the modulus value,positive BigInteger</param>
        /// <returns>BigInteger,The result of (B ^ P) mod M</returns>
        public static BigInteger ModOfPower(BigInteger B,lenm = M.GetDigitsCount();
            BigInteger q = new BigInteger(new byte[lenb]);
            BigInteger r = new BigInteger(new byte[lenm]);
            BigInteger.safe2 = new BigInteger(new byte[] { 1 });

            var gg = new Tuple<BigInteger,r);
            gg = DivMod(P,BigInteger.limit);
            Console.WriteLine("gg 0: " + gg.Item1.Number_getter());
            Console.WriteLine("gg: " + gg.Item2.Number_getter());
            if (B.Equals(zero))
            {
                return zero;
            }


            Bounce(B,BigInteger.limit,gg.Item1);
            gg =DivMod(BigInteger.safe2* ModOfP(B,gg.Item2,M);

            return gg.Item2;
        }