假设一个带权图G采用邻接矩阵存储。设计一个算法采用狄克斯特拉算法思路求顶点s到顶点t的最短路径长度（假设顶点s和t都是G中的顶点）。

要使用狄克斯特拉(Dijkstra's Algorithm)在邻接矩阵表示的带权图中找到从顶点 `s` 到顶点 `t` 的最短路径长度，你可以按照以下步骤进行：

1. 初始化：
- 创建一个大小为图中顶点数的数组或vector `dist`，用于存放每个顶点到起始顶点 `s` 的最短距离，默认值初始化为无穷大（除了`s`本身，设为0）。
- 创建一个布尔型数组 `visited`，标记已访问过的顶点，初始时只有 `s` 标记为 `true`。

2. 运行循环：
- 设置当前未访问的最小距离节点为 `dist` 数组中最小的那个未访问节点。如果所有节点都被访问过，说明找到了最短路径，返回 `dist[t]` 作为结果。
- 对于当前节点 `u`，更新其相邻节点 `v` 的 `dist[v]` 值，如果通过 `u` 可以到达 `v` 且新路径更短，则更新 `dist[v] = dist[u] + weight(u, v)`，其中 `weight(u, v)` 是 `(u, v)` 边的权重。
- 将 `u` 标记为已访问 (`visited[u] = true`)，然后移除 `u`，继续寻找下一个未访问的节点。

3. 结束后，如果没有找到直接连接 `t` 的边，但 `t` 已经被访问过，那么 `dist[t]` 就是最短路径长度；否则，说明 `t` 没有直接从 `s`可达，此时 `dist[t]` 表示没有路径。

下面是用C++实现的一个简化版本：

#include <vector>
#include <limits>

int dijkstra(int graph[][V], int s, int t, int V) {
    std::vector<int> dist(V, INT_MAX); // dist[i] is the shortest distance from source to i
    std::vector<bool> visited(V, false);

    dist[s] = 0; // distance to source is 0
    visited[s] = true;

    for (int count = 0; count < V - 1 && !visited[t]; ++count) {
        int u = min_distance(dist, visited);
        visited[u] = true;

        for (int v = 0; v < V; ++v)
            if (!visited[v] && graph[u][v] != 0 && dist[u] != INT_MAX && dist[u] + graph[u][v] < dist[v])
                dist[v] = dist[u] + graph[u][v];
    }

    return visited[t] ? dist[t] : -1; // Return -1 if no path exists
}

// Helper function to find minimum distance vertex in unvisited vertices
int min_distance(std::vector<int>& dist, std::vector<bool>& visited) {
    int min_val = INT_MAX;
    int min_index = -1;

    for (int i = 0; i < dist.size(); ++i)
        if (!visited[i] && dist[i] < min_val)
            min_val = dist[i], min_index = i;

    return min_index;
}

在这个代码中，`graph` 是邻接矩阵，`V` 是顶点数量，`s` 和 `t` 分别是起点和终点。注意这个实现假设所有边都是非负权重，如果你的图中可能有负权重，你需要处理这种情况，比如使用Bellman-Ford算法。