Java 我如何纠正我针对Cherry捡拾问题的DP解决方案

我的方法似乎是正确的，问题是是否允许多次旅行。 我的答案似乎超过了正确答案

问题：

class Solution {
    public int cherryPickup(int[][] grid) {

     int N = grid.length;

        int[][] dp;
        char[][] track;

        boolean f = true;

        int sum = 0;
        int count = 0;

        while(f)
        {
            dp = new int[N][N];
            track = new char[N][N];

            dp[0][0] = grid[0][0];
            track[0][0] = 'a';

            char c;

            c='u';

            for(int i=1;i<N;i++)
            {
              if(c=='r'||grid[i][0]==-1)
              {
                  c='r';
                  dp[i][0]=-1;
              }
                else
                    dp[i][0] = dp[i-1][0] + grid[i][0];

                track[i][0] = c;
            }

            c='s';

            for(int j=1;j<N;j++)
            {
                if(c=='r'||grid[0][j]==-1)
                {
                    c='r';
                    dp[0][j]=-1;
                }
                else
                    dp[0][j] = dp[0][j-1] + grid[0][j];

                track[0][j] = c;
            }

            for(int i=1;i<N;i++)
                for(int j=1;j<N;j++)
                {
                    if(grid[i][j]==-1||(track[i-1][j]=='r' && track[i][j-1]=='r'))
                    {
                        track[i][j] = 'r';
                        dp[i][j] = -1;
                    }
                    else
                    {
                        if(dp[i-1][j]>=dp[i][j-1])
                        {
                            track[i][j] = 'u';
                            dp[i][j] = dp[i-1][j] + grid[i][j];
                        }
                        else
                        {
                            track[i][j] = 's';
                            dp[i][j] = dp[i][j-1] + grid[i][j];
                        }
                    }
                }


            if(dp[N-1][N-1]<=0)
                break;

            sum += dp[N-1][N-1];

            int r = N-1 , cr = N-1;

            while(r>0||cr>0)
            {
                grid[r][cr]=0;
                if(track[r][cr]=='s')
                    cr--;
                else
                    r--;
            }

            grid[0][0] = 0;

        }

      return sum;
    }
}

在表示樱桃区域的nxn网格中，每个单元格是三个可能整数中的一个

0表示单元格为空，可以通过； 1表示该单元包含一个樱桃，可以拾取并穿过； -1表示单元格中有一根刺挡住了你的路

您的任务是按照以下规则收集尽可能多的樱桃：

通过在有效路径单元格（值为0或1的单元格）中向右或向下移动，从位置（0，0）开始并到达（N-1，N-1）； 到达（N-1，N-1）后，通过有效路径单元格向左或向上移动返回（0，0）； 当通过包含樱桃的路径单元格时，将其拾取，该单元格将变为空单元格（0）； 如果（0，0）和（N-1，N-1）之间没有有效路径，则无法收集樱桃

我的解决方案：

class Solution {
    public int cherryPickup(int[][] grid) {

     int N = grid.length;

        int[][] dp;
        char[][] track;

        boolean f = true;

        int sum = 0;
        int count = 0;

        while(f)
        {
            dp = new int[N][N];
            track = new char[N][N];

            dp[0][0] = grid[0][0];
            track[0][0] = 'a';

            char c;

            c='u';

            for(int i=1;i<N;i++)
            {
              if(c=='r'||grid[i][0]==-1)
              {
                  c='r';
                  dp[i][0]=-1;
              }
                else
                    dp[i][0] = dp[i-1][0] + grid[i][0];

                track[i][0] = c;
            }

            c='s';

            for(int j=1;j<N;j++)
            {
                if(c=='r'||grid[0][j]==-1)
                {
                    c='r';
                    dp[0][j]=-1;
                }
                else
                    dp[0][j] = dp[0][j-1] + grid[0][j];

                track[0][j] = c;
            }

            for(int i=1;i<N;i++)
                for(int j=1;j<N;j++)
                {
                    if(grid[i][j]==-1||(track[i-1][j]=='r' && track[i][j-1]=='r'))
                    {
                        track[i][j] = 'r';
                        dp[i][j] = -1;
                    }
                    else
                    {
                        if(dp[i-1][j]>=dp[i][j-1])
                        {
                            track[i][j] = 'u';
                            dp[i][j] = dp[i-1][j] + grid[i][j];
                        }
                        else
                        {
                            track[i][j] = 's';
                            dp[i][j] = dp[i][j-1] + grid[i][j];
                        }
                    }
                }


            if(dp[N-1][N-1]<=0)
                break;

            sum += dp[N-1][N-1];

            int r = N-1 , cr = N-1;

            while(r>0||cr>0)
            {
                grid[r][cr]=0;
                if(track[r][cr]=='s')
                    cr--;
                else
                    r--;
            }

            grid[0][0] = 0;

        }

      return sum;
    }
}

类解决方案{
公共int樱桃皮卡（int[][]网格）{
int N=网格长度；
int[]dp；
char[][]轨道；
布尔f=真；
整数和=0；
整数计数=0；
while（f）
{
dp=新整数[N][N]；
track=新字符[N][N]；
dp[0][0]=网格[0][0]；
音轨[0][0]=“a”；
字符c；
c='u'；
对于（int i=1；i