A - TT 的魔法猫
众所周知，TT 有一只魔法猫。
这一天，TT 正在专心致志地玩《猫和老鼠》游戏，然而比赛还没开始，聪明的魔法猫便告诉了 TT 比赛的最终结果。TT 非常诧异，不仅诧异于他的小猫咪居然会说话，更诧异于这可爱的小不点为何有如此魔力？
魔法猫告诉 TT，它其实拥有一张游戏胜负表，上面有 N 个人以及 M 个胜负关系，每个胜负关系为 A B，表示 A 能胜过 B，且胜负关系具有传递性。即 A 胜过 B，B 胜过 C，则 A 也能胜过 C。
TT 不相信他的小猫咪什么比赛都能预测，因此他想知道有多少对选手的胜负无法预先得知，你能帮帮他吗？
Input
第一行给出数据组数。
每组数据第一行给出 N 和 M（N , M <= 500）。
接下来 M 行，每行给出 A B，表示 A 可以胜过 B。
Output
对于每一组数据，判断有多少场比赛的胜负不能预先得知。注意 (a, b) 与 (b, a) 等价，即每一个二元组只被计算一次。
Sample Input
3
3 3
1 2
1 3
2 3
3 2
1 2
2 3
4 2
1 2
3 4
Sample Output
0
0
4
解题思路
-
Floyd-Warshall
用于求取图中任意两点之间的关系
多源最短路，任意两点之间的距离关系
图上的传递闭包，任意两点的连通关系 -
本题复杂度O(n3)
-
因为胜负关系具有传递性，因此可以用Floyd算法求出任意两点之间的胜负关系（传递闭包），即可求出答案
dis[a][b]=1表示a比b强
dis[a][b]=0表示a与b的胜负关系不明
dis[a][b]=0且dis[a][b]=0即表示a与b的胜负关系无法预先判断 -
剪枝 当dis[i][k]=0时，就不需要j循环了
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
int dis[501][501];
int main()
{
int num;
cin >> num;
while (num--)
{
int n, m;
cin >> n >> m;
memset(dis, 0, sizeof(dis));
for (int i = 0; i < m; i++)
{
int a, b;
cin >> a >> b;
dis[a][b] = 1;
}
for (int k = 1; k <= n; k++)
{
for (int i = 1; i <= n; i++)
{
if (dis[i][k] != 0)
{
for (int j = 1; j <= n; j++)
dis[i][j] = max(dis[i][j], dis[i][k] & dis[k][j]);
}
}
}
int ans = 0;
for (int i = 1; i <= n; i++)
{
for (int j = i + 1; j <= n; j++)
{
if (dis[i][j] == 0 && dis[j][i] == 0)
{
ans++;
}
}
}
cout << ans << endl;
}
}B - TT 的旅行日记
众所周知，TT 有一只魔法猫。
今天他在 B 站上开启了一次旅行直播，记录他与魔法猫在喵星旅游时的奇遇。 TT 从家里出发，准备乘坐猫猫快线前往喵星机场。猫猫快线分为经济线和商业线两种，它们的速度与价钱都不同。当然啦，商业线要比经济线贵，TT 平常只能坐经济线，但是今天 TT 的魔法猫变出了一张商业线车票，可以坐一站商业线。假设 TT 换乘的时间忽略不计，请你帮 TT 找到一条去喵星机场最快的线路，不然就要误机了！输入输入包含多组数据。每组数据第一行为 3 个整数 N, S 和 E (2 ≤ N ≤ 500, 1 ≤ S, E ≤ 100)，即猫猫快线中的车站总数，起点和终点（即喵星机场所在站）编号。
下一行包含一个整数 M (1 ≤ M ≤ 1000)，即经济线的路段条数。
接下来有 M 行，每行 3 个整数 X, Y, Z (1 ≤ X, Y ≤ N, 1 ≤ Z ≤ 100)，表示 TT 可以乘坐经济线在车站 X 和车站 Y 之间往返，其中单程需要 Z 分钟。
下一行为商业线的路段条数 K (1 ≤ K ≤ 1000)。
接下来 K 行是商业线路段的描述，格式同经济线。
所有路段都是双向的，但有可能必须使用商业车票才能到达机场。保证最优解唯一。输出对于每组数据，输出3行。第一行按访问顺序给出 TT 经过的各个车站（包括起点和终点），第二行是 TT 换乘商业线的车站编号（如果没有使用商业线车票，输出"Ticket Not Used"，不含引号），第三行是 TT 前往喵星机场花费的总时间。
本题不忽略多余的空格和制表符，且每一组答案间要输出一个换行输入样例4 1 4
4
1 2 2
1 3 3
2 4 4
3 4 5
1
2 4 3
输出样例
1 2 4
2
5
解题思路
如果走商业线的话，只能走一条。如果商业线为（a,b),则我们可能的线路为
起点->a->b->终点 或 起点->终点 或 起点->b->a->终点。所以我们的方法为：
从起点求dijkstra最短路，记录dis1数组。
从终点求dijkstra最短路，记录dis2数组。
使用min求取最短路。
#include <iostream>
#include <cstring>
#include <climits>
#include <queue>
using namespace std;
const int N = 100000 + 1;
int vis[N], dis1[N], dis2[N], head[N], path1[N], path2[N], pathlong = INT_MAX;
int pos1, pos2;
bool flage = false;
vector<int> v;
priority_queue<pair<int, int>> q;
int n, s, e, tot = 0;
struct Edge
{
int v, w, nxt;
} Edges[2 * N];
void add(int x, int y, int z)
{
Edges[++tot].v = y, Edges[tot].w = z;
Edges[tot].nxt = head[x];
head[x] = tot;
}
void dijkstra(int s, int *dis, int *path)
{
while (q.size())
q.pop();
dis[s] = 0;
q.push(make_pair(0, s));
while (q.size())
{
int x = q.top().second;
q.pop();
if (vis[x])
continue;
vis[x] = 1;
for (int i = head[x]; i; i = Edges[i].nxt)
{
int y = Edges[i].v, w = Edges[i].w;
if (dis[y] > dis[x] + w)
{
dis[y] = dis[x] + w;
q.push(make_pair(-dis[y], y));
path[y] = x;
}
}
}
}
int main()
{
while (scanf("%d%d%d", &n, &s, &e) == 3)
{
if (!flage)
flage = true;
else
cout << endl;
memset(head, 0, sizeof(head));
memset(vis, 0, sizeof(vis));
memset(path1, 0, sizeof(path1));
memset(path2, 0, sizeof(path2));
memset(dis1, 999999, sizeof(dis1));
memset(dis2, 999999, sizeof(dis2));
int m;
cin >> m;
for (int i = 0; i < m; i++)
{
int x, y, z;
cin >> x >> y >> z;
add(x, y, z);
add(y, x, z);
}
dijkstra(s, dis1, path1);
memset(vis, 0, sizeof(vis));
dijkstra(e, dis2, path2);
int k, ans = INT_MAX;
cin >> k;
for (int i = 0; i < k; i++)
{
int x, y, z;
cin >> x >> y >> z;
if (dis1[x] + dis2[y] + z < pathlong)
{
pos1 = x;
pos2 = y;
pathlong = dis1[x] + dis2[y] + z;
ans = x;
}
if (dis2[x] + dis1[y] + z < pathlong)
{
pos1 = y;
pos2 = x;
pathlong = dis2[x] + dis1[y] + z;
ans = y;
}
}
if (dis1[e] < pathlong)
{
for (int i = e; i != s; i = path1[i])
v.push_back(i);
v.push_back(s);
for (int i = v.size() - 1; i >= 1; i--)
cout << v[i] << " ";
cout << v[0] << endl
<< "Ticket Not Used" << endl
<< dis1[e] << endl;
}
else
{
for (int i = pos1; i != s; i = path1[i])
v.push_back(i);
v.push_back(s);
for (int i = pos2; i != e; i = path2[i])
v.insert(v.begin(), i);
v.insert(v.begin(), e);
for (int i = v.size() - 1; i >= 1; i--)
cout << v[i] << " ";
cout << v[0] << endl
<< ans << endl
<< pathlong << endl;
}
v.clear();
ans = 0;
tot = 0;
pathlong = INT_MAX;
}
}
C - TT 的美梦
这一晚，TT 做了个美梦！
在梦中，TT 的愿望成真了，他成为了喵星的统领！喵星上有 N 个商业城市，编号 1 ～ N，其中 1 号城市是 TT 所在的城市，即首都。
喵星上共有 M 条有向道路供商业城市相互往来。但是随着喵星商业的日渐繁荣，有些道路变得非常拥挤。正在 TT 为之苦恼之时，他的魔法小猫咪提出了一个解决方案！TT 欣然接受并针对该方案颁布了一项新的政策。
具体政策如下：对每一个商业城市标记一个正整数，表示其繁荣程度，当每一只喵沿道路从一个商业城市走到另一个商业城市时，TT 都会收取它们（目的地繁荣程度 - 出发地繁荣程度）^ 3 的税。
TT 打算测试一下这项政策是否合理，因此他想知道从首都出发，走到其他城市至少要交多少的税，如果总金额小于 3 或者无法到达请悄咪咪地打出 ‘?’。 Input第一行输入 T，表明共有 T 组数据。（1 <= T <= 50）
对于每一组数据，第一行输入 N，表示点的个数。（1 <= N <= 200）
第二行输入 N 个整数，表示 1 ～ N 点的权值 a[i]。（0 <= a[i] <= 20）
第三行输入 M，表示有向道路的条数。（0 <= M <= 100000）
接下来 M 行，每行有两个整数 A B，表示存在一条 A 到 B 的有向道路。
接下来给出一个整数 Q，表示询问个数。（0 <= Q <= 100000）
每一次询问给出一个 P，表示求 1 号点到 P 号点的最少税费。Output每个询问输出一行，如果不可达或税费小于 3 则输出 ‘?’。Sample Input2
5
6 7 8 9 10
6
1 2
2 3
3 4
1 5
5 4
4 5
2
4
5
10
1 2 4 4 5 6 7 8 9 10
10
1 2
2 3
3 1
1 4
4 5
5 6
6 7
7 8
8 9
9 10
2
3 10Sample OutputCase 1:
3
4
Case 2:
?
?
解题思路
含有负权边的有向图单源最短路问题。
当出现负环时，交税为负数，需要着重考虑。
使用spfa顺利解决，具体步骤为：
从一个城市开始搜索
到达某一个城市经过的边数超过n-1，则出现负环
从该城市搜索，到达的路径都标记上，不符合题意。
#include <iostream>
#include <cstring>
#include <climits>
#include <math.h>
#include <queue>
using namespace std;
const int N = 100000 + 5;
const int M = 200 + 5;
int vis[M], dis[M], cnt[M], head[N], a[N];
bool flag[N];
int n, tot = 0;
struct Edge
{
int v, w, nxt;
} Edges[N];
void add(int x, int y, int z)
{
Edges[++tot].v = y, Edges[tot].w = z;
Edges[tot].nxt = head[x];
head[x] = tot;
}
void bfs(int s)
{
queue<int> q;
while (q.size())
q.pop();
q.push(s);
flag[s] = true;
while (!q.empty())
{
int x = q.front();
q.pop();
for (int i = head[x]; i; i = Edges[i].nxt)
{
int y = Edges[i].v;
if (!flag[y])
{
q.push(y);
flag[y] = true;
}
}
}
}
void spfa(int s)
{
queue<int> q;
while (q.size())
q.pop();
for (int i = 1; i <= n; i++)
{
vis[i] = cnt[i] = 0;
dis[i] = 99999;
flag[i] = false;
}
dis[s] = 0;
vis[s] = 1;
q.push(s);
while (!q.empty())
{
int x = q.front();
q.pop();
vis[x] = 0;
for (int i = head[x]; i; i = Edges[i].nxt)
{
int y = Edges[i].v;
if (dis[y] > dis[x] + Edges[i].w)
{
cnt[y] = cnt[x] + 1;
if (cnt[y] >= n)
bfs(y);
dis[y] = dis[x] + Edges[i].w;
if (vis[y] == 0 && !flag[y])
{
q.push(y);
vis[y] = 1;
}
}
}
}
}
int main()
{
int t;
scanf("%d", &t);
for (int k = 1; k <= t; k++)
{
tot = 0;
memset(a, 0, sizeof(a));
memset(head, 0, sizeof(head));
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
int m;
scanf("%d", &m);
for (int i = 1; i <= m; i++)
{
int a1, b1;
scanf("%d%d", &a1, &b1);
int c1 = pow(a[b1] - a[a1], 3);
add(a1, b1, c1);
}
spfa(1);
printf("Case %d:\n", k);
int Q;
scanf("%d", &Q);
for (int i = 1; i <= Q; i++)
{
int p;
scanf("%d", &p);
if (flag[p] || dis[p] < 3 || dis[p] == 99999)
printf("?\n");
else
printf("%d\n", dis[p]);
}
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
