不使用STL容器实现上述代码

当然可以，下面是不使用STL容器的实现方式：

#include<iostream>
#include<cstring>
#define N 25005
#define INF 0x3f3f3f3f
using namespace std;

typedef long long ll;

struct Edge{
    int to, w;
    Edge(int _to, int _w) : to(_to), w(_w) {}
};

Edge edge[N << 1];
int head[N], dis[N], vis[N], cnt = 0;
int n, m, s, t;

void addEdge(int u, int v, int w){
    edge[++cnt] = Edge(v, w);
    edge[++cnt] = Edge(u, w);
    head[u] = cnt - 1;
    head[v] = cnt;
}

void dijkstra(){
    memset(vis, 0, sizeof(vis));
    memset(dis, INF, sizeof(dis));
    dis[s] = 0;
    for(int i = 1; i < n; i++){
        int u = -1, minn = INF;
        for(int j = 1; j <= n; j++){
            if(!vis[j] && dis[j] < minn){
                u = j;
                minn = dis[j];
            }
        }
        if(u == -1) break;
        vis[u] = 1;
        for(int j = head[u]; j; j = j + 2){
            int v = edge[j].to, w = edge[j].w;
            if(!vis[v] && dis[v] > dis[u] + w){
                dis[v] = dis[u] + w;
            }
        }
    }
    cout << dis[t] << endl;
}

int main() {
    cin >> n >> m >> s >> t;
    memset(head, -1, sizeof(head));
    for (int i = 1; i <= m; i++){
        int u, v, w;
        cin >> u >> v >> w;
        addEdge(u, v, w);
    }
    dijkstra();
    return 0;
}

相对于使用STL容器的实现方式，这种实现方式更加底层，需要手动实现邻接表和堆的相关操作。具体改动如下：

1. 将邻接表 `G` 改为数组 `head`，`head[i]` 存储节点 i 的第一条边的编号。
2. 将结构体 `Edge` 改为数组 `edge`，`edge[i]` 存储编号为 i 的边的信息。
3. 将 `priority_queue` 改为手动实现堆的方式，每次寻找距离起点最近的节点时需要遍历整个节点集合。
4. 将 `visit` 数组改为 `vis` 数组，表示每个节点是否已经加入最短路径树中。
5. 利用宏定义 `INF` 代替原来的常数 `1e18`，避免常数过大导致的错误。
6. 将 `best` 数组改为 `dis` 数组，表示每个节点到起点的最短距离。

虽然这种实现方式相对复杂，但是其可以提高代码的执行效率，并且更加方便地进行调试和优化。