Dotted lines are notifications (for example, an observer pattern), and solid lines are direct knowledge (i.e. compilation of time dependencies). Data change notifications flow in dashed lines. A solid line with an arrow says that one component has knowledge of another and can directly push data. The dashed line is a looser link because the sender fires the event, but does not know the nature of the receiver of this event, which is hidden behind the event listener interface (if you are running event-driven versions of these templates).
The point of templates is to create order by avoiding spaghetti code, where everything interacts directly with everything else. Thus, diagrams are really just hints of what should be separated from what. Like any such diagrams, they are difficult to find without a detailed explanation, and they only really indicate what you should strive for; certain frameworks have more or less support for doing things in a "clean way." As components are loaded and connected together, they are not included in the scope of these diagrams; only what happens when the user enters data or the model is updated through another component of the view. Thus, actual classes can compile time dependencies and code to initialize objects that seem to break diagrams; however, while this is just an “initialization” code that connects things together, it may not be material.
Here is a presentation that tries to explain MVP, MVC (or perhaps MVVMP) and MVVM (aka MVB) in terms of some less formal diagrams that show what compiles what and who notifies whom with event listeners of the observer pattern. This is relevant for your question, as it sets the context for what patterns they seek to achieve, which helps in interpreting the diagrams in your question:
Design Patterns in ZK: Java MVVM as Model-View-Binder, Simon Massey
Here's an article in which there are no diagrams, but which make the same simple screen three times using three different desktop templates controlled by a graphical interface (which can be freely described as MVP, MVVM, and MVC / MVVMP). One of the key points of confusion regarding M__ templates is that they are overloaded with nicknames and hardly describe the real picture. The article is relevant to your question as it follows Martin Fowlers' formal description of patterns that are more clear and less confusing than their names "M__":
Implement event driven graphical GUIs using the ZK Java AJAX platform, Simon Massey
While this article does not specifically answer your question, it gives a comparison of the three template implementations you are asking for and compares them; therefore, he will probably shed some light on choosing templates that should describe the diagrams. Of course, if you choose a different structure to implement the three templates, the example code will look different; but hopefully the same trade-offs will be considered as examples shown in this article.