程序设计思维 week7 作业C-Extended Traffic

最新推荐文章于 2024-04-10 17:36:22 发布

噗噗噗噗噗噗噗

最新推荐文章于 2024-04-10 17:36:22 发布

阅读量177

点赞数

分类专栏：程序设计思维与实践

本文链接：https://blog.csdn.net/weixin_43805228/article/details/105411136

版权

程序设计思维与实践专栏收录该内容

48 篇文章 0 订阅

订阅专栏

题目

在梦中，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 号点的最少税费。

Ouput

每个询问输出一行，如果不可达或税费小于 3 则输出 ‘?’。

Sample Input

2
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 10

Sample Ouput

Case 1:
3
4
Case 2:
?
?

思路

由于税收可能为负，存在负权边，所以这是一个含负边的单源最短路问题，使用SPFA。
输出’?'有3种情况：

不可达
最短路不存在
最短路小于3（题意）

在代码中对应的情况分别是：

dis[v] = inf
cnt[v] >= n即找到负环，负环所在连通图中所有的点
dis[v] < 3

SPFA

Bellman-ford算法：对图中的每一条边进行松弛操作，由于最短路的路径条数小于点的个数，故松弛点数-1轮即可。
Bellman-ford的队列优化算法——SPFA。
在Bellman-ford的松弛过程中发现，松弛操作仅发生在最短路径前导节点已经成功松弛过的节点上：与 S 邻接的点被松弛 -> 最短路径上的第一条边；与第一轮被松弛的点相邻接的点被松弛 -> 最短路径上的第二条边；……
故在SPFA中，每次只做有效的松弛操作。建立一个队列，队列中存储已经松弛过的点，每次从队首取点并松弛其邻接点，若邻接点松弛成功，则将其加入队列。
当图中存在负环时，那么可以沿着负环不断走下去，那么最短路长度为负无穷，没有意义。当解决单源最短路径问题时，如果图中边的权值非负时，不需要考虑额外的问题；如果含有负权边，则需考虑SPFA求出的最短路径是否有效。
判断负环：判断点的入队次数，如果某一点入队n次，则说明有负环。

代码

#include <cstdio>
#include <cstring>
#include <math.h>
#include <queue>
using namespace std;
const int inf=1e8;
int t,n,m,q,p,tot,head[205],aa[205],dis[205],inq[205],cnt[205];
bool vis[205];
queue<int> que;
struct edge{
    int to,w,next=-1;
}e[100005];

void add(int x,int y,int z){
    e[++tot].to=y;
    e[tot].w=z;
    e[tot].next=head[x];
    head[x]=tot;
}

void dfs(int s){
    vis[s]=false;
    for(int i=head[s];i!=-1;i=e[i].next){
        if(vis[e[i].to])
            dfs(e[i].to);
    }
}

void spfa(int s){
    dis[s]=0;
    inq[s]=1;
    que.push(s);
    while (!que.empty()) {
        int u=que.front();que.pop();
        inq[u]=0;
        for(int i=head[u];i!=-1;i=e[i].next){
            int v=e[i].to;
            if(!vis[v])//不可到达
                continue;
            if(dis[v]>dis[u]+e[i].w){
                cnt[v]=cnt[u]+1;
                dis[v]=dis[u]+e[i].w;
                if(cnt[v]>=n){//找到负环
                    dfs(v);
                }
                if(!inq[v]){
                    que.push(v);
                    inq[v]=1;
                }
            }
        }
    }
}

int main(){
    scanf("%d",&t);
    for(int i=0;i<t;i++){
        memset(vis, true, sizeof(vis));
        scanf("%d",&n);
        for(int j=0;j<=n;j++){
            head[j]=-1;
            dis[j]=inf;
            inq[j]=0;
            cnt[j]=0;
            aa[j]=0;
        }
        for(int j=1;j<=n;j++)
            scanf("%d",&aa[j]);
        scanf("%d",&m);
        tot=0;
        for(int j=0;j<m;j++){
            int a,b;
            scanf("%d%d",&a,&b);
            add(a, b, pow(aa[b]-aa[a],3));
        }
        spfa(1);
        scanf("%d",&q);
        printf("Case %d:\n",i+1);
        for(int j=0;j<q;j++){
            scanf("%d",&p);
            if(!vis[p]||dis[p]<3||dis[p]==inf)
                printf("?\n");
            else
                printf("%d\n",dis[p]);
        }
    }
}