人工智能学习：python实现深度优先搜索算法

人工智能学习：python实现深度优先搜索算法

本文博客链接:http://blog.csdn.net/jdh99,作者:jdh,转载请注明.

 

环境：

主机:WIN10

python版本:3.5

开发环境:pyCharm

说明：

深度优先搜索原理和伪代码：

 

 

 

 

算法流程分析：

数据结构：

• limit：深度限制。每深入1层，本变量减1，到0则返回截至cutoff（表示不能再深入）
• 返回结果：
  • solution：成功
  • failure：失败
  • cutoff：limit为0，截至

流程：

• 节点目标测试：通过返回。否则判断limit是否为0，为0返回失败
• 设置截至标志：cutoff_occurred，初值为false
• 遍历节点的所有动作
  • 每个动作产生子节点
  • 递归子节点，参数中的深度：limit-1。递归结果返回到变量result
  • result如果为成功则返回成功，如果是cutoff，则变量cutoff_occurred=true
• 如果cutoff_occurred为true，则返回cutoff，否则返回失败

 

本算法会从第1个节点开始深度遍历，直到limit被消耗完，才返回。

 

 

算法性能分析：

• 有限空间是完备的，否则是不完备的
• 不是最优的

源码中的罗马尼亚城市地图与 《人工智能学习：python实现宽度优先搜索算法》中的地图一致。

源码：

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')
        limit = int(input('input limit\n'))
        result = depth_limited_search(src_city, dst_city, limit)
        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 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()

运行实例：

从Zerind导航到Urziceni，深度限制为20：

input src city
Zerind
input dst city
Urziceni
input limit
6
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
child node:state:Mehadia path cost:661
node state:Mehadia parent state:Lugoj
this node is cutoff!
search failure, child state: Mehadia parent state: Lugoj limit cutoff
search failure, child state: Lugoj parent state: Timisoara limit cutoff
search failure, child state: Timisoara parent state: Arad limit cutoff
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
child node:state:Rimnicu Vilcea path cost:730
node state:Rimnicu Vilcea parent state:Pitesti
this node is cutoff!
search failure, child state: Rimnicu Vilcea parent state: Pitesti limit cutoff
child node:state:Craiova path cost:771
node state:Craiova parent state:Pitesti
this node is cutoff!
search failure, child state: Craiova parent state: Pitesti limit cutoff
search failure, child state: Pitesti parent state: Bucharest limit cutoff
child node:state:Giurgiu path cost:622
node state:Giurgiu parent state:Bucharest
child node:state:Urziceni path cost:617
node state:Urziceni parent state:Bucharest
this node is goal!
search success
search success
search success
search success
search success
from city: Zerind to city Urziceni search success
Zerind->Oradea->Sibiu->Fagaras->Bucharest->Urziceni

从Zerind导航到Urziceni，深度限制为6：

input src city
Zerind
input dst city
Urziceni
input limit
6
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
child node:state:Mehadia path cost:661
node state:Mehadia parent state:Lugoj
this node is cutoff!
search failure, child state: Mehadia parent state: Lugoj limit cutoff
search failure, child state: Lugoj parent state: Timisoara limit cutoff
search failure, child state: Timisoara parent state: Arad limit cutoff
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
child node:state:Rimnicu Vilcea path cost:730
node state:Rimnicu Vilcea parent state:Pitesti
this node is cutoff!
search failure, child state: Rimnicu Vilcea parent state: Pitesti limit cutoff
child node:state:Craiova path cost:771
node state:Craiova parent state:Pitesti
this node is cutoff!
search failure, child state: Craiova parent state: Pitesti limit cutoff
search failure, child state: Pitesti parent state: Bucharest limit cutoff
child node:state:Giurgiu path cost:622
node state:Giurgiu parent state:Bucharest
child node:state:Urziceni path cost:617
node state:Urziceni parent state:Bucharest
this node is goal!
search success
search success
search success
search success
search success
from city: Zerind to city Urziceni search success
Zerind->Oradea->Sibiu->Fagaras->Bucharest->Urziceni