leetocde 5941. 找出知晓秘密的所有专家

 

 

 

 

 

 

typedef pair<int,int> pii;
const int N=1e5+5;
class Solution {
public:
    struct cmp{
        bool operator()(pii &a, pii &b)
        {
            return a.second>b.second;
        }
    };
    
    int dis[N];
    vector<int> findAllPeople(int n, vector<vector<int>>& meetings, int firstPerson) {
        memset(dis,0x3f,sizeof(dis));
        vector<pii>G[N];
        vector<int>ans;
        priority_queue<pii,vector<pii>,cmp>pq;
        for(auto &p:meetings)
        {
            int u=p[0],v=p[1],d=p[2];
            G[u].push_back({v,d});
            G[v].push_back({u,d});
        }
        dis[0]=0;
        G[0].push_back({firstPerson,0});
        pq.push({0,0});
        while(pq.size())
        {
            auto [u,d]=pq.top();
            pq.pop();
            if(dis[u]<d)continue;
            ans.push_back(u);
            for(auto &[v,dv]:G[u])
            {
               if(dv>=d&&dv<dis[v])
               {
                   pq.push({v,dv});
                   dis[v]=dv;
               }
            }
        }
        return ans;
    }
};

这是dijkstra的变形题，关键在于能否看出用两个专家的时间代替距离，这样更新的时候我们判断一下当前节点的所有dis[u]与当前时间线d的关系，dis[u]<d说明u在前面更新过，u的专家已经知道信息了。更新的时候取判断与u专家开会的其他专家，如果d[v]>=d，说明v的时间线在d后面，从而v也是能获取信息的，否则v在当前d的前面v是不能知道信息的，由dij算法原理，我们知道每个专家u的d是它知道信息的最开始时间。从而算法是正确的。

 

typedef pair<int,int> pii;
class Solution {
public:

    vector<int> findAllPeople(int n, vector<vector<int>>& meetings, int firstPerson) {
        vector<int>ans;
        int f[n];
        memset(f,0,sizeof(f));
        f[0]=1;f[firstPerson]=1;
        map<int,vector<pii>>mp;
        for(auto &p:meetings)
        {
            int u=p[0],v=p[1],time=p[2];
            mp[time].push_back({u,v});
        }  
        for(auto &t:mp)
        {
            unordered_map<int,vector<int>>G;
            for(auto &[u,v]:t.second)
            {
                G[u].push_back(v);
                G[v].push_back(u);            
            }
            queue<int>q;
            for(auto &p:G)
            {
                if(f[p.first])
                q.push(p.first);
            }
            while(q.size())
            {
                auto u=q.front();
                q.pop();
                for(auto &v:G[u])
                {
                    if(!f[v])
                    {
                        q.push(v);
                        f[v]=1;
                    }
                }
            }
        }
        for(int i=0;i<n;i++)if(f[i])ans.push_back(i);
        return ans;
    }
};

 

按时间建图的做法复杂度好高啊，也是我一开始先预处理；