Related Articles

# Find initial integral solution of Linear Diophantine equation if finite solution exists

• Difficulty Level : Medium
• Last Updated : 27 Sep, 2021

Given three integers a, b, and c representing a linear equation of the form: ax + by = c. The task is to find the initial integral solution of the given equation if a finite solution exists.

A Linear Diophantine equation (LDE) is an equation with 2 or more integer unknowns and the integer unknowns are each to at most degree of 1. Linear Diophantine equation in two variables takes the form of ax+by=c, where x,y are integer variables and a, b, c are integer constants. x and y are unknown variables.

Examples:

Input: a = 4, b = 18, c = 10
Output: x = -20, y = 5

Explanation: (-20)*4 + (5)*18 = 10

Input: a = 9, b = 12, c = 5
Output: No Solutions exists

Approach:

1. First, check if a and are non-zero.
2. If both of them are zero and c is non-zero then, no solution exists. If c is also zero then infinite solution exits.
3. For given a and b, calculate the value of x1, y1, and gcd using Extended Euclidean Algorithm.
4. Now, for a solution to existing gcd(a, b) should be multiple of c.
5. Calculate the solution of the equation as follows:
```x = x1 * ( c / gcd )
y = y1 * ( c / gcd )```

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to implement the extended``// euclid algorithm``int` `gcd_extend(``int` `a, ``int` `b,``               ``int``& x, ``int``& y)``{``    ``// Base Case``    ``if` `(b == 0) {``        ``x = 1;``        ``y = 0;``        ``return` `a;``    ``}` `    ``// Recursively find the gcd``    ``else` `{``        ``int` `g = gcd_extend(b,``                           ``a % b, x, y);``        ``int` `x1 = x, y1 = y;``        ``x = y1;``        ``y = x1 - (a / b) * y1;``        ``return` `g;``    ``}``}` `// Function to print the solutions of``// the given equations ax + by = c``void` `print_solution(``int` `a, ``int` `b, ``int` `c)``{``    ``int` `x, y;``    ``if` `(a == 0 && b == 0) {` `        ``// Condition for infinite solutions``        ``if` `(c == 0) {``            ``cout``                ``<< ``"Infinite Solutions Exist"``                ``<< endl;``        ``}` `        ``// Condition for no solutions exist``        ``else` `{``            ``cout``                ``<< ``"No Solution exists"``                ``<< endl;``        ``}``    ``}``    ``int` `gcd = gcd_extend(a, b, x, y);` `    ``// Condition for no solutions exist``    ``if` `(c % gcd != 0) {``        ``cout``            ``<< ``"No Solution exists"``            ``<< endl;``    ``}``    ``else` `{` `        ``// Print the solution``        ``cout << ``"x = "` `<< x * (c / gcd)``             ``<< ``", y = "` `<< y * (c / gcd)``             ``<< endl;``    ``}``}` `// Driver Code``int` `main(``void``)``{``    ``int` `a, b, c;` `    ``// Given coefficients``    ``a = 4;``    ``b = 18;``    ``c = 10;` `    ``// Function Call``    ``print_solution(a, b, c);``    ``return` `0;``}`

