initial commit

Author: Nadim-Mahmud

Source/Big Interger/factorial.cpp

@@ -0,0 +1,34 @@
+
+///    ***Bigint Factorial ****
+
+//package main;
+
+import java.math.BigInteger;
+import java.util.Scanner;
+
+public class Main {
+
+	public static Scanner sc;
+
+	public static void main(String [] arg) {
+
+		BigInteger [] fact = new BigInteger[200];
+
+    	fact[0] = BigInteger.ONE;
+
+		for(int i=1;i<=150;i++) {
+			fact[i] = fact[i-1].multiply(new BigInteger(i + ""));
+		}
+
+        sc = new Scanner(System.in);
+        int ts = sc.nextInt();
+        int n,cas=0;
+
+        while(++cas<=ts) {
+        	n = sc.nextInt();
+        	System.out.println(fact[n]);
+        }
+	}
+}
+
+

Source/Computetional Geometry/Covex Hull (Graham Scan) .cpp

@@ -0,0 +1,110 @@
+
+///    *** Convex Hull[Grahams Scan]  [nlog(n)]
+
+#define ll long long
+struct point{
+    ll x,y;
+}convex_points[MX],points[MX];;
+
+/// global scope decraltion of min-left point of collcetion
+point pivot;
+
+///Distance calculation mathod
+ll dist(point p1,point p2){
+    return ((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y));
+}
+
+/**
+*   https://www.geeksforgeeks.org/orientation-3-ordered-points/
+*   calculating orientation based on slope (yi-yj)/(xi-xj)
+*   by compering slope of p-q and q-r;
+*   if p-q<q-r then counter-clockwise
+*   @return 0 if colinear
+*   @return 1 if clockwise (Right rotetion)
+*   @return 2 if counter-clockwise (left rotetion)
+*/
+int orientation(point p,point q,point r){
+    ll val = ((q.y-p.y)*(r.x-q.x) - (r.y-q.y)*(q.x-p.x));
+    if(val==0) return 0;
+    if(val>0) return 1;
+    return 2;
+}
+
+/**
+*   sorting by polor angle in counterclockwise order around point0.
+*   If polor angle of two points is same, then put the nearest point first.
+*/
+bool cmp(point p1,point p2){
+    ll o = orientation(pivot,p1,p2);
+    if(o==0){
+        return dist(pivot,p1) < dist(pivot,p2);
+    }
+    return (o==2);
+}
+
+/// returning previous value of top element
+inline point nextToTop(stack<point>&st){
+    point p,res;
+    p = st.top();
+    st.pop();
+    res = st.top();
+    st.push(p);
+    return res;
+}
+
+int total;
+
+/**
+*   This function will calculate convexHull points
+*   All arrays are in 0 based indexing
+*   @param n total numbers of points
+*/
+bool convexHull(int n){
+    ll i,pos=0,in=0,miny = points[0].y,minx = points[0].x;
+    stack<point>st;
+
+    /// Finding bottom-left most point
+    for(i=0;i<n;i++){
+        if((miny==points[i].y&&minx>points[i].x)||miny>points[i].y){
+            minx = points[i].x;
+            miny = points[i].y;
+            pos = i;
+        }
+    }
+
+    ///sorting element according to the criteria
+    swap(points[0],points[pos]);
+    pivot = points[0];
+    sort(points+1,points+n,cmp);
+
+    ///Now removing same angle point
+    for(i=1;i<n;i++){
+        while(i<n-1&&orientation(pivot,points[i],points[i+1])==0){
+            i++;
+        }
+        points[++in] = points[i];
+    }
+    if(in<2) return 0;
+
+    st.push(points[0]);
+    st.push(points[1]);
+    st.push(points[2]);
+    for(i=3;i<=in;i++){
+        ///only valid sequence is ant-clockwise
+        while(orientation(nextToTop(st),st.top(),points[i])!=2){
+            st.pop();
+        }
+        st.push(points[i]);
+    }
+
+    in = total = st.size();
+    point tmp;
+    /// storing convex points
+    while(!st.empty()){
+        tmp = st.top();
+        st.pop();
+        convex_points[--in] = tmp;
+    }
+    return 1;
+}
+

