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) 等价,即每一个二元组只被计算一次。
思路:
这个问题可以用弗洛伊德来解决。通过dis来表示双方的胜负关系 若dis[i][j]=1则表示i胜于j,dis[i][j]=0且dis[j][i]=0即表示i与j无法判断双方的胜负关系。dis[i][j]=max(dis[i][j],dis[i][k]&dis[k][j])则使胜负关系具有传递性。这样就解决了这个问题,通过弗洛伊德算法进行三次遍历就能找到所有dis符合1的,但中间可以进行剪枝,若dis[i][k]==0就知道dis[i][j]肯定不为1,所以只需进行dis[i][k]==1的即可。
代码:
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
#define maxn 502
int dis[maxn][maxn];
void freud(int N) //弗洛伊德算法
{
for (int k = 1; k <= N; k++)
for (int i = 1; i <= N; i++)
{
if (dis[i][k] == 0) //剪枝
continue;
for (int j = 1; j <= N; j++)
{
dis[i][j] = max(dis[i][j], dis[i][k] & dis[k][j]);
}
}
}
int main()
{
ios::sync_with_stdio(false);
int group;
cin >> group;
for (int i = 0; i < group; i++)
{
int N, M;
int A, B;
int count = 0;
cin >> N >> M;
for (int j = 0; j <= N; j++)
for (int k = 0; k <= N; k++) //初始化dis
dis[j][k] = 0;
for (int j = 0; j < M; j++)
{
cin >> A >> B;
dis[A][B] = 1;
}
freud(N);
for (int j = 1; j <= N; j++)
for (int k = 1; k <= N; k++)
if (dis[j][k] == 1)
count++;
cout << N * (N - 1) / 2 - count << endl;
}
return 0;
}
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 前往喵星机场花费的总时间。
本题不忽略多余的空格和制表符,且每一组答案间要输出一个换行
思路:
这道题可以利用单源最短路径来解决,当然也可以用SPFA来解决,当然这次为了学习方法使用了单源最短路径。首先采用edge和链式前向星的方式存储X,Y,Z。整个过程需要经过两次的dijkstral。第一次从起点开始,第二次从终点开始跑,来记录单源的最短路。然后找到商业线所用时间的最小值,再与经济线进行比较。首先使用dis来记录每个点的距离,path用来记录经过的路径。初始先让起点放入小根堆中,然后将该点vis设置为1,每次取出堆顶元素,然后进行松弛操作,比较一下e[i].to与 dis1[x]+e[i].w的大小,若大于的化,就进行更新,并且将该点存入小根堆中。在进行dijkstral之后从需要比较从起点到i加上终点到j的距离加上i和j间商业线的w,起点到j的距离和终点到i的距离加上i和j间商业线的w同时还要和使用经济线时的权重进行比较,求出来最小值。最后通过递归输出路径即可。
要点:要注意输出的格式,因为递归输出需要注意空格,这道题因为没用有用的函数存储导致多次PE,修改了很多次,也知道了queue,stack等存储STL的重要性
代码:
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int n = 5 * 1e6 + 100;
const int inf = 5 * 1e8;
struct edge
{
int to;
int next;
int w;
}e[n];
priority_queue<pair <int, int> >q;
int head[n], vis[1002], tot;
int dis1[1002], dis2[1002]; //记录距离
int path1[1002], path2[1002]; //记录路径
int N, S, E;
void add(int x, int y, int w)
{
e[++tot].to = y;
e[tot].next = head[x];
e[tot].w = w;
head[x] = tot;
}
void Dijkstra1(int s)
{
while (q.size())
q.pop();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= N; i++)
dis1[i] = inf;
dis1[s] = 0;
q.push(make_pair(0, s));
while (q.size())
{
int x = q.top().second;
q.pop();
vis[x] = 1;
for (int i = head[x]; i != -1; i = e[i].next)
{
int y = e[i].to, w = e[i].w;
if (dis1[y] > dis1[x] + w)
{
path1[y] = x;
dis1[y] = dis1[x] + w;
q.push(make_pair(-dis1[y], y));
}
}
}
}
void Dijkstra2(int s)
{
while (q.size())
q.pop();
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= N; i++)
dis2[i] = inf;
dis2[s] = 0;
q.push(make_pair(0, s));
while (q.size())
{
int x = q.top().second;
q.pop();
vis[x] = 1;
for (int i = head[x]; i != -1; i = e[i].next)
{
int y = e[i].to, w = e[i].w;
if (dis2[y] > dis2[x] + w)
{
dis2[y] = dis2[x] + w;
q.push(make_pair(-dis2[y], y));
path2[y] = x;
}
}
}
}
void output1(int a)
{
if (a == S)
{
printf("%d", a);
return;
}
output1(path1[a]);
printf(" %d", a);
}
void output2(int a)
{
printf(" %d", a);
if (a == E)
return;
output2(path2[a]);
}
int main()
{
int M, K;
int X, Y, Z;
int b = 0;
while (/*cin >> N >> S >> E*/scanf("%d %d %d", &N, &S, &E) != EOF)
{
int l = 0, r = 0;
if (b) printf("\n");
scanf("%d", &M);
//cin >> M;
tot = 1;
memset(head, -1, sizeof(head));
memset(path1, -1, sizeof(path1));
memset(path2, -1, sizeof(path2));
for (int i = 1; i <= M; i++)
{
scanf("%d %d %d", &X, &Y, &Z);
//cin >> X >> Y >> Z;
add(X, Y, Z);
add(Y, X, Z);
}
Dijkstra1(S);
Dijkstra2(E);
int mint = dis1[E];
scanf("%d", &K);
//cin >> K;
for (int i = 1; i <= K; i++)
{
scanf("%d %d %d", &X, &Y, &Z);
//cin >> X >> Y >> Z;
if (mint > dis1[X] + dis2[Y] + Z)
{
mint = dis1[X] + dis2[Y] + Z;
l = X;
r = Y;
}
if (mint > dis1[Y] + dis2[X] + Z)
{
mint = dis1[Y] + dis2[X] + Z;
l = Y;
r = X;
}
}
if (l == 0)
{
output1(E);
printf("\nTicket Not Used\n%d\n", mint);
//cout << endl << "Ticket Not Used" << endl << mint << endl;
}
else
{
output1(l);
output2(r);
printf("\n%d\n%d\n", l, mint);
//cout << endl << l << endl << mint << endl;
}
b = 1;
}
return 0;
}
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 则输出 ‘?’。
思路:
这道题因为有负数和环路,所以应当使用Bellman−Ford算法-SPFA最为适用。存储图的方式使用链式前向星。
下面分别介绍各数组的作用:inq代表标记经过的点,dis标记两点之间的距离,cnt用来记录松弛的次数,pre记录是不是负环。
首先在进行spfa之前需要对所有的数组初始化,对其他数组初始化为0,dis初始化为inf,然后将起点压入队列,如果起点不为空,则进行循环,每次取出队首元素,删除队首元素,并将inq的该点设置为0,然后对邻接点进行松弛,对于dis[v] > dis[u] + e[i].w的点inq设置为1并且cnt+1,并将邻接点压入队列当中,如果cnt[v] >= N则证明存在负环,然后dfs该点,找到负环并用pre标记该点。进行spfa之后对所有点进行判断,若pre=0且dis[P] < 3 || dis[P] == inf则输出‘?’,否则输出dis值。
代码:
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<cmath>
using namespace std;
#define inf 0x3f3f3f3f
const int maxn = 500;
const int maxm = 100050;
int tot,head[maxn],dis[maxn],cnt[maxn],inq[maxn],pre[maxn];
int T,N, M,A,B,Q,P,g[maxn];
queue<int>q;
struct edge
{
int to;
int w;
int next;
}e[maxm];
void add(int x, int y, int w)
{
e[tot].to = y;
e[tot].w = w;
e[tot].next = head[x];
head[x] = tot;
tot++;
}
void dfs(int v)
{
pre[v] = 1;
for (int i = head[v]; i != -1; i = e[i].next) //找到负环
{
if (pre[e[i].to] == 0)
dfs(e[i].to);
}
}
void spfa(int a)
{
while (!q.empty()) q.pop();
for (int i = 1; i <= N; i++)
{
dis[i] = inf;
inq[i] = 0;
cnt[i] = 0;
pre[i] = 0;
}
dis[a] = 0;
inq[a] = 1;
q.push(a);
while (!q.empty())
{
int u = q.front();
q.pop();
inq[u] = 0;
for (int i = head[u]; i != -1; i = e[i].next)
{
int v = e[i].to;
if (pre[v]) continue;
if (dis[v] > dis[u] + e[i].w)
{
dis[v] = dis[u] + e[i].w;
if (!inq[v])
{
q.push(v);
inq[v] = 1;
cnt[v] = cnt[v] + 1;
if (cnt[v] >= N)
{
dfs(v);
}
}
}
}
}
}
int main()
{
cin >> T;
int count = 1;
for (int i = 1; i <= T; i++)
{
cin >> N;
for (int j = 1; j <= N; j++)
cin >> g[j];
tot = 0;
memset(head, -1, sizeof(head));
cin >> M;
for (int j = 1; j <= M; j++)
{
cin >> A >> B;
add(A, B, pow(g[B] - g[A], 3));
}
spfa(1);
cout << "Case" << " " << count << ":" << endl;
cin >> Q;
for (int j = 1; j <= Q; j++)
{
cin >> P;
if (pre[P] == 0)
{
if (dis[P] < 3 || dis[P] == inf)
cout << "?" << endl;
else
cout << dis[P] << endl;
}
else cout << "?" << endl;
}
count++;
}
return 0;
}