动态规划算法

动态规划算法

  有一道算法题, 如下所示, 有一数字矩阵, 从左上走到右下, 只能向下或向右走, 求走到右下角所经过的数字的和的最大值以及经过的路径.

1 2 3 4
5 6 9 8
9 1 0 1
2 3 4 5

  这道题就用到了动态规划算法, 那么什么是动态规划算法呢? 按照某百科的说法, “动态规划算法是通过拆分问题，定义问题状态和状态之间的关系，使得问题能够以递推（或者说分治）的方式去解决” 感觉是不是云里雾里的, 其实动态规划的关键在于”拆分”, 比如这道题, 如何拆分呢?
  由于只能向下或向右, 所以一个点的和的最大值取决于该点左 上两点谁的和更大.
  假设左上是(0,0)点, 右下是(3,3)点, 按照只能向右或向下的原则, 想要得到从(0,0)到(3,3)点的最大值, 就要得到从(0,0)到(2,3)点的和的最大值, 以及从(0,0)到(3,2)点和的最大值, 然后比较(2,3) (3,2)两点中更大的一个和, 加上(3,3)点的5.
  由于(0,0)点的和固定为1, 所以正推, 首先我们能得到第一行到任意一点的最大值, 因为只能往右走, 也能得到第一列任意一点的和的最大值, 因为只能往下走, 有了(0,1)和(1,0)两点最大值, 则可以得出(1,1)点的最大值, 按照此种方法, 可以得到(3,2)和(2,3)各自和的最大值, 最终可以求出到右下的最大值.
  使用程序来求解, (用Java实现, 如下所示)首先定义Node类, 即每个点, 属性x y 代表坐标, value代表该点的值, sum代表该点和的最大值, lastNode代表得到sum最大值所依靠的上个Node节点. 然后从上到下从左到右遍历, 依次得到每个点的最大值, lastNode将得到最大值的整个过程串成一个链表, 遍历完成即可得到(3,3)点的最大值以及路径.

public class DynamicProgrammingAlgorithm {
    static Node[][] nodes = {
            {new Node(1),new Node(2),new Node(3),new Node(4)},
            {new Node(5),new Node(6),new Node(9),new Node(8)},
            {new Node(9),new Node(1),new Node(0),new Node(1)},
            {new Node(2),new Node(3),new Node(4),new Node(5)}                   
    };
    public static void main(String[] args) {
        for (int y = 0; y < nodes.length; y++) {
            for (int x = 0; x < nodes[0].length; x++) {
                Node node = nodes[x][y];
                node.x = x;
                node.y = y;
                if(y == x && y == 0){
                    node.sum = node.value;
                }else {
                    Node lastNode;
                    if(x == 0){
                        lastNode = nodes[0][y - 1];
                    }else if(y == 0){
                        lastNode = nodes[x - 1][0];
                    }else {
                        Node upNode = nodes[x][y - 1];
                        Node leftNode = nodes[x - 1][y];
                        if(upNode.sum >= leftNode.sum){
                            lastNode = upNode;
                        }else {
                            lastNode = leftNode;
                        }
                    }
                    node.sum = lastNode.sum + node.value;
                    node.lastNode = lastNode;
                }
            }
        }
        Node resultNode = nodes[nodes[nodes.length - 1].length - 1][nodes.length - 1];
        System.out.println(resultNode.sum);
        StringBuilder sb = new StringBuilder();

        Node node = resultNode;
        while(node.lastNode != null){
            sb.append("(");
            sb.append(node.x);
            sb.append(",");
            sb.append(node.y);
            sb.append(")<--");
            node = node.lastNode;
        }
        sb.append("(");
        sb.append(node.x);
        sb.append(",");
        sb.append(node.y);
        sb.append(")");
        System.out.println(sb.toString());
    }
}
class Node{
    int x;
    int y;
    public Node(int value) {
        this.value = value;
    }
    int value;
    int sum;
    Node lastNode;
}