Merge branch 'develop'

Chapter 18

Author: gardncl

greedyalgorithms/README.md

@@ -0,0 +1,11 @@
+# Chapter 18: Greedy Algorithms and Invariants
+
+* 18.1 ComputeOptimumAssignment
+* 18.2 ScheduleMinimizedWaitingTime
+* 18.3 IntervalCoveringProblem
+* 18.4 ThreeSumProblem
+* 18.5 FindMajorityElement
+* 18.6 GasUpProblem
+* 18.7 ComputeMaximumWaterTrapped
+* 18.8 ComputeLargestRectangle
+ 

greedyalgorithms/pom.xml

@@ -0,0 +1,28 @@
+<?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>greedyalgorithms</artifactId>
+    <name>Chapter 18: Greedy Algorithms and Invariants</name>
+    <dependencies>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>datastructures</artifactId>
+            <version>1.4</version>
+        </dependency>
+        <dependency>
+            <groupId>gardncl</groupId>
+            <artifactId>utils</artifactId>
+            <version>1.0</version>
+        </dependency>
+    </dependencies>
+
+
+</project>

greedyalgorithms/src/main/java/ComputeLargestRectangle.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class ComputeLargestRectangle {
+
+    /*
+    18.8
+
+    Let A be an array representing the heights of adjacent buildings
+    of unit width. Design an algorithm to compute the area of the
+    largest rectangle contained in this skyline.
+     */
+
+    public static int calculateLargestRectangle(List<Integer> heights) {
+
+        return 0;
+    }
+}

greedyalgorithms/src/main/java/ComputeMaximumWaterTrapped.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class ComputeMaximumWaterTrapped {
+
+    /*
+    18.7
+
+    Write a program which takes as input an integer
+    array and returns the prior of entries that
+    trap the maximum amount of water.
+     */
+
+    public static int getMaxTrappedWater(List<Integer> heights) {
+
+        return 0;
+    }
+}

greedyalgorithms/src/main/java/ComputeOptimumAssignment.java

@@ -0,0 +1,17 @@
+import java.util.Collections;
+import java.util.List;
+
+public class ComputeOptimumAssignment {
+
+    /*
+    18.1
+
+    Design an algorithm that takes as input a set of tasks
+    and returns an optimum assignment.
+     */
+
+    public static List<Tuple> optimumTaskAssignment(List<Integer> taskDurations) {
+
+        return Collections.emptyList();
+    }
+}

greedyalgorithms/src/main/java/FindMajorityElement.java

@@ -0,0 +1,20 @@
+import java.util.Iterator;
+
+public class FindMajorityElement {
+
+    /*
+    18.5
+
+    You are reading a sequence of strings. You know a priori
+    that more than half the strings are repetitions of a
+    single string (the "majority element") but the positions
+    where the majority element occurs are unknown. Write a
+    program that makes a single pass over the sequence and
+    identifies the majority element.
+     */
+
+    public static String majoritySearch(Iterator<String> sequence) {
+
+        return "";
+    }
+}

greedyalgorithms/src/main/java/GasUpProblem.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class GasUpProblem {
+
+    /*
+    18.6
+
+    Given an instance of the gas up problem,
+    how would you efficiently compute an ample
+    city? You can assume that there exists an ample city.
+     */
+
+    public static int findAmpleCity(List<Integer> gallons, List<Integer> distances) {
+
+        return 0;
+    }
+}

greedyalgorithms/src/main/java/IntervalCoveringProblem.java

@@ -0,0 +1,18 @@
+import java.util.Collections;
+import java.util.List;
+
+public class IntervalCoveringProblem {
+
+    /*
+    18.3
+
+    You are given a closed set of intervals. Design an efficient
+    algorithm for finding a minimum sized set of numbers that
+    cover all the intervals.
+     */
+
+    public static List<Integer> findMinimumVisits(List<Tuple> intervals) {
+
+        return Collections.emptyList();
+    }
+}

greedyalgorithms/src/main/java/ScheduleMinimizedWaitingTime.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class ScheduleMinimizedWaitingTime {
+
+    /*
+    18.2
+
+    Given service times for a set of queries, compute a schedule
+    for processing the queries that minimizes the total waiting
+    time. Return the minimum waiting time.
+     */
+
+    public static int minimumTotalWaitingTime(List<Integer> serviceTime) {
+
+        return 0;
+    }
+}

greedyalgorithms/src/main/java/ThreeSumProblem.java

@@ -0,0 +1,17 @@
+import java.util.List;
+
+public class ThreeSumProblem {
+
+    /*
+    18.4
+
+    Design an algorithm that takes as input an array and a number,
+    and determines if there are three entries in the array
+    (not necessarily distinct) which add up to the specified number.
+     */
+
+    public static boolean hasThreeSum(List<Integer> A, int t) {
+
+        return false;
+    }
+}