new solution

Author: stupidjoey

118.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    vector<vector<int>> generate(int numRows) {
+        vector<vector<int>> mat(numRows);
+        for (int i = 0; i < numRows; i++){
+            mat[i].resize(i+1);
+            mat[i][0] = mat[i][i] = 1;
+        }
+        
+        for(int i =1; i< numRows; i++)
+            for(int j = 1; j< i; j++)
+                mat[i][j] = mat[i-1][j-1] + mat[i-1][j];
+        
+        return mat;
+            
+    }
+};

119.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    vector<int> getRow(int rowIndex) {
+        vector<int> result(rowIndex+1,0);
+        result[0] = 1;
+        for(int i = 1; i < rowIndex+1;i++)
+            for(int j =i ; j >=1 ; j--)
+                result[j] += result[j-1];
+                
+        return result;
+    }
+};

34.cpp

@@ -0,0 +1,34 @@
+class Solution {
+public:
+    vector<int> searchRange(vector<int>& nums, int target) {
+        int n = nums.size();
+        int low = 0;
+        int high = n - 1;
+        int mid = 0;
+        int index = -1;
+        while (low <= high){
+            mid = low + (high - low)/2;
+            if(nums[mid] < target)
+                low = mid+1;
+            else if (nums[mid] == target)
+            {
+                index = mid;
+                break;
+            }
+            else
+                high = mid - 1;
+        }
+        
+        if (index != -1){
+            int startIndex = mid;
+            while(startIndex>0 && nums[startIndex-1] == target)
+                startIndex--;
+            int endIndex = mid;
+            while(endIndex<n-1 && nums[endIndex+1] == target)
+                endIndex++;
+            return vector<int>{startIndex,endIndex};
+        }
+        else
+            return vector<int>{-1,-1};
+    }
+};

63.cpp

@@ -0,0 +1,22 @@
+class Solution {
+public:
+    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
+        int m = obstacleGrid.size();
+        int n = obstacleGrid[0].size();
+        vector<int> mat(n,0);
+        mat[0] = 1;
+        
+        for(int i = 0 ; i < m ; i++)
+            for(int j = 0; j<n; j++){
+                if(obstacleGrid[i][j]==1)
+                    mat[j] = 0;
+                else if (j > 0)
+                    mat[j] = mat[j] + mat[j-1];
+           
+            }
+        
+        
+        return mat[n-1];
+        
+    }
+};

73.cpp

@@ -0,0 +1,61 @@
+class Solution {
+public:
+    void setZeroes(vector<vector<int>>& matrix) {
+        int m = matrix.size();
+        int n = matrix[0].size();
+        bool row0 = false, col0 = false;
+        
+        for(int i = 0; i < m; i++)
+        {
+            if (matrix[i][0] == 0)
+            {
+                col0 = true;
+                break;
+            }
+        }
+        
+        for(int j =0; j< n; j++)
+        {
+            if (matrix[0][j] == 0)
+            {
+                row0 = true;
+                break;
+            }
+        }
+        
+        for(int i =1; i < m; i++)
+            for(int j=1; j<n; j++)
+            {
+                if (matrix[i][j] == 0)
+                {
+                    matrix[i][0] = 0;
+                    matrix[0][j] = 0;
+                }
+            }
+        
+        for(int i = 1 ; i < m; i ++)
+            for(int j =1 ; j <n ; j++)
+            {
+                if (matrix[i][0] == 0 || matrix[0][j] == 0)
+                    matrix[i][j] = 0;
+            }
+        
+        
+        if(row0)
+        {
+            for(int j=0;j<n;j++){
+                matrix[0][j] = 0;
+            }
+        }
+        
+        if(col0)
+        {
+            for(int i =0; i<m;i++){
+                matrix[i][0] = 0;
+            }
+        }
+        
+        
+        
+    }
+};

78.cpp

@@ -0,0 +1,47 @@
+class Solution {
+public:
+
+    
+    vector<vector<int>> subsets(vector<int>& nums) {
+        sort(nums.begin(),nums.end());
+        vector<vector<int>> result;
+        result.push_back({});
+        int n = nums.size();
+        for (int i = 0 ;i < n; i++){
+            
+            vector<vector<int>> tempRes = result;
+            int m = tempRes.size();
+            
+            for(int j =0; j< m;j++){
+                
+                tempRes[j].push_back(nums[i]);
+                result.push_back(tempRes[j]);
+
+            }
+            
+        }
+        
+        
+        return result;
+    }
+
+    // bit manipulation
+    vector<vector<int>> subsets(vector<int>& nums) {
+        int numSize = nums.size();
+        int allSize = pow(2, numSize);
+        sort(nums.begin(),nums.end());
+        
+        vector<vector<int>> result(allSize, vector<int>());
+        
+        for(int i = 0 ; i < numSize; i++)
+            for(int j =0;j < allSize; j++){
+                if ((j >>i)&1)
+                    result[j].push_back(nums[i]);
+            }
+        
+        return result;
+        
+    }
+
+
+};