Recursión: O(2^n)
llamate a ti mismo
Ejemplos y plantillas de código:
secuencia Fibonacci
Ingrese un número entero n y encuentre el término n de la secuencia de Fibonacci.
Suponiendo que a partir de 0, el elemento 0 es 0.
rango de datos
0≤n≤39
muestra
输入整数 n=5
返回 5#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;
int Fibonacci(int n){
if(n==0) return 0;
if(n==1) return 1;
if(n==2) return 1;
return Fibonacci(n-1)+Fibonacci(n-2);
}
int main(){
int n;
cin>>n;
cout<<Fibonacci(n)<<endl;
return 0;
} O(n*2^n)
Implementación recursiva de enumeración exponencial
Seleccione aleatoriamente cualquier número de n enteros de 1∼n y genere todas las opciones posibles.
formato de entrada
Introduzca un número entero n.
formato de salida
Salida de un esquema por línea.
Los números en la misma línea deben colocarse en orden ascendente y dos números adyacentes deben estar separados por exactamente un espacio.
Para los esquemas que no eligen ningún número, genere una línea en blanco.
Esta pregunta tiene un validador personalizado (SPJ), y el orden entre líneas (diferentes esquemas) es arbitrario.
rango de datos
1≤n≤15
Muestra de entrada:
3
Salida de muestra:
3
2
2 3
1
1 3
1 2
1 2 3
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=15;
int n;
int st[N];
void dfs(int u){
if(u==n){
for(int i=0;i<n;i++){
if(st[i]==1)
cout<<i+1<<" ";
}
cout<<endl;
return ;
}
st[u]=2;
dfs(u+1);
st[u]=0;
st[u]=1;
dfs(u+1);
st[u]=0;
}
int main(){
cin>>n;
dfs(0);
return 0;
}Implementación recursiva de enumeración de permutación.
Organice n enteros del 1 al n en una fila y baraje aleatoriamente el orden, y genere todos los pedidos posibles.
formato de entrada
un número entero
formato de salida
Muestra todas las soluciones en orden ascendente, 1 por línea.
Primero, dos números adyacentes en la misma línea están separados por un espacio.
En segundo lugar, para dos filas diferentes, compare los números correspondientes a los subíndices uno por uno, y el que tiene el orden lexicográfico más pequeño ocupa el primer lugar.
rango de datos
1≤n≤9
Muestra de entrada:
3
Salida de muestra:
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
complejidad del tiempo:
Un total de n capas de recursividad:
La primera capa es: O(n)
La segunda capa: hay n ramas, cada rama tiene un ciclo for, es decir O(n*n)
La tercera capa: hay n*(n-1) ramas, cada rama tiene un bucle for, es decir, O(n*(n-1)*n)
……
Capa n (nodos hoja): ¡Hay n! ramas, cada rama tiene un bucle for, que es O(n!*n)
Entonces la complejidad del tiempo total es: n(1+n+n(n-1)+...+n!)
(1+n+n(n-1)+...+n!) es equivalente a: (n!+n!/1+n!/(1*2)+n!/(1*2*3 ) +++n!/(n-1)!+n!/n!); Primero, esta ecuación debe ser mayor que n! y menor que (n!+n!/1+n!/2+n! /4+ ...+n!/2^(n-1)+n!/2^n) eso es 3n!
Entonces, la complejidad temporal de esta pregunta es O(3n*n!), es decir, O(n*n!)
#include<cstring>
#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=10;
int n,state[N];
bool used[N];
void dfs(int u) {
if(u>n) {
for(int i=1; i<=n; i++)
cout<<state[i]<<" ";
cout<<endl;
return ;
}
for(int i=1; i<=n; i++) {
if(!used[i]) {
state[u]=i;
used[i]=true;
dfs(u+1);
state[u]=0;
used[i]=false;
}
}
}
int main() {
cin>>n;
dfs(1);
return 0;
}