Question

我正试图在这个地铁系统中打印出640条路径。我知道有640条路径，因为我已经使用邻接矩阵完成了这个程序。现在我需要用类来做。第一站从'a'开始，路径在站'l'结束。我无法实现递归函数SearchRoute，因为我需要打印路径，标记路径，然后再次标记路径以允许回溯。目前我只能打印'a'到'b'的曲目，因此我的递归函数出现严重错误。任何建议将不胜感激

标题

//Function Declarations 

#include <iostream>
#include <string>


using namespace std; 

#ifndef SUBWAY_H
#define SUBWAY_H


class Track
{
    public:
    //Default Constructor 
    Track();

    //Overload Constructor
    Track(char, char);

    //Destructor 
    ~Track();

    //Member variables 
    char node_1;
    char node_2;
    bool visited; 
};


class Station
{
    public:
    //Default Constructor 
    Station();

    //Destructor 
    ~Station();

    //Overload Constructor
    Station(char, int, int);

    //Member variables 
    char station_name; 
    int track_starting_ID;
    int track_size; 
};


class SubwaySystem
{
    public:
    //Default Constructor
    SubwaySystem();

    //Destructor 
    ~SubwaySystem();

    //Recursive function
    void SearchRoute(int);

    //Other member functions 
    friend ostream& operator<<(ostream& os, const Track& my_track);
    friend ostream& operator<<(ostream& os, const Station& my_station);


    //Member variables 
    Track my_track[34];
    Station my_station[12];

    int count_routes; 
    int Current_Station_ID;

    //String to save found route 
};



#endif

CPP

//Function Definitions
#include <iostream>
#include <string>

#include "subway.h"

using namespace std; 


Track::Track()
{
    visited = 0; 
}


Track::~Track(){

}


Track::Track(char pass_track1, char pass_track2)
{
    node_1 = pass_track1;
    node_2 = pass_track2;
}


Station::Station(){

}


Station::~Station(){

}


Station::Station(char pass_station_name, int pass_start, int pass_size){
    station_name = pass_station_name;
    track_starting_ID = pass_start;
    track_size = pass_size; 
}


SubwaySystem::SubwaySystem()
{
    //Initialize tracks 
    //node_1, node_2
    my_track[0] = Track('a', 'b');
    my_track[1] = Track('b', 'a');
    my_track[2] = Track('b', 'c');
    my_track[3] = Track('b', 'd');
    my_track[4] = Track('b', 'e');
    my_track[5] = Track('b', 'f');
    my_track[6] = Track('c', 'b');
    my_track[7] = Track('c', 'e');
    my_track[8] = Track('d', 'b');
    my_track[9] = Track('d', 'e');
    my_track[10] = Track('e', 'b');
    my_track[11] = Track('e', 'c');
    my_track[12] = Track('e', 'd');
    my_track[13] = Track('e', 'g');
    my_track[14] = Track('e', 'h');
    my_track[15] = Track('f', 'b');
    my_track[16] = Track('f', 'h');
    my_track[17] = Track('g', 'e');
    my_track[18] = Track('g', 'k');
    my_track[19] = Track('h', 'e');
    my_track[20] = Track('h', 'f');
    my_track[21] = Track('h', 'i');
    my_track[22] = Track('h', 'j');
    my_track[23] = Track('h', 'k');
    my_track[24] = Track('i', 'h');
    my_track[25] = Track('i', 'k');
    my_track[26] = Track('j', 'h');
    my_track[27] = Track('j', 'k');
    my_track[28] = Track('k', 'g');
    my_track[29] = Track('k', 'h');
    my_track[30] = Track('k', 'i');
    my_track[31] = Track('k', 'j');
    my_track[32] = Track('k', 'l');
    my_track[33] = Track('l', 'k');

    //Initialize stations 
    //station_name, track_starting_ID, track_size 
    my_station[0] = Station ('a', 0, 1);
    my_station[1] = Station ('b', 1, 5);
    my_station[2] = Station ('c', 6, 2);
    my_station[3] = Station ('d', 8, 2);
    my_station[4] = Station ('e', 10, 5);
    my_station[5] = Station ('f', 15, 2);
    my_station[6] = Station ('g', 17, 2);
    my_station[7] = Station ('h', 19, 5);
    my_station[8] = Station ('i', 24, 2);
    my_station[9] = Station ('j', 26, 2);
    my_station[10] = Station ('k', 28, 5);
    my_station[11] = Station ('l', 33, 1); 

    //Initiaize other members 
    count_routes = 0; 
    Current_Station_ID = 0;
}


