Skip to content
Related Articles

Related Articles

Total number Of valid Home delivery arrangements

Improve Article
Save Article
Like Article
  • Difficulty Level : Expert
  • Last Updated : 20 May, 2021

Given the number of orders, find the number of valid arrangements of orders where delivery of ith order is always after the pickup of ith order.

Examples:

Input: N = 1 
Output:
Here, the total event is 2. They are {P1, D1}. 
The total possible arrangement is 2! = 2. [P1, D1] and [D1, P1]. 
So the only valid arrangement possible: [P1, D1]. 
[D1, P1] is an invalid arrangement as delivery of 1st order is done before pickup of 1st order.

Input: N = 2
Output:
Here, the total event is 4. They are {P1, D1, P2, D2}. 
Here, the total possible arrangements are 4! = 24. 
Among them, 6 are valid arrangements: 
[P1, P2, D1, D2], [P1, D1, P2, D2], [P1, P2, D2, D1], [P2, P1, D2, D1], [P2, P1, D1, D2], and [P2, D2, P1, D1]. 
The rest of all are invalid arrangements. 
Some invalid arrangements: 
[P1, D1, D2, P2] – Delivery of 2nd order is done before pickup 
[P2, D1, P1, D2] – Delivery of 1st order is done before pickup 
[D1, D2, P2, P1] – Delivery of both orders is before pickup
 

Approach 1: 

  1. Consider N = 4, we have a total of 8 events.
  2. There are 4 events for pickup {P1, P2, P3, P4} and 4 events for delivery {D1, D2, D3, D4}.
  3. If we consider only pickup events, there are no restrictions on arrangements between pickups. So, total possible arrangements 4!
  4. Now we consider delivery. We start from the last pickup we made. 
    • For D4, we can place D4 only after P4. 
      That is P1, P2, P3, P4, __. So there is only 1 valid position.
    • For D3, we can place D3 in any one of the following positions. 
      They are P1, P2, P3, __, P4, __, D4, __. So there are 3 valid positions.
    • For D2, we can place D2 in any one of the following positions. 
      They are P1, P2, __, P3, __, P4, __, D4, __, D3 __ .So 5 valid positions.
    • For D1, we can place D1 in any one of the following positions. 
      They are P1, __, P2, __, P3, __, P4, __, D4, __, D3 __, D2, __ .So, 7 valid positions.

For any N, total valid arrangements: 
N! * (1 * 3 * 5 * ... * (2 * N - 1))

Below is the implementation of the above approach.

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find arrangements
int Arrangements(int N)
{
    int result = 1;
 
    for(int i = 1; i <= N; i++)
    {
       // Here, i for factorial and
       // (2*i-1) for series
       result = result * i * (2 * i - 1);
    }
    return result;
}
 
// Driver code
int main()
{
    int N = 4;
 
    cout << Arrangements(N);
 
    return 0;
}


Java




// Java implementation of the above approach
class GFG{
 
// Function to find arrangements
public static int Arrangements(int N)
{
    int result = 1;
     
    for(int i = 1; i <= N; i++)
    {
 
        // Here, i for factorial and
        // (2*i-1) for series
       result = result * i * (2 * i - 1);
    }
    return result;
}
 
// Driver code   
public static void main(String[] args)
{
    int N = 4;
     
    System.out.print(Arrangements(N));
}
}
 
// This code is contributed by divyeshrabadiya07


Python3




# Python3 implementation of the above approach
 
# Function to find arrangements
def Arrangements(N):
 
    result = 1
 
    for i in range(1, N + 1):
 
        # Here, i for factorial and
        # (2*i-1) for series
        result = result * i * (2 * i - 1)
 
    return result
 
# Driver code
N = 4;
print(Arrangements(N));
 
# This code is contributed by Akanksha_Rai


C#




// C# implementation of the above approach
using System;
 
class GFG{
     
// Function to find arrangements
public static int Arrangements(int N)
{
    int result = 1;
         
    for(int i = 1; i <= N; i++)
    {
 
       // Here, i for factorial and
       // (2*i-1) for series
       result = result * i * (2 * i - 1);
    }
    return result;
}
     
// Driver code
public static void Main(String[] args)
{
    int N = 4;
         
    Console.Write(Arrangements(N));
}
}
 
// This code is contributed by AnkitRai01


Javascript




<script>
 
// Javascript implementation of the above approach
 
// Function to find arrangements
function Arrangements(N)
{
    let result = 1;
 
    for(let i = 1; i <= N; i++)
    {
         
        // Here, i for factorial and
        // (2*i-1) for series
        result = result * i * (2 * i - 1);
    }
    return result;
}
 
// Driver code
let N = 4;
 
document.write(Arrangements(N));
 
// This code is contributed by _saurabh_jaiswal
 
</script>


Output: 

2520

 

Time complexity: O(N) 
Auxiliary Space complexity: O(1)

Approach 2: 

  1. For N number of orders, we have Total events = 2 * N
  2. So the total number of arrangements possible is ( 2 * N )!
  3. Now, each order can only be valid if delivery is one after pickup.

For each [Pi, Di], we can’t change this arrangement, ie we can’t do [Di, Pi]. There is only one valid arrangement for each such order. So we need to divide by 2 for each order. So the total valid arrangement is ( 2 * N )! / 2 ^ N

Below is the implementation of the above approach.

C++




// C++ implementation of the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find arrangements
int Arrangements(int N)
{
    int result = 1;
 
    for (int i = 1; i <= 2 * N; i += 2)
        result = (result * i * (i + 1)) / 2;
 
    return result;
}
 
// Driver code
int main()
{
    int N = 4;
 
    cout << Arrangements(N);
 
    return 0;
}


Java




// Java implementation of the above approach
import java.util.*;
class GFG{
     
// Function to find arrangements
public static int Arrangements(int N)
{
    int result = 1;
 
    for (int i = 1; i <= 2 * N; i += 2)
        result = (result * i * (i + 1)) / 2;
 
    return result;
}
 
// Driver code
public static void main(String args[])
{
    int N = 4;
 
    System.out.print(Arrangements(N));
}
}
 
// This code is contributed by Code_Mech


Python3




# Python3 implementation of the above approach
 
# Function to find arrangements
def Arrangements(N):
    result = 1;
 
    for i in range(1, (2 * N) + 1, 2):
        result = (result * i * (i + 1)) / 2;
 
    return int(result);
 
# Driver code
if __name__ == '__main__':
    N = 4;
 
    print(Arrangements(N));
 
# This code is contributed by gauravrajput1


C#




// C# implementation of the above approach
using System;
class GFG{
     
// Function to find arrangements
public static int Arrangements(int N)
{
    int result = 1;
 
    for (int i = 1; i <= 2 * N; i += 2)
        result = (result * i * (i + 1)) / 2;
 
    return result;
}
 
// Driver code
public static void Main()
{
    int N = 4;
 
    Console.Write(Arrangements(N));
}
}
 
// This code is contributed by Code_Mech


Javascript




<script>
// Javascript implementation of the above approach
 
// Function to find arrangements
function Arrangements(N)
{
    var result = 1;
 
    for (var i = 1; i <= 2 * N; i += 2)
        result = parseInt( (result * i * (i + 1)) / 2);
 
    return result;
}
 
var  N = 4;
document.write( Arrangements(N));
 
 
// This code is contributed by SoumikMondal
</script>


Output: 

2520

 

Time complexity: O(N) 
Auxiliary Space complexity: O(1) 
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!