[Lc_week] 447 | 155 | Q1 | hash | pair {}调用

447_Q1

题解

复制代码
class Solution {
    typedef pair<int,int> PII;

    // 自定义哈希函数
    struct HashPII {
        size_t operator()(const PII& p) const {
            return hash<int>()(p.first) ^ (hash<int>()(p.second) << 1);
        }
    };

public:
    int countCoveredBuildings(int n, vector<vector<int>>& buildings) 
    {
         //不管有多远 至少存在一个建筑
        //bfs变形

        //哦不对,hash 快速查找同行同列,不就可以判断了吗

//添加自定义哈希函数HashPII,使用unordered_map<PII, bool, HashPII>解决pair作为键的问题
        unordered_map<PII,bool,HashPII> hash;
        int ans=0;
        for(auto& b:buildings)
            {
                PII p={b[0],b[1]};  //pair构造和调用 要用{}
                hash[p]=true;
            }
        for(auto& b:buildings)
            {
                int cnt=0;
                //四个 方向的查找
                //上
                for(int i=b[1]+1;i<=n;i++)
                    {
                        if(hash.count({b[0],i}))
                        {
                            cnt++;
                            break;
                        }
                    }
                for(int i=b[1]-1;i>=1;i--)
                    {
                        if(hash.count({b[0],i}))
                        {
                            cnt++;
                            break;
                        }
                    }
                for(int i=b[0]-1;i>=1;i--)
                    {
                        if(hash.count({i,b[1]}))
                        {
                            cnt++;
                            break;
                        }
                    }
                for(int i=b[0]+1;i<=n;i++)
                    {
                        if(hash.count({i,b[1]}))
                        {
                            cnt++;
                            break;
                        }
                    }
                if(cnt==4) ans++;
            }
        return ans;
    }
};©leetcode
  • pair 构造和调用 要用 {}
  • !!!!!!!!!!!!!!花括号

超时了

优化

  • 采取 行列极值法

    class Solution {
    public:
    int countCoveredBuildings(int n, vector<vector<int>>& buildings) {
    // 存 行位置极值和列位置极值
    unordered_map<int, int> row_min, row_max;
    unordered_map<int, int> col_min, col_max;

    复制代码
          for (auto& b : buildings) 
          {
              int x = b[0], y = b[1];
    
              // 预处理行极值
              if (!row_min.count(x) || y < row_min[x])
                  row_min[x] = y;
              if (!row_max.count(x) || y > row_max[x])
                  row_max[x] = y;
    
              // 预处理列极值
              if (!col_min.count(y) || x < col_min[y])
                  col_min[y] = x;
              if (!col_max.count(y) || x > col_max[y])
                  col_max[y] = x;
          }
          int ans = 0;
          for (auto& b : buildings) 
          {
              int x = b[0], y = b[1];
              bool up = (y < row_max[x]);
              bool down = (y > row_min[x]);
              bool left = (x > col_min[y]);
              bool right = (x < col_max[y]);
              if (up && down && left && right)
                  ans++;
          }
          return ans;
      }

    };©leetcode

155_Q1

复制代码
class Solution {
public:
    string findCommonResponse(vector<vector<string>>& responses) 
    {
        unordered_map<string,int> hash;
        for(auto& re:responses)
            {
                unordered_map<string,bool> check;
                for(auto& str:re)
                    {
                        if(!check[str])
                        {
                             check[str]=true;
                            hash[str]++; //确保 每一个 只加一次
                        }
                    }
            }
        pair<string,int> ret(responses[0][0],0);
        for(auto& [a,b]:hash)
            {
                string& f=ret.first;
                int& g=ret.second;
                if(b==g)
                {
                    if(a<f)
                        f=a;
                }
                if(b>g)
                {
                    f=a;
                    g=b;
                }
            }
        return ret.first;
    }
};
相关推荐
仙俊红13 分钟前
LeetCode每日一题,20250914
算法·leetcode·职场和发展
风中的微尘7 小时前
39.网络流入门
开发语言·网络·c++·算法
西红柿维生素8 小时前
JVM相关总结
java·jvm·算法
ChillJavaGuy9 小时前
常见限流算法详解与对比
java·算法·限流算法
sali-tec9 小时前
C# 基于halcon的视觉工作流-章34-环状测量
开发语言·图像处理·算法·计算机视觉·c#
你怎么知道我是队长11 小时前
C语言---循环结构
c语言·开发语言·算法
艾醒11 小时前
大模型面试题剖析:RAG中的文本分割策略
人工智能·算法
纪元A梦13 小时前
贪心算法应用:K-Means++初始化详解
算法·贪心算法·kmeans
_不会dp不改名_13 小时前
leetcode_21 合并两个有序链表
算法·leetcode·链表
mark-puls13 小时前
C语言打印爱心
c语言·开发语言·算法