Practise 17-Jul-2020

Author: sureshmangs

algorithms/graph/dijkstras_algorithm.cpp

@@ -0,0 +1,51 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define INF INT_MAX
+typedef pair<int, int> iPair;
+
+void adjListGraph(vector<pair<int, int> > adj[], int s, int d, int w){
+    // undirected graph
+    adj[s].push_back({d, w});
+    adj[d].push_back({s, w});
+}
+
+void dijkstras(vector<pair<int, int> > adj[], int V, int src){
+    priority_queue<iPair, vector<iPair>, greater<iPair> > pq;     // min heap
+    vector<int> dist(V, INF);    // create a vector for distances and initialize all distances as infinite (INF)
+    pq.push({0, src});
+    dist[src]=0;
+
+    while(!pq.empty()){
+        int u=pq.top().second;  // pair<distance, vertex >
+        pq.pop();
+        for(auto x: adj[u]){
+            int v=x.first;     // pair<vertex, weight >
+            int w=x.second;
+
+            if(dist[v]>dist[u]+w){
+                dist[v]=dist[u]+w;
+                pq.push({dist[v], v});
+            }
+        }
+    }
+    cout<<endl;
+    cout<<"Vertex  Distance"<<endl;
+    for(int i=0;i<V;i++){
+        cout<<i<<"          "<<dist[i]<<endl;
+    }
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int v,e;
+    cin>>v>>e;
+    vector<pair<int, int> > adj[v];
+    while(e--){
+        int s,d,w;
+        cin>>s>>d>>w;
+        adjListGraph(adj,s,d,w);
+    }
+    dijkstras(adj, v, 0);    // source is 0
+}

algorithms/graph/kosarajus_algorithm.cpp

@@ -0,0 +1,68 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+void adjListGraph(vector<int> adj[], int s, int d){
+    // directed graph
+    adj[s].push_back(d);
+}
+
+void dfs(vector<int> adj[], int s, bool vis[], stack<int> &st){
+    vis[s]=true;
+    for(auto x : adj[s]){
+        if(!vis[x]){
+            dfs(adj, x, vis,st);
+        }
+    }
+    st.push(s);
+}
+
+void invertGraph(vector<int>iadj[], vector<int>adj[], int v){
+
+    for(int i=0;i<v;i++){
+        for(auto x: adj[i]){
+            iadj[x].push_back(i);
+        }
+    }
+}
+
+void reDfs(vector<int>iadj[], int s, bool vis[]){
+    vis[s]=true;
+    cout<<s<<" ";
+    for(auto x: iadj[s]){
+        if(!vis[x]){
+            reDfs(iadj, x, vis);
+        }
+    }
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int v,e;
+    cin>>v>>e;
+    vector<int> adj[v];
+    while(e--){
+        int s,d;
+        cin>>s>>d;
+        adjListGraph(adj,s,d);
+    }
+    int s=0;   // source is node 0
+    bool vis[v];
+    memset(vis, false, sizeof(vis));
+    stack<int> st;
+    dfs(adj, s, vis, st);     // STEP 1
+    vector<int>iadj[v];
+    invertGraph(iadj, adj, v);  // STEP 2
+    memset(vis, false, sizeof(vis));    // STEP 3
+    while(!st.empty()){
+        int yy=st.top();
+        st.pop();
+        if(!vis[yy]){
+            cout<<"SCC: ";
+            reDfs(iadj, yy, vis);
+            cout<<endl;
+        }
+    }
+}
+
+

algorithms/graph/prims_mst_algorithm.cpp

