Comet OJ CCPC-Wannafly Winter Camp Day1 (Div2, online mirror) F.爬爬爬山-最短路(Dijkstra)(两个板子)+思维(mdzz...) zhixincode

爬爬爬山

已经提交 已经通过

9.83%

Total Submission：417

Total Accepted：41

题目描述

爬山是wlswls最喜欢的活动之一。

在一个神奇的世界里，一共有nn座山，mm条路。

wlswls初始有kk点体力，在爬山的过程中，他所处的海拔每上升1m1m，体力会减11点，海拔每下降1m1m，体力会加一点。

现在wlswls想从11号山走到nn号山，在这个过程中，他的体力不能低于00，所以他可以事先花费一些费用请dlsdls把某些山降低，将一座山降低ll米需要花费l*ll∗l的代价，且每座山的高度只能降低一次。因为wlswls现在就在11号山上，所以这座山的高度不可降低。

wlswls从11号山到nn号山的总代价为降低山的高度的总代价加上他走过的路的总长度。

wlswls想知道最小的代价是多少。

 

 

输入描述

第一行三个整数nn，mm，kk。

接下来一行nn个整数，第ii个整数h_ihi​表示第ii座山的高度。

接下来mm行，每行三个整数xx，yy，zz表示xyxy之间有一条长度为zz的双向道路。

经过每条路时海拔是一个逐步上升或下降的过程。

数据保证11号山和nn号山联通。

1 \leq n, k, h_i, z \leq 1000001≤n,k,hi​,z≤100000

1 \leq m \leq 2000001≤m≤200000

1 \leq x, y \leq n1≤x,y≤n

x \neq yx̸​=y

输出描述

一行一个整数表示答案。

样例输入 1

4 5 1
1 2 3 4
1 2 1
1 3 1
1 4 100
2 4 1
3 4 1

样例输出 1

6

去年的题，其实当时写了，两个板子，有一个过了一个没过，今天又看到这道题了，打算改一改，改了一下午，一直过不去，最后发现初始化有点问题，有一个是比数据范围大一点点的初始化，一个是直接memset初始化，因为以前memset初始化写超时过，所以就没在意，结果发现就是这里错了。。。啊啊啊啊啊啊啊啊啊，哭死。初始化的时候，要比最大值大一点初始化，for循环的初始化，改成1e18就可以。之所以memset是对的，是因为填充的时候，inf比实际的要大。

思路就是把体力值加到路径里面，然后想一想，发现有几分道理，只要往上走才会掉值，emnnnn，反正感觉有点怪，就是把体力值加到路径里面然后跑个最短路就可以了。

两个版本的dijkstra，随便看着玩吧。。。

代码1(短一点):

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<cassert>
 #include<cctype>
 #include<cmath>
 #include<cstdlib>
 #include<ctime>
 #include<deque>
 #include<iomanip>
 #include<list>
 #include<map>
 #include<queue>
 #include<set>
 #include<stack>
 #include<vector>
 using namespace std;
 typedef long long ll;
 typedef long double ld;
 typedef pair<int,int> pii;

 const double PI=acos(-1.0);
 const double eps=1e-;
 const ll mod=1e9+;
 const int inf=0x3f3f3f3f;
 const int maxn=1e5+;
 const int maxm=+;
 #define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

 int n,m,k;
 int cnt=,head[maxn<<];
 bool vist[maxn];
 ll dis[maxn],body[maxn];
 priority_queue<pair<ll,int>,vector<pair<ll,int> >,greater<pair<ll,int> > >q;

 struct node{
     int v,nex;
     ll w;
 }edge[maxn<<];

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

 void dijkstra(int s)
 {
     dis[s]=;//到自己的最短距离直接设为0
     q.push(make_pair(,s));
     while(!q.empty()){//队列非空
         int u=q.top().second;q.pop();
         vist[u]=true;
         for(int i=head[u];~i;i=edge[i].nex){
             int v=edge[i].v;
             ll w=edge[i].w+(body[v]>k?(body[v]-k)*(body[v]-k):);
             if(dis[v]>dis[u]+w){//满足条件更新距离
                 dis[v]=dis[u]+w;
                 //p[v]=u;//保存路径
                 q.push(make_pair(dis[v],v));//把更新完的值压入队列
             }
         }
     }
 }

 int main()
 {
     memset(head,-,sizeof(head));//初始化数组
     memset(vist,false,sizeof(vist));
     memset(dis,inf,sizeof(dis));
     cin>>n>>m>>k;
     for(int i=;i<=n;i++)
         cin>>body[i];
     for(int i=;i<=m;i++){
         int u,v;ll w;
         cin>>u>>v>>w;
         add(u,v,w);
         add(v,u,w);//无向图相互可达 有向图一次就好
     }
     k+=body[];
     dijkstra();
     cout<<dis[n]<<endl;
 }

