搜索与图论

本文已参与[新人创作礼]活动，一起开启掘金创作者之路。

堆优化版dijkstra 时间复杂度 O(mlogn)O(mlogn), nn 表示点数，mm 表示边数 typedef pair<int, int> PII;

int n; // 点的数量 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储所有点到1号点的距离 bool st[N]; // 存储每个点的最短距离是否已确定

// 求1号点到n号点的最短距离，如果不存在，则返回-1 int dijkstra() { memset(dist, 0x3f, sizeof dist); dist[1] = 0; priority_queue<PII, vector, greater> heap; heap.push({0, 1}); // first存储距离，second存储节点编号

while (heap.size())
{
    auto t = heap.top();
    heap.pop();

    int ver = t.second, distance = t.first;

    if (st[ver]) continue;
    st[ver] = true;

    for (int i = h[ver]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (dist[j] > distance + w[i])
        {
            dist[j] = distance + w[i];
            heap.push({dist[j], j});
        }
    }
}

if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];

} Bellman-Ford算法 时间复杂度 O(nm)O(nm), nn 表示点数，mm 表示边数 注意在模板题中需要对下面的模板稍作修改，加上备份数组，详情见模板题。

int n, m; // n表示点数，m表示边数 int dist[N]; // dist[x]存储1到x的最短路距离

struct Edge // 边，a表示出点，b表示入点，w表示边的权重 { int a, b, w; }edges[M];

// 求1到n的最短路距离，如果无法从1走到n，则返回-1。 int bellman_ford() { memset(dist, 0x3f, sizeof dist); dist[1] = 0;

// 如果第n次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
    for (int j = 0; j < m; j ++ )
    {
        int a = edges[j].a, b = edges[j].b, w = edges[j].w;
        if (dist[b] > dist[a] + w)
            dist[b] = dist[a] + w;
    }
}

if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];

} spfa 算法（队列优化的Bellman-Ford算法） 时间复杂度 平均情况下 O(m)O(m)，最坏情况下 O(nm)O(nm), nn 表示点数，mm 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N]; // 存储每个点到1号点的最短距离 bool st[N]; // 存储每个点是否在队列中

// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1 int spfa() { memset(dist, 0x3f, sizeof dist); dist[1] = 0;

queue<int> q;
q.push(1);
st[1] = true;

while (q.size())
{
    auto t = q.front();
    q.pop();

    st[t] = false;

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (dist[j] > dist[t] + w[i])
        {
            dist[j] = dist[t] + w[i];
            if (!st[j])     // 如果队列中已存在j，则不需要将j重复插入
            {
                q.push(j);
                st[j] = true;
            }
        }
    }
}

if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];

} spfa判断图中是否存在负环 时间复杂度是 O(nm)O(nm), nn 表示点数，mm 表示边数 int n; // 总点数 int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边 int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数 bool st[N]; // 存储每个点是否在队列中

// 如果存在负环，则返回true，否则返回false。 bool spfa() { // 不需要初始化dist数组 // 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。

queue<int> q;
for (int i = 1; i <= n; i ++ )
{
    q.push(i);
    st[i] = true;
}

while (q.size())
{
    auto t = q.front();
    q.pop();

    st[t] = false;

    for (int i = h[t]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (dist[j] > dist[t] + w[i])
        {
            dist[j] = dist[t] + w[i];
            cnt[j] = cnt[t] + 1;
            if (cnt[j] >= n) return true;       // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
            if (!st[j])
            {
                q.push(j);
                st[j] = true;
            }
        }
    }
}

return false;

}