蓝桥杯 Day13 java组 剪枝

最新推荐文章于 2024-08-19 20:00:00 发布
最新推荐文章于 2024-08-19 20:00:00 发布
阅读量357 收藏 4
点赞数 2
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 java 剪枝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46274219/article/details/122909267
版权

暴力法往往比较低效，把时间浪费在很多不必要的计算上。

剪枝是一个比喻：把不会产生答案的，或不必要的枝条“剪掉”。而剪枝的关键在于剪枝的判断：剪什么枝、在哪里减。剪枝是搜索常用的优化手段，常常能把指数级的复杂度，优化到近似多项式的复杂度。

  • BFS的主要剪枝技术是判重，如果搜索到某一层时，出现重复的状态，就剪枝。
  • DFS的剪枝技术较多，有可行性剪枝、最优性剪枝、搜索顺序剪枝、排除等效冗余、记忆化搜索等等：

  1. 可行性剪枝：对当前状态进行检查，如果当前条件不合法就不再继续，直接返回
  2. 搜索顺序剪枝：搜索树有多个层次和分支，不同的搜索顺序会产生不同的搜索树形态，复杂度也相差很大。
  3. 最优性剪枝：在最优化问题的搜索过程中，如果当前花费的代价已超过前面搜索到的最优解，那么本次搜索已经没有继续进行下去的意义，此时停止对当前分支的搜索进行回溯。
  4. 排除等效冗余：搜索的不同分支，最后的结果是一样的，那么只搜一个分支就够了。
  5. 记忆化搜索：在递归的过程中，有许多分支被反复计算，会大大降低算法的执行效率。用记忆化搜索，将已经计算出来的结果保存起来，以后需要用到的时候直接取出结果，避免重复运算，从而提高了算法的效率。记忆化搜索一般在DP中。

第一题 四平方和

样例输入

12

样例输出

0 2 2 2

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int i = 0, j = 0, k = 0, l = 0;
        int x = scanner.nextInt();
        for (i = 0; x >= i * i; i++) {
            for (j = i; x >= i * i + j * j; j++) {
                for (k = j; x >= i * i + j * j + k * k; k++) {
                    for (l = k; x >= i * i + j * j + k * k + l * l; l++) {
                        if (i * i + j * j + k * k + l * l == x) {
                            System.out.println(i + " " + j + " " + k + " " + l);
                            return;
                        }
                    }
                }
            }
        }
    }
}

第二题 剪格子

输出描述

在所有解中，包含左上角的分割区可能包含的最小的格子数目。

样例输入

3 3
10 1 52
20 30 1
1 2 3

样例输出

3
import java.util.Scanner;

public class Main {
    public static int[][] map;
    public static int[][] visited;
    public static int m;
    public static int n;
    public static int sum = 0;
    public static int min = 999999;
    public static int[][] direction = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        m = scanner.nextInt();
        n = scanner.nextInt();
        map = new int[1000][1000];
        visited = new int[1000][1000];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                map[i][j] = scanner.nextInt();
                visited[i][j] = 0;
                sum = sum + map[i][j];
            }
        }
        dfs(0, 0, 0, 1);
        System.out.println(min);
    }

    public static void dfs(int x, int y, int temp, int k) {
        temp = temp + map[x][y];
        if (temp * 2 > sum) {
            return;
        }

        if (temp * 2 == sum) {
            if (k < min) {
                min = k;
            }
            return;
        }
        visited[x][y] = 1;
        for (int i = 0; i < direction.length; i++) {
            int x1 = x + direction[i][0];
            int y1 = y + direction[i][1];
            if (x1 >= m || y1 >= n) {
                continue;
            }
            if (x1 >= 0 && x1 < n && y1 >= 0 && y1 < m && visited[x1][y1] == 0) {
                dfs(x1, y1, temp, k+1);
            }
        }
        visited[x][y] = 0;
    }
}

写的贼慢，太菜了。 

第三题 路径之谜

样例输入

4
2 4 3 4
4 3 3 3

样例输出

0 4 5 1 2 3 7 11 10 9 13 14 15

import java.util.Scanner;
import java.util.Stack;

