def minimalOperations(words):
    result = []
    for word in words:
        count = 0
        i = 0
        while i < len(word) - 1:
            if word[i] == word[i+1]:
                count += 1
                i += 2  # Skip the next character to avoid overlapping
            else:
                i += 1
        result.append(count)
    return result

def getMinimumOperations(tree_nodes, tree_from, tree_to, initial, expected):
    adj = [[] for _ in range(tree_nodes)]
    for i in range(len(tree_from)):
        adj[tree_from[i]].append(tree_to[i])
        adj[tree_to[i]].append(tree_from[i])
    
    parent = [-1] * tree_nodes
    depth = [0] * tree_nodes
    children = [[] for _ in range(tree_nodes)]
    
    def dfs(node, par):
        for next_node in adj[node]:
            if next_node != par:
                parent[next_node] = node
                depth[next_node] = depth[node] + 1
                children[node].append(next_node)
                dfs(next_node, node)
    
    dfs(0, -1)
    
    def flip_subtree(curr_values, node):
        new_values = curr_values.copy()
        stack = [node]
        while stack:
            current = stack.pop()
            if current % 2 == 0:
                new_values[current] = 1 - new_values[current]
            stack.extend(children[current])
        return new_values
    
    def get_path_to_root(node):
        path = []
        while node != -1:
            path.append(node)
            node = parent[node]
        return path
    
    operations = 0
    current = initial.copy()
    
    for node in range(tree_nodes):
        if current[node] != expected[node]:
            path = get_path_to_root(node)
            found = False
            for ancestor in path:
                test_values = flip_subtree(current, ancestor)
                if test_values[node] == expected[node]:
                    current = test_values
                    operations += 1
                    found = True
                    break
            if not found:
                return -1
    
    return operations if current == expected else -1