few ques

Author: prajwal714

Leetcode/Arrays/first-missing-positive.cpp

@@ -1,42 +1,44 @@
+
+//we know the answer lies between 1 and n+1 inclusive, 
+// complexity O(n) and O(1)
+
+/* so we simply swap the numbers with their correct correct position numbers, such that i+1=nums[i] for each i
+in case nums[i]<0 || nums[i]>n we simply ignore these values
+
+the smallest i where i+1 != nums[i] is our answer
+ */
+
 class Solution {
 public:
     int firstMissingPositive(vector<int>& nums) {
 
-        int i;
-        int n=nums.size();
+      int n=nums.size();
         if(n==0)
             return 1;
-        
-        
-        bool containsOne=false;
-        for(i=0;i<n;i++)
+        for(int i=0;i<n;i++)
         {
-            if(nums[i]==1)
-                containsOne=true;
-            else if(nums[i]>n||nums[i]<=0)
-                nums[i]=1;
-        }
-        
-        
-        if(containsOne==false)
-            return 1;
-        
-        for(i=0;i<n;i++)
-        {
-            int index=abs(nums[i])-1;
+            if(nums[i]<0 || nums[i]>n)
+                continue;
+                
+            int pos=nums[i]-1;
 
-            if(nums[index]>0)
-                nums[index]=-nums[index];
+            while(nums[i]>=1 && nums[i]<=n && nums[i]!=nums[pos])
+            {
+                swap(nums[i], nums[pos]);
+                pos=nums[i]-1;
+            }
         }
 
-        for(i=0;i<n;i++)
+        for(int i=0;i<n;i++)
         {
-            if(nums[i]>=0)
+            if(nums[i]!=i+1)
+            {
                 return i+1;
+            }
+                
         }
 
         return n+1;
 
-        
     }
-};
+};

Leetcode/DP/jump-game.cpp

@@ -0,0 +1,73 @@
+//dp solution, where we build a dp table and keep track whether the current index is a good pos or not;
+
+// time: O(n^2) space O(n)
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        
+        int n=nums.size();
+        int dp[n];
+        
+        memset(dp, 0, sizeof(dp));
+        
+        
+        int i;
+       dp[n-1]=1;
+       
+        int good_pos=n-1;
+        
+        for(i=n-2;i>=0;i--)
+        {
+            int maxJump=i+nums[i];
+            
+           for(int j=i+1;j<=maxJump; j++)
+           {
+               if(dp[j]==1)
+               {
+                   dp[i]=1;
+                   break;
+               }
+           }
+        }
+       
+        
+        return dp[0]==1;
+    }
+};
+
+
+
+//greedy solution where we keep track of the closest good pos in the left, if the jump range
+// is >= to this position then current position is also a good position
+
+//time complexity: O(n), space O(1)
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        
+        int n=nums.size();
+        int dp[n];
+        
+        memset(dp, 0, sizeof(dp));
+        
+        
+        int i;
+       dp[n-1]=1;
+       
+        int good_pos=n-1;
+        
+        for(i=n-2;i>=0;i--)
+        {
+            int maxJump=i+nums[i];
+            
+            if(maxJump>=good_pos)
+            {
+                good_pos=i;
+                
+            }
+        }
+       
+        
+        return good_pos==0;
+    }
+};

Leetcode/Heap/find-median-from-data-stream.cpp

@@ -0,0 +1,68 @@
+class MedianFinder {
+public:
+    /** initialize your data structure here. */
+    
+     priority_queue<int, vector<int> , greater<int>> highers;
+     priority_queue<int> lowers;
+    
+    
+    MedianFinder() {
+      
+    }
+    
+    void addNum(int num) {
+        
+        
+        if(lowers.size()==0 || num<lowers.top())
+            lowers.push(num);
+        else
+           highers.push(num);
+        
+        //rebalance the two heaps
+        rebalanceHeap();
+       
+            
+    }
+    
+    void rebalanceHeap()
+    {
+        int lowSize=lowers.size(), highSize=highers.size();
+         if(lowSize-highSize>1)
+        {
+         
+            highers.push(lowers.top());
+            lowers.pop();
+        }
+        else if(highSize-lowSize>1)
+        {
+            
+            lowers.push(highers.top());
+            highers.pop();
+            
+        }
+    }
+    
+    double findMedian() {
+        double median=0;
+        if(lowers.size()==highers.size())
+        {
+            median=(lowers.top()+highers.top())/2.0;
+        }
+        else
+        {
+            if(lowers.size()>highers.size())
+                median=lowers.top();
+            else
+                median=highers.top();
+        }
+        
+        return median;
+    }
+};
+
+/**
+ * Your MedianFinder object will be instantiated and called as such:
+ * MedianFinder* obj = new MedianFinder();
+ * obj->addNum(num);
+ * double param_2 = obj->findMedian();
+ */