最短路径中的分层图

目录

  • 题目描述
  • 题目分析
  • 分层图
  • 本题代码

题目描述

P4568 [JLOI2011] 飞行路线

题目分析

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

分层图

分层图并不是算法,而是一种建模思想。建模后,依然是用 D i j k s t r a Dijkstra Dijkstra 求解,与单纯的最短路径问题没有区别。接下来,通过一个例子来了解分层图。
假设有一张 4 4 4 个顶点、 4 4 4 条边的无向图, k = 1 k = 1 k=1
最短路径中的分层图_第1张图片
k = 1 k = 1 k=1 表明我们可以令某一条边的权值为0,换句话来说,就是为某条边添上一条权值为0的重边。因为每一条边都有可能被选到,所以图中的每一条边都应该有一条这样的重边。但是,如果我们将重边直接添在原图上,就只能表示一次选择(某条边的权值为0)。所以,我们要创建原图的副本,要做 k k k 次选择,就要创建 k k k 张副本,连同原图共 k + 1 k + 1 k+1 层图。每层图之间依靠权值为0的重边连接。每次进入下一层图,就是做了一次选择。
为了与原图有区别,我们需要对副本的顶点按顺序重新编号。原图有 n n n 个顶点,建图后就变成了 ( k + 1 ) n (k + 1)n (k+1)n 个。此时,边 e ( u , v ) e(u, v) e(u,v) (一层图共 n n n 个顶点,且是无向图)的到下一层图的重边就变成了 e ( u , v + n ) e(u, v + n) e(u,v+n) e ( v , u + n ) e(v, u + n) e(v,u+n) 。我们要找到 s s s t t t 的最短路径,就变成了 m i n ( { t + k ∗ n ∣ k ≥ 0 } ) min(\{t + k \ast n | k \geq 0\}) min({t+knk0})
最短路径中的分层图_第2张图片

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

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

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

#include 

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 
#include 
#include 
#include 

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;
}

你可能感兴趣的:(algorithms,luogu,算法)