BZOJ2763， 最短路

   

   好激动，没想到，我在BZOJ这个网站AC的第一道是一个最短路的，虽然仔细一想也不是很难。

   简单说一下吧！之所以开始做这道题还是想练一下最短路，因为刚重温了一下dijkstra。刚开始看到也是又蒙了，然后仔细一想，状态的转移应该不难，应该是分层进行的，不断地进行下一步决策。所以就把刘汝佳的dijkstra算法改了一下，用在这道题；

   

#include<cstdio>
#include<iostream>
#include<queue>
#include<vector>
#include<cstring>
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 10005
#define INF 0xfffffff;
using namespace std;
 
int n, s, t, k, m;
 
int read()
{
    int s = 0, t = 1; char  c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c - '0'; c = getchar();
    }
    return s * t;
}
 
struct heapnode{
int d, u, zhi;
bool operator < (const heapnode& rhs) const{
  return d > rhs.d; 
}
};
 
struct edge{
int from, to, key;
};
 
struct Dijkstra{
int n, k;
vector<edge> edges;
vector<int> q[maxn];
int d[maxn][15];
bool done[maxn][15];
 
void init(int n,int k)
{
    this->n = n;
    this->k = k;
    rep(i,0,n-1){
        q[i].clear();
    }
    edges.clear();
}
 
void dijkstra(int s)
{
    rep(i,0,n-1) rep(j,0,k) d[i][j] = INF;
    rep(i,0,k) d[s][i] = 0;
    priority_queue<heapnode> Q;
    Q.push((heapnode){0,s,0});
    memset(done,0,sizeof(done));
    while( !Q.empty() ){
        heapnode x = Q.top(); Q.pop();
        int u = x.u;
        int zhi = x.zhi;
        if( done[u][zhi] ) continue;
        done[u][zhi] = 1;
        int s = q[u].size();
        rep(i,0,s-1){
            edge& x = edges[q[u][i]];
            int y = x.to;
            if( d[y][zhi] > d[u][zhi] + x.key ){
                d[y][zhi] = d[u][zhi] + x.key;
                Q.push((heapnode){d[y][zhi],y,zhi}); 
            } 
            if( d[y][zhi+1] > d[u][zhi] && zhi < k ){
                d[y][zhi+1] = d[u][zhi]; 76                 Q.push((heapnode){d[y][zhi+1],y,zhi+1});
            }
        }
    } 
}
 
void add_edge(int x,int y,int key)
{
    edges.push_back((edge){x,y,key});
    edges.push_back((edge){y,x,key});
    int m = edges.size();
    q[x].push_back(m-2);
    q[y].push_back(m-1);
}
};
 
Dijkstra solver;
 
int main()
{
    n = read(), m = read(), xk = read(), s = read(), t = read();
    solver.init(n,k);
    rep(i,1,m){
        int x = read(), y = read(), key = read();
        solver.add_edge(x,y,key);
    } 
    solver.dijkstra(s);
    int ans = 0xfffffff;
    rep(i,0,k){
        ans = min(solver.d[t][i],ans);
    }
    cout<<ans<<endl;
    return 0;
}

     同学说，指针版能更快一些，就学着打了个指针版，加油，也不难。

#include<cstdio>
#include<iostream>
#include<cstring>
#include<queue>
#define rep(i,j,k) for(int i = j; i <= k; i++)
#define maxn 10005
#define maxl 50003
#define clr(i,l) memset(i,l,sizeof(i));
using namespace std;

int n, m, s, t, xk;
int d[maxn][13] = {0}; 

int read()
{
    int s = 0, t = 1; char c = getchar();
    while( !isdigit(c) ){
        if( c == '-' ) t = -1; c = getchar();
    }
    while( isdigit(c) ){
        s = s * 10 + c - '0'; c = getchar();
    }
    return s * t;
}

struct edge{
int to, key;
edge* next;
};

struct heapnode{
int r, k, u;
bool operator < (const heapnode& rhs) const{
  return r > rhs.r;
}
};

priority_queue<heapnode> Q;

edge edges[maxl*2];
edge* pt;
edge* head[maxn];

void add_edge(int x,int y,int key)
{
    pt->to = y;
    pt->key = key;
    pt->next = head[x];
    head[x] = pt++;
    pt->to = x;
    pt->key = key;
    pt->next = head[y];
    head[y] = pt++;
}

void dijkstra()
{
    clr(d,127); clr(d[s],0);
    Q.push((heapnode){0,0,s});
    while( !Q.empty() ){
        heapnode x = Q.top(); Q.pop();
        int u = x.u, k= x.k;
        if( x.r != d[u][k] ) continue;
        for( edge*i = head[u]; i ; i = i->next ){
            int t = i->to;
            if( d[t][k] > d[u][k] + i->key ) {
                d[t][k] = d[u][k] + i->key;
                Q.push((heapnode){d[t][k],k,t});
            }
            if( d[t][k+1] > d[u][k] && k < xk ){
                d[t][k+1] = d[u][k];
                Q.push((heapnode){d[t][k+1],k+1,t});
            }
        }
    }
}

int main()
{
    n = read(), m = read(), xk = read(), s = read(), t = read();
    pt = edges;
    rep(i,1,m){
        int x = read(), y = read(), key = read();
        add_edge(x,y,key);
    }
    dijkstra();
    int ans = 0xfffffff;
    rep(i,0,xk){
        ans = min(ans,d[t][i]);
    }
    cout<<ans<<endl;
    return 0;
}

2763: [JLOI2011]飞行路线

Time Limit: 10 Sec  Memory Limit: 128 MB
Submit: 1462  Solved: 564
[Submit][Status][Discuss]

Description

Alice和Bob现在要乘飞机旅行，他们选择了一家相对便宜的航空公司。该航空公司一共在n个城市设有业务，设这些城市分别标记为0到n-1，一共有m种航线，每种航线连接两个城市，并且航线有一定的价格。Alice和Bob现在要从一个城市沿着航线到达另一个城市，途中可以进行转机。航空公司对他们这次旅行也推出优惠，他们可以免费在最多k种航线上搭乘飞机。那么Alice和Bob这次出行最少花费多少？

Input

数据的第一行有三个整数，n,m,k，分别表示城市数，航线数和免费乘坐次数。

第二行有两个整数，s,t，分别表示他们出行的起点城市编号和终点城市编号。(0<=s,t<n)

接下来有m行，每行三个整数，a,b,c，表示存在一种航线，能从城市a到达城市b，或从城市b到达城市a，价格为c。(0<=a,b<n,a与b不相等，0<=c<=1000)

 

Output

 

只有一行，包含一个整数，为最少花费。

Sample Input

5 6 1
0 4
0 1 5
1 2 5
2 3 5
3 4 5
2 3 3
0 2 100

Sample Output

8