2020年暑假ACM集训图论练习3【题解】

对应题单练习链接

A :hdu1548 【A strange lift】 (Bfs && Dijkstra)

题目大意 ：这是一个发生在电梯里面的故事，给出起点和终点，求最少需要操作几次能够到达目的地，给出每层楼对应的数字，该数字代表当前层可以上下这个数字的层数。注意，该电梯不能超过终点，也没有地下室，也就是说最小值为1.求最小操作次数。

BFS
刚刚看到这个题目的时候，本能反应这是一个bfs的题目，但是题目又放在求最短路的题单里面，潜意识告诉我，最短路的算法是dijkstra，弗洛伊德，spfa算法，导致一直在想最短路如何求解…忘记了bfs也可以求最短路

#include 
using namespace std;
const int maxn = 1e5 + 10;
int vis[maxn], f[maxn];
struct node
{
     
    int x, step;
};
int n, a, b;
int bfs()
{
     
    node s, e;
    memset(vis, 0, sizeof(vis));
    queue<node> q;
    s.x = a; //初始化起点的位置，根据输入数据来判定
    s.step = 0;
    q.push(s);
    while (!q.empty())
    {
     
        s = q.front();
        q.pop();
        if (s.x == b) //如果找到了就返回
            return s.step;
        e.x = s.x + f[s.x];        //往上走
        if (e.x <= b && !vis[e.x]) //如果当前点小于终点，并且没有走过1那么就符合
        {
     
            e.step = s.step + 1; //操作数加1
            vis[e.x] = 1;        //标记该点已经走过
            q.push(e);           //入队列
        }
        e.x = s.x - f[s.x]; //往下走（同上）
        if (e.x >= 1 && !vis[e.x])
        {
     
            vis[e.x] = 1;
            e.step = s.step + 1;
            q.push(e);
        }
    }
    return -1; //没找到
}
int main()
{
     
    while (~scanf("%d", &n) && n)
    {
     
        scanf("%d%d", &a, &b);
        for (int i = 1; i <= n; ++i)
            scanf("%d", &f[i]);
        printf("%d\n", bfs());
    }
}

Dijkstra
最短路的算法设计的比较巧妙，但是不可否认这依然是一个朴素版的dijkstra板子题目，我们需要判断当前层加上可以移动（上下）的层数是否会越界，如果没有越界说明就是一个可行解，这个题目的最短路就是最小操作次数，我们把每一次的可行解都标记为1，代表依次可以操作的次数，这也就是为什么可以用bfs的原因，我们的目的就是找出最小操作数，也就是求出起点到终点的最小操作步骤，每条边的权值都是1！

#include 
using namespace std;
const int maxn = 1e3 + 10;
const int inf = 0x3f3f3f3f;
int dis[maxn], vis[maxn], n;
int w[maxn][maxn], a[maxn];

int dijkstra(int s, int e)
{
     
    int pos;
    memset(vis, 0, sizeof(vis));
    for (int i = 1; i <= n; ++i)
        dis[i] = w[s][i];//赋值，把起点到其他点的距离赋给dis数组
    dis[s] = 0;
    vis[s] = 1;
    for (int i = 1; i <= n; ++i)
    {
     
        int min = inf;
        for (int j = 1; j <= n; ++j)//每次遍历都找一条最短的边并且记录下来方便后序的松弛操作
        {
     
            if (dis[j] < min && !vis[j])//判断求最小值
            {
     
                pos = j;
                min = dis[j];//维护最小值
            }
        }
        if (min == inf)
            break;
        vis[pos] = 1;
        for (int i = 1; i <= n; ++i)//松弛操作
            if (dis[i] > dis[pos] + w[pos][i] && !vis[i])
                dis[i] = dis[pos] + w[pos][i];
    }
}
int main()
{
     
    int s, e;
    while (~scanf("%d", &n) && n)
    {
     
        memset(w, inf, sizeof(w));
        scanf("%d%d", &s, &e);
        for (int i = 1; i <= n; ++i)
        {
     
            scanf("%d", &a[i]);
            if (i + a[i] <= n)//判断边界
                w[i][i + a[i]] = 1;
            if (i - a[i] >= 1)//同上
                w[i][i - a[i]] = 1;
        }
        dijkstra(s, e);
        printf("%d\n", dis[e] == inf ? -1 : dis[e]);
    }
    return 0;
}