代码2(队友的板子，哈哈哈哈)：

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<bitset>
 #include<cassert>
 #include<cctype>
 #include<cmath>
 #include<cstdlib>
 #include<ctime>
 #include<deque>
 #include<iomanip>
 #include<list>
 #include<map>
 #include<queue>
 #include<set>
 #include<stack>
 #include<vector>
 using namespace std;
 typedef long long ll;
 typedef long double ld;
 typedef pair<int,int> pii;

 const double PI=acos(-1.0);
 const double eps=1e-;
 const ll mod=1e9+;
 const int inf=0x3f3f3f3f;
 const int maxn=1e5+;
 const int maxm=+;
 #define ios ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);

 int n,m,k;
 int done[maxn],p[maxn];//d[i]表示i点到起点s的最短路距离,p[i]表示起点s到i的最短路径与i点相连的上一条边
 ll d[maxn],body[maxn];//done[u]==1表示u点到起点s的最短路已经找到

 struct edge{         //边结构体;
     int from,to;
     ll dis;
 };

 vector<edge> edges;     //边集 无向图 边数*2
 vector<int> g[maxn];    //g数组存的是边的序号

 struct mindis{           //压入优先队列的结构体 因为d[u]和u要绑定起来 才可标记 u是否已确定最短路;
     ll d;
     int u;

     bool operator <(const mindis& rhs)const{
         return d>rhs.d;         //距离最小值优先 距离相等无所谓 随便一个先出 边权是正的 两个会依次访问 不会影想结果
     }
 };

 priority_queue<mindis> q;   //优先队列 小顶堆 最小值优先

 void addedge(int from,int to,ll dis)      //加边操作
 {
     edges.push_back((edge){from,to,dis});   //将边压入边集
     int k=edges.size();
     g[from].push_back(k-);                 //k-1为边序号 以后调用边集数组要从下标0开始 所以边的编号从0开始 将边序号压入已from为起点的数组
 }

 void dijkstra(int s)     //主算法
 {
     d[s]=;                     //到自己的最短距离直接设为0
     q.push((mindis){,s});
     while(!q.empty()){              //队列非空
         mindis x=q.top();           //取当前最小值
         q.pop();
         int u=x.u;
         if(done[u]==) continue;    //已确定路径直接跳过
         done[u]=;                  //标记 已确定
         for(int i=;i<g[u].size();i++){
             edge e=edges[g[u][i]];  //g[u][i]表示以u为起点的第i条边在边集edges中的下标
             ll w=e.dis+(body[e.to]>k?(body[e.to]-k)*(body[e.to]-k):);
             if(d[e.to]>d[u]+w){     //满足条件更新距离
                 d[e.to]=d[u]+w;
                 p[e.to]=g[u][i];       //保存路径
                 q.push((mindis){d[e.to],e.to});  //把更新完的值压入队列
             }
         }
     }
 }

 int main()
 {
     memset(done,,sizeof(done));  //初始化数组
     memset(p,-,sizeof(p));
     //memset(d,inf,sizeof(d));
     cin>>n>>m>>k;
     for(int i=;i<=n;i++)      //把距离初始化为 inf  不能用memset  自己估算一下路径最长有多长 inf定义大一点就好
         d[i]=1e18;
     for(int i=;i<=n;i++)
         cin>>body[i];
     for(int i=;i<=m;i++){
         int u,v;ll w;
         cin>>u>>v>>w;
         addedge(u,v,w);
         addedge(v,u,w);             //无向图相互可达 有向图一次就好
     }
     k+=body[];
     dijkstra();
     cout<<d[n]<<endl;
 }

好想找队友聊天，但是放假了，不能打扰，超乖.jpg。

溜了，我姐的狗窝没有吃的，要饿死了(；´д｀)ゞ