C++ 如何正确实现二维向量C++；

直截了当地说，我试图将一个棋子的两点之间的所有可能路径添加到一个2d向量中。基本上所有的路径都在一个结构中，这样我就可以通过它来确定最短的路径。我似乎只是在添加第一个向量，并且每隔一次迭代，就会添加一个空向量

注意**在我的代码中，它显示了“path.erase（）”，我使用它清除向量，以便下一次迭代接收空向量。我也使用了std:：vector.clear（），但给出了相同的结果

我对2d向量没有太多经验，感觉我访问2d向量是错误的。希望接受任何必要的建议或更正

#include <iostream>
#include <string>
#include <vector>
#include <random>
#include <algorithm>
#include <iterator>
using namespace std;    

class Piece {
private:
char type; //type or rank of piece (can be 'K' for "Knight" or 'O' for every other piece)
int x, y;
bool atFinish;
int movesMade;
int finalCount;
int visited[8][8]; //where '0' represents unvisited square and '1' represents visited
vector<string> path;
vector <vector<string> > possiblePaths;

public:
Piece(int xIn, int yIn, char typeIn) {
    x = xIn;
    y = yIn;
    movesMade = 0;
    finalCount = 100;
    type = typeIn;
    for (int i = 0; i < 8; i++) {
        for (int j = 0; j < 8; j++) {
            visited[i][j] = 0;
        }
    }
}

bool canMove(int y, int x) {
    return ((x > 0 && x < 8) 
            && (y > 0 && y < 8)
            && (visited[y][x] == 0));
}

void move(int endY, int endX) {
    int preX, preY;
    vector<int> v;
    random_device rd;

    //Randomizing the possible moves for every new position the knight comes to
    //so as to not continually use the same sequence of moves at every new position
    for (int i = 0; i < 8; i++)
        v.push_back(i);

    mt19937 g(rd());
    shuffle(v.begin(), v.end(), g);
    /*********************************************/

    if (x == endX && y == endY) {
        movesMade = 0;
    }
    else {
        for (int i = 0; i < 8; i++) {
            preX = x;
            preY = y;
            movePiece(v[i]);

            if (canMove(y, x)) {
                movesMade+= 1;
                visited[y][x] = 1;
                string pos = to_string(y) + to_string(x);
                path.push_back(pos);
                move(endY, endX);
            }
            else {
                y = preY;
                x = preX;
            }
            x = preX;
            y = preY;
        }
    }
}

void movePiece(int move) {
    switch (move) {
        case 0: //piece moves 'down' 2 and 'right' 1
            x += 1;
            y += 2;
            break;
        case 1: //piece moves 'down' 2 and 'left' 1
            x -= 1;
            y += 2;
            break;
        case 2: //piece moves 'up' 2 and 'right' 1
            x += 1;
            y -= 2;
            break;
        case 3: // piece moves 'up' 2 and 'left' 1
            x -= 1;
            y -=2;
            break;
        case 4: //piece moves 'left' 2 and 'down' 1
            x -= 2;
            y += 1;
            break;
        case 5: //piece moves 'left' 2 and 'up' 1
            x -= 2;
            y -= 1;
            break;
        case 6: //piece moves 'right' 2 and 'down' 1
            x += 2;
            y += 1;
            break;
        case 7: //piece moves 'right' 2 and 'up' 1
            x += 2;
            y -= 1;
            break;
        default:
            break;
    }
}

void solution(int startY, int startX, int endY, int endX) {
    for (int i = 0; i < 50; i++) {
        y = startY;
        x = startX;
        move(endY, endX);
        possiblePaths.push_back(path);
        path.erase(path.begin(), path.end());
    }

    //Error checking purposes, print size of 2d vector and all paths made
    cout << possiblePaths.size() << "\n";

    for (int i = 0; i < possiblePaths.size(); i++) {
        vector<string> v = possiblePaths[i];
        for (vector<string>::const_iterator j = v.begin(); j != v.end(); j++)
            cout << *j << " ";
        cout << "\n";
    }
}
};

int convertLetter(char letter) {
switch(letter) {
    case 'A':
        return 0;
    case 'B':
        return 1;
    case 'C':
        return 2;
    case 'D':
        return 3;
    case 'E':
        return 4;
    case 'F':
        return 5;
    case 'G':
        return 6;
    case 'H':
        return 7;
    case '1':
        return 7;
    case '2':
        return 6;
    case '3':
        return 5;
    case '4':
        return 4;
    case '5':
        return 3;
    case '6':
        return 2;
    case '7':
        return 1;
    case '8':
        return 0;
    default:
        return -1;
}
}