public class Main {
    private static int n = 0;
    private static int[] north;
    private static int[] west;
    private static int[][] map;
    private static int[][] direction = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};
    private static int[][] visited;
    private static Stack<Node> stack = new Stack<Node>();
    private static int temp = 0;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        north = new int[n];
        west = new int[n];
        map = new int[n][n];
        visited = new int[n][n];
        for (int i = 0; i < n; i++) {
            north[i] = scanner.nextInt();
        }
        for (int i = 0; i < n; i++) {
            west[i] = scanner.nextInt();
        }
        int temp = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                map[i][j] = temp;
                visited[i][j] = 0;
                temp++;
            }
        }
        dfs(0, 0);
    }

    private static void dfs(int x, int y) {
        west[x]--;
        north[y]--;
        visited[x][y] = 1;
        int flag = 0;
        if (temp == 1) {
            return;
        }
        if (west[x] < 0 || north[y] < 0) {
            west[x]++;
            north[y]++;
            visited[x][y] = 0;
            return;
        }
        if (x == n - 1 && y == n - 1) {
            for (int i = 0; i < n; i++) {
                if (west[i] != 0 || north[i] != 0) {
                    flag = 1;
                    break;
                }
            }
            if (flag != 1) {
                temp = 1;
                Node node = new Node(x, y, map[x][y]);
                stack.push(node);
                int[] a = new int[stack.size()];
                for (int i = stack.size() - 1; !stack.isEmpty(); i--) {
                    a[i] = stack.pop().value;
                }
                for (int i = 0; i < a.length; i++) {
                    System.out.print(a[i] + " ");
                }
                return;
            }
        }
        Node node = new Node(x, y, map[x][y]);
        stack.push(node);
        for (int i = 0; i < direction.length; i++) {
            int nx = x + direction[i][0];
            int ny = y + direction[i][1];
            if (nx >= 0 && nx < n && ny >= 0 && ny < n && visited[nx][ny] == 0) {
                dfs(nx, ny);
            }
        }
        if (!stack.isEmpty()) {
            stack.pop();
        }
        visited[x][y] = 0;
        west[x]++;
        north[y]++;
    }
}

class Node {
    int x;
    int y;
    int value;

    Node(int x, int y, int value) {
        this.x = x;
        this.y = y;
        this.value = value;
    }
}

剪枝前深搜722次  剪枝后深搜54次 

第四题 分考场 

样例输入

5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5

样例输出

import java.util.*;

public class Main {
    private static int n;
    private static int m;
    private static int ans = 10000;
    private static int[][] relation;
    private static Map<Integer, List<Integer>> map = new HashMap<>();

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        relation = new int[n + 1][n + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                relation[i][j] = 0;
            }
        }
        for (int i = 0; i < m; i++) {
            int a1 = scanner.nextInt();
            int a2 = scanner.nextInt();
            relation[a1][a2] = 1;
            relation[a2][a1] = 1;
        }
        List<Integer> list = new ArrayList<>();
        list.add(1);
        map.put(0, list);
        dfs(1);
        System.out.println(ans);
    }

    public static boolean checked(int i, int k) {
        for (int j = 0; j < map.get(i).size(); j++) {
            if (relation[k][map.get(i).get(j)] == 1 || relation[map.get(i).get(j)][k] == 1) {
                return false;
            }
        }
        return true;
    }

    public static void dfs(int k) {
        System.out.println("DFS");
        if (k == n + 1) {
            ans = Math.min(ans, map.size());
            return;
        }
        if (map.size() >= ans) {
            return;
        }
        for (int i = 0; i < map.size(); i++) {//对每一个考场进行遍历

            if (checked(i, k)) {//对第i个考场进行检查
                map.get(i).add(k);
                dfs(k + 1);
                map.get(i).remove(map.get(i).size() - 1);//将集合最后的元素移除
            }

            /*int flag = 0;
            List<Integer> list = map.get(i);

            for (int j = 0; j < list.size(); j++) {//对每一个考场中的每个人进行遍历
                int temp = list.get(j);
                if (relation[k][temp] == 1 || relation[temp][k] == 1) {//有关系
                    flag = 1;
                    break;
                }
            }

            if (flag == 0) {
                list.add(k);//第i个考场里没有任何一个人和k有关系,将k加入到第i号考场
                dfs(k + 1);
                list.remove(list.size() - 1);
                break;//对每个考场的遍历可以结束了
            }

            if (i == map.size()) {//到了最后一次循环 则创建新的考场
                List<Integer> list1 = new ArrayList<>();
                list1.add(k);//将第k个学生加入集合
                map.put(map.size(), list1);//将新创建的考场加入到考场里
                dfs(k + 1);
                map.remove(map.size() - 1);
            }*/
        }

        List<Integer> list = new ArrayList<>();
        list.add(k);
        map.put(map.size(), list);
        dfs(k + 1);
        map.remove(map.size() - 1);

    }

}

