Merge pull request #203 from Ankitr19/master

Sieve New

Author: prateekiiest

CONTRIBUTORS.md

@@ -6,9 +6,8 @@ Thanks for all your contributions :heart: :octocat:
 
 
 [prateekiiest](https://github.com/prateekiiest) : KWOC Mentor
-
 | Github username      | Pull Request           | Status  |
-| ------------- |:-------------:| -----:|
+|[Ankitr19](https://github.com/Ankitr19)| [#203]https://github.com/codeIIEST/Algorithms/pull/203 |OPEN|
 |[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#46](https://github.com/codeIIEST/Algorithms/pull/46), [#66](https://github.com/codeIIEST/Algorithms/pull/66), [#88](https://github.com/codeIIEST/Algorithms/pull/88), [#89](https://github.com/codeIIEST/Algorithms/pull/89), [#90](https://github.com/codeIIEST/Algorithms/pull/90), [#93](https://github.com/codeIIEST/Algorithms/pull/93), [#159](https://github.com/codeIIEST/Algorithms/pull/159) | CLOSED |
 |[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#94](https://github.com/codeIIEST/Algorithms/pull/94), [#95](https://github.com/codeIIEST/Algorithms/pull/95), [#112](https://github.com/codeIIEST/Algorithms/pull/112), [#151](https://github.com/codeIIEST/Algorithms/pull/151), [#174](https://github.com/codeIIEST/Algorithms/pull/174) | MERGED |
 |[Rahul Arulkumaran](https://github.com/rahulkumaran)| [#206](https://github.com/codeIIEST/Algorithms/pull/206), [#207](https://github.com/codeIIEST/Algorithms/pull/207) | OPEN |

Competitive Coding/Dynamic Programming/Maximum Sum Increasing Subsequence/Maximum_sum_increasing_subsequence.cpp

@@ -0,0 +1,39 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int MaxSumIncrsSubseq(int arr[],int n)
+{
+	int i,j,mx=0;
+	int MSIS[n];   //An array of initial size as that of the original array to store the maximum sum of the increasing subsequence till that point.
+	for(i=0;i<n;i++)
+	{
+		MSIS[i]=arr[i];
+	}
+	/* The main condition to check if the next element of the array should be considered in the maximum sum subsequence array or not , 
+	   by checking the given two conditions:-
+	   1.) arr[i]>arr[j]
+	   2.)MSIS[i]<MSIS[j] + arr[i]
+	*/
+	for(i=1;i<n;i++)
+	{
+		for(j=0;j<i;j++)
+		{
+			if(arr[i]>arr[j] && MSIS[i]<MSIS[j]+arr[i])
+				MSIS[i]=MSIS[j]+arr[i];
+		}
+	}
+	for(i=0;i<n;i++)
+		if(mx<MSIS[i])
+			mx=MSIS[i];
+
+	return mx;       // The maximum sum of the increasing subsequence.
+}
+
+int main()
+{
+	int arr[] = {2,3,100,5,6,101,1};
+	int n = sizeof(arr)/sizeof(arr[0]);
+	int ans = MaxSumIncrsSubseq(arr,n);
+	cout<<ans<<"\n";
+	return 0;
+}

Competitive Coding/Dynamic Programming/Maximum Sum Increasing Subsequence/Maximum_sum_increasing_subsequence.md

@@ -0,0 +1,10 @@
+Maximum Sum in an increasing subsequence - Dynamic Programming
+
+-This algorithm is a slight variation in the Longest Increasing Subsequence.
+-In this algorithm we insert a case to check whether the sum of the new increasing subsequence is greater than the previous one or not.
+
+Example:-
+
+arr[] = {2,3,100,5,6,101,1}
+
+Now, here the maximum sum increasing subsequence will be = 206.

Competitive Coding/Graphs/Graph_Search/BreadthFirstSearch/BFS.md

@@ -0,0 +1,5 @@
+This is the algortihm for Breadth First Search in a given graph.
+
+-We take a starting vertex , and push all its adjacent vertexes in a queue.
+-Now we pop an element from a queue and push all its vertexes in the queue , and we also mark down these vertexes as visited.
+-After executing the code, we will get the vertex visited in a breadth first manner.

Competitive Coding/Graphs/Graph_Search/BreadthFirstSearch/Breadth_First_Search.cpp

@@ -0,0 +1,61 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<bool>Visited;
+vector< vector<int> >Graph;
+
+void edge(int a,int b)
+{
+	Graph[a].push_back(b); //for directed
+
+	//If undirected graph is there, then add the following line
+	// Graph[b].push_back(a);
+}
+
+void BreadthFirstSearch(int u)
+{
+	queue<int>q;
+	q.push(u);
+	Visited[u]=true;
+
+	while(!q.empty())
+	{
+		int f=q.front();
+		q.pop();
+
+		cout<<f<<" ";
+		int ln=Graph[f].size();
+		for(int j=0;j<ln;j++)
+		{
+			if(!Visited[Graph[f][j]])
+			{
+				q.push(Graph[f][j]);
+				Visited[Graph[f][j]]=true;
+			}
+		}
+	}
+}
+
+int main()
+{
+	int n,e;
+	cin>>n>>e;
+	Visited.assign(n,false);
+	Graph.assign(n,vector<int>());
+
+	int a,b;
+	for(int i=0;i<e;i++)
+	{
+		cin>>a>>b;
+		edge(a,b);
+	}
+
+	for(int i=0;i<n;i++)
+	{
+		if(!Visited[i])
+		{
+			BreadthFirstSearch(i);
+		}
+	}
+	return 0;
+}

Competitive Coding/Graphs/Graph_Search/DepthFIrstSearch/DFS.md

@@ -0,0 +1,5 @@
+This is the algortihm for Depth First Search in a given graph.
+
+-We take a starting vertex , and push all its adjacent vertexes in a stack.
+-Now we pop an element from a stack and push all its vertexes in the stack , and we also mark down these vertexes as visited.
+-After executing the code, we will get the vertex visited in a depth first manner.

Competitive Coding/Graphs/Graph_Search/DepthFIrstSearch/Depth_First_Search.cpp

@@ -0,0 +1,48 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void addEdge(vector<int>adj[],int u,int v)
+{
+	//For undirected graph
+	adj[u].push_back(v);
+	adj[v].push_back(u);
+}
+
+void DFSUtil(int u,vector<int>adj[],vector<bool>&visited)
+{
+	visited[u]=true;
+	cout<<u<<" ";
+	for(int i=0;i<adj[u].size();i++)
+	{
+		if(visited[adj[u][i]]==false)
+			DFSUtil(adj[u][i],adj,visited);
+	}
+}
+
+void DFS(vector<int>adj[],int V)
+{
+	vector<bool>visited(V,false);
+	for(int u=0;u<V;u++)
+	{
+		if(visited[u]==false)
+		{
+			DFSUtil(u,adj,visited);
+		}
+	}
+}
+
+int main()
+{
+	 int V = 5;
+    vector<int> adj[V];
+    addEdge(adj, 0, 1);
+    addEdge(adj, 0, 4);
+    addEdge(adj, 1, 2);
+    addEdge(adj, 1, 3);
+    addEdge(adj, 1, 4);
+    addEdge(adj, 2, 3);
+    addEdge(adj, 3, 4);
+    DFS(adj, V);
+    cout<<"\n";
+    return 0;
+}

Competitive Coding/Math/SieveOfEratosthenes/SieveOfEratosthenes.md

@@ -0,0 +1,6 @@
+This is the famous algorithm to find the prime numbers from '1' to 'n'.
+It uses a logic that if a number 'p' is prime , then the numbers 2*p, 3*p, 4*p, .... are not prime.
+Suppose we have p as 2, and we know 2 is a prime number, then all its multiple, which are 4,6,8,10,.... must not be prime as they have 2 as a factor other then 1 and the number itself.
+Similarly, for all other number we can do that, and in the end all the numbers which are marked 'True' in the boolean array will be prime.
+
+The complexity of this algorithm is O(N log(logN)).

Competitive Coding/Math/SieveOfEratosthenes/Sieve_Of_Eratosthenes.cpp

@@ -0,0 +1,47 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<int> SieveOfEratosthenes(int n)
+{
+	bool prime[n+1];           //To mark those numbers which are prime, prime numbers will be marked by a 'True'
+	memset(prime,true,sizeof(prime));
+	vector<int>Primes;
+	/*
+		In this nested loop , we start from the value 2, and marked all its multiple which are less then or equal to n,
+		similarly for 3,4,5....upto n. The logic is simple, since every number which are multiple of 2 are having 2 as a 
+		factor other then 1 and the number itself, similarly for all other numbers.
+	*/
+	for(int p=2;p*p<=n;p++)    
+	{
+		if(prime[p]==true)
+		{
+			for(int i=p*2;i<=n;i+=p)
+			{
+				prime[i]=false;
+			}
+		}
+	}
+	/* Pushing all the prime numbers in one container. */
+	for(int p=2;p<=n;p++)
+	{
+		if(prime[p])
+		{
+			Primes.push_back(p);
+		}	
+	}
+	return Primes;
+}
+
+int main()
+{
+	int n;
+	cout<<"Enter the number upto which prime numbers are to be found\n";
+	cin>>n;
+	vector<int> result;
+	result = SieveOfEratosthenes(n);
+	for(int i=0;i<result.size();i++)
+	{
+		cout<<result[i]<<" ";
+	}
+	cout<<"\n";
+}