C++ 连接的组件程序产生不正确的输出

我正在编写一个程序，该程序接收5x5个字符数组，并查找相同字符的最长列表，连接表示上、下、左或右相邻（表示没有对角线）。但是，输出为1，给出6而不是正确的7，输入为：

a b c c b
a c b c c
c a a b a
b b a a c
a a a b a

有人能帮我找到代码中的错误吗？（我的代码在下面）

详细信息：缺少的字符位于索引[3][3]（索引从0开始）。当我测试我的

look（）

函数时，它工作正常，当我为row传递它3，为col传递它2时，它将[3][3]添加到要返回的最终向量中，但我认为递归的结果不太正确

我已经调试过了，但没有成功，您可以在我的代码中看到调试打印。

#include <iostream>
#include <vector>
#include <algorithm>
#include <fstream>
#include <utility>

using namespace std;
char grid[5][5];
bool seen[5][5];
int cnt = 1;
int maxn = 0;

vector<pair<int, int>> look(int row, int col)
{
    //
    vector<pair<int, int >> node_list;
    if (row != 0)
        if (grid[row - 1][col] == grid[row][col])
            if (!seen[row - 1][col])
                node_list.push_back(make_pair(row - 1, col));
    if (row != 4)
        if (grid[row + 1][col] == grid[row][col])
            if (!seen[row+1][col])
                node_list.push_back(make_pair(row + 1, col));
    if (col != 0)
        if (grid[row][col - 1] == grid[row][col])
            if (!seen[row][col-1])
                node_list.push_back(make_pair(row, col - 1));
    if (col != 4)
        if (grid[row][col + 1] == grid[row][col])
            if (!seen[row][col+1])
                node_list.push_back(make_pair(row, col + 1));
    if (binary_search(node_list.begin(), node_list.end(), make_pair(2, 2)))
        cout << "HAPPENED^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^" << "\n";
    return node_list;
}

void search(int row, int col)
{
    for (pair<int, int> a : look(row, col))
    {
        if (!seen[a.first][a.second])
        {
            seen[a.first][a.second] = true;
            cnt++;
            cout << "COUNTED and now SEARCHING " << a.first << " " << a.second << "\n";
            cout << "search about to be called on " << a.first << " " << a.second << "\n";
            search(a.first, a.second);
        }
    }
    if (cnt > maxn)
        maxn = cnt;
    cout << "CNT: " << cnt << "\n";
    cnt = 1;
    return;
}

int main()
{
    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            cin >> grid[i][j];
            seen[i][j] = false;
        }
    }

    for (int i = 0; i < 5; i++)
    {
        for (int j = 0; j < 5; j++)
        {
            if (!seen[i][j])
            {
                cout << "INITIALLY SEARCHING: " << i << " " << j << "\n";
                seen[i][j] = true;
                cout << "search about to be called on " << i << " " << j << "\n";
                search(i, j);
            }
            else
                cout << "NO INITIAL SEARCH, SEEN: " << i << " " << j << "\n";
        }
    }
    cout << maxn << "\n";
    return 0;
}

#包括
#包括
#包括
#包括
#包括
使用名称空间std；
字符网格[5][5]；
bool-seen[5][5]；
int-cnt=1；
int maxn=0；
矢量外观（整数行，整数列）
{
//
向量节点列表；
如果（行！=0）
if（网格[行-1][col]==网格[行][col]）
如果（！见[第1行][列]）
node_list.push_back（创建_对（行-1，列））；
如果（行！=4）
if（网格[行+1][col]==网格[行][col]）
如果（！见[行+1][列]）
节点列表。向后推（组成一对（行+1，列））；
如果（列！=0）
if（网格[行][col-1]==网格[行][col]）
如果（！见[row][col-1]）
node_list.push_back（创建_对（行，列-1））；
如果（列！=4）
如果（网格[行][col+1]==网格[行][col]）
如果（！看到[行][col+1]）
节点列表。向后推（组成一对（行、列+1））；
if（二进制搜索（node_list.begin（）、node_list.end（）、make_pair（2,2）））
cout问题在于，您正在递归地使用
搜索
，但也在它的末尾无条件地重置
cnt

这个问题可以在一个只有3个字符的简单“电路板”上演示：

a a a

假设我们从中间的
a
开始
search
。它调用
look
，并被告知检查另外两个地方：左边的
a
，右边的
a
。
search
然后调用自身，比如说用左边的
a
cnt
此时是
2
，然后both左侧和中间的
a
将其
seen设置为
true
。第二个递归
搜索
调用再次要求
look
查找附近的
a
，但这一次它们都已被看到。因此第二个
搜索
结束，将
maxn
设置为
2
，并重置ode>cnt
到
1。现在我们回到递归的第一级，继续到右侧的
a
。不用说，我们已经放弃了左侧的一次计数
a

这里的问题是，您没有明确区分“递归搜索附近字段”和“从此点开始搜索”。当前
搜索的最后两行属于后者，而不是前者。我建议：

void searchRecursive(int row, int col)
{
    for (pair<int, int> a : look(row, col))
    {
        if (!seen[a.first][a.second])
        {
            seen[a.first][a.second] = true;
            cnt++;
            searchRecursive(a.first, a.second);
        }
    }
}

void startSearchFrom(int row, int col)
{
    cnt = 1;
    seen[i][j] = true;
    searchRecursive(row, col);
    if (cnt > maxn)
        maxn = cnt;
    cout << "CNT: " << cnt << "\n";
}

void searchRecursive（int行，int列）
{
用于（a对：外观（行、列））
{
如果（！看到[a.first][a.second]）
{
第一次[第二次]=正确；
cnt++；
搜索递归（a.第一，a.第二）；
}
}
}
void startSearchFrom（整数行，整数列）
{
cnt=1；
seed[i][j]=真；
搜索递归（行、列）；
如果（cnt>maxn）
maxn=cnt；
当我通过[3][2]时，输出应该是什么？这不是实际的输入，而是我通过look（）的测试输入函数，其中3为行，2为列。它输出2 2、4 2和3 3。您是否尝试附加调试器，以便一步一步地检查程序？这将允许您找到它执行您不希望它执行的操作的点。