mew question added

Author: arorarahul

README.md

@@ -115,6 +115,13 @@ remainder.
 Then we take the remainder and quotient from bottom to top and assign them alphabets corresponding to their
 values.
 
+### For Greedy
+- Used in case of optimization problems (maximize of minimize something)
+- When to use heaps vs when to use sorting: When the problem requires just finding the min or max, we can use sorting, but if after finding something is to be inserted again for which in case of sorting it will take O(n) time as it requires finding the place, heaps are better as they take only O(logn) time to do the same thing.
+- In order to represent nodes using bits etc, (eg: huffman coding), we use trees.
+- Huffman codes or optimal merge patterns where something is to be minimized, always choose the maximum
+value to be at the top of the tree with min edge length (or path to be traversed) and min at bottom with
+max edge or path to be traversed to minimize work.
 
 # Topic0: Programming Questions
 
@@ -279,6 +286,13 @@ values.
 - [Find the smallest window in the string containing all characters of another string](/strings/question11.c)
 - [Find first non-repeating characters from a stream of characters](/strings/question12.c)
 
+### Greedy
+
+- [Make a program for greedy knapsack problem](/greedy/question1.c)
+- [Make a program to implement huffman encoding](/greedy/question2.c)
+- [Make a program to sequence given jobs with deadlines to maximize profits](/greedy/question3.c)
+- [Optimal merge patterns](/greedy/question4.c)
+
 ## Some important concepts to solve algos better
 
 - For extreme values refer to limits.h constants given by C
@@ -355,6 +369,12 @@ Eg: SSMMMAAARRT => S2M3A3R2T1
 - Two strings are anagrams if they have same no of characters and they are composed of the same letters.
 Even if there are repetitions, they are going to be same. 
 - Ideal approach of writing a program is return from a functiona and keep strings at a single place and not scattered
+- Greedy method and DP are two programing paradigms which can be used to solve optimization problems
+- Greedy method fractions are allowed
+- For huffman coding to work letters must not be uniformly distributed
+- Spanning tree is min number of edges present in the graph such that all nodes are connected. Span tree is always subgraph of the main graph and cannot contain edges which are not present in the main graph
+- Number of edges incident on the node is degree of node in undirected graphs. In case of directed, there is no degree but in degree and out degree
+- Kirchoff theorem is used to find spanning tree of non-weighted undirected simple graph
 
 # C Programming - Topic1: Introduction
 

greedy/question1.c

@@ -0,0 +1,27 @@
+/*
+Program for greedy knapsack problem.
+
+METHOD:
+In this problem different weights are given along with the profit associated to each weight (if full weight
+is used). Now, a bag is given with a max capacity. We have to put objects in the bag such that profit
+is maximum.
+
+The approach is to find the profit by weight ratio corresponding to each object, then sort the list.
+Now from the list keep filling the bag with the object completely with the max profit by weight ratio.
+Once the bag is full enough such that it cannot accomodate the next weight fully, put the fraction of
+that weight such that the bag is full and add the fraction of profit to the total profit so far.
+
+Time complexity: O(nlogn) //since sorting is the dominant term
+Space complexity: O(n) //since we will be storing profit by weight ratio in array
+
+We can also use max heap in this case and everytime we will have to delete max and max heapify n times
+which will give the same time complexity
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(){
+	
+	return 0;
+}

greedy/question2.c

@@ -0,0 +1,27 @@
+/*
+Program to implement Huffman encoding
+
+METHOD:
+In case of huffman encoding the condition is that elements should not be uniformly distributed.
+There the element that is repeating most number of times, we represent it using least number of bits
+and the element that is repeating least number of times, we use max bits. Therefore in this case we can
+represent this thing using tree.
+The algo is to make a min heap out of the given elements (as we are required to find min each time) and also
+insertion is to be done (therefore sorting is not used).
+
+Now each time min is extracted twice. A new node is made which will contain the value equal to the sum
+of the two mins (freq). The left node smaller one will be the left child of the newly created node and the
+bigger of the two will be the right child. Like this we keep repeating this process for n-1 elements
+to build the tree.
+Now we can fix one pattern that is making left edge of each tree as 0 and right as 1 or vice versa down
+to the bottom and then we traverse for each node to generate the huffman codes.
+
+Note that in this each node will have its own unique pattern which wont be present in any of the nodes.
+Also note that node which is smaller has to be on the left and each time there is a possibility that not 
+always there will be a tree, many a times there can be forests also and then you combine two search forests.
+This may happen because least two values will be different from the current sequence
+
+Time complexity: O(nlogn) //finding min n times (twice) and inserting the sum back to the tree O(logn) which
+is done n-1 times again
+Space complexity: O(n) //tree
+*/

greedy/question3.c

@@ -0,0 +1,16 @@
+/*
+Make a program to sequence given jobs with deadlines to maximize profits
+
+Here some jobs will be given along with some profits associated to each job if the job is done in
+given deadline.
+METHOD:
+First we find the job with the max deadline. That is the max slot that will be available to us. Therefore
+array will be of that size. Now, we arrange them in decreasing order of profits. Once that is done we pick
+max profit job and place it as far away as possible such that it is meeting its deadline. Like this we
+keep scanning the empty slot to place a job as far as possible such that it meets its deadline. Like this
+we maximize profit.
+Note: if the deadline is very very high as compared to the no. of jobs, always limit the array size
+with the number of jobs given. So compare both. 
+Time complexity: O(n^2) //in worst case we will end up scanning all the cells in the array
+Space complexity: O(n) //array size or O(max deadline)
+*/

greedy/question4.c

@@ -0,0 +1,13 @@
+/*
+Optimal merge patterns
+
+In this some files with sorted number of records are given. We need to make an algo such that
+there is min record movement when merging them in sorted order into single file
+
+Same algo as that of Huffman codes. File with lowest records is moved more so is kept at the bottom
+away from the root. Files with higher number of records are placed closer to the root i.e. merged
+later
+
+Time complexity: O(nlogn)
+
+*/