@@ -0,0 +1,106 @@
+/*
+Steps
+1) Initialize keys of all vertices as infinite and
+   parent of every vertex as -1.
+
+2) Create an empty priority_queue pq.  Every item
+   of pq is a pair (weight, vertex). Weight (or
+   key) is used used as first item  of pair
+   as first item is by default used to compare
+   two pairs.
+
+3) Initialize all vertices as not part of MST yet.
+   We use boolean array inMST[] for this purpose.
+   This array is required to make sure that an already
+   considered vertex is not included in pq again. This
+   is where Ptim's implementation differs from Dijkstra.
+   In Dijkstr's algorithm, we didn't need this array as
+   distances always increase. We require this array here
+   because key value of a processed vertex may decrease
+   if not checked.
+
+4) Insert source vertex into pq and make its key as 0.
+
+5) While either pq doesn't become empty
+    a) Extract minimum key vertex from pq.
+       Let the extracted vertex be u.
+
+    b) Include u in MST using inMST[u] = true.
+
+    c) Loop through all adjacent of u and do
+       following for every vertex v.
+
+           // If weight of edge (u,v) is smaller than
+           // key of v and v is not already in MST
+           If inMST[v] = false && key[v] > weight(u, v)
+
+               (i) Update key of v, i.e., do
+                     key[v] = weight(u, v)
+               (ii) Insert v into the pq
+               (iv) parent[v] = u
+
+6) Print MST edges using parent array.
+*/
+
+
+
+
+
+
+#include<bits/stdc++.h>
+using namespace std;
+
+#define INF INT_MAX
+typedef pair<int, int> iPair;
+
+void adjListGraph(vector<pair<int, int> > adj[], int s, int d, int w){
+    // undirected graph
+    adj[s].push_back({d, w});
+    adj[d].push_back({s, w});
+}
+
+void prims(vector<pair<int, int> > adj[], int V){
+    priority_queue<iPair, vector<iPair>, greater<iPair> > pq;     // min heap
+    int src=0;
+    vector<int> key(V, INF);         // weights
+    vector<int> parent(V, -1);       //  u ----> v  edge then u is parent of v
+    vector<bool> inMST(V,false);     //  keep track of vertices included in MST
+
+    pq.push({0, src});      // insert source itself in priority queue
+    key[src]=0;             // and initialize its key as 0
+
+    while(!pq.empty()){
+        int u=pq.top().second;      // pait< key, vertex>
+        pq.pop();
+        inMST[u]=true;
+        for(auto x: adj[u]){
+            int v=x.first;         //  vector<vertex, weight>
+            int w=x.second;
+
+            // If v is not in MST and weight of (u,v) is smaller than current key of v
+            if(inMST[v]==false && w<key[v]){
+                key[v]=w;
+                pq.push({key[v], v});
+                parent[v]=u;
+            }
+        }
+    }
+    cout<<"Edge      Weight"<<endl;
+    for(int i=1;i<V;i++){
+        cout<<parent[i]<<" - "<<i<<"        "<<key[i]<<endl;
+    }
+}
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    int v,e;
+    cin>>v>>e;
+    vector<pair<int, int> > adj[v];
+    while(e--){
+        int s,d,w;
+        cin>>s>>d>>w;
+        adjListGraph(adj,s,d,w);
+    }
+    prims(adj, v);
+}

array/top_k_frequent_nums_min_heap.cpp

@@ -0,0 +1,31 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+typedef pair<int,int> iPair;
+
+int main(){
+    ios_base::sync_with_stdio(false);
+    cin.tie(NULL);
+    cout.tie(NULL);
+    int t;
+    cin>>t;
+    while(t--){
+        int n, k;
+        cin>>n>>k;
+        int a[n];
+        for(int i=0;i<n;i++) cin>>a[i];
+
+        priority_queue<iPair, vector<iPair>, greater<iPair> > minh;   // min heap
+        unordered_map<int, int> mp;  // calculating frequencies
+        for(int i=0;i<n;i++) mp[a[i]]++;
+        for(auto it=mp.begin(); it!=mp.end(); it++){
+            minh.push({it->second, it->first});
+            if(minh.size()> k) minh.pop();
+        }
+        while(!minh.empty()){
+            cout<<minh.top().second<<" ";
+            minh.pop();
+        }
+        cout<<endl;
+    }
+}

competitive programming/leetcode/2020-June-Challenge/Day-16-Validate IP Address.cpp

