实现简单地图检索C++

要实现简单地图检索，可以通过以下步骤：

1. 定义地图数据结构：可以使用二维数组、图或者其他数据结构来表示地图。地图上的每个位置可以表示为一个节点，每个节点可以有多个连接的边，用于表示可以从该节点到达的其他节点。

2. 实现搜索算法：可以使用广度优先搜索（BFS）或者深度优先搜索（DFS）等算法来搜索地图。搜索的过程中，需要维护一个队列或者栈，用于记录待搜索的节点。

3. 实现路径规划算法：可以使用Dijkstra算法或者A*算法等算法来实现路径规划。这些算法可以根据节点之间的距离和启发式函数来计算最短路径。

4. 实现用户接口：可以使用命令行或者图形界面来实现用户接口。用户可以输入起点和终点的坐标，程序会返回最短路径以及路径长度。

以下是C++代码的示例：

#include <iostream>
#include <queue>
#include <vector>

using namespace std;

const int MAX = 100;

struct Node {
    int x, y, dist;
    Node(int x, int y, int dist): x(x), y(y), dist(dist) {}
};

int bfs(int map[][MAX], int n, int m, int sx, int sy, int tx, int ty) {
    int dx[] = {-1, 0, 1, 0};
    int dy[] = {0, 1, 0, -1};
    queue<Node> q;
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    q.push(Node(sx, sy, 0));
    visited[sx][sy] = true;
    while (!q.empty()) {
        Node cur = q.front();
        q.pop();
        if (cur.x == tx && cur.y == ty) {
            return cur.dist;
        }
        for (int i = 0; i < 4; i++) {
            int nx = cur.x + dx[i];
            int ny = cur.y + dy[i];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && map[nx][ny] != -1 && !visited[nx][ny]) {
                visited[nx][ny] = true;
                q.push(Node(nx, ny, cur.dist + 1));
            }
        }
    }
    return -1;
}

int dijkstra(int map[][MAX], int n, int m, int sx, int sy, int tx, int ty) {
    const int INF = 0x3f3f3f3f;
    int dx[] = {-1, 0, 1, 0};
    int dy[] = {0, 1, 0, -1};
    vector<vector<int>> dist(n, vector<int>(m, INF));
    vector<vector<bool>> visited(n, vector<bool>(m, false));
    dist[sx][sy] = 0;
    for (int i = 0; i < n * m; i++) {
        int x = -1, y = -1, minDist = INF;
        for (int j = 0; j < n; j++) {
            for (int k = 0; k < m; k++) {
                if (!visited[j][k] && dist[j][k] < minDist) {
                    minDist = dist[j][k];
                    x = j;
                    y = k;
                }
            }
        }
        if (x == -1 || y == -1) {
            break;
        }
        visited[x][y] = true;
        for (int j = 0; j < 4; j++) {
            int nx = x + dx[j];
            int ny = y + dy[j];
            if (nx >= 0 && nx < n && ny >= 0 && ny < m && map[nx][ny] != -1 && dist[nx][ny] > dist[x][y] + map[nx][ny]) {
                dist[nx][ny] = dist[x][y] + map[nx][ny];
            }
        }
    }
    return dist[tx][ty] == INF ? -1 : dist[tx][ty];
}

int main() {
    int map[MAX][MAX];
    int n, m, sx, sy, tx, ty;
    cin >> n >> m >> sx >> sy >> tx >> ty;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> map[i][j];
        }
    }
    cout << bfs(map, n, m, sx, sy, tx, ty) << endl;
    cout << dijkstra(map, n, m, sx, sy, tx, ty) << endl;
    return 0;
}

在上面的代码中，我们实现了BFS和Dijkstra算法来搜索地图并计算最短路径。用户可以通过命令行输入地图的大小、起点和终点的坐标以及地图的数据，程序会输出最短路径的长度。