先基于迷宫构造相应的无向图，再利用Dijkstra算法的思路进行求解

可以将迷宫看作一个网格图，每个网格表示一个节点，相邻的网格之间连一条边。由于每个节点的权值都为非负整数，因此可以使用Dijkstra算法求解最短路径。

以下是基于迷宫构造无向图并使用Dijkstra算法求解最短路径的C语言代码：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_M 100
#define MAX_N 100
#define INF 0x3f3f3f3f

typedef struct {
    int x, y;  // 表示节点的坐标
    int dist;  // 表示起点到该节点的距离
} Vertex;

typedef struct {
    int v;  // 表示边的起点
    int w;  // 表示边的终点
    int weight;  // 表示边的权值
} Edge;

int m, n;  // 迷宫的行数和列数
int T[MAX_M][MAX_N];  // 存储迷宫信息
int vis[MAX_M][MAX_N];  // 标记某个位置是否已经访问过
Vertex vertices[MAX_M * MAX_N];  // 存储所有节点
Edge edges[MAX_M * MAX_N * 4];  // 存储所有边
int n_vertices = 0, n_edges = 0;  // 节点数和边数

// 判断一个位置是否可以走
int can_go(int x, int y) {
    if (x < 0 || x >= m || y < 0 || y >= n || T[x][y] < 0) {
        return 0;  // 该位置超出迷宫范围或为墙
    }
    return 1;
}

// 将一个节点加入vertices数组中
void add_vertex(int x, int y, int dist) {
    vertices[n_vertices++] = (Vertex){x, y, dist};
}

// 将一条边加入edges数组中
void add_edge(int v, int w, int weight) {
    edges[n_edges++] = (Edge){v, w, weight};
}

// 构造无向图
void build_graph() {
    // 构造所有节点
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (T[i][j] >= 0) {
                add_vertex(i, j, INF);
            }
        }
    }
    // 构造所有边
    for (int i = 0; i < n_vertices; i++) {
        Vertex v = vertices[i];
        for (int j = 0; j < 4; j++) {
            int nx = v.x + dx[j];
            int ny = v.y + dy[j];
            if (can_go(nx, ny)) {
                for (int k = 0; k < n_vertices; k++) {
                    if (vertices[k].x == nx && vertices[k].y == ny) {
                        add_edge(i, k, T[nx][ny]);
                        break;
                    }
                }
            }
        }
    }
}

// Dijkstra算法求解最短路径
int dijkstra() {
    int dist[MAX_M * MAX_N];
    memset(dist, INF, sizeof(dist));
    dist[0] = 0;  // 起点的距离为0
    for (int i = 0; i < n_vertices; i++) {
        int min_dist = INF, u = -1;
        for (int j = 0; j < n_vertices; j++) {
            if (!vis[j] && dist[j] < min_dist) {
                min_dist = dist[j];
                u = j;
            }
        }
        if (u == -1) {
            break;
        }
        vis[u] = 1;  // 标记该节点已经访问过
        for (int j = 0; j < n_edges; j++) {
            if (edges[j].v == u) {
                int w = edges[j].w;
                if (dist[u] + edges[j].weight < dist[w]) {
                    dist[w] = dist[u] + edges[j].weight;
                }
            } else if (edges[j].w == u) {
                int v = edges[j].v;
                if (dist[u] + edges[j].weight < dist[v]) {
                    dist[v] = dist[u] + edges[j].weight;
                }
            }
        }
    }
    return dist[n_vertices - 1];
}

int main() {
    scanf("%d %d", &m, &n);
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &T[i][j]);
        }
    }
    build_graph();  // 构造无向图
    int ans = dijkstra();  // 使用Dijkstra算法求解最短路径
    if (ans == INF) {
        printf("无\n");
    } else {
        printf("%d\n", ans);
    }
    return 0;
}

该程序先读入迷宫的大小和信息，然后使用build_graph函数构造无向图，使用Dijkstra算法求解最短路径，并输出结果。其中，can_go函数用于判断一个位置是否可以走，add_vertex函数用于将一个节点加入vertices数组中，add_edge函数用于将一条边加入edges数组中，build_graph函数用于构造无向图，dijkstra函数用于实现Dijkstra算法，main函数用于程序的输入和输出。