opt3 seems to be working at least 4 3 vertices

import java.util.*;

public class optlab3 {

    Map<Vertex, Set<Vertex>> dominanceFrontier;
    List<Vertex> postOrder;
    Vertex root;

    private void generateDFGlobal() {

        postOrder.forEach(x -> {
            dominanceFrontier.put(x, new HashSet<Vertex>());
            x.succs.forEach(succ -> {
                if (x != succ.immediateDom) {
                    dominanceFrontier.get(x).add(succ);
                    System.out.println("added");
                }
            });
            x.children.forEach(child -> {
                if (null != dominanceFrontier.get(child)) {
                    dominanceFrontier.get(child).forEach(y -> {
                        if (x != y.immediateDom)
                            dominanceFrontier.get(x).add(y);
                    });
                }
            });
        });
    }

    private Set<Vertex> generateDFSet(Set<Vertex> vertexSet) {

        Set<Vertex> res = new HashSet<Vertex>();
        vertexSet.forEach(v -> res.addAll(dominanceFrontier.get(v)));

        return res;
    }

    private Set<Vertex> generateDFPSet(Set<Vertex> vertexSet) {

        Set<Vertex> res = new HashSet<Vertex>();
        Set<Vertex> DFP = generateDFSet(vertexSet);
        boolean change;

        do {
            change = false;

            DFP.addAll(vertexSet);
            DFP = generateDFSet(DFP);

            if (DFP != res) {
                DFP = res;
                change = true;
            }
        } while (change);

        return res;
    }

    private int whichPred(Vertex bottomVertexToBeSearchedWithin,
                          Vertex topVertexToBeSearhedFor) {

        return bottomVertexToBeSearchedWithin.precs.indexOf(topVertexToBeSearhedFor);
    }

    private void traverse(Vertex v, Var p, List<Integer> stack, int counter) {
        /*
        v.statements.forEach(stmt -> {
            if (!stmt.isPhi)
                stmt.renameRhsVar(p.name, stack.get(stack.size() - 1));
            if (stmt.isAss && stmt.lhsIs(p)) {
                stmt.renameLhsVar(counter);
                stack.add(counter);
                //counter++
            }
        });*/
        //int counter = stack.get(stack.size() - 1);

        for (Stmt stmt : v.statements) {
            if (!stmt.isPhi)
                stmt.renameRhsVar(p.name, stack.get(stack.size() - 1));
            if (stmt.isAss && stmt.lhsIs(p)) {
                stmt.renameLhsVar(p.name, counter);
                stack.add(counter);
                counter++;
            }
        }

        v.succs.forEach(succ -> {
            int j = whichPred(succ, v);
            succ.phis.forEach(phiStmt -> {
                Var operand = phiStmt.rhs.vars.get(j);
                operand.index = stack.get(stack.size() - 1);
                phiStmt.rhs.vars.set(j, operand);
            });
        });

        //v.children.forEach(child -> traverse(child, p, stack, counter));
        for (Vertex child : v.children)
            traverse(child, p, stack, counter);

        v.statements.forEach(stmt -> {
            if (stmt.lhs.name.equals(p.name))
                stack.remove(stack.size() - 1);
        });
    }

    private void renameVar(Var p) {

        List<Integer> stack = new ArrayList<Integer>();
        stack.add(0);
        int counter = 0;

        traverse(root, p, stack, counter);
    }


    private List<Stmt> initStmts(String statment) {
        return null;
    }

    private void buildCFGSample1() {

        //   [A]
        //  /   \
        // [B]  [C]
        //  \   /
        //   [D]
        //    |
        //   [E]

        Vertex a = new Vertex("a");
        Vertex b = new Vertex("b");
        Vertex c = new Vertex("c");
        Vertex d = new Vertex("d");
        Vertex e = new Vertex("e");

        this.postOrder.add(b);
        this.postOrder.add(c);
        this.postOrder.add(a);

        //=================== A ===================
        Var leftPartA1 = new Var("x", "=");
        Expr rightPartA1 = new Expr();
        rightPartA1.vars.add(new Var("5", ";"));
        Expr rightPartA2 = new Expr();
        rightPartA2.vars.add(new Var("x", "-"));
        rightPartA2.vars.add(new Var("3", ";"));
        Expr rightPartA3 = new Expr();
        rightPartA3.vars.add(new Var("1", ";"));

        a.statements.add(new AssStmt(leftPartA1, rightPartA1));
        a.statements.add(new AssStmt(new Var("x", "="), rightPartA2));
        a.statements.add(new AssStmt(new Var("y", "="), rightPartA3));
        a.children.add(b);
        a.children.add(c);
        a.succs.add(b);
        a.succs.add(c);
        a.immediateDom = null;

        //=================== B ===================
        Var leftPartB = new Var("t", "=");
        Expr rightPartB1 = new Expr();
        rightPartB1.vars.add(new Var("x", "*"));
        rightPartB1.vars.add(new Var("2", ";"));
        Expr rightPartB2 = new Expr();
        rightPartB2.vars.add(new Var("y", ";"));

        b.statements.add(new AssStmt(new Var("y", "="), rightPartB1));
        b.statements.add(new AssStmt(new Var("w", "="), rightPartB2));
        b.precs.add(a);
        b.immediateDom = a;

        //=================== C ===================
        Expr rightPartC1 = new Expr();
        rightPartC1.vars.add(new Var("x", "-"));
        rightPartC1.vars.add(new Var("3", ";"));

        c.statements.add(new AssStmt(new Var("y", "="), rightPartC1));
        c.precs.add(b);
        c.immediateDom = a;


        //renameVar(a, new Var("x", ""));
        //renameVar(a, new Var("y", ""));
        root = a;
    }

    public static void main(String args[]) {

        optlab3 CFG = new optlab3();
        CFG.postOrder = new ArrayList<Vertex>();
        CFG.dominanceFrontier = new HashMap<Vertex, Set<Vertex>>();

        CFG.buildCFGSample1();
        CFG.generateDFGlobal();

        CFG.renameVar(new Var("x", ""));
        CFG.renameVar(new Var("y", ""));
        CFG.renameVar(new Var("w", ""));

        CFG.printDominanceFrontier();

    }



    private void printDominanceFrontier() {
        String s = "->";
        for (Vertex v : dominanceFrontier.keySet()) {
            s += v.toString() + " :[";
            Set<Vertex> tmpSet = dominanceFrontier.get(v);
            for (Vertex v1 : tmpSet)
                s += v1.toString();
            s += "];\n";
        }
        System.out.println(s);
    }
}



->A={stmts=[x_0 =5_0 ; , x_1 =x_0 - 3_0 ; , y_0 =1_0 ; ]} :[];
C={stmts=[y_1 =x_1 - 3_0 ; ]} :[];
B={stmts=[y_1 =x_1 * 2_0 ; , w_0 =y_1 ; ]} :[];