A strange lift HDU - 1548（Dijkstra/SPFA/BFS/DFS）

 法一：Dijkstra+邻接表

对于每一层，在它与它up和down可到的两个楼层间建边(down的楼层要大于0)，权值为1，求最短路。（代码中注释的地方是默写模板时出错的地方，要特别注意）

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int> PII;
const int N=205,M=N<<1;
int INF=0x3f3f3f3f;
int h[N],e[M],ne[M],w[M],idx;
int n;
int dist[N];
bool st[N];

void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
void Dij(int s){
    memset(dist,INF,sizeof dist);
    dist[s]=0;
    priority_queue<PII,vector<PII>,greater<PII>>heap;
    heap.push({0,s});
    //st[s]=true;//
    while(heap.size()){

        auto t=heap.top();
        heap.pop();

        int ver=t.second,distance=t.first;

        if(st[ver])continue;//
        st[ver]=true;//

        for(int i=h[ver];~i;i=ne[i]){
            int j=e[i];
            if(/*!st[j]&&*/dist[j]>w[i]+distance){
                dist[j]=w[i]+distance;
                heap.push({dist[j],j});
                //st[j]=true;//
            }
        }
    }
}
int main(){
    while(scanf("%d",&n)!=EOF && n){
        memset(h,-1,sizeof h);
        memset(st,0,sizeof st);
        idx=0;

        int a,b;
        scanf("%d%d",&a,&b);
        for(int i=1;i<=n;++i){
            int k;
            scanf("%d",&k);
            add(i,i+k,1);
            if(i-k>0) add(i,i-k,1);
        }
    
        Dij(a);
        if(dist[b]==INF) puts("-1");
        else printf("%d\n",dist[b]);
    }
}

法二：SPFA+邻接表

思路与法一一致，熟悉模板用。（注释的地方默写易错）

#include<bits/stdc++.h>
using namespace std;
const int N=205,M=N<<1;
int INF=0x3f3f3f3f;
int h[N],e[M],ne[M],w[M],idx;
int n;
int dist[N];
bool st[N];

void add(int a,int b,int c){
    e[idx]=b,ne[idx]=h[a],w[idx]=c,h[a]=idx++;
}
void SPFA(int s){
    memset(dist,INF,sizeof dist);
    dist[s]=0;

    queue<int>q;
    q.push(s);
    st[s]=true;

    while(q.size()){
        int t=q.front();
        q.pop();
        st[t]=false;//

        for(int i=h[t];~i;i=ne[i]){
            int j=e[i];
            if(dist[j]>dist[t]+w[i]){
                dist[j]=dist[t]+w[i];
                if(!st[j]){//
                    q.push(j);
                    st[j]=true;
                }
            }
        }
    }

}
int main(){
    while(scanf("%d",&n)!=EOF && n){
        memset(h,-1,sizeof h);
        memset(st,0,sizeof st);
        idx=0;

        int a,b;
        scanf("%d%d",&a,&b);
        for(int i=1;i<=n;++i){
            int k;
            scanf("%d",&k);
            add(i,i+k,1);
            if(i-k>0) add(i,i-k,1);
        }
    
        SPFA(a);
        if(dist[b]==INF) puts("-1");
        else printf("%d\n",dist[b]);
    }
}

法三：BFS

emm，好久不写都忘了BFS怎么写了......这还是个优先队列BFS

#include<bits/stdc++.h>
using namespace std;
typedef pair<int,int>PII;

const int N=205;
int n,res;
bool vis[N];
int k[N];

void BFS(int a,int b){

    priority_queue<PII,vector<PII>,greater<PII>>q;
    q.push({0,a});
    vis[a]=true;
    res=-1;

    while(!q.empty()){
        auto t=q.top();
        q.pop();
        int ver=t.second,step=t.first;
        if(ver==b){
            res=step;
            break;
        }
        
        if(ver+k[ver]<=n&&!vis[ver+k[ver]]){
            vis[ver+k[ver]]=true;
            q.push({step+1,ver+k[ver]});
        }

        if(ver-k[ver]>=1&&!vis[ver-k[ver]]){
            vis[ver-k[ver]]=true;
            q.push({step+1,ver-k[ver]});
        }
        
    }

    printf("%d\n",res);

}
int main(){
    while(scanf("%d",&n)!=EOF && n){
        memset(vis,0,sizeof vis);
        int a,b;
        scanf("%d%d",&a,&b);
        for(int i=1;i<=n;++i){
            scanf("%d",&k[i]);
        }
        BFS(a,b);
    }
}

法四：DFS

#include<bits/stdc++.h>
using namespace std;
const int INF=0x3f3f3f3f;
const int N=205;
int n,res;
bool vis[N];
int k[N];
int a,b;

void DFS(int x,int step){
    if(x==b) res=min(res,step);
    else if(step<=res){
        vis[x]=true;
        if(x+k[x]<=n&&!vis[x+k[x]]) DFS(x+k[x],step+1);
        if(x-k[x]>=1&&!vis[x-k[x]]) DFS(x-k[x],step+1);
        vis[x]=false;
    }

}
int main(){
    while(scanf("%d",&n)!=EOF && n){
        memset(vis,0,sizeof vis);
        scanf("%d%d",&a,&b);
        for(int i=1;i<=n;++i){
            scanf("%d",&k[i]);
        }
        res=INF;
        DFS(a,0);
        if(res==INF) puts("-1");
        else printf("%d\n",res);
    }
}

注意：BFS中，当搜索到ver==b直接就是答案，因为宽度优先的搜索具有最短路的性质，而DFS中res=min(res,step)，要在所有可行的解中找最小的。

四种方法中SPFA最快，DFS最慢，其他两个差不多。