Algorithms

Author: deepakkasera

Graphs/DijkstraAlgo.cpp

@@ -0,0 +1,74 @@
+#include <bits/stdc++.h>
+#define INF 0x3f3f3f3f
+using namespace std;
+
+typedef pair<int,int> iPair;
+
+class Graph
+{
+	int V;
+	std::vector<iPair> *v;
+public:
+	Graph(int V){
+		this->V = V;
+		v = new vector<iPair>[V];
+	}
+
+	void addEdge(int a,int b,int d){
+		v[a].push_back(make_pair(b,d));
+		v[b].push_back(make_pair(a,d));
+	}
+
+	void shortestPath(int src);
+};
+
+void Graph::shortestPath(int src){
+	priority_queue < iPair , std::vector<iPair> , greater<iPair> > pq;
+	std::vector<int> distance(V,INF);
+
+	pq.push(make_pair(0,src));
+	distance[src] = 0;
+	while(!pq.empty()){
+		int u = pq.top().second;
+		pq.pop();
+
+		for(int i=0;i<v[u].size();i++){
+			int vertex = v[u][i].first;
+			int dist = v[u][i].second;
+
+			if(distance[vertex] > dist + distance[u]){
+				distance[vertex] = dist + distance[u];
+				pq.push(make_pair(distance[vertex],vertex));
+			} 
+		}
+	}
+
+	cout << "Shortest path of all the nodes from " << src << " node is\n";
+	for(int i=0;i<V;i++){
+		cout << i << " "  << distance[i] << endl;
+	}
+}
+
+int main(int argc, char const *argv[])
+{
+	int V=9;
+	Graph g(V);
+
+	g.addEdge(0, 1, 4);
+    g.addEdge(0, 7, 8);
+    g.addEdge(1, 2, 8);
+    g.addEdge(1, 7, 11);
+    g.addEdge(2, 3, 7);
+    g.addEdge(2, 8, 2);
+    g.addEdge(2, 5, 4);
+    g.addEdge(3, 4, 9);
+    g.addEdge(3, 5, 14);
+    g.addEdge(4, 5, 10);
+    g.addEdge(5, 6, 2);
+    g.addEdge(6, 7, 1);
+    g.addEdge(6, 8, 6);
+    g.addEdge(7, 8, 7);
+ 
+    g.shortestPath(0);
+	return 0;
+}

Graphs/a.out

@@ -0,0 +1,76 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+pair< pair<int,int> , int> queries[100050];
+long long current_answer;
+long long cnt[100050];
+long long answers[100050];
+int BLOCK_SIZE;
+int arr[100050];
+
+bool mo_comp(const pair< pair<int,int>,int > &x,const pair< pair<int,int>,int > &y){
+	int block_x = x.first.first/BLOCK_SIZE;
+	int block_y = y.first.first/BLOCK_SIZE;
+	if(block_x != block_y)
+		return block_x < block_y ;
+	return x.first.second < y.first.second;
+}
+
+void add(int x){
+	current_answer -= cnt[x] * cnt[x] * x ;
+	cnt[x]++;
+	current_answer += cnt[x] * cnt[x] * x ;   
+}
+
+void remove(int x){
+	current_answer -= cnt[x] * cnt[x] * x;
+    cnt[x]--;
+    current_answer += cnt[x] * cnt[x] * x;
+}
+
+int main(int argc, char const *argv[])
+{
+	ios_base::sync_with_stdio(false);
+	cin.tie(NULL);
+	int N,Q;
+	cin >> N >> Q;
+	for(int i=0;i<N;i++)
+		cin >> arr[i];
+	BLOCK_SIZE = sqrt(N);
+	for(int i=0;i<Q;i++){
+		cin >> queries[i].first.first >> queries[i].first.second ;
+		queries[i].second = i;
+	}
+	sort(queries,queries+Q,mo_comp);
+
+	int mo_left = 0,mo_right = -1;
+	for(int i=0;i<Q;i++){
+		int left = queries[i].first.first;
+		int right = queries[i].first.second;
+
+		while(mo_right < right){
+			mo_right++;
+			add(arr[mo_right]);
+		}
+
+		while(mo_right > right){
+			remove(arr[mo_right]);
+			mo_right--;
+		}
+
+		while(mo_left < left){
+			remove(arr[mo_left]);
+			mo_left++;
+		}
+
+		while(mo_left > left){
+			mo_left--;
+			add(arr[mo_left]);
+		}
+		answers[queries[i].second] = current_answer;
+	}
+	for(int i=0;i<Q;i++){
+		cout << answers[i] << '\n';
+	}
+	return 0;
+}

Mo-sAlgorithm.cpp

