# Total number Of valid Home delivery arrangements

• 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: Below is the implementation of the above approach.

## C++

 `// C++ implementation of the above approach`   `#include ` `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

 ``

Output:

`2520`

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

Approach 2:

1. For N number of orders, we have 2. So the total number of arrangements possible is 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 Below is the implementation of the above approach.

## C++

 `// C++ implementation of the above approach`   `#include ` `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

 ``

Output:

`2520`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :