Introduction à l'algorithme: le suivi
arrière (exploration et retour arrière) est une sorte de méthode de recherche optimale, également connue sous le nom de méthode heuristique, qui recherche vers l'avant en fonction des conditions optimales pour atteindre l'objectif. Cependant, lors de l'exploration d'une certaine étape, on constate que le choix initial n'est pas bon ou n'atteint pas le but, puis une étape est retournée pour être resélectionnée. Cette technique de retour et de retour est une méthode rétrospective et un certain point de l'état qui remplit la condition rétrospective C'est ce qu'on appelle le «point de retour en arrière».
Vernaculaire: La méthode de retour en arrière peut être comprise comme la recherche d'une destination en sélectionnant différentes fourches, en essayant de trouver la destination une par une. Si vous vous trompez, continuez de revenir pour trouver une autre route à l'intersection jusqu'à ce que vous trouviez votre destination.
Selon la définition, pour effectuer un retour en arrière, deux points et une recherche sont nécessaires Deux espaces de
solution L' espace de solution est un vecteur comme un tableau [a1, a2, ..., an]. Chaque élément de ce vecteur est une solution partielle au problème. Ce n'est que lorsque chaque élément de ce tableau est rempli (pour obtenir toutes les solutions) qu'il montre que le problème a été résolu. La difficulté de presque tous les problèmes de retour arrière réside donc dans la définition de l'espace de solution.
Le modèle suivant s'applique à tous les problèmes de "détermination de retour arrière"! ! !
def backtrack(i, n, *args)
if condition:
add_answer()
else:
change()
backtrack(i+1, n, *args);
remove_change()
Ensuite, nous allons approfondir le
problème d' espace de l' algorithme de retour en arrière à travers le sujet spécifique. Le problème de
n reines est d'étudier comment placer n reines sur un échiquier n × n, et empêcher les reines de s'attaquer.
Étant donné un entier n, retournez toutes les différentes solutions n queen.
Chaque solution contient un schéma clair de placement des pièces à problème n-reine, où «Q» et «.» Représentent la reine et le poste vacant, respectivement.
Voici le code principal de retour en arrière:
def backtrack(row):
for col in range(len(cb)):
if judge(row, col)：
#开始试探
place_queen(row, col)
if row == len(cb) - 1:
add_cb()
else:
backtrack(row + 1)
#回到原点
remove_queen(row, col)
Problème 2
Étant donné une chaîne de caractères s, divisez s en sous-chaînes de sorte que chaque sous-chaîne soit une chaîne palindrome.
Renvoie tous les schémas de fractionnement possibles.
def backtrack(start):
for end in range(start, len(s)):
if judge(s[start:end + 1]):
temp.append(s[start:end+1])
if end + 1 == len(s):
save = copy.deepcopy(temp)
ans.append(save)
else:
backtrack(end + 1)
temp.pop()
Sujet 3 Le
nombre accumulé est une chaîne et les nombres qui le composent peuvent former une séquence accumulée.
Une séquence d'accumulation valide doit contenir au moins 3 chiffres. À l'exception des deux premiers nombres, les autres nombres de la chaîne sont égaux à la somme des deux nombres précédents.
Étant donné une chaîne contenant uniquement les chiffres «0» - «9», écrivez un algorithme pour déterminer si l'entrée donnée est un nombre cumulatif.
Explication: Les nombres dans la séquence d'accumulation ne commenceront pas par 0, il n'y aura donc pas de cas de 1, 2, 03 ou 1, 02, 3.
#初始三个数通过for循环获取，这里只摘取回溯部分
def backtrack(num1, num2, num3, tot):
if judge(num1, num2, num3):
if tot + 1 == len(num):
self.ans = True
else:
for tot1 in range(tot + 1, len(num)):
if num[tot + 1] == '0' and tot + 1 != tot1:
continue
backtrack(num2, num3, int(num[tot + 1: tot1 + 1]), tot1)
