More solutions for leetcode

Author: andy2git

N-Queens.cpp

@@ -0,0 +1,71 @@
+class Solution {
+public:
+    vector<vector<string> > solveNQueens(int n) {
+        
+        vector<vector<string>> solution;
+        vector<vector<bool>> board(n, vector<bool>(n, false));
+        
+        solve(solution, board, 0);
+        
+        return solution;
+    }
+private:    
+    void solve(vector<vector<string>> &solution, vector<vector<bool>> &board, int col){
+        if(col >= board.size()){
+            solution.push_back(board_str(board));
+            return;
+        }
+        
+        for(int row = 0; row < board.size(); row++){
+            if(is_safe(board, row, col)){
+                place_queen(board, row, col);
+                solve(solution, board, col+1);
+                remove_queen(board, row, col);
+            }
+        }
+        
+    }
+    
+    void place_queen(vector<vector<bool>> &board, int row, int col){
+        board[row][col] = true;
+    }
+    
+    void remove_queen(vector<vector<bool>> &board, int row, int col){
+        board[row][col] = false;
+    }
+    
+    bool is_safe(vector<vector<bool>> &board, int row, int col){
+        for(int j = 0; j < board.size(); j++){
+            if(board[row][j]) return false;
+            if(board[j][col]) return false;
+        }
+        
+        int ind = 1;
+        while(row-ind>=0 && col-ind>=0){
+            if(board[row-ind][col-ind]) return false;
+            ind++;
+        }
+        
+        ind = 1;
+        while(row+ind < board.size() && col-ind>=0){
+            if(board[row+ind][col-ind]) return false;
+            ind++;
+        }
+        return true;
+    }
+    
+    vector<string> board_str(vector<vector<bool>> &board){
+        string layer;
+        vector<string> result;
+        
+        for(int i = 0; i < board.size(); i++){
+            layer = "";
+            for(int j = 0; j < board[0].size(); j++){
+                if(board[i][j]) layer += 'Q';
+                else layer += '.';
+            }
+            result.push_back(layer);
+        }
+        return result;
+    }
+};

N-Queens_2.cpp

@@ -0,0 +1,56 @@
+class Solution {
+public:
+    int totalNQueens(int n) {
+        
+        int num_solutions = 0;
+        
+        vector<vector<bool>> board(n, vector<bool>(n, false));
+        solve(num_solutions, board, 0);
+        
+        return num_solutions;
+    }
+private:
+    void solve(int &num_solutions, vector<vector<bool>> &board, int col){
+        if(col >= board.size()){
+            num_solutions++;
+            return;
+        }
+        
+        for(int row = 0; row < board.size(); row++){
+            if(is_safe(board, row, col)){
+                place_queen(board, row, col);
+                solve(num_solutions, board, col+1);
+                remove_queen(board, row, col);
+            }
+        }
+        
+    }
+    
+    void place_queen(vector<vector<bool>> &board, int row, int col){
+        board[row][col] = true;
+    }
+    
+    void remove_queen(vector<vector<bool>> &board, int row, int col){
+        board[row][col] = false;
+    }
+    
+    bool is_safe(vector<vector<bool>> &board, int row, int col){
+        for(int j = 0; j < board.size(); j++){
+            if(board[row][j]) return false;
+            if(board[j][col]) return false;
+        }
+        
+        int ind = 1;
+        while(row-ind>=0 && col-ind>=0){
+            if(board[row-ind][col-ind]) return false;
+            ind++;
+        }
+        
+        ind = 1;
+        while(row+ind < board.size() && col-ind>=0){
+            if(board[row+ind][col-ind]) return false;
+            ind++;
+        }
+        return true;
+    }
+};

Search_a_2D_Matrix.cpp

