DepthFirstSearchSkeletonAlgorithm

java.lang.Object
- cusack.hcg.graph.algorithm.AbstractAlgorithm<PuzzleInstance>
- - cusack.hcg.graph.algorithm.standard.DepthFirstSearchSkeletonAlgorithm

All Implemented Interfaces:

AlgorithmInterface<PuzzleInstance>

Direct Known Subclasses:

ContainsCycle
```
public abstract class DepthFirstSearchSkeletonAlgorithm
extends AbstractAlgorithm<PuzzleInstance>
```
A skeleton Depth First Search algorithm. This implementation is based on the one from Chapter 5 of "The Algorithm Design Manual" by Steven Skiena. Note that this version begins from vertex 0 unless it is otherwise set (using setSource). It also does NOT start the algorithm from every vertex like some versions do. Thus, it only discovered vertices reachable from the first vertex. This should be fine for undirected connected graphs. ****It may not be O.K. for unconnected graphs or digraphs.**** 12/9/16

Author:

cusack

Constructor Summary

Constructors
Constructor and Description

DepthFirstSearchSkeletonAlgorithm()

Constructors
Constructor and Description
`DepthFirstSearchSkeletonAlgorithm()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`java.lang.String`	`argumentFormat()` Describe how the argument(s) to the algorithm should be formatted, if applicable.
`boolean`	`countsOperations()`
`java.lang.String`	`getCurrentProblemData()`
`int`	`getEntryTime(Vertex v)`
`int`	`getExitTime(Vertex v)`
`Vertex`	`getParent(Vertex v)`
`java.lang.Class<PuzzleInstance>`	`getProblemType()`
`Vertex`	`getSource()`
`void`	`initializeData()` setProblemData is already implemented for you, but you might need to initialize other data related to your algorithm.
`boolean`	`isDiscovered(Vertex v)`
`boolean`	`isFinished()`
`boolean`	`isProcessed(Vertex v)`
`void`	`parseArguments(java.lang.String args)` Sends a string that the user can enter to the algorithm.
`void`	`quit()` (Hopefully) gracefully stop the computation.
`void`	`runAlgorithm()` Runs the Algorithm.
`void`	`setFinished(boolean finished)`

Methods inherited from class cusack.hcg.graph.algorithm.AbstractAlgorithm
getNumberOfOperations, getState, isDone, isNotDone, isQuit, setProblemData, setState

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface cusack.hcg.graph.algorithm.AlgorithmInterface
getProgressReport, getResult, getVersion

- Constructor Detail
  - DepthFirstSearchSkeletonAlgorithm
```
public DepthFirstSearchSkeletonAlgorithm()
```
- Method Detail
  - initializeData
```
public void initializeData()
```
    Description copied from class: AbstractAlgorithm
    
    setProblemData is already implemented for you, but you might need to initialize other data related to your algorithm. This method is called in setProblemData.
    
    Specified by:
    
    initializeData in class AbstractAlgorithm<PuzzleInstance>
  - runAlgorithm
```
public void runAlgorithm()
```
    Description copied from interface: AlgorithmInterface
    
    Runs the Algorithm. This is the most important method.
  - isFinished
```
public boolean isFinished()
```
  - setFinished
```
public void setFinished(boolean finished)
```
  - isDiscovered
```
public boolean isDiscovered(Vertex v)
```
  - isProcessed
```
public boolean isProcessed(Vertex v)
```
  - getEntryTime
```
public int getEntryTime(Vertex v)
```
  - getExitTime
```
public int getExitTime(Vertex v)
```
  - getParent
```
public Vertex getParent(Vertex v)
```
  - getSource
```
public Vertex getSource()
```
    Returns:
    
    the source vertex used in DFS.
  - getCurrentProblemData
```
public java.lang.String getCurrentProblemData()
```
    Returns:
    
    A string representation of the current state of the problem data. This should be in the same format as it was passed in to setProblemData, but updated to give the current state based on the algorithm progress so far. The idea is that this can be used to show the progress of the algorithm by some GUI (or in text form, I suppose).
  - getProblemType
```
public java.lang.Class<PuzzleInstance> getProblemType()
```
    Returns:
    
    The class object representing the subclass of PuzzleInstance that this algorithm runs on. The implementation should probably be something like "return Blah.class;", where Blah is the subclass of PuzzleInstance used in place of T.
  - countsOperations
```
public boolean countsOperations()
```
    Returns:
    
    True if and only if the algorithm intends to keep track of the number of operations it is performing. Each algorithm is free to decide what it considers an "operation" to be.
  - quit
```
public void quit()
```
    Description copied from interface: AlgorithmInterface
    
    (Hopefully) gracefully stop the computation.
  - parseArguments
```
public void parseArguments(java.lang.String args)
```
    Description copied from interface: AlgorithmInterface
    
    Sends a string that the user can enter to the algorithm. The string will be in whatever format the user enters. Implementation can assume this method is called after the problem data has been set. Throw an exception if different arguments are required.
  - argumentFormat
```
public java.lang.String argumentFormat()
```
    Description copied from interface: AlgorithmInterface
    
    Describe how the argument(s) to the algorithm should be formatted, if applicable.
    
    Returns:

Class DepthFirstSearchSkeletonAlgorithm

Constructor Summary

Method Summary

Methods inherited from class cusack.hcg.graph.algorithm.AbstractAlgorithm

Methods inherited from class java.lang.Object

Methods inherited from interface cusack.hcg.graph.algorithm.AlgorithmInterface

Constructor Detail

DepthFirstSearchSkeletonAlgorithm

Method Detail

initializeData

runAlgorithm

isFinished

setFinished

isDiscovered

isProcessed

getEntryTime

getExitTime

getParent

getSource

getCurrentProblemData

getProblemType

countsOperations

quit

parseArguments

argumentFormat