纯纯的鬼物题

对于第k个学生来说，即使能加入到某个教室里，也要在每个dfs（）的最后。为他新建一个考场去尝试。想明白这一点就很容易写。

第五题 四阶幻方 

  1  2 15 16
 12 14  3  5
 13  7 10  4
  8 11  6  9

以及：

  1 12 13  8
  2 14  7 11
 15  3 10  6
 16  5  4  9

就可以算为两种不同的方案。

public class Main {
    private static int[][] map;
    private static int count = 0;
    private static int[] a = {9999, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};

    public static void main(String[] args) {
        map = new int[5][5];
        for (int i = 0; i < 5; i++) {
            for (int j = 0; j < 5; j++) {
                map[i][j] = 0;
            }
        }
        map[1][1] = 1;
        dfs(2, 16);
        System.out.println(count);
    }

    private static void dfs(int s, int t) {
        //System.out.println("DFS");
        if (s == 5 && map[1][1] + map[1][2] + map[1][3] + map[1][4] != 34) {
            //System.out.println(map[1][1] + " " + map[1][2] + " " + map[1][3] + " " + map[1][4]);
            return;
        }
        if (map[1][1] + map[1][2] + map[1][3] + map[1][4] == 34) {
            //System.out.println(map[1][1] + " " + map[1][2] + " " + map[1][3] + " " + map[1][4]);
        }
        if (s == 9 && map[2][1] + map[2][2] + map[2][3] + map[2][4] != 34) {
            return;
        }
        if (s == 13 && map[3][1] + map[3][2] + map[3][3] + map[3][4] != 34) {
            return;
        }
        if (s == 14 && map[1][1] + map[2][1] + map[3][1] + map[4][1] != 34) {
            return;
        }
        if (s == 14 && map[1][4] + map[2][3] + map[3][2] + map[4][1] != 34) {
            return;
        }
        if (s == 15 && map[1][2] + map[2][2] + map[3][2] + map[4][2] != 34) {
            return;
        }
        if (s == 16 && map[1][3] + map[2][3] + map[3][3] + map[4][3] != 34) {
            return;
        }
        if (s == 17 && map[1][4] + map[2][4] + map[3][4] + map[4][4] == 34 && map[1][1] + map[2][2] + map[3][3] + map[4][4] == 34 && map[4][1] + map[4][2] + map[4][3] + map[4][4] == 34) {
            count++;
            return;
        }

        for (int i = s; i <= t; i++) {
            swap(i, s);
            for (int j = 2; j <= 16; j++) {
                if (j % 4 != 0) {
                    map[j / 4 + 1][j % 4] = a[j];//赋值
                } else {
                    map[j / 4][4] = a[j];
                }
            }
            dfs(s + 1, t);
            swap(s, i);
        }
    }

    private static void swap(int i, int s) {
        int temp;
        temp = a[i];
        a[i] = a[s];
        a[s] = temp;
    }
}

 答案为416种 对16个数进行全排列  跑的很慢 不知道是不是哪块的剪枝出了问题

