This causes a TLE in case of (9,8)

After comparing with other accepted kernals in other questions, I ran all for 999 times and found it obviously faster in this case and return right result.

The logic is recursion: first arrange [1,2,3,.... k] when k=n

then the result of combine(n) will cover all result of combine(n-1) and those which replace one digit in all single list in result of combine(n-1).

Not fast in most case but at least in this case (9,8) and works.

Why TLE?

```
public class Solution {
public List<List<Integer>> combine(int n, int k) {
if(k>n)
return Collections.<List<Integer>>emptyList();
List<List<Integer>> ans = new ArrayList<List<Integer>>();
if(n==k){
ArrayList<Integer> newlist = new ArrayList<Integer> ();
for(int i = 1; i<= n; i++){
newlist.add(i);
}
ans.add(newlist);
}else{
List<List<Integer>> pre = combine(n-1,k);
for(final List<Integer> oldlist: pre){
ans.add(oldlist);
for(int j = 0; j<k;j++){
List<Integer> newlist = new ArrayList<Integer> (oldlist);
newlist.set(j,n);
ans.add(newlist);
}
}
}
return ans;
}
```