罗马尼亚度假问题和N皇后问题

罗马尼亚度假问题主体代码

#ifndef NODEEDGE
#define NODEEDGE
extern class cMap;
class cMapEdge;
class cMapNode;
//-----------------------------------------------------------------------
//图的边
class cMapEdge
{
public:
    //边到达的结点的在结点数组中的下标
    int m_edgeDesIndex;
    //边的权值
    double m_edgeWeight;
    //指向下一条边
    cMapEdge * m_pEdge;
public:
    cMapEdge(int des = -1, double weight = -1, cMapEdge * pEdge = NULL);
    //拷贝构造函数
    cMapEdge(cMapEdge & edge);
    //重载赋值操作符
    cMapEdge & operator =(const cMapEdge& edge);
    ~cMapEdge(){}
};
//---------------------------------------------------------
//图的结点
class cMapNode
{
    friend class Map;
public:
    string m_nodeName;
    double m_nodeValue;
    //结点在链表中的下标
    int m_nodeIndex;
    cMapNode * m_pNextNode;
    cMapEdge * m_pEdge;
public:
    cMapNode(string name = "", double value = -1, int index = -1, cMapEdge * pEdge = NULL, cMapNode * pNext = NULL);
    ~cMapNode(){}
    void AddEdge(int endIndex = -1, double weight = -1);
    //复制构造函数，为了更快的访问结点信息，使用浅复制就行
    cMapNode(cMapNode & node);
    //=复制操作重载
    cMapNode & operator =(const cMapNode & node);
};

#endif

#include "afxfunc.h"
#include "NodeEdge.h"

//----------------------------------------------------------------------------------------------------------------------
cMapEdge::cMapEdge(int des, double weight, cMapEdge *pEdge)
{
    m_edgeDesIndex = des;
    m_edgeWeight = weight;
    m_pEdge = pEdge;
}
cMapEdge::cMapEdge(cMapEdge & edge)
{
    m_edgeDesIndex = edge.m_edgeDesIndex;
    m_edgeWeight = edge.m_edgeWeight;
    m_pEdge = edge.m_pEdge;
}
cMapEdge & cMapEdge::operator =(const cMapEdge& edge)
{
    m_edgeDesIndex = edge.m_edgeDesIndex;
    m_edgeWeight = edge.m_edgeWeight;
    m_pEdge = edge.m_pEdge;
    return *this;
}
//-------------------------------------------------------------------------------------------------------------------------
cMapNode::cMapNode(string name, double value, int index, cMapEdge *pEdge, cMapNode *pNext)
{
    m_nodeName = name;
    m_nodeValue = value;
    m_nodeIndex = index;
    m_pEdge = pEdge;
    m_pNextNode = pNext;
}

void cMapNode::AddEdge(int endIndex, double weight)
{
    m_pEdge = new cMapEdge(endIndex, weight, NULL);
}
//复制构造函数，为了更快的访问结点信息，使用浅复制就行
cMapNode::cMapNode(cMapNode & node)
{
    m_nodeIndex = node.m_nodeIndex;
    m_nodeName = node.m_nodeName;
    m_nodeValue = node.m_nodeValue;
    m_pNextNode = node.m_pNextNode;
    m_pEdge = node.m_pEdge;
}
//=复制操作重载
cMapNode & cMapNode::operator =(const cMapNode & node)
{
    m_nodeIndex = node.m_nodeIndex;
    m_nodeName = node.m_nodeName;
    m_nodeValue = node.m_nodeValue;
    m_pNextNode = node.m_pNextNode;
    m_pEdge = node.m_pEdge;
    return *this;
}

#ifndef MAP
#define MAP
#include "NodeEdge.h"
//邻接矩阵保存图
//-----------------------------------------------------
//封装结点name和下标减少遍历次数
struct sNameIndex
{
    string m_name;
    int m_index;
    sNameIndex(string name = "", int index = -1) :m_name(name), m_index(index){}
};
//封装结点name,下标和深度减少遍历次数
struct sNameIndexDepth
{
    string m_name;
    int m_index;
    int m_depth;
    sNameIndexDepth(string name = "", int index = -1,int depth=-1) :m_name(name), m_index(index){}
};
//-----------------------------------------------------
class cMap
{
   
   
private:

    //结点集的首指针
    cMapNode * m_pHeadNode;
    //图的结点数量
    int m_size;
    //为方便访问结点而定义的
    cMapNode *m_pCurr;
public:
    int COUNT ;
    //默认构造函数
    cMap();
    //析构函数,显式delete结点集和边集
    ~cMap();
    //从文件中载入结点
    void LoadNodeFromFile(string path = "G://C++//SearchPro1//node.txt");
    //从文件载入边集
    void LoadEdgeFromFile(string path = "G://C++//SearchPro1//edge.txt");
    //添加边
    void AddEdge(int endIndex=-1,double weight=-1);
    //添加结点
    void AddNode(string nodeName="",double nodeValue=-1,int index=-1);
    //获取结点
    cMapNode* GetNodeByName(string nodeName = "");
    cMapNode* GetNodeByIndex(int index = -1);
    //获取结点在链表中位置和name
    sNameIndex cMap::GetNodeNamePos(const string nodeName="",const int position=-1);
    //代价一致的广度优先搜索,返回路径数组
    string BFSearch(string startName = "", string endName = "");
    //预设搜索深度的深度优先搜索,返回路径数组
    string DLSearch(string startName = "", string endName = "", int depth = 20);
    //考虑启发值的贪婪搜索,深度优先,返回路径数组
    string GSearch(string startName = "", string endName = "");
    //A*搜索根据启发值与边长,深度优先，与Dijkstra一样把全部路径找出来,返回路径数组（最短）
    string ASearch(string startName = "", string endName = "");
    //根据sNameIndex[]里的信息构建path
    string GetPath(sNameIndex * path, int finalIndex = -1);
    string GetPathD(sNameIndexDepth * path, int finalIndex = -1);
};
#endif

#include "afxfunc.h"
#include "Map.h"
#include "LinQueue.h"
#include "LinStack.h"

//--------------------------------------------------------------------------------------------------------------------------
//默认构造函数
cMap::cMap()
{
    COUNT = (0);
    m_pCurr = NULL;
    m_pHeadNode = NULL;
    m_size = 0;
}
//析构函数,显式delete结点集和边集
cMap::~cMap()
{
}
//从文件中载入结点
void cMap::LoadNodeFromFile(string path)
{
    string name = "";
    double value = -1;
    string line;
    ifstream ifs;
    ifs.open(path);
    if (ifs.is_open())
    {
        cMapNode * p;
        cMapNode * q = NULL;
        while (!ifs.eof())
        {
            getline(ifs, line);
            int pos = line.find('\t');
            name = line.substr(0, pos);
            istringstream iss(line.substr(pos +