Merge branch 'develop'

Chapter 19: Graphs

Author: gardncl

datastructures/src/main/java/GraphVertex.java

@@ -0,0 +1,32 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class GraphVertex {
+    public int data;
+    public List<GraphVertex> edges;
+    public boolean visited;
+
+    public GraphVertex(int data) {
+        this.data = data;
+        this.edges = new ArrayList<>();
+        this.visited = false;
+    }
+
+    public GraphVertex(int data, GraphVertex... graphVertices) {
+        this.data = data;
+        this.edges = Arrays.asList(graphVertices);
+        this.visited = false;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        GraphVertex that = (GraphVertex) o;
+
+        if (data != that.data) return false;
+        return edges != null ? edges.equals(that.edges) : that.edges == null;
+    }
+}

datastructures/src/main/java/Vertex.java

@@ -0,0 +1,24 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Vertex {
+    public Map<Vertex, Integer> edges = new HashMap<>();
+    public Character id;
+    public boolean visited = false;
+
+    public Vertex(Character id) {
+        this.id = id;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        Vertex vertex = (Vertex) o;
+
+        if (visited != vertex.visited) return false;
+        if (edges != null ? !edges.equals(vertex.edges) : vertex.edges != null) return false;
+        return id != null ? id.equals(vertex.id) : vertex.id == null;
+    }
+}

graphs/README.md

@@ -0,0 +1,11 @@
+# Chapter 19: Graphs
+
+* 19.1 SearchMaze
+* 19.2 PaintBooleanMatrix
+* 19.3 ComputeEnclosedRegions
+* 19.4 DeadlockDetection
+* 19.5 CloneAGraph
+* 19.6 MakingWiredConnections
+* 19.7 TransformOneStringToAnother
+* 19.8 TeamPhotoDay
+* 19.9 ComputeShortestPath

graphs/pom.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>elements-of-programming-interviews</artifactId>
+        <groupId>gardncl</groupId>
+        <version>1.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>graphs</artifactId>
+    <name>Chapter 19: Graphs</name>
+    <dependencies>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>datastructures</artifactId>
+            <version>1.0</version>
+        </dependency>
+    </dependencies>
+
+
+</project>

graphs/src/main/java/CloneAGraph.java

@@ -0,0 +1,17 @@
+public class CloneAGraph {
+
+    /*
+    19.5
+
+    Consider a vertex type for a directed graph in which there
+    are two fields: an integer data and a list of references
+    to other vertices. Design an algorithm that takes a reference
+    to a vertex u, and creates a copy of the graph on the vertices
+    reachable from u. Return the copy of u.
+     */
+
+    public static GraphVertex cloneGraph(GraphVertex g) {
+
+        return new GraphVertex(0);
+    }
+}

graphs/src/main/java/ComputeEnclosedRegions.java

@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class ComputeEnclosedRegions {
+
+    /*
+    19.3
+
+    Let A by a 2D array whose entries are either W or B.
+    Write a program that takes A, and replaces all Ws
+    that cannot reach the boundary with a B.
+     */
+
+    public static void fillSurroundingRegions(List<List<Boolean>> board) {
+
+    }
+}

graphs/src/main/java/ComputeShortestPath.java

@@ -0,0 +1,19 @@
+import java.util.Collections;
+import java.util.List;
+
+public class ComputeShortestPath {
+
+    /*
+    19.9
+
+    Design an algorithm which takes as input a graph G = (V,E),
+    directed or undirected, a non-negative cost function on E,
+    and vertices s and t; your algorithm should output a path
+    with the fewest edges amongst all shortest paths from s to t.
+     */
+
+    public static List<Vertex> compute(int cost, List<Vertex> graph, Vertex s, Vertex t) {
+
+        return Collections.emptyList();
+    }
+}

graphs/src/main/java/DeadlockDetection.java

@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class DeadlockDetection {
+
+    /*
+    19.4
+
+    Write a program that takes as input a directed graph
+    and checks if the graph contains a cycle.
+     */
+
+    public static boolean isDeadlocked(List<GraphVertex> G) {
+
+        return false;
+    }
+}

graphs/src/main/java/MakingWiredConnections.java

@@ -0,0 +1,19 @@
+import java.util.List;
+
+public class MakingWiredConnections {
+
+    /*
+    19.6
+
+    Design an algorithm that takes a set of pins and a set of wires
+    connecting pairs of pins, and determines if it is possible to
+    place some pins on the left half of a PCB, and the remainder on
+    the right half, such that each wire is between left and right
+    halves.
+     */
+
+    public static boolean isAnyPlacementFeasible(List<GraphVertex> G) {
+
+        return false;
+    }
+}

graphs/src/main/java/PaintBooleanMatrix.java

@@ -0,0 +1,16 @@
+import java.util.List;
+
+public class PaintBooleanMatrix {
+
+    /*
+    19.2
+
+    Implement a routine that takes an n x m Boolean array A
+    together with an entry (x,y) and flips the color of the
+    region associated with (x,y).
+     */
+
+    public static void flipColor(List<List<Boolean>> A, int x, int y) {
+
+    }
+}