Aprendizaje de inteligencia artificial: Python se da cuenta de una profundización iterativa de la búsqueda en profundidad primero

Aprendizaje de inteligencia artificial: Python implementa un algoritmo de búsqueda en profundidad

Enlace del blog de este artículo:http://blog.csdn.net/jdh99 , autor: jdh, reimprimir, especifique.

alrededores:

Anfitrión: WIN10

Versión de Python: 3.5

Entorno de desarrollo: pyCharm

Descripción:

El mapa de la ciudad rumana en el código fuente es consistente con el mapa en "Aprendizaje de inteligencia artificial: Implementación de Python del algoritmo de búsqueda primero de amplitud" .

Se puede comparar con "Aprendizaje de inteligencia artificial: implementación de Python del algoritmo de búsqueda en profundidad" .

Principio de búsqueda en profundidad primero y pseudocódigo para profundización iterativa:

Análisis de flujo de algoritmos:

Proceso:

La profundidad se profundiza gradualmente, llame a la búsqueda de profundidad primero para buscar

Análisis de rendimiento de algoritmos:

Algunos estados se generan repetidamente. Pero el costo no es tan grande, porque la mayoría de los nodos están en la capa inferior, por lo que la generación repetida de los nodos de la capa superior tiene poco efecto. Número total de nodos generados:

complejidad del tiempo:

En comparación con la búsqueda en amplitud, el costo de generar nodos repetidamente no es grande, por ejemplo:

Código fuente:

import pandas as pd
from pandas import Series, DataFrame

# 城市信息：city1 city2 path_cost
_city_info = None

# 已探索集合
_explored = []


# 节点数据结构
class Node:
    def __init__(self, state, parent, action, path_cost):
        self.state = state
        self.parent = parent
        self.action = action
        self.path_cost = path_cost


def main():
    global _city_info, _explored
    import_city_info()

    while True:
        src_city = input('input src city\n')
        dst_city = input('input dst city\n')
        result = iterative_deepening_search(src_city, dst_city)
        if result == "failure" or result == "cutoff":
            print('from city: %s to city %s search failure' % (src_city, dst_city))
        else:
            print('from city: %s to city %s search success' % (src_city, dst_city))
            path = []
            while True:
                path.append(result.state)
                if result.parent is None:
                    break
                result = result.parent
            size = len(path)
            for i in range(size):
                if i < size - 1:
                    print('%s->' % path.pop(), end='')
                else:
                    print(path.pop())


def import_city_info():
    global _city_info
    data = [{'city1': 'Oradea', 'city2': 'Zerind', 'path_cost': 71},
            {'city1': 'Oradea', 'city2': 'Sibiu', 'path_cost': 151},
            {'city1': 'Zerind', 'city2': 'Arad', 'path_cost': 75},
            {'city1': 'Arad', 'city2': 'Sibiu', 'path_cost': 140},
            {'city1': 'Arad', 'city2': 'Timisoara', 'path_cost': 118},
            {'city1': 'Timisoara', 'city2': 'Lugoj', 'path_cost': 111},
            {'city1': 'Lugoj', 'city2': 'Mehadia', 'path_cost': 70},
            {'city1': 'Mehadia', 'city2': 'Drobeta', 'path_cost': 75},
            {'city1': 'Drobeta', 'city2': 'Craiova', 'path_cost': 120},
            {'city1': 'Sibiu', 'city2': 'Fagaras', 'path_cost': 99},
            {'city1': 'Sibiu', 'city2': 'Rimnicu Vilcea', 'path_cost': 80},
            {'city1': 'Rimnicu Vilcea', 'city2': 'Craiova', 'path_cost': 146},
            {'city1': 'Rimnicu Vilcea', 'city2': 'Pitesti', 'path_cost': 97},
            {'city1': 'Craiova', 'city2': 'Pitesti', 'path_cost': 138},
            {'city1': 'Fagaras', 'city2': 'Bucharest', 'path_cost': 211},
            {'city1': 'Pitesti', 'city2': 'Bucharest', 'path_cost': 101},
            {'city1': 'Bucharest', 'city2': 'Giurgiu', 'path_cost': 90},
            {'city1': 'Bucharest', 'city2': 'Urziceni', 'path_cost': 85},
            {'city1': 'Urziceni', 'city2': 'Vaslui', 'path_cost': 142},
            {'city1': 'Urziceni', 'city2': 'Hirsova', 'path_cost': 98},
            {'city1': 'Neamt', 'city2': 'Iasi', 'path_cost': 87},
            {'city1': 'Iasi', 'city2': 'Vaslui', 'path_cost': 92},
            {'city1': 'Hirsova', 'city2': 'Eforie', 'path_cost': 86}]

    _city_info = DataFrame(data, columns=['city1', 'city2', 'path_cost'])
    # print(_city_info)


