分层图

合集 - 最短路径(7)

1.最短路径问题2024-02-05

2.分层图2024-02-05

3.次短路径问题2024-02-064.差分约束算法2024-02-085.传递闭包2024-02-086.SPFA算法2024-02-257.Johnson算法2024-05-15

收起

题目描述

P4568 [JLOI2011] 飞行路线

题目分析

显然，这是一道最短路径的题目，我们可以选择 \(Dijkstra\) 算法求解。但是，题目中有 他们可以免费在最多 k 种航线上搭乘飞机。也就是说，我们可以令最多 \(k\) 条边的权值为零。这时，我们就要采用分层图。

分层图

分层图并不是算法，而是一种建模思想。建模后，依然是用 \(Dijkstra\) 求解，与单纯的最短路径问题没有区别。接下来，通过一个例子来了解分层图。
假设有一张 \(4\) 个顶点、\(4\) 条边的无向图，\(k = 1\)。

\(k = 1\) 表明我们可以令某一条边的权值为0，换句话来说，就是为某条边添上一条权值为0的重边。因为每一条边都有可能被选到，所以图中的每一条边都应该有一条这样的重边。但是，如果我们将重边直接添在原图上，就只能表示一次选择（某条边的权值为0）。所以，我们要创建原图的副本，要做 \(k\) 次选择，就要创建 \(k\) 张副本，连同原图共 \(k + 1\) 层图。每层图之间依靠权值为0的重边连接。每次进入下一层图，就是做了一次选择。
为了与原图有区别，我们需要对副本的顶点按顺序重新编号。原图有 \(n\) 个顶点，建图后就变成了 \((k + 1)n\) 个。此时，边 \(e(u, v)\) （一层图共 \(n\) 个顶点，且是无向图）的到下一层图的重边就变成了 \(e(u, v + n)\) 和 \(e(v, u + n)\) 。我们要找到 \(s\) 到 \(t\) 的最短路径，就变成了 \(min(\{t + k \ast n | k \geq 0\})\)。

现在，我们来总结一下分层图。
假设有一张 \(n\) 个顶点、\(m\) 条边的无向图，最多可令 \(k\) 条边的权值为0，求 \(s\) 到 \(t\) 的最短路径。这时，我们就要建立分层图：

• 一共要建 \(k + 1\) 层图（连同原图）
• 按图的顺序，给每一个顶点编号
• 每层图之间依靠权值为0的重边连接（每条边都要有这样的重边）

有了分层图的模型，接下来，我们就来具体实现。

#include <bits/stdc++.h>

using namespace std;

// 原图有n个顶点，分层图共有(k+1)n个
#define MAX 8					// 以n=4, k=1为例，MAX至少为8（编号从0开始）

// 定义边
typedef pair<int, int> P;		// first -- 边的终点; second -- 边的权值

// 图
int n, m, k;					// n -- 顶点数; m -- 边数; k -- 免费数
vector<P> G[MAX];				// G[i] -- 以i为起点的所有边

int main()
{
	scanf("%d%d%d", &n, &m, &k);
	for (int i = 0; i < m; i++)
	{
		int a, b, c;
		scanf("%d%d%d", &a, &b, &c);

		// 原图添加无向边
		G[a].push_back(P(b, c));
		G[b].push_back(P(a, c));

		// k张副本
		for (int i = 1; i <= k; i++)
		{
			// 建立分层图
			G[a + i * n].push_back(P(b + i * n, c));
			G[b + i * n].push_back(P(a + i * n, c));

			// 连接分层图
			G[a + (i - 1) * n].push_back(P(b + i * n, 0));
			G[b + (i - 1) * n].push_back(P(a + i * n, 0));
		}
	}

	return 0;
}

---

本题代码

有了分层图，我们就能很轻松地解决本题了。

#include <cstdio>
#include <vector>
#include <queue>
#include <utility>

using namespace std;

#define MAX 200003
#define INF 1e8

typedef pair<int, int> P;

struct cmp
{
    bool operator()(const P &a, const P &b)
    {
        return a.second > b.second;
    }
};

struct cmp1
{
    bool operator()(const P &a, const P &b)
    {
        return a.second < b.second;
    }
};

int n, m, k, s, t;
vector<P> E[MAX];
int d[MAX];

int quickin(void)
{
    int ret = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9')
        ch = getchar();
    while (ch >= '0' && ch <= '9')
    {
        ret = 10 * ret + ch - '0';
        ch = getchar();
    }
    return ret;
}

void dijkstra(int dest)
{
    fill(begin(d), end(d), INF);
    priority_queue<P, vector<P>, cmp> Q;
    Q.push(P(dest, 0));
    d[dest] = 0;

    while (!Q.empty())
    {
        P u = Q.top();
        Q.pop();

        if (d[u.first] < u.second)
            continue;
        
        for (int i = 0; i < E[u.first].size(); i++)
        {
            P e = E[u.first][i];
            if (d[e.first] > d[u.first] + e.second)
            {
                d[e.first] = d[u.first] + e.second;
                Q.push(P(e.first, d[e.first]));
            }
        }
    }
}

int main()
{
    n = quickin(), m = quickin(), k = quickin();
    s = quickin(), t = quickin();
    for (int i = 0; i < m; i++)
    {
        int a, b, c;
        a = quickin(), b = quickin(), c = quickin();
        E[a].push_back(P(b, c));
        E[b].push_back(P(a, c));

        for (int i = 0; i < k; i++)
        {
            E[a + i * n].push_back(P(b + (i + 1) * n, 0));
            E[b + i * n].push_back(P(a + (i + 1) * n, 0));
            E[a + (i + 1) * n].push_back(P(b + (i + 1) * n, c));
            E[b + (i + 1) * n].push_back(P(a + (i + 1) * n, c));
        }
    }

    dijkstra(s);

    int val = INF;
    for (int i = 0; i <= k; i++)
        val = min(val, d[t + n * i]);
    printf("%d\n", val);

    return 0;
}

---

完