C 二维矩阵遍历-最优路径记忆

我有一个函数，用于在2D矩阵（整数、值和和的结构）中找到最佳路径，但它不记忆最佳值，它只在到达矩阵底部时返回遍历的最小代价。我们应该使用堆栈以某种方式记住这些最佳值，但不幸的是，我不知道如何做到这一点。这是一个递归算法，因此有点难以分析。值用伪随机数（1到10）填充，总和初始化为

INT\u MAX

。这似乎有点类似于三元树

堆栈函数原型包括：

stack_t stack_new(); // already done in main
void stack_delete(stack_t stack); // -||-
void stack_push(stack_t stack, stack_element_t elem);
stack_element_t stack_pop(stack_t stack);
stack_element_t stack_top(stack_t stack);
int stack_is_empty(stack_t stack);

/* recursively seeks the optimal path in a 2D matrix */

void traverse(struct path **matrix, unsigned row, unsigned col, int path_cost, int *min_cost, int *cnt, stack_t stack, FILE *f)
{
    char buffer[16];
    path_cost += matrix[row][col].value;
    matrix[row][col].sum = path_cost;
    (*cnt)++; // counting calls
    fprintf(f, "call_counter: %d, min_cost: %s, path_cost: %d, value: %d, sum: %d\n", *cnt, *min_cost == INT_MAX ? "Inf" : itoa(*min_cost, buffer, 10), path_cost, matrix[row][col].value, matrix[row][col].sum); // logging
    if(matrix[row][col].sum > *min_cost) // if we've been here before and it wasn't as costly, return
    {
        return;
    }
    if(row == MATRIX_ROW - 1) // if we're at the bottom of the matrix
    {
        if(path_cost < *min_cost)
        {
            *min_cost = path_cost;
        }
        return;
    }
    if (col < MATRIX_COL - 1) // go down and right
        traverse(matrix, row + 1, col + 1, path_cost, min_cost, cnt, stack, f);

    traverse(matrix, row + 1, col, path_cost, min_cost, cnt, stack, f); // go down

    if (col > 0) // go down and left
        traverse(matrix, row + 1, col - 1, path_cost, min_cost, cnt, stack, f);
}

stack_t stack_new（）；//基本上已经完成了
无效堆栈删除（堆栈）；//-||-
无效堆栈推送（堆栈、堆栈元素）；
栈元素栈弹出（栈栈栈）；
堆叠元素堆叠顶部（堆叠）；
int stack_为空（stack_t stack）；
/*在二维矩阵中递归地寻找最优路径*/
无效遍历（结构路径**矩阵、无符号行、无符号列、整数路径成本、整数*最小成本、整数*cnt、堆栈、文件*f）
{
字符缓冲区[16]；
路径成本+=矩阵[行][列].值；
矩阵[行][列].sum=路径成本；
（*cnt）++；//计数调用
fprintf（f，“调用计数器：%d，最小成本：%s，路径成本：%d，值：%d，和：%d\n“，*cnt，*min\u成本==INT\u MAX？”Inf:itoa（*最小成本，缓冲区，10），路径成本，矩阵[行][col].值，矩阵[行][col].sum）；//日志记录
if（matrix[row][col].sum>*minu cost）//如果我们以前来过这里，而且成本不高，请返回
{
回来
}
if（row==MATRIX_row-1）//如果我们在矩阵的底部
{
如果（路径成本<*最小成本）
{
*最小成本=路径成本；
}
回来
}
if（col0）//向下向左走
遍历（矩阵，行+1，列-1，路径成本，最小成本，cnt，堆栈，f）；
}

您可以使用“使用两个堆栈查找路径”。 一个是临时堆栈，另一个是ANSWER堆栈

基本思想是，当你移动时，你将移动的方向推入堆栈。同样，在该特定移动的“函数调用（）”之后，你将弹出（）该方向。然后，当你到达底部时，如果以下条件为真，则执行该步骤：

if(path_cost < *min_cost)
{
  *min_cost = path_cost;
}

if（路径成本<*最小成本）
{
*最小成本=路径成本；
}

清空应答堆栈，并将临时堆栈的内容复制到其中

stack answer ;
stack temporary;

/* recursively seeks the optimal path in a 2D matrix */



