【图】可能的二分法

题目描述

给定一组 n 人（编号为 1, 2, ..., n）， 我们想把每个人分进任意大小的两组。每个人都可能不喜欢其他人，那么他们不应该属于同一组。

给定整数 n 和数组 dislikes ，其中 dislikes[i] = [ai, bi] ，表示不允许将编号为 ai 和  bi的人归入同一组。当可以用这种方法将所有人分进两组时，返回 true；否则返回 false。

示例 1：

输入：n = 4, dislikes = [[1,2],[1,3],[2,4]]
输出：true
解释：group1 [1,4], group2 [2,3]

解题思路

最开始我认为只要有环就说明不满足条件，实际情况要分为奇数个节点的环还是偶数个节点的环。

这里先举例说明：

case1: 奇数个元素形成环

输入：n = 3, dislikes = [[1,2],[2,3],[1,3]]
输出：false

解释：group1   group2

                    1            2

                    3            2

---------------------------------------

由于 [1,3] 导致最终不能分成2组。

case2: 偶数个元素形成环

输入：n = 4, dislikes = [[1,2],[2,3],[3,4],[1,4]]
输出：false

解释：group1   group2

                    1            2

                    3            2

                    3            4

最终给出来的解法是使用标记法，思路如下：

• 准备一个MAP，key为Integer，value为List<Integer>;
• 遍历dislikes，将dislikes中的元素，写入到MAP中；
• 准备一个int colored[]，初始化成-1，用于标记这个元素被标记为0 还是 1.
• 定义int i，从1到n做遍历，遍历逻辑如下：
  • 如果colored[i] = -1 ,  说明没有标记过，令colored[i]=0；
  • 调用一个dfs(i, map, colored)遍历方法，判断是否满足条件，如果返回false，则直接返回false；
• 如果之前没有返回过结果直接返回true；

接着构造dfs遍历方法，判断是否满足条件，方法定义：private boolean dfs(int v, Map<Integer, Set<Integer>> map, int[] colored)，思路如下：

• 从map中获取所有的元素：Set<Integer> set = map.get(v);
• 执行遍历set，遍历如下：
  • set中的元素dislike，如果colored[dislike] == -1 , 那么执行colored[dislike]=1-colored[v]，递归调用dfs，如果dsf返回false，直接返回false；
  • set中的元素dislike，colored[dislike]==colored[v]，执法返回false；
• 如果上述情况都没有返回，则返回true

代码实现

import java.util.*;

class Solution1 {
    public boolean possibleBipartition(int n, int[][] dislikes) {

        Map<Integer, Set<Integer>> map = new HashMap<>();
        for (int[] dislike : dislikes) {
            Set<Integer> set1 = map.getOrDefault(dislike[0], new HashSet<>());
            set1.add(dislike[1]);
            map.put(dislike[0], set1);

            Set<Integer> set2 = map.getOrDefault(dislike[1], new HashSet<>());
            set2.add(dislike[0]);
            map.put(dislike[1], set2);
        }

        int colored[] = new int[n + 1];
        Arrays.fill(colored, -1);

        for (int i = 1; i <= n; i++) {
            if (colored[i] == -1) {
                colored[i] = 0;
                if (!dfs(i, map, colored)) {
                    return false;
                }
            }
        }

        return true;
    }

    private boolean dfs(int v, Map<Integer, Set<Integer>> map, int[] colored) {

        Set<Integer> set = map.get(v);
        if (set != null) {
            for (Integer dislike : set) {
                if (colored[dislike] == -1) {
                    colored[dislike] = 1 - colored[v];
                    if (!dfs(dislike, map, colored)) {
                        return false;
                    }
                } else if (colored[dislike] == colored[v]) {
                    return false;
                }
            }
        }

        return true;

    }

    public static void main(String[] args) {
        Solution1 solution = new Solution1();

        System.out.println(solution.possibleBipartition(4, new int[][]{
                {1, 2}, {1, 3}, {2, 4}
        }));
    }
}

由于这道题的元素是确定1到n，这里我们可以不使用map，改成List<Integer>[] 来解决问题，修改后代码如下：

import java.util.*;

class Solution {
    public boolean possibleBipartition(int n, int[][] dislikes) {

        List<Integer>[] listArray = new List[n + 1];

        for (int i = 0; i <= n; i++) {
            listArray[i] = new ArrayList<>();
        }

        for (int[] dislike : dislikes) {
            listArray[dislike[0]].add(dislike[1]);
            listArray[dislike[1]].add(dislike[0]);
        }

        int colored[] = new int[n + 1];
        Arrays.fill(colored, -1);

        for (int i = 1; i <= n; i++) {
            if (colored[i] == -1) {
                colored[i] = 0;
                if (!dfs(i, listArray, colored)) {
                    return false;
                }
            }
        }

        return true;
    }

    private boolean dfs(int v, List<Integer>[] cache, int[] colored) {

        List<Integer> set = cache[v];
        for (Integer dislike : set) {
            if (colored[dislike] == -1) {
                colored[dislike] = 1 - colored[v];
                if (!dfs(dislike, cache, colored)) {
                    return false;
                }
            } else if (colored[dislike] == colored[v]) {
                return false;
            }
        }
        return true;
    }

    public static void main(String[] args) {
        Solution solution = new Solution();

        System.out.println(solution.possibleBipartition(4, new int[][]{
                {1, 2}, {1, 3}, {2, 4}
        }));
    }
}

第一种的耗时在46 ms，第二种的耗时在11 ms，优化还是很明显的。

 

总结

这道题是一道图论相关的题，核心点是要熟悉二分图的处理思路，如果之前没有了解过，完全作为一个新问题做解答还是比较复杂的。工作的时候，基本没有遇到过leetcode的问题，但做题的核心还是锻炼思维，开拓眼界。如果有更加简洁、高效的解题思路欢迎回复。