# My Recursive Java Solution(Not Backtracking), 2ms

• This is a recursive solution, but it does not follow the regular backtracking pattern. The underlying idea is simple. I'll use 40 as an example:
The minimum factor to try is 2, and it works: 40=2*20.
Then, to get the rest of solutions that start with 2, I'll only need to work out all the ways to factorize 20. And for every solution, I only need to add the number 2 to the front. For example, 20 can be factorized as 4 and 5. So, one of all the solutions for 20 is [4, 5]. We only need to add 2 to the front, to get the solution for 40: [2, 4, 5]. This works similarly for [2, 10] and [2, 2, 5].

By the way, it surprises me that this runs only 2ms, because it involves moving backwards every item in an array by one, and I thought it would run slower than most submissions.

``````public class Solution {
public List<List<Integer>> getFactors(int n) {
return factorsHelper(n, 2);
}

private ArrayList<List<Integer>> factorsHelper(int n, int minFactor){
ArrayList<List<Integer>> solutions = new ArrayList<>();
ArrayList<List<Integer>> subSolutions;
int factor, quotient;

for(factor = minFactor, quotient = n/factor; factor <= quotient; factor++, quotient = n/factor) {
if(n%factor == 0) {
ArrayList<Integer> factors = new ArrayList<>();
subSolutions = factorsHelper(quotient, factor);

for(int cnt = 0; cnt < subSolutions.size(); cnt++) {