SubwaySystem::~SubwaySystem()
{
}


ostream& operator<<(ostream& os, const Track& my_track)
{
    os << my_track.node_1 << '.' << my_track.node_2;
    return os;
}


ostream& operator<<(ostream& os, const Station& my_station)
{
    os << my_station.station_name << '.' << my_station.track_starting_ID << '.' << my_station.track_size;
    return os;
}


void SubwaySystem::SearchRoute(int Current_Station_ID)
{
    while (Current_Station_ID < 33)
    {
        if (Current_Station_ID == 0) //Find a successful route to Station L
        {
            count_routes++; //Add 1 into the variable “count_routes”
            cout << count_routes << " " << my_track[Current_Station_ID] << endl; //Print out this route 
            return; 
        }

        else //Get into recursive Function Body
        {
            for (int i = my_station[Current_Station_ID].track_starting_ID; i < my_station[Current_Station_ID].track_starting_ID + my_station[Current_Station_ID].track_size; i++)
            {
                if (my_track[Current_Station_ID].visited == 0) //if this track is not visited before
                {
                    my_track[Current_Station_ID].visited = 1; //mark this track as visited
                    my_track[Current_Station_ID].node_2 = 1; //mark its corresponding track as visited
                    cout << my_track[Current_Station_ID] << endl; //save this track
                    SearchRoute(Current_Station_ID + 1); //Recursive
                    i--; //Backtrack this track
                    my_track[Current_Station_ID].visited = 0;//mark this track as unvisited
                    my_track[Current_Station_ID].node_2 = 0;//mark its corresponding track as unvisited
                }
            }
        }
    }
}

主要

#include <iostream>
#include <string>

#include "subway.h"

using namespace std; 

int main(int argc, char **argv)
{
    SubwaySystem Test; 
    Test.SearchRoute(0);
}

Answer 1

为什么

中有返回声明

     if (Current_Station_ID == 0) //Find a successful route to Station L
    {
        count_routes++; //Add 1 into the variable “count_routes”
        cout << count_routes << " " << my_track[Current_Station_ID] << endl; //Print out this route 
        return; 
    }

（可能只值得评论，但我讨厌在评论中粘贴代码）

Answer 2

到目前为止，我可以看到你没有初始化构造函数中的所有成员。至少在赛道上。正确的ctor看起来像：

Track::Track(char pass_track1, char pass_track2)
{
    node_1 = pass_track1;
    node_2 = pass_track2;
    visited = false;              // this was missing
}

在C ++中，您必须初始化所有构造函数中的所有成员。否则，值具有以前在内存中的值。访问成员中存在0的可能性是1：2 ^ 32 =＆gt;接近于零。

Answer 3

你好@ace：就像弗兰克建议你需要初始化所有变量一样。但是我还会包含一个默认构造函数，它可以创建单件轨道并使用重载的构造函数：

Track::Track()    {        Track("~","~");    }
Track::Track(char pass_track1, char pass_track2)
{
    node_1 = pass_track1;
    node_2 = pass_track2;
    visited = false;
}

这意味着基本构造函数将始终从“〜”到“〜”（可以是任何字符）创建单个片段轨道我还将使用基本构造函数的字符，您将不会在实际使用中使用该字符您可以在将来跟踪和跟踪问题，当默认构造函数一目了然时，它就变得明显，因为它包含您选择的所述字符。

使用递归在C ++中寻路

3 个答案: