![Algorithm
Knapsack(n,cw)
1. int M[][] = new int[n + 1][cw + 1];//Build a memoization matrix in bottom up manner.
2. for i<-0 to n
3. for w<-0 to cw
4. if (i == 0 || w == 0) then
5. M[i][w] = 0;
6. else if(gwt[i - 1]<= w) then
7. M[i][w] = max(pro[i - 1] + M[i - 1][w - gwt[i - 1]], M[i - 1][w])
8. else
9. M[i][w] = M[i - 1][w]
10. return M[n][cw]](https://image.slidesharecdn.com/algorithmsdesignpatternsashwinshiv-210804160830/85/Algorithms-Design-Patterns-29-320.jpg)
Algorithms Design Patterns
- 1. Algorithms Design Approach/Patterns 1. DIVIDE AND CONQUER 2. Greedy Algorithms 3. Dynamic programing 4. BackTracking 5. Branch and Bound By Name: Ashwin Shiv Roll No:181210013 CSE 2nd Year NIT Delhi
- 3. DIVIDE AND CONQUER -3 Part TOP DOWN APPROCH TOP down Approach to design Algorithms 1) Divide : Divide the problem into sub problem that is similar to original problem 2) Conquer Solve the problem recursively 3) Combine : Combine the solution of sub problem to create the solution of original problem
- 4. APPLICATION OF D&C ALOGORATHIM Binary Search Finding Max and Min Merge Sort Quick Sort Strassen Matrix Multiplication Convex hull
- 5. DIVIDE and CONQUER – APPROCH ALGO DANDC (P) { if small (p) then return S(p) else { divide P in smaller p1, p2...pk where k >=1 apply DANDC to each sub problem Recursively return combine ( DANDC(p1), DANDC(p1) ……………… DANDC(pk)) } }
- 7. Greedy Algorithms A greedy algorithm is an algorithm that constructs an object X one step at a time, at each step choosing the locally best option. In some cases, greedy algorithms construct the globally best object by repeatedly choosing the locally best option.
- 8. Greedy Algorithms – Advantages Greedy algorithms have several advantages over other algorithmic approaches: ● Simplicity: Greedy algorithms are often easier to describe and code up than other algorithms. ● Efficiency: Greedy algorithms can often be implemented more efficiently than other algorithms.
- 9. Greedy Algorithms – DIS Advantages Greedy algorithms have several drawbacks: ● Hard to design: Once you have found the right greedy approach, designing greedy algorithms can be easy. However, finding the right approach can be hard. ● Hard to verify: Showing a greedy algorithm is correct often requires a nuanced argument.
- 10. Greedy Algorithms – APPROCH ALGO GREDDY ( a, n) { solution = 0; for i to n do { x = select (a) ; if feasible (solution , x ) ; then solution Union (solution , x) ; } return solution; }
- 11. Applications OF Greedy Algorithms Activity Selection Huffman coding Job Sequencing Knap Snap Minimum Spanning tree Single Source shortest Path Bellman ford Algorithm Dijkstra’s Algorithm
- 13. Dynamic Programming Used to solve optimization problems. 1. Breaks down the complex problems into simpler subproblems. 2. Find optimal solution to these subproblems. 3. Store the results of these subproblems so that it can be reused later. 4. Finally Calculates the result of complex sub-problem.
- 14. Dynamic Programming– Advantages Time Complexity will be always less because it reduces the line code It speeds up the processing as we use previously calculated intermediate values.
- 15. Dynamic Programming– Disadvantages Space Complexity would be more as dividing problem in sub problem and storing intermediate results in consuming memory.
- 16. APPLICATION OF Dynamic Programming Cutting a rod into pieces to Maximize Profit Matrix Chain Multiplication Longest Common Subsequence Optimal Binary Search Tree Travelling Salesman Problem 0/1 Knapsack Problem
- 17. BackTracking
- 18. BackTracking Backtracing uses bruit force approach to solve the problem. The Algorithmic Approach – Backtracking systematically try and search possibilities to find the solution. Brute force approach say for any given problem generate all possible solution and pick a desire solution. Generate depth first search to generate state space tree.
- 19. BackTracking– Advantages Comparison with the Dynamic Programming, Backtracking Approach is more effective in some cases. Backtracking Algorithm is the best option for solving tactical problem. Also Backtracking is effective for constraint satisfaction problem. In greedy Algorithm, getting the Global Optimal Solution is a long procedure and depends on user statements but in Backtracking It Can Easily getable. Backtracking technique is simple to implement and easy to code. Different states are stored into stack so that the data or Info can be usable anytime. The accuracy is granted.
- 20. BackTracking– DisAdvantages – Backtracking Approach is not efficient for solving strategic Problem. – The overall runtime of Backtracking Algorithm is normally slow – To solve Large Problem Sometime it needs to take the help of other techniques like Branch and bound. – Need Large amount of memory space for storing different state function in the stack for big problem. – Thrashing is one of the main problem of Backtracking. – The Basic Approach Detects the conflicts too late.
- 21. BackTracking– APPROCH Backtrack (v1,Vi) { If (V1,……., Vi) is a Solution Then Return (V1,…, Vi) For each v DO If (V1,…….,Vi) is acceptable vector THEN Solution = try (V1,…,Vi, V); If Solution != () Then RETURN Solution ; } } }
- 22. APPLICATION OF BackTracking N Queen Problem Sum of subset problem Graph Coloring problem Hamiltonian Circuit Problem Maze Problem
- 23. Branch and Bound
- 24. Branch and Bound Branch and bound is an algorithm design paradigm which is generally used for solving combinatorial optimization problems. These problems are typically exponential in terms of time complexity and may require exploring all possible permutations in worst case. The Branch and Bound Algorithm technique solves these problems relatively quickly. BFS (Brute-Force)We can perform a Breadth-first search on the state space tree. This always finds a goal state nearest to the root. But no matter what the initial state is, the algorithm attempts the same sequence of moves like Depth-first-search DFS. Branch and Bound. The search for an answer node can often be speeded by using an “intelligent” ranking function, also called an approximate cost function to avoid searching in sub-trees that do not contain an answer node. It is similar to the backtracking technique but uses BFS-like search
- 25. Branch and Bound– APPROCH FIFO Branch Bound ( First IN First OUT) LIFO Branch Bound ( Last IN First OUT) LC Branch Bound ( Least Cost )
- 26. APPLICATION OF Branch and Bound 0/1 Knapsack Problem using Least Cost Branch and Bound Algorithm Travelling Salesman Problem using Branch and Bound
- 27. 0/1 Knapsack Problem using Dynamic Programming • In these kinds of problems,we are given some items with weights and profits. • The 0/1 denotes that either you will not pick the item(0) or you can pick the item completely(1). • Cannot take a fractional amount of an item taken or take an item more than once. • It cannot be solved by the Greedy Approach because it is enable to fill the knapsack to capacity. • In simple words,0/1 Knapsack Problem means that we want to pack n items in a bag(knapsack): 1. The ith item is worth pi(profit) and weight wi kg. 2. Take as valuable a load as possible, but cannot exceed W pounds. 3. pi,wi,W are integers.
- 28. Why Dynamic Programming to solve 0/1 Knapsack Problem? It is a very helpful problem in combinatorics. Recomputation is avoided as it stores the result of previous subproblem so that it can be used again in solving another subproblem.
- 29. Algorithm Knapsack(n,cw) 1. int M[][] = new int[n + 1][cw + 1];//Build a memoization matrix in bottom up manner. 2. for i<-0 to n 3. for w<-0 to cw 4. if (i == 0 || w == 0) then 5. M[i][w] = 0; 6. else if(gwt[i - 1]<= w) then 7. M[i][w] = max(pro[i - 1] + M[i - 1][w - gwt[i - 1]], M[i - 1][w]) 8. else 9. M[i][w] = M[i - 1][w] 10. return M[n][cw]
- 30. Code in Java to solve 0-1 Knapsack problem Solution using Dynamic Programming to get Maximum Profit My Java Program 0/1 Knapsack Problem using Dynamic Programming