LeetCode之第394场周赛

100294. 统计特殊字母的数量 I

 Hash表存储是否出现大小写字母的状态，然后枚举即可。

class Solution {
public:
    int numberOfSpecialChars(string word) {
        
        int sum=0;
        
        int s[128];
        
        for(int i='a';i<='z';i++)
        {
            s[i]=0;
        }
        
        for(int i=0;i<word.size();i++)
        {
            if(word[i]<='Z')
            {
                if(s[word[i]+'a'-'A']==1)
                {
                    sum++;
                    s[word[i]+'a'-'A']=3;
                }
                else if(s[word[i]+'a'-'A']==0)
                    s[word[i]+'a'-'A']=2;
                    
            }
            else 
            {
                if(s[word[i]]==2)
                {
                    sum++;
                    s[word[i]]=3;
                }
                else if(s[word[i]]==0)
                    s[word[i]]=1;
                    
            }
        }
        return sum;
        
    }
};

 

100291. 统计特殊字母的数量 II

 使用Hash表存储四个状态，注意状态转移，一遍过即可。

class Solution {
public:
    int numberOfSpecialChars(string word) {
        
        int sum=0;
        
        int s[128];
        
        for(int i='a';i<='z';i++)
        {
            s[i]=0;
        }
        
        for(int i=0;i<word.size();i++)
        {
            if(word[i]<='Z')
            {
                if(s[word[i]+'a'-'A']==1)
                {
                    sum++;
                    s[word[i]+'a'-'A']=2;
                    
        
                }
                else if(s[word[i]+'a'-'A']==0)
                    s[word[i]+'a'-'A']=3;
                    
            }
            else 
            {
         
                if(s[word[i]]==0)
                    s[word[i]]=1;
                else if(s[word[i]]==2)
                {
                    sum--;
                    s[word[i]]=3;
                }
                    
            }
        }
        return sum;
        
    }
};

 

100290. 使矩阵满足条件的最少操作次数

先初始化每一列各个数字数量f[i][j] ，然后做出状态转移方程：

class Solution {
public:
    int minimumOperations(vector<vector<int>>& grid) {

        int n=grid[0].size(),m=grid.size();

        int f[n][10];

        memset(f,0,sizeof f);

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<m;j++)
            {
                f[i][grid[j][i]]++;
            }
        }

        int dp[n][10];

        for(int i=0;i<n;i++)
        {
            for(int j=0;j<10;j++)
            dp[i][j]=INT_MAX;
        }

        for(int i=0;i<10;i++)
        dp[0][i]=m-f[0][i];

        for(int i=1;i<n;i++)
        {
            for(int j=0;j<10;j++)
            {
                for(int k=0;k<10;k++)
                {
                    if(j!=k)
                    dp[i][j]=min(dp[i][j],dp[i-1][k]+m-f[i][j]);
                }
            }
        }

        int res=INT_MAX;

        for(int i=0;i<10;i++)
        res=min(res,dp[n-1][i]);

        return res;
    }
};

 

100276. 最短路径中的边

先使用Dijstra算法求解起点每一个点的最短距离，然后从终点反向DFS遍历寻找该边是否在最短路径上

class Solution {
public:

    typedef long long LL;
    typedef pair<pair<int,int>,int> PIII;
    typedef pair<int,int> PII; 

    vector<PIII> v[50010];

    LL dist[50010];

    bool f[50010];

    void dfs(int r,vector<bool> &res)
    {
        f[r]=true;

        for(int i=0;i<v[r].size();i++)
        {
            int u=v[r][i].first.first, w=v[r][i].first.second;

            if(dist[u]+w==dist[r])
            {
                res[v[r][i].second]=true;
                if(!f[u])
                dfs(u,res);
            }
        }
    }

    vector<bool> findAnswer(int n, vector<vector<int>>& edges) {

        for(int i=0;i<edges.size();i++)
        {
            v[edges[i][0]].push_back({{edges[i][1],edges[i][2]},i});
            v[edges[i][1]].push_back({{edges[i][0],edges[i][2]},i});
        }

        memset(dist,0x7f,sizeof dist);
        memset(f,false,sizeof f);

        dist[0]=0;

        priority_queue<PII,vector<PII>,greater<PII>> q;

        q.push({0,0});

        while(!q.empty())
        {
            PII t=q.top();
            q.pop();

            int w=t.first, p=t.second;

            if(f[p])
            continue;
            f[p]=true;

            for(int i=0;i<v[p].size();i++)
            {
                int u=v[p][i].first.first, r=v[p][i].first.second;
                if(dist[u]>w+r)
                {
                    dist[u]=w+r;
                    q.push({dist[u],u});
                }
            }

        }

        vector<bool> res(edges.size(),false);

        memset(f,false,sizeof f);

        dfs(n-1,res);

        return res;        
    }
};