我正在尝试在地铁系统中打印出所有可能的路径，这些路径有从A到L的站点。换句话说，目的是找出一个人可以通过地铁系统可以走多少路线而不会过去不止一次的赛道。我知道自从我之前在C中使用邻接矩阵编写此程序以来，有640条可能的路径。现在我正在尝试编写相同的程序，除了使用C ++中的类而不使用邻接矩阵。
我遇到的问题是我似乎无法正确实现我的递归函数SearchRoute，因为我需要打印路径，标记路径，然后再次标记路径以允许回溯。当我打印出最终结果时，我只得到从A到B的曲目，这显然意味着某些事情显然是错误的。
这就是我认为问题所在：我知道在我的SubwaySystem :: SearchRoute函数中我使用了if和else语句，它显然不允许调用我的递归函数但是我尝试使用另一个if语句而不是否则我不太确定条件是什么。
void SubwaySystem::SearchRoute(int Current_Station_ID)
{
while(Current_Station_ID < 33)
{
cout << "In while loop\n";
// \\ Checking progress
if(Current_Station_ID == 0) //Find a successful route to Station L
{
count_routes++; //Add 1 into the variable “count_routes”
cout << "In if statement\n";
// \\Checking progress
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
{
cout << "In recursive part of function\n";
// \\ Checking progress
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
}
}
}
}
}
此外，我还尝试在整个程序中使用打印语句来跟踪进度。我的递归函数永远不会被我上面指定的原因调用（至少这就是为什么我认为它不起作用）。由于某种原因，我无法弄清楚为什么我的默认和重载轨道构造函数被多次调用。
如果您能帮助我弄清楚我的代码中的问题区域/向我展示正确的方法，我将不胜感激。我厌倦了这个想法。提前谢谢。
以下是单个TU中程序的其余部分：
//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;
//cout << "Default Track has been called\n";
//\\ Checking progress
}
Track::~Track()
{
}
Track::Track(char pass_track1, char pass_track2)
{
node_1 = pass_track1;
node_2 = pass_track2;
visited = false;
//cout << "Overload Track constructor has been called\n";
// \\ Checking progress
}
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;
//cout << "Overload station has been called\n";
// \\ Checking progress
}
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;
//cout << "SubwaySystem constructor called\n";
// \\ Checking progress
}
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;
}
// **main**
#include <iostream>
#include <string>
//#include "subway.h"
using namespace std;
int main(int argc, char **argv)
{
SubwaySystem Test;
Test.SearchRoute(0);
}
如果“检查进度”打印语句使得阅读代码变得更加困难，我很抱歉。
答案 0 :(得分：0)
你的第一个条件
while(Current_Station_ID < 33)
{
cout << "In while loop\n";
// \\ Checking progress
if(Current_Station_ID == 0) //Find a successful route to Station L
这将始终成为现实，因为这就是你在main中所说的：
int main(int argc, char **argv)
{
SubwaySystem Test;
Test.SearchRoute(0);
}
所以，你永远不会进入else分支，因为第一个将永远被占用，并且它会立即结束（return）
答案 1 :(得分：0)
使用递归算法，当到达最终目的地时，if语句应为true。否则声明就是你还在旅途中。在这种情况下，当您访问每个轨道时，您已“到达”。继续您的旅程由else声明处理。 for循环找到所有“下一个”停靠点。
我会将递归调用扩展为：
void SubwaySystem::SearchRoute(int visited_count, int current_station, string route);
如果满足visited_count，则打印路线。否则，选择尚未访问过的下一站。 对于每个递归调用，选择要访问的下一个站，将当前访问计数加1，并将当前位置附加到路由字符串。
目前，如果您的for循环，my_station最多只有11，但Current_Station_ID可能是33，那么您也会遇到错误。