LeetCode每日一题

994. 腐烂的橘子

解法一：DFS

int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
class Solution {
public:
    //这里需要对普通的DFS进行一定的处理，即DFS进化版本。。。
    void dfs(vector<vector<int>>& grid,int i,int j,int res){
        if(i<0||j<0||i>=grid.size()||j>=grid[0].size())return ;
        if(grid[i][j]!=1&&grid[i][j]<res)return ;//预防不符合条件的再次访问。。。
        grid[i][j]=res;
        res++;

        for(int k=0;k<4;k++){
            int x=dx[k]+i,y=dy[k]+j;
            dfs(grid,x,y,res);
        }
    }
    int orangesRotting(vector<vector<int>>& grid) {
        int m=grid.size();
        int n=grid[0].size();
        
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==2){
                    dfs(grid,i,j,2);//很好解决我没法解决的问题。。。
                }
            }
        }
        int cnt=0;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1)return -1;
                else{
                    cnt=max(cnt,grid[i][j]);
                    //cout<<cnt<<endl;
                }
            }
        }
        if(cnt==0)return 0;
        return cnt-2;


    }
};

解法二：BFS

int dx[4]={-1,0,1,0};
int dy[4]={0,-1,0,1};
class Solution {
public:
    int orangesRotting(vector<vector<int>>& grid) {
        queue<pair<int,int>>que;
        int m=grid.size();
        int n=grid[0].size();
        for(int i=0;i<m;i++){//初始化
            for(int j=0;j<n;j++){
                if(grid[i][j]==2){
                    que.push({i,j});
                }
            }
        }
        int res=0;
        while(!que.empty()){
            int k=que.size();
            bool flag=false;
            for(int i=0;i<k;i++){
                pair<int,int>q=que.front();
                que.pop();
                int f1=q.first,f2=q.second;
                for(int j=0;j<4;j++){
                    int x=dx[j]+f1,y=dy[j]+f2;
                    if(x>=0&&y>=0&&x<m&&y<n&&grid[x][y]==1){
                        flag=true;
                        grid[x][y]=2;
                        que.push({x,y});
                    }
                }
            }
            if(flag)res++;
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(grid[i][j]==1)return -1;
            }
        }
        return res;
    }
};

面试题57 - II. 和为s的连续正数序列

滑动窗口：

解法一：list STL:

class Solution {
public:
//滑动窗口求解。。。。或者叫做双指针
    vector<vector<int>> findContinuousSequence(int target) {
        vector<vector<int>>ans;
        list<int>ls;//使用一个链表来实现滑动窗口。。。
        vector<int>temp;
        int k=0,i=1;
        while(i<target){
            if(k==target){
                for(auto v:ls){
                    temp.push_back(v);
                }
                ans.push_back(temp);
                temp.clear();
                k=k-ls.front();
                ls.pop_front();
            }else if(k>target){
                k=k-ls.front();
                ls.pop_front();
            }else{
                k=k+i;
                ls.push_back(i);
                i++;
            }
        }
        return ans;
    }
};

方法二：双指针：

class Solution {
public:
    vector<vector<int>> findContinuousSequence(int target) {
        vector<vector<int>>ans;
        for(int i=1,j=2;i<j;){
            int sum=(i+j)*(j-i+1)/2;
            if(sum==target){
                vector<int>res;
                for(int k=i;k<=j;k++){
                    res.push_back(k);
                }
                ans.push_back(res);
            }
            if(sum>target){
                i++;
            }else j++;
        }
        return ans;
    }
};

322. 零钱兑换

解法一：DFS

class Solution {
public:
//DFS解法，优先使用大的币值，之后加上一些剪枝，因为之前DFS使用大的币值，需要的硬币的数目更少。。。所以之后DFS的到的硬币数目多余之前的数目直接剪枝掉。。。
    void dfs(vector<int>& coins, int amount,int count,int& ans,int s){
        //递归结束条件
        int coin=coins[s];
        if(amount<0)return ;
        if(s==coins.size()-1){
            if(amount%coin==0){
                ans=min(ans,count+amount/coin);//表示的当前需要的硬币数加上之前需要的硬币数
            }
        }else{
            for(int k=amount/coin;k>=0&&count+k<ans;k--){//count+k<ans就是剪枝，表示的意思是：之前硬币的数量加上当前的硬币的数量大于等于已经求得的数量的时候，就不要DFS下去啦。。。
                dfs(coins,amount-k*coin,count+k,ans,s+1);
            }
        }
    }
    int coinChange(vector<int>& coins, int amount) {
        sort(coins.begin(),coins.end(),greater<int>());
        //count=0;//count表示的意思是之前递归，使用之前的币值需要的硬币数。
        int ans=amount+1;
        dfs(coins,amount,0,ans,0);
        return ans==amount+1?-1:ans;
    }
};

