Solving Homogeneous Recurrence Equations Using Polynomial Reduction
Last Updated :
30 Dec, 2022
A recurrence relation is an equation that recursively defines a sequence or multidimensional array of values, once one or more initial terms are given; each further term of the sequence or array is defined as a function of the preceding terms. Below are the steps required to solve a recurrence equation using the polynomial reduction method:
- Form a characteristic equation for the given recurrence equation.
- Solve the characteristic equation and find the roots of the characteristic equation.
- Simplify the solution with unknown coefficients.
- Solve the equation with respect to the initial conditions to get a specific solution.
Example:
Consider the following second-order recurrence equation:
T(n) = a1T(n-1) + a2T(n-2)
For solving this equation formulate it into a characteristic equation.
Let us rearrange the equation as follows:
T(n) - a1T(n-1) - a2T(n-2) = 0
Let, T(n) = xn
Now we can say that T(n-1) = xn-1 and T(n-2)=xn-2
Now the equation will be:
xn + a1xn-1 + a2xn-2 = 0
After dividing the whole equation by xn-2 [since x is not equal to 0] we get:
x2 + a1x + a2 = 0
We have got our characteristic equation as x2+a1x+a2=0
Now, find the roots of this equation.
Three cases may exist while finding the roots of the characteristic equation and those are:
Case 1: Roots of the Characteristic Equation are Real and Distinct
If there are r number of distinct roots for the characteristic equation then it can be said that r number of fundamental solutions are possible. One can take any linear combination of roots to get the general solution of a linear recurrence equation.
If r1, r2, r3......, rk are the roots of the characteristic equation then the general solution of the recurrence equation will be:
tn = c1r1n + c2r2n + c3r3n +...........+ ckrkn
Case 2: Roots of the Characteristic Equation are Real but not Distinct
Let us consider the roots of the characteristic equations are not distinct and the roots r is in the multiplicity of m. In this case, the solution of the characteristic equation will be:
r1 = rn
r2 = nrn
r3 = n2rn
.........
rm = nm-1rn
Therefore, include all the solutions to get a general solution of the given recurrence equation.
Case 3: Roots of the Characteristic Equation are Distinct but Not Real
If the roots of the characteristic equation are complex, then find the conjugate pair of roots.
If r1 and r2 are the two roots of a characteristic equation, and they are in conjugate pair with each other it can be expressed as:
r1 = reix
r2 = re-ix
The general solution will be:
tn = rn(c1cos nx + c2sin nx)
Example:
Let's solve the given recurrence relation:
T(n) = 7*T(n-1) - 12*T(n-2)
Let T(n) = xn
Now we can say that T(n-1) = xn-1 and T(n-2)=xn-2
And dividing the whole equation by xn-2, we get:
x2 - 7*x + 12 = 0
Below is the implementation to solve the given quadratic equation:
C++
// C++ program to find roots
// of a quadratic equation
#include<bits/stdc++.h>
using namespace std;
class Quadratic{
public:
// Prints roots of quadratic
// equation ax * 2 + bx + x
void findRoots(int a, int b, int c)
{
// If a is 0, then equation is not
// quadratic, but linear
if (a == 0)
{
cout << "Invalid";
return;
}
int d = b * b - 4 * a * c;
float sqrt_val = sqrt(abs(d));
// Real Roots
if (d > 0)
{
cout << "Roots are real and different" << endl;
cout << fixed << std::setprecision(1)
<< float((-b + sqrt_val) / (2 * a)) << endl;
cout << fixed << std::setprecision(1)
<< float((-b - sqrt_val) / (2 * a)) << endl;
}
// Imaginary Roots
else
{
cout << "Roots are complex" << endl;
cout << fixed << std::setprecision(1)
<< float(b / (2.0 * a)) << " + i"
<< sqrt_val << endl;
cout << fixed << std::setprecision(1)
<< float(b / (2.0 * a)) << " - i"
<< sqrt_val << endl;
}
}
};
// Driver code
int main()
{
Quadratic obj;
// Given value of coefficients
int a = 1, b = -7, c = 12;
obj.findRoots(a, b, c);
}
// This code is contributed by SURENDRA_GANGWAR
// Java program to find roots
// of a quadratic equation
import java.io.*;
import static java.lang.Math.*;
class Quadratic {
// Prints roots of quadratic
// equation ax * 2 + bx + x
void findRoots(int a, int b, int c)
{
// If a is 0, then equation is not
// quadratic, but linear
if (a == 0) {
System.out.println("Invalid");
return;
}
int d = b * b - 4 * a * c;
double sqrt_val = sqrt(abs(d));
// Real Roots
if (d > 0) {
System.out.println(
"Roots are real"
+ " and different \n");
System.out.println(
(double)(-b + sqrt_val)
/ (2 * a)
+ "\n"
+ (double)(-b - sqrt_val)
/ (2 * a));
}
// Imaginary Roots
else {
System.out.println(
"Roots are complex \n");
System.out.println(
-(double)b / (2 * a)
+ " + i"
+ sqrt_val + "\n"
+ -(double)b / (2 * a)
+ " - i" + sqrt_val);
}
}
// Driver code
public static void main(String args[])
{
Quadratic obj = new Quadratic();
// Given value of coefficients
int a = 1, b = -7, c = 12;
obj.findRoots(a, b, c);
}
}
# Python3 program to find roots
# of a quadratic equation
from math import sqrt
# Prints roots of quadratic
# equation ax * 2 + bx + x
def findRoots(a, b, c):
# If a is 0, then equation is not
# quadratic, but linear
if (a == 0):
print("Invalid")
return
d = b * b - 4 * a * c
sqrt_val = sqrt(abs(d))
# Real Roots
if (d > 0):
print("Roots are real and different")
print((-b + sqrt_val) / (2 * a))
print((-b - sqrt_val) / (2 * a))
# Imaginary Roots
else:
print("Roots are complex \n")
print(-b / (2 * a), " + i",
sqrt_val, "\n",
-b / (2 * a), " - i",
sqrt_val)
# Driver code
if __name__ == '__main__':
# Given value of coefficients
a = 1
b = -7
c = 12
findRoots(a, b, c)
# This code is contributed by mohit kumar 29
// C# program to find roots
// of a quadratic equation
using System;
class Quadratic{
// Prints roots of quadratic
// equation ax * 2 + bx + x
void findRoots(int a,
int b, int c)
{
// If a is 0, then equation
// is not quadratic, but linear
if (a == 0)
{
Console.WriteLine("Invalid");
return;
}
int d = b * b - 4 *
a * c;
double sqrt_val =
Math.Sqrt(Math.Abs(d));
// Real Roots
if (d > 0)
{
Console.WriteLine("Roots are real" +
" and different \n");
Console.WriteLine((double)
(-b + sqrt_val) /
(2 * a) + "\n" +
(double)
(-b - sqrt_val) /
(2 * a));
}
// Imaginary Roots
else
{
Console.WriteLine("Roots are complex \n");
Console.WriteLine(-(double)b / (2 * a) +
" + i" + sqrt_val +
"\n" + -(double)b /
(2 * a) + " - i" +
sqrt_val);
}
}
// Driver code
public static void Main(String []args)
{
Quadratic obj = new Quadratic();
// Given value of coefficients
int a = 1, b = -7, c = 12;
obj.findRoots(a, b, c);
}
}
// This code is contributed by Princi Singh
<script>
// Javascript program to find roots
// of a quadratic equation
// Prints roots of quadratic
// equation ax * 2 + bx + x
function findRoots(a, b, c)
{
// If a is 0, then equation is not
// quadratic, but linear
if (a == 0) {
document.write("Invalid");
return;
}
let d = b * b - 4 * a * c;
let sqrt_val = Math.sqrt(Math.abs(d));
// Real Roots
if (d > 0) {
document.write(
"Roots are real"
+ " and different <br>");
document.write(
(-b + sqrt_val)
/ (2 * a)
+ "<br>"
+ (-b - sqrt_val)
/ (2 * a));
}
// Imaginary Roots
else {
document.write(
"Roots are complex <bR>");
document.write(
-b / (2 * a)
+ " + i"
+ sqrt_val + "<br>"
+ -b / (2 * a)
+ " - i" + sqrt_val);
}
}
// Driver code
// Given value of coefficients
let a = 1, b = -7, c = 12;
findRoots(a, b, c);
// This code is contributed by unknown2108
</script>
OutputRoots are real and different
4.0
3.0
Time Complexity: O(log(N))
Auxiliary Space: O(1)
Similar Reads
Solving 2nd Order Homogeneous Difference Equations in MATLAB
Difference Equations are Mathematical Equations involving the differences between usually successive values of a function ('y') of a discrete variable. Here, a discrete variable means that it is defined only for values that differ by some finite amount, generally a constant (Usually '1'). A differen
4 min read
Substitution Method to solve Recurrence Relations
Recursion is a method to solve a problem where the solution depends on solutions to smaller subproblems of the same problem. Recursive functions (function calling itself) are used to solve problems based on Recursion. The main challenge with recursion is to find the time complexity of the Recursive
6 min read
How to solve time complexity Recurrence Relations using Recursion Tree method?
The Recursion Tree Method is a way of solving recurrence relations. In this method, a recurrence relation is converted into recursive trees. Each node represents the cost incurred at various levels of recursion. To find the total cost, costs of all levels are summed up.Steps to solve recurrence rela
4 min read
Different types of recurrence relations and their solutions
In this article, we will see how we can solve different types of recurrence relations using different approaches. Before understanding this article, you should have idea about recurrence relations and different method to solve them.Recurrence relations are equations that define sequences based on pr
5 min read
Recurrence Relations | A Complete Guide
Have you ever wondered how to calculate the time complexity of algorithms like Fibonacci Series, Merge Sort, etc. where the problem is solved by dividing it into subproblems. This is done by analyzing the Recurrence Relations of these algorithms. In this article, we will learn about the basics of Re
9 min read
How to analyse Complexity of Recurrence Relation
The analysis of the complexity of a recurrence relation involves finding the asymptotic upper bound on the running time of a recursive algorithm. This is usually done by finding a closed-form expression for the number of operations performed by the algorithm as a function of the input size, and then
7 min read
Find nth term of a given recurrence relation
Let an be a sequence of numbers, which is defined by the recurrence relation a1=1 and an+1/an=2n. The task is to find the value of log2(an) for a given n. Examples: Input: 5 Output: 10 Explanation: log2(an) = (n * (n - 1)) / 2 = (5*(5-1))/2 = 10Input: 100 Output: 4950 \frac{a_{n+1}}{a_{n}}=2^{n} \fr
3 min read
Recurrence Relations Notes for GATE Exam [2024]
Recurrence relations are the mathematical backbone of algorithmic analysis, providing a systematic way to express the time complexity of recursive algorithms. As GATE Exam 2024 approaches, a profound understanding of recurrence relations becomes imperative for tackling questions that demand a deep c
13 min read
Recurrence Relation in python
Recurrence relation is an equation that recursively defines a sequence, where the next term is a function of the previous terms. Recurrence relations are commonly used to describe the runtime of recursive algorithms in computer science and to define sequences in mathematics. What is a Recurrence Rel
3 min read
Adding two polynomials using Linked List
Given two polynomial numbers represented by a linked list. The task is to add these lists meaning the coefficients with the same variable powers will be added.Note: Given polynomials are sorted in decreasing order of power.Example: Input: head1: [[5, 2], [4, 1], [2, 0]]head2: [[5, 1], [5, 0]]Output:
15+ min read