不用STL解决以下问题。并尽可能提高算法效率：题目描述 给一个 � ( 1 ≤ � ≤ 1 0 6 ) n(1≤n≤10 6 ) 个点 � ( 1 ≤ � ≤ 1 0 6 ) m(1≤m≤10 6 ) 条边的无向图，求 � s 到 � t 的最短路的长度。 数据保证， � s 出发可以到达 � t。 Input 请从 stdin 读入。注意，输入可能很大 ( > 10 M B ) (>10MB)。 第一行为四个正整数 � , � , � , � n,m,s,t。 第二行起 � m 行，每行三个非负整数 � � , � � , � � ( 0 ≤ � � ≤ 1 ) u i ​ ,v i ​ ,w i ​ (0≤w i ​ ≤1)，表示从 � � u i ​ 到 � � v i ​ 有一条权值为 � � w i ​ 的无向边。 Output 请输出到 stdout 中。 输出一行一个整数，表示 � s 到 � t 的距离。

以下是不使用STL解决该问题的代码，使用了堆优化的Dijkstra算法来求解最短路问题。

#include <cstdio>
#include <cstring>

const int INF = 0x3f3f3f3f;
const int MAXN = 1e6 + 5;
const int MAXM = 2e6 + 5;

struct Edge {
    int to, w, next;
} edges[MAXM];
int head[MAXN], edge_cnt = 0;

void add_edge(int u, int v, int w) {
    edges[++edge_cnt].to = v;
    edges[edge_cnt].w = w;
    edges[edge_cnt].next = head[u];
    head[u] = edge_cnt;
}

struct Node {
    int v, d;
};

bool operator < (Node a, Node b) {
    return a.d > b.d;
}

Node heap[MAXN];
int heap_size = 0;

void push_heap(Node x) {
    heap[++heap_size] = x;
    int i = heap_size;
    while (i > 1 && heap[i].d < heap[i/2].d) {
        std::swap(heap[i], heap[i/2]);
        i /= 2;
    }
}

Node pop_heap() {
    Node res = heap[1];
    heap[1] = heap[heap_size--];
    int i = 1, j;
    while (i*2 <= heap_size) {
        if (i*2+1 <= heap_size && heap[i*2+1].d < heap[i*2].d) {
            j = i*2+1;
        } else {
            j = i*2;
        }
        if (heap[j].d < heap[i].d) {
            std::swap(heap[i], heap[j]);
            i = j;
        } else {
            break;
        }
    }
    return res;
}

int dis[MAXN];
bool vis[MAXN];

void dijkstra(int s, int t) {
    memset(dis, INF, sizeof(dis));
    dis[s] = 0;
    push_heap({s, 0});
    while (heap_size > 0) {
        Node u = pop_heap();
        if (vis[u.v]) {
            continue;
        }
        vis[u.v] = true;
        for (int e = head[u.v]; e != 0; e = edges[e].next) {
            int v = edges[e].to, w = edges[e].w;
            if (!vis[v] && dis[u.v] + w < dis[v]) {
                dis[v] = dis[u.v] + w;
                push_heap({v, dis[v]});
            }
        }
    }
}

int main() {
    int n, m, s, t;
    scanf("%d%d%d%d", &n, &m, &s, &t);
    for (int i = 1; i <= m; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        add_edge(u, v, w);
        add_edge(v, u, w);
    }
    dijkstra(s, t);
    printf("%d\n", dis[t]);
    return 0;
}

在上面的代码中，我们首先定义了一个结构体 `Edge` 来表示图的边，并使用邻接表来存储图。为了实现堆优化的Dijkstra算法，我们还定义了一个结构体 `Node` 来表示堆中的元素，并实现了 `push_heap()` 和 `pop_heap()` 函数来操作堆。

在 `dijkstra()` 函数中，我们首先初始化起点的距离为0，并将其加入堆中。然后，我们不断从堆中取出距离目前最小的顶点，并更新其邻接点的距离。如果邻接点的距离被更新，我们将其加入堆中。

最后，在主函数中，我们读入图的信息并运行 `dijkstra()` 函数来求解最短路问题，并输出结果。