基于cache和不拆点的优化算法

　　一直对ds课上晏海华老师讲的dijkstra算法印象深刻，苦于一直没有地方施展，这次终于有了机会，于是第二次和第三次我都用了dijkstra算法莽到底。Dijkstra是单源的最短路径算法，主要特点是以起点为中心向外层层扩展（广度优先搜索思想），直至遍历完所有点，算出源点到其余所有点的最短距离。其具体算法思想在此不做过多阐述，不清楚的可以移步此网站。

　　

　　存储图

　　要想遍历图，首先得存图，我用邻接表来存 private HashMap<Integer, HashMap<Edge, Integer>>

　　第一个Integer为起始节点(fromNodeId)，第二个Integert为相同边的条数(为了防止在删边时一次删去了所有相同的边)，Edge类中保存了 toNodeId 和 weight (Edge类需要重写hashCode和equals方法以作为hashMap的key；需要继承Comparable接口并重写compareTo方法，使得Edge可以放入优先队列中；可以重写toSrting方法方便debug)

　　为什么一个叫Edge的类只保存了 toNodeId 和 weight ，而没有保存 fromNodeId 呢，因为在邻接表中 formNodeId 是作为索引的存在。在之后的 Dijkstra 算法中以起点为中心向外层层扩展，因为起点已经存在，每次只扩展 weight 和 toNodeId。所以在Edge类中根本用不到 fromNodeId。

public class Edge implements Comparable<Edge> {
    
    private int toNodeId;
    private int weight;
    
    public Edge(int toNodeId, int weight) {
        this. toNodeId= toNodeId;
        this.weight = weight;
    }

    @Override
    public int compareTo(Edge o) {
        return this.weight - o.getWeight();
    }
    
    @Override
    public String toString() {
        return (toNodeId + " " + weight);
    }
    
    @Override
    public int hashCode() {
        int result = 17;
        result = result * 37 + toNodeId;
        result = result * 37 + weight;
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (obj != null && (obj instanceof Edge)) {
            return (((Edge) obj).getTo() == toNodeId
                && ((Edge) obj).getWeight() == weight);
        } else {
            return false;
        }
    }
    
    public int getToNodeId() {
        return toNodeId;
    }
    
    public int getWeight() {
        return weight;
    }
}

　　我们得明确一点就是，要算的PATH_LENGTH、TICKET_PRICE、TRANSFER_COUNT和UNPLEASANT_VALUE是不相同的，而CONNECTED_BLOCK_COUNT可以利用上面任何一个来计算，我用的是PATH_LENGTH。接下来要解决的两个问题是如何构建邻接表和在何时利用Dijkstra算法。

　　

　　何时使用Dijkstra

　　第二次作业结构变更指令有20条，第三次作业结构变更指令有50条，虽然有所增加，但是还是只占指令总数的很小一部分。所以最先能想到的方法就是在结构变更指令中计算出之后所有可能要用到的信息并存储起来，但仔细一想这种做法其实是不可取的，因为这种做法可能会计算很多用不到的信息，浪费时间。因此我们可以在add和remove之后只构建好邻接表，在查询时知道具体的起点和终点之后再利用Dijkstra算法的可以算出起点到所有点的最短路径的特点，建立四个类似于cache的hashMap来保存先前计算出的结果。

　　我们利用Connect类来保存两个节点的信息。(Connect类同样需要重写hashCode和equals方法，可以重写toString方法，在这里运用一个小技巧，就是在构造方法中把较小的作为fromNodeId，较大的作为toNodeId，这样在查询时可以不用考虑fromNodeId和toNodeId的顺序)

public class Connect {

    private int fromNodeId;
    private int toNodeId;
    
    public Connect(int a, int b) {
        if (a <= b) {
            this.fromNodeId = a;
            this.toNodeId = b;
        } else {
            this.fromNodeId = b;
            this.toNodeId = a;
        }
    }
    
    @Override
    public int hashCode() {
        int result = 17;
        result = result * 37 + fromNodeId;
        result = result * 37 + toNodeId;
        return result;
    }
    
    @Override
    public boolean equals(Object obj) {
        if (obj != null && (obj instanceof Connect)) {
            return (((Connect) obj).getFromId() == fromNodeId
                && ((Connect) obj).getToId() == toNodeId);
        } else {
            return false;
        }
    }
    
    @Override
    public String toString() {
        return (fromNodeId + " " + toNodeId);
    }
    
    
    public int getFromIdNodeId () {
        return fromNodeId;
    }
    
    public int getToIdNodeId () {
        return toNodeId;
    }
}

　　我们在使用完Dijkstra后，将原点到各个点的距离保存在HashMap<Integer, Integer>中，前一个Integer为toNodeId，后一个Integer为计算出的最短距离。然后将计算结果保存在cache中cache.put(new Connect(fromNodeId, a), dis.get(a))，a为用Iterator遍历的dis的keySet()。

　　

