Finding Number of ways - combinations

Question

Given M digits which are between 1 to 9, Find the number of ways to form N digit number, by repeating one or more given digits such that each of M digits are present in N digit number at least once. Example if M = 3 and N = 4 Answer is 36.
Explanation - let the three digits be 1 2 3 our N = 4, digit number can be 1123, 3211, 1132, ..... repeating 1 similarly repeating 2 and three we will get the total ans.
Since answer is large find the ans % 10000000007. 1 ≤ M ≤ N ≤ 100.

Answer 1

Since you haven't specified which programming language to use, I will use whatever language I prefer (i.e. Java). If you prefer another programming language, you can taje my code as pseudo-code (I have added sufficiently many comments in the code to explain what's going on) and translate to another programming language by yourself.
Clarification
Before I actually get into tackling the problem, I would like to point out that the input arguments should be a set of digits S, and an integer N that is at least the size of S. The way you phrase the problem appears to suggest the input arguments are M and N. This is misleading because if you consider S = {1, 1, 3} and N = 4, then it is obvious that the number of combinations in this case is less than that of your example.
High Level Idea
The core technique to tackle this problem is (not so surprisingly) dynamic programming, the sub-problems P(L, T) are indexed by two parameters: (1) the length L of the number to be constructed; and (2) the set of digits T that must appear in constructing the L-digit number. In your example, the parameters are: (1) L = 4; and (2) T = {1, 2, 3}.
Suppose now we want to solve the problem P(L, S). Let's pick an arbitrary digit a from the digit alphabet (i.e. all the digits between 1 and 9 that appears in the input argument S).
If a is in S, then the number of L-digit numbers that starts with a is given by P(L - 1, S \ {a}).
On the other hand, if a is not in S, then the number of L-digit numbers that starts with a is given by P(L - 1, S).
Therefore we have the following formula:
Here Γ denotes the digit alphabet, and S \ {a} = S if a is not in S.
And the base cases for this problem are P(0, Ø) = 1 (Ø denotes the empty set), and P(L, S) = 0 if L < |S|.
Code
Update: I have rolled back my code to mod the count by 10000000007 (the module you used in your question) instead of 1000000007 (1 zero less).
The code written in Java is given below:
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class Combination {
/* Input arguments */
private static int[] inputNums = {1, 2, 3};
private static final int N = 4;
// This contains all the valid digits for constructing our N-digit number
private static Set<Integer> validDigits;
// Lookup table for sub-problems to save computation time
private static Map<String, Long> subProbLookup;
public static void main(String[] args) {
validDigits = new HashSet<Integer>();
List<Integer> initNums = new ArrayList<Integer>();
subProbLookup = new HashMap<String, Long>();
// Initiation
for (int i = 0; i < inputNums.length; i++) {
validDigits.add(inputNums[i]);
initNums.add(inputNums[i]);
}
// For ensuring the keys for the lookup table are consists
Collections.sort(initNums);
System.out.println("The number of combinations is " + countDP(N, initNums));
}
private static long countDP(int length, List<Integer> requiredNums) {
// This corresponds to the case that not all given digits are used
if (requiredNums.size() > length) {
return 0;
}
// Base Case
if (requiredNums.size() == 0 && length == 0) {
return 1;
}
// Check for cached result
final String key = requiredNums.toString() + ";" + length;
if (subProbLookup.containsKey(key)) {
return subProbLookup.get(key);
}
long count = 0;
for (Integer i : validDigits) {
// Generate next sub-problem
List<Integer> updatedNums = new ArrayList<Integer>(requiredNums);
if (requiredNums.contains(i)) {
updatedNums.remove(i);
}
count = (count + countDP(length - 1, updatedNums)) % 10000000007L;
}
// Cache the result
subProbLookup.put(key, count);
return count;
}
}