人工智能导论实训 第三章 通过搜索进行问题求解

任务描述

本关任务：

了解有信息搜索策略的算法思想；

能够运用计算机语言实现搜索算法；

应用A*搜索算法解决罗马尼亚问题；

相关知识

A搜索
算法介绍
A算法常用于 二维地图路径规划，算法所采用的启发式搜索可以利用实际问题所具备的启发式信息来指导搜索，从而减少搜索范围，控制搜索规模，降低实际问题的复杂度。

算法原理：
A*算法的原理是设计一个代价估计函数：其中 **评估函数F(n)**是从起始节点通过节点n的到达目标节点的最小代价路径的估计值，函数G(n)是从起始节点到n节点的已走过路径的实际代价，函数H(n)是从n节点到目标节点可能的最优路径的估计代价 。

函数 H(n)表明了算法使用的启发信息，它来源于人们对路径规划问题的认识，依赖某种经验估计。根据 F(n)可以计算出当前节点的代价，并可以对下一次能够到达的节点进行评估。

采用每次搜索都找到代价值最小的点再继续往外搜索的过程，一步一步找到最优路径。

编程要求
罗马尼亚问题：agent在罗马尼亚度假，目前位于 Arad 城市。agent明天有航班从Bucharest 起飞，不能改签退票。

现在你需要寻找到 Bucharest 的最短路径，在右侧编辑器补充void A_star(int goal,node &src,Graph &graph)函数，使用编写的搜索算法代码求解罗马尼亚问题：

测试说明
平台会对你编写的代码进行测试：

预期输出：

solution: 0-> 15-> 14-> 13-> 1-> end
cost:418

开始你的任务吧，祝你成功！

#include<iostream>
#include<vector>
#include<memory.h>
#include<stack>
#include<algorithm>
#define A 0
#define B 1
#define C 2
#define D 3
#define E 4
#define F 5
#define G 6
#define H 7
#define I 8
#define L 9
#define M 10
#define N 11
#define O 12
#define P 13
#define R 14
#define S 15
#define T 16
#define U 17
#define V 18
#define Z 19

using namespace std;

int h[20] =
{ 366,0,160,242,161,
178,77,151,226,244,
241,234,380,98,193,
253,329,80,199,374 };

struct node
{
    int g;
    int h;
    int f;
    int name;
    node(int name, int g, int h)
    {
        this->name = name;
        this->g = g;
        this->h = h;
        this->f = g + h;
    };
    bool operator <(const node &a)const
    {
        return f < a.f;
    }
};


class Graph
{
public:
    Graph()
    {
        memset(graph, -1, sizeof(graph));
    }
    int getEdge(int from, int to)
    {
        return graph[from][to];
    }
    void addEdge(int from, int to, int cost)
    {
        if (from >= 20 || from < 0 || to >= 20 || to < 0)
            return;
        graph[from][to] = cost;
    }
    
	void init(){
        addEdge(O, Z, 71);
        addEdge(Z, O, 71);

        addEdge(O, S, 151);
        addEdge(S, O, 151);

        addEdge(Z, A, 75);
        addEdge(A, Z, 75);

        addEdge(A, S, 140);
        addEdge(S, A, 140);

        addEdge(A, T, 118);
        addEdge(T, A, 118);

        addEdge(T, L, 111);
        addEdge(L, T, 111);

        addEdge(L, M, 70);
        addEdge(M, L, 70);

        addEdge(M, D, 75);
        addEdge(D, M, 75);

        addEdge(D, C, 120);
        addEdge(C, D, 120);

        addEdge(C, R, 146);
        addEdge(R, C, 146);

        addEdge(S, R, 80);
        addEdge(R, S, 80);

        addEdge(S, F, 99);
        addEdge(F, S, 99);

        addEdge(F, B, 211);
        addEdge(B, F, 211);

        addEdge(P, C, 138);
        addEdge(C, P, 138);

        addEdge(R, P, 97);
        addEdge(P, R, 97);

        addEdge(P, B, 101);
        addEdge(B, P, 101);

        addEdge(B, G, 90);
        addEdge(G, B, 90);

        addEdge(B, U, 85);
        addEdge(U, B, 85);

        addEdge(U, H, 98);
        addEdge(H, U, 98);

        addEdge(H, E, 86);
        addEdge(E, H, 86);

        addEdge(U, V, 142);
        addEdge(V, U, 142);

        addEdge(I, V, 92);
        addEdge(V, I, 92);

        addEdge(I, N, 87);
        addEdge(N, I, 87);
	}

private:
    int graph[20][20];
};

bool list[20];
vector<node> openList;
bool closeList[20];
stack<int> road;
int parent[20];

void A_star(int goal,node &src,Graph &graph)
{
    openList.push_back(src);
    sort(openList.begin(), openList.end());
    
    while (!openList.empty())
    {
        /********** Begin **********/
		node current = openList[0];//取出第一个节点，第一个节点的f值是最小的   
        if (current.name == goal)//如果是目标节点，那么结束循环         
            break;    
        openList.erase(openList.begin());//将节点从openList表中拿出     
        list[current.name] = false;        
        sort(openList.begin(), openList.end());//对openList重新排序    
        closeList[current.name] = true;//将节点加入closeList中        
        //以下开始遍历和当前节点相邻的点        
        for (int i = 0; i < 20; i++)        
        {            
            if (graph.getEdge(current.name, i) != -1)//如果值不等于-1，则代表相邻       
            {                
                if(closeList[i])//如果已经在closeList表中，则查下下一个点     
                    continue;                
                else if (list[i])//如果在openList表中                
                {                    
                    //以下进行的操作是，从openList中找到这个节点         
                    int num = 0;                    
                    for (vector<node>::iterator it = openList.begin(); it != openList.end(); it++)  
                    {                        
                        if (it->name == i)                            
                            break;                        
                        num++;                    
                    }                    
                    //如果经过current到达i点更好的话，也就是g值更小，则更新这个节点         
                    if (current.g + graph.getEdge(current.name, i) < openList[num].g)   
                    {                        
                        openList[num].g = current.g + graph.getEdge(current.name, i);  
                        openList[num].f = openList[num].g + openList[num].h;         
                        parent[i] = current.name;                        
                        list[i] = true;                    
                    }                
                }                
                else                
                {                    
                    //如果这个点既不在openList也不在closeList则创建一个新点，将这个点加入openList      
                    node newNode(i, graph.getEdge(current.name, i), h[i]); 
                    parent[i] = current.name;                    
                    openList.push_back(newNode);                    
                    sort(openList.begin(), openList.end());                
                }            
            }        
        }

		/********** End **********/  
    }
}

void print_result(Graph &graph)
{
    int p = openList[0].name;
    int lastNodeNum;
    road.push(p);
    while (parent[p] != -1)
    {
        road.push(parent[p]);
        p = parent[p];
    }
    lastNodeNum = road.top();
    int cost = 0;
    cout << "solution: ";
    while (!road.empty())
    {
        cout << road.top() << "-> ";
        if (road.top() != lastNodeNum)
        {
            cost += graph.getEdge(lastNodeNum, road.top());
            lastNodeNum = road.top();
        }
        road.pop();
    }
    cout << "end" << endl;
    cout << "cost:" << cost;
}