Reason 1: Question 1 has already been discounted

Reason 2: Question 3 is also strange.  The videos showed that the running time of BFS is O(m + n) in the general case, so we don't need to look at any specific code.  The first two answers can't be right.  Consider the star graph.

The central node is handled (i.e., either put on the tovisit list or ignored because it is in the explored set) an astonishing 7 times, which is greater than the "at most twice" or "at most once" limit imposed in the answer.

The last two can't be the answer either.  Consider the singleton graph.

A graph of one node (0 edges).  Clearly, performing a BFS on this graph is O(n) because O(0) doesn't make too much sense.

Reason 3: Question 4 is also weird.  The search method belongs to graph.  Since the search is a part of graph, we could technically not count it depending on the interpretation of the question.  Also, it says not to consider the call stack, but since this is coded in Java, to run the code, the JVM is taking up storage.

Reason 4: I don't like question 5 either.  If it is referring to the storage used in storage, then it should be 0 because storage is local to the search and thus goes uncounted.

Reason 5: Questions 4, 5 and 6 ask about maximum amount of storage.  If we take maximum to mean an upper bound on the amount of storage, we could just choose the option that would require the most memory and be done for the day.  Perhaps the question meant the minimum amount of storage that the searches would need to run? or the maximum amount of storage used when running the search?

Reason 6: There are 5 reasons(listed above) why this quiz was confusing.

Reason 7: There are 6 reasons(listed above) why this quiz was baffling.

Reason 8. There are 7 reasons(listed above) why this quiz was bewildering.

Reason 9: There are 8 reasons(listed above) why this quiz was confounding.

Reason 10: I spent the greater part of my test time typing this up.

I think an equivalent rewording of questions 4-6 would be something like "In order to run Graph.search, a certain amount of non-local storage is needed.  Ignoring the graph itself, the call stack, the explored set and visited list, how much non-local storage is this?"

Worded like this, it is more obvious that we would have to count the Node and Edge objects along with the JVM.  The Node and Edge objects are needed because they define the graph being searched.  The Node and Edge objects are not local to Graph.search, so they fit the non-local criteria.  Node and Edge are also separate classes from the graph itself.

Well, it was worth a shot