输入一个数组（M,N），只可以想右边下边走，从（1，1）到（M,N）经过的最大数字和

本文介绍了一个使用记忆化搜索算法解决寻找二维矩阵中从左上角到右下角的最大路径和的问题。通过引入记忆数组来降低时间复杂度，避免重复计算，实现了高效的求解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

#include<iostream>
#include<vector>
using namespace std;
vector<vector<int> >A;
int N,M;
int max(int i,int j)
{
return i>j?i:j;
}

int dfs(int i,int j)
{

if(i==N||j==M)
return 0;
else if(i==N-1&&j==M-1)
return A[i][j];
else
return max(dfs(i+1,j),dfs(i,j+1))+A[i][j];

}

void init()
{
int t;
vector<int>X;
while(cin>>N>>M)
{
for(int i=0;i<N;i++)
{
for(int j=0;j<M;j++)
{
cin>>t;
X.push_back(t);
}

A.push_back(X);
X.clear();
}
cout<<dfs(0,0)<<endl;
A.clear();
}
}
int main()
{
init();

}

如果数据量大了，时间复杂度会很高，所以加上记忆化数组：

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
vector<vector<int> >A;
const int maxn=100;
int D[maxn][maxn];
int N,M;
int max(int i,int j)
{
    return i>j?i:j;
}

int dfs(int i,int j)
{
    if(D[i][j]>0)
        return D[i][j];

    if(i==N||j==M)
        return 0;
    else if(i==N-1&&j==M-1)
        return D[i][j]=A[i][j];
    else
        return D[i][j]=max(dfs(i+1,j),dfs(i,j+1))+A[i][j];

}

void init()
{
    for(int i=0;i<maxn;i++)
    {
        memset(D[i],-1,sizeof(int)*100);
    }
    int t;
    vector<int>X;
    while(cin>>N>>M)
    {
        for(int i=0; i<N; i++)
        {
            for(int j=0; j<M; j++)
            {
                cin>>t;
                X.push_back(t);
            }

            A.push_back(X);
            X.clear();
        }
        cout<<dfs(0,0)<<endl;
        A.clear();
    }
}
int main()
{
    init();

}

这里写图片描述
首先输入数组大小M*N;
其次输入数组；
输出最短路劲