Greedy Algorithm

Algorithm Series 3

Greedy Algorithm

What is Greedy Algorithm?
A greedy algorithm is any algorithm that follows the problem solving heuristic of making the locally optimal choice at each stage with the hope of finding the global optimum.

Greedy algorithms do not always yield optimal solutions, but for many problems they do. For those problems which greedy algorithm does yield optimal solutions, we need prove its correctness.
1.  Cast the optimization problem as one in which we make a choice and are left with one subproblem to solve.
2.  Prove that there is always an optimal solution to the original problem that makes the greedy choice, so that the greedy choice is always safe.
3.  Demonstrate that, having made the greedy choice, what remains is a subproblem with the property that if we combine an optimal solution to the subproblem with the greedy choice we have made, we arrive at an optimal solution to the original problem.
4. Prove whether the solution of greedy algorithm is globally optimal solution.

We develop our substructure with an eye toward making a greedy choice that leaves just one subproblem to solve optimally.
When to use Greedy Algorithm?
Greedy-choice property
A globally optimal solution can be arrived at by making a locally optimal (greedy) choice.
Optimal substructure

Difference between Dynamic programming
Unlike dynamic programming, which solves the subproblems bottom up, a greedy strategy usually progresses in a top-down fashion, making one greedy choice after another, reducing each given problem instance to a smaller one.
To the traveling salesman problem, greedy algorithm means: "At each stage visit the unvisited city nearest to the current city".

The fractional knapsack problem is solvable by a greedy strategy, whereas the 0–1 problem is not.

Huffman code
Always merge 2 least-frequent nodes and re-put it to the priority queue.
n |C|
for i 1 to n - 1
     do allocate a new node z
        left[z] x EXTRACT-MIN (Q)
        right[z] y EXTRACT-MIN (Q)
        f [z] f [x] + f [y]
        INSERT(Q, z)

Activity-selection problem
Dynamic-programming solution
C[i,j] = max(i<k<j){C[i,k] + C[k,j] + 1} 
Add fictitious activities a0 and an+1 and adopt the conventions that f0 = 0 and sn+1 = ∞.

Converting to a greedy solution
Consider any nonempty subproblem Sij, and let am be the activity in Sij with the earliest finish time (proof by contradiction):
1.  Activity am is used in some maximum-size subset of mutually compatible activities of Sij.
2.  The subproblem Sim is empty, so that choosing am leaves the subproblem Smj as the only one that may be nonempty.
n ← length[s] 
A ← {a1} 
i ← 1 
for m ← 2 to n 
     do if sm ≥ fi 
           then A ← A U {am} 
                i ← m 
return A 
Greedy solution
Always pick the one with the earliest finish time that can be legally scheduled. It maximizes the amount of unscheduled time remaining.

Minimum Spanning Tree algorithm for a connected, undirected graph- O(E*lgV)
Let (u, v) be a light edge crossing (S, V - S). Then, edge (u, v) is safe for A. - Prove by cut-and-paste technique. At each step it adds to the forest an edge of least possible weight.
Prim's algorithm
The set A forms a single tree. The safe edge added to A is always a least-weight edge connecting the tree to a vertex not in the tree. 
The tree starts from an arbitrary root vertex r.
At each step with an edge that contributes the minimum amount possible to the tree's weight.
By using Fibonacci heaps, Prim's algorithm can be sped up to run in time O(E + VlgV).
A = {(v, π[v]) : v ∈ V - {r}}.
MST-PRIM(G, w, r)
for each u ∈ V [G]
     do key[u] ← ∞
        π[u] ← NIL
key[r] ← 0
Q ← V [G]
while Q ≠ Ø
    do u ← EXTRACT-MIN(Q)
       for each v ∈ Adj[u]
           do if v ∈ Q and w(u, v) < key[v]
                 then π[v] ← u
                      key[v] ← w(u, v)

Kruskal's algorithm
The set A is a forest. The safe edge added to A is always a least-weight edge in the graph that connects two distinct components.
A ← Ø
for each vertex v ∈ V[G]
     do MAKE-SET(v)
sort the edges of E into nondecreasing order by weight w
for each edge (u, v) ∈ E, taken in nondecreasing order by weight
    do if FIND-SET(u) ≠ FIND-SET(v)
           then A ← A ∪ {(u, v)}
                UNION(u, v)