@@ -0,0 +1,65 @@
+Write a function to check whether an input string is a valid IPv4 address or IPv6 address or neither.
+
+IPv4 addresses are canonically represented in dot-decimal notation, which consists of four decimal numbers, each ranging from 0 to 255, separated by dots ("."), e.g.,172.16.254.1;
+
+Besides, leading zeros in the IPv4 is invalid. For example, the address 172.16.254.01 is invalid.
+
+IPv6 addresses are represented as eight groups of four hexadecimal digits, each group representing 16 bits. The groups are separated by colons (":"). For example, the address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is a valid one. Also, we could omit some leading zeros among four hexadecimal digits and some low-case characters in the address to upper-case ones, so 2001:db8:85a3:0:0:8A2E:0370:7334 is also a valid IPv6 address(Omit leading zeros and using upper cases).
+
+However, we don't replace a consecutive group of zero value with a single empty group using two consecutive colons (::) to pursue simplicity. For example, 2001:0db8:85a3::8A2E:0370:7334 is an invalid IPv6 address.
+
+Besides, extra leading zeros in the IPv6 is also invalid. For example, the address 02001:0db8:85a3:0000:0000:8a2e:0370:7334 is invalid.
+
+Note: You may assume there is no extra space or special characters in the input string.
+
+Example 1:
+Input: "172.16.254.1"
+
+Output: "IPv4"
+
+Explanation: This is a valid IPv4 address, return "IPv4".
+Example 2:
+Input: "2001:0db8:85a3:0:0:8A2E:0370:7334"
+
+Output: "IPv6"
+
+Explanation: This is a valid IPv6 address, return "IPv6".
+Example 3:
+Input: "256.256.256.256"
+
+Output: "Neither"
+
+Explanation: This is neither a IPv4 address nor a IPv6 address.
+
+
+
+
+
+
+class Solution {
+public:
+    string validIPAddress(string IP) {
+        if(count(IP.begin(), IP.end(), '.')==3){
+         if(IP[IP.length()-1]=='.') return "Neither";
+            stringstream s(IP);
+            string tmp;
+            while(getline(s, tmp, '.')){
+                if(tmp.length()==0 || tmp.length()>3) return "Neither";
+                if(tmp[0]=='0' && tmp.length()!=1) return "Neither";
+                for(char c: tmp) if(!isdigit(c)) return "Neither";
+                if(stoi(tmp)>255) return "Neither";
+            }
+            return "IPv4";
+        } else if(count(IP.begin(), IP.end(), ':')==7){
+           if(IP[IP.length()-1]==':') return "Neither";
+            stringstream s(IP);
+            string tmp;
+            while(getline(s, tmp, ':')){
+                if(tmp.length()==0 || tmp.length()>4) return "Neither";
+                for(char c: tmp) if(!isxdigit(c)) return "Neither";
+            }
+            return "IPv6";
+
+        } else return "Neither";
+    }
+};

competitive programming/leetcode/347. Top K Frequent Elements.cpp

@@ -0,0 +1,41 @@
+Given a non-empty array of integers, return the k most frequent elements.
+
+Example 1:
+
+Input: nums = [1,1,1,2,2,3], k = 2
+Output: [1,2]
+Example 2:
+
+Input: nums = [1], k = 1
+Output: [1]
+Note:
+
+You may assume k is always valid, 1 ≤ k ≤ number of unique elements.
+Your algorithm's time complexity must be better than O(n log n), where n is the array's size.
+It's guaranteed that the answer is unique, in other words the set of the top k frequent elements is unique.
+You can return the answer in any order.
+
+
+
+
+
+class Solution {
+public:
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        priority_queue<pair<int,int>, vector<pair<int,int> >, greater<pair<int,int> > > minh;
+        int n=nums.size();
+        unordered_map<int, int> mp;  // calculating frequencies
+        for(int i=0;i<n;i++) mp[nums[i]]++;
+        for(auto it=mp.begin(); it!=mp.end(); it++){
+            minh.push({it->second, it->first});
+            if(minh.size()> k) minh.pop();
+        }
+        vector<int> res;
+        while(!minh.empty()){
+            res.push_back(minh.top().second);
+            minh.pop();
+        }
+        sort(res.begin(), res.end());
+        return res;
+    }
+};