Algorithms Q&A - Recent questions and answers in Greedy Algorithms

Answered: Is Greed the best choice?

Sat, 16 Dec 2023 18:29:53 +0000

a.) Chess - The current best step may or may not lead to the global best solution. Because there are many possibilities where opponent can tackle our best step. We need to check all the possibilities. So, greedy may not be optimal/ applicable.

b.) Sorting - Yes, Greedy is applicable here but not necessarily encouraged. For ex- Selection Sort. Where the local solution leads to the global solution. But the time complexity is high(O(n²)). Using other approaches may give optimal ways to sort.

c.) Shortest path computation - Some problems like MST, Dijkstra's algorithm which are quite similar to Shortest path computation applies Greedy approach.

d.) Knapsack - Incase of fractional Knapsack we consider Max {Value/Weight} at each step which gives an optimal solution but for 0/1 Knapsack, dynamic programming gives optimal solution. So, for Fractional Knapsack, Greedy method is applicable.

Answered: Maximum Product Spanning Tree

Sat, 16 Dec 2023 18:26:17 +0000

If the product w1*w2*w3 is at its maximum, then the sum log(w1) + log(w2) + log(w3) is also at its maximum due to the logarithmic property. Therefore, substituting each w1 with its logarithmic value and determining the maximum weight spanning tree is similar to discovering the maximum product spanning tree in the original tree.

Answered: Interval Scheduling

Thu, 14 Dec 2023 04:29:36 +0000

Sort the given intervals based on their end times. This is crucial to ensure that you are considering intervals that end earliest first. Start with the first interval and consider it as part of the solution. Iterate through the sorted intervals.

For each interval, check if its start time is greater than or equal to the end time of the last selected interval. If it is, add it to the solution. Maintain a count of the selected intervals. The count represents the maximum number of non-overlapping intervals.

Answered: Maximum Spanning Tree

Thu, 14 Dec 2023 04:16:19 +0000

Sort all the edges in descending order based on their weights.

Start with an empty graph, which will become the Maximum Spanning Tree.

Iterate through the sorted edges. For each edge, if adding it to the current Maximum Spanning Tree doesn't create a cycle, add it to the tree. Continue this process until the Maximum Spanning Tree has (n-1) edges, where n is the number of vertices.

Answered: Symbol Frequency

Thu, 14 Dec 2023 04:08:34 +0000

Huffman tree is what you describe.

Answered: Chromatic Number, Relation to Max Degree

Sun, 10 Dec 2023 22:21:33 +0000

Let the vertices of a graph G be v 1 , v 2 , ..., v n and the maximum degree of G be ∆ .
For i = 1, 2, ..., n we color v i with the smallest number that is available, i.e., the number that has not been used on the vertices in {v 1 , v 2 , ..., v i−1 } that are adjacent to v i .
Since there are at most ∆ vertices that are adjacent to v i , this algorithm will not use more than ∆ + 1 colors. Therefore, we have χ(G) ≤ ∆(G)+1 .

Answered: Maximize Party Planning Reward

Tue, 23 Jun 2020 21:17:03 +0000

Suppose parties are given by their start and end times as: [[s1, e1], [s2, e2], .... [sn, en]]

We can see there is an optimal schedule with non-overlapping party time.

Proof : Assume that there is no optimal schedule with non-overlapping that includes the first ending party.

suppose an optimal schedule is given as S. We construct a schedule S’ as follows:

remove the very first ending party in S and add the first ending party overall, which consists of interval [s1, e1].

We observe that S’ is a feasible schedule. Further S’ schedules as many parties as the given optimal schedule S. Further S’ includes the first ending one. This contradicts the assumption that there is no optimal schedule with non-overlapping parties that includes the first ending party.

we can simply sort them by their end time and iterate the parties as following steps:

step1. Sort the parties by increasing end times using O(n log n) time

step2. Initialize ending time of selected party in O(1) time

step3. For j = 1 to n

If j-th starts after the ending time, then: Select j-th and update ending time, else skip which takes O(n) time

Thus, the overall algorithm runs in O(n log n) time.

Answered: Show that Greedy Algorithm is suboptimal for Gold Rod Question

Sat, 04 May 2019 17:36:56 +0000

When using the greedy method, you will get an approximate answer, which is not always right. For example, due to the length of the wire are given, it is very possible you can't use all wire and has some wire left. In that case, what's has to be left probably be larger than those pieces you choose before.

Here is a simple example: if the wire length is 50.

p1.length = 10, value =60;

p2.length = 20, value =100;

p3.length = 30, value =120;

Using greedy method, you will get p1+p2, value = 160.

However, the right solution is p2+p3, value = 220.

Answered: "Fast Response" Locating a Proxy Server for the network

Wed, 12 Jul 2017 20:56:27 +0000

Greedy algorithm works fine.

Iterate the weight array from left to right and find out the TOTAL weight. // This step takes O(n) time
Iterate the weight array again from right to left and find the point at which the accumulated weight meets or exceeds half of total weight. Put the proxy server on that location.

Examples:

Given [1, 1, 1, 1], put the proxy server on the 2nd server

Given [1,2,3,4], put the proxy server on the 3rd server.

Given [1,2,3,10], put the proxy server on the 4th server.

Given [10,1,1,1,1,1,1], put the proxy server on the 1st server.

Answered: Adjustment to Greedy Knapsack Algorithm to Guarantee Atleast 50% value of Optimal

Sun, 06 Mar 2016 03:22:51 +0000

Solution:

Add a 3rd step to the original algorithm states: Return MAX {the Greedy Algorithms's solution, the most valuable item}.

Claim:

The new 3-steps algorithm guarantees at least 50% value of the optimal solution.

Proof:

Recall items have been sorted by its profit(value/weight). Assume the 2nd step of this solution returns a result includes the first k items (a₁,a₂...a_k), since items cannot be divided, a_kis the last item included, and a_k+1 is the first item excluded. Therefore, the result of this step will be at least equal to the total value of the first k items. That's RESULT1 = a_{1 +}a_{2 +}...+ a_k.
Consider an alternative - a_max, where a_max is the most valuable item. Therefore, RESULT2 = a_max >= a_k+1.
We choose RESULT = max{RESULT1, RESULT2}
Here comes the cool part. Plus the two in-equations, We have (RESULT1 + RESULT2) = a_{1 +}a_{2 +}...+ a_k+a_k+1, which is the total value of the first k+1 items, which is also >= the fractional solution we talked about earlier (because the fractional solution takes at most the (k+1)-th item), and also the fractional solution will be at least equal to the optimal solution of this problem because the fractional solution consume all knapsack's capacity and choose items by its profit in decending order.
So we have: RESULT >= RESULT1, and RESULT >= RESULT2. That is, we have, 2 * RESULT >= RESULT1 + RESULT2 = Value(1,k+1) >= the fractional solution >= the optimal solution. That's 2 * RESULT >= Optimal solution. That is, RESULT >= 0.5 * Optimal Solution.

I wrote an article contains more details about this problem: Knapsack Problem