Find number of solutions of a linear equation of n variables - GeeksforGeeks

05 Jan, 2022
Given a linear equation of n variables, find number of non-negative integer solutions of it. For example, let the given equation be “x + 2y = 5”, solutions of this equation are “x = 1, y = 2”, “x = 5, y = 0” and “x = 3, y = 1”. It may be assumed that all coefficients in given equation are positive integers.Example :  
Input:  coeff[] = {1, 2}, rhs = 5
Output: 3
The equation "x + 2y = 5" has 3 solutions.
(x=3,y=1), (x=1,y=2), (x=5,y=0)

Input:  coeff[] = {2, 2, 3}, rhs = 4
Output: 3
The equation "2x + 2y + 3z = 4"  has 3 solutions.
(x=0,y=2,z=0), (x=2,y=0,z=0), (x=1,y=1,z=0)
We strongly recommend you to minimize your browser and try this yourself first.We can solve this problem recursively. The idea is to subtract first coefficient from rhs and then recur for remaining value of rhs. 
If rhs = 0
  countSol(coeff, 0, rhs, n-1) = 1
Else
  countSol(coeff, 0, rhs, n-1) = ∑countSol(coeff, i, rhs-coeff[i], m-1) 
                                 where coeff[i]<=rhs and 
                                 i varies from 0 to n-1                             