B hdu2544 【最短路】dijkstra模板题

ps：这就是一个裸的dijkstra模板题

#include 
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5 + 10;
int a[maxn], vis[maxn], c[1010][1010], dis[maxn], n, m;
void dijkstra()
{
     
    memset(vis, 0, sizeof(vis));
    memset(dis, inf, sizeof(dis));
    for (int i = 1; i <= n; ++i)
        dis[i] = c[1][i];
    dis[1] = 0;
    vis[1] = 1;
    for (int i = 1; i <= n; ++i)
    {
     
        int min = inf;
        int pos;
        for (int j = 1; j <= n; ++j) //查找最小边
        {
     
            if (dis[j] < min && !vis[j])
            {
     
                min = dis[j]; //维护最小值
                pos = j;
            }
        }
        vis[pos] = 1;                //标记最小值
        for (int i = 1; i <= n; ++i) //松弛操作
            if (dis[i] > dis[pos] + c[pos][i] && !vis[i])
                dis[i] = dis[pos] + c[pos][i];
    }
}
int main()
{
     
    while (~scanf("%d%d", &n, &m) && n && m)
    {
     
        memset(c, inf, sizeof(c));
        for (int i = 1; i <= m; ++i)
        {
     
            int u, v, e;
            scanf("%d%d%d", &u, &v, &e);
            c[u][v] = c[v][u] = e; //无向图存储两次
        }
        dijkstra();
        printf("%d\n", dis[n]);
    }
    return 0;
}

C hdu2066 【一个人的旅行】 dijkstra模板题

题目分析
首先这个题目并没有给出城市对应的编号，所以我们可以在输入城市的时候去最大城市的编号让他去做n，其次我们在更新路径权值的时候需要进行一次min取最小值地操作（话说这个我没懂）不然代码就不对，刚刚开始的时候我想着是离小草家的每个取一个最小值然后遍历一次把最小值输出，但是时间上是超限的，所以我们可以把小草自己家看成源点，源点到每个临近的点的距离为0，这样我们只需要跑一次dijkstra就可以求出最小值

朴素版dijkstra

#include 
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 1e3 + 10;
int a[maxn], vis[maxn], c[1010][1010], dis[maxn], n, m, d, b[maxn], tot;
void dijkstra()
{
     
    memset(vis, 0, sizeof(vis));
    memset(dis, inf, sizeof(dis));
    for (int i = 0; i <= tot; ++i)
        dis[i] = c[0][i];
    dis[0] = 0;
    vis[0] = 1;
    for (int i = 1; i <= tot; ++i)
    {
     
        int min = inf;
        int pos;
        for (int j = 1; j <= tot; ++j)
        {
     
            if (dis[j] < min && !vis[j])
            {
     
                min = dis[j];
                pos = j;
            }
        }
        vis[pos] = 1;
        for (int i = 1; i <= tot; ++i)
            if (dis[i] > dis[pos] + c[pos][i] && !vis[i])
                dis[i] = dis[pos] + c[pos][i];
    }
}
int main()
{
     
    while (~scanf("%d%d%d", &n, &m, &d))
    {
     
        tot = 0;
        memset(c, inf, sizeof(c));
        for (int i = 1; i <= n; ++i)
        {
     
            int u, v, e;
            scanf("%d%d%d", &u, &v, &e);
            tot = max(tot, max(u, v));
            c[u][v] = c[v][u] = min(c[u][v],e); //无向图存储两次
        }
        for (int i = 1; i <= m; ++i)
        {
     
            scanf("%d", &a[i]);
            c[0][a[i]] = c[a[i]][0] = 0;//小草家到每个点的距离为0
        }
        for (int j = 1; j <= d; ++j)
            scanf("%d", &b[j]);
        int ans = inf;
        dijkstra();
        for (int j = 1; j <= d; ++j)
            ans = min(ans, dis[b[j]]);
        printf("%d\n", ans);
    }
    return 0;
}

dijkstra+堆优化

#include 
using namespace std;

#define ll long long
const int inf = 0x3f3f3f3f;
int m, a[1005], si, ei, b[1005], n;
int vis[1005], mp[1005][1005], dis[1005];