解法二：一维DP，背包问题的进化版本

class Solution {
public:
//DP：经典的DP问题
    int coinChange(vector<int>& coins, int amount) {
        sort(coins.begin(),coins.end());
        vector<int>dp(amount+1,amount+1);//初始化：初始化一个比较大的数字，amount+1足矣，因为需要的硬币数不可能大于总共需要的硬币。。。。
        dp[0]=0;//初始化
        for(int i=0;i<coins.size();i++){
            int num=coins[i];
            for(int k=num;k<=amount;k++){
                dp[k]=min(dp[k],dp[k-num]+1);
            }
        }
        return dp[amount]==amount+1?-1:dp[amount];
    }
};

1071. 字符串的最大公因子

inline int gcd(int a,int b){
    return b==0?a:gcd(b,a%b);
}
class Solution {
public:
    string gcdOfStrings(string str1, string str2) {
        if(str1+str2!=str2+str1)return "";//如果 str1 和 str2 存在最大公约数 str，那么就相当于 str1 和 str2 都是由 str 组成的，那么 str1 + str2 和 str2 + str1 应该是相等的
        //如果不满足，那么不存在最大公约数
        return str1.substr(0,gcd(str1.length(),str2.length()));
    }
};

300. 最长上升子序列

解法一：暴力dp求解，但是注意将dp初始化为1，因为我们往往在记录的时候通常不会将当前的结点算上。

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        if(n==0)return 0;
        vector<int>dp(n+1,1);
        cout<<dp[0];
        int res=0;
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                if(nums[i]>nums[j]){
                    dp[i]=max(dp[i],dp[j]+1);
                }
            }
            res=max(res,dp[i]);
        }
        return res;
    }
};

解法二：二分法进行优化求解最长上升子序列：

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n=nums.size();
        vector<int>dp;
        for(int i=0;i<n;i++){
            if(dp.size()==0||nums[i]>dp.back()){
                dp.push_back(nums[i]);
            }else{
                *lower_bound(dp.begin(),dp.end(),nums[i])=nums[i];//注意lower_bound返回的是地址，所以要进行取地址操作
//还有就是：lower_bound返回的是大于等于nums[i]的数的地址，upper_bound返回的是大于nums[i]的数的地址，这是两者不同的地方
            }
        }
        return dp.size();
    }
};

695. 岛屿的最大面积

int dx[4]={1,-1,0,0};
int dy[4]={0,0,1,-1};
class Solution {
public:
//求解最大连通块的大小。。。DFS
    void dfs(vector<vector<int>>& grid,vector<vector<int>>&vis,int i,int j,int &cnt){
        // vis[i][j]=true;
        // cnt++;
        for(int k=0;k<4;k++){
            int x=i+dx[k];
            int y=j+dy[k];
            if(x>=0&&x<grid.size()&&y>=0&&y<grid[0].size()&&!vis[x][y]&&grid[x][y]){
                cnt++;
                //cout<<cnt<<endl;
                vis[x][y]=1;
                dfs(grid,vis,x,y,cnt);
            }
        }

    }
    int maxAreaOfIsland(vector<vector<int>>& grid) {
        int res=0;
        int m=grid.size();
        int n=grid[0].size();
        vector<vector<int>>vis(m+1,vector<int>(n+1,0));
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(vis[i][j]==0&&grid[i][j]){
                    int cnt=1;
                    vis[i][j]=1;
                    dfs(grid,vis,i,j,cnt);
                    //cout<<cnt<<endl;
                    res=max(cnt,res);
                }
            }
        }
        return res;
    }
};