现在要做一个校园导航，用C语言实现，要求学生向系统输入某个日程信息时系统能自动进行路径规划，并输出最短路线

实现校园导航的路径规划功能，需要借助图论算法。以下是一个基于Dijkstra算法的C语言实现示例：

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

#define MAX_NODES 1000

typedef struct {
    int dest;
    int weight;
    struct Node* next;
} Node;

typedef struct {
    Node* head;
} List;

typedef struct {
    List* array;
    int size;
} Graph;

Node* createNode(int dest, int weight) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->dest = dest;
    newNode->weight = weight;
    newNode->next = NULL;
    return newNode;
}

Graph* createGraph(int size) {
    Graph* graph = (Graph*)malloc(sizeof(Graph));
    graph->array = (List*)malloc(size * sizeof(List));
    graph->size = size;
    for (int i = 0; i < size; i++) {
        graph->array[i].head = NULL;
    }
    return graph;
}

void addEdge(Graph* graph, int src, int dest, int weight) {
    Node* newNode = createNode(dest, weight);
    newNode->next = graph->array[src].head;
    graph->array[src].head = newNode;
    newNode = createNode(src, weight);
    newNode->next = graph->array[dest].head;
    graph->array[dest].head = newNode;
}

void dijkstra(Graph* graph, int src, int dest) {
    int dist[MAX_NODES];
    int visited[MAX_NODES];
    int prev[MAX_NODES];
    int count = 0, minDist, nextNode;
    for (int i = 0; i < graph->size; i++) {
        dist[i] = INT_MAX;
        visited[i] = 0;
        prev[i] = -1;
    }
    dist[src] = 0;
    visited[src] = 1;
    for (Node* neighbor = graph->array[src].head; neighbor != NULL; neighbor = neighbor->next) {
        dist[neighbor->dest] = neighbor->weight;
        prev[neighbor->dest] = src;
    }
    while (count < graph->size - 1) {
        minDist = INT_MAX;
        for (int i = 0; i < graph->size; i++) {
            if (dist[i] < minDist && !visited[i]) {
                minDist = dist[i];
                nextNode = i;
            }
        }
        visited[nextNode] = 1;
        for (Node* neighbor = graph->array[nextNode].head; neighbor != NULL; neighbor = neighbor->next) {
            if (!visited[neighbor->dest]) {
                if (minDist + neighbor->weight < dist[neighbor->dest]) {
                    dist[neighbor->dest] = minDist + neighbor->weight;
                    prev[neighbor->dest] = nextNode;
                }
            }
        }
        count++;
    }
    printf("Shortest path from %d to %d: ", src, dest);
    int path[MAX_NODES], pathCount = 0;
    path[pathCount++] = dest;
    int node = dest;
    while (prev[node] != -1) {
        path[pathCount++] = prev[node];
        node = prev[node];
    }
    for (int i = pathCount - 1; i >= 0; i--) {
        printf("%d ", path[i]);
    }
    printf("\nShortest distance: %d\n", dist[dest]);
}

int main() {
    int n, m;
    printf("Enter number of nodes and edges: ");
    scanf("%d %d", &n, &m);
    Graph* graph = createGraph(n);
    for (int i = 0; i < m; i++) {
        int src, dest, weight;
        printf("Enter edge %d: ", i + 1);
        scanf("%d %d %d", &src, &dest, &weight);
        addEdge(graph, src, dest, weight);
    }
    int src, dest;
    printf("Enter source and destination: ");
    scanf("%d %d", &src, &dest);
    dijkstra(graph, src, dest);
    return 0;
}

在该示例中，首先定义了三个结构体：`Node`表示图的节点，包含目标节点、边权重和下一个节点指针；`List`表示邻接表，包含链表头节点；`Graph`表示图，包含邻接表数组和节点数。

然后定义了一些辅助函数，包括创建节点、创建图、添加边和Dijkstra算法。在Dijkstra算法中，使用了`dist`数组记录起点到每个节点的最短距离，`visited`数组记录节点是否已被访问，`prev`数组记录路径节点。

最后在`main`函数中，读入节点数和边数，创建图并添加边。然后读入起点和终点，调用Dijkstra算法进行路径规划，并输出最短路径和最短距离。