　　构建邻接表

　　邻接表的构建需要分别考虑PATH_ADD和PATH_REMOVE两个过程，shortCount、transferCount、priceCount和valueCout分别代表四种图的邻接表。

a. shortCount

　　求最短路径就只需要按一般思路构建邻接表，即遍历一条路径，将相邻的两个点加入邻接表中。只用一次循环，path上两个点之间的权重设为1，需要更新相同边的num。

public HashMap<Integer, HashMap<Edge, Integer>> addShort(Path path) {
    for (int i = 0; i < path.size() - 1; i++) {
        if (shortCount.containsKey(path.getNode(i))) {
            HashMap<Edge, Integer> value
                = shortCount.get(path.getNode(i));
            Edge edge = new Edge(path.getNode(i + 1), 1);
            if (value.containsKey(edge)) {
                int num = value.get(edge);
                num++;
                value.put(edge, num);
            } else {
                value.put(edge, 1);
            }
            shortCount.put(path.getNode(i), value);
        } else {
            HashMap<Edge, Integer> value = new HashMap<>();
            Edge edge = new Edge(path.getNode(i + 1), 1);
            value.put(edge, 1);
            shortCount.put(path.getNode(i), value);
        }
        if (shortCount.containsKey(path.getNode(i + 1))) {
            HashMap<Edge, Integer> value
                = shortCount.get(path.getNode(i + 1));
            Edge edge = new Edge(path.getNode(i), 1);
            if (value.containsKey(edge)) {
                int num = value.get(edge);
                num++;
                value.put(edge, num);
            } else {
                value.put(edge, 1);
            }
            shortCount.put(path.getNode(i + 1), value);
        } else {
            HashMap<Edge, Integer> value = new HashMap<>();
            Edge edge = new Edge(path.getNode(i), 1);
            value.put(edge, 1);
            shortCount.put(path.getNode(i + 1), value);
        }
    }
    return shortCount;
}

public HashMap<Integer, HashMap<Edge, Integer>>
    removeShort(Path path) {
    for (int i = 0; i < path.size() - 1; i++) {
        HashMap<Edge, Integer> value = shortCount.get(path.getNode(i));
        Edge edge = new Edge(path.getNode(i + 1), 1);
        int num = value.get(edge);
        num--;
        if (num == 0) {
            value.remove(edge);
            if (value.size() == 0) {
                shortCount.remove(path.getNode(i));
            } else {
                shortCount.put(path.getNode(i), value);
            }
        } else {
            value.put(edge, num);
            shortCount.put(path.getNode(i), value);
        }
        value = shortCount.get(path.getNode(i + 1));
        edge = new Edge(path.getNode(i), 1);
        num = value.get(edge);
        num--;
        if (num == 0) {
            value.remove(edge);
            if (value.size() == 0) {
                shortCount.remove(path.getNode(i + 1));
            } else {
                shortCount.put(path.getNode(i + 1), value);
            }
        } else {
            value.put(edge, num);
            shortCount.put(path.getNode(i + 1), value);
        }
    }
    return shortCount;
}

　　在后面的三种情况中，因为涉及到了不同路径之间的换乘，所以按照之前的方法构建邻接表是不可取的。我们尝试构建一种新的、重构的图，将一条路径之间任意两点的都建立一条路径，那么在重构的图中，两个点之间有几条路径，就可以表示换乘了几次，我们开可以通过给重构的图的边赋不同的值，来最终得到我们想要的结果。

b. transferCount

　　为了计算换乘次数，需要将同一条路径之间任意两点之间都构建一条路径，所以要用两重循环，每两点之间的权重仍为1。换乘的次数即为求出的最短路径减1。

　　e.g.对于路径1 2 3和路径4 2 5

　　

　　1到3换乘1-1=0次

　　1到5换乘2-1=1次

public HashMap<Integer, HashMap<Edge, Integer>>
    addTransfer(Path path) {
    for (int i = 0; i < path.size() - 1; i++) {
        for (int j = i + 1; j < path.size(); j++) {
            if (transferCount.containsKey(path.getNode(i))) {
                HashMap<Edge, Integer> value
                    = transferCount.get(path.getNode(i));
                Edge edge = new Edge(path.getNode(j), 1);
                if (value.containsKey(edge)) {
                    int num = value.get(edge);
                    num++;
                    value.put(edge, num);
                } else {
                    value.put(edge, 1);
                }
                transferCount.put(path.getNode(i), value);
            } else {
                HashMap<Edge, Integer> value = new HashMap<>();
                Edge edge = new Edge(path.getNode(j), 1);
                value.put(edge, 1);
                transferCount.put(path.getNode(i), value);
            }
            if (transferCount.containsKey(path.getNode(j))) {
                HashMap<Edge, Integer> value
                    = transferCount.get(path.getNode(j));
                Edge edge = new Edge(path.getNode(i), 1);
                if (value.containsKey(edge)) {
                    int num = value.get(edge);
                    num++;
                    value.put(edge, num);
                } else {
                    value.put(edge, 1);
                }
                transferCount.put(path.getNode(j), value);
            } else {
                HashMap<Edge, Integer> value = new HashMap<>();
                Edge edge = new Edge(path.getNode(i), 1);
                value.put(edge, 1);
                transferCount.put(path.getNode(j), value);
            }
        }
    }
    return transferCount;
}

