给定一个图，设计一个程序，找出一条从某一顶点A到另一顶点B边数最少的一条路径

这是一个经典的图论问题，可以使用BFS（宽度优先搜索）算法来解决。以下是BFS算法的思路：

1. 定义一个队列，将起点加入队列中，同时记录起点到自己的距离为0。
2. 当队列不为空时，取出队首元素，遍历其邻居节点，如果邻居节点未被访问过，则将其加入队列中，并记录起点到该邻居节点的距离为上一个节点到起点的距离加1。
3. 重复步骤2，直到找到目标顶点或者队列为空。
4. 如果找到目标顶点，可以通过记录每个节点的前驱节点，从目标顶点开始向前遍历，即可得到一条从起点到目标顶点的最短路径。

具体实现时，可以使用队列来存储待访问的节点，使用数组来记录起点到各个节点的距离和前驱节点。以下是使用BFS算法求解从顶点A到顶点B的最短路径的C语言代码示例：

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

int graph[6][6] = {  // 有向图的邻接矩阵表示
    {0, 1, 1, 0, 0, 0},
    {0, 0, 0, 1, 0, 0},
    {0, 0, 0, 1, 1, 0},
    {0, 0, 0, 0, 0, 1},
    {0, 0, 0, 0, 0, 1},
    {0, 0, 0, 0, 0, 0}
};

int dist[6];  // 存储起点到各个顶点的距离
int prev[6];  // 存储每个节点的前驱节点
bool visited[6];  // 标记顶点是否已经访问过

// 使用BFS算法求解最短路径
void bfs(int start, int end) {
    // 初始化dist数组、visited数组和prev数组
    for (int i = 0; i < 6; i++) {
        dist[i] = -1;
        visited[i] = false;
        prev[i] = -1;
    }
    dist[start] = 0;

    // 定义一个队列，将起点加入队列中
    int queue[100];
    int front = 0;
    int rear = 0;
    queue[rear++] = start;

    // BFS遍历图
    while (front < rear) {
        int cur = queue[front++];
        visited[cur] = true;
        for (int i = 0; i < 6; i++) {
            if (graph[cur][i] == 1 && !visited[i]) {
                queue[rear++] = i;
                visited[i] = true;
                dist[i] = dist[cur] + 1;
                prev[i] = cur;
                if (i == end) {  // 找到目标顶点，退出循环
                    goto end;
                }
            }
        }
    }

    end:
    // 输出起点到目标顶点的最短路径长度和路径
    printf("Distance from A to B: %d\n", dist[end]);
    printf("Shortest path: ");
    int path[6];
    int index = 0;
    for (int i = end; i != -1; i = prev[i]) {
        path[index++] = i;
    }
    for (int i = index - 1; i >= 0; i--) {
        printf("%c ", path[i] + 'A');
    }
}

int main() {
    bfs(0, 1);  // 从顶点A到顶点B的最短路径
    return 0;
}

这里是一个简单的有向图，可以根据需要修改邻接矩阵来测试不同的情况，代码中的起点为顶点A，目标顶点为顶点B。