Count number of ways to arrange the first N natural numbers in a line such that the leftmost number is always 1 and no two consecutive numbers have an absolute difference greater than 2.
Examples:
Input: N = 4
Output: 4
The only possible arrangements are (1, 2, 3, 4),
(1, 2, 4, 3), (1, 3, 4, 2) and (1, 3, 2, 4).Input: N = 6
Output: 9
Naive approach: Generate all the permutations and count how many of them satisfy the given conditions.
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the count // of required arrangements int countWays( int n)
{ // Create a vector
vector< int > a;
int i = 1;
// Store numbers from 1 to n
while (i <= n)
a.push_back(i++);
// To store the count of ways
int ways = 0;
// Generate all the permutations
// using next_permutation in STL
do {
// Initialize flag to true if first
// element is 1 else false
bool flag = (a[0] == 1);
// Checking if the current permutation
// satisfies the given conditions
for ( int i = 1; i < n; i++) {
// If the current permutation is invalid
// then set the flag to false
if ( abs (a[i]  a[i  1]) > 2)
flag = 0;
}
// If valid arrangement
if (flag)
ways++;
// Generate the next permutation
} while (next_permutation(a.begin(), a.end()));
return ways;
} // Driver code int main()
{ int n = 6;
cout << countWays(n);
return 0;
} 
9
Efficient approach: This problem can be solved using dynamic programming.
A better linear approach to this problem relies on the following observation. Look for the position of 2. Let a[i] be the number of ways for n = i. There are three cases:
 12_____ – “2” in the second position.

1*2____ – “2” in the third position.
1**2___ – “2” in the fourth position is impossible because only possible way is (1342), which is same as case 3.
1***2__ – “2” in the fifth position is impossible because 1 must be followed by 3, 3 by 5 and 2 needs 4 before it so it becomes 13542, again as case 3.  1_(i – 2)terms___2 – “2” in the last position (1357642 and similar)
For each case, the following are the subtask:
Adding 1 to each term of a[i – 1] i.e. (1__(i – 1) terms__).
As for 1_2_____ there can only be one 1324___(i – 4) terms____ i.e. a[i – 3].
Hence, the recurrence relation will be,
a[i] = a[i – 1] + a[i – 3] + 1
And the base cases will be:
a[0] = 0
a[1] = 1
a[2] = 1
Below is the implementation of the above approach:
// C++ implementation of the approach #include <bits/stdc++.h> using namespace std;
// Function to return the count // of required arrangements int countWays( int n)
{ // Create the dp array
int dp[n + 1];
// Initialize the base cases
// as explained above
dp[0] = 0;
dp[1] = 1;
// (12) as the only possibility
dp[2] = 1;
// Generate answer for greater values
for ( int i = 3; i <= n; i++) {
dp[i] = dp[i  1] + dp[i  3] + 1;
}
// dp[n] contains the desired answer
return dp[n];
} // Driver code int main()
{ int n = 6;
cout << countWays(n);
return 0;
} 
// Java implementation of the approach class GFG
{ // Function to return the count // of required arrangements static int countWays( int n)
{ // Create the dp array
int []dp = new int [n + 1 ];
// Initialize the base cases
// as explained above
dp[ 0 ] = 0 ;
dp[ 1 ] = 1 ;
// (12) as the only possibility
dp[ 2 ] = 1 ;
// Generate answer for greater values
for ( int i = 3 ; i <= n; i++)
{
dp[i] = dp[i  1 ] + dp[i  3 ] + 1 ;
}
// dp[n] contains the desired answer
return dp[n];
} // Driver code public static void main(String args[])
{ int n = 6 ;
System.out.println(countWays(n));
} } // This code is contributed by 29AjayKumar 
# Python implementation of the approach # Function to return the count # of required arrangements def countWays(n):
# Create the dp array
dp = [ 0 for i in range (n + 1 )]
# Initialize the base cases
# as explained above
dp[ 0 ] = 0
dp[ 1 ] = 1
# (12) as the only possibility
dp[ 2 ] = 1
# Generate answer for greater values
for i in range ( 3 , n + 1 ):
dp[i] = dp[i  1 ] + dp[i  3 ] + 1
# dp[n] contains the desired answer
return dp[n]
# Driver code n = 6
print (countWays(n))
# This code is contributed by Mohit Kumar 
// C# implementation of the approach using System;
class GFG
{ // Function to return the count // of required arrangements static int countWays( int n)
{ // Create the dp array
int []dp = new int [n + 1];
// Initialize the base cases
// as explained above
dp[0] = 0;
dp[1] = 1;
// (12) as the only possibility
dp[2] = 1;
// Generate answer for greater values
for ( int i = 3; i <= n; i++)
{
dp[i] = dp[i  1] + dp[i  3] + 1;
}
// dp[n] contains the desired answer
return dp[n];
} // Driver code public static void Main()
{ int n = 6;
Console.WriteLine(countWays(n));
} } // This code is contributed by Code@Mech. 
9
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a studentfriendly price and become industry ready.
Recommended Posts:
 Calculate Stirling numbers which represents the number of ways to arrange r objects around n different circles
 Number of ways to arrange N numbers which are in a range from 1 to K under given constraints.
 Count ways to arrange N distinct objects if all clockwise arrangements are considered the same
 Number of ways to arrange N items under given constraints
 Number of ways to arrange a word such that all vowels occur together
 Number of ways to arrange K different objects taking N objects at a time
 Number of ways to arrange a word such that no vowels occur together
 Number of ways to arrange 2*N persons on the two sides of a table with X and Y persons on opposite sides
 Ways to arrange Balls such that adjacent balls are of different types
 Find ways to arrange K green balls among N balls such that exactly i moves is needed to collect all K green balls
 Arrange given numbers to form the smallest number
 Arrange numbers to form a valid sequence
 Arrange numbers 1 to N^2 in a ZigZag Matrix in ascending order
 Arrange the numbers in the Array as per given inequalities
 Permutations to arrange N persons around a circular table
 Number of ways to obtain each numbers in range [1, b+c] by adding any two numbers in range [a, b] and [b, c]
 Count ways to express a number as sum of consecutive numbers
 Count ways to express a number as sum of exactly two numbers
 Number of ways to represent a number as sum of k fibonacci numbers
 Count number of ways to divide a number in 4 parts
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.