树形dp 2246. 相邻字符不同的最长路径

leetcode周赛的一题，这里可以对比出使用邻接表模拟数组以及使用vector容器的时间复杂度对比。
回到问题本身，是一体典型的树形dp问题，遍历每一个节点，返回和每一个子节点所构成的最长路径，而答案是某个节点（如果有），其最长的两个节点构成的路径之和。

以下为解答给出的答案：

class Solution {
public:
    int longestPath(vector<int> &parent, string &s) {
        int n = parent.size();
        vector<vector<int>> g(n);
       	// 用二维数组记录每一个父子节点关系
        for (int i = 1; i < n; ++i)
            g[parent[i]].push_back(i);

        int ans = 0;
        // function 模板和 lambda表达式结合 [&]表示按引用传递上下文的值
        function<int(int)> dfs = [&](int x) -> int {
            int maxLen = 0;
            for (int y : g[x]) {
                int len = dfs(y) + 1;
                if (s[y] != s[x]) {
                    ans = max(ans, maxLen + len);
                    maxLen = max(maxLen, len);
                }
            }
            return maxLen;
        };
        dfs(0);
        return ans + 1;
    }
};

执行耗时：

如果使用y总的单链表来进行保存父子关系：

const int N = 100010;
class Solution {
public:
    int h[N], e[N], ne[N], idx, res = 0;
    string s;
    int dfs(int u) {
        int maxLen = 0;
        for (int i = h[u]; i != -1; i = ne[i]) {
            int j = e[i];
            int len = dfs(j) + 1;
            if (s[u] != s[j]) {
                res = max(res, len + maxLen);
                maxLen = max(maxLen, len);
            }
            
        }
        return maxLen;
    }
    int longestPath(vector<int>& parent, string _s) {
        s = _s;
        memset(h, -1, sizeof h);
        int head;
        // 用单链表保存关系，并且记录出头节点
        for (int i = 0; i < parent.size() ;i++) {
            if (parent[i] == -1) head = i;
            else {
                e[idx] = i, ne[idx] = h[parent[i]], h[parent[i]] = idx++;
            }
        }
        int find = dfs(head);    // 这句话的作用就是去执行以下循环而已，find表示根节点以下的最长路径，但不是答案，答案是可以在两个子节点中最长路劲相加的值

        return res + 1;
    }
};

y总yyds!!!