　　(remove同理)

　　在后两种邻接表的构建过程中仍然仿照transfer方法，但是对weight需要有新的计算方法，这里采用floyd算法。price的边权为1，value的边权为F(fromNodeId，toNodeId)(F定义如下)，switching为开关，true为price，false为value。

private int[] aa = {1, 4, 16, 64, 256};
private int F(int x, int y) {
    return aa[Math.max(((x % 5 + 5) % 5), ((y % 5 + 5) % 5))];
}

private void flord(Path path, boolean switching) {
    HashMap<Integer, Integer> hashMap = new HashMap<>();
    int n = 0;
    int max = 120;
    int[][] matrix = new int[max][max];
    for (int i = 0; i < max; i++) {
        for (int j = 0; j < max; j++) {
            if (i == j) {
                matrix[i][j] = 0;
            } else {
                matrix[i][j] = 1000000;
            }
        }
    }
    for (int i = 0; i < path.size() - 1; i++) {
        if (!hashMap.containsKey(path.getNode(i))) {
            hashMap.put(path.getNode(i), n);
            n++;
        }
        if (!hashMap.containsKey(path.getNode(i + 1))) {
            hashMap.put(path.getNode(i + 1), n);
            n++;
        }
        if (path.getNode(i) == path.getNode(i + 1)) {
            matrix[hashMap.get(path.getNode(i))]
                [hashMap.get(path.getNode(i + 1))] = 0;
        } else {
            if (switching) {
                matrix[hashMap.get(path.getNode(i))]
                    [hashMap.get(path.getNode(i + 1))] = 1;
                matrix[hashMap.get(path.getNode(i + 1))]
                    [hashMap.get(path.getNode(i))] = 1;
            } else {
                matrix[hashMap.get(path.getNode(i))]
                    [hashMap.get(path.getNode(i + 1))]
                    = F(path.getNode(i), path.getNode(i + 1));
                matrix[hashMap.get(path.getNode(i + 1))]
                    [hashMap.get(path.getNode(i))]
                    = F(path.getNode(i), path.getNode(i + 1));
            }
        }      
    }
    for (int k = 0; k < max; k++) {
        for (int i = 0; i < max; i++) {
            for (int j = 0; j < max; j++) {
                if (matrix[i][k] + matrix[k][j] < matrix[i][j]) {
                    matrix[i][j] = matrix[i][k] + matrix[k][j];
                }
            }
        }
    }
    if (switching) {
        priceMatrix = matrix;
        priceMap = hashMap;
    } else {
        valueMatrix = matrix;
        valueMap = hashMap;
    }
}

　　计算出的两两之间的权值保存在matrix中，因为nodeId并不是按照从零开始递增的，但是为了利用二维数组，需要建立一个映射表，存在hashMap中。因为在删除边是还要利用映射关系和权值，所以matrix和hashMap需要分别保存在HashMap<Path, int[][]>和HashMap<Path, HashMap<Integer, Integer>>中。

c. priceCount

　　计算出一条路径中任意两点之间的权重后，构建邻接表就比较简单了。边权为一条path内最短路径加2，票价为最终求出的最短路径减2

　　e.g.对于路径1 2 3和路径4 2 5

　　1到2的边权为1+2=3，票价为3-2=1

　　1到3的边权为2+2=4，票价为4-2=2

　　1到5的票价为3+3-2=4

　　相对于transfer，有改动的地方是 Edge edge = new Edge(path.getNode(j), 2 + priceMatrix[priceMap.get(path.getNode(i))][priceMap.get(path.getNode(j))]);

d. valueCout

　　计算出一条路径中任意两点之间的权重后，构建邻接表就比较简单了。边权为一条path内最短路径加32，票价为最终求出的最短路径减32

　　e.g.对于路径1 2 3和路径4 2 5

　　1到2的边权为16+32=48，不满意度为48-32=16

　　1到3的边权为16+64+32=112，票价为112-32=80

　　1到5的票价为48+48-32=64

