leetcode热题100刷题笔记(4)

78.子集

思路：

这是经典的回溯法的题目：

定义一个回溯方法 dfs(first, temp,nums)，第一个参数为索引 first，第二个参数为当前子集temp。

如果当前子集构造完成，将它添加到输出集合中。

否则，从 first 到 mums.size()-1 遍历索引 i。

将整数 nums[i] 添加到当前子集 curr。

继续向子集中添加整数：dfs(i + 1, temp,nums)。

从 curr 中删除 nums[i] 进行回溯。

代码

class Solution {
public:
    vector<vector<int>> ans;
    int k;//限制temp的长度
    void dfs(int first,vector<int>& temp,vector<int>&nums){
        if(temp.size()==k)
            ans.push_back(temp);
        for(int i=first;i<nums.size();i++){
            temp.push_back(nums[i]);
            dfs(i+1,temp,nums);
            temp.pop_back();
        }
    }
    vector<vector<int>> subsets(vector<int>& nums) {
        vector<int> temp;
        for(k=0;k<=nums.size();k++){
            dfs(0,temp,nums);
        }
        return ans;
    }
};

79.单词搜索

思路

此题类似N皇后问题，是一个经典模版，应当熟悉。
依然使用回溯法求解，也就是dfs和状态重制，只要熟悉了N皇后问题，此题的思路就不难理顺，只需要在一些细节上多加注意即可

代码

class Solution {
public:
    int dx[4]={-1,0,1,0};
    int dy[4]={0,1,0,-1};
    bool visited[210][210]={false};
    bool dfs(vector<vector<char>>& board,string word,int step,int x,int y){
        if(step==word.size()-1)
            return board[x][y]==word[step];
        if(board[x][y]==word[step]){
            visited[x][y]=true;
            for(int k=0;k<4;k++){
                int newx=x+dx[k];
                int newy=y+dy[k];
                if(newx>=0&&newx<board.size()&&newy>=0&&newy<board[0].size()&&!visited[newx][newy]){
                    if(dfs(board,word,step+1,newx,newy))
                        return true;
                }
            }
            visited[x][y]=false;
        }
        return false;
    }
    
    bool exist(vector<vector<char>>& board, string word) {
        for(int i=0;i<board.size();i++){
            for(int j=0;j<board[0].size();j++){
                if(dfs(board,word,0,i,j)){
                   return true;
                }
            }
        }
        return false;
    }

};

84.柱状图中的最大矩形

思路

采用分治法：

通过观察，可以发现，最大面积矩形存在于以下几种情况：

确定了最矮柱子以后，矩形的宽尽可能往两边延伸。

在最矮柱子左边的最大面积矩形（子问题）。

在最矮柱子右边的最大面积矩形（子问题）。

如图：

代码

class Solution {
public:
    int calculate(vector<int>& heights,int start,int end){
        int minheight = INT_MAX;
        int index=start;
        if(start>end) return 0;
        for(int i=start;i<=end;i++){
            if(heights[i]<minheight){
                minheight=heights[i];
                index=i;
            }
        }
        int area1 = minheight*(end-start+1);
        int area2 = calculate(heights,start,index-1);
        int area3 = calculate(heights,index+1,end);
        return max(area1,max(area2,area3));
    }
    int largestRectangleArea(vector<int>& heights) {
        int max = calculate(heights,0,heights.size()-1);
        return max;
    }
};

85.最大矩形

思路

将如图的局部看成是竖直放置的柱状图，利用动态规划的方法，定义二维数组dp，dp[i][j]表示以matrix[i][j]为结束时，第i行最长的宽度，那么:

dp[i][j]= j ==0?dp[i][j-1]+1 (当matrix[I][j]==1)

之后，向上不断更新最大面积值，将matrix全部遍历之后，便可以得出结果。

代码

class Solution {
    public int maximalRectangle(char[][] matrix) {
        if (matrix.length == 0) return 0;
        int maxarea = 0;
        int[][] dp = new int[matrix.length][matrix[0].length];

        for(int i = 0; i < matrix.length; i++){
            for(int j = 0; j < matrix[0].length; j++){
                if (matrix[i][j] == '1'){

                    // compute the maximum width and update dp with it
                    dp[i][j] = j == 0? 1 : dp[i][j-1] + 1;

                    int width = dp[i][j];

                    // compute the maximum area rectangle with a lower right corner at [i, j]
                    for(int k = i; k >= 0; k--){
                        width = Math.min(width, dp[k][j]);
                        maxarea = Math.max(maxarea, width * (i - k + 1));
                    }
                }
            }
        } return maxarea;
    }
}