Source/Data Structure/binary indexed tree.cpp

@@ -0,0 +1,24 @@
+
+///   *** BIT [Log(n)] space [n]
+
+/**   1 based index
+*     which functions has inverse function that can be solve bye BIT
+*     it works like consucative sums but in log(n)
+*/
+
+int n=SIZE of space;
+void update(int idx,int val)//adding value val to idx index
+{
+    while(idx<=n){
+        bitree[idx]+=val;
+        idx+=idx&(-idx); // Last set of digit
+    }
+}
+int query(int idx){// returns sum of 1 to idx index
+    int sum=0;
+    while(idx>0){
+        sum+=bitree[idx];
+        idx-=idx&(-idx);
+    }
+    return sum;
+}

Source/Data Structure/disjoint set.cpp

@@ -0,0 +1,11 @@
+
+///  *** Disjoint Set Union Find [n||1]
+
+int parent(int n)
+{
+    if(rp[n]==n)return n;
+    return rp[n]=parent(rp[n]);
+}
+void setUp(int a,int b){
+    rp[parent(b)]=parent(a);
+}

Source/Data Structure/merge sort tree.cpp

@@ -0,0 +1,102 @@
+///   *** Merge Sort Tree [nlog(n) + query*log(n)*log(n)]
+
+
+int ara[MX];
+vector<int>seg[MX*4];
+/// 1 based index
+
+int bns(int n,int val){
+    /// lower bound 1 2 2 2 3 4
+    /// then returns 2
+    int mid,i,j,low=0,high = seg[n].size()-1;
+    while((high-low)>4){
+        mid = (low+high)/2;
+        if(seg[n][mid]<=val) low = mid;
+        else high = mid - 1;
+    }
+    for(low;low<=high&&low<seg[n].size();low++){
+        if(seg[n][low]>val) break;
+    }
+    return seg[n].size()-low; /// numbers greater than value
+}
+
+void mergee(int x,int y,int z){ /// merging 2 vector x and y to Z in sorted order
+    int i,j,k,md,sz;
+    sz = seg[x].size() + seg[y].size();
+    for(i=0,j=0,k=0;k<sz;k++){
+        if(i>=seg[x].size()) seg[z].push_back(seg[y][j++]);
+        else if(j>=seg[y].size()) seg[z].push_back(seg[x][i++]);
+        else if(seg[x][i]<seg[y][j]) seg[z].push_back(seg[x][i++]);
+        else seg[z].push_back(seg[y][j++]);
+    }
+}
+
+/** [low,high]  total range :: variable range
+*   [qlow,qhigh] query range
+*   pos = current position
+*/
+void creat(int low,int high,int pos){ /// creating merge sort tree
+    if(low==high){
+        seg[pos].push_back(ara[low]);
+        return ;
+    }
+    int mid = (low+high)/2;
+    creat(low,mid,pos*2);
+    creat(mid+1,high,pos*2+1);
+    mergee(pos*2,pos*2+1,pos);
+    /// merge with stl
+    /// merge(seg[pos*2].begin() , seg[pos*2].end(), seg[pos*2].begin(), seg[pos*2].end(),back_inserter(seg[pos]));
+}
+
+int query(int low,int high,int qlow,int qhigh,int pos,int val){
+    if(qlow>qhigh) return 0;
+    if(qlow>high||qhigh<low) return 0;
+    if(qlow<=low&&qhigh>=high){
+        return bns(pos,val);
+    }
+    int mid = (low + high)/2;
+    return query(low,mid,qlow,qhigh,pos*2,val) + query(mid+1,high,qlow,qhigh,pos*2+1,val);
+}
+
+/// *** For Rnage orders statistics (find k'th number in sorted segment)
+
+vector<pii>input;
+vector<int>seg[MX*4];
+
+void creat(int low,int high,int pos){ /// creating merge sort tree
+    if(low==high){
+        seg[pos].push_back(input[low-1].second); /// in is 0 based
+        return ;
+    }
+    int mid = (low+high)/2;
+    creat(low,mid,pos*2);
+    creat(mid+1,high,pos*2+1);
+    mergee(pos*2,pos*2+1,pos);
+}
+
+/** calculating total number in left range lower than the given index
+*  if numbers are greater than equals to the searging value than look into left
+*  searhing on right sub array and substracting left sub arrys given up values
+*/
+
+int query(int low,int high,int qlow,int qhigh,int pos,int val)
+{
+    if(low==high) return seg[pos][0];
+    int mid = (low+high)>>1,left=pos<<1;
+
+    int total = upper_bound(seg[left].begin(),seg[left].end(),qhigh) -
+    lower_bound(seg[left].begin(),seg[left].end(),qlow);
+
+    if(total>=val){
+        return query(low,mid,qlow,qhigh,pos*2,val);
+    }
+    else{
+        return query(mid+1,high,qlow,qhigh,pos*2+1,val-total);
+    }
+}
+
+sort(input.begin(),input.end());
+
+
+
+

