第 16 场双周赛：1301. 最大得分的路径数目（两种解法）

给你一个正方形字符数组 board ，你从数组最右下方的字符 'S' 出发。

你的目标是到达数组最左上角的字符 'E' ，数组剩余的部分为数字字符 1, 2, ..., 9 或者障碍 'X'。在每一步移动中，你可以向上、向左或者左上方移动，可以移动的前提是到达的格子没有障碍。

一条路径的 「得分」 定义为：路径上所有数字的和。

请你返回一个列表，包含两个整数：第一个整数是 「得分」 的最大值，第二个整数是得到最大得分的方案数，请把结果对 10^9 + 7 取余。

如果没有任何路径可以到达终点，请返回 [0, 0] 。

 

示例 1：

输入：board = ["E23","2X2","12S"]
输出：[7,1]
示例 2：

输入：board = ["E12","1X1","21S"]
输出：[4,2]
示例 3：

输入：board = ["E11","XXX","11S"]
输出：[0,0]
 

提示：

2 <= board.length == board[i].length <= 100

思路：比赛时我是采用bfs+剪枝强撸过去的，其实正解是dp，这里附上这两个方法的代码：

方法一：bfs+状态保存

class Solution {
	
	class node{
		int x,y,val;
		public node(int x,int y,int val) {
			this.x=x;
			this.y=y;
			this.val=val;
		}
	}
	
	int[] dx= {0,-1,-1};
	int[] dy= {-1,0,-1};
	
    public int[] pathsWithMaxScore(List<String> board) {
        
    	Queue<node>q=new LinkedList<>();
    	//Map<Integer,Integer> map=new HashMap<>();
    	
    	int[] ans=new int[2];
    	int m=board.size(),maxvalue=-1;
    	int[][] sum=new int[m][m];
    	int[][] flag=new int[m][m];
    	sum[m-1][m-1]=1;
    	q.add(new node(m-1,m-1,0));
    	while(!q.isEmpty()) {
    		node now=q.poll();
    		if(board.get(now.x).charAt(now.y)=='E') {
    			//map.put(now.val,(map.getOrDefault(now.val, 0)+1)%1000000007);
    			//maxvalue=Math.max(maxvalue, now.val);
    			continue;
    		}
    		for(int i=0;i<3;i++) {
    			int x=now.x+dx[i];
    			int y=now.y+dy[i];
    			if(x<0 || y<0 || board.get(x).charAt(y)=='X') continue;
    			//System.out.println(now.val+board.get(x).charAt(y)-'0');
    			if(board.get(x).charAt(y)=='E') {
    				if(now.val>maxvalue) {
    					sum[x][y]=sum[now.x][now.y];
    					maxvalue=now.val;
    				}
    				else if(now.val==maxvalue) {
    					sum[x][y]=(sum[x][y]+sum[now.x][now.y])%1000000007;
    					continue;
    				}
    				q.add(new node(x,y,now.val));
    			}
    			else if(flag[x][y]<=now.val+board.get(x).charAt(y)-'0') {
    				if(flag[x][y]==now.val+board.get(x).charAt(y)-'0')
    					sum[x][y]=(sum[x][y]+sum[now.x][now.y])%1000000007;
    				else {
    					sum[x][y]=sum[now.x][now.y];
    					q.add(new node(x,y,now.val+board.get(x).charAt(y)-'0'));
    					flag[x][y]=now.val+board.get(x).charAt(y)-'0';
    				}
    			}
    		}
    	}
    	if(maxvalue==-1) {
    		ans[0]=ans[1]=0;
    	}
    	else {
    		ans[0]=maxvalue;
    		ans[1]=sum[0][0];
    	}
    	return ans;
    }
}

方法二：动态规划。

定义dp[i][j][0]：表示走到（i，j）时的最大值:dp[i][j][1]：表示走到（i，j）并且能获得最大值的方案数。

class Solution {
    public int[] pathsWithMaxScore(List<String> board) {
        
    	int mod=1000000007;
    	int n=board.size();
    	int m=board.get(0).length();
    	int[][][] dp=new int[n][m][2];
    	
    	dp[0][0][1]=1;
    	for(int i=1;i<n;i++) {
    		if(board.get(i).charAt(0)=='X') {
    			dp[i][0][0]=Integer.MIN_VALUE;
				dp[i][0][1]=Integer.MIN_VALUE;
				continue;
    		}
    		dp[i][0][0]=dp[i-1][0][0]+board.get(i).charAt(0)-'0';
    		dp[i][0][1]+=dp[i-1][0][1];
    	}
    	for(int i=1;i<m;i++) {
    		if(board.get(0).charAt(i)=='X') {
    			dp[0][i][0]=Integer.MIN_VALUE;
				dp[0][i][1]=Integer.MIN_VALUE;
				continue;
    		}
    		dp[0][i][0]=dp[0][i-1][0]+board.get(0).charAt(i)-'0';
    		dp[0][i][1]+=dp[0][i-1][1];
    	}
    	
    	for(int i=1;i<n;i++)
    		for(int j=1;j<m;j++) {
    			int max,val;
    			if(board.get(i).charAt(j)=='X') {
    				dp[i][j][0]=Integer.MIN_VALUE;
    				dp[i][j][1]=Integer.MIN_VALUE;
    				continue;
    			}
    			if(board.get(i).charAt(j)=='S') 
    				val=0;
    			else
    				val=board.get(i).charAt(j)-'0';
    			max=dp[i-1][j][0];
    			if(max+val>=dp[i][j][0]) {
    				dp[i][j][0]=max+val;
    				dp[i][j][1]=dp[i-1][j][1];
    			}
    			if(max<dp[i][j-1][0]) {
    				dp[i][j][0]=dp[i][j-1][0]+val;
    				dp[i][j][1]=dp[i][j-1][1];
    				max=dp[i][j-1][0];
    			}
    			else if(max==dp[i][j-1][0]) 
    				dp[i][j][1]=(dp[i][j][1]+dp[i][j-1][1])%mod;
    			if(max<dp[i-1][j-1][0]) {
    				dp[i][j][0]=dp[i-1][j-1][0]+val;
    				dp[i][j][1]=dp[i-1][j-1][1];
    				max=dp[i-1][j-1][0];
    			}
    			else if(max==dp[i-1][j-1][0])
    				dp[i][j][1]=(dp[i][j][1]+dp[i-1][j-1][1])%mod;
    			//System.out.println(max+" "+i+" "+j);
    		}
    	
    	int[] ans=new int[2];
    	if(dp[n-1][m-1][0]<0 || dp[n-1][m-1][1]<0) {
    		ans[0]=ans[1]=0;
    	}
    	else {
    		ans[0]=dp[n-1][m-1][0];
    		ans[1]=dp[n-1][m-1][1];
    	}
    	return ans;
    }
}