用c语言写给定一张包含 � n 个点以及 � m 条边的无向图，点按 1 1 到 � n 进行编号，试求出点 � s 到点 � t 的最短路长度。

以下是使用 Dijkstra 算法求解两点之间最短路的 C 代码：

#include <stdio.h>
#include <stdbool.h>
#include <limits.h>

#define N 10000
#define M 100000

typedef struct edge {
    int v;  // 边的终点
    int w;  // 边的权值
    struct edge *next;  // 链表下一条边
} Edge;

Edge edges[M * 2 + 1];  // 边的链表
int head[N + 1];  // 每个点的第一条边
int dist[N + 1];  // 起点到每个点的最短距离
bool vis[N + 1];  // 记录每个点是否已经访问
int heap[N + 1];  // 堆
int heap_size;  // 堆的大小

// 初始化边的链表和每个点的第一条边
void init() {
    for (int i = 0; i <= N; i++) {
        head[i] = -1;
    }
}

// 添加一条边
void add_edge(int u, int v, int w) {
    edges[heap_size].v = v;
    edges[heap_size].w = w;
    edges[heap_size].next = head[u];
    head[u] = heap_size++;
}

// 堆的操作
void swap(int *a, int *b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

void heap_push(int x) {
    heap[heap_size++] = x;
    int i = heap_size - 1;
    while (i > 0) {
        int p = (i - 1) / 2;
        if (dist[heap[p]] > dist[x]) {
            heap[i] = heap[p];
            i = p;
        } else {
            break;
        }
    }
    heap[i] = x;
}

int heap_pop() {
    int x = heap[0];
    heap[0] = heap[--heap_size];
    int i = 0, c = 1;
    while (c < heap_size) {
        if (c + 1 < heap_size && dist[heap[c + 1]] < dist[heap[c]]) {
            c++;
        }
        if (dist[heap[c]] < dist[heap[i]]) {
            swap(&heap[c], &heap[i]);
            i = c;
            c = i * 2 + 1;
        } else {
            break;
        }
    }
    return x;
}

// Dijkstra 算法
void dijkstra(int s) {
    // 初始化
    heap_size = 0;
    for (int i = 1; i <= N; i++) {
        dist[i] = INT_MAX;
        vis[i] = false;
    }
    dist[s] = 0;
    heap_push(s);

    // 循环
    while (heap_size > 0) {
        int u = heap_pop();
        if (vis[u]) {
            continue;
        }
        vis[u] = true;
        for (int i = head[u]; i != -1; i = edges[i].next) {
            int v = edges[i].v, w = edges[i].w;
            if (!vis[v] && dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                heap_push(v);
            }
        }
    }
}

int main() {
    int n, m, s, t;
    scanf("%d %d %d %d", &n, &m, &s, &t);
    init();
    for (int i = 0; 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);
    printf("%d\n", dist[t]);
    return 0;
}

在这个程序中，我们首先定义了一个结构体Edge，它包含了一条边的终点和边权。然后我们定义了一个数组head，它存储每个点的第一条边。我们使用链表来存储边，每个点的第一条边存储在head数组中，之后的边通过链表的next指针连接起来。

在输入完边后，我们使用add_edge函数来添加边到链表中。由于是无向图，所以每条边需要在两个方向上都添加。

接下来，我们使用Dijkstra算法来求解起点s到终点t的最短路。我们使用一个堆来维护当前距离起点最近的点，堆中存储的是点的编号。堆中的元素按照dist数组的值从小到大排序。在堆的操作中，我们使用自下而上的方式将元素插入堆中，使用自上而下的方式将元素取出堆中。

在dijkstra函数中，我们首先初始化dist数组和vis数组。然后将起点s加入堆中，并开始进行循环。每次从堆中取出当前距离起点最近的点u，并将它标记为已访问。然后遍历u的所有邻居点v，如果v还没有被访问，并且从s到u再到v的距离比之前计算的dist[v]更短，则更新dist[v]，并将v加入堆中。

最后输出dist[t]，即为起点s到终点t的最短路径长度。