LeetCode(3)——數組

1.surrounded-regions(leetcode 130)

給定一個二維的矩陣，包含 ‘X’ 和 ‘O’（字母 O）。
找到所有被 ‘X’ 圍繞的區域，並將這些區域裏所有的 ‘O’ 用 ‘X’ 填充。

class Solution {
public:
    void dfs(vector<vector<char>>& board, int row, int column){
        if(row<0 || column<0 || row>=board.size()||column>=board[0].size()||board[row][column]=='X'||board[row][column]=='#')
            return ;
        board[row][column] = '#';
        dfs(board,row-1,column);//up
        dfs(board,row+1,column);//down
        dfs(board,row,column-1);//left
        dfs(board,row,column+1);//right
    }
    void solve(vector<vector<char>>& board) {
        if(board.empty())
            return;
        int row = board.size();
        int column = board[0].size();
        for(int i=0;i<row;++i){
            for(int j=0;j<column;++j){
                bool isedge = i==0 || j==0 || i==row-1 || j==column-1;
                if(isedge && board[i][j]=='O')
                    dfs(board,i,j);
            }
        }
        for(int i=0;i<row;++i){
            for(int j=0;j<column;++j){
                if(board[i][j]=='#')
                    board[i][j]='O';
                else if(board[i][j]=='O')
                    board[i][j]='X';
            }
        }

    }
};

2. longest-consecutive-sequence(leetcode 128)

給定一個無序的整數類型數組，求最長的連續元素序列的長度。
例如：
給出的數組爲[100, 4, 200, 1, 3, 2],最長的連續元素序列爲[1, 2, 3, 4]. 返回這個序列的長度：4
你需要給出時間複雜度在O（n）之內的算法

class Solution {
public:
    int longestConsecutive(vector<int> &num) {
        if(num.empty()) return 0;
        int res = 0;
        unordered_set<int> hash(num.begin(),num.end());
        for(int val: num){
            int last = val;
            if(hash.find(last-1)==hash.end()){
                while(hash.erase(last)) ++last;
                res = max(res,last-val);
            }
        }
        return res;
    }
};

hash表的應用小技巧，每次判斷該點是否是有序序列的首元素，若是的話就將這個相關的整個有序序列刪除掉，然後找其他的有序子序列，最終得出最大值即可。

3.best-time-to-buy-and-sell-stock(leetcode 121)

買賣股票的最佳時機:給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。
如果你最多隻允許完成一筆交易（即買入和賣出一支股票），設計一個算法來計算你所能獲取的最大利潤。
注意你不能在買入股票前賣出股票。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int maxprofit = 0;
        int minprice = INT32_MAX;
        for(int i=0;i<prices.size();++i){
            if(minprice > prices[i])
                minprice = prices[i];
            else if(prices[i]-minprice > maxprofit)
                maxprofit = prices[i]-minprice;
        }
        return maxprofit;
    }
};

4.best-time-to-buy-and-sell-stock-ii(leetcode 122)

買賣股票的最佳時機 II給定一個數組，它的第 i 個元素是一支給定股票第 i 天的價格。
設計一個算法來計算你所能獲取的最大利潤。你可以儘可能地完成更多的交易（多次買賣一支股票）。
注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。

class Solution {
public://峯谷法
    int maxProfit(vector<int>& prices) {
        if(prices.empty()) return 0;
        int res = 0;
        int valley ;
        int peak ;
        for(int i=0;i<prices.size()-1;){
            while(i<prices.size()-1 && prices[i]>=prices[i+1])
                ++i;
            valley = prices[i];
            while(i<prices.size()-1 && prices[i]<=prices[i+1])
                ++i;
            peak = prices[i];
            res += peak-valley;
        }
        return res;
    }
};

5.convert-sorted-array-to-binary-search-tree(leetcode 108)

給出一個升序排序的數組，將其轉化爲平衡二叉搜索樹（BST）

class Solution {
public:
    TreeNode* Build(vector<int>& nums, int low, int high){
        if(low>high)
            return NULL;
        int mid = (low+high)/2;
        if ((low + high) % 2 == 1) ++mid;//這個要注意，否則過不去
        TreeNode* root = new TreeNode(nums[mid]);
        root->left = Build(nums,low,mid-1);
        root->right = Build(nums,mid+1,high);
        return root;
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if(nums.empty())
            return NULL;
        TreeNode *root = Build(nums,0,nums.size()-1);
        return root;
    }
};