【笔试题】网易——逃离梦境

题意

示例1：
输入：
2
8 11 2
5 4
6 3
8 6
6 2
5 7
3 4
2 4
5 2
2 1
3 1
2 8
8 4
1 4
9 8 7
5 3
7 3
7 8
9 8
2 6
6 8
1 4
4 3
5 7
9 2
2 1
4 8
3 5
6 1
2 8
输出：1 1

---

分析

思路一：Dijkstra求最短路径。

图 用例1中第一个例子，其中红色为可跳跃边，白色不可跳跃边

需注意：

1. 根据 能否进入梦境标志 来重新设置各源点之间的路径。
2. 根据前者选择的路径来设置 能否进入梦境标志。

分析：T(n)=O(n^2)， 因需要选择数组中最小值和根据最小值设置其他边距离。S(n)=O(n^2)，二维数组记录边。

---

代码

#include <bits/stdc++.h>

using namespace std;

const int Max_Distance = 10000;

class graph{
public:
    graph() {}
    
    graph(int vex_num) : vexnum(vex_num), vex(vex_num, 0), arcs(vex_num, vector<arc>(vex_num)) {
        for(int i = 0; i < vexnum; i++) {
            vex[i] = i;
        }
    }

    void add_arc(int x0, int x1, bool flag) {
        x0--; x1--;
        if(flag) {
            arcs[x0][x1].type = arcs[x1][x0].type = inner;
        }else {
            arcs[x0][x1].type = arcs[x1][x0].type = outter;
        }
        arcs[x0][x1].weight = arcs[x1][x0].weight = 1;
        arcnum += 2;
    }
    
public:
    enum arc_type {
        outter, // 表世界边
        inner   // 里世界边 
    };
    
    struct arc {
        int weight;
        arc_type type;

        arc() : weight(Max_Distance), type(outter) {}
    };
    
    int vexnum;         // 顶点个数
    vector<int> vex;    // 顶点
    
    int arcnum;         // 弧个数
    vector<vector<arc> > arcs;// 弧矩阵
};

void init_graph(graph& g) {
    int vex_num = 0, outter_cnt = 0, inner_cnt = 0;
    
    cin >> vex_num >> outter_cnt >> inner_cnt;
    g = graph(vex_num);
    
    while(outter_cnt--) {
        int x0 = 0, x1 = 0;
        cin >> x0 >> x1;
        g.add_arc(x0, x1, 0);
    }
    while(inner_cnt--) {
        int x0 = 0, x1 = 0;
        cin >> x0 >> x1;
        g.add_arc(x0, x1, 1);
    }
}

void ShortPath_DIJ(graph& g, int v0, vector<vector<int> >& path, vector<int>& D){
    bool can_in_inner = true;       // 跳跃标志
    vector<int> final(g.vexnum, false);
    
    // 初始化
    for(int i = 0; i < g.vexnum; i++){
        D[i] = (g.arcs[v0][i].type == graph::arc_type::inner && can_in_inner) ? 0 : g.arcs[v0][i].weight;    // 根据边类型赋值
        
        // 两点相连，将其加入路径数组
        if(i != v0 && D[i] < Max_Distance){
            path[i].push_back(v0);
            path[i].push_back(i);
        }
    }
    D[v0] = 0; final[v0] = true;
    int min_index_1 = v0, min_index_2 = 0;// 最后连续加入的两个节点，用于设置跳跃标志
   
    // 循环，每次求得v0到某个顶点的最短路径，并加入遍历集合
    for(int i = 1; i < g.vexnum ; i++){
        int min_elem = Max_Distance;

        // 选取当前距离数组D中最小的边，并加入final集
        for(int j = 0; j < D.size(); j++){
            if(!final[j] && D[j] < min_elem){
                min_index_2 = j;
                min_elem = D[j];
            }
        }
        final[min_index_2] = true;

        // 根据选择边类型跳跃标志
        if(g.arcs[min_index_1][min_index_2].type == graph::arc_type::outter) {
            can_in_inner = true;
        }
        else {
            can_in_inner = false;
        }
        min_index_1 = min_index_2;
        
        // 根据当前最短距离更新其他节点
        for(int j = 0; j < D.size(); j++){
            if(!final[j]) {
                int val = (g.arcs[min_index_2][j].type == graph::arc_type::inner && can_in_inner) ? 0 : g.arcs[min_index_1][j].weight;
                
                if(D[min_index_2] + val < D[j]){   // 注：不选里世界路径则出错，因为已经根据里世界的路径设置了D数组
                    D[j] = D[min_index_2] + val;
                    // min_index和自己中的顶点都在j中
                    path[j].resize(path[min_index_2].size());
                    copy(path[min_index_2].begin(), path[min_index_2].end(), path[j].begin());
                    path[j].push_back(j);
                }
            }
        }
    }
}

int main(){
    int n = 0;
    
    cin >> n;

    while(n--) {
        int v0;
        graph g;
        vector<int> D;
        vector<vector<int> > path;
        ostream_iterator<int> out(cout, " ");

        // 输入
        init_graph(g);
        v0 = 0;
        path.resize(g.vexnum);
        D.resize(g.vexnum);

        // Dijkstra求解v0到各个边的最短路径
        ShortPath_DIJ(g, v0, path, D);

        cout << D.back() << endl;
        /* for(int i = 0; i < path.size(); i++){
            cout<<v0<<"->"<<g.vex[i]<<"，最短路径长度="<<D[i]<<"，路径=";
            copy(path[i].begin(), path[i].end(), out);
            cout<<endl;
        }*/
    }
    return 0;
}

其中有误还望指正，欢迎更多解答。