队列相关算法（最短路径条数问题,拓扑排序）

queue

• 队列是一种特殊的线性表，只允许在表的前端front进行删除操作，在表的后端rear进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。
• 队列元素服从先进先出原则
  • FIFO——First In First Out

最短路径条数问题

• 给定如图所示的无向连通图，假定图中所有边的权值都为1，显然，从源点A到终点T的 最短路径有多条，求不同的最短路径的数目。
  

算法分析

• 权值相同的最短路径问题，则单源点Dijkstra算法退化成BFS广度优先搜索，假定起点为0，终点为N：
  • 结点步数step[0…N-1]初始化为0
  • 路径数目pathNum[0…N-1]初始化为0
  • pathNum[0] = 1
• 若从当前结点i扩展到邻接点j时：
  • 若step[j]为0，则
    • step[j]=step[i]+1，pathN[j] = pathN[i]
  • 若step[j]==step[i]+1，则
    • pathN[j] += pathN[i]
  • 可考虑一旦扩展到结点N，则提前终止算法。

代码实现

int _tmain(int argc, _TCHAR *argv[])
{
    int G[N][N];
    memset(G, 0, sizeof(int) * N * N);
    G[0][1] = G[0][4] = 1;
    G[1][5] = G[1][0] = G[1][2] = 1;
    G[3][2] = G[3][7] = 1;
    G[4][0] = G[4][5] = 1;
    G[5][1] = G[5][4] = G[5][6] = G[5][9];
    G[6][2] = G[6][5] = G[6][7] = G[6][10] = 1;
    G[7][3] = G[7][6] = 1;
    G[8][9] = G[8][12] = 1;
    G[9][8] = G[9][10] = G[9][13] = 1;
    G[10][6] = G[10][9] = G[10][11] = G[10][14] = 1;
    G[11][10] = G[11][15] = 1;
    G[12][8] = G[12][13] = 1;
    G[13][9] = G[13][12] = G[13][14] = 1;
    G[14][10] = G[14][13] = G[14][15] = 1;
    G[15][11] = G[15][14] = 1;

    cout << Calc(G) << endl;
    return 0;
}

const int N = 16;
int Calc(int G[N][N])
{
    int step[N];       //每个节点第几步可以到达
    int stepNumber[N]; //每个节点有几种走法
    memset(step, 0, sizeof(int) * N);
    memset(stepNumber, 0, sizeof(int) * N);
    stepNumber[0] = 1; //无向图可以第一步到第一步，即A到A
    queue<int> q;      //当前搜索的节点
    q.push(0);
    int from, i, s;
    while (!q.empty())
    {
        form = q.front();
        q.pop();
        s = step[from] + 1;
        for (i = 1; i < N; i++)
        {
            if (G[from][i] == 1)
            { //连通
                //i尚未可达或发现更快的路（权值不同才可能）
                if ((step[i] == 0) || (step[i] > s))
                {
                    step[i] = s;
                    stepNumber[i] = stepNumber[from];
                    q.push(i);
                }
                else if (step[i] == s)
                { //发现相同的路径
                    stepNumber[i] += stepNumber[from];
                }
            }
        }
    }
}

拓扑排序

• 对一个有向无环图(Directed Acyclic Graph， DAG)G进行拓扑排序，是将G中所有顶点排 成线性序列，使得图中任意一对顶点u和v， 若边(u,v)∈E(G)，则u在线性序列中出现在v 之前。
• 一种可能的拓扑排序结果 2->8->0->3->7->1->5->6 ->9->4->11->10->12
  

拓扑排序的方法

• 从有向图中选择一个没有前驱(即入度为0)的 顶点并且输出它；
• 从网中删去该顶点，并且删去从该顶点发出 的全部有向边；
• 重复上述两步，直到剩余的网中不再存在没 有前趋的顶点为止。
  

代码实现

//结点数为n，用邻接矩阵gragh[n][n]存储边权
//用indegree[n]存储每一个结点的入度
void toplogic(int *topsort)
{
    int cnt = 0;  //当前拓扑排序列表有多少结点
    queue<int> q; //保存入度为0的结点，还可以用栈甚至随机取
    int i = 0;
    for (i = 0; i < n; i++)
    {
        if (indegree[i] == 0)
            q.push(i);
    }
    int cur; //当前入度为0的结点
    while (!e.empty)
    {
        cur = q.front();
        q.pop();
        toposort[cnt++] = cur;
        for (i = 0; i < n; i++)
        {
            if (gragh[cur][i] != 0)
            {
                indegree[i]--;
                q.push(i);
            }
        }
    }
}

---

更多内容请关注微信公众号：