C / C++程序用于模块化方程的解数

给定A和B，任务是找到X可以采用的可能值的数量，以使给定的模块化方程(A mod X)= B成立。在此，X也称为模块化方程式的解。

例子：

Input : A = 26, B = 2
Output : 6
Explanation
X can be equal to any of {3, 4, 6, 8,
12, 24} as A modulus any of these values
equals 2 i. e., (26 mod 3) = (26 mod 4) 
= (26 mod 6) = (26 mod 8) = .... = 2 

Input : 21 5
Output : 2
Explanation
X can be equal to any of {8, 16} as A modulus 
any of these values equals 5 i.e. (21 mod 
8) = (21 mod 16) = 5

如果我们仔细分析方程式A mod X = B，则很容易注意到，如果(A = B)，那么X可以取无穷多个比A大的值。在(A B)时间，因此现在我们深入研究此案例。

现在，在这种情况下，我们可以使用一个众所周知的关系，即

Dividend = Divisor * Quotient + Remainder

我们正在寻找所有可能的X即除数，给定A即股息，而B即余数。所以，

We can say,
A = X * Quotient + B

Let Quotient be represented as Y
∴ A = X * Y + B
A - B = X * Y

∴ To get integral values of Y, 
we need to take all X such that X divides (A - B)

∴ X is a divisor of (A - B)

因此，问题减少到找到(A – B)的除数，并且这样的除数的数量就是X可以取的可能值。
但是，我们知道A mod X会产生从(0到X – 1)的值，我们必须取所有这样的X使得X>B。

因此，我们可以得出结论：(A – B)的除数大于B是X满足A mod X = B所需的所有可能值。

/* C++ Program to find number of possible 
   values of X to satisfy A mod X = B */
#include 
using namespace std;
  
/* Returns the number of divisors of (A - B)
   greater than B */
int calculateDivisors(int A, int B)
{
    int N = (A - B);
    int noOfDivisors = 0;
  
    for (int i = 1; i <= sqrt(N); i++) {
  
        // if N is divisible by i
        if ((N % i) == 0) {
  
            // count only the divisors greater than B
            if (i > B)
                noOfDivisors++;
  
            // checking if a divisor isnt counted twice
            if ((N / i) != i && (N / i) > B)
                noOfDivisors++;
        }
    }
  
    return noOfDivisors;
}
  
/* Utility function to calculate number of all 
   possible values of X for which the modular 
   equation holds true */
int numberOfPossibleWaysUtil(int A, int B)
{
  
    /* if A = B there are infinitely many solutions
       to equation  or we say X can take infinitely
       many values > A. We return -1 in this case */
    if (A == B)
        return -1;
  
    /* if A < B, there are no possible values of 
       X satisfying the equation */
    if (A < B)
        return 0;
  
    /* the last case is when A > B, here we calculate
       the number of divisors of (A - B), which are 
       greater than B */
    int noOfDivisors = 0;
    noOfDivisors = calculateDivisors(A, B);
    return noOfDivisors;
}
  
/* Wrapper function for numberOfPossibleWaysUtil() */
void numberOfPossibleWays(int A, int B)
{
    int noOfSolutions = numberOfPossibleWaysUtil(A, B);
  
    // if infinitely many solutions available
    if (noOfSolutions == -1) {
        cout << "For A = " << A << " and B = " << B
             << ", X can take Infinitely many values"
                " greater than "
             << A << "\n";
    }
  
    else {
        cout << "For A = " << A << " and B = " << B
             << ", X can take " << noOfSolutions
             << " values\n";
    }
}
  
// Driver code
int main()
{
    int A = 26, B = 2;
    numberOfPossibleWays(A, B);
    A = 21, B = 5;
    numberOfPossibleWays(A, B);
    return 0;
}

输出：

For A = 26 and B = 2, X can take 6 values
For A = 21 and B = 5, X can take 2 values

上述方法的时间复杂度不过是找到(A – B)除数的时间复杂度，即O(√(A – B))

有关更多详细信息，请参阅关于模块化方程的解数的完整文章！

想要从精选的最佳视频中学习和练习问题，请查看《基础知识到高级C的C基础课程》。