【C++】leetcode 第77场双周赛

6051. 统计是给定字符串前缀的字符串数目

给你一个字符串数组 words 和一个字符串 s ，其中 words[i] 和 s 只包含 小写英文字母 。

请你返回 words 中是字符串 s 前缀 的 字符串数目 。

一个字符串的 前缀 是出现在字符串开头的子字符串。子字符串 是一个字符串中的连续一段字符序列。

class Solution {
public:
    int countPrefixes(vector<string>& words, string s) {
    int cnt=0;
        for(auto x:words)
        {
            if(x.size()>s.size())continue;
            int i=0;
            for(i=0;i<s.size();i++)
            {
                if(s[i]!=x[i])break;
            }
            if(i==x.size())cnt++;
        }
        return cnt;
    }
};

6052. 最小平均差

给你一个下标从 0 开始长度为 n 的整数数组 nums 。

下标 i 处的 平均差 指的是 nums 中 前 i + 1 个元素平均值和 后 n - i - 1 个元素平均值的 绝对差 。两个平均值都需要 向下取整 到最近的整数。

请你返回产生 最小平均差 的下标。如果有多个下标最小平均差相等，请你返回 最小 的一个下标。

注意：

两个数的 绝对差 是两者差的绝对值。
n 个元素的平均值是 n 个元素之 和 除以（整数除法） n 。
0 个元素的平均值视为 0 。

class Solution {
public:
    int minimumAverageDifference(vector<int>& nums) {
        vector<long long>s((int)nums.size()+10);
        for(int i=0;i<nums.size();i++)
        {
            if(i==0)s[i]=nums[i];
            else s[i]=s[i-1]+nums[i];
        }
        long long res=0x3f3f3f3f;
        int idx=0;
        for(int i=0;i<nums.size();i++)
        {
            int l=i+1,r=nums.size()-l;
            if(r)
            {
                if(res>abs(s[i]/l-(s[nums.size()-1]-s[i])/r))
                {
                    res=abs(s[i]/l-(s[nums.size()-1]-s[i])/r);
                    idx=i;
                }
            }
            else 
            {
                if(res>abs(s[i]/l-0))
                {
                    res=abs(s[i]/l-0);
                    idx=i;
                }
            }
        }
        return idx;
    }
};

6053. 统计网格图中没有被保卫的格子数

给你两个整数 m 和 n 表示一个下标从 0 开始的 m x n 网格图。同时给你两个二维整数数组 guards 和 walls ，其中 guards[i] = [rowi, coli] 且 walls[j] = [rowj, colj] ，分别表示第 i 个警卫和第 j 座墙所在的位置。

一个警卫能看到 4 个坐标轴方向（即东、南、西、北）的 所有 格子，除非他们被一座墙或者另外一个警卫 挡住 了视线。如果一个格子能被 至少 一个警卫看到，那么我们说这个格子被 保卫 了。

请你返回空格子中，有多少个格子是 没被保卫 的。

class Solution {
public:
    int countUnguarded(int m, int n, vector<vector<int>>& guards, vector<vector<int>>& walls) {
        int g[m+10][n+10];//0无保护，1有保护，2 G,3 W；
        memset(g,0,sizeof g);
        for(auto item:guards)
        {
            int x=item[0],y=item[1];
            g[x][y]=2;
        }
        for(auto item:walls)
        {
            int x=item[0],y=item[1];
            g[x][y]=3;
        }
        for(auto item:guards)
        {
            int x=item[0],y=item[1];
            for(int i=x-1;i>=0;i--)//up
            {
                if(g[i][y]==3||g[i][y]==2)break;
                if(g[i][y]==0)g[i][y]=1;
            }
            for(int i=x+1;i<m;i++)//down
            {
                if(g[i][y]==3||g[i][y]==2)break;
                if(g[i][y]==0)g[i][y]=1;
            }
            for(int i=y-1;i>=0;i--)//left
            {
                if(g[x][i]==3||g[x][i]==2)break;
                if(g[x][i]==0)g[x][i]=1;
            }
            for(int i=y+1;i<n;i++)
            {
                if(g[x][i]==3||g[x][i]==2)break;
                if(g[x][i]==0)g[x][i]=1;
            }
        }
        int res=0;
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                if(g[i][j]==0)res++;
        return res;
    }
};

6054. 逃离火灾

给你一个下标从 0 开始大小为 m x n 的二维整数数组 grid ，它表示一个网格图。每个格子为下面 3 个值之一：

0 表示草地。
1 表示着火的格子。
2 表示一座墙，你跟火都不能通过这个格子。
一开始你在最左上角的格子 (0, 0) ，你想要到达最右下角的安全屋格子 (m - 1, n - 1) 。每一分钟，你可以移动到 相邻 的草地格子。每次你移动 之后 ，着火的格子会扩散到所有不是墙的 相邻 格子。

请你返回你在初始位置可以停留的 最多 分钟数，且停留完这段时间后你还能安全到达安全屋。如果无法实现，请你返回 -1 。如果不管你在初始位置停留多久，你 总是 能到达安全屋，请你返回 109 。

注意，如果你到达安全屋后，火马上到了安全屋，这视为你能够安全到达安全屋。

如果两个格子有共同边，那么它们为 相邻 格子。

const int dx[4]={-1,0,1,0};
const int dy[4]={0,1,0,-1};
class Solution {
    bool check(vector<vector<int>>&grid,int t)
    {
        int m=grid.size(),n=grid[0].size();
        bool fire[m+10][n+10];
        memset(fire,false, sizeof fire);
        vector<pair<int,int>>f;//着火的坐标
        for(int i=0;i<m;i++)
            for(int j=0;j<n;j++)
                if(grid[i][j]==1)
                {
                    f.push_back({i,j});
                    fire[i][j]=true;
                }
        auto judge=[&]()
        {
            vector<pair<int,int>>backup;
            for(auto item:f)
            {
                for(int i=0;i<4;i++)
                {
                    int x=item.first+dx[i],y=item.second+dy[i];
                    if(x<0||x>=m||y<0||y>=n)continue;
                    if(fire[x][y])continue;
                    if(grid[x][y]==2)continue;
                    fire[x][y]=true;
                    backup.push_back({x,y});
                }
            }
            f=backup;
        };
        while(t--&&f.size())judge();
        if(fire[0][0])return false;
        bool st[m+10][n+10];
        memset(st,false,sizeof st);
        st[0][0]=true;
        vector<pair<int,int>>q;
        q.push_back({0,0});
        while(q.size())
        {
            vector<pair<int,int>>nq;
            for(auto t:q)
            {   
                if (!fire[t.first][t.second])
                {   
                    for(int i=0;i<4;i++)
                    {
                        int x=t.first+dx[i],y=t.second+dy[i];
                        if(x<0||x>=m||y<0||y>=n)continue;
                        if(st[x][y])continue;
                        if(fire[x][y])continue;
                        if(grid[x][y]==2)continue;
                        if(x==m-1&&y==n-1)return true;
                        st[x][y]=true;
                        nq.push_back({x,y});
                    }
                }
            }
            q=nq;
            judge();
        }
        return false;
    }
public:
    int maximumMinutes(vector<vector<int>>& grid) {
        int m=grid.size(),n=grid[0].size();
        int l=-1,r=m*n;
        while(l<r)
        {
            int mid=l+r+1>>1;
            if(check(grid,mid))l=mid;
            else r=mid-1;
        }
        return l<m*n?l:1e9;
    }
};