struct node
{
     
    int id;
    int val;
    bool operator<(const node x) const
    {
     
        return val > x.val;
    }
};

void dijkstra()
{
     
    memset(vis, 0, sizeof(vis));
    memset(dis, inf, sizeof(dis));
    dis[0] = 0;
    priority_queue<node> q;
    node s, e;
    s.id = 0;
    s.val = 0;
    q.push(s);
    while (!q.empty())
    {
     
        s = q.top();
        q.pop();
        int id = s.id, val = s.val;
        vis[id] = 1;
        for (int i = 1; i <= n; i++)
        {
     
            if (!vis[i] && dis[i] > mp[id][i] + val)
            {
     
                dis[i] = mp[id][i] + val;
                e.id = i;
                e.val = val + mp[id][i];
                q.push(e);
            }
        }
    }
}

int main()
{
     
    while (~scanf("%d %d %d", &m, &si, &ei))
    {
     
        n = 0;
        memset(mp, inf, sizeof(mp));
        for (int i = 1; i <= m; i++)
        {
     
            int a, b, c;
            scanf("%d %d %d", &a, &b, &c);
            n = max(max(a, b), n);
            if (mp[a][b] > c)
                mp[a][b] = mp[b][a] = c;
        }
        for (int i = 1; i <= si; i++)
        {
     
            scanf("%d", &a[i]);
            mp[0][a[i]] = mp[a[i]][0] = 0;
        }
        for (int i = 1; i <= ei; i++)
            scanf("%d", &b[i]);
        dijkstra();
        int mi = inf;
        for (int i = 1; i <= ei; i++)
            mi = min(dis[b[i]], mi);
        printf("%d\n", mi);
    }
    return 0;
}

D hdu1217 【Arbitrage】 （Floyd && spfa）

题目大意：给出几种货币以及每种货币之间的汇率让你判断经过货币之间的转换是否是赚了
PS：第一次做floyd，感觉floyd比其他算法好理解，代码也很短，floyd求的是多源最短路径，经过每一次的更新，我们都可以求出任意两种货币之间的转换，首先初始化一下，同种货币之间的“距离”是1，再经过转换更新路径，只不过这里的是乘法，经过最终的遍历，我们发现如果其中两种货币之间存在大于1的那么就说明通过汇率之间的转换是可以赚钱的。
快速理解Floyd算法

#include 
using namespace std;

const int maxn = 1e3 + 10;
double dis[maxn][maxn];
char s[maxn][maxn];
int n, m;

void floyd()
{
     
    for (int k = 1; k <= n; ++k)
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= n; ++j)
                dis[i][j] = max(dis[i][j], dis[i][k] * dis[k][j]);
}
int main()
{
     
    int cnt = 1;
    while (~scanf("%d", &n) && n)
    {
     
        for (int i = 1; i <= n; ++i)
            for (int j = 1; j <= n; ++j)
                dis[i][j] = i == j ? 1 : 0;
        for (int i = 1; i <= n; ++i)
            scanf("%s", s[i]);
        scanf("%d", &m);
        for (int i = 1; i <= m; ++i)
        {
     
            char s0[maxn], s1[maxn];
            double x;
            int k1, k2;
            scanf("%s%lf%s", s0, &x, s1);
            for (int j = 1; j <= n; ++j)
            {
     
                if (strcmp(s0, s[j]) == 0)
                    k1 = j;
                if (strcmp(s1, s[j]) == 0)
                    k2 = j;
            }
            dis[k1][k2] = x;
        }
        floyd();
        int flag = 0;
        for (int i = 1; i <= n; ++i)
        {
     
            if (dis[i][i] > 1.0)
            {
     
                printf("Case %d: Yes\n", cnt++);
                flag = 1;
                break;
            }
        }
        if (!flag)
            printf("Case %d: No\n", cnt++);
    }
    return 0;
}

spfa算法
PS：spfa之所以能判断负环，是因为，在求最短路的时候可以一直走含有负环的圈，这样就能一直刷新最短路，无限的刷新下去，这个题目可以用spfa也是这个道理，因为大于1的数的乘积必比原来的数大，所有出现边权乘积大于1时，就相当于边权和为负的负环，其实是一个道理，只要判断大于1那就是yes否则就是no

