leetcode 2359.找到离给定两个节点最近的节点

首先说一下超时的做法，其实也能过66个样例：

就是用BFS遍历存储路径，因为题目中已经说了至多一条边，所以对于每一点来说，不可能出现多路径问题，要么只有一条路径，要么就没有路，所以顺序存储的节点的距离是依次按1递增的（从自己的距离0开始）。

由于有两个出发点，所以我们用了两个数组存储这两个点的路径，然后判断这里面的哪些点是遇到的点相同的，记录一下它们之间的的最大距离，存储到最终的结果数组中。

在结果数组中筛选出距离最小的那个对应的节点就是答案了。

因为时间复杂度在判断相同结点的时候变高了，所以这个做法有一部分大数据过不了。

class Solution {
public:
queue<int>q;
void bfs(int u,vector<vector<int>>&s,vector<bool>&st,vector<int>&res){
    q.push(u);
    res.push_back(u);
    st[u]=true;
    while(!q.empty()){
        int tmp=q.front();
        q.pop();
        for(int i=0;i<s[tmp].size();i++){
            if(!st[s[tmp][i]]){
                st[s[tmp][i]]=true;
                res.push_back(s[tmp][i]);
                q.push(s[tmp][i]);
            }
        }
    }
}
    int closestMeetingNode(vector<int>& edges, int node1, int node2) {
        vector<int>res1;
        vector<int>res2;
        vector<vector<int>>s(edges.size());
        vector<bool>st(edges.size(),false);
        for(int i=0;i<edges.size();i++){
            if(edges[i]!=-1){
                s[i].push_back(edges[i]);
            }
        }
        bfs(node1,s,st,res1);
        q=queue<int>();
        for(int i=0;i<st.size();i++)
        st[i]=false;
        bfs(node2,s,st,res2);
        vector<int>res(edges.size(),edges.size()+1);
        int mins=INT_MAX;
        for(int i=0;i<res1.size();i++){
            int tmp=res1[i];
            for(int j=0;j<res2.size();j++){
                if(tmp==res2[j]){
                    res[tmp]=max(j,i);
                }
            }
        }
            for(int i=0;i<res.size();i++){
                mins=min(mins,res[i]);
            }
            int index=-1;
            for(int i=0;i<res.size();i++){
                if(mins==edges.size()+1)
                break;
                else{
                if(res[i]==mins)
                {
                    index=i;
                    break;
                }
                }
            }
        return index;
    }
};

然后作者做了一些改进，就是用了哈希表映射，让程序看起来更长了，其实就是空间换时间而已。

把二重循环换掉了，匹配相同路径的做法，换成了用一个共同的数组计数，为2的时候说明这个是两个起点开始经过的共同点。

class Solution {
public:
queue<int>q;
void bfs(int u,vector<vector<int>>&s,vector<bool>&st,vector<int>&res){
    q.push(u);
    res.push_back(u);
    st[u]=true;
    while(!q.empty()){
        int tmp=q.front();
        q.pop();
        for(int i=0;i<s[tmp].size();i++){
            if(!st[s[tmp][i]]){
                st[s[tmp][i]]=true;
                res.push_back(s[tmp][i]);
                q.push(s[tmp][i]);
            }
        }
    }
}
    int closestMeetingNode(vector<int>& edges, int node1, int node2) {
        vector<int>res1;
        vector<int>res2;
        vector<vector<int>>s(edges.size());
        vector<bool>st(edges.size(),false);
        for(int i=0;i<edges.size();i++){
            if(edges[i]!=-1){
                s[i].push_back(edges[i]);
            }
        }
        bfs(node1,s,st,res1);
        q=queue<int>();
        for(int i=0;i<st.size();i++)
        st[i]=false;
        bfs(node2,s,st,res2);
        vector<int>res(edges.size(),edges.size()+1);
        vector<int>counts(edges.size(),0);
        vector<int>m1(edges.size(),0);
        vector<int>m2(edges.size(),0);
        for(int i=0;i<res1.size();i++){
            counts[res1[i]]++;
            m1[res1[i]]=i;
        }
        for(int i=0;i<res2.size();i++){
            counts[res2[i]]++;
            m2[res2[i]]=i;
        }
        for(int i=0;i<counts.size();i++){
            if(counts[i]==2){
                res[i]=max(m2[i],m1[i]);
            }
            
        }
        int index=-1;
        int mins=INT_MAX;
        for(int i=0;i<res.size();i++){
            mins=min(mins,res[i]);
        }
        for(int i=0;i<res.size();i++){
            if(mins==edges.size()+1)
            break;
            else{
                if(mins==res[i]){
                    index=i;
                    break;
                }
            }
        }
        return index;
    }
};