return A
Single-Source Shortest Path
For shortest-path problem of unweighted graph, breadth-first-search can be used.

Positive-weighted shortest-path problem in a weighted, directed graph
Dijkstra's algorithm
Dijkstra's algorithm maintains a set S of vertices whose final shortest-path weights from the source s have already been determined. The algorithm repeatedly selects the vertex u V - S with the minimum shortest-path estimate, adds u to S, and relaxes all edges leaving u. In the following implementation, we use a min-priority queue Q of vertices, keyed by their d values.
S ← Ø
Q ← V[G]
while Q ≠ Ø
    do u ← EXTRACT-MIN(Q)
       S ← S ∪{u}
       for each vertex v ∈ Adj[u]
           do RELAX(u, v, w)
Negative-weighted shortest-path problem in a directed acyclic graph
Bellman-Ford algorithm [TODO]

Topological Sorting
1. Find any vertex that has no incoming edges, process it and logically remove it - lower the incoming edges for each vertex adjacent to it. - apply this strategy to the rest of the graph.

Post a Comment


Java (160) Lucene-Solr (112) Interview (64) All (58) J2SE (53) Algorithm (45) Soft Skills (39) Eclipse (33) Code Example (31) JavaScript (23) Linux (22) Spring (22) Windows (22) Tools (21) Web Development (20) Nutch2 (18) Bugs (17) Debug (16) Defects (14) Text Mining (14) Troubleshooting (14) J2EE (13) Network (13) PowerShell (11) Problem Solving (10) Chrome (9) Design (9) How to (9) Learning code (9) Performance (9) UIMA (9) html (9) Http Client (8) Maven (8) Security (8) Tips (8) bat (8) blogger (8) Big Data (7) Database (7) Google (7) Guava (7) JSON (7) Shell (7) System Design (7) ANT (6) Coding Skills (6) Lesson Learned (6) Programmer Skills (6) Scala (6) css (6) Algorithm Series (5) Cache (5) Continuous Integration (5) IDE (5) adsense (5) xml (5) AIX (4) Become a Better You (4) Code Quality (4) Concurrency (4) Dynamic Languages (4) GAE (4) Git (4) Good Programming Practices (4) Jackson (4) Memory Usage (4) Miscs (4) OpenNLP (4) Project Managment (4) Review (4) Spark (4) Testing (4) ads (4) regular-expression (4) Android (3) Apache Spark (3) Distributed (3) Eclipse RCP (3) English (3) Happy Hacking (3) IBM (3) J2SE Knowledge Series (3) JAX-RS (3) Jetty (3) Life (3) Python (3) Restful Web Service (3) Script (3) regex (3) seo (3) .Net (2) Android Studio (2) Apache (2) Apache Procrun (2) Architecture (2) Batch (2) Bit Operation (2) Build (2) Building Scalable Web Sites (2) C# (2) C/C++ (2) CSV (2) Career (2) Cassandra (2) Fiddler (2) Google Drive (2) Gson (2) How to Interview (2) Html Parser (2) Http (2) Image Tools (2) JQuery (2) Jersey (2) LDAP (2) Logging (2) Mac (2) Software Issues (2) Storage (2) Text Search (2) xml parser (2) AOP (1) Application Design (1) AspectJ (1) Chrome DevTools (1) Cloud (1) Codility (1) Data Mining (1) Data Structure (1) ExceptionUtils (1) Exif (1) Feature Request (1) FindBugs (1) Firefox (1) Greasemonkey (1) HTML5 (1) Httpd (1) I18N (1) IBM Java Thread Dump Analyzer (1) Invest (1) JDK Source Code (1) JDK8 (1) JMX (1) Lazy Developer (1) Machine Learning (1) Mobile (1) My Plan for 2010 (1) Netbeans (1) Notes (1) Operating System (1) Perl (1) Problems (1) Product Architecture (1) Programming Life (1) Quality (1) Redhat (1) Redis (1) RxJava (1) Solutions logs (1) Team Management (1) Thread Dump Analyzer (1) Visualization (1) boilerpipe (1) htm (1) ongoing (1) procrun (1) rss (1)

Popular Posts