Question

我正试图浏览贫民窟地图。我从.txt输入我的节点，其值如下：

所以：

节点0将连接到节点3
节点1将连接到节点2和3
节点2将连接到节点1

依此类推......＆＃39; -1＆＃39;只是为了终止该行

目前，我将它们存储在大小为11的数组中，我只使用getline()将每个行号拉入匹配的数组单元格;这是输出到屏幕。我还将它们放入2d数组中，其中每个值都有自己的单元格。我将要求用户提供起始节点和结束节点，然后我将使用递归函数计算两者之间的路径（如果有的话），并输出有多少节点那条路。我甚至都不会对最佳路径感兴趣，任何人都会这样做。

我将如何递归地进行此操作？

到目前为止未完成的代码：

#include<iostream>
#include<fstream>
#include<string>
using namespace std;

const int ARRAY_SIZE = 11;

void toString(string network[ARRAY_SIZE]);
int numNodes(string network[], int start, int end);

int main()
{
    int start;
    int end;

    // inputting network into array
    string network[ARRAY_SIZE];

    ifstream in;
    in.open("network.txt");

    if (in.is_open())
    {
        while (!in.eof())
        {
            for (int i = 0; i < ARRAY_SIZE; i++)
            {
                getline(in, network[i]);
            }
        }
    }

    in.close();

    //start of user prompts
    cout << "Welcome. " << endl << "Here is the network " << endl << endl;

    toString(network);

    // the loop for start val
    do
    {
        cout << "Please enter a a starting node number (0-10), enter '-1' to quit" << endl;
        cin >> start;
        if (start == -1)
            return 0;
    } while (start < 0 && start > 10);

    toString(network);


    //loop for end value
    do
    {
        cout << "Please enter an ending node number (0-10), enter '-1' to quit" << endl;
        cin >> end;
        if (start == -1)
            return 0;
    } while (end < 0 && end > 10);


    //recursive stuffs 

    return 0;
}

int numNodes(string network[], int start, int end)
{
    //unfinished function
    int num;

    //base case
    if (start == end)
    {
        return 1;
    }

    //recursion
    else
    {

    }

    return num;
}

void toString(string network[ARRAY_SIZE])
{
    cout << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        cout << network[i] << endl;
    }

    cout << endl;
}

Answer 1

不确定'贫民窟地图'是什么意思，我猜你只是个玩笑。

您实际谈论的是计算机科学/离散数学中的一个概念，称为Graph。有许多类型的图形，图形只有正权重图形包含负权重，图形中所有路径都是双向的，图形路径是单向图形，其中边缘必须全部连接，图形边缘具有一定的权重，容量和/或其他一些功能......

在这种情况下，我认为你正在处理的是未加权（没有分配给边的权重）directed（从A到B的连接并不意味着从B到A的连接）图（未加权的定向）图表）以及图表可能附加的unconnected。

您还使用了Adjacency List类型来表示图节点之间的连接。

有许多算法可以遍历图形（例如Dijkstras用于路径查找或统一成本搜索），但是大多数（如果不是全部）算法都来自两个基本搜索算法Depth First Search和Breadth First Search < / p>

深度优先搜索正是名称所暗示的。如果你有一些结构来表示你的图形（比如你的邻接列表），你将不断搜索最右边或最左边的节点到最深点，直到你达到目标或死胡同。这可能如下所示（请注意这是Python）：

def DepthFirstSearch(adjacencylist, start, end):
    traversallist = []
    traversallist.push(start)
    for edge in adjacencylist[start]:
        if edge.connectsTo(end):
           traversalstack.push(end)
           return traversallist
        else:
            resursivelist = DepthFirstSearch(adjacencylist, edge.endNode(), end)
            if resursive_list != []:
                return traversallist.extend(recursivelist)
    return []

如果它返回一个空列表（[]）则没有连接。如果没有连接并返回找到的第一个路径。

广度frist搜索是其名称所暗示的内容。在与以前相同的场景中，不是搜索最深的节点，而是先搜索每个连接边缘，然后再深入搜索。这可能如下所示：

#note that queue starts with the start element
def BreadthFirstSearch(adjacencylist, queue, end):
    start = queue.pop()
    traversallist = []
    traversallist.push(start)

    for edge in adjacencylist[start]:
        if edge.connectsTo(end):
           traversalstack.push(end)
           return traversallist
    queue.push(adjacencylist[start])
    if not queue.empty():
        return traversallist.extend(BreadthFirstSearch(adjacencylist, queue, end))
    else:
        return []

但是，在遍历期间有循环的情况下，这两种方法都将在内部运行。为了避免这种情况，您可以设置一个列表（或者用于bettern运行时复杂性，哈希表）以查看您是否已经遍历了某些内容。

def DepthFirstSearch(adjacencylist, start, end, closedset):
    ...
    if start not in closedset:
    ...
    else:
       return []

def BreadthFirstSearch(adjacencylist, queue, end, closedset):
    ...
    if start not in closedset:
    ...
    else:
       return []

这应该为您提供足够的信息来实现图形路径查找器，该路径查找器将返回一个路径（如果您只需要节点数，则可以简单地返回大小）。

查找路径上的节点数

1 个答案: