前言
当递归函数有两个可变参数时，改成的动态规划就是二维的。
一、从递归到二维动态规划
1.最小路径和
class Solution {
public:vector<int>move={0,1,0};static bool cmp(vector<int>&a,vector<int>&b){return a[2]>b[2];}int minPathSum(vector<vector<int>>& grid) {int n=grid.size();int m=grid[0].size();//return dijkstra(n,m,grid);//return recursion(0,0,n,m,grid);//vector<vector<int>>dp(n,vector<int>(m,-1));//return memorized_search(0,0,n,m,grid,dp);//return dynamic_programming(n,m,grid);return optimized_dp(n,m,grid);}int dijkstra(int n,int m,vector<vector<int>>&grid){vector<vector<int>>distance(n,vector<int>(m,INT_MAX));distance[0][0]=grid[0][0];vector<vector<bool>>visited(n,vector<bool>(m,false));priority_queue<vector<int>,vector<vector<int>>,decltype(&cmp)>heap(cmp);heap.push({0,0,grid[0][0]});while(!heap.empty()){int x=heap.top()[0];int y=heap.top()[1];heap.pop();if(!visited[x][y]){if(x==n-1&&y==m-1){return distance[x][y];}visited[x][y]=true;for(int i=0;i<2;i++){int nx=x+move[i];int ny=y+move[i+1];if(nx>=0&&nx<n&&ny>=0&&ny<m&&!visited[nx][ny]){if(grid[nx][ny]+distance[x][y]<distance[nx][ny]){distance[nx][ny]=grid[nx][ny]+distance[x][y];heap.push({nx,ny,distance[nx][ny]});}}}}}return -1;}//递归 -> 超时int recursion(int x,int y,int n,int m,vector<vector<int>>&grid){if(x==n-1&&y==m-1){return grid[x][y];}if(x<0||x>n-1||y<0||y>m-1){return INT_MAX;}int ans=grid[x][y]+min(recursion(x,y+1,n,m,grid),recursion(x+1,y,n,m,grid));return ans;}//记忆化搜索 -> 超时int memorized_search(int x,int y,int n,int m,vector<vector<int>>&grid,vector<vector<int>>&dp){if(x==n-1&&y==m-1){return grid[x][y];}if(x<0||x>n-1||y<0||y>m-1){return INT_MAX;}if(dp[x][y]!=-1){return dp[x][y];}int ans=grid[x][y]+min(recursion(x,y+1,n,m,grid),recursion(x+1,y,n,m,grid));dp[x][y]=ans;return ans;}//动态规划int dynamic_programming(int n,int m,vector<vector<int>>&grid){vector<vector<int>>dp(n,vector<int>(m));dp[n-1][m-1]=grid[n-1][m-1];for(int i=n-1;i>=0;i--){for(int j=m-1;j>=0;j--){if(i==n-1&&j==m-1){continue;}dp[i][j]=grid[i][j]+min(i+1<=n-1?dp[i+1][j]:INT_MAX,j+1<=m-1?dp[i][j+1]:INT_MAX);}}return dp[0][0];}//空间压缩int optimized_dp(int n,int m,vector<vector<int>>&grid){vector<int>dp(m);//初始化dp[m-1]=grid[n-1][m-1];for(int j=m-2;j>=0;j--){dp[j]=dp[j+1]+grid[n-1][j];}for(int i=n-2;i>=0;i--){dp[m-1]=grid[i][m-1]+dp[m-1];for(int j=m-2;j>=0;j--){dp[j]=grid[i][j]+min(dp[j],dp[j+1]);}}return dp[0];}
};其实这个题用dijkstra也能做。（）
观察可知，递归函数肯定有两个可变参数，一个是x坐标一个是y坐标。那么之后就是到了终点就返回终点格子的大小，否则就是当前格子的大小加上下边和右边的最小值。又因为要比较最小值，所以当越界的时候要返回无穷大。
之后记忆化搜索就是挂个dp表即可。
再就是改动态规划，在二维动态规划中，由于有两个可变参数，所以dp表呈现的形式是一个二维网格。之后分析严格位置依赖可知，每个格子依赖自己右方和下方的格子，那么在填格子的时候就从下往上，从右往左填。
然后因为只依赖自己下方和右方的格子，那么就可以只用一个一维数组，只表示当前一行。之后从下往上滚动更新即可。
2.单词搜索
这个题想说明的就是带路径的递归不适合改动态规划。
class Solution {
public:vector<int>move={-1,0,1,0,-1};bool exist(vector<vector<char>>& board, string word) {for(int i=0;i<board.size();i++){for(int j=0;j<board[0].size();j++){if(recursion(i,j,0,word,board)){return true;}}}return false;}bool recursion(int x,int y,int i,string &word,vector<vector<char>>&board){if(i==word.length()){return true;}if(x<0||x>=board.size()||y<0||y>=board[0].size()||board[x][y]!=word[i]){return false;}char tmp=board[x][y];//带路径！！！board[x][y]=0;bool ans=false;for(int j=0;j<4;j++){ans|=recursion(x+move[j],y+move[j+1],i+1,word,board);}board[x][y]=tmp;//还原现场return ans;}
};因为要求不能走回头路，那么每来到一个格子，都要先把当前格子改成0，之后在回来的时候再还原。那么由此可知，每次递归的时候，可变参数不只两个坐标，还有整个棋盘格，所以没法改成动态规划。
那么整体思路就是遍历棋盘格，即讨论以每个点开头的情况，