We use cookies to ensure you have the best browsing experience on our website. Please read our cookie policy for more information about how we use cookies.
  1. Prepare
  2. Java
  3. Advanced
  4. Java Visitor Pattern
  5. Discussions

Java Visitor Pattern

Sort by

recency

|

198 Discussions

|

  • koduruvijay2004
     + 0 comments

    class SumInLeavesVisitor extends TreeVis { private int sum = 0;

    public int getResult() {
    return sum;
}

public void visitNode(TreeNode node) {
    // No action needed for internal nodes in this visitor
}

public void visitLeaf(TreeLeaf leaf) {
    sum += leaf.getValue();
}

    }

    class ProductOfRedNodesVisitor extends TreeVis { private double product = 1;

    public int getResult() {
    return (int) product;
}

public void visitNode(TreeNode node) {
    increaseProduct(node);
}

public void visitLeaf(TreeLeaf leaf) {
    increaseProduct(leaf);
}

private void increaseProduct(Tree tree) {
    if (tree.getColor() == Color.RED) {
        product = (product * tree.getValue()) % (Math.pow(10, 9) + 7);
    }
}

    }

    class FancyVisitor extends TreeVis { private int nonLeafNodeSum = 0; private int greenLeafSum = 0;

    public int getResult() {
    return Math.abs(nonLeafNodeSum - greenLeafSum);
}

public void visitNode(TreeNode node) {
    if (node.getDepth() % 2 == 0) {
        nonLeafNodeSum += node.getValue();
    }
}

public void visitLeaf(TreeLeaf leaf) {
    if (leaf.getColor() == Color.GREEN) {
        greenLeafSum += leaf.getValue();
    }
}

    }

    public class Solution {

    public static Tree solve() {
    Scanner scan = new Scanner(System.in);
    int n = Integer.parseInt(scan.nextLine());
    String valuesLine = scan.nextLine();
    String colorsLine = scan.nextLine();

    String[] valuesStr = valuesLine.split(" ");
    int[] values = new int[n];

    for (int i = 0; i < n; i++) {
        values[i] = Integer.parseInt(valuesStr[i]);
    }

    String[] colorsStr = colorsLine.split(" ");
    byte[] colors = new byte[n];

    for (int i = 0; i < n; i++) {
        colors[i] = (byte) Integer.parseInt(colorsStr[i]);
    }

    Map<Integer, List<Integer>> adj = new HashMap<>();
    boolean[] visited = new boolean[n];

    for (int i = 0; i < n; i++) {
        adj.put(i, new ArrayList<Integer>());
    }

    while (scan.hasNextInt()) {
        int u = scan.nextInt() - 1;
        int v = scan.nextInt() - 1;
        adj.get(u).add(v);
        adj.get(v).add(u);
    }

    scan.close();

    return buildTree(0, 0, values, colors, adj, visited);
}

public static Tree buildTree(
    int index, int depth, int[] values, byte[] colors, Map<Integer, List<Integer>> adj, boolean[] visited
) {
    boolean isLeaf = true;
    visited[index] = true;

    Color color = colors[index] == 0 ? Color.RED : Color.GREEN;
    List<Integer> children = adj.get(index);
    TreeNode treeNode = new TreeNode(values[index], color, depth);

    for (int child : children) {
        if (!visited[child]) {
            isLeaf = false;
            Tree childNode = buildTree(child, depth + 1, values, colors, adj, visited);
            treeNode.addChild(childNode);
        }
    }

    if (isLeaf) {
        return new TreeLeaf(values[index], color, depth);
    } else {
        return treeNode;
    }
}

  • tusharvyavahare1
     + 0 comments

    what?!?

  • erickpastrana
     + 0 comments

    java solution with the supposed pre-existing classes

    public class Solution {
    static int n;
    static int[] values;
    static Color[] colors;
    static Map<Integer, Set<Integer>> edges;

    public static void main(String[] args) {
        Tree root = solve();

        SumInLeavesVisitor vis1 = new SumInLeavesVisitor();
        ProductRedNodesVisitor vis2 = new ProductRedNodesVisitor();
        FancyVisitor vis3 = new FancyVisitor();

        root.accept(vis1);
        root.accept(vis2);
        root.accept(vis3);

        System.out.println(vis1.getResult());
        System.out.println(vis2.getResult());
        System.out.println(vis3.getResult());
    }
    
     public static Tree solve() {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();

        values = new int[n+1];
        for (int i = 1; i <= n; i++) {
            values[i] = sc.nextInt();
        }

        colors = new Color[n+1];
        for (int i = 1; i <= n; i++) {
            int c = sc.nextInt();
            colors[i] = (c == 0 ? Color.RED : Color.GREEN);
        }

        edges = new HashMap<>();
        for (int i = 1; i <= n; i++) edges.put(i, new HashSet<>());
        for (int i = 0; i < n-1; i++) {
            int u = sc.nextInt();
            int v = sc.nextInt();
            edges.get(u).add(v);
            edges.get(v).add(u);
        }

        sc.close();
        return buildTree(1, 0, -1); // root=1, depth=0, parent=-1
    }    
    
    private static Tree buildTree(int node, int depth, int parent) {
        Set<Integer> childs = edges.get(node);
        if(childs.size() == 1 && childs.contains(parent)){
            //es hoja
            return new TreeLeaf(values[node], colors[node], depth);
        } else {
            TreeNode tn = new TreeNode(values[node], colors[node], depth);
            for(int child : childs){
                if(child != parent) {
                    tn.addChild(buildTree(child, depth+1, node));
                }
            }
            return tn;
        }
    }
}

enum Color {RED, GREEN}

abstract class Tree {
    private int value;
    private Color color;
    private int depth;
    
    public Tree(int value, Color color, int depth){
        this.value = value;
        this.color = color;
        this.depth = depth;
        
    }
    
    public int getValue(){ return value;}
    public Color getColor(){ return color;}
    public int getDepth(){ return depth;}
    
    public abstract void accept(TreeVis visitor);
}

class TreeNode extends Tree{
    private List<Tree> children = new ArrayList<>();
    
    public TreeNode(int value, Color color, int depth){
        super(value, color, depth);
    }
    
    public void accept(TreeVis visitor){
        visitor.visitNode(this);
        for(Tree child : children){
            child.accept(visitor);
        }
    }
    
    public void addChild(Tree child){ children.add(child); }
}

class TreeLeaf extends Tree{
    public TreeLeaf(int value, Color color, int depth){
        super(value, color, depth);
    }
    
    public void accept(TreeVis visitor){
        visitor.visitLeaf(this);
    }
}

interface TreeVis{
    int getResult();
    void visitNode(TreeNode tree);
    void visitLeaf(TreeLeaf tree);
}

class SumInLeavesVisitor implements TreeVis {
    private int sum = 0;
    
    public int getResult(){ return sum; }
    
    public void visitNode(TreeNode node){ /*no hace nada*/ }
    
    public void visitLeaf(TreeLeaf leaf){
        sum += leaf.getValue();
    }
}

class ProductRedNodesVisitor implements TreeVis {
    private long product = 1;
    private static final int MOD = 1000000007;
     
    public int getResult(){ return (int)(product % MOD); }
    
    public void visitNode(TreeNode node){ 
        if(node.getColor() == Color.RED)
            product = (product * node.getValue()) % MOD;
     }
    
    public void visitLeaf(TreeLeaf leaf) {
        if (leaf.getColor() == Color.RED) {
            product = (product * leaf.getValue()) % MOD;
        }
    }
}

class FancyVisitor  implements TreeVis {
    private int evenDepthNonLeafSum  = 0;
    private int greenLeafSum = 0;
     
    public int getResult(){ return (int)(Math.abs( evenDepthNonLeafSum - greenLeafSum)); }
    
    public void visitNode(TreeNode node){ 
        if(node.getDepth()  % 2 == 0)
            evenDepthNonLeafSum += node.getValue();
     }
    
    public void visitLeaf(TreeLeaf leaf) {
        if (leaf.getColor() == Color.GREEN) {
            greenLeafSum += leaf.getValue();
        }
    }
}

  • erickpastrana
     + 0 comments

    I don't get it are this clases provided? or do we have to implement them? abstract class Tree class TreeNode extends Tree class TreeLeaf extends Tree abstract class TreeVis

    because the compiler is not able to find the but the text says: "A Tree class implementing a rooted tree is provided in the editor"

  • tileharshad
     + 0 comments

    import java.io.; import java.util.;

    enum Color { RED, GREEN }

    abstract class Tree { private int value; private Color color; private int depth;

    public Tree(int value, Color color, int depth) {
    this.value = value;
    this.color = color;
    this.depth = depth;
}

public int getValue() {
    return value;
}

public Color getColor() {
    return color;
}

public int getDepth() {
    return depth;
}

public abstract void accept(TreeVis visitor);

    }

    class TreeNode extends Tree { private final List children = new ArrayList<>();

    public TreeNode(int value, Color color, int depth) {
    super(value, color, depth);
}

public void accept(TreeVis visitor) {
    visitor.visitNode(this);
    for (Tree child : children) {
        child.accept(visitor);
    }
}

public void addChild(Tree child) {
    children.add(child);
}

    }

    class TreeLeaf extends Tree { public TreeLeaf(int value, Color color, int depth) { super(value, color, depth); }

    public void accept(TreeVis visitor) {
    visitor.visitLeaf(this);
}

    }

    abstract class TreeVis { public abstract int getResult(); public abstract void visitNode(TreeNode node); public abstract void visitLeaf(TreeLeaf leaf); }

    // Visitor 1: Sum of all leaf values class SumInLeavesVisitor extends TreeVis { private int sum = 0;

    public int getResult() {
    return sum;
}

public void visitNode(TreeNode node) {}

public void visitLeaf(TreeLeaf leaf) {
    sum += leaf.getValue();
}

    }

    // Visitor 2: Product of red node values class ProductOfRedNodesVisitor extends TreeVis { private long product = 1; private final int MOD = 1_000_000_007;

    public int getResult() {
    return (int) product;
}