void traverse(struct path **matrix, unsigned row, unsigned col, int path_cost, int *min_cost, int *cnt, stack_t stack, FILE *f)
{
    char buffer[16];
    path_cost += matrix[row][col].value;
    matrix[row][col].sum = path_cost;
    (*cnt)++; // counting calls
    fprintf(f, "call_counter: %d, min_cost: %s, path_cost: %d, value: %d, sum: %d\n", *cnt, *min_cost == INT_MAX ? "Inf" : itoa(*min_cost, buffer, 10), path_cost, matrix[row][col].value, matrix[row][col].sum); // logging
    if(matrix[row][col].sum > *min_cost) // if we've been here before and it wasn't as costly, return
    {
        return;
    }
    if(row == MATRIX_ROW - 1) // if we're at the bottom of the matrix
    {
        if(path_cost < *min_cost)
        {
            *min_cost = path_cost;
            
            /*
            
            just empyty teh Answer stack here;
            then copy the Temp stack into answer stack
            
            */
            
        }
        return;
    }
    
    // 1 for (row +1 ,col +1 )
    // 2 for (row +1 ,col )
    // 3 for (row +1 ,col -1 )
    
    if (col < MATRIX_COL - 1) // go down and right
    {
        temporary.push(1);
        traverse(matrix, row + 1, col + 1, path_cost, min_cost, cnt, stack, f);
        temporary.pop(1);
    }
    
    temporary.push(2);  
    traverse(matrix, row + 1, col, path_cost, min_cost, cnt, stack, f); // go down
    temporary.pop(2);
    
    if (col > 0) // go down and left
    {
        temporary.push(3);      
       traverse(matrix, row + 1, col - 1, path_cost, min_cost, cnt, stack, f);
       temporary.pop(3);
    }
}

堆栈应答；
临时堆放；
/*在二维矩阵中递归地寻找最优路径*/
无效遍历（结构路径**矩阵、无符号行、无符号列、整数路径成本、整数*最小成本、整数*cnt、堆栈、文件*f）
{
字符缓冲区[16]；
路径成本+=矩阵[行][列].值；
矩阵[行][列].sum=路径成本；
（*cnt）++；//计数调用
fprintf（f，“调用计数器：%d，最小成本：%s，路径成本：%d，值：%d，和：%d\n“，*cnt，*min\u成本==INT\u MAX？”Inf:itoa（*最小成本，缓冲区，10），路径成本，矩阵[行][col].值，矩阵[行][col].sum）；//日志记录
if（matrix[row][col].sum>*minu cost）//如果我们以前来过这里，而且成本不高，请返回
{
回来
}
if（row==MATRIX_row-1）//如果我们在矩阵的底部
{
如果（路径成本<*最小成本）
{
*最小成本=路径成本；
/*
只需暂时回答这里的问题；
然后将临时堆栈复制到应答堆栈中
*/
}
回来
}
//1个用于（行+1，列+1）
//2个用于（行+1，列）
//第3行（第1行，第1列）
if（col0）//向下向左走
{
临时推送（3）；
遍历（矩阵，行+1，列-1，路径成本，最小成本，cnt，堆栈，f）；
临时警察（3）；
}
}

编辑：

---

临时堆栈中的pop（）和push（）。每次找到“潜在”解决方案时，应答堆栈都会更新。而且我没有时间进行参数传递。临时堆栈“必须”是本地的。根据需要使用应答堆栈。

我不确定是否遵循此操作-我应该在移动时弹出哪个堆栈？它们是否应该像您预期的那样在全球可见？我已经传递给函数的那个呢？请澄清。由于您正在迭代所有可能的解决方案，我们试图做的是保留我们在当前递归调用跟踪中“遇到”的元素堆栈。Push（）-表示当前元素记录在我们的路径中。如果它是最优路径的组成部分，它将保留在该堆栈中，直到调用结束。Pop（）-函数调用完成后，如果需要，当前方向（即最佳方向）将在到达底部时记录在应答堆栈中。现在，如果我们不弹出（）刚访问的方向，而是推（）其他方向，技术上意味着在一个步骤中，我们采用了两条路径，希望您理解这是错误的！若你们仍然面临问题，也请给我评论一下你们实施的最终解决方案。