java暴力递归回溯算法

今天这个问题是我之前一直想解决的，还记得以前第一次上蓝桥杯的课的时候，也就是大一高数期中模拟考试那天，下午去上蓝桥杯课，遇到这道题，当时写了写，根本没有思路，然后就给大一的模拟考试去了。印象深刻啊，一直没写出来。先来说一下题目吧。

1.问题描述:
　　　　如下图所示的数字三角形，编写一个程序计算从顶部到底部某一处的一条路径，使得该路径数字和最大，输出路径和最大值。

　　　　　　　　7

　　　　　　　3      8

　　　　　　8      1      0

　　　　　2      7      4      4

　　　　4      5      2      6      5

　　　　当然什么是路径，路径就是能连着，但是不能跳过，比如7-3-8-7-2就是一条路径。

2.输入:

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

3.输出:

　　路径:7-3-8-7-5，最大值:30

4.算法思想: 这道题啊，其实和马走日思想很像，首先从0,0这个位置出发，一直走遍整个棋盘(把整体看做一个棋盘)

　　　　　　7

　　　　　　3     8

　　　　　　8     1     0

　　　　　　2     7     4     4

　　　　　　4     5     2     6     5

棋盘挪过来成这样的形状。我输入放在qipan[][]数组中，然后用一个临时数组temp[][]和棋盘大小一样，把这个临时数组全部初始化为0，走一步把这个数组更新为1(想象成马走日) 全部走到底，则遍历temp[][]数组，如果temp[][]不为0，即有走的，那么就输出棋盘上面对应的棋盘数字。分别用变量sum，和maxv来记录最大值，当为最大值时要保存走的状态，即输出走的最大值是哪步。最后我是用一个HashMap来保存所有的取值情况，在主函数中，如果hashmap的值 = maxv，则输出，最后得到结果。这种暴力解决方法是在数据量不多的情况下好解决，可是数据量多，就用动态规划来解决。

5.代码示例:

package com.zzl.zt;

/*
 * 7
 * 3 8
 * 8 1 0
 * 2 7 4 4
 * 4 5 2 6 5
 */
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Scanner;

public class RouteTest {
    static int qipan[][] = new int[20][20];
    static int temp[][] = new int[20][20];
    static int weizhi[][] = {{1,0},{1,1}}; // 只能向下走，或者向右下走
    static int step = 1;
    static int sum = 0;
    static int maxv = 0;
    static Map<StringBuffer, Integer> map = new HashMap<StringBuffer, Integer>();
    

    public static void main(String[] args) {
        Scanner scn = new Scanner(System.in);
        System.out.println("请输入共有多少行并输入数据:");
        int n = scn.nextInt(); //总共的行数
        for(int i=0;i<n;i++){
            for(int j=0;j<=i;j++){
                qipan[i][j] = scn.nextInt();
                temp[i][j] = 0;
            }
        }
        temp[0][0] = step;
        step++;
        move(0,0,n); //把n行数传进去，要不然不知道行数
        
        //遍历Map集合，一次输出，作为一个样本即可
        Iterator it = map.entrySet().iterator();  
        while (it.hasNext()) {  
            Entry entry = (Entry) it.next();  
            if(entry.getValue() == Integer.valueOf(maxv)){
                System.out.println(entry.getKey() + "最大值:" + entry.getValue());  
            }
        }  
    }
    public static void move(int x, int y, int n) {
        int next_x = 0;
        int next_y = 0;
        if(step>n){  //递归到了底部
            sum = 0;
            StringBuffer sb = new StringBuffer();
            sb.append("路径:");
            for(int i=0;i<n;i++){
                for(int j=0;j<=i;j++){
                    if(temp[i][j] !=0){  //也就是说有走过了
                        //这就是一个输出表示形式
                        if(i==n-1){
                            sb.append(qipan[i][j] + ",");
                        }else{
                            sb.append(qipan[i][j] + "-");
                        }
                        //计算这一趟sum的总值
                        sum = sum+qipan[i][j];
                    }
                }
            }
            //判断sum是否更大，更大则更新数据
            if(sum>maxv){
                maxv = sum;
            }
            map.put(sb, sum);
        }else{
            for(int i=0;i<2;i++){ //只有两个位置可以走，并且这两个位置都能走，没有限制条件
                next_x = x+weizhi[i][0];
                next_y = y+weizhi[i][1];
                temp[next_x][next_y] = step;
                step++;
                move(next_x, next_y, n);
                temp[next_x][next_y] = 0;
                step--;
            }
        }
    }
}