@@ -0,0 +1,71 @@
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int> > &matrix, int target) {
+        if(matrix.empty()) return false;
+        
+        int m = matrix.size();
+        int n = matrix[0].size();
+        
+        int i = 0;
+        int j = n-1;
+        while(i < m && j >= 0){
+            if(matrix[i][j] == target) return true;
+            else if(matrix[i][j] < target) i++;
+            else j--;
+        }
+        
+        return false;
+    }
+};
+
+pair<int, int> search_2D_matrix(vector<vector<int>> &A, int sr, int sc, int er, int ec, int target){
+    if(sr > er || sc > ec) return {-1, -1};
+    
+    int mr = sr + (er-sr)/2;
+    int mc = sc + (ec-sc)/2;
+    
+    if(A[mr][mc] == target) return {mr, mc};
+    else if(A[mr][mc] > target) return search_2D_matrix(A, sr, sc, mr, mc, target);
+    else{
+        pair<int, int> t = search_2D_matrix(A, mr+1, sc, er, mc, target);
+        if(t.first == -1 && t.second == -1) return search_2D_matrix(A, sr, mc+1, er, ec, target);
+        else return t;
+    }
+}
+
+class Solution {
+public:
+    bool searchMatrix(vector<vector<int>> &matrix, int target) {
+        // IMPORTANT: Please reset any member data you declared, as
+        // the same Solution instance will be reused for each test case.
+        
+        int sInd, mInd, eInd;
+        pair<int, int> rc;
+        int nCol, nRow;
+        
+        nRow = matrix.size();
+        nCol = matrix[0].size();
+        
+        sInd = 0; eInd = nRow*nCol - 1;
+        
+        while (sInd <= eInd) {
+            mInd = sInd + (eInd - sInd)/2;
+            rc = index_rc(mInd, nCol);
+            
+            if (matrix[rc.first][rc.second] == target) {
+                return true;
+            }else if (matrix[rc.first][rc.second] < target) {
+                sInd = mInd + 1;
+            }else{
+                eInd = mInd - 1;
+            }
+        }
+        
+        return false;
+    }
+    
+private:
+    pair<int, int> index_rc(int index, int sz){
+        return make_pair(index / sz, index % sz);
+    }
+};

Swap_Nodes_in_Pairs.cpp

@@ -0,0 +1,95 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode *swapPairs(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return head;
+        
+        ListNode *cur = head;
+        ListNode *next = nullptr;
+        ListNode dummy(0);
+        ListNode *d = &dummy;
+        d->next = head;
+        
+        while(cur && cur->next){
+            next = cur->next;
+            cur->next = next->next;
+            next->next = cur;
+            d->next = next;
+            d = cur;
+            cur = cur->next;
+        }
+        
+        return dummy.next;
+    }
+};
+
+
+/**
+ * Solution 2: split the list into two, and merge them back into one.
+ * 
+ */
+class Solution {
+public:
+    ListNode *swapPairs(ListNode *head) {
+        if(head == nullptr) return nullptr;
+        if(head->next == nullptr) return head;
+        
+        ListNode dummy1(0);
+        ListNode *d1 = &dummy1;
+        ListNode dummy2(0);
+        ListNode *d2 = &dummy2;
+        
+        bool flag = true;
+        ListNode *p = head;
+        ListNode *t = nullptr;
+        while(p){
+            t = p->next;
+            p->next = nullptr;
+            if(flag){
+                d1->next = p;
+                d1 = d1->next;
+                flag = false;
+            }else{
+                d2->next = p;
+                d2 = d2->next;
+                flag = true;
+            }
+            p = t;
+        }
+        
+        return merge_list(dummy1.next, dummy2.next);
+    }
+private:
+    ListNode *merge_list(ListNode *l1, ListNode *l2){
+        ListNode dummy(0);
+        ListNode *d = &dummy;
+        
+        bool flag = true;
+        while(l1 && l2){
+            if(flag){
+                d->next = l2;
+                l2 = l2->next;
+                d = d->next;
+                flag = false;
+            }else{
+                d->next = l1;
+                l1 = l1->next;
+                d = d->next;
+                flag = true;
+            }
+        }
+        
+        if(l1) d->next = l1;
+        if(l2) d->next = l2;
+        
+        return dummy.next;
+    }
+};