Joint search set

summary

• Function: support the rapid merging and searching of collections, with time complexity of O (1)
• Two basic methods: isSameSet: whether two sets belong to the same set; union: merge two sets
• The traditional data structure can not support the rapidity of the two methods at the same time. For example, the linked list structure can support fast consolidation, but it cannot support fast search; Hash table: supports fast lookup, but cannot support fast merge

Solution

(1) At the beginning, the pointer of each node points to itself
(2) If it points to Union (1, 3): the operation of merging the sets of 1 and 3 will point the pointer of 3 to 1. At this time, 1 is the vertex

(3) If multiple sets are merged, the vertex with less nodes should point to the vertex with more nodes. For example, union(1,2) is to change the pointer of 2

(4) isSameSet: the method can determine whether the top nodes are the same. For example, in the above figure: the return value of isSameSet(2, 6) is false; If in the following figure: the return value of isSameSet(2, 6) is true.

(5) Optimization problem (path compression): if the chain is too long, the time complexity will increase when using isSameSet. Using findHead method, the parent node of each node will eventually become the highest vertex in the process

After using findHead, connect 1 and 2 directly to the vertex

realization

    public static class Element<V>{
        //Packaging of samples to form elements
        //Internal use Element
        //External use V, use of generic classes
        public V value;

        public Element(V value){
         this.value = value;
        }
    }

    public static class UnionFindSet<V>{
        //Joint search set
        public HashMap<V, Element<V>> elementMap;
        //key is the sample, and value is the packaged element corresponding to the sample, which is convenient to judge whether the sample exists
        public HashMap<Element<V>, Element<V>> fatherMap;
        //key is the element and value is the parent element of the element
        public HashMap<Element<V>, Integer> sizeMap;
        //key is the vertex element of a set (representing the set), and value is the size of the set

        public UnionFindSet(List<V> list){
            //Initialization: requires the user to provide a collection
            elementMap = new HashMap<>();
            fatherMap = new HashMap<>();
            sizeMap = new HashMap<>();
            for (V value : list){
                //Traversal set
                //They all start as a set
                Element<V> element = new Element<>(value);
                elementMap.put(value, element);
                fatherMap.put(element, element);
                sizeMap.put(element, 1);
            }
        }

        private Element<V> findHead(Element<V> element){
            //A vertex element of a collection was found
            //And all the parent nodes of the node and its upper nodes are changed into vertex nodes
            Stack<Element<V>> stack = new Stack<>();
            while (element != fatherMap.get(element)){
                //Traverse to vertex element
                stack.push(element);
                element = fatherMap.get(element);
            }
            while (!stack.isEmpty()){
                //Modify this node and the parent node of the node above it to all vertex nodes
                fatherMap.put(stack.pop(), element);
            }
            return element;
        }

        public boolean isSameSet(V a, V b){
            //Judge whether a and b belong to the same set
            if (elementMap.containsKey(a) && elementMap.containsKey(b)){
                //a. b all exist in the set, and judge whether the vertex elements are the same
                return findHead(elementMap.get(a)) == findHead(elementMap.get(b));
            }
            return false;
        }

        public void union(V a, V b){
            if (!elementMap.containsKey(a) || ! elementMap.containsKey(b)){
                //If it does not exist in the set
                return;
            }
            if (isSameSet(a, b)){
                //Belong to the same set
                return;
            }
            //a. Top element of b
            Element<V> aH = findHead(elementMap.get(a));
            Element<V> bH = findHead(elementMap.get(b));
            //a. Distinction between larger sets and smaller sets in b
            Element<V> big = sizeMap.get(aH) >= sizeMap.get(bH) ? aH : bH;
            Element<V> small = big == aH ? bH : aH;
            //Connect smaller vertices to larger vertices
            fatherMap.put(small, big);
            sizeMap.put(big, sizeMap.get(small) + sizeMap.get(big));
            sizeMap.remove(small);
        }
    }

Title: Island problem

thinking

Ergodic matrix turns all connected 1 into 2. There are several islands in the process of turning 2 several times

    public static int countIslands(int[][] land){
        if (land == null || land[0] == null){
            return 0;
        }
        int x = land.length;
        int y = land[1].length;
        int res = 0;
        for (int i = 0; i < x; i++){
            for (int j = 0; j < y; j++){
                if (land[i][j] == 1){
                    //ergodic matrix 
                    res++;
                    infect(land, i, j, x, y);
                }
            }
        }
        return res;
    }

    public static void infect(int[][] land, int i, int j, int x, int y){
        //Change all connected as 1 into 2
        if (i < 0 || i >= x || j < 0 || j >= y || land[i][j] != 1){
            //End condition
            return;
        }
        land[i][j] = 2;
        //Traverse around
        infect(land, i + 1, j, x, y);
        infect(land, i - 1, j, x, y);
        infect(land, i, j + 1, x, y);
        infect(land, i, j - 1, x, y);
    }

    public static void main(String[] args) {
        int[][] land = {{0, 0, 1, 0, 1, 0},
                        {1, 1, 1, 0, 1, 0},
                        {1, 0, 0, 1, 0, 0},
                        {0, 0, 0, 0, 0, 0}};
        System.out.println(countIslands(land));
    }

• Result demonstration:
  
• Time complexity: O (X * Y) x: height of matrix, Y: width of matrix

Advanced: application of joint search set

(1) If the graph is particularly large, divide the graph, and the divided graph can process data in the subgraph at the same time to achieve the effect of parallelism
(2) However, the division map may increase the number of islands
(3) The boundary needs to be processed, and the points to which the boundary becomes in the same connection process are taken as a set
(4) Judge the connected points of the divided subgraph through the line. If the points of the subgraph have adjacent attributes, check whether they belong to a set. If not, the two sets are merged, and the number of graphs is reduced by one