void play(string start, string end) {
int startX = convertLetter(start[0]);
int startY = convertLetter(start[1]);
int endY = convertLetter(end[1]);
int endX = convertLetter(end[0]);
Piece p(startY, startX, 'K');

p.solution(startY, startX, endY, endX);
}

int main(int argc, char const *argv[])
{
if ( argc != 3) // argc should be 3 for correct execution
    cout << "Invalid entry \n";
else {
    string start = argv[1];
    string end = argv[2];
    play(start, end);
}
}

#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间std；
班级作品{
私人：
char type；//棋子的类型或等级（可以是“骑士”的“K”或其他棋子的“O”）
int x，y；
完成时的bool；
int-movesMade；
国际财务账户；
int visted[8][8]；//其中“0”表示未访问的方块，“1”表示已访问的方块
向量路径；
向量可能路径；
公众：
单张（整心、整阴、字符输入）{
x=xIn；
y=阴；
movesMade=0；
最终数量=100；
类型=输入类型；
对于（int i=0；i<8；i++）{
对于（int j=0；j<8；j++）{
访问量[i][j]=0；
}
}
}
布尔可以移动（整数y，整数x）{
返回（（x>0&&x<8）
&&（y>0&&y<8）
&&（访问[y][x]==0））；
}
无效移动（int-endY，int-endX）{
intprex，猎物；
向量v；
随机器件rd；
//随机化骑士每到一个新位置的可能动作
//这样就不会在每个新的位置持续使用相同的移动顺序
对于（int i=0；i<8；i++）
v、 推回（i）；
mt19937g（rd（））；
洗牌（v.begin（），v.end（），g）；
/*********************************************/
如果（x==endX&&y==endY）{
movesMade=0；
}
否则{
对于（int i=0；i<8；i++）{
preX=x；
猎物=y；
动件（v[i]）；
if（可以移动（y，x））{
movesMade+=1；
访问量[y][x]=1；
字符串位置=到字符串（y）+到字符串（x）；
路径。推回（位置）；
移动（endY，endX）；
}
否则{
y=猎物；
x=preX；
}
x=preX；
y=猎物；
}
}
}
无效移动块（内部移动）{
开关（移动）{
案例0://工件向下移动2，向右移动1
x+=1；
y+=2；
打破
案例1://工件向下移动2，向左移动1
x-=1；
y+=2；
打破
案例2://工件向上移动2和向右移动1
x+=1；
y-=2；
打破
案例3://工件向上移动2，向左移动1
x-=1；
y-=2；
打破
案例4://工件向左移动2，向下移动1
x-=2；
y+=1；
打破
案例5://工件向左移动2，向上移动1
x-=2；
y-=1；
打破
案例6://工件向右移动2，向下移动1
x+=2；
y+=1；
打破
案例7://工件向右移动2和向上移动1
x+=2；
y-=1；
打破
违约：
打破
}
}
无效解决方案（int-startY、int-startX、int-endY、int-endX）{
对于（int i=0；i<50；i++）{
y=星形；
x=startX；
移动（endY，endX）；
可能路径。推回（路径）；
擦除（path.begin（），path.end（））；
}
//错误检查目的、2d矢量的打印大小和所有路径
cout我不确定我是否完全理解您的算法，但您是否打算在找到可能的路径后清除访问的
？例如：

for (int i = 0; i < 50; i++) {
  y = startY;
  x = startX;
  move(endY, endX);
  possiblePaths.push_back(path);
  path.erase(path.begin(), path.end());
  for(auto& v : visited) std::fill(std::begin(v), std::end(v), 0);
}

for（int i=0；i<50；i++）{
y=星形；
x=startX；
移动（endY，endX）；
可能路径。推回（路径）；
擦除（path.begin（），path.end（））；
对于（自动和验证：已访问）标准：：填充（标准：：开始（v），标准：：结束（v），0）；
}

否则，后续搜索可能会被阻止，因为大多数位置都被访问过。
创建一个单独的示例；此代码取决于我们无法访问的部分。@BartekBanachewicz我如何才能做到这一点。不确定如何做到。@BartekBanachewicz请参见编辑。我阅读了链接，我个人认为我没有重放大约200行代码这篇文章完全遵守了说明，但是它提供了一个可执行的示例。如果您在代码中添加一些注释以突出显示您有问题的部分，这将非常有用。旁注：部分代码不必要地冗长。例如，
convertLetter（）的主体
可以这样写：
如果（字母>='A'&&letter='1'&&letter