nefu_zth
关注
专栏目录
Java:实现剪枝算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-28 341
Java:实现剪枝算法（附完整源码）
剪枝算法的实现（Java）
ByteWhisper的博客
09-04 253
然后，我们判断剪枝条件：如果一个节点的左右子节点都是叶子节点，并且它们的值相同，那么我们认为可以对该节点进行剪枝。然而，这个示例代码可以帮助您理解剪枝算法的基本原理和实现方式，并为您提供一个起点，以便根据自己的需求进行进一步的扩展和优化。在这里，我们使用一个简单的剪枝条件：如果一个节点的左右子节点都是叶子节点，并且它们的值相同，则可以将该节点剪枝。在本文中，我们将使用Java语言来实现一个简单的剪枝算法，并提供相应的源代码。剪枝后的决策树将不再包含满足剪枝条件的节点及其子节点，从而减少了决策树的大小。
Java - 剪枝算法介绍、应用场景和示例代码
最新发布
a_beiyo的博客
08-19 696
剪枝算法（Pruning Algorithm）是计算机科学中一种优化算法，主要用于减少搜索空间以提高效率。它通过在某些条件下提前终止无效或不必要的计算来加快问题的求解过程。剪枝算法常用于解决组合优化问题，如博弈树搜索、约束满足问题和路径规划等。剪枝算法通过排除一些不可能产生最优解的分支，来降低计算复杂度。Alpha-Beta剪枝：主要用于博弈树的搜索中，可以减少搜索的节点数量。分支限界法：常用于解决整数规划问题和组合优化问题。迭代加深搜索与深度限制搜索结合的剪枝：用于图搜索和路径规划。
介绍java中的剪枝搜索
LJH_java10086的博客
11-04 828
剪枝搜索是一种常见的搜索优化技术，它可以大大减少搜索的时间和空间复杂度，从而提高搜索效率。Java中的剪枝搜索通常是在回溯、深度优先搜索、广度优先搜索等算法中运用的。剪枝搜索是通过排除明显不符合要求的搜索结果来减少搜索的数量，从而达到优化搜索的目的。在搜索过程中，判断某个结果是否符合要求是很关键的一步。如果能够通过一些方法在搜索过程中排除掉不符合要求的结果，就可以减少搜索的数量，提高搜索效率。
（Java）寻路问题之练习剪枝
重庆科技学院XMY的博客
04-01 353
package 蓝桥杯; import java.util.ArrayList; import java.util.Scanner; import java.util.Vector; public class VO深搜_寻路问题 { static int K,N,R;//钱数<10000，城市数<100，道路数<10000 //我们需要一个邻接表来存放道路信息 st...
2023第十四届蓝桥杯Java B组个人题解
热门推荐
小宇的修炼之路
04-08 1万+
本文是2023年第十四届蓝桥杯Java B组个人题解，有详细的思路分析和Java代码实现，期待和大家一起交流！
第十五届蓝桥杯java b组
04-14
### 第十五届蓝桥杯Java B组知识点解析 #### 一、比赛背景与形式 第十五届蓝桥杯Java B组比赛是一项针对具有一定Java编程基础的学生进行的技术竞赛。该比赛旨在通过一系列精心设计的编程挑战，全面评估参赛者在...
2018年第九届蓝桥杯省赛Java A组真题解析（带源码）
weixin_51840839的博客
04-05 1230
第一题：分数题目描述 1/1 + 1/2 + 1/4 + 1/8 + 1/16 + … 每项是前一项的一半，如果一共有20项, 求这个和是多少，结果用分数表示出来。 类似： 3/2 当然，这只是加了前2项而已。分子分母要求互质。 注意： 需要提交的是已经约分过的分数，中间任何位置不能含有空格。 请不要填写任何多余的文字或符号。 分析：数学问题，将所有分数都化为成第20项的分母，然后所有分子相加，最后分子和分母化简，输出最后化简的分子和分母即可 package A组2018年; //答案1048575
FiveChess1.5.rar_五子棋java剪枝_剪枝
09-24
《五子棋Java剪枝算法详解与应用》 在计算机科学领域，特别是在人工智能与游戏编程中，五子棋是一款常见的研究对象。本项目"FiveChess1.5.rar"是一个基于Java实现的五子棋游戏，它引入了剪枝算法以提高AI的智能水平...
2014年第五届蓝桥杯大赛软件类JAVA-A组全国总决赛真题.doc
05-09
在2014年第五届蓝桥杯大赛软件类JAVA-A组全国总决赛中，出现了一道名为“海盗分金币”的题目。题目背景设定为五位海盗在一次帆船比赛中遭遇天气突变，各自在途中的一座荒岛上发现了金币，并按照特定的方式分配。 ##...
阿尔法贝塔剪枝算法Java五子棋
03-16
阿尔法贝塔剪枝算法五子棋，人工智能课程，Java代码，可直接运行
Java实现 LeetCode 814 二叉树剪枝 （遍历树）
12-20
814. 二叉树剪枝 给定二叉树根结点 root ，此外树的每个结点的值要么是 0，要么是 1。 返回移除了所有不包含 1 的子树的原二叉树。 ( 节点 X 的子树为 X 本身，以及所有 X 的后代。) 示例1: 输入: [1,null,0,0,1] 输出: [1,null,0,null,1] 解释: 只有红色节点满足条件“所有不包含 1 的子树”。 右图为返回的答案。 原创文章 1949获赞 3万+访问量 702万+ 关注
669. 修剪二叉搜索树
尚未佩妥剑 转眼便江湖
11-09 850
给你二叉搜索树的根节点 root ，同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树，使得所有节点的值在[low,high]中。修剪树不应该改变保留在树中的元素的相对结构（即，如果没有被移除，原有的父代子代关系都应当保留）。 可以证明，存在唯一的答案。 所以结果应当返回修剪好的二叉搜索树的新的根节点。注意，根节点可能会根据给定的边界发生改变。 输入：root = [1,0,2], low = 1, high = 2 输出：[1,null,2] 输入：root = [3,0,4,nu.
组合 - Java - 回溯 + 剪枝
jike11231的博客
07-28 962
给定两个整数n和k，返回1…n中所有可能的k个数的组合。示例输入输出[[2,4],[3,4],[2,3],[1,2],[1,3],[1,4],]
二叉树剪枝java实现
guiguchunqiu的博客
11-21 1098
/** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode() {} * TreeNode(int val) { this.val = val; } * TreeNode(int val, TreeNode left, TreeNode right) { *
实现剪枝算法的Java代码
CyberSparkZ的博客
08-13 136
总结起来，剪枝算法是一种有效的优化技术，能够通过减少冗余计算来提高程序的执行效率。通过合理设置剪枝条件，我们可以在搜索问题和其他领域中应用剪枝算法，从而提升算法的性能。剪枝算法是一种用于优化搜索空间的技术，它可以通过减少冗余的计算来提高程序的执行效率。在本文中，我们将使用Java编写一个简单的剪枝算法，并给出相应的源代码。在每一步搜索中，我们根据当前的最大值与数组中的下一个元素进行比较，如果已经存在更大的值，则剪枝并返回。使用剪枝算法可以减少不必要的搜索，提高程序的执行效率。方法来查找给定数组中的最大值。
leetcode814. 二叉树剪枝(java)
SP_1024的博客
06-23 466
递归完成后，当这三个条件：左子树为空，右子树为空，当前节点的值为 0，同时满足时，才表示以当前节点为根的原二叉树的所有节点都为 0，需要将这棵子树移除，返回空。输入：root = [1,1,0,1,1,0,1,0]输入：root = [1,0,1,0,0,0,1]输入：root = [1,null,0,0,1]返回移除了所有不包含 1 的子树的原二叉树。输出：[1,1,0,1,1,null,1]输出：[1,null,0,null,1]输出：[1,null,1,null,1]来源：力扣（LeetCode）
二叉树剪枝(Java)
looshen的博客
12-06 453
给定二叉树根结点?root?，此外树的每个结点的值要么是 0，要么是 1。 返回移除了所有不包含 1 的子树的原二叉树。 (节点 X 的子树为 X 本身，以及所有 X 的后代。) 示例1: 输入: [1,null,0,0,1] 输出: [1,null,0,null,1] 1 \ 0 / \ 0 1 输出后树为： 1 \ 0 \...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值