Hay dos conceptos importantes recursión: recursiva y los límites (llamada) recursiva
Ejemplo 1: utilizando la solución recursiva de n factorial
#include <cstdio>
using namespace std;
int F(int n) {
if (n == 0) return 1; //递归边界为0
else return F(n - 1)*n; //没有达到递归边界时，使用递归式递归调用下去
}
int main()
{
int n;
scanf("%d", &n);
printf("%d\n", F(n));
return 0;
}
Ejemplo 2: encontrar el término n-ésimo de la secuencia de Fibonacci
#include "stdafx.h"
#include <cstdio>
using namespace std;
int F(int n) {
if (n == 1 || n == 2) return 1;
else return F(n - 1) + F(n - 2);
}
int main()
{
int n;
scanf("%d", &n);
printf("%d\n", F(n));
return 0;
}
El código anterior, de hecho, es dividir y conquistar un reflejo de problemas ideológicos F (n) es el combinado (n-1) y F (n-2) de dos sub-preguntas F.
Ejemplo 3: problema de alineación completa (Full Permutación)
#include "stdafx.h"
#include <cstdio>
const int maxn = 11;
int n, P[maxn], hashTable[maxn] = { false };
using namespace std;
void rowF(int index) {
if (index == n + 1) //递归边界
{
for (int i = 1; i <= n; i++)
{
printf("%d", P[i]); //输出当前自问题的解
}
printf("\n");
return;
}
else //没有达到递归边界时，使用递归式递归调用下去
{
for (int i = 1; i <= n; i++)
{
if (hashTable[i] == false)
{
P[index] = i;
hashTable[i] = true;
rowF(index + 1);
hashTable[i] = false;
}
}
}
}
int main()
{
n = 3;
rowF(1); //从第一行开始
return 0;
}
. Ejemplo 4: n reinas problema
n reinas veintidós no en la misma fila de la matriz de n * n, misma columna, el mismo en una línea diagonal, el número de programas buscan legal.El libro proporciona una buena idea: teniendo en cuenta el número por fila sólo puede colocar una reina, la reina de la fila n la columna con el fin de escribir, se disponen en un 1 hasta n, que entran en una + gama completa de pruebas cuestión de si el problema de la misma diagonal.
#include "stdafx.h"
#include <cstdio>
#include<math.h>
const int maxn = 11;
int count = 0;
int n, P[maxn], hashTable[maxn] = { false };
using namespace std;
void rowF(int index) {
if (index == n + 1) //递归边界
{
//for (int i = 1; i <= n; i++) printf("%d", P[i]); //输出当前问题的解
//printf("\n");
bool flag = true; //表示当前排列为一个合法方案
for (int i = 1; i <= n; i++) //遍历任意两个皇后
{
for (int j = i + 1; j <= n; j++)
{
if (abs(i - j) == abs(P[i] - P[j])) //如果在同一条对角线上
{
flag = false; //不合法
}
}
}
if (flag) count++; //若当前方案合法，令count+1 这里是否要担心把列的组合算进去呢？ 不用，不存在列的组合吗？不存在吗 不存在
return;
}
else //没有达到递归边界时，使用递归式递归调用下去
{
for (int i = 1; i <= n; i++)
{
if (hashTable[i] == false)
{
P[index] = i;
hashTable[i] = true;
rowF(index + 1);
hashTable[i] = false;
}
} //这里的i是一个列的循环，没有返回，到n即停（当然也可以看成为行服务），所以上面的index==n+1更像是为行服务，一行到头，则输出行/做出合法判断
} //为什么行能返回列不会返回导致无限循环呢，因为有个 hashTable[i] = false;吗？
} //不是，因为对于列而言，其实只有一个for语句，在这个for语句里，进行完就完了
//但是对于行而言，它是列语句每个for语句里的一个小的递归（递归的集合直到行结束，然后会回到列的for语句中）
int main()
{
scanf("%d", &n);
rowF(1); //从第一行开始
printf("%d\n", count);
return 0;
}
Tenga en cuenta que hay un período de comentarios, para ayudar a entender, de hecho, para la gama completa de comprensión suficiente o exhaustiva
El código anterior línea de pensamiento mejorarDelante de la línea de pensamiento, en esencia, es un método de fuerza bruta
se puede encontrar, para algunos casos, cuando una parte de las reinas se han colocado (parte generada de la matriz), el resto de la emperatriz no se puede colocar, por muy legítima, es no hacia abajo recursiva un retorno directo a la alta
El dar marcha atrás definición:Si una capa recursiva antes de llegar a la frontera, ya que los hechos no tienen que conducir a una sub-problemas de forma recursiva cualquiera, puede volver directamente a la anterior
o menos es la mejora de código:
#include "stdafx.h"
#include <cstdio>
#include<math.h>
const int maxn = 11;
int count = 0;
int n, P[maxn], hashTable[maxn] = { false };
using namespace std;
void rowF(int index) {
if (index == n + 1) //递归边界
{
count++; //若当前方案合法，令count+1
return;
}
else //没有达到递归边界时，使用递归式递归调用下去
{
for (int i = 1; i <= n; i++) //第i行
{
if (hashTable[i] == false) //第i行还没有皇后
{
bool flag = true;
for (int pre = 1; pre < index; pre++)
//第index列皇后的行号为i，第pre列皇后的行号为P[pre]
{
if (abs(index - pre) == abs(i - P[pre]))
{
flag = false; //同一对角线，冲突
break;
}
}
if (flag)
{
P[index] = i;
hashTable[i] = true; //第x行被占用
rowF(index + 1); //递归处理第index+1行皇后
hashTable[i] = false; //递归完毕，换原第x行未占用
}
}
}
}
}
int main()
{
scanf("%d", &n);
rowF(1); //从第一行开始
printf("%d\n", count);
return 0;
}
práctica
comer dulces
Descripción Título
nombre de la madre de la parte posterior viaje de nombre de campo con una caja de bombones deliciosos nombre nombre fina (caja de bombones N total, 20> N> 0).
Mamá le dice a dar nombres pueden comer un trozo de chocolate de un día o dos.
Asumir comer chocolate cada día dar nombres, nombres de nombre y le preguntó cómo muchos tipos diferentes de comer programa de chocolate.
Por ejemplo:
si N = 1, entonces el nombre del nombre en el primer día a comer, Total 1 realización;
si n = 2, el nombre puede ser el nombre de un alimento en el Día 1, Día 2 comen 1, puede ser primero día para comer 2, un total de dos tipos de programas;
si N = 3, entonces el nombre del nombre de la primera día para comer una, los dos restantes pueden ser el primer día de comer dos dejaron uno, los nombres de un total de 2 + 1 = 3 tipos de programas;
si N = 4, el nombre puede ser el nombre de un alimento en el día 1, a la izquierda 3, puede tomar dos en el día 1, los dos restantes, con un total de 3 + 2 = 5 tipos de programas.
Ahora N dado, encontrar el programa se escribe el número de programas Cocina famoso chocolate.
De entrada
de entrada sólo una línea, es decir, el número entero N.
De salida
puede ser múltiples conjuntos de datos de prueba para cada conjunto de datos,
la salida de una sola línea, es decir, el número de programa de nombres Cocina chocolate.
entrada de la muestra
. 1
2
. 4
muestra de salida
. 1
2
. 5
#include <cstdio>
#include<math.h>
int count;
void func(int index)
{
if (index == 0) return;
if (index==1)
{
count++;
return;
}
if (index == 2)
{
count += 2;
}
if (index != 0 && index != 1 && index != 2 )
{
for (int i = 1; i <= 2; i++)//这里有没有等号？我觉得有：今天吃i块
{
func(index-i);
}
}
}
int main()
{
int N;
while (scanf("%d", &N) != EOF)
{
count = 0;
func(N);
printf("%d\n", count);
}
return 0;
}
progresión
Título Descripción
de escritura una solicitud número Fibonacci de función recursiva, un valor para n, se utiliza la función recursiva, el patrón de salida de la siguiente manera (ver ejemplos).
De entrada
de entrada de la primera muestra de comportamiento número m, hay m filas cada fila siguiente entero n, n no excede de 10.
Salida
patrón (véase el formato de muestra) correspondiente a cada muestra de salida requerida.
#include <cstdio>
#include<math.h>
int outputraw[30];
int func(int index)
{
if (index == 1)
{
return 0;
}
if (index == 2)
{
return 1;
}
if (index != 2 && index != 1)
{
return func(index - 1) + func(index - 2);
}
}
int main()
{
int N,M;
int temp = 1;
while (scanf("%d", &M) != EOF)
{
for (int j = 0; j < M; j++)
{
scanf("%d", &N);
for (int i = 0; i < N; i++)
{
for (int j = temp; j <= 2 * i + 1; j++)
{
outputraw[j] = func(j);
temp = j;
}
for (int k = 1; k < N - i; k++)
{
printf(" ");
}
for (int j = 1; j <= 2 * i + 1; j++)
{
printf("%d", outputraw[j]);
if (j != 2 * i + 1)
printf(" ");
}
printf("\n");
}
}
}
return 0;
}
bolsillo de la magia
Esta pregunta no puede ser!
Descripción Título
tiene un bolsillo mágico, el volumen total fue de 40, con algunas variaciones de este artículo bolsillos, el volumen total de estos elementos debe ser de 40. John ahora hay n elementos que se obtiene, el volumen de cada elemento, respectivamente, a1, a2 ...... una. John puede seleccionarse de algunos de estos elementos, si se selecciona el volumen total del objeto 40, a continuación, utilizar el bolsillo magia, John estos artículos puede ser obtenido. La pregunta ahora es, ¿Cuántas John diferentes formas de seleccionar elementos.
De entrada
de la primera línea de entrada es un número entero positivo n (1 <= n <= 20), indica el número de artículos diferentes. Los siguientes n líneas, cada línea tiene un entero positivo entre 1 y 40, respectivamente, dar valores de a1, a2 ...... una a.
La salida de
la serie de elementos diferentes selecciona el modo de salida.
ocho reinas
Título Descripción
juego de ajedrez son gente muy claro: la reina no puede comer otra pieza al número de pasos en la diagonal horizontal, vertical. Cómo ocho reinas en el tablero de ajedrez (8 * 8 plazas), de modo que no se pueden comer por cualquier persona! Este es el famoso problema de las ocho reinas.
8. Un método para la colocación de una reina para satisfacer los requisitos de la definición de una secuencia que corresponde a una reina, es decir, a = B1B2 ... b8, donde bi es el número correspondiente de columnas en la fila i Pendulum Queen ubicados. 8 se conoce un total de 92 Queens conjunto de soluciones (es decir, 92 cadenas diferentes Queen).
Un número dado b, b de las cadenas de salida requeridas. comparación de cadenas es tal que: antes de Queen Queen dispuesta secuencia de la secuencia x y, y si y sólo si x es menor que cuando se considera número entero.
Entrada
de línea 1 es un conjunto de un número n de los datos de prueba, seguido por n líneas de entrada. Cada conjunto de datos de prueba que representa una línea, que comprende un número entero b positivo (1 <= b <= 92)
da salida a
la salida tiene n filas, cada fila corresponde a una salida de entrada. La salida debe ser un número entero positivo, b es la reina de la cadena correspondiente.
#include <string>
#include <iostream>
#include "stdafx.h"
#include<math.h>
#include <cstdio>
int output[100] = { 0 };
int temp[10];
bool hashTable[10] = { false };
int c_count = 1;
int x = 8;
void func_g(int index)
{
if (index == x+1)
{
for (int j = 1; j <= x; j++)
{
output[c_count] = output[c_count] * 10 + temp[j];
}
c_count++;
return;
}
else
{
for (int i = 1; i <= x; i++)
{
if (hashTable[i] == false)
{
bool flag = true;
for (int p = 1; p < index; p++)
{
if (abs(p - index) == abs(i - temp[p]))
{
flag = false;
break;
}
}
if (flag)
{
temp[index] = i;
hashTable[i] = true;
func_g(index + 1);
hashTable[i] = false;
}
}
}
}
}
int main()
{
int n;
int b[200] = { 0 };
func_g(1);
sort(output+1, output + c_count);
while (scanf("%d", &n) != EOF)
{
for (int i = 1; i <= n; i++)
{
scanf("%d", &b[i]);
printf("%d\n", output[b[i]]);
}
}
}
