「BJWC2012」冻结题解

一.题目

"我要成为魔法少女！"

"那么，以灵魂为代价，你希望得到什么？"

"我要将有关魔法和奇迹的一切，封印于卡片之中"

在这个愿望被实现以后的世界里，人们享受着魔法卡片（SpellCard，又名符卡）带来的便捷。

现在，不需要立下契约也可以使用魔法了！你还不来试一试？

比如，我们在魔法百科全书（Encyclopedia of Spells）里用“freeze”作为关键字来查询，会有很多有趣的结果。

例如，我们熟知的Cirno，她的冰冻魔法当然会有对应的 SpellCard 了。

当然，更加令人惊讶的是，居然有冻结时间的魔法，Cirno 的冻青蛙比起这些来真是小巫见大巫了。

这说明之前的世界中有很多魔法少女曾许下控制时间的愿望，比如 Akemi Homura、Sakuya Izayoi……

当然，在本题中我们并不是要来研究历史的，而是研究魔法的应用。

我们考虑最简单的旅行问题吧：现在这个大陆上有 N 个城市，M 条双向的道路。城市编号为$1$~$N$，我们在 1 号城市，需要到$N$号城市，怎样才能最快地到达呢？

这不就是最短路问题吗？我们都知道可以用 Dijkstra、Bellman-Ford、Floyd-Warshall等算法来解决。

现在，我们一共有$k$张可以使时间变慢 50%的 SpellCard，也就是说，在通过某条路径时，我们可以选择使用一张卡片，这样，我们通过这一条道路的时间就可以减少到原先的一半。需要注意的是：

①.在一条道路上最多只能使用一张 SpellCard。

②.使用一张SpellCard 只在一条道路上起作用。

③.你不必使用完所有的 SpellCard。

给定以上的信息，你的任务是：求出在可以使用这不超过 K 张时间减速的 SpellCard 之情形下，从城市1 到城市N最少需要多长时间。

二.输入/出格式

2.1输入格式

第一行包含三个整数：$N$,$M$,$K$。

接下来$M$行，每行包含三个整数：$Ai$,$Bi$,$Timei$表示存在一条$Ai$与$$Bi之间的双向道路，在不使用 SpellCard 之前提下，通过它需要的时间。

2.2输出格式

输出一个整数，表示从1号城市到$N$号城市的最小用时。

三.思路

因为有k次机会对边权进行修改操作，是分层图擅长的操作，所以果断选择分层图

同时，这道题是一道裸的分层图模板，每一层的建图和原图一样，所以建图很简单

层与层之间的连边的权值w根据题意就是/2，变为原来的一半,那么层与层之间的连接也很简单了

四.代码(干货注释)

4.1物理建图

  #include<bits/stdc++.h>
  using namespace std;
  const int inf=0x3f3f3f3f;//极大值
  int head[55*55];
  int cnt=0;
  struct edge{//链式前向星
	int v;
	int nex;
	int w;
  }e[1010*55*4];
  void add(int u,int v,int w){//加边
	e[cnt].v=v;//<u,v>表示一条边的两个节点
	e[cnt].w=w;//边权
	e[cnt].nex=head[u];
	head[u]=cnt++;
  }
  int n,m,k;
  int dis[55*55];
  bool vis[55*55];//标记数组，标记是否遍历过
  void dij(int s) {
	memset(vis,0,sizeof(vis));
	memset(dis,inf,sizeof(dis));//清空，很重要!!!
	dis[s]=0;
    //小根堆优化 
	priority_queue<pair<int,int>,vector<pair<int,int> >,greater<pair<int,int> > > q;
	q.push(make_pair(0,s)) ;//pair
	while(!q.empty()) {
		int u=q.top().second;//取第二个
		q.pop();
		if(vis[u]){//跳过
            continue;
        }else{
			vis[u]=1;
			for(int i=head[u];~i;i=e[i].nex){//遍历
				int v=e[i].v;
				if(dis[v]>dis[u]+e[i].w) {
					dis[v]=dis[u]+e[i].w;
					q.push(make_pair(dis[v],v));
				}
			}
        }
	}
  }
  int main(){
    //初始化
    memset(head,-1,sizeof(head));
    cin>>n>>m>>k;
    for(int i=1;i<=m;i++){
        int u,v,w;
        cin>>u>>v>>w;
        //第0层
        add(u,v,w);
        add(v,u,w);
        //建立k层
        for(int j=1;j<=k;j++){
        add(u+j*n-n,v+j*n,w/2);
        add(v+j*n-n,u+j*n,w/2);
        add(u+j*n,v+j*n,w);
        add(v+j*n,u+j*n,w);
        }
    }
    dij(1);
    //循环看不同操作次数的min值 
    int ans=inf;
    for(int i=0;i<=k;i++){
        ans=min(ans,dis[n+i*n]);
    }	
    cout<<ans<<endl;
    return 0;
  }

4.2逻辑建图

  #include<bits/stdc++.h>
  using namespace std;
  const int maxn=55;//定义
  const int maxk=55;
  int n,m,k;
  int ans=0x7f3f3f3f;//极大值
  int a,b,c;
  int dis[maxn][maxk];
  int vis[maxn][maxk];
  int first[maxn];
  int nex[2010],v[2010],w[2010];//存图数组
  struct node{
	int val;
	int u;
	int tot;
  };
  bool operator<(node a,node b){//优先队列
	return a.val>b.val;
  }
  priority_queue<node> q;
  int cnt;
  void add(int U,int V,int val){//存图
	v[++cnt]=V;
	w[cnt]=val;
	nex[cnt]=first[U];
	first[U]=cnt;
  }
  int main(){
	cin>>n>>m>>k;
	for(int i=1;i<=n;i++){//加边
		cin>>a>>b>>c;
		add(a,b,c);
		add(b,a,c);
	}
	memset(dis,0x3f,sizeof(dis));//初始化
	dis[1][0]=0;
	q.push({0,1,0});
	while(q.size()){
		int u=q.top().u;
		int tot=q.top().tot;
		q.pop();
		if(vis[u][tot]){//跳过
			continue;
		}
		vis[u][tot]=1;
        //核心代码，牢记
		for(int i=first[u];i;i=nex[i]){
			if(dis[v[i]][tot]>dis[u][tot]+w[i]){
				dis[v[i]][tot]=dis[u][tot]+w[i];
				q.push({dis[v[i]][tot],v[i],tot});
			}
			if(tot<k&&dis[v[i]][tot+1]>dis[u][tot]+w[i]/2){
				dis[v[i]][tot+1]=dis[u][tot]+w[i]/2;
				q.push({dis[v[i]][tot+1],v[i],tot+1});
			}
		}
	}
	for(int i=0;i<=k;i++){
		ans=min(ans,dis[n][i]);
	}
	cout<<ans<<endl;
	return 0;
  }

这篇题解到这就结束啦！！！[完结撒花]