public void visitNode(TreeNode node) {
    if (node.getColor() == Color.RED) {
        product = (product * node.getValue()) % MOD;
    }
}

public void visitLeaf(TreeLeaf leaf) {
    if (leaf.getColor() == Color.RED) {
        product = (product * leaf.getValue()) % MOD;
    }
}

    }

    // Visitor 3: Difference between even depth node sum and green leaf sum class FancyVisitor extends TreeVis { private int sumEvenDepthNonLeaf = 0; private int sumGreenLeaf = 0;

    public int getResult() {
    return Math.abs(sumEvenDepthNonLeaf - sumGreenLeaf);
}

public void visitNode(TreeNode node) {
    if (node.getDepth() % 2 == 0) {
        sumEvenDepthNonLeaf += node.getValue();
    }
}

public void visitLeaf(TreeLeaf leaf) {
    if (leaf.getColor() == Color.GREEN) {
        sumGreenLeaf += leaf.getValue();
    }
}

    }

    public class Solution {

    private static int[] values;
private static Color[] colors;
private static Map<Integer, List<Integer>> treeMap = new HashMap<>();

public static void main(String[] args) {
    Tree root = solve();

    TreeVis vis1 = new SumInLeavesVisitor();
    TreeVis vis2 = new ProductOfRedNodesVisitor();
    TreeVis vis3 = new FancyVisitor();

    root.accept(vis1);
    root.accept(vis2);
    root.accept(vis3);

    System.out.println(vis1.getResult());
    System.out.println(vis2.getResult());
    System.out.println(vis3.getResult());
}

public static Tree solve() {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();

    values = new int[n];
    for (int i = 0; i < n; i++) {
        values[i] = sc.nextInt();
    }

    colors = new Color[n];
    for (int i = 0; i < n; i++) {
        colors[i] = sc.nextInt() == 0 ? Color.RED : Color.GREEN;
    }

    for (int i = 0; i < n - 1; i++) {
        int u = sc.nextInt() - 1;
        int v = sc.nextInt() - 1;

        treeMap.computeIfAbsent(u, x -> new ArrayList<>()).add(v);
        treeMap.computeIfAbsent(v, x -> new ArrayList<>()).add(u);
    }

    return buildTree(0, 0, -1);
}

private static Tree buildTree(int node, int depth, int parent) {
    List<Integer> children = treeMap.getOrDefault(node, new ArrayList<>());
    children.remove((Integer) parent);

    if (children.isEmpty()) {
        return new TreeLeaf(values[node], colors[node], depth);
    } else {
        TreeNode treeNode = new TreeNode(values[node], colors[node], depth);
        for (int child : children) {
            treeNode.addChild(buildTree(child, depth + 1, node));
        }
        return treeNode;
    }
}

    }