¿Por qué a veces necesitamos sacar explícitamente después de una recursión cuando hacemos retroceso?

Por ejemplo, consideremos una tarea en la que necesitamos encontrar todas las permutaciones de una cadena dada preservando la secuencia de caracteres pero cambiando la mayúscula y minúscula.

Aquí hay una solución de backtracking sin .pop():

def letterCasePermutation(S):
“””
:type S: str
:rtype: List[str]
“””
def backtrack(sub=””, i=0):
if len(sub) == len(S):
res.append(sub)
else:
if S[i].isalpha():
backtrack(sub + S[i].swapcase(), i + 1)
backtrack(sub + S[i], i + 1)

res = []
backtrack()
return res

Y aquí hay una solución con .pop():

def letterCasePermutation(s):
def backtrack(idx, path):
if idx == n:
res.append(“”.join(path))
return

    ele = s[idx]
    if ele.isnumeric():
        path.append(ele)
        backtrack(idx + 1, path)
        path.pop()
    else:
        path.append(ele.lower())
        backtrack(idx + 1, path)
        path.pop()
        path.append(ele.upper())
        backtrack(idx + 1, path)
        path.pop()

n = len(s)
res = []
backtrack(0, [])
return res

¿Ambos ejemplos de código son backtracking, o debería llamar al primer ejemplo DFS y al segundo backtracking?