Merge pull request div-bargali#870

Addition of Readme file contents for each item and addition of Cycle Sort to C++ Algorithm Sorting part etc...

Author: div-bargali

C++/Algorithms/Backtracking/readme.md

@@ -1 +1,42 @@
-### Backtracking-Algorithms
+### Backtracking-Algorithms
+- [CROSSWARD](CROSSWARD.cpp)
+ 
+ Using Crossward Algorithm, user inputs 10 words
+
+ Timing complexity = O(k)
+
+- [Permutation of String](Permutation_of_string.cpp)
+ 
+ Premutation of string is a algorithm that functions to find all possible permutations of a given string, for example if there are given string "ABC" then ABC,ACB,BAC,BCA,CBA,CAB is the result
+
+ Time complexity = O(n^2*n!)
+
+- [RAT IN MAZE](RAT_IN_MAZE_problem.cpp)
+ 
+ RAT IN MAZE is a algorithm to find all possible path in maze to escape using backtracking
+ 
+ Time complexity = O(2^(n^2))
+
+- [Subsets](Subsets.cpp)
+
+ Subset is a alogrithm for a given set of positive integers that functions to find all its subset
+
+ Time complexity = O(2^n)
+
+- [SudokuSolver](sudokuSolver.cpp)
+ 
+ SudokuSolver is a algorithm to solve sudoku which starts with some cells containing numbers, and the goal is to solve the remaining cells
+ 
+ Time complexity = O(9^(n*n))
+
+- [NQueens](nqueens.cpp)
+ 
+ NQueens is a alogrithm when there is an arrangement of N queens on a N*N chess board, find out the number of N queens in which they do not collide with each other
+ 
+ Time complexity = O(2^n)
+
+- [Word Break Problem](word_break_problem.cpp)
+ 
+ Word_Break_Problem is a algorithm when there is a valid sentence without any spaces between the words and a dictionary of valid English words, find all possible ways to break the sentence in individual dictionary words. For example when there is a example like "ilikeicecreamandmango" outputs will be "i like ice cream and mango", "i like ice cream and mango" if the dictionary were {i,like, ice, cream, and, icecream, mango}
+ 
+ Time complexity = O(2^(n*s)) (since we approach using recursive) 

C++/Algorithms/Divide-and-Conquer/readme.md

@@ -1 +1,12 @@
 ### Divide-and-Conquer
