反转图表 - 试图提高效率

Question

我试图在这个反向图问题中提高效率。这个想法很简单，你得到一个有向连通循环图，然后反转边的方向。

我猜对了，但我想让它更快，有些条目需要将近 2 秒。太可怕了……

如果有人知道任何可以帮助加快下面这段代码的事情，请告诉我。

static class Node
        {
            Integer val;
            Vector<Node> neighbours = new Vector<Node>(0);
            Node(Integer _val)
            {
                val = _val;
                neighbours.clear();
            }
        };

static Node build_other_graph(Node node)
    {
        if(node.neighbours.size() == 0)
            return new Node(node.val);

        dfs(node);
        return col.get(node.val);
    }

    static Node n = null;
    static HashMap<Integer, Node> col = new HashMap<>();
    static HashSet<Integer> visited = new HashSet<>();
    static void dfs(Node node)
    {
        if(node == null || visited.contains(node.val))
            return;

        //visit
        Vector<Node> adj = node.neighbours;
        visited.add(node.val);
        for(Node i: adj)
        {
            if(col.keySet().contains(i.val))
            {
               if(col.keySet().contains(node.val))
                    col.get(i.val).neighbours.add(col.get(node.val));
               else
                   col.get(i.val).neighbours.add(new Node(node.val));
            }
            else
            {
               Node v = new Node(i.val);
               if(col.keySet().contains(node.val))
                    v.neighbours.add(col.get(node.val));
               else
                    v.neighbours.add(new Node(node.val));
               col.put(i.val, v);
            }
            dfs(i);
        }
    }

Answer 1

所以这里是我的意思的简单例子。看看它运行了多长时间 - 需要更多时间进行初始化，但反向立即进行并且只有一个

   package graph.nodes.simple;

import java.util.ArrayList;

public class GArrayListGraph extends ArrayList<GArrayListNode> {

    /**
     * 
     */
    private static final long serialVersionUID = 2493196722065921126L;
    boolean calculated = false;



    public GArrayListNode addNode(Object e) {

        GArrayListNode ret = new GArrayListNode(e);
        super.add(ret);
        return ret ;
    }

    public void addEdge(GArrayListNode a, GArrayListNode b) {

        a.neighbours.add(b);
    }   


    public void printall() {

        System.out.println("GArrayListGraph");

        for (GArrayListNode node : this) {


            System.out.println(node.toString());
        }

    }


    public void reverce() {

        if (!calculated) {
            for (GArrayListNode node : this) {

                for (GArrayListNode neighbour : node.neighbours) {

                    neighbour.neighboursReverse.add(node);

                }
            }
            this.calculated = true;
        }
        // swap neighbours and neighboursReverse
        for (GArrayListNode node : this) {

            ArrayList<GArrayListNode> temp = node.neighbours;
            node.neighbours = node.neighboursReverse;
            node.neighboursReverse = temp;

        }

    }
}    



package graph.nodes.simple;

import java.util.ArrayList;

import java.util.Random;


import java.util.Timer;
import java.util.TimerTask;

public class GArrayListNode {

    Object val;
    ArrayList<GArrayListNode> neighbours;
    ArrayList<GArrayListNode> neighboursReverse;

    public GArrayListNode(Object val) {
        this.val = val;
        this.neighbours = new ArrayList<GArrayListNode>();
        this.neighboursReverse = new ArrayList<GArrayListNode>();
    }

    @Override
    public String toString() {

        return val.toString() + " : " + this.toStringChildren();
    }

    public String toStringChildren() {

        StringBuilder sb = new StringBuilder();

        for (GArrayListNode node : neighbours) {

            sb.append(node.val).append(',');

        }
        return sb.toString();
    }

    public static void main(String[] args) {

        GArrayListGraph g = new GArrayListGraph();

        GArrayListNode n10 = g.addNode(10);

        GArrayListNode n11 = g.addNode(11);

        GArrayListNode n12 = g.addNode(12);

        GArrayListNode n13 = g.addNode(13);

        GArrayListNode n14 = g.addNode(14);

        g.addEdge(n10, n11);

        g.addEdge(n11, n12);

        g.addEdge(n10, n12);

        g.addEdge(n12, n13);

        g.addEdge(n12, n14);

        g.addEdge(n14, n10);

        g.printall();

        g.reverce();

        g.printall();

        g.reverce();

        g.printall();

        System.out.println("see its the same, now time performance test");

        int nodes = 1000 * 1000 * 10;

        for (int i = 0; i < nodes; i++) {

            g.addNode(i);

        }

        int edges = 1000 * 10;

        Random r = new Random();
        for (int i = 0; i < nodes; i++) {

            int from = r.nextInt(nodes);
            int to = r.nextInt(nodes);

            g.addEdge(g.get(from), g.get(to));


        }

        long startTime = System.currentTimeMillis();
        System.out.println("start" );
        g.reverce();

        long elapsed = System.currentTimeMillis() - startTime;

        System.out.println("elapsed " + elapsed);



    }

}