【leetcode】图---简单（1）997. 找到小镇的法官_出入度（2）1042. 不邻接植花_dfs涂色&判连通分支

997、在一个小镇里，按从 1 到 N 标记了 N 个人。传言称，这些人中有一个是小镇上的秘密法官。

如果小镇的法官真的存在，那么：

1.     小镇的法官不相信任何人。
2.     每个人（除了小镇法官外）都信任小镇的法官。
3.     只有一个人同时满足属性 1 和属性 2 。

给定数组 trust，该数组由信任对 trust[i] = [a, b] 组成，表示标记为 a 的人信任标记为 b 的人。

如果小镇存在秘密法官并且可以确定他的身份，请返回该法官的标记。否则，返回 -1。

示例 1：

输入：N = 2, trust = [[1,2]]
输出：2

示例 2：

输入：N = 3, trust = [[1,3],[2,3]]
输出：3

图 ，出入度 

// 找出度为0，入度为n-1
class Solution {
public:
    int findJudge(int N, vector<vector<int>>& trust) {
        vector<bool> D_out(N + 1, false);
        vector<int> D_in(N + 1, 0);
        for(int i = 0; i < trust.size(); i++){
            D_out[trust[i][0]] = true;
            D_in[trust[i][1]]++;
        }
        int id = -1;
        for(int i = 1; i <= N; i++){
            if(!D_out[i] && D_in[i] == N - 1){
                if(id != -1) return -1;
                else id = i;
            }
        }
        return id;
    }
};

 结果：

执行用时：460 ms, 在所有 C++ 提交中击败了43.78% 的用户

内存消耗：60.9 MB, 在所有 C++ 提交中击败了16.67% 的用户

 

修改：用一个数组表示，出入度的和。N个点中，只有可能存在一个点，入度为N-1.

// 找出度为0，入度为n-1
class Solution {
public:
    int findJudge(int N, vector<vector<int>>& trust) {
        vector<int> degree(N + 1, 0);  // 出入度和
        for(int i = 0; i < trust.size(); i++){
           degree[trust[i][0]]--;   // 出度减
           degree[trust[i][1]]++;   // 入度加
        }
        for(int i = 1; i <= N; i++){
          if(degree[i] == N - 1) return i;  //  N个点，只有可能一个入度为N-1
        }
        return -1;
    }
};

结果：

执行用时：484 ms, 在所有 C++ 提交中击败了34.41% 的用户

内存消耗：60.9 MB, 在所有 C++ 提交中击败了16.67% 的用户

 

1042、有 N 个花园，按从 1 到 N 标记。在每个花园中，你打算种下四种花之一。

paths[i] = [x, y] 描述了花园 x 到花园 y 的双向路径。

另外，没有花园有 3 条以上的路径可以进入或者离开。

你需要为每个花园选择一种花，使得通过路径相连的任何两个花园中的花的种类互不相同。

以数组形式返回选择的方案作为答案 answer，其中 answer[i] 为在第 (i+1) 个花园中种植的花的种类。花的种类用  1, 2, 3, 4 表示。保证存在答案。

示例 1：

输入：N = 3, paths = [[1,2],[2,3],[3,1]]
输出：[1,2,3]

示例 2：

输入：N = 4, paths = [[1,2],[3,4]]
输出：[1,2,1,2]

图涂色，dfs涂色，dfs判联通分支

Attention：此处图的每个节点的相邻节点用set存，为了保证相邻节点排序为升序，涂色先涂小号节点。

class Solution {
public:
    vector<set<int>> gra;
    vector<int> ans;    // ans[i]:i+1号花园种植花卉种类
    bool dfs(int x, int c){
        ans[x - 1] = c;
        for(auto &i:gra[x]){    // 对点i相邻点涂色，候选色为1-4
            if(ans[i-1] == c) return false;   // 相邻点同色，返回，此次涂色失败
            if(ans[i-1] > 0) continue;  // 相邻点异色，无需涂色，继续下一个
            for(int color = 1; color < 5; color++){
                if(color == c) continue;
                if(dfs(i, color)) break;;
            }
        }
        return true; // 当x为c色，其相邻的点能正常涂色，则x为c色成立
    }

    vector<int> gardenNoAdj(int N, vector<vector<int>>& paths) {
        gra.resize(N + 1);
        ans.resize(N, -1);
        for(auto &it:paths){
            gra[it[0]].insert(it[1]);
            gra[it[1]].insert(it[0]);
        }
        for(int i = 0; i < N; i++){
            if(ans[i] < 0) dfs(i + 1, 1);
        }
        return ans;
    }
};

结果：

执行用时：300 ms, 在所有 C++ 提交中击败了91.28% 的用户

内存消耗：51 MB, 在所有 C++ 提交中击败了100.00% 的用户