leetcode（相邻字符不同的最长路径）

 采用思路：BFS+分治

/**
 * @param {number[]} parent
 * @param {string} s
 * @return {number}
 */

var longestPath = function(parent, s) {
    var maps = [];
    var ans = 0;
    var new_tree_node = [];
    var new_tree = [];
    var new_s = [];
    //注意：是相邻节点不同而不是路径上所有的字符都不同
    //如果是路径上所有字符都不相同呢？
    for(let i = 0; i < parent.length; i++) {
        maps[i] = [1];
        if(new_tree_node[parent[i]] == undefined) {
            new_tree_node[parent[i]] = [];
        } 
        new_tree_node[parent[i]].push(i);
    }

    var root = new_tree_node[-1];
    var node_queue = [];
    node_queue.push(root);
    let inx = -1;
    let pos = 0;
    new_tree.push(inx);
    new_s[pos] = s[root];
    inx++;pos++;
    while(node_queue.length > 0) {
        let cur_node = node_queue.pop();
        if(new_tree_node[cur_node] == undefined) {
            inx++;
            continue;
        }
        for(let y = 0; y < new_tree_node[cur_node].length; y++) {
            node_queue.unshift(new_tree_node[cur_node][y]);
            new_tree.push(inx);
            new_s[pos] = s[new_tree_node[cur_node][y]];
            pos++;
        }
        inx++;
    }

    s = new_s;parent = new_tree;

    for(let i = parent.length - 1; i >= 0; i--) {
        
        if(parent[i] == -1 || s[parent[i]] == s[i]) {
            continue;
        }
        maps[parent[i]].push(maps[i][0] + 1);
        maps[parent[i]].sort((a, b)=>{
            return b - a;
        });
        if(maps[parent[i]].length > 2) {
            maps[parent[i]].pop();
        }
       
    }

    for(let l = 0; l < maps.length; l++) {
        let node_max_path = 0;
        for(let m = 0; m < maps[l].length; m++) {
            node_max_path += maps[l][m];
            if(m == 1) {
                node_max_path--;
            }
        }
        ans = Math.max(node_max_path,ans);
    }

    return ans;
};

如果是找寻树中路径上没有相同字符的最长路径呢？

一种方法是中序遍历加上前序遍历构成两组字符串，然后找到的字符串中最长连续的不含相同字符的子字符串便是该树上最长的不同字符路径。