+- [Painter's Partition Problem](painter%E2%80%99s%20partition%20problem.cpp)
+ 
+ Painter's Partition Problem is to find the minimum time when we have to paint n boards of length {A1,A2,....,An} and there are k painters available and each takes 1 unit time to paint 1 unit of board under the constraints that any painter will only paint continuous sections of boards like board {2,3,4} or only board {1}, or nothing but not board {2,4,5}
+ 
+ Time complexity = O(k*N^3)
+
+- [Tower of Hanoi1](tower_of_hanoi.cpp), [Tower of Hanoi2](TowerOfHanoi.cpp)
+ 
+ Tower of Hanoi is a mathematic puzzle which consists of three towers and more than one rings. There are three rules in this algorithm in moving all the disks to some another tower without violationg the sequence of arrangement. 1. Only one disk can be moved among the towers at any given time 2. Only the top disk can be removed 3. No large disk can sit over a small disk
+ 
+ Time complexity = O(n)

C++/Algorithms/Dynamic-Programming/readme.md

@@ -1 +1,108 @@
-### Dynamic-Programming
+### Dynamic-Programming 
+- [0-1 Knapsack Problem](0-1%20Knapsack%20Problem/0-1%20Knapsack%20Problem.cpp)
+ 
+ 0-1 Knapsack Problem is a problem in combinatiorial optimization: Given a set of items, each with a weight and a value, determine the number of each item to include in a collection so that the total weight is less than or equal to a given limit and the total value is as large as possible. And for the 0-1 Knapsack problem, you cannot break an item, either pick the complete item or don't pick it(0-1 property)
+
+ Time complexity = O(2^n)
+
+- [Matrix-Chain Multiplication](Matrix-Chain-Multiplication/matrix_chain_multiplication.cpp)
+
+ Matrix-Chain-Multiplication is a algorithm when there is a given sequence of matrices, find the most efficient way to multiply these matrices together. However the problem is not actually to perform the multiplications, but merly to decide in which order to perform the multiplications.
+
+ Time complexity = O(n^3)
+
+- [SubsetSum](SubsetSum/Subset_Sum_dp.cpp)
+
+ SubsetSum is a algorithm with a given set of non-negative integers, and a value sum, determine if there is a subset of the given set with sum equal to given sum. For example if set is {3,34,4,12,5,2} and sum is 9 then output will be true because there is a subset (4,5) with sum 9.
+
+ Time complexity = O(sum*n)
+
+- [Activity Selection](Activity_Selection.cpp)
+
+ Activity Selection is a problem that given n activities with their start and finish times. Select the maximum number of activities that can be performed by a single person, assuming that a person can only work on a single activity at a time. 
+
+ Time complexity = O(nlog n) (since input didn't sorted) 
+
+- [Coin Change Problem](Coin%20Change%20Problem.cpp)
+
+ Coin change problem, with a given value N, if we want to make change for N cents, and we have infinite supply of each of S = {S1, S2,... ,Sm} valued coins
+
+ Time complexity = O(mn)
+
+- [Egg Droping Problem](egg_dropping_problem.cpp)
+
+ Egg dropping problem, suppose that we wish to know which stories in a 36-story building are safe to drop eggs from, and which will cause the eggs to break on landing. There are few assumptions which is an egg that survives a fall can be used again, a broken egg must be discarded, the effect of a fall is the same for all eggs, if an egg breaks when dropped, then it would break if dropped from a higher floor, if an egg survives a fall then it would break if dropped from a higher floor, if an egg survives a fall then it would survive a shorter fall, and it is not ruled out that the first-floor windows break eggs, nor is it ruled out that the 36th-floor do not cause an egg to break.
+
+ Time complexity = O(n*k^2)
+
+- [Josephus Problem](Josephus%20problem.cpp)
+
+ Josephus problem is a theoretical problem. There are n people standing in a circle waiting to be executed. The counting out begins at some point in the circle and proceeds around the circle in a fixed direction. In each step, a certain number of people are skipped and next person is executed. The elimination proceeds around the circle (which is becoming smaller and smaller as the executed people are removed), until only the last person remains, who is given freedom. Given the total number of persons n and a number k which indicates that k-1 persons are skipped and kth person is killed in circle. Goal is to choose the pace in the initial circle so that you are the last one remaining and so survive. 
+
+ Time complexity = O(n) 
+
+- [Kadene Algorithm](Kadane-Algorithm.cpp)
+ 
+ kadane's algorithm is a algorithm with an given array of n integers, we have to look for all positive continuous segments of the array, and keep track of maximum sum contiguous segment among all positive segments. 
+
+ Time complexity = O(n) 
+
+- [Longest Palindromic Sequence](Longest%20%20Palindromic%20Sequence.cpp)
+
+ Longest Palindromic Sequence which is Longest palindromic Subsequence. With a given sequence, find the length of the longest palindromic subsequence in it. For example, if the given sequence is BBABCBCAB then output will be 7 which is BABCBAB(which is the longest).
+
+ Time complexity = O(n^2)
+
+- [Longest Common Subsequence](Longest%20Common%20Subsequence.cpp)
+
+ Longest Common Subsequence with given two sequences, find the length of longest subsequence present in both of them.
+
+ Time complexity = O(2^n)
+
+- [Longest Bitonic Subsequence](longest_bitonic_subsequence.cpp)
+
+ Longest Bitonic Subsequence, with an given array arr[0....n-1] containing n positive integers, a subsequence of arr[] is called Bitonic if it is first increasing, then decreasing. Our goal is to write a function that takes an array as an argument and returns the length of the longest bitonic subsequence. A sequence, sorted in increasing order is considered Bitonic with the decreasing part as empty. Similarly, decreasing order sequence is considered Bitonic with the increasing part as empty.
+
+ Time complexity = O(n^2)
+
+- [Longest Palindromic SubString](LongestPalindromicSubstring.cpp)
+ 
+ Longest Palindromic Substring, given a string, find the longest substring which is palindrome. For example if input is given as "forgeeksskeegfor" output will be "geeksskeeg"
+ 
+ Time complexity = O(n^3)
+
+- [Max Profit With K Transactions](Max%20Profit%20with%20K%20transactions.cpp)
+ 
+ Max Profit with K transaction which is Maximum profit by buying and selling a share at most k times. In share trading, a buyer buys shares and sells on a future date. Given the stock price of n days, the trader is allowed to make at most k transactions, where a new transaction can only start after the previous transaction is complete, find out the maximum profit that a share trader could have made.
+ 
+ Time complexity = O(k*n^2)
+
+- [Minimum No of Coins(Greedy Approach)](Minimum%20no%20of%20coins(Greedy%20Approach).cpp)
+ 
+ Minimum no of coins(Greedy Approach) is to find minimum number of coins that make a given value. Given a value V, if we want to make change for V cents, and we have infinite supply of each of C = {C1,C2,..,Cm} valued coins, we have to find the minimum number of coins to make the change. 
+ 
+ Time complexity = O(mv)
+
+- [Minimum Number of Jumps](Minimum%20Number%20of%20Jumps.cpp)
+
+ Minimum Number of Jumps, given an array of integers where each element represents the max number of steps that can be made forward from that element. Write a function to return the minimum number of jumps to reach the end of the array(starting from the first element). If an element is 0, they cannot move through that element.
+ 
+ Time complexity = O(n^n)
+
+- [Unique_Paths](Unique_Paths.cpp)
+ 
+ Unique Paths, to count all the possible paths from top left to bottom right of a m x n matrix with the constrains that from each cell you can either move only to right or down.
+
+ Time complexity = O(mn) 
+
+- [WildCard_Matching](Wildcard_matching.cpp)
+
+ Wildcard matching, with a given text and a wildcard pattern, implement wildcard pattern matching algorithm that finds if wildcard pattern is matched with text. The matching should cover the entire text(not partial text).
+ 
+ Time complexity = O(mn)
+
+- [WordBreak](wordbreak.cpp)
+ 
+ wordbreak is a problem with a given input string and a dictonary of words, find out if the input string can be segmented into a space-separated sequence of dictionary words.
+
+ Time complexity = O(n*s) 

C++/Algorithms/Factorial/readme.md

@@ -0,0 +1,12 @@
+### Factorial
+- [FactRecursion](factRecursion.cpp)
+ 
+ FactRecursion, which is a program for factorial of a number. Factorial of a non-negative integer, is multiplication of all integers smaller than or equal to n. For example, we can think of factorial 5 is = 5x4x3x2x1 = 120
+ 
+ Time complexity = O(n)
+
+- [FactUsual](factUsual.cpp)
+ 
+ FactUsual, which is a same problem above(which is factorial recursion), but calculating factorial of a number in an iterative way.
+
+ Time complexity = O(n)

C++/Algorithms/Graph-Algorithms/readme.md

@@ -1 +1,90 @@
-### Graph-Algorithms
+### Graph-Algorithms
+- [A Star Search Algorithm](A_star_Search_Algorithm.cpp)
+
+ A_star_Search_Algorithm is one of the best and popular technique used in path-finding and graph traversals. Consider a square grid having many obstacles and we are given a starting cell and a target cell. We want to reach the target cell from the starting cell as quickly as possible.
+
+ Time complexity = O(E) (E is the number of edges in the graph) 
+
+- [Articulation Point and Bridges](ArticulationPointandBridges.cpp)
+ 
+ ArticulationPointandBridges, a vertex in an undirected connected graph is an undirected connected graph is an articulation point if and only if removing it (and edges through it) disconncets the grapth. Articulation points represent vulnerabilities in a connected network - single points whose failure would split the network into 2 or more components. For a disconnected undirected graph, an articulation point is a vertex removing which increases number of connected components. 
+ 
+ Time complexity = O(V*(V+E))
+
+- [Bipartite Graph](Bipartite_Graph.cpp)
+ 
+ Bipartite_Graph, which is a graph whose vertices can be divided into two independent sets, U and V such that every edge(u,v) either connects a vertex from U to V or a from V to U. A bipartite graph is possible if the graph coloring is possible using two colors such that vertices in a set are colored with the same color.
+ 
+ Time complexity = O(V+E)
+
+- [Breadth First Search](Breadth%20First%20Search.cpp)
+ 
+ Breadth First Search(BFS) is an algorithm for traversing or searching tree or garph data structures. It starts at the tree root(or some arbitrary node of a graph) and explores all of the neighbor nodes at the present depth prior to moving on to the nodes at the next depth level.
+ 
+ Time complexity = O(V+E)
+
+- [Component Count](Component_Count.cpp)
+ 
+ Component_count, with a given undirected graph G, the task is to print the number of connected components in the graph. To approach, we use a variable count to store the number of connected components and to the following steps. 1. Initialize all vertices as unvisited. 2. For all the vertices check if a vertex has not been visited, then perform DFS on that vertex and increment the variable count by 1. 
+ 
+ Time complexity = O(|V|+|E|) 
+
+- [Cycle Detection Directed Graph](Cycle_detection_directed_graph.cpp)
+ 
+ Cycle_detection_directed_graph, with a given directed graph, check whether the graph contains a cycle or not. Function we created should return true if the given graph contains at least one cycle, else return false.
+ 
+ Time complexity = O(V+E)
+
+- [Depth First Search](Depth%20First%20Search.cpp)
+ 
+ Depth First Search is an algorithm for traversing or searching tree or graph data structures. The algorithm starts at the root node and explores as far as possible along each branch before backtracking.
+ 
+ Time complexity = O(V+E)
+
+- [Dijkstra's Algorithm](Dijkstra's%20Algorithm.cpp)
+ 
+ The shortest path tree is built up, edge by edge. We maintain two sets: a set of the vertices already included in the tree and the set of the vertices not yet included. The Greedy choice is to pick the edge that connects the two sets and is on the smallest weight path from source to the set that contains not yet included vertices.
+ 
+ Time complexity = O(|E|+|V|log|V|)
+
+- [FordFulkerson](FordFlkerson.cpp)
+ 
+ FordFulkerson is a algorithm with a given graph which represents a flow network where every edge has a capacity. Also given two vertices source 's' and sink 't' in the graph, we have to find the maximum possible flow from s to t with following constraints which is Flow on an edge doesn't exceed the given capacity of the edge and incoming flow is equal to outgoing flow for every vertex except s and t.
+ 
+ Time complexity = O(max_flow*E)
+
+- [Kosaraju or Kosaraju-Sharir Algorithm](Kosaraju.cpp)
+ 
+ Kosaraju or kosaraju-Sharir algorithm is a linear time algorithm to find the strongly connected components of a directed graph.
+ 
+ Time complexity = O(V+E)
+
+- [Kruskal's Minimum Spanning Tree](Kruskal's.cpp)
+ 
+ In Kruskal's algorithm, we create a MST(Minimum Spanning Tree) by picking edges one by one. The Greedy Choice is to pick the smallest weight edge that doesn't cause a cycle in the MST constructed so far.
+ 
+ Time complexity = O(Elog V) (V is the number of vertices)
+
+- [Number of Islands](Number_of_islands.cpp)
+ 
+ Number_of_Islands is a algorithm with an given boolean 2D matrix, find the number of islands. In this algorithm island is a group of connected 1s that forms an island. We can find value by counting the number of connected components in an undirected graph. (connected component of an undirected graph is a subgraph in which every two vertices are connected to each other by a path(s), and which is connected to no other vertices outside the subgraph).
+ 
+ Time complexity = O(ROW x COL)
+
+- [Prim's Minimum Spanning Tree](prims.cpp)
+ 
+ We create a MST by picking edges one by one in Prim's algorithm. We maintatin two sets: a set of the vertices already included in MST and the set of the vertices not yet included. The Greedy choice is to pick the smallest weight edge that connects the two sets. 
+ 
+ Time complexity = O((V+E)log V)
+
+- [Topological Sort](Topological_sort.cpp)
+ 
+ Topological_sort is sorting algorithm for directed acyclic graph, which is a linear ordering of vertices such that for every directed edge u v, vertex u comes before v in the ordering. But if graph is not a DAG, topological sorting is not possible.
+ 
+ Time complexity = O(V+E) 
+
+- [Transitive Closure](Transitive_Closure.cpp)
+ 
+ Transitive_Closure is a algorithm, with given a directed graph, find out if a vertex v is reachable from another vertex u for all vertex pairs (u,v) in the given graph. In this algorithm, reachable mean that there is a path from vertex u to v. The reachability matrix is called transitive closure of a graph.
+ 
+ Time complexity = O(v^2)

C++/Algorithms/Greedy-Algorithms/interval queries.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+int main() {
+// your code goes here
+// this program will give an intuition behind the solution for CP questions based on interval quries. Refer to the question 
+//http://codeforces.com/gym/294377/problem/E
+
+//this following two lines are used for fast input-output
+ios_base::sync_with_stdio(false);
+ cin.tie(NULL);
+
+ int t;
+ cin>>t;
+ while(t--) //running the program for 't' test cases
+ {
+ int n;
+ cin>>n; //number of students in th college
+
+ //declare an array of max size (based on the input constraint) to indicate the timeline of all the students
+ int N=2*100000;
+ int a[N]={0};
+
+ for(int i=0;i<n;i++)
+ {
+ int x,y;
+ cin>>x>>y;
+ // while taking the entering and leaving time of each student, increase the (x-1)th index by one and decrease the (y-1)th index by 1. 
+ a[x-1]+=1;
+ a[y-1]-=1;// Here the student is outside the college during the yth sec, hence we subtract 1 from (y-1)th index. Else we would subtract the same from yth index 
+ }
+ for(int i=1;i<2*100000;i++)
+ {
+ // Summing the value in the current index by its previous index's value will give the total number of students at a perticular instance of time on the timeline a[N] 
+ a[i]+=a[i-1];
+ }
+ int q;
+ cin>>q;
+ while(q--)// running a loop to ans all the queries
+ {
+ int pp;
+ cin>>pp;// The required time to output number of students present at that particular instance 
+
+ // We can find out the number of students present at that perticular time by accessing the value stored in the array 'a' at (pp-1) index
+ cout<<a[pp-1]<<endl; 
+ }
+ }
+return 0;
+}