　　相对于transfer，有改动的地方是 Edge edge = new Edge(path.getNode(j), 32 + valueMatrix[valueMap.get(path.getNode(i))][valueMap.get(path.getNode(j))]);

　　

　　add和remove

public int addPath(Path path) {
    if (path != null && path.isValid()) {
        if (pidList.containsKey(path)) {
            return pidList.get(path);
        }
        id++;
        pathList.put(id, path);
        pidList.put(path, id);
        shortCount = addShort(path);
        transferCount = addTransfer(path);
        priceCount = addPrice(path);
        priceMatrixPath.put(path, priceMatrix);
        priceMapPath.put(path, priceMap);
        valueCount = addRemove.addValue(path);
        valueMatrixPath.put(path, valueMatrix);
        valueMapPath.put(path, valueMap);
        shorrt = new HashMap<>();
        transfer = new HashMap<>();
        price = new HashMap<>();
        value = new HashMap<>();
        block = connectedBlock();
        return id;
    } else {
        return 0;
    }
}

public int removePath(Path path) throws PathNotFoundException {
    if (path == null || !path.isValid() || !pidList.containsKey(path)) {
        throw new PathNotFoundException(path);
    } else {
        shortCount = addRemove.removeShort(path);
        transferCount = addRemove.removeTransfer(path);
        priceCount = addRemove.removePrice(path);
        valueCount = addRemove.removeValue(path);
        int pathId = pidList.get(path);
        pidList.remove(path);
        pathList.remove(pathId);
        shorrt = new HashMap<>();
        transfer = new HashMap<>();
        price = new HashMap<>();
        value = new HashMap<>();
        block = connectedBlock();
        return pathId;
    }
}

　　（removePathById同理）

　　注意到有一句是 block = connectedBlock()，connectBlock是计算连通块个数的，在遍历所有点的基础上调用了几次Dijkstra算法，便有几个连通块，并将结果保存在cache中。因为连通块的个数在add和remove之后会变动，并且不能利用缓存中的信息，所以在结构变更指令后直接计算connectBlock的个数，并将结果保存在cache中。

　　事实上用四种算法都可以计算连通块的个数，但是在我的程序中isConnect也是用short来算的，这样short的cache命中率会大大增加。

　　查询

　　在查询时先查cache，若cache命中则直接输出结果，若未命中再用dijkstra算法算出结果，保存在cache中并输出结果。(shorrt即为cache)

public int getShortestPathLength(int fromNodeId, int toNodeId)
    throws NodeIdNotFoundException, NodeNotConnectedException {
    if (!shortCount.containsKey(fromNodeId)) {
        throw new NodeIdNotFoundException(fromNodeId);
    } else if (!shortCount.containsKey(toNodeId)) {
        throw new NodeIdNotFoundException(toNodeId);
    } else if (!isConnected(fromNodeId, toNodeId)) {
        throw new NodeNotConnectedException(fromNodeId, toNodeId);
    } else {
        Connect connect = new Connect(fromNodeId, toNodeId);
        if (shorrt.containsKey(connect)) {
            return shorrt.get(connect);
        } else {
            dis = dijkstra(fromNodeId);
            Iterator<Integer> iterator = dis.keySet().iterator();
            while (iterator.hasNext()) {
                int a = iterator.next();
                shorrt.put(new Connect(fromNodeId, a), dis.get(a));
            }
            return shorrt.get(connect);
        }
    }
}

　　Dijkstra

　　最后贴上我的dijkstra算法。

public HashMap<Integer, Integer> dijkstra(int s) {
    HashMap<Integer, Integer> visit = new HashMap<>();
    HashMap<Integer, Integer> dis = new HashMap<>();
    Iterator<Integer> iterator = shortCount.keySet().iterator();
    while (iterator.hasNext()) {
        int key = iterator.next();
        dis.put(key, 1000000);
        visit.put(key, 0);
    }
    Queue<Edge> queue = new PriorityQueue<>();
    queue.add(new Edge(s, 0));
    dis.put(s, 0);
    while (!queue.isEmpty()) {
        Edge now = queue.poll();
        if (dis.get(now.getTo()) < now.getWeight()) {
            continue;
        }
        if (visit.get(now.getTo()) == 1) {
            continue;
        }
        visit.put(now.getTo(), 1);
        Iterator<Edge> i
            = shortCount.get(now.getTo()).keySet().iterator();
        while (i.hasNext()) {
            Edge edge = i.next();
            if (visit.get(edge.getTo()) == 0 && dis.get(edge.getTo())
                > dis.get(now.getTo()) + edge.getWeight()) {
                dis.put(edge.getTo(),
                    dis.get(now.getTo()) + edge.getWeight());
                queue.add(
                    new Edge(edge.getTo(), dis.get(edge.getTo())));
            }
        }
    }
    return dis;
}