#include 
using namespace std;
const int maxn = 1e3 + 10;
int n, m, tot, u, v;
double w;
struct node
{
     
	int v, next;
	double w;
} edge[maxn];
double dis[maxn];
int vis[maxn], head[maxn], cnt[maxn];
char str[maxn][maxn], buff[maxn], buff1[maxn];

int solve(char *s)
{
     
	for (int i = 1; i <= n; i++)
		if (strcmp(s, str[i]) == 0)
			return i;
	return -1;
}

void add(int u, int v, double w)
{
     
	edge[++tot].v = v;
	edge[tot].w = w;
	edge[tot].next = head[u];
	head[u] = tot;
}
int Spfa(int s)
{
     
	memset(dis, 0, sizeof dis);
	memset(vis, 0, sizeof vis);
	memset(cnt, 0, sizeof cnt);
	dis[s] = 1.0;
	vis[s] = 1;
	queue<int> q;
	q.push(s);
	while (!q.empty())
	{
     
		int e = q.front();
		q.pop();
		vis[e] = 0;
		for (int i = head[e]; ~i; i = edge[i].next)
		{
     
			int v = edge[i].v;
			if (dis[e] * edge[i].w > dis[v])
			{
     
				dis[v] = dis[e] * edge[i].w;
				if (!vis[v])
				{
     
					q.push(v);
					vis[v] = 1;
					if (++cnt[v] > n)
						break;
				}
			}
		}
	}
	if (dis[s] > 1.0)
		return 1;
	return 0;
}

int main()
{
     
	int cas = 1;
	while (scanf("%d", &n) && n)
	{
     
		tot = 0;
		memset(head, -1, sizeof head);
		for (int i = 1; i <= n; i++)
			scanf("%s", str[i]);
		scanf("%d", &m);
		for (int i = 1; i <= m; i++)
		{
     
			scanf("%s%lf%s", buff1, &w, buff);
			u = solve(buff1);
			v = solve(buff);
			add(u, v, w);
		}
		int find = 0;
		for (int i = 1; i <= n; i++)
			if (Spfa(i))
			{
     
				printf("Case %d: Yes\n", cas++);
				find = 1;
				break;
			}
		if (!find)
			printf("Case %d: No\n", cas++);
	}
	return 0;
}

E hdu 1317 【XYZZY】（floyd && spfa）

题目大意：有n个房间(n<=100)，每个房间有一个点权（第1号房间和第n号房间权值均为0），到达该房间时会自动获得该点权（可能为负权）。给出一些无向边。有一个人，初始有能量值100，初始位置是第1号房间，要走到第n号房间，且路途中不得使身上能量值小于或等于0。能到达第n个房间就算赢，问能否赢。

题目分析：首先我们用floyd去判断他的连通性，然后取跑一遍spfa，注意初始是100
这个题目我理解的不透彻，在这里给出一篇写的很详细的博客仅供参考详细解析博客

#include 
using namespace std;
const int maxn = 1e3 + 10;
const int inf = -0x3f3f3f3f;

int n, m;
int dis[maxn][maxn], d[maxn], mp[maxn][maxn], num[maxn], e[maxn];

void floyd()
{
     
	for (int k = 1; k <= n; ++k)
		for (int i = 1; i <= n; ++i)
			for (int j = 1; j <= n; ++j)
				dis[i][j] = dis[i][j] || (dis[i][k] && dis[k][j]);
}

