珠宝的最大价值

现有一个记作二维矩阵 frame 的珠宝架，其中 frame[i][j] 为该位置珠宝的价值。拿取珠宝的规则为：

• 只能从架子的左上角开始拿珠宝
• 每次可以移动到右侧或下侧的相邻位置
• 到达珠宝架子的右下角时，停止拿取

注意：珠宝的价值都是大于 0 的。除非这个架子上没有任何珠宝，比如 frame = [[0]]。

示例 1：

输入：frame = [[1,3,1],[1,5,1],[4,2,1]]
输出：12
解释：路径 1→3→5→2→1 可以拿到最高价值的珠宝

动态规划：

int dfs(int ** memo,int** frame,int n,int m){
    if(n < 0 || m < 0){
        return 0;
    }
    if(memo[n][m] != -1){
        return memo[n][m];
    }else{
        memo[n][m] = fmax(dfs(memo,frame,n-1,m),dfs(memo,frame,n,m-1)) + frame[n][m];
        return memo[n][m];
    }
}
int jewelleryValue(int** frame, int frameSize, int* frameColSize) {
    int N = frameSize,M = frameColSize[0];
    int** memo = (int**)malloc(N*sizeof(int*));
    for(int i = 0;i < N;i++){
        memo[i] = (int*)malloc(M*sizeof(int));
        for(int j = 0;j < M;j++){
            memo[i][j] = -1;
        }
    }
    int result = dfs(memo,frame,N-1,M-1);
    for(int i = 0;i < N;i++){
        free(memo[i]);
    }
    free(memo);
    return result;
}

如果有负数，下面这段代码就不适用了

    if(n < 0 || m < 0){
        return 0;
    }

因为假如一路选过来都是负数，fmax()中一个是越界访问值0，另一个是负数，那么较大值是0，就出错了，应更改为：

if(n < 0 || m < 0){
    return -INT_MAX;
}

当有负数时还有一种情况就是行列下标都为零时，此时dfs[0][0] = fmax(dfs[-1][0],dfs[0][-1]) + frame[0][0] ,一定是负无穷，又不对了。所以对这个点要单独讨论。

if(n ==0 && m==0){
    return frame[0][0];
}

翻译成递推:

递归改成循环，~每一个参数代表一个循环~递归的边界改成f数组的初始值、

f [ i ][ j ]和dfs[ i ][ j ]的意义是一样的，都是表示从左上角到右下角的最大家之和。相应的递推公式也是一样的：

                       f[ i ][ j ] = max( f[ i ][ j - 1 ] ,f[ i - 1][ j ] ) + grid[ i ][ j ]。

但是当 i = 0或 j = 0时，等号右边会出现负数下标。也就是说没有状态能表示递推出界情况。

解决方法：在 f 数组的上边和左边各加一排，把原来的f[i] 改成 f[i+1]，f[i−1] 改成 f[i]，j 也同理。

修改后 f[i+1][j+1] 表示从左上角到 ( i , j ) 的最大价值和。此时 f[i][0] 和 f[0][j] 就可以表示出界的状态了。

相应的递推式为                f[i+1][j+1]=max(f[i+1][j],f[i][j+1])+grid[i][j]

class Solution {
public:
    int jewelleryValue(vector<vector<int>> &grid) {
        int m = grid.size(), n = grid[0].size(), f[m + 1][n + 1];
        memset(f, 0, sizeof(f));
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j)
                f[i + 1][j + 1] = max(f[i + 1][j], f[i][j + 1]) + grid[i][j];
             //注意这里的grid[i][j]，f[i + 1][j + 1]在grid数组中对应的位置就是这
        return f[m][n];
    }
};

初始值 f[i][0]=0，f[0][j]=0。

优化思路

由于 f[i+1] 只依赖 f[i]，那么 f[i−1] 及其之前的数据就没用了。

例如计算 f[2] 的时候，数组 f[0] 不再使用了。

那么干脆把 f[2] 填到 f[0] 中。同理，把 f[3] 填到 f[1] 中，f[4] 填到 f[0] 中，……

因此可以只用两个长为 n+1 的数组滚动计算。

class Solution {
public:
    int jewelleryValue(vector<vector<int>> &grid) {
        int m = grid.size(), n = grid[0].size(), f[2][n + 1];
        memset(f, 0, sizeof(f));
        for (int i = 0; i < m; ++i)
            for (int j = 0; j < n; ++j)
                f[(i + 1) % 2][j + 1] =
                    max(f[(i + 1) % 2][j], f[i % 2][j + 1]) + grid[i][j];
//注意这里的grid[i][j]，f[i + 1][j + 1]在grid数组中对应的位置就是这
        return f[m % 2][n];
    }
};

空间优化：方法二：

举个例子，在计算 f[1][1] 时，会用到 f[0][1]，但是之后就不再用到了。

那么干脆把 f[1][1] 记到 f[0][1] 中，这样对于 f[1][2] 来说，它需要的数据就在 f[0][1] 和 f[0][2] 中。

f[1][2] 算完后也可以同样记到 f[0][2] 中。所以只需要一个长为 n+1 的一维数组就够了。

class Solution {
public:
    int jewelleryValue(vector<vector<int>> &grid) {
        int n = grid[0].size(), f[n + 1];
        memset(f, 0, sizeof(f));
        for (auto &row : grid)
            for (int j = 0; j < n; ++j)
                f[j + 1] = max(f[j], f[j + 1]) + row[j];
        return f[n];
    }
};

空间优化方案三：

直接用 grid[0] 当作 f 数组，可以做到 O(1) 额外空间。

由于 grid[0] 的长度只有 n，所以要按照

f[i][j]=max(f[i][j−1],f[i−1][j])+grid[i][j]
的方式来转移。

i=0 和 j=0 的情况要单独计算：

i=0 时，上式为 f[i][j]=f[i][j−1]+grid[i][j]；用一个数组时，为 f[j]=f[j−1]+grid[0][j]=f[j−1]+f[j]（grid[0] 就是 f 数组）。
j=0 时，上式为 f[i][j]=f[i−1][j]+grid[i][j]；用一个数组时，为 f[0]=f[0]+grid[i][0]。
注：对比上下两份代码，你会发现长为 n+1 的数组写起来是更加简洁的，因为可以避免判断边界条件。

class Solution {
public:
    int jewelleryValue(vector<vector<int>> &grid) {
        int m = grid.size(), n = grid[0].size();
        auto &f = grid[0];
        for (int j = 1; j < n; ++j)
            f[j] += f[j - 1];
        for (int i = 1; i < m; ++i) {
            f[0] += grid[i][0];
            for (int j = 1; j < n; ++j)
                f[j] = max(f[j - 1], f[j]) + grid[i][j];
        }
        return f[n - 1];
    }
};