def iterative_deepening_search(src_state, dst_state):
    for i in range(100):
        result = depth_limited_search(src_state, dst_state, i)
        if result != "failure" and result != "cutoff":
            return result
    return "cutoff"


def depth_limited_search(src_state, dst_state, limit):
    global _explored
    _explored = []
    node = Node(src_state, None, None, 0)
    return recursive_dls(node, dst_state, limit)


def recursive_dls(node, dst_state, limit):
    """

    :param node:
    :param dst_state:
    :param limit:
    :return: "failure"：失败."cutoff"：被截至.node：成功
    """
    global _city_info, _explored

    if node.parent is not None:
        print('node state:%s parent state:%s' % (node.state, node.parent.state))
    else:
        print('node state:%s parent state:%s' % (node.state, None))
    _explored.append(node.state)

    # 目标测试
    if node.state == dst_state:
        print('this node is goal!')
        return node
    elif limit == 0:
        print('this node is cutoff!')
        return "cutoff"
    else:
        cutoff_occurred = False

        # 遍历子节点
        for i in range(len(_city_info)):
            dst_city = ''
            if _city_info['city1'][i] == node.state:
                dst_city = _city_info['city2'][i]
            elif _city_info['city2'][i] == node.state:
                dst_city = _city_info['city1'][i]
            if dst_city == '':
                continue
            child = Node(dst_city, node, 'go', node.path_cost + _city_info['path_cost'][i])
            # 过滤已探索的点
            if child.state in _explored:
                continue
            print('child node:state:%s path cost:%d' % (child.state, child.path_cost))

            result = recursive_dls(child, dst_state, limit - 1)
            if result == "cutoff":
                cutoff_occurred = True
                print('search failure, child state: %s parent state: %s limit cutoff' %
                      (child.state, child.parent.state))
            elif result != "failure":
                print('search success')
                return result
        if cutoff_occurred:
            return "cutoff"
        else:
            return "failure"


if __name__ == '__main__':
    main()

Prueba: Navega de Zerind a Urziceni:

input src city
Zerind
input dst city
Urziceni
node state:Zerind parent state:None
this node iscutoff!
node state:Zerind parent state:None
child node:state:Oradea path cost:71
node state:Oradea parent state:Zerind
this node iscutoff!
search failure, child state: Oradea parent state: Zerind limitcutoff
child node:state:Arad path cost:75
node state:Arad parent state:Zerind
this node iscutoff!
search failure, child state: Arad parent state: Zerind limit cutoff
node state:Zerind parent state:None
child node:state:Oradea path cost:71
node state:Oradea parent state:Zerind
child node:state:Sibiu path cost:222
node state:Sibiu parent state:Oradea
this node iscutoff!
search failure, child state: Sibiu parent state: Oradea limitcutoff
search failure, child state: Oradea parent state: Zerind limitcutoff
child node:state:Arad path cost:75
node state:Arad parent state:Zerind
child node:state:Timisoara path cost:193
node state:Timisoara parent state:Arad
this node iscutoff!
search failure, child state: Timisoara parent state: Arad limitcutoff
search failure, child state: Arad parent state: Zerind limit cutoff
node state:Zerind parent state:None
child node:state:Oradea path cost:71
node state:Oradea parent state:Zerind
child node:state:Sibiu path cost:222
node state:Sibiu parent state:Oradea
child node:state:Arad path cost:362
node state:Arad parent state:Sibiu
this node iscutoff!
search failure, child state: Arad parent state: Sibiu limit cutoff
child node:state:Fagaras path cost:321
node state:Fagaras parent state:Sibiu
this node iscutoff!
search failure, child state: Fagaras parent state: Sibiu limitcutoff
child node:state:Rimnicu Vilcea path cost:302
node state:Rimnicu Vilcea parent state:Sibiu
this node iscutoff!
search failure, child state: Rimnicu Vilcea parent state: Sibiu limitcutoff
search failure, child state: Sibiu parent state: Oradea limitcutoff
search failure, child state: Oradea parent state: Zerind limit cutoff
node state:Zerind parent state:None
child node:state:Oradea path cost:71
node state:Oradea parent state:Zerind
child node:state:Sibiu path cost:222
node state:Sibiu parent state:Oradea
child node:state:Arad path cost:362
node state:Arad parent state:Sibiu
child node:state:Timisoara path cost:480
node state:Timisoara parent state:Arad
this node iscutoff!
search failure, child state: Timisoara parent state: Arad limitcutoff
search failure, child state: Arad parent state: Sibiu limit cutoff
child node:state:Fagaras path cost:321
node state:Fagaras parent state:Sibiu
child node:state:Bucharest path cost:532
node state:Bucharest parent state:Fagaras
this node iscutoff!
search failure, child state: Bucharest parent state: Fagaras limitcutoff
search failure, child state: Fagaras parent state: Sibiu limitcutoff
child node:state:Rimnicu Vilcea path cost:302
node state:Rimnicu Vilcea parent state:Sibiu
child node:state:Craiova path cost:448
node state:Craiova parent state:Rimnicu Vilcea
this node iscutoff!
search failure, child state: Craiova parent state: Rimnicu Vilcea limitcutoff
child node:state:Pitesti path cost:399
node state:Pitesti parent state:Rimnicu Vilcea
this node iscutoff!
search failure, child state: Pitesti parent state: Rimnicu Vilcea limitcutoff
search failure, child state: Rimnicu Vilcea parent state: Sibiu limitcutoff
search failure, child state: Sibiu parent state: Oradea limit cutoff
search failure, child state: Oradea parent state: Zerind limit cutoff
node state:Zerind parent state:None
child node:state:Oradea path cost:71
node state:Oradea parent state:Zerind
child node:state:Sibiu path cost:222
node state:Sibiu parent state:Oradea
child node:state:Arad path cost:362
node state:Arad parent state:Sibiu
child node:state:Timisoara path cost:480
node state:Timisoara parent state:Arad
child node:state:Lugoj path cost:591
node state:Lugoj parent state:Timisoara
this node iscutoff!
search failure, child state: Lugoj parent state: Timisoara limitcutoff
search failure, child state: Timisoara parent state: Arad limitcutoff
search failure, child state: Arad parent state: Sibiu limit cutoff
child node:state:Fagaras path cost:321
node state:Fagaras parent state:Sibiu
child node:state:Bucharest path cost:532
node state:Bucharest parent state:Fagaras
child node:state:Pitesti path cost:633
node state:Pitesti parent state:Bucharest
this node iscutoff!
search failure, child state: Pitesti parent state: Bucharest limitcutoff
child node:state:Giurgiu path cost:622
node state:Giurgiu parent state:Bucharest
this node iscutoff!
search failure, child state: Giurgiu parent state: Bucharest limitcutoff
child node:state:Urziceni path cost:617
node state:Urziceni parent state:Bucharest
this node isgoal!
search success
search success
search success
search success
search success
from city: Zerind to city Urziceni searchsuccess
Zerind->Oradea->Sibiu->Fagaras->Bucharest->Urziceni

可以看出，与深度优先搜索算法相比，本算法可以找出更优深度的路径。

Aprendizaje de inteligencia artificial: Python se da cuenta de una profundización iterativa de la búsqueda en profundidad primero

Supongo que te gusta