🚀 29-Jun-2020

Author: sureshmangs

competitive programming/leetcode/2020-June-Challenge/Day-28-Reconstruct Itinerary.cpp

@@ -0,0 +1,60 @@
+Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.
+
+Note:
+
+If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary ["JFK", "LGA"] has a smaller lexical order than ["JFK", "LGB"].
+All airports are represented by three capital letters (IATA code).
+You may assume all tickets form at least one valid itinerary.
+One must use all the tickets once and only once.
+Example 1:
+
+Input: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
+Output: ["JFK", "MUC", "LHR", "SFO", "SJC"]
+Example 2:
+
+Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
+Output: ["JFK","ATL","JFK","SFO","ATL","SFO"]
+Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"].
+But it is larger in lexical order.
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> findItinerary(vector<vector<string>>& tickets) {
+        unordered_map<string, multiset<string> > adj;
+        vector<string> res;
+        int n=tickets.size();
+        for(int i=0;i<n;i++){
+            adj[tickets[i][0]].insert(tickets[i][1]);
+        }
+        stack<string> s;
+        s.push("JFK");
+
+        while(!s.empty()){
+            string src=s.top();
+            if(adj[src].size()==0){ // no further travel possible
+                res.push_back(src);
+                s.pop();
+            } else {
+                auto dst=adj[src].begin();
+                s.push(*dst);
+                adj[src].erase(dst);
+            }
+        }
+
+        reverse(res.begin(), res.end());
+
+        return res;
+    }
+};
+
+
+

competitive programming/leetcode/332. Reconstruct Itinerary.cpp

@@ -0,0 +1,57 @@
+Given a list of airline tickets represented by pairs of departure and arrival airports [from, to], reconstruct the itinerary in order. All of the tickets belong to a man who departs from JFK. Thus, the itinerary must begin with JFK.
+
+Note:
+
+If there are multiple valid itineraries, you should return the itinerary that has the smallest lexical order when read as a single string. For example, the itinerary ["JFK", "LGA"] has a smaller lexical order than ["JFK", "LGB"].
+All airports are represented by three capital letters (IATA code).
+You may assume all tickets form at least one valid itinerary.
+One must use all the tickets once and only once.
+Example 1:
+
+Input: [["MUC", "LHR"], ["JFK", "MUC"], ["SFO", "SJC"], ["LHR", "SFO"]]
+Output: ["JFK", "MUC", "LHR", "SFO", "SJC"]
+Example 2:
+
+Input: [["JFK","SFO"],["JFK","ATL"],["SFO","ATL"],["ATL","JFK"],["ATL","SFO"]]
+Output: ["JFK","ATL","JFK","SFO","ATL","SFO"]
+Explanation: Another possible reconstruction is ["JFK","SFO","ATL","JFK","ATL","SFO"].
+But it is larger in lexical order.
+
+
+
+
+
+
+
+
+
+
+class Solution {
+public:
+    vector<string> findItinerary(vector<vector<string>>& tickets) {
+        unordered_map<string, multiset<string> > adj;
+        vector<string> res;
+        int n=tickets.size();
+        for(int i=0;i<n;i++){
+            adj[tickets[i][0]].insert(tickets[i][1]);
+        }
+        stack<string> s;
+        s.push("JFK");
+
+        while(!s.empty()){
+            string src=s.top();
+            if(adj[src].size()==0){ // no further travel possible
+                res.push_back(srac);
+                s.pop();
+            } else {
+                auto dst=adj[src].begin();
+                s.push(*dst);
+                adj[src].erase(dst);
+            }
+        }
+
+        reverse(res.begin(), res.end());
+
+        return res;
+    }
+};

linked list/merge_two_sorted_list.cpp

