Question

Consider that I have a map of sets of values to values, in Java the type of this map would be:

Map<Set<Object>, Object> setToObjMap;

Given a new set of objects set, I wish to find all values in the setToObjMap where the associated key is a subset of a “search set”.

So, for example, if my map was:

["telephone", "hat"] -> "book"
["laugh", "fry", "mouse"] -> "house"
["dog", "cat"] -> "monster"

Then, given the search set ["telephone", "hat", "book", "dog", "cat"] I would retrieve the values “book” and “monster”.

In practice there may be tens of thousands of entries in the setToObjectMap, with tens of thousands of possible values in the sets. The search set will typically have around 10 elements.

I’m hoping there is an efficient way to do this that doesn’t require iterating through all keys in the map. Can anyone offer any suggestions?

Answer 1

You can create a lookup data structure

Map<String,List<Finder>>

With Finder having an int count and max, and a res word. Take note that the list is there to take care of the case where many sets in setToObjMap can share the same word, which is not in your examples.

"telephone" -> [{res:"book",count=0,max=2}]
"hat" -> same object as above
"laugh" -> [{res:"house",count=0,max=3}]
...

This lookup collection is quick to build and even quicker to flush after a lookup.

The lookup algorithm iterates through set, for each word, and each Finder for this word, it increases the count variable. Second pass, take all values of the lookup map, if count==max, put res in the result.

Init algorithm:

for Entry e in setToObjMap
  Finder f = new Finder(e.value, 0, e.key.size) // res, count, max
  for String word in e.key
    lookup.get(word).add(f)

Lookup algorithm:

for String word in set
  for Finder f in lookup.get(word)
    f.count ++
for Finder f in lookup.values()
  if (f.count==f.max)
    res.add(f.res)

Reset algorithm:

for Finder f in lookup.values()
    f.count = 0

As for the complexity, if n is the number of elements in set and m the number of values in setToObjMap, the complexity will be O(n+m)