Below is recursive implementation of above solution. 
C++
Java
Python3
C#
PHP
Javascript
// A naive recursive C++ program to// find number of non-negative solutions// for a given linear equation#include<bits/stdc++.h>using namespace std; // Recursive function that returns// count of solutions for given rhs// value and coefficients coeff[start..end]int countSol(int coeff[], int start,             int end, int rhs){    // Base case    if (rhs == 0)    return 1;     // Initialize count    // of solutions    int result = 0;     // One by subtract all smaller or    // equal coefficiants and recur    for (int i = start; i <= end; i++)    if (coeff[i] <= rhs)        result += countSol(coeff, i, end,                           rhs - coeff[i]);     return result;} // Driver Codeint main(){    int coeff[] = {2, 2, 5};    int rhs = 4;    int n = sizeof(coeff) / sizeof(coeff[0]);    cout << countSol(coeff, 0, n - 1, rhs);    return 0;}
// A naive recursive Java program// to find number of non-negative// solutions for a given linear equationimport java.io.*; class GFG{             // Recursive function that returns    // count of solutions for given    // rhs value and coefficients coeff[start..end]    static int countSol(int coeff[], int start,                        int end, int rhs)    {        // Base case        if (rhs == 0)        return 1;             // Initialize count of solutions        int result = 0;             // One by subtract all smaller or        // equal coefficiants and recur        for (int i = start; i <= end; i++)        if (coeff[i] <= rhs)            result += countSol(coeff, i, end,                               rhs - coeff[i]);             return result;    }         // Driver Code    public static void main (String[] args)    {        int coeff[] = {2, 2, 5};        int rhs = 4;        int n = coeff.length;        System.out.println (countSol(coeff, 0,                                     n - 1, rhs));                 }} // This code is contributed by vt_m.
# A naive recursive Python program# to find number of non-negative# solutions for a given linear equation # Recursive function that returns# count of solutions for given rhs# value and coefficients coeff[stat...end]def countSol(coeff, start, end, rhs):     # Base case    if (rhs == 0):        return 1     # Initialize count of solutions    result = 0     # One by one subtract all smaller or    # equal coefficients and recur    for i in range(start, end+1):        if (coeff[i] <= rhs):            result += countSol(coeff, i, end,                               rhs - coeff[i])     return result # Driver Codecoeff = [2, 2, 5]rhs = 4n = len(coeff)print(countSol(coeff, 0, n - 1, rhs)) # This code is contributed# by Soumen Ghosh
// A naive recursive C# program// to find number of non-negative// solutions for a given linear equationusing System; class GFG{             // Recursive function that    // returns count of solutions    // for given RHS value and    // coefficients coeff[start..end]    static int countSol(int []coeff, int start,                        int end, int rhs)    {        // Base case        if (rhs == 0)        return 1;             // Initialize count of solutions        int result = 0;             // One by subtract all smaller or        // equal coefficiants and recur        for (int i = start; i <= end; i++)        if (coeff[i] <= rhs)            result += countSol(coeff, i, end,                               rhs - coeff[i]);             return result;    }         // Driver Code    public static void Main ()    {        int []coeff = {2, 2, 5};        int rhs = 4;        int n = coeff.Length;        Console.Write (countSol(coeff, 0,                                n - 1, rhs));                 }} // This Code is contributed// by nitin mittal.
<?php// A naive recursive PHP program to// find number of non-negative solutions// for a given linear equation // Recursive function that returns count// of solutions for given rhs value and// coefficients coeff[start..end] function countSol($coeff, $start, $end, $rhs){    // Base case    if ($rhs == 0)    return 1;     // Initialize count of solutions    $result = 0;     // One by subtract all smaller or    // equal coefficiants and recur    for ($i = $start; $i <= $end; $i++)    if ($coeff[$i] <= $rhs)        $result += countSol($coeff, $i, $end,                            $rhs - $coeff[$i]);     return $result;} // Driver Code$coeff = array (2, 2, 5);$rhs = 4;$n = sizeof($coeff);echo countSol($coeff, 0, $n - 1, $rhs); // This code is contributed by ajit?>
<script>     // A naive recursive Javascript program    // to find number of non-negative    // solutions for a given linear equation         // Recursive function that    // returns count of solutions    // for given RHS value and    // coefficients coeff[start..end]    function countSol(coeff, start, end, rhs)    {        // Base case        if (rhs == 0)            return 1;               // Initialize count of solutions        let result = 0;               // One by subtract all smaller or        // equal coefficiants and recur        for (let i = start; i <= end; i++)          if (coeff[i] <= rhs)              result += countSol(coeff, i, end, rhs - coeff[i]);               return result;    }         let coeff = [2, 2, 5];    let rhs = 4;    let n = coeff.length;    document.write(countSol(coeff, 0, n - 1, rhs));     </script>
Output : 
3
The time complexity of above solution is exponential. We can solve this problem in Pseudo Polynomial Time (time complexity is dependent on numeric value of input) using Dynamic Programming. The idea is similar to Dynamic Programming solution Subset Sum problem. Below is Dynamic Programming based implementation. 
C++
Java
Python3
C#
PHP
Javascript
// A Dynamic programming based C++// program to find number of non-negative// solutions for a given linear equation#include<bits/stdc++.h>using namespace std; // Returns count of solutions for// given rhs and coefficients coeff[0..n-1]int countSol(int coeff[], int n, int rhs){    // Create and initialize a table    // to store results of subproblems    int dp[rhs + 1];    memset(dp, 0, sizeof(dp));    dp[0] = 1;     // Fill table in bottom up manner    for (int i = 0; i < n; i++)    for (int j = coeff[i]; j <= rhs; j++)        dp[j] += dp[j - coeff[i]];     return dp[rhs];} // Driver Codeint main(){    int coeff[] = {2, 2, 5};    int rhs = 4;    int n = sizeof(coeff) / sizeof(coeff[0]);    cout << countSol(coeff, n, rhs);    return 0;}
// A Dynamic programming based Java program// to find number of non-negative solutions// for a given linear equationimport java.util.Arrays; class GFG{    // Returns counr of solutions for given    // rhs and coefficients coeff[0..n-1]    static int countSol(int coeff[],                        int n, int rhs)    {                 // Create and initialize a table to        // store results of subproblems        int dp[] = new int[rhs + 1];        Arrays.fill(dp, 0);        dp[0] = 1;             // Fill table in bottom up manner        for (int i = 0; i < n; i++)        for (int j = coeff[i]; j <= rhs; j++)            dp[j] += dp[j - coeff[i]];             return dp[rhs];    }         // Driver code    public static void main (String[] args)    {        int coeff[] = {2, 2, 5};        int rhs = 4;        int n = coeff.length;        System.out.print(countSol(coeff, n, rhs));    }} // This code is contributed by Anant Agarwal
# A Dynamic Programming based# Python program to find number# of non-negative solutions for# a given linear equation # Returns count of solutions for given# rhs and coefficients coeff[0...n-1]def countSol(coeff, n, rhs):     # Create and initialize a table    # to store results of subproblems    dp = [0 for i in range(rhs + 1)]    dp[0] = 1     # Fill table in bottom up manner    for i in range(n):        for j in range(coeff[i], rhs + 1):            dp[j] += dp[j - coeff[i]]     return dp[rhs] # Driver Codecoeff = [2, 2, 5]rhs = 4n = len(coeff)print(countSol(coeff, n, rhs)) # This code is contributed# by Soumen Ghosh
// A Dynamic programming based// C# program to find number of// non-negative solutions for a// given linear equationusing System; class GFG{    // Returns counr of solutions    // for given rhs and coefficients    // coeff[0..n-1]    static int countSol(int []coeff,                        int n, int rhs)    {                 // Create and initialize a        // table to store results        // of subproblems        int []dp = new int[rhs + 1];                 // Arrays.fill(dp, 0);        dp[0] = 1;             // Fill table in        // bottom up manner        for (int i = 0; i < n; i++)        for (int j = coeff[i]; j <= rhs; j++)            dp[j] += dp[j - coeff[i]];             return dp[rhs];    }         // Driver code    public static void Main ()    {        int []coeff = {2, 2, 5};        int rhs = 4;        int n = coeff.Length;        Console.Write(countSol(coeff,                               n, rhs));    }} // This code is contributed// by shiv_bhakt.
<?php// PHP program to find number of// non-negative solutions for a// given linear equation // Returns count of solutions// for given rhs and coefficients// coeff[0..n-1]function countSol($coeff, $n, $rhs){    // Create and initialize a table    // to store results of subproblems    $dp = str_repeat ("\0", 256);    $dp[0] = 1;         // Fill table in    // bottom up manner    for ($i = 0; $i < $n; $i++)    for ($j = $coeff[$i];         $j <= $rhs; $j++)        $dp[$j] = $dp[$j] + ($dp[$j -                             $coeff[$i]]);     return $dp[$rhs];} // Driver Code$coeff = array(2, 2, 5);$rhs = 4; // $n = count($coeff);$n = sizeof($coeff) / sizeof($coeff[0]);echo countSol($coeff, $n, $rhs); // This code is contributed// by shiv_bhakt.?>
<script>     // A Dynamic programming based    // Javascript program to find number of    // non-negative solutions for a    // given linear equation         // Returns counr of solutions    // for given rhs and coefficients    // coeff[0..n-1]    function countSol(coeff, n, rhs)    {                  // Create and initialize a        // table to store results        // of subproblems        let dp = new Array(rhs + 1);        dp.fill(0);                  // Arrays.fill(dp, 0);        dp[0] = 1;              // Fill table in        // bottom up manner        for (let i = 0; i < n; i++)        for (let j = coeff[i]; j <= rhs; j++)            dp[j] += dp[j - coeff[i]];              return dp[rhs];    }         let coeff = [2, 2, 5];    let rhs = 4;    let n = coeff.length;    document.write(countSol(coeff, n, rhs));     </script>
Output : 
3
Time Complexity of above solution is O(n * rhs)This article is contributed by Ashish Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
nitin mittal
jit_t
Vishal_Khoda
ManasChhabra2
decode2207
rameshtravel07
abhishekvk100
permutation
Dynamic Programming
Mathematical
Dynamic Programming
Mathematical
permutation
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Travelling Salesman Problem | Set 1 (Naive and Dynamic Programming)
Longest Palindromic Substring | Set 1
Subset Sum Problem | DP-25
C++ Data Types
Write a program to print all permutations of a given string
Set in C++ Standard Template Library (STL)
Program to find GCD or HCF of two numbers
Merge two sorted arrays