请在不适用stl容器的情况下，用C++解决下列问题：给一个n个点，m条线的无向图，求s到t的最短路径，注意第一行分别输入n，m，s，t，后续每行输入3个数，分别为起始点，终止点和路径权值

好的，你可以使用Dijkstra算法来解决这个问题。由于题目要求不使用STL容器，我们需要手动实现堆来维护待处理的点。具体步骤如下：

1. 定义一个数组dist，表示起点s到每个点的最短路径。将所有点的dist值都赋为正无穷大，s点的dist值初始化为0。

2. 定义一个数组visited，表示每个点是否已经被加入到S集合中。将所有点的visited值都赋为false。

3. 定义一个堆heap，用于维护待处理的点。每个元素是一个pair，第一个元素是该点的dist值，第二个元素是该点的编号。将起点s加入到堆中。

4. 从堆中取出dist值最小的点u，并将其加入到S集合中。如果u等于目标点t，则退出循环，此时dist[t]就是s到t的最短路径长度。

5. 遍历u的所有邻居v，如果v没有被加入到S集合中，并且通过u可以更新v的dist值，则将v加入到堆中。具体地，如果dist[u]+w(u,v) < dist[v]，则更新dist[v]为dist[u]+w(u,v)。

6. 重复步骤4和步骤5，直到堆为空，或者目标点t已经被加入到S集合中。

下面是C++代码实现：

#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>

using namespace std;

const int INF = 0x3f3f3f3f;

// 自定义堆，用于维护待处理的点
class Heap {
public:
    Heap(int n): capacity_(n), size_(0) {
        data_ = new pair<int, int>[n];
    }

    ~Heap() {
        delete[] data_;
    }

    void push(pair<int, int> x) {
        if (size_ == capacity_) {
            capacity_ *= 2;
            pair<int, int>* new_data = new pair<int, int>[capacity_];
            for (int i = 0; i < size_; ++i) {
                new_data[i] = data_[i];
            }
            delete[] data_;
            data_ = new_data;
        }
        data_[size_++] = x;
        push_heap(data_, data_+size_, greater<pair<int, int>>());
    }

    pair<int, int> top() {
        return data_[0];
    }

    void pop() {
        pop_heap(data_, data_+size_, greater<pair<int, int>>());
        --size_;
    }

    bool empty() {
        return size_ == 0;
    }

private:
    pair<int, int>* data_;
    int capacity_;
    int size_;
};

// Dijkstra算法实现
int dijkstra(int n, int m, const vector<vector<pair<int, int>>>& edges, int s, int t) {
    int* dist = new int[n];
    bool* visited = new bool[n];
    for (int i = 0; i < n; ++i) {
        dist[i] = INF;
        visited[i] = false;
    }
    dist[s] = 0;
    Heap heap(n);
    heap.push(make_pair(0, s));
    while (!heap.empty()) {
        pair<int, int> p = heap.top();
        heap.pop();
        int u = p.second;
        if (visited[u]) {
            continue;
        }
        visited[u] = true;
        if (u == t) {
            break;
        }
        for (auto it = edges[u].begin(); it != edges[u].end(); ++it) {
            int v = it->first;
            int w = it->second;
            if (!visited[v] && dist[u]+w < dist[v]) {
                dist[v] = dist[u] + w;
                heap.push(make_pair(dist[v], v));
            }
        }
    }
    int result = dist[t];
    delete[] dist;
    delete[] visited;
    return result;
}

// 主函数
int main() {
    int n, m, s, t;
    cin >> n >> m >> s >> t;
    --s;
    --t;
    vector<vector<pair<int, int>>> edges(n);
    for (int i = 0; i < m; ++i) {
        int u, v, w;
        cin >> u >> v >> w;
        --u;
        --v;
        edges[u].push_back(make_pair(v, w));
        edges[v].push_back(make_pair(u, w));
    }
    int result = dijkstra(n, m, edges, s, t);
    cout << result << endl;
    return 0;
}

输入示例：

5 7 1 5
1 2 2
1 3 6
2 3 3
2 4 7
3 4 1
3 5 4
4 5 3

输出示例：

8