## Java

 `// Java program for the above approach``class` `GFG{` `static` `int` `x, y;` `// Function to implement the extended``// euclid algorithm``static` `int` `gcd_extend(``int` `a, ``int` `b)``{``    ` `    ``// Base Case``    ``if` `(b == ``0``)``    ``{``        ``x = ``1``;``        ``y = ``0``;``        ``return` `a;``    ``}` `    ``// Recursively find the gcd``    ``else``    ``{``        ``int` `g = gcd_extend(b, a % b);``        ``int` `x1 = x, y1 = y;``        ``x = y1;``        ``y = x1 - (a / b) * y1;``        ``return` `g;``    ``}``}` `// Function to print the solutions of``// the given equations ax + by = c``static` `void` `print_solution(``int` `a, ``int` `b, ``int` `c)``{``    ``if` `(a == ``0` `&& b == ``0``)``    ``{``        ` `        ``// Condition for infinite solutions``        ``if` `(c == ``0``)``        ``{``            ``System.out.print(``"Infinite Solutions "` `+``                             ``"Exist"` `+ ``"\n"``);``        ``}` `        ``// Condition for no solutions exist``        ``else``        ``{``            ``System.out.print(``"No Solution exists"` `+``                             ``"\n"``);``        ``}``    ``}``    ``int` `gcd = gcd_extend(a, b);` `    ``// Condition for no solutions exist``    ``if` `(c % gcd != ``0``)``    ``{``        ``System.out.print(``"No Solution exists"` `+ ``"\n"``);``    ``}``    ``else``    ``{``        ` `        ``// Print the solution``        ``System.out.print(``"x = "` `+ x * (c / gcd) +``                       ``", y = "` `+ y * (c / gcd) + ``"\n"``);``    ``}``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `a, b, c;` `    ``// Given coefficients``    ``a = ``4``;``    ``b = ``18``;``    ``c = ``10``;` `    ``// Function Call``    ``print_solution(a, b, c);``}``}` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program for the above approach``import` `math` `x, y ``=` `0``, ``0``  ` `# Function to implement the extended``# euclid algorithm``def` `gcd_extend(a, b):``    ``global` `x, y``    ` `    ``# Base Case``    ``if` `(b ``=``=` `0``):``        ``x ``=` `1``        ``y ``=` `0``        ``return` `a``  ` `    ``# Recursively find the gcd``    ``else``:``        ``g ``=` `gcd_extend(b, a ``%` `b)``        ``x1, y1 ``=` `x, y``        ``x ``=` `y1``        ``y ``=` `x1 ``-` `math.floor(a ``/` `b) ``*` `y1``        ``return` `g``  ` `# Function to prlet the solutions of``# the given equations ax + by = c``def` `print_solution(a, b, c):``    ``if` `(a ``=``=` `0` `and` `b ``=``=` `0``):``      ` `        ``# Condition for infinite solutions``        ``if` `(c ``=``=` `0``):``            ``print``(``"Infinite Solutions Exist"``)``  ` `        ``# Condition for no solutions exist``        ``else` `:``            ``print``(``"No Solution exists"``)``    ``gcd ``=` `gcd_extend(a, b)``  ` `    ``# Condition for no solutions exist``    ``if` `(c ``%` `gcd !``=` `0``):``        ``print``(``"No Solution exists"``)``    ``else``:``        ``# Print the solution``        ``print``(``"x = "``, ``int``(x ``*` `(c ``/` `gcd)), ``", y = "``, ``int``(y ``*` `(c ``/` `gcd)), sep ``=` `"")``        ` `# Given coefficients``a ``=` `4``b ``=` `18``c ``=` `10` `# Function Call``print_solution(a, b, c)` `# This code is contributed by decode2207.`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG{` `static` `int` `x, y;` `// Function to implement the extended``// euclid algorithm``static` `int` `gcd_extend(``int` `a, ``int` `b)``{``    ` `    ``// Base Case``    ``if` `(b == 0)``    ``{``        ``x = 1;``        ``y = 0;``        ``return` `a;``    ``}` `    ``// Recursively find the gcd``    ``else``    ``{``        ``int` `g = gcd_extend(b, a % b);``        ``int` `x1 = x, y1 = y;``        ``x = y1;``        ``y = x1 - (a / b) * y1;``        ``return` `g;``    ``}``}` `// Function to print the solutions of``// the given equations ax + by = c``static` `void` `print_solution(``int` `a, ``int` `b, ``int` `c)``{``    ``if` `(a == 0 && b == 0)``    ``{``        ` `        ``// Condition for infinite solutions``        ``if` `(c == 0)``        ``{``            ``Console.Write(``"Infinite Solutions "` `+``                          ``"Exist"` `+ ``"\n"``);``        ``}` `        ``// Condition for no solutions exist``        ``else``        ``{``            ``Console.Write(``"No Solution exists"` `+``                          ``"\n"``);``        ``}``    ``}``    ``int` `gcd = gcd_extend(a, b);` `    ``// Condition for no solutions exist``    ``if` `(c % gcd != 0)``    ``{``        ``Console.Write(``"No Solution exists"` `+ ``"\n"``);``    ``}``    ``else``    ``{``        ` `        ``// Print the solution``        ``Console.Write(``"x = "` `+ x * (c / gcd) +``                    ``", y = "` `+ y * (c / gcd) + ``"\n"``);``    ``}``}` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `a, b, c;` `    ``// Given coefficients``    ``a = 4;``    ``b = 18;``    ``c = 10;` `    ``// Function call``    ``print_solution(a, b, c);``}``}` `// This code contributed by amal kumar choubey`

## Javascript

 ``
Output:
`x = -20, y = 5`

Time Complexity: O(log(max(A, B))), where A and B are the coefficient of x and y in the given linear equation.
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up