C Don'；我不知道如何使用哈希表来解决问题

我必须使用哈希表解决以下问题（在C中）（我假设使用哈希表，因为我们现在正在研究哈希表）：

输入的第一行有两个数字：n，m

接下来，我们输入带有m数字的n行。（因此an*m矩阵） 我们必须从左上角到右下角（只能向南或向东移动）。我们交叉的每个单元格要么将单元格中的数字添加到变量“s”中，要么将其减少。因此，如果我们用-5遍历一个单元格，我们将得到s-5，如果我们用+3遍历一个单元格，我们将得到s+3。开始时，s是左上角的数字，始终大于0。另一条规则是我们不能遍历数字为0的单元格。而且，每次我们离开一个单元格时，我们必须减去1，因此每次我们离开一个单元格时，我们将得到s-1。 输出必须是到达右下角后可获得的最大s。 以下是输入/输出示例：

可以保证至少有一条到右下角的路径，它最终会给出一个至少等于1的s，因此如果最后s为负值，则该路径肯定是错误的

---

我很难解决这个问题（特别是使用哈希表），所以非常感谢您的帮助。还有，还有其他更有效的方法吗？

这似乎是一个非常简单的动态规划问题

---

让左上角有索引

（0，0）

，右下角有索引

（n-1，m-1）

，让

arr[i][j]

成为

（i，j）

位置的数字。然后对于所有的

i，j

，这似乎是一个非常简单的动态规划问题

---

让左上角有索引

（0，0）

，右下角有索引

（n-1，m-1）

，让

arr[i][j]

成为

（i，j）

位置的数字。然后对于所有的

i，j

，使得

0，正如Mark提到的，这是动态规划问题。所以这个问题与哈希表无关。现在，由于马克的答案有点难理解，我将尝试解释我的解决方案。
给定的问题类似于标准矩阵路径优化问题，有两个有趣的转折点

解决方案路径不能包含
0值单元格
以上这一点也是一个标准问题。但问题是。因为单元格有整数值。由于先前的加法和减法运算，很难区分原始
0值单元格
与中间
dp
矩阵中的单元格
因此，为了解决上述问题，我们需要分别存储原始
0值单元的索引。最简单的方法是创建另一个参考矩阵并标记
0值单元格

现在，我们应用简单的动态规划技术

dp[i][j]=dp[i][j]+max（dp[i-1][j]，dp[i][j-1]）-1

如果（归零[i][j]==1）
即为
0值单元格
，则忽略此单元格
如果（归零[i-1][j]==1）
则忽略顶部单元格的加法
如果（归零[i][j-1]==1）
则忽略左单元格的加法
dp[row-1][col-1]
是最佳答案
这就是我们解决这个问题的方法。如果你仍然觉得很难，那么你需要学习动态规划。
程序代码：

#include<iostream>
using namespace std;
int zeroed[50][50]; //for reference of 0 valued cells
int main(){
        int dp[50][50];
        int row,col,value;
        cin>>row>>col;
        /*=========initializing matrix========*/
        for(int i=0;i<row;i++){
                for(int j=0;j<col;j++){

                        cin>>value;
                        dp[i][j]=value;
                        if(value == 0){
                                zeroed[i][j]=1; //marking 0 valued cell
                        }

                }
        }

        /*==========applying dynamic programming=====*/
        for(int i=0;i<row;i++){
                for(int j=0;j<col;j++){
                        if(zeroed[i][j]== 1){
                                continue; //just ignore this cells
                        }
                        if(i>0 && j>0){
                                if(zeroed[i-1][j] !=1 && zeroed[i][j-1]!=1){
                                        dp[i][j]+=max(dp[i-1][j],dp[i][j-1]) - 1;
                                }else if(zeroed[i-1][j]!=1){
                                        dp[i][j]+= dp[i-1][j] - 1;
                                }else if(zeroed[i][j-1]!=1){
                                        dp[i][j]+=dp[i][j-1] - 1;
                                }
                                //ignore other cases

                        }else if(i>0){
                                if(zeroed[i-1][j]!=1){
                                        dp[i][j]+=dp[i-1][j] - 1;
                                }
                                //ignore other cases
                        }else if(j>0){
                                if(zeroed[i][j-1]!=1){

                                        dp[i][j]+=dp[i][j-1] - 1;
                                }
                                //ignore other cases
                        }
                }
        }
        cout<<dp[row-1][col-1];//max s 
        return 0;
}

#包括
使用名称空间std；
整数归零[50][50]//用于0值单元格的参考
int main（）{
int dp[50][50]；
int行、列、值；
cin>>行>>列；
/*==========初始化矩阵========*/
对于（int i=0；ivalue；
dp[i][j]=数值；
如果（值==0）{
归零[i][j]=1；//标记0值单元格
}
}
}
/*=============应用动态规划=====*/
对于（int i=0；i0）{
如果（归零[i-1][j]！=1和归零[i][j-1]！=1）{
dp[i][j]+=max（dp[i-1][j]，dp[i][j-1]）-1；
}否则如果（归零[i-1][j]！=1）{
dp[i][j]+=dp[i-1][j]-1；
}否则如果（归零[i][j-1]！=1）{
dp[i][j]+=dp[i][j-1]-1；
}
//忽略其他情况
}如果（i>0），则为else{
如果（归零[i-1][j]！=1）{
dp[i][j]+=dp[i-1][j]-1；
}
//忽略其他情况
}否则，如果（j>0）{
如果（归零[i][j-1]！=1）{
dp[i][j]+=dp[i][j-1]-1；
}
//忽略其他情况
}
}
}
正如Mark提到的，这是一个动态规划问题。所以这个问题与哈希表无关。现在，由于Mark的答案有点难理解，我将尝试解释我的解决方案。
给定的问题类似于标准矩阵路径优化问题，有两个有趣的转折点

解决方案路径不能包含
0值单元格
上面这一点也是一个标准问题。但这里有一个转折点。因为单元格有整数值。很难区分原始的
0值单元格
，以及由于先前添加而在中间
dp
矩阵中的单元格