In modern computer applications graphs are needed to represent numerous types of data. Graphs represent our social networks in social media applications, navigation within a website, and any other data which focuses on the relationship between items. Understanding associations between elements is crucial to the development of algorithms which use these relationships to make decisions without human involvement. These algorithms recommend new connections on social media, suggest new products for purchase by a customer, serve relevant ads to users, and many of the other personalization strategies characteristic of modern software products. In these learning and intelligent algorithms, partitioning cite{karypis1995metis, kwatra2003graphcut, leskovec2009community} is often a crucial component in understanding the similarities between unique elements.\Defined partitions can be used to quickly designate what elements belong to a category or have certain properties at the expense of significant preliminary computation. Unfortunately, the processes used to create partitions are often extremely expensive, and in many dynamic programs partitions must be regularly reevaluated. In an online marketplace with hundreds of purchases per day partitions which are created one day may quickly fall out of relevance. New products may be added whose relationship to other nodes needs to be evaluated, or user purchase trends may change altering our partitions. In most partition algorithms updating means reevaluating from the beginning, requiring significant overhead and repeated computation.\ Our research focuses on how partitions can be updated with limited computation when a new node is added. Specifically, given a partition that was created from a set of marked nodes the research asks how one can add another node to that partition if it is marked after the partitions initial creation. As an example, suppose the relationship between products that have been often bought in tandem has been established. If several new products begin to be purchased alongside those already partitioned products, how can they be added to that partition for providing product recommendations without having to recompute the subgraph.\Several algorithms have been created to form partitions in a graph cite{berkhin2006survey, ng1994cient, huang1997fast, ding2001min, slota2014pulp} which contain a certain set of marked nodes. These algorithms create a subgraph known as a minimum spanning tree or an arborescence cite{kruskal1956shortest, prim1957shortest}. Dot2Dot algorithm cite{akoglu2013mining} efficiently finds the minimum arborescence of a graph with marked nodes. However, to add another marked node to this subgraph requires the algorithm be rerun with the union of the sets of marked nodes. This leads to unnecessary reiteration of operations with a large time complexity. No algorithm could be found which allows for the addition of new nodes to a partition without the reproduction of all computation steps.\Generally algorithms similar to Dot2Dot have five approaches. They all are used to find the set of trees with minimum total cost on marked nodes. egin{itemize} item Finding Bounded Path Length: Finding shortest path between terminal nodes using BFS-like expansion till the threshold path length, $log|V|$ (where $|V|$ indicates the total number of vertices in graph), is reached. item Connected Components: The algorithm detects connected components and puts all directly connected terminal nodes in one group. Nodes which do not satisfy both properties are placed into separate groups. item Minimum Arborescence: The algorithm uses the transitive closure graph of terminals to find the minimum cost graphs. The algorithm calculates bounded path lengths and connected components. item 1-Level Tree: The algorithm returns a forest of Steiner trees by building a level 1 tree from the transitive closure graph by considering each terminal node as root to find the shortest path on transformed graph.  item 2-Level Tree: This algorithm generalizes 1-level tree algorithm to k-level trees. This is achieved by reducing the cost of 1-level trees successively in each step. end{itemize}