Eulerian Number
Last Updated :
04 Dec, 2023
In combinatorics, the Eulerian Number A(n, m), is the number of permutations of the numbers 1 to n in which exactly m elements are greater than previous element.
For example, there are 4 permutations of the number 1 to 3 in which exactly 1 element is greater than the previous elements.Â
Examples:Â Â
Input : n = 3, m = 1
Output : 4
Please see above diagram (There
are 4 permutations where 1 no. is
greater.
Input : n = 4, m = 1
Output : 11
Eulerian Numbers are the coefficients of the Eulerian polynomials described below.Â
The Eulerian polynomials are defined by the exponential generating functionÂ
The Eulerian polynomials can be computed by the recurrenceÂ
Â
An explicit formula for A(n, m) isÂ
We can calculate A(n, m) by recurrence relation:Â
Example:Â
Suppose, n = 3 and m = 1.Â
Therefore,Â
A(3, 1)Â
= (3 - 1) * A(2, 0) + (1 + 1) * A(2, 1)Â
= 2 * A(2, 0) + 2 * A(2, 1)Â
= 2 * 1 + 2 * ( (2 - 1) * A(1, 0) + (1 + 1) * A(1, 1))Â
= 2 + 2 * (1 * 1 + 2 * ((1 - 1) * A(0, 0) + (1 + 1) * A(0, 1))Â
= 2 + 2 * (1 + 2 * (0 * 1 + 2 * 0)Â
= 2 + 2 * (1 + 2 * 0)Â
= 2 + 2 * 1Â
= 2 + 2Â
= 4Â
We can verify this with example shown above.
Below is the implementation of finding A(n, m):Â Â
C++
#include <bits/stdc++.h>
using namespace std;
int eulerian( int n, int m)
{
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return (n - m) * eulerian(n - 1, m - 1)
+ (m + 1) * eulerian(n - 1, m);
}
int main()
{
int n = 3, m = 1;
cout << eulerian(n, m) << endl;
return 0;
}
|
Java
import java.util.*;
class Eulerian {
public static int eulerian( int n, int m)
{
if (m >= n || n == 0 )
return 0 ;
if (m == 0 )
return 1 ;
return (n - m) * eulerian(n - 1 , m - 1 )
+ (m + 1 ) * eulerian(n - 1 , m);
}
public static void main(String[] args)
{
int n = 3 , m = 1 ;
System.out.print(eulerian(n, m));
}
}
|
Python3
def eulerian(n, m):
if (m > = n or n = = 0 ):
return 0
if (m = = 0 ):
return 1
return ((n - m) * eulerian(n - 1 , m - 1 ) +
(m + 1 ) * eulerian(n - 1 , m))
n = 3
m = 1
print (eulerian(n, m))
|
C#
using System;
class Eulerian {
public static int eulerian( int n, int m)
{
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return (n - m) * eulerian(n - 1, m - 1)
+ (m + 1) * eulerian(n - 1, m);
}
public static void Main()
{
int n = 3, m = 1;
Console.WriteLine(eulerian(n, m));
}
}
|
Javascript
<script>
function eulerian(n, m)
{
if (m >= n || n == 0)
return 0;
if (m == 0)
return 1;
return (n - m) * eulerian(n - 1, m - 1) +
(m + 1) * eulerian(n - 1, m);
}
let n = 3, m = 1;
document.write( eulerian(n, m) );
</script>
|
PHP
<?php
function eulerian( $n , $m )
{
if ( $m >= $n || $n == 0)
return 0;
if ( $m == 0)
return 1;
return ( $n - $m ) * eulerian( $n - 1, $m - 1) +
( $m + 1) * eulerian( $n - 1, $m );
}
$n = 3; $m = 1;
echo eulerian( $n , $m );
?>
|
Time Complexity: O(2n)
Auxiliary Space: O(log(n)), Due, to recursive call stack
Below is the implementation of finding A(n, m) using Dynamic Programming:Â
C++
#include <bits/stdc++.h>
using namespace std;
int eulerian( int n, int m)
{
int dp[n + 1][m + 1];
memset (dp, 0, sizeof (dp));
for ( int i = 1; i <= n; i++) {
for ( int j = 0; j <= m; j++) {
if (i > j) {
if (j == 0)
dp[i][j] = 1;
else
dp[i][j] = ((i - j) * dp[i - 1][j - 1])
+ ((j + 1) * dp[i - 1][j]);
}
}
}
return dp[n][m];
}
int main()
{
int n = 3, m = 1;
cout << eulerian(n, m) << endl;
return 0;
}
|
Java
import java.util.*;
class Eulerian {
public static int eulerian( int n, int m)
{
int [][] dp = new int [n + 1 ][m + 1 ];
for ( int i = 1 ; i <= n; i++) {
for ( int j = 0 ; j <= m; j++) {
if (i > j) {
if (j == 0 )
dp[i][j] = 1 ;
else
dp[i][j]
= ((i - j) * dp[i - 1 ][j - 1 ])
+ ((j + 1 ) * dp[i - 1 ][j]);
}
}
}
return dp[n][m];
}
public static void main(String[] args)
{
int n = 3 , m = 1 ;
System.out.print(eulerian(n, m));
}
}
|
Python3
def eulerian(n, m):
dp = [[ 0 for x in range (m + 1 )]
for y in range (n + 1 )]
for i in range ( 1 , n + 1 ):
for j in range ( 0 , m + 1 ):
if (i > j):
if (j = = 0 ):
dp[i][j] = 1
else :
dp[i][j] = (((i - j) *
dp[i - 1 ][j - 1 ]) +
((j + 1 ) * dp[i - 1 ][j]))
return dp[n][m]
n = 3
m = 1
print (eulerian(n, m))
|
C#
using System;
class Eulerian {
public static int eulerian( int n, int m)
{
int [, ] dp = new int [n + 1, m + 1];
for ( int i = 1; i <= n; i++) {
for ( int j = 0; j <= m; j++) {
if (i > j) {
if (j == 0)
dp[i, j] = 1;
else
dp[i, j]
= ((i - j) * dp[i - 1, j - 1])
+ ((j + 1) * dp[i - 1, j]);
}
}
}
return dp[n, m];
}
public static void Main()
{
int n = 3, m = 1;
Console.WriteLine(eulerian(n, m));
}
}
|
Javascript
<script>
function eulerian(n, m)
{
var dp = Array.from(Array(n+1),
()=> Array(m+1).fill(0));
for ( var i = 1; i <= n; i++) {
for ( var j = 0; j <= m; j++) {
if (i > j) {
if (j == 0)
dp[i][j] = 1;
else
dp[i][j] = ((i - j) *
dp[i - 1][j - 1]) +
((j + 1) * dp[i - 1][j]);
}
}
}
return dp[n][m];
}
var n = 3, m = 1;
document.write( eulerian(n, m) );
</script>
|
PHP
<?php
function eulerian( $n , $m )
{
$dp = array ( array ());
for ( $i = 0; $i < $n + 1; $i ++)
for ( $j = 0; $j < $m + 1; $j ++)
$dp [ $i ][ $j ] = 0 ;
for ( $i = 1; $i <= $n ; $i ++)
{
for ( $j = 0; $j <= $m ; $j ++)
{
if ( $i > $j )
{
if ( $j == 0)
$dp [ $i ][ $j ] = 1;
else
$dp [ $i ][ $j ] = (( $i - $j ) *
$dp [ $i - 1][ $j - 1]) +
(( $j + 1) * $dp [ $i - 1][ $j ]);
}
}
}
return $dp [ $n ][ $m ];
}
$n = 3 ;
$m = 1;
echo eulerian( $n , $m ) ;
?>
|
Time Complexity: O(n*m)
Auxiliar Space: O(n*m)
Efficient approach: Space optimization
In the previous approach, the current value dp[i][j] is only depend upon the current and previous row values of DP. So to optimize the space complexity we use a single 1D array to store the computations.
Implementation steps:
- Create a 1D vector dp of size m+1.
- Set a base case by initializing the values of DP .
- Now iterate over subproblems by the help of nested loop and get the current value from previous computations.
- Now Create a variable prev to store previous computations and a temp variable to update prev at every iteration.
- After every iteration assign the value of temp to prev for further iteration.
- At last return and print the final answer stored in dp[m].
Implementation:
C++
#include <bits/stdc++.h>
using namespace std;
int eulerian( int n, int m)
{
vector< int > dp(m+1,0);
for ( int i = 1; i <= n; i++) {
int prev = 0;
for ( int j = 0; j <= m; j++) {
int temp = dp[j];
if (i > j) {
if (j == 0)
dp[j] = 1;
else
dp[j] = ((i - j) * prev) + ((j + 1) * dp[j]);
prev = temp;
}
}
}
return dp[m];
}
int main()
{
int n = 3, m = 1;
cout << eulerian(n, m) << endl;
return 0;
}
|
Java
import java.util.*;
public class Main {
static int eulerian( int n, int m) {
int [] dp = new int [m+ 1 ];
Arrays.fill(dp, 0 );
for ( int i = 1 ; i <= n; i++) {
int prev = 0 ;
for ( int j = 0 ; j <= m; j++) {
int temp = dp[j];
if (i > j) {
if (j == 0 )
dp[j] = 1 ;
else
dp[j] = ((i - j) * prev) + ((j + 1 ) * dp[j]);
prev = temp;
}
}
}
return dp[m];
}
public static void main(String[] args) {
int n = 3 , m = 1 ;
System.out.println(eulerian(n, m));
}
}
|
Python3
def eulerian(n, m):
dp = [ 0 ] * (m + 1 )
for i in range ( 1 , n + 1 ):
prev = 0
for j in range ( 0 , m + 1 ):
temp = dp[j]
if i > j:
if j = = 0 :
dp[j] = 1
else :
dp[j] = ((i - j) * prev) + ((j + 1 ) * dp[j])
prev = temp
return dp[m]
n = 3
m = 1
print (eulerian(n, m))
|
C#
using System;
class EulerianNumber
{
static int Eulerian( int n, int m)
{
int [] dp = new int [m + 1];
for ( int i = 1; i <= n; i++)
{
int prev = 0;
for ( int j = 0; j <= m; j++)
{
int temp = dp[j];
if (i > j)
{
if (j == 0)
dp[j] = 1;
else
dp[j] = ((i - j) * prev) + ((j + 1) * dp[j]);
prev = temp;
}
}
}
return dp[m];
}
static void Main()
{
int n = 3, m = 1;
int result = Eulerian(n, m);
Console.WriteLine(result);
}
}
|
Javascript
function eulerian(n, m) {
let dp = new Array(m + 1).fill(0);
for (let i = 1; i <= n; i++) {
let prev = 0;
for (let j = 0; j <= m; j++) {
let temp = dp[j];
if (i > j) {
if (j == 0) {
dp[j] = 1;
}
else {
dp[j] = (i - j) * prev + (j + 1) * dp[j];
}
prev = temp;
}
}
}
return dp[m];
}
let n = 3;
let m = 1;
console.log(eulerian(n, m));
|
PHP
<?php
function eulerian( $n , $m )
{
$dp = array_fill (0, $m + 1, 0);
for ( $i = 1; $i <= $n ; $i ++) {
$prev = 0;
for ( $j = 0; $j <= $m ; $j ++) {
$temp = $dp [ $j ];
if ( $i > $j ) {
if ( $j == 0)
$dp [ $j ] = 1;
else
$dp [ $j ] = (( $i - $j ) * $prev ) + (( $j + 1) * $dp [ $j ]);
$prev = $temp ;
}
}
}
return $dp [ $m ];
}
$n = 3;
$m = 1;
echo eulerian( $n , $m ) . PHP_EOL;
?>
|
Time Complexity: O(n*m)
Auxiliary Space: O(m)
Share your thoughts in the comments
Please Login to comment...