Source/Data Structure/segmet tree.cpp

@@ -0,0 +1,74 @@
+/// *** Segment Tree [log(total array size)*Query]
+
+/** [ulow,uhigh] Query Range
+*   [low,high] total range of root
+*   [qlow,qhigh] Query Range
+*   Currrent position = pos
+*   0 based Index And Root is also 0
+*/
+
+int ara[MX],seg[4*MX],lazy[4*MX];
+
+void creat(int low,int high,int pos)
+{
+    if(low==high){
+        seg[pos] = ara[low]; // reached leaf and update
+        return ;
+    }
+    int mid = (high+low)/2;
+    creat(low,mid,pos*2+1);
+    creat(mid+1,high,pos*2+2);
+    seg[pos] += seg[pos*2+1] + seg[pos*2+2];
+}
+
+void update(int low,int high,int ulow,int uhigh,int val,int pos)
+{
+    if(low>high) return ;
+    if(lazy[pos]!=0){ /// is not propagated yet
+        seg[pos] = 0;
+        if(low!=high){  ///if not leaf node
+            lazy[pos*2+1] += lazy[pos];
+            lazy[pos*2+2] += lazy[pos];
+        }
+        lazy[pos] = 0;
+    }
+
+    if(ulow>high||uhigh<low) return; ///No overlap
+    if(ulow<=low&&uhigh>=high){ /// Total Overlap
+        seg[pos] += val;
+        if(low!=high){
+            lazy[pos*2+1] += val;
+            lazy[pos*2+2] += val;
+        }
+        return;
+    }
+    /// Partial overlap
+    int mid = (high+low)/2;
+
+    update(low,mid,ulow,uhigh,val,pos*2+1);
+    update(mid+1,high,ulow,uhigh,val,pos*2+2);
+    seg[pos] = seg[pos*2+1] + seg[pos*2+2]; /// Updating the intermediate node
+}
+
+int query(int low,int high,int qlow,int qhigh,int pos)
+{
+    if(low>high) return 0;
+    if(lazy[pos]!=0){
+        seg[pos] += lazy[pos];
+        if(low!=high){
+            lazy[pos*2+1] += lazy[pos];
+            lazy[pos*2+2] += lazy[pos];
+        }
+        lazy[pos] = 0;
+    }
+
+    if(qlow>high||qhigh<low) return 0;
+
+    if(qlow<=low&&qhigh>=high)
+        return seg[pos];
+
+    int mid = (high+low)/2;
+
+    return query(low,mid,qlow,qhigh,pos*2+1) + query(mid+1,high,qlow,qhigh,pos*2+2);
+}
+