📜  解决集合覆盖问题的Java程序

📅  最后修改于: 2022-05-13 01:55:47.169000             🧑  作者: Mango

解决集合覆盖问题的Java程序

问题陈述:给定一组元素 1 到 n 和一个由 n 个集合组成的集合 S,它们的并集等于一切,问题是在一对 2 中找到等于该集合的子集的最小数目。

概念:这个问题是解决集合问题。我们可以使用排列组合来解决这个问题。

插图:

方法:

  1. 首先,我们在数组中给出可能的组合集合和数目作为输入。
  2. 创建一个列表并存储所有这些。
  3. 取一个集合并将解决方案存储在该集合中。
  4. 调用最短组合函数
  5. 此函数将集合作为输入并在大小大于 20 时引发异常
  6. 迭代所有可能组合的大小和新的 Set
  7. 然后将值右移,然后将其结束为 1,我们将所有解决方案添加到数组 List 中。
  8. 这个数组List是通过消除List中的重复值返回的

执行:

例子

Java
// Java Program to Solve Set Cover Problem
// assuming at Maximum 2 Elements in a Subset
  
// Importing input output classes
import java.io.*;
// Importing necessaely required utility classes
// from java.util package
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
  
// Main class
public class GFG {
  
    // Interface
    // Declaring the interface thereby taking
    // abstract methods of the interface
    interface Filter {
  
        boolean matches(T t);
    }
  
    // Method 1
    // Declaring a method-'shortcombo'
    // Declaring in form of set also returning a set
    private static  Set
    shortcombo(Filter > filter, List sets)
    {
        // Taking the size of the set
        final int size = sets.size();
  
        // Condition check
        // If the size of the set is greater than 25
        // We throw an exception like too many combinations
        if (size > 20)
            throw new IllegalArgumentException(
                "Too many Combinations");
  
        // Now the comb will left shift 1 time of size
        int comb = 1 << size;
  
        // Taking a set with reg=ference possible
        // this Arraylist will contain all the possible
        // solution
        List > possible = new ArrayList >();
  
        // Taking a loop which iterates till comb
        for (int i = 0; i < comb; i++) {
  
            // Taking a lInkedHashSet of reference
            // combination
            Set combination = new LinkedHashSet();
  
            // Taking a loop and iterating till size
            for (int j = 0; j < size; j++) {
  
                // If now we right shift i and j
                // and then ending it with 1
  
                // This possible logic will give us how many
                // combinations are possible
                if (((i >> j) & 1) != 0)
  
                    // Now the combinations are added to the
                    // set
                    combination.add(sets.get(j));
            }
  
            // It is added to the possible reference
            possible.add(combination);
        }
  
        // Collections can be now sorted accordingly
        // using the sort() method over Collections class 
        Collections.sort(
            possible, new Comparator >() {
                
                // We can find the minimum length by taking
                // the difference between sizes of possible
                // list
                public int compare(Set a1, Set a2)
                {
                    return a1.size() - a2.size();
                }
            });
  
        // Now we take the iteration till possible
        for (Set possibleSol : possible) {
  
            // Then we check for matching of the possible
            // solution
  
            // If it does we return the solution
            // If it doesnot we return null
            if (filter.matches(possibleSol))
                return possibleSol;
        }
        return null;
    }
  
    // Method 2
    // Main method
    public static void main(String[] args)
    {
  
        // Taking all the the possible combinations
        // Custom entries in array
        Integer[][] all = {
            { 1, 2 },  { 3, 4 }, { 8, 9 },
            { 10, 7 }, { 5, 8 }, { 11, 6 },
            { 4, 5 },  { 6, 7 }, { 10, 11 },
        };
  
        // Here is the list of numbers to be chosen from
        // Again, custom entries in array
        Integer[] solution
            = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 };
  
        // Here let us take set as an object of an ArrayList
        List > sets
            = new ArrayList >();
  
        // Now taking an array of the function all
        for (Integer[] array : all)
  
            // Now taking those elements and adding them to
            // an LinkedHashSet
            sets.add(new LinkedHashSet(
                Arrays.asList(array)));
  
        // Now taking a set integer sol and
        // setting it as solution
        final Set sol = new LinkedHashSet(
            Arrays.asList(solution));
  
        // Now taking a filter to check the values
        Filter > > filter
            = new Filter > >() {
                  // Now taking boolean function matches
  
                  // This function helps iterate all values
                  // over the inetegrs variable which adds
                  // up all that to an union which will give
                  // us the desired result
                  public boolean matches(
                      Set > integers)
                  {
                      Set union
                          = new LinkedHashSet();
  
                      // Iterating using for-each loop
                      for (Set ints : integers)
                          union.addAll(ints);
  
                      return union.equals(sol);
                  }
              };
  
        // Now the below set will call the short combo
        // function This function will sort the shortest
        // combo
        Set > firstSol
            = shortcombo(filter, sets);
  
        // Print and display out the same
        System.out.println("The short combination was : "
                           + firstSol);
    }
}


输出
The short combination was : [[1, 2], [3, 4], [8, 9], [10, 7], [5, 8], [11, 6]]