g0801_0900.s0886_possible_bipartition.Solution Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of leetcode-in-java21 Show documentation
Java-based LeetCode algorithm problem solutions, regularly updated
There is a newer version: 1.38
package g0801_0900.s0886_possible_bipartition;

// #Medium #Depth_First_Search #Breadth_First_Search #Graph #Union_Find
// #Graph_Theory_I_Day_14_Graph_Theory #2022_03_28_Time_20_ms_(80.12%)_Space_75.6_MB_(32.57%)

import java.util.ArrayList;
import java.util.List;

/**
 * 886 - Possible Bipartition\.
 *
 * Medium
 *
 * We want to split a group of `n` people (labeled from `1` to `n`) into two groups of **any size**. Each person may dislike some other people, and they should not go into the same group.
 *
 * Given the integer `n` and the array `dislikes` where dislikes[i] = [a_i, b_i] indicates that the person labeled a_i does not like the person labeled b_i, return `true` _if it is possible to split everyone into two groups in this way_.
 *
 * **Example 1:**
 *
 * **Input:** n = 4, dislikes = \[\[1,2],[1,3],[2,4]]
 *
 * **Output:** true
 *
 * **Explanation:** group1 [1,4] and group2 [2,3]. 
 *
 * **Example 2:**
 *
 * **Input:** n = 3, dislikes = \[\[1,2],[1,3],[2,3]]
 *
 * **Output:** false 
 *
 * **Example 3:**
 *
 * **Input:** n = 5, dislikes = \[\[1,2],[2,3],[3,4],[4,5],[1,5]]
 *
 * **Output:** false 
 *
 * **Constraints:**
 *
 * *   `1 <= n <= 2000`
 * *   0 <= dislikes.length <= 10⁴
 * *   `dislikes[i].length == 2`
 * *   `1 <= dislikes[i][j] <= n`
 * *   a_i < b_i
 * *   All the pairs of `dislikes` are **unique**.
**/
@SuppressWarnings("unchecked")
public class Solution {
    public boolean possibleBipartition(int n, int[][] dislikes) {
        // build graph
        Graph g = new Graph(n);
        for (int[] dislike : dislikes) {
            g.addEdge(dislike[0] - 1, dislike[1] - 1);
        }
        boolean[] marked = new boolean[n];
        boolean[] colors = new boolean[n];
        for (int v = 0; v < n; v++) {
            if (!marked[v] && !checkBipartiteDFS(g, marked, colors, v)) {
                // No need to run on other connected components if one component has failed.
                return false;
            }
        }
        return true;
    }

    private boolean checkBipartiteDFS(Graph g, boolean[] marked, boolean[] colors, int v) {
        marked[v] = true;
        for (int w : g.adj(v)) {
            if (!marked[w]) {
                colors[w] = !colors[v];
                if (!checkBipartiteDFS(g, marked, colors, w)) {
                    // this is to break for other neighbours
                    return false;
                }
            } else if (colors[v] == colors[w]) {
                return false;
            }
        }
        return true;
    }

    private static class Graph {
        private ArrayList[] adj;

        public Graph(int v) {
            adj = new ArrayList[v];
            for (int i = 0; i < v; i++) {
                adj[i] = new ArrayList<>();
            }
        }

        private void addEdge(int v, int w) {
            adj[v].add(w);
            adj[w].add(v);
        }

        private List adj(int v) {
            return adj[v];
        }
    }
}