PigyChan_LeetCode 1129. 颜色交替的最短路径

1129. 颜色交替的最短路径

难度中等

在一个有向图中，节点分别标记为 0, 1, …, n-1。这个图中的每条边不是红色就是蓝色，且存在自环或平行边。
red_edges 中的每一个 [i, j] 对表示从节点 i 到节点 j 的红色有向边。类似地，blue_edges 中的每一个 [i, j] 对表示从节点 i 到节点 j 的蓝色有向边。
返回长度为 n 的数组 answer，其中 answer[X] 是从节点 0 到节点 X 的红色边和蓝色边交替出现的最短路径的长度。如果不存在这样的路径，那么 answer[x] = -1。

示例 1：

输入：n = 3, red_edges = [[0,1],[1,2]], blue_edges = []
输出：[0,1,-1]
示例 2：

输入：n = 3, red_edges = [[0,1]], blue_edges = [[2,1]]
输出：[0,1,-1]
示例 3：

输入：n = 3, red_edges = [[1,0]], blue_edges = [[2,1]]
输出：[0,-1,-1]
示例 4：

输入：n = 3, red_edges = [[0,1]], blue_edges = [[1,2]]
输出：[0,1,2]
示例 5：

输入：n = 3, red_edges = [[0,1],[0,2]], blue_edges = [[1,0]]
输出：[0,1,1]

提示：
* 1 <= n <= 100
* red_edges.length <= 400
* blue_edges.length <= 400
* red_edges[i].length == blue_edges[i].length == 2
* 0 <= red_edges[i][j], blue_edges[i][j] < n

思路1.0：

采用Dijkstra算法，从节点0为起点，根据题目所给信息选择一条颜色作为第一条边，然后下一次就在另一条颜色的可选路径中选择边。

思路2.0：

没有权值，需要记录高度，还有我不小心瞥到题解里说要用深度遍历，所以。。。

代码2.0（未过）：

class Solution{
public:
    vector<int> ans;        //存储结果
    vector<vector<bool>> isVisited;     //记录已访问过的边
    int len;        //数组边长
    void DFS(int start,bool isRed,int dis,const vector<vector<bool>>& redArr,  const vector<vector<bool>>& blueArr) {
        if (isRed) {
            for (int j = 0; j < len; ++j) {
                if (redArr[start][j] == true) {
                    if (!isVisited[start][j]) {
                        ans[j] = min(ans[j],dis);
                        isVisited[start][j] = true;
                        DFS(j, !isRed, dis + 1, redArr, blueArr);
                    }
                }
            }
        }
        else{
            for (int j = 0; j < len; ++j) {
                if (blueArr[start][j] == true) {
                    if (!isVisited[start][j]) {
                        ans[j] = min(ans[j], dis);
                        isVisited[start][j] = true;
                        DFS(j, !isRed, dis + 1, redArr, blueArr);
                    }
                }
            }
        }
    }
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& red_edges,  vector<vector<int>>& blue_edges) {
        vector<vector<bool>> redArray(n, vector<bool>(n, false));
        vector<vector<bool>> blueArray(n, vector<bool>(n, false));
        //初始化
        len = n;
        ans.resize(n, INT_MAX);
        ans[0] = 0;
        isVisited.resize(n, vector<bool>(n, true));
        for (const auto& i : red_edges) {
            isVisited[i[0]][i[1]] = false;
            redArray[i[0]][i[1]] = true;
        }
        for (const auto& i : blue_edges) {
            isVisited[i[0]][i[1]] = false;
            blueArray[i[0]][i[1]] = true;
        }
        //开始深度遍历
        DFS(0, true, 1, redArray, blueArray);
        DFS(0, false, 1, redArray, blueArray);
        for (auto& i : ans) {
            if (i == INT_MAX)
                i = -1;
        }
        return ans;
    }
};

这类题目自己还是太菜，很多如环路啊啥的，在一开始都没考虑周全，使得中间一直加加改改，还缺胳膊少腿，体验极其糟糕。存在环路的题目的套路还没摸清，接下来要多刷一些存在环路的题目。

思路3.0（已看题解）：

使用动态规划的思想，用一个2xN的数组，存储以红蓝两种入度的节点 离起点的最短距离，判断条件 if(rst[parent]+1 < rst[children]) rst[children] = rst[parent]+1;
而最终结果就是每个节点的两种链接方式的较小值。

代码3.0；

class Solution {
public:
        //存储着每个节点以红蓝两种入度的，离起点最近的距离
    void DFS(const vector<vector<vector<int>>>& twoArray, int col, int start,  vector<vector<int>>& rst) {
        for (const auto& i : twoArray[col][start]) {
            //第一次赋值，也为了接下来在所有结果中取得最小值
            if (rst[start][col] + 1 < rst[i][!col]) {
                rst[i][!col] = rst[start][col] + 1;
                DFS(twoArray, !col, i, rst);
            }
        }
    }
    vector<int> shortestAlternatingPaths(int n, vector<vector<int>>& red_edges,  vector<vector<int>>& blue_edges) {
        vector<vector<int>> redArray(n);
        vector<vector<int>> blueArray(n);
        for (const auto& i : red_edges) {   
            redArray[i[0]].push_back(i[1]);
        }
        for (const auto& i : blue_edges) {
            blueArray[i[0]].push_back(i[1]);
        }
        vector<vector<vector<int>>> twoArray{ redArray, blueArray };
        vector<vector<int>> rst(n, { INT_MAX,INT_MAX });
        rst[0] = { 0,0 };
        //开始深度遍历
        DFS(twoArray, 0, 0, rst);
        DFS(twoArray, 1, 0, rst);
        //在rst中得出结果
        vector<int> ans(n);
        for (int i = 0; i < n; ++i) {
            ans[i] = min(rst[i][0], rst[i][1]);
            if (ans[i] == INT_MAX)
                ans[i] = -1;
        }
        return ans;
    }
};