迷宫最值问题

#include<iostream>
#include<vector>
#include<cstring>
#include<queue>
using namespace std;
const int maxn = 10005;
const int INF = 2147483647;
struct Edge{
	int from,to,dist;
};
struct HeapNode{
	int d,u;
	bool operator <(const HeapNode & a) const{
		return d > a.d;
	}
};
struct Dijkstra{
	int n,m;
	vector<Edge> edges;
	vector<int> G[maxn]; 
	int d[maxn];
	bool vis[maxn];
	int p[maxn];
	
	void init(int n){
		this->n = n;
		for(int i = 0;i <= n;i++)	G[i].clear();
		memset(vis,false,sizeof vis);
		for(int i = 0;i <= n;i++)	p[i] = i;
		for(int i = 1;i <= n;i++)	d[i] = INF;
	}
	void add_edge(int from,int to,int dist){
		edges.push_back(Edge{from,to,dist});
		m = edges.size();
		G[from].push_back(m-1);
	}
	void dijkstra(int s){
		priority_queue<HeapNode> q;
		q.push(HeapNode{0,s});
		d[s] = 0;
		while(!q.empty()){
			HeapNode x = q.top();
			q.pop();
			int u = x.u;
			if(vis[u])	continue;
			vis[u] = true;
			for(int i = 0;i < G[u].size();i++){
				Edge& e = edges[G[u][i]];
				if(d[e.to] > d[u] + e.dist){
					d[e.to] = d[u] + e.dist;
					p[e.to] = u;
					q.push(HeapNode{d[e.to],e.to});
				}
			}
		}
	}
};

先把dijstra放在这。
题目：给定一个矩阵，可以上下左右走，每次走的代价为对应矩阵值差的绝对值，也就是|X-Y|，求从左上角到右下角的走过的最小代价。注意：可以重复走同一个格子。
举一个例子：
2 1 3
2 2 3
dp的话，可能得双向dp了。
思路是到右下角的2，那么应该是dp[1][2]=min(dp[1][1]+abs(3-2),dp[0][2]+abs(3-3)]
然后求dp[1][1]和dp[0][2]。
一开始我的思路是：

n=int(input())
l=[[0]*n for _ in range(n)]
for i in range(n):
        s=input()
        l[i]=[int(j) for j in s.split()]
dp=[[0]*n for _ in range(n)]
dp[0][0]=l[0][0]
for i in range(1,n):
        dp[0][i]=dp[0][i-1]+abs(l[0][i-1]-l[0][i])
        dp[i][0]=dp[i-1][0]+abs(l[i-1][0]-l[i][0])

for i in range(1,n):
        for j in range(1,n):
                dp[i][j]=min(
                                dp[i-1][j]+abs(l[i-1][j]-l[i][j]),
                                dp[i][j-1]+abs(l[i][j-1]-l[i][j])
                                )
for i in range(n):
        for j in range(n):
                le=float("inf") if i-1<0 else dp[i-1][j]+abs(l[i-1][j]-l[i][j])
                r=float("inf") if i+1>n-1 else dp[i+1][j]+abs(l[i+1][j]-l[i][j])
                t= float("inf") if j-1<0 else dp[i][j-1]+abs(l[i][j-1]-l[i][j])
                b=float("inf") if j+1>n-1 else dp[i][j+1]+abs(l[i][j+1]-l[i][j])
                dp[i][j]=min([le,r,t,b])
                dp[0][0]=0
print(dp[-1][-1])
        
                
        

假设为方阵，不是仿真其实也一样。这个代码还可以优化，先填满第一行和第一列，填的方法是按照左和上的来决定下一个，但是这样没有可能出问题。
比如
: 2 1 3
2 2 3
这个最小代价如果按照上面的方法：
dp是
0 1 3
0 0 1
这个到达右上角的3是有问题的，因为最小其实是1。
这样的错误可能导致最后的结果错误，如果再来一个反向dp呢？
就是
3 2 2
3 1 2
这样的话，
0 1 1
0 2 1
但是我的dp算法通过率也才55%。
这个感觉能用dijkstra，但是那样感觉空间太大。
那么就试试BFS和DFS吧。