@@ -0,0 +1,94 @@
+#include<iostream>
+#include<math.h>
+#include<string.h>
+#include<stdlib.h>
+
+#define DIFF_SIZE 100000
+using namespace std;
+
+int myPrimes[DIFF_SIZE];
+int cnt;
+
+void populateMyPrimes(int N) // i need to find the primes upto root(N)
+{
+int i=0,j=0;
+bool primeArray[DIFF_SIZE];
+for(i=2;i<DIFF_SIZE;i++)
+{
+primeArray[i]=true;
+myPrimes[i]=0;//myPrimes[] array will hold our primes calculated via traditional sieve
+}
+int myRange=floor(sqrt((double)N)); //we need to calculate prime numbers till myRange
+//TRADITIONAL SIEVE STARTS HERE
+
+int k=floor(sqrt((double)myRange));//to calculate prime numbers till myRange,loop needs to run till sqrt(myRange)
+for(i=2;i<=k;i=i++)
+{
+if(primeArray[i]==true)
+{
+for(j=i*i;j<=myRange;j=j+i)
+{
+primeArray[j]=false; // j is a composite number
+}
+}
+}
+cnt=0; //stores the number of primes till sqrt(N)
+for(i=2;i<=myRange;i++)
+{
+if(primeArray[i] == true) // false means composite number,true means prime number
+{
+myPrimes[cnt++]=i; //store the primes in myPrimes[]
+}
+}
+cout<<endl;
+}
+
+int main()
+{
+int T;//the number of test cases
+scanf("%d",&T);
+int i,p=0,s;
+
+int N;//larger number
+int M;//smaller number
+bool primesNow[DIFF_SIZE];
+
+while(T--)
+{
+scanf("%d %d",&M,&N); //input the range
+
+for(i=0;i<DIFF_SIZE;i++)
+primesNow[i]=true;  //initialise to all true . we will mark the composite number as false and then
+//the remaining true numbers will be prime
+
+populateMyPrimes(N); //this populates the primes in sqrt(N) in an array myPrimes
+
+for(i=0;i<cnt;i++)  //for each prime in sqrt(N) we need to use it in the segmented sieve process
+{
+p=myPrimes[i]; //store the prime
+s=M/p;
+s=s*p; //the closest number less than M that is a composite number for this prime p
+
+for(int j=s;j<=N;j=j+p)
+{
+if(j<M) continue; //because composite numbers less than M are of no concern to use.
+primesNow[j-M]=false;//j-M = index in the array primesNow,this is because max index allowed in the array
+//is not N ,it is DIFF_SIZE so we are storing the numbers offset from M
+//while printing we will add M and print to get the actual number
+}
+}
+
+for(int i=0;i<cnt;i++)     //in the above loop the first prime numbers for example say 2,3 are also set to false
+{                          //hence we need to print them in case they  are within range.
+if(myPrimes[i]>=M && myPrimes[i]<=N) //without this loop you will see that for an range(1,30), 2 and 3 does
+cout<<myPrimes[i]<<endl;         //not get printed
+}
+
+for(int i=0;i<N-M+1;++i) // primesNow[]=false for all composite numbers,so prime numbers can be found by checking with true
+{
+if(primesNow[i] == true && (i+M)!=1) //i+M != 1 to ensure that for i=0 and M=1 , 1 is not considered a prime number
+cout<<i+M<<endl; //print our prime numbers in the range
+}
+}
+return 0;
+}

SegmentedSieve.cpp

@@ -0,0 +1,103 @@
+#include <bits/stdc++.h>
+using namespace std;
+int isPrime[1000005];
+int minPrime[1000005];
+void sieveOfEratosthenes(int n){
+	for(int i=0;i<=n;i++)
+		isPrime[i] = 1;
+	isPrime[0] = isPrime[1] = 0;
+	for(int i=2;i<=n;i++){
+		if(isPrime[i] == 1){
+			for(int j=i*i;j<=n;j+=i)
+				isPrime[j]=0;
+		}
+	}
+	return ;
+}
+
+//fast factorization
+std::vector<int> v;
+int k;
+std::vector<int> factorization(int n){
+	std::vector<int> res;
+	//res.push_back(1);
+	for(int i=2;i*i<=n;i++){
+		while(n%i == 0){
+			res.push_back(i);
+			n/=i;
+		}
+	}
+	if(n!=1) res.push_back(n);
+	return res;
+}
+
+// void function(int n){
+// 	int minPrime[n+1];
+// 	for(int i=0;i<=n;i++)
+// 		minPrime[i] = !isPrime[i];
+// 	for(int i=2;i*i<=n;i++){
+// 		if(minPrime[i] == 0){   
+// 			for(int j=i*i;j<=n;j+=i){
+// 				if(minPrime[j] == )
+// 					minPrime[j] = ;
+// 			}
+// 		}
+// 	}
+// }
+
+// log(n) factorization
+std::vector<int> factorizationlog(int n){
+	for(int i=0;i<=n;i++)
+		minPrime[i] = 0;
+	minPrime[0] = minPrime[1] = 1;
+	for(int i=2;i*i<=n;i++){
+		if(minPrime[i] == 0){     /// if i is prime
+			for(int j=i*i;j<=n;j+=i){
+				if(minPrime[j] == 0)
+					minPrime[j] = i;
+			}
+		}
+	}
+
+	for(int i=2;i<=n;i++){
+		if(minPrime[i] == 0)
+			minPrime[i] =  i;
+	}
+
+	std::vector<int> res;
+	std::map<int,int> m;
+	std::map<int,int>::iterator it;
+		while(n != 1){
+			res.push_back(minPrime[n]);
+			m[minPrime[n]]++;
+			n /= minPrime[n];
+	}
+	cout << "map is \n";
+	for(it=m.begin();it!=m.end();it++){
+		cout << it->first << " " << it->second << endl;
+	}
+	cout << endl;
+	return res;
+}
+
+
+int main(int argc, char const *argv[])
+{
+	int n;
+	cin >> n;
+	sieveOfEratosthenes(n);
+	for(int i=2;i<=n;i++){
+		if(isPrime[i])
+			cout << i << " ";
+	}
+	cout << "\n";
+	std::vector<int> factors = factorization(n);
+	for(int i=0;i<factors.size();i++)
+		cout << factors[i] << " ";
+	cout << endl;
+	//cout << n << "\n";
+	std::vector<int> factors2 = factorizationlog(n);
+	for(int i=0;i<factors2.size();i++)
+		cout << factors2[i] << " ";
+	return 0;
+}