int spfa(int s, int d[])
{
     
	queue<int> q;
	q.push(s);
	d[s] = 100;
	while (!q.empty())
	{
     
		int u = q.front();
		q.pop();
		num[u]++;
		if (num[u] > n)
			//如果一个点进队次数大于等于n就说明它在环中（事实上由于最长路中负环不会循环所以这里一定是正环），那么这里只要能从该点到达终点（Floyd判断），那么就一定能赢；反之如果不能到达终点就一定会输（因为松弛次数大于或等于n还没有结束则说明最长路不存在）。
			return dis[u][n];
		for (int i = 1; i <= n; ++i)
			if (mp[u][i] && d[u] + e[i] > d[i] && d[u] + e[i] > 0) //如果这个条路存在并且走过这条路要大于0
			{
     
				d[i] = d[u] + e[i];
				q.push(i);
			}
	}
	return d[n] > 0; //返回的值一定要大于0
}
int main()
{
     
	while (~scanf("%d", &n))
	{
     
		if (n == -1)
			return 0;
		memset(mp, 0, sizeof(mp));
		memset(d, inf, sizeof(d));
		memset(num, 0, sizeof(num));
		memset(dis, 0, sizeof(dis));
		for (int i = 1; i <= n; ++i)
		{
     
			scanf("%d%d", &e[i], &m);
			for (int j = 1; j <= m; ++j)
			{
     
				int v;
				scanf("%d", &v);
				mp[i][v] = 1;  //数组存储边的信息
				dis[i][v] = 1; //数组表示这两点连通
			}
		}
		floyd();
		if (dis[1][n] == 0) //如果起点到终点没有连通那么直接输出
			puts("hopeless");
		else
		{
     
			if (spfa(1, d)) //如果连通并且值要大于0就可以
				puts("winnable");
			else //小于零那么就不行
				puts("hopeless");
		}
	}
	return 0;
}

F hdu 1535 【Invitation Cards】 （spfa+优化）

题目大意：有编号1～P的站点， 有Q条公交车路线，公交车路线只从一个起点站直接到达终点站，是单向的，每条路线有它自己的车费。
有P个人早上从1出发，他们要到达每一个公交站点， 然后到了晚上再返回点1。 求所有人来回的最小费用之和。

题目分析：求最短路，首先正反向求一次最短路，求的的是1号点到所有点的最短路之和,之后再反向存储一遍边，再求一次最短路，因为数据比较大所以需要优化，还有及得用long long去定义变量

#include 
using namespace std;
const int maxn = 1e6 + 10;
typedef long long ll;
const int inf = 0x3f3f3f3f;
int vis[maxn], head[maxn];
ll dis[maxn];
ll cnt;
int n, m;
struct node
{
     
	int u, v, w, next;
} edge[maxn];

void add(int u, int v, int w)
{
     
	edge[++cnt].u = u;
	edge[cnt].v = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	head[u] = cnt;
}

int spfa(int s)
{
     
	queue<int> q;
	q.push(s);
	vis[s] = 1;
	dis[s] = 0;
	while (!q.empty())
	{
     
		int now = q.front();
		q.pop();
		vis[now] = 0;
		for (int i = head[now]; ~i; i = edge[i].next)
		{
     
			int to = edge[i].v;
			if (dis[to] > dis[now] + edge[i].w)
			{
     
				dis[to] = dis[now] + edge[i].w;
				if (!vis[to])
				{
     
					vis[to] = 1;
					q.push(to);
				}
			}
		}
	}
	ll sum = 0;
	for (int i = 1; i <= n; ++i)
		if (dis[i] != inf)
			sum += dis[i];
	return sum;
}
int main()
{
     
	int t, a, b, c;
	scanf("%d", &t);
	while (t--)
	{
     
		cnt = 0;
		memset(dis, inf, sizeof(dis));
		memset(vis, 0, sizeof(vis));
		memset(head, -1, sizeof(head));
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= m; ++i)
		{
     
			scanf("%d%d%d", &a, &b, &c);
			add(a, b, c);
		}
		ll ans = spfa(1);
		cnt = 0;
		memset(dis, inf, sizeof(dis));
		memset(vis, 0, sizeof(vis));
		memset(head, -1, sizeof(head));
		for (int i = 1; i <= m; ++i)
		{
     
			a = edge[i].u;
			b = edge[i].v;
			c = edge[i].w;
			add(b, a, c);
		}
		ll ans2 = ans + spfa(1);
		printf("%lld\n", ans2);
	}
	return 0;
}

G

H

I

J

K

L

M

N

O

P

Q

R

S

T

于是，我明白了，爱情总有一天会消失，这是必然的。当这种感觉消失后，剩下的就只是互相理解、互相信任、互相依赖的关系，如果没有，那么早晚会酿成悲剧。女生不能总是依靠在男生肩膀上，男生也不能总是缠着女生，只有两个人互相搀扶着，才能不会摔倒。