@@ -0,0 +1,154 @@
+/*
+Given two sorted linked lists consisting of N and M nodes respectively. The task is to merge both of the list (in-place) and return head of the merged list.
+Note: It is strongly recommended to do merging in-place using O(1) extra space.
+
+Input:
+First line of input contains number of testcases T. For each testcase, first line of input contains N and M, and next two line contains N and M sorted elements in two lines for each.
+
+Output:
+For each testcase, print the merged list in sorted form.
+
+User Task:
+The task is to complete the function sortedMerge() which takes references to the heads of two linked lists as the arguments and returns the head of merged linked list.
+
+Expected Time Complexity : O(n+m)
+Expected Auxilliary Space : O(1)
+
+Constraints:
+1 <= T <= 100
+1 <= N, M <= 104
+1 <= Node's data <= 105
+
+Example:
+Input:
+2
+4 3
+5 10 15 40
+2 3 20
+2 2
+1 1
+2 4
+Output:
+2 3 5 10 15 20 40
+1 1 2 4
+
+Explanation:
+Testcase 1: After merging the two linked lists, we have merged list as 2, 3, 5, 10, 15, 20, 40.
+Testcase 2: After merging the given two linked list , we have 1, 1, 2, 4 as output.
+*/
+
+
+
+
+
+
+// { Driver Code Starts
+#include<iostream>
+using namespace std;
+
+/* Link list Node */
+struct Node {
+  int data;
+  struct Node *next;
+
+  Node(int x) {
+    data = x;
+    next = NULL;
+  }
+};
+
+Node* sortedMerge(struct Node* a, struct Node* b);
+
+
+/* Function to print Nodes in a given linked list */
+void printList(struct Node *n)
+{
+    while (n!=NULL)
+    {
+        cout << n->data << " ";
+        n = n->next;
+    }
+    cout << endl;
+}
+
+/* Driver program to test above function*/
+int main()
+{
+    int t;
+    cin>>t;
+    while(t--)
+    {
+        int n,m;
+        cin>>n>>m;
+
+        int data;
+        cin>>data;
+        struct Node *head1 = new Node(data);
+        struct Node *tail1 = head1;
+        for (int i = 1; i < n; ++i)
+        {
+            cin>>data;
+            tail1->next = new Node(data);
+            tail1 = tail1->next;
+        }
+
+        cin>>data;
+        struct Node *head2 = new Node(data);
+        struct Node *tail2 = head2;
+        for(int i=1; i<m; i++)
+        {
+            cin>>data;
+            tail2->next = new Node(data);
+            tail2 = tail2->next;
+        }
+
+        Node *head = sortedMerge(head1, head2);
+        printList(head);
+    }
+    return 0;
+}
+// } Driver Code Ends
+
+
+
+
+/* Link list Node
+struct Node {
+  int data;
+  struct Node *next;
+
+  Node(int x) {
+    data = x;
+    next = NULL;
+  }
+};
+*/
+
+Node* sortedMerge(Node* h1, Node* h2)
+{
+    if(!h1) return h1;
+    if(!h2) return h1;
+
+    struct Node *start=(struct Node*)malloc(sizeof(struct Node)); // dummy
+    struct Node *tail=start;
+
+    while(h1 && h2){
+        if(h1->data <= h2->data){
+            tail->next=h1;
+            tail=tail->next;
+            h1=h1->next;
+        } else {
+            tail->next=h2;
+            tail=tail->next;
+            h2=h2->next;
+        }
+    }
+    if(h1){
+        tail->next=h1;
+    }
+    if(h2){
+        tail->next=h2;
+    }
+
+    return start->next;
+}

linked list/pairwise_swap.cpp

@@ -1,3 +1,42 @@
+/*
+Given a singly linked list of size N. The task is to swap elements in the linked list pairwise.
+For example, if the input list is 1 2 3 4, the resulting list after swaps will be 2 1 4 3.
+
+Input:
+The first line of input contains the number of test cases T. For each test case, the first line of input contains the length of the linked list and the next line contains linked list data.
+
+Output:
+Output the linked list after swapping pairwise nodes.
+
+User Task:
+The task is to complete the function pairWiseSwap() which takes the head node as the only argument and returns the modified head.
+
+Expected Time Complexity: O(N).
+Expected Auxiliary Space: O(1).
+
+Constraints:
+1 <= T <= 100
+1 <= N <= 103
+
+Example:
+Input:
+1
+8
+1 2 2 4 5 6 7 8
+
+Output:
+2 1 4 2 6 5 8 7
+
+Explanation:
+Testcase 1: After swapping each pair considering (1,2), (2, 4), (5, 6).. so on as pairs, we get 2, 1, 4, 2, 6, 5, 8, 7 as a new linked list.
+*/
+
+
+
+
+
+
+
 #include<bits/stdc++.h>
 using namespace std;
 

linked list/palindrome_check.cpp

@@ -1,3 +1,46 @@
+/*
+Given a singly linked list of size N of integers. The task is to check if the given linked list is palindrome or not.
+Expected Time Complexity: O(N)
+Expected Auxialliary Space Usage: O(1)  (ie, you should not use the recursive stack space as well)
+
+Input:
+First line of input contains number of testcases T. For each testcase, first line of input contains length of linked list N and next line contains N integers as data of linked list.
+
+Output:
+For each test case output will be 1 if the linked list is a palindrome else 0.
+
+User Task:
+The task is to complete the function isPalindrome() which takes head as reference as the only parameter and returns true or false if linked list is palindrome or not respectively.
+
+Constraints:
+1 <= T <= 103
+1 <= N <= 50
+
+Example:
+Input:
+2
+3
+1 2 1
+4
+1 2 3 4
+Output:
+1
+0
+
+Explanation:
+Testcase 1: The given linked list is 1 2 1 , which is a pallindrome and Hence, the output is 1.
+Testcase 2: The given linked list is 1 2 3 4 , which is not a pallindrome and Hence, the output is 0.
+*/
+
+
+
+
+
+
+
+
+
+
 #include<bits/stdc++.h>
 using namespace std;