LeetCode - 第210场周赛

Rank

挺简单的第三题被卡了，结果第四题没时间写，难受…

A. 括号的最大嵌套深度

括号匹配，简单模拟.

class Solution {
public:
    int maxDepth(string s) {
        stack<char> st;
        int ans=0;
        for(char ch:s){
            if(ch=='('){
                st.push(ch);
                ans=max(ans,(int)st.size());
            }
            else if(ch==')'){
                st.pop();
            }
        }
        return ans;
    }
};

B. 最大网络秩

暴力枚举.

class Solution {
public:
    int g[105][105];

    int maximalNetworkRank(int n, vector<vector<int>>& roads) {
        for(int i=0;i<n;++i){
            for(int j=0;j<n;++j){
                g[i][j]=0;
            }
        }
        for(auto e:roads){
            int u=e[0],v=e[1];
            g[u][v]=g[v][u]=1;
        }
        int ans=0;
        for(int u=0;u<n;++u){
            for(int v=u+1;v<n;++v){
                int tmp=0;
                for(int i=0;i<n;++i) if(g[u][i]) ++tmp;
                for(int i=0;i<n;++i) if(g[v][i]) ++tmp;
                if(g[u][v]) --tmp;
                ans=max(ans,tmp);
            }
        }
        
        return ans;
    }
};

C. 分割两个字符串得到回文串

$a_{pre}+b_{suf}$ 能构成一个回文串，需要满足一下 2 个条件之一：

1. 前一部分满足 $a[i]=b[len-1-i]$，后一部分满足 $a[i]=a[len-1-i]$.
2. 前一部分满足 $a[i]=b[len-1-i]$，后一部分满足 $b[i]=b[len-1-i]$.

即只要 a 的开头和 b 的结尾符合回文串的要求，就让它们匹配，当不匹配时，a 或 b 的剩余部分为回文串才能满足要求.

class Solution {
public:
    bool check(string a,string b){
        int n=a.size();
        int i=0,j=n-1;
        while(i<j && a[i]==b[j]){
            ++i;--j;
        }
        
        bool ok=true;
        int pi=i,pj=j;
        while(pi<pj){
            if(a[pi]!=a[pj]){
                ok=false;
                break;
            }
            ++pi;
            --pj;
        }
        if(ok) return true;
        
        ok=true;
        pi=i,pj=j;
        while(pi<pj){
            if(b[pi]!=b[pj]){
                ok=false;
                break;
            }
            ++pi;
            --pj;
        }
        return ok;
    }

    bool checkPalindromeFormation(string a, string b) {
        int n=a.size();
        if(n<2) return true;
        return check(a,b) || check(b,a);
    }
};

D. 统计子树中城市之间最大距离

暴力枚举+树的直径.

二进制枚举树上点的集合，dfs 判断当前集合是否为一个连通块，如果是说明这是一颗子树，然后两次 bfs 计算该子树的直径，计入结果数组中.

class Solution {
public:
    const static int maxn=16;
    
    int d[maxn];
    bool in[maxn],done[maxn];
    vector<int> g[maxn];
    
    void dfs(int u){
        done[u]=true;
        for(auto v:g[u]) if(!done[v]) dfs(v);
    }
    
    pair<int,int> bfs(int s,int n){
        for(int i=0;i<n;++i) done[i]=false;
        done[s]=true;
        d[s]=0;
        queue<int> que;
        que.push(s);
        while(!que.empty()){
            int u=que.front();
            que.pop();
            for(auto v:g[u]){
                if(!done[v]){
                    done[v]=true;
                    d[v]=d[u]+1;
                    que.push(v);
                }
            }
        }
        int maxd=0,id;
        for(int i=0;i<n;++i){
            if(in[i] && d[i]>maxd){
                maxd=d[i];
                id=i;
            }
        }
        return make_pair(id,maxd);
    }
    
    vector<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges) {
        vector<int> ans(n-1,0);
        for(int s=1;s<(1<<n);++s){
            for(int i=0;i<n;++i){
                in[i]=done[i]=false;
                g[i].clear();
            }
            int sz=0;
            for(int i=0;i<n;++i){
                if(s>>i&1){
                    in[i]=true;
                    ++sz;
                }
            }
            if(sz<2) continue;
            for(auto e:edges){
                int u=e[0]-1,v=e[1]-1;
                if(!in[u] || !in[v]) continue;
                g[u].emplace_back(v);
                g[v].emplace_back(u);
            }
            for(int i=0;i<n;++i){
                if(in[i]){
                    dfs(i);
                    break;
                }
            }
            bool ok=true;
            for(int i=0;i<n;++i){
                if(in[i] && !done[i]){
                    ok=false;
                    break;
                }
            }
            if(!ok) continue;
            
            for(int i=0;i<n;++i){
                if(in[i]){
                    auto tmp=bfs(i,n);
                    int dist=bfs(tmp.first,n).second;
                    ++ans[dist-1];
                    break;
                }
            }
        }
        return ans;
    }
};