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--;
            }
        }
    }
}

原文地址:https://www.cnblogs.com/zzlback/p/8469508.html

时间: 2024-10-11 13:31:36

java暴力递归回溯算法的相关文章

Java数据结构之回溯算法的递归应用迷宫的路径问题

一.简介 回溯法的基本思想是:对一个包括有很多结点,每个结点有若干个搜索分支的问题,把原问题分解为对若干个子问题求解的算法.当搜索到某个结点.发现无法再继续搜索下去时,就让搜索过程回溯(即退回)到该结点的前一结点,继续搜索这个结点的其他尚未搜索过的分支:如果发现这个结点也无法再继续搜索下去时,就让搜索过程回溯到这个结点的前一结点继续这样的搜索过程:这样的搜索过程一直进行到搜索到问题的解或搜索完了全部可搜索分支没有解存在为止. 该方法可以使用堆栈实现.也可以使用递归实现,递归实现的话代码比较简单,

java 二叉树递归遍历算法

//递归中序遍历 public void inorder() { System.out.print("binaryTree递归中序遍历:"); inorderTraverseRecursion(root); System.out.println(); } //层次遍历 public void layerorder() { System.out.print("binaryTree层次遍历:"); LinkedList<Node<Integer>>

穷举递归和回溯算法终结篇

穷举递归和回溯算法 在一般的递归函数中,如二分查找.反转文件等,在每个决策点只需要调用一个递归(比如在二分查找,在每个节点我们只需要选择递归左子树或者右子树),在这样的递归调用中,递归调用形成了一个线性结构,而算法的性能取决于调用函数的栈深度.比如对于反转文件,调用栈的深度等于文件的大小:再比如二分查找,递归深度为O(nlogn),这两类递归调用都非常高效. 现在考虑子集问题或者全排列问题,在每一个决策点我们不在只是选择一个分支进行递归调用,而是要尝试所有的分支进行递归调用.在每一个决策点有多种

回溯算法解八皇后问题(java版)

八皇后问题是学习回溯算法时不得不提的一个问题,用回溯算法解决该问题逻辑比较简单. 下面用java版的回溯算法来解决八皇后问题. 八皇后问题,是一个古老而著名的问题,是回溯算法的典型案例.该问题是国际西洋棋棋手马克斯·贝瑟尔于1848年提出:在8×8格的国际象棋上摆放八个皇后,使其不能互相攻击,即任意两个皇后都不能处于同一行.同一列或同一斜线上,问有多少种摆法. 思路是按行来规定皇后,第一行放第一个皇后,第二行放第二个,然后通过遍历所有列,来判断下一个皇后能否放在该列.直到所有皇后都放完,或者放哪

回溯0--递归回溯算法框架

递归回溯算法框架 一.心得 3 都是在for下的if下的 4 保存结果,找下一步,回溯,这三个是一起的 5 还有一个到达目的地输出解放在外面就好 search后面的k是轮数  三个数组:原数据数组标记数组储存结果数组 框架二 到目的地的情况要多加1,因为满足了的下一轮就好判断 二.代码 1 /* 2 递归回溯算法框架: 3 都是在for下的if下的 4 保存结果,找下一步,回溯,这三个是一起的 5 还有一个到达目的地输出解放在外面就好 6 */ 7 /* 8 框架一 9 */ 10 int se

【八皇后问题】 回溯算法

回溯算法:回溯算法实际上是一个类似枚举的搜索尝试方法,它的思想是在搜索尝试中寻找问题的解,当发现不满足求解条件时,就“回溯”返回,尝试别的路径.之前介绍的基础算法中的贪婪算法,动态规划等都具有“无后效性”,也就是在分段处理问题时,某状态一旦确定,将不再改变.而多数问题很难找到"无后效性”的阶段划分和相应决策,而是通过深入搜索尝试和回溯操作完成的. 八皇后问题:8*8的国际象棋棋盘中放八个皇后,是任意两个皇后不能互相吃掉.规则:皇后能吃掉同一行,同一列,同一对角线的任意棋子. 模型建立:不妨设八个

8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,循环控制及其优化

上两篇博客 8皇后以及N皇后算法探究,回溯算法的JAVA实现,递归方案 8皇后以及N皇后算法探究,回溯算法的JAVA实现,非递归,数据结构“栈”实现 研究了递归方法实现回溯,解决N皇后问题,下面我们来探讨一下非递归方案 实验结果令人还是有些失望,原来非递归方案的性能并不比递归方案性能高 代码如下: package com.newflypig.eightqueen; import java.util.Date; /** * 使用循环控制来实现回溯,解决N皇后 * @author [email pr

c语言数据结构:递归的替代-------回溯算法

1.要理解回溯就必须清楚递归的定义和过程. 递归算法的非递归形式可采用回溯算法.主要考虑的问题在于: 怎样算完整的一轮操作. 执行的操作过程中怎样保存当前的状态以确保以后回溯访问. 怎样返回至上一次未执行的操作. 2.贴代码表现: 先序遍历二叉树: BTNode *FindNode(BTNode *b,ElementType x) { //在二叉树中查找值为x的结点 BTNode *p; if (b==NULL) return NULL; else if (b->Element==x) retu

谈谈递归和回溯算法的运用

递归和回溯算法的运用 题目描述 有n个士兵站成一列,从第1个士兵前面向后望去,刚好能看到m个士兵,如果站在后面的士兵身高小于或者等于前面某个士兵的身高,那么后面的这个士兵就不能被看到,问这n个士兵有多少种排列方式,刚好在观测位能看到m个士兵? 第一行输入 n 个士兵和 m 个可以看到的士兵(n >= m),第二行输入 n 个士兵的身高,输出为排列方式的种数. 输入: 4 3 1 1 2 3 输出: 6 也就是说,输入数 n, m (n < m),然后输入 n 个正整数到一个数组 a 中,a 数