Given two positive numbers ‘n’ and ‘m’ (n <= m) which represent total number of items of first and second type of sets respectively. Find total number of ways to select at-least one pair by picking one item from first type(I) and another item from second type(II). In any arrangement, an item should not be common between any two pairs.

**Note:** Since answer can be large, output it in modulo **1000000007**.

Input: 2 2Output: 6ExplanationLet's denote the items of I type as a, b and II type as c, d i.e, Type I - a, b Type II - c, d Ways to arrange one pair at a time 1. a --- c 2. a --- d 3. b --- c 4. b --- d Ways to arrange two pairs at a time 5. a --- c, b --- d 6. a --- d, b --- cInput: 2 3Output: 12Input: 1 2Output: 2

The approach is simple, we only need the combination of choosing ‘**i**‘ items from ‘**n**‘ type and ‘**i**‘ items from ‘**m**‘ type and multiply them(Rule of product) where ‘**i**‘ varies from **1** to ‘**n**‘. But we can also permute the resultant product in ‘i’ ways therefore we need to multiply with **i!**. After that take the sum(Rule of sum) of all resultant product to get the final answer.

## C++

`// C++ program to find total no. of ways ` `// to form a pair in two different set ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// initialize global variable so that ` `// it can access by preCalculate() and ` `// nCr() function ` `int` `* fact, *inverseMod; ` `const` `int` `mod = 1e9 + 7; ` ` ` `/* Iterative Function to calculate (x^y)%p in O(log y) */` `int` `power(` `int` `x, ` `int` `y, ` `int` `p) ` `{ ` ` ` `int` `res = 1; ` `// Initialize result ` ` ` ` ` `x = x % p; ` `// Update x if it is more than or ` ` ` `// equal to p ` ` ` ` ` `while` `(y) { ` ` ` ` ` `// If y is odd, multiply x with result ` ` ` `if` `(y & 1) ` ` ` `res = (1LL * res * x) % p; ` ` ` ` ` `// y must be even now ` ` ` `y = y >> 1; ` `// y = y/2 ` ` ` `x = (1LL * x * x) % p; ` ` ` `} ` `// trace(res); ` ` ` ` ` `return` `res; ` `} ` ` ` `// Pre-calculate factorial and ` `// Inverse of number ` `void` `preCalculate(` `int` `n) ` `{ ` ` ` `fact[0] = inverseMod[0] = 1; ` ` ` `for` `(` `int` `i = 1; i <= n; ++i) { ` ` ` ` ` `fact[i] = (1LL * fact[i - 1] * i) % mod; ` ` ` `inverseMod[i] = power(fact[i], mod - 2, mod); ` ` ` `} ` `} ` ` ` `// utility function to calculate nCr ` `int` `nPr(` `int` `a, ` `int` `b) ` `{ ` ` ` `return` `(1LL * fact[a] * inverseMod[a - b]) % mod; ` `} ` ` ` `int` `countWays(` `int` `n, ` `int` `m) ` `{ ` ` ` `fact = ` `new` `int` `[m + 1]; ` ` ` `inverseMod = ` `new` `int` `[m + 1]; ` ` ` ` ` `// Pre-calculate factorial and ` ` ` `// inverse of number ` ` ` `preCalculate(m); ` ` ` ` ` `// Initialize answer ` ` ` `int` `ans = 0; ` ` ` `for` `(` `int` `i = 1; i <= n; ++i) { ` ` ` ` ` `ans += (1LL * ((1LL * nPr(n, i) ` ` ` `* nPr(m, i)) % mod) ` ` ` `* inverseMod[i]) % mod; ` ` ` `if` `(ans >= mod) ` ` ` `ans %= mod; ` ` ` `} ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver program ` `int` `main() ` `{ ` ` ` `int` `n = 2, m = 2; ` ` ` ` ` `cout << countWays(n, m); ` ` ` ` ` `return` `0; ` `} ` |

## Java

`// Java program to find total ` `// no. of ways to form a pair ` `// in two different set ` ` ` `public` `class` `Test ` `{ ` ` ` `static` `long` `[] fact; ` ` ` `static` `long` `[] inverseMod; ` ` ` `static` `int` `mod=` `1000000007` `; ` ` ` ` ` `/* Iterative Function to calculate ` ` ` `(x^y)%p in O(log y) */` ` ` ` ` `static` `long` `power(` `long` `x, ` `int` `y, ` `int` `p) ` ` ` `{ ` ` ` `// Initialize result ` ` ` `long` `res = ` `1` `; ` ` ` ` ` `// Update x if it is more than or ` ` ` `// equal to p ` ` ` `x = x % p; ` ` ` ` ` `while` `(y!=` `0` `) ` ` ` `{ ` ` ` ` ` `// If y is odd, multiply ` ` ` `// x with result ` ` ` `if` `((y & ` `1` `)!=` `0` `) ` ` ` `res = (` `1` `* res * x) % p; ` ` ` `} ` ` ` `// y must be even now ` ` ` `y = y >> ` `1` `; ` ` ` ` ` `x = (` `1` `* x * x) % p; ` ` ` `} ` ` ` ` ` ` ` `return` `res; ` ` ` `} ` ` ` ` ` `// Pre-calculate factorial and ` ` ` `// Inverse of number ` ` ` `public` `static` `void` `preCalculate(` `int` `n) ` ` ` `{ ` ` ` `//int fact[]=new long[n]; ` ` ` `// int inverseMod[]=new long[n]; ` ` ` `fact[` `0` `] = ` `1` `; ` ` ` `inverseMod[` `0` `] = ` `1` `; ` ` ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) ` ` ` `{ ` ` ` ` ` `fact[i] = (` `1` `* fact[i - ` `1` `] * i) ` ` ` `% mod; ` ` ` ` ` `inverseMod[i] = power(fact[i], ` ` ` `mod - ` `2` `, mod); ` ` ` ` ` `} ` ` ` `} ` ` ` ` ` `// utility function to calculate nCr ` ` ` `public` `static` `long` `nPr(` `int` `a, ` `int` `b) ` ` ` `{ ` ` ` ` ` `return` `(` `1` `* fact[a] * inverseMod[a - b]) ` ` ` `% (` `long` `)mod; ` ` ` `} ` ` ` ` ` `public` `static` `int` `countWays(` `int` `n, ` `int` `m) ` ` ` `{ ` ` ` ` ` `fact = ` `new` `long` `[m + ` `1` `]; ` ` ` `inverseMod = ` `new` `long` `[m + ` `1` `]; ` ` ` ` ` `// Pre-calculate factorial and ` ` ` `// inverse of number ` ` ` `preCalculate(m); ` ` ` ` ` `// Initialize answer ` ` ` `long` `ans = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `1` `; i <= n; i++) { ` ` ` ` ` `ans = ans+(` `1` `* ((` `1` `* nPr(n, i)* ` ` ` `nPr(m, i)) % mod)* ` ` ` `(inverseMod[i])) % mod; ` ` ` ` ` `if` `(ans >= mod) ` ` ` `ans %= mod; ` ` ` `} ` ` ` ` ` `return` `(` `int` `)ans; ` ` ` `} ` ` ` ` ` `/* Driver program */` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{ ` ` ` `int` `n = ` `2` `, m = ` `2` `; ` ` ` ` ` `System.out.println(countWays(n, m)); ` ` ` `} ` `} ` ` ` `// This code is contributed by Gitanjali ` |

**Output:**

6

**Time complexity: **O(m*log(mod))

**Auxiliary space: **O(m)

This article is contributed by Shubham Bansal. 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.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.