一组数中寻找加和最接近某个值的组合 JAVA实现

最新推荐文章于 2024-06-06 18:00:00 发布
最新推荐文章于 2024-06-06 18:00:00 发布
阅读量7.9k 收藏 29
点赞数 17
分类专栏： 数据结构 文章标签： 算法 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizefeng1998/article/details/115397685
版权

一组数中寻找加和最接近某个值的组合 JAVA实现

最近帮人做了一个题，就是在一组数中寻找一个子集合，使得这个子集合的数的加和最接近给定的某个值，此外，这些数的类型是浮点数。我第一想到是用01背包问题去解，但是感觉对于整型数好做，浮点数会难以控制精度。再次我给出三种做法，第一种是暴力做法，第二三中方法都是基于蒙特卡洛算法。

1、暴力法

这个方法的思路是使用深度优先遍历将给定数组的所有子集合给出，在代码中，我们按子集合内数字的个数依次给出，例如对于数组[1,2,3]，我们先给出只有一个数字的子集合[1],[2],[3]，再给出两个的和三个的。

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Random;

public class baoli {
    public ArrayList<ArrayList<Double>> res = new ArrayList<>();

    /**
     *
     * @param input 需要产生排列组合的数组
     * @param weishu 需要产生排列组合的位数
     * @param nowweishu 当前已经完成的位数
     * @param nowres 当前已经装入数组的数字
     * @param num_weishu 需要使用该位数之后的数字
     */
    public void dfs(List<Double> input, int weishu, int nowweishu, ArrayList<Double> nowres, int num_weishu)//用来产生子集合
    {
        if(nowweishu == weishu)
        {
            res.add((ArrayList<Double>) nowres.clone());
            return;
        }
        for(int i = num_weishu + 1;i<input.size();i++)
        {
            nowres.add(input.get(i));
            dfs(input,weishu,nowweishu+1,nowres,i);
            nowres.remove(nowres.size()-1);
        }
    }

    public ArrayList<ArrayList<Double>> print(List<Double> input, int weishu) {
        res = new ArrayList<>();
        ArrayList<Double> nowres= new ArrayList<>();
        dfs(input,weishu,0,nowres,-1);
        return res;
    }



    public ArrayList<Double> sch_emuration(ArrayList<Double> nums,double target)
    {
        double lapse = 10000;
        ArrayList<Double> res = new ArrayList<>();
        for (int i = 1;i<=nums.size();i++)
        {
            ArrayList<ArrayList<Double>> ares = print(nums,i);

            for (int j = 0;j<ares.size();j++)
            {
                double thissum = 0;
                for (int k = 0;k<ares.get(j).size();k++)
                {
                    thissum+=ares.get(j).get(k);
                }
                if (Math.abs(thissum - target)<lapse)
                {
                    res = (ArrayList<Double>) ares.get(j).clone();
                    lapse = Math.abs(thissum - target);
                }
            }
        }

        return res;
    }


    public static void main(String args[]) {
        test t = new test();
        Random r = new Random();
        ArrayList<Double> nums =  new ArrayList<>();
        nums.add(8.05);nums.add(6.98);nums.add(6.19);nums.add(5.0);nums.add(22.96);nums.add(4.71);nums.add(4.74);nums.add(4.25);
        nums.add(6.34);nums.add(2.77);nums.add(7.31);nums.add(3.59);nums.add(19.55);

        ArrayList<Double> res = t.sch_emuration(nums,84.01);
        double sum = 0;
        for (int i=0;i<res.size();i++) {
            System.out.println(res.get(i));
            sum = sum + res.get(i);
        }
        System.out.println(sum);
    }
}

该方法的结果展示：
在这里插入图片描述

2、蒙特卡洛组合法

这个方法使用了随机的思想，每次随机得到一个子集合的数量，再依据这个数量随机选择数组中的数（可以使用HashMap避免重复选择）

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Random;

public class mtkl {
    public ArrayList<Double> MC_combination(ArrayList<Double> nums,double target)
    {
        ArrayList<Double> res = new ArrayList<>();
        double lapse = 10000;
        Random random = new Random();

        for (int i=0;i<1000000;i++)
        {
            if(i%10000==0)
                System.out.println(i);
            int numsize = random.nextInt(nums.size()  + 1);
            ArrayList<Double> ares = new ArrayList<>();
            HashMap<Integer,Integer> map = new HashMap<>();
            double thissum = 0;
            for (int j=0 ;j<numsize;j++)
            {
                int anumberindex = random.nextInt(nums.size());
                while (map.containsKey(anumberindex))
                {
                    anumberindex = random.nextInt(nums.size());
                }
                map.put(anumberindex,1);
                ares.add(nums.get(anumberindex));
                thissum += nums.get(anumberindex);
            }
            if(Math.abs(thissum - target)<lapse)
            {
                lapse = Math.abs(thissum - target);
                res = (ArrayList<Double>) ares.clone();
            }
            if(lapse<0.000001)
                break;
        }
        return res;
    }



    public static void main(String args[]) {
        Random r = new Random();
        ArrayList<Double> nums =  new ArrayList<>();
        nums.add(8.05);nums.add(6.98);nums.add(6.19);nums.add(5.0);nums.add(22.96);nums.add(4.71);nums.add(4.74);nums.add(4.25);
        nums.add(6.34);nums.add(2.77);nums.add(7.31);nums.add(3.59);nums.add(19.55);
        mtkl m = new mtkl();
        ArrayList<Double> res = m.MC_combination(nums,84.01);
        double sum = 0;
        for (int i=0;i<res.size();i++) {
            System.out.println(res.get(i));
            sum = sum + res.get(i);
        }
        System.out.println(sum);
        System.out.println(Math.abs(sum - 84.01));


    }
};

该方法的结果展示：
在这里插入图片描述

3、蒙特卡洛排列法

这个方法也是基于随机算法。该方法的思想是在每次计算前，都对数组进行一次打乱顺序，然后从头加和，直到加和的值大于给定目标值。这个方法没有前两个精度高，而且运算次数大于前两个，因此可以当一个思路。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Random;

public class mtkl2 {
    public ArrayList<Double> MC_permutation(ArrayList<Double> nums,double target)
    {
        ArrayList<Double> res = new ArrayList<>();
        for (int i=0;i<9000000;i++)
        {
            double lapse = 10000;
            ArrayList<Double> newnum = (ArrayList<Double>) nums.clone();
            Collections.shuffle(newnum);
            double lastsum = 0;
            ArrayList<Double> alist = new ArrayList<>();
            for (int j = 0;j< newnum.size();j++)
            {
                double thissum = lastsum + newnum.get(j);
                if(thissum>target)
                {
                    double ds1 = Math.abs(lastsum - target);
                    double ds2 = Math.abs(thissum - target);
                    double ds = Math.min(ds1,ds2);
                    if(ds<lapse)
                    {
                        lapse = ds;
                        if(ds1<ds2)
                        {
                            res = (ArrayList<Double>) alist.clone();
                        }
                        else
                        {
                            alist.add(newnum.get(j));
                            res = (ArrayList<Double>) alist.clone();
                        }
                        break;
                    }
                }
                alist.add(newnum.get(j));
                lastsum = thissum;
            }

            if(lapse<0.00001)
                break;
        }
        return res;
    }

    public static void main(String args[]) {
        ArrayList<Double> nums =  new ArrayList<>();
        nums.add(8.05);nums.add(6.98);nums.add(6.19);nums.add(5.0);nums.add(22.96);nums.add(4.71);nums.add(4.74);nums.add(4.25);
        nums.add(6.34);nums.add(2.77);nums.add(7.31);nums.add(3.59);nums.add(19.55);
        mtkl2 m = new mtkl2();
        ArrayList<Double> res = m.MC_permutation(nums,84.01);
        double sum = 0;
        for (int i=0;i<res.size();i++) {
            System.out.println(res.get(i));
            sum = sum + res.get(i);
        }
        System.out.println(sum);
        System.out.println(Math.abs(sum - 84.01));


    }
}

该方法的结果展示：
在这里插入图片描述

zhaoliwen是猪啊
关注
  • 17
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
java找出和最接近指定值_如何找到数组元素与特定值最接近的和？
weixin_39624700的博客
03-02 1503
小编典典对于这种问题，通常将使用动态编程。但是，本质上可以归结为保留一组可能的总和，然后将输入值一个接一个地添加，如以下代码所示，并且具有相同的渐近运行时间：O(nK)，其中n输入数组的大小和K目标值。但是，以下版本中的常量可能更大，但我认为代码比动态编程版本容易遵循。public class Test {public static void main(String[] args) {int K ...
数组中找出n个数相加，最接近num的
xinpz的博客
11-19 4788
数学问题 -数组中找出n个数相加，最接近num的 有同事提过这个问题，现在有时间了实现下做个整理，主要当时排列组合的概念都不知道是啥了，更不用说实现功能了。 已经不知道排列组合，二项式定理，集合的可以先复习下相关概念和公式算法。 java实现排列组合https://blog.csdn.net/xinpz/article/details/109728624 目录 数学问题 -数组中找出n个数相加，最接近num的 一、概述 问题：数组中找出n个数相加，最接近num的 实现思路： 1...
求解数组中N数之和最接近目标值的算法详解
最新发布
fudaihb的博客
06-06 1528
在算法和数据结构的领域中，找到数组中N个元素的和最接近给定目标值的问题是一项经典而有趣的挑战。本文将详细探讨这一问题的解法，包括其背景、常见的解决思路、具体的实现方法以及一些优化技巧。希望读者能够通过本文的学习，深入理解该问题并掌握相关算法的应用。
在一组数中寻找加和最接近某个值的数组合
xenonhu的博客
02-04 9739
在一组数中寻找加和最接近某个值的数组合 今天碰到个小问题，就是需要在一组数中，找到加和数最接近某个值的一系列数。 比如： [8.05, 6.98, 6.19, 5, 22.96,4.71,4.74,4.25,6.34,2.77,7.31,3.59,18.28,19.55] 中找到最接近84.01的一组数。 这个问题，所有的可能元素的加和组合数为16383，即： Binomial[14, 1] + Binomial[14, 2] + Binomial[14, 3] + Binomial[14, 4] +
Java在列表中查找与指定数字最为接近的值
weixin_62094610的博客
07-31 961
注:输入列表为字符串类型,可以自行更改;在列表中寻找与指定数字最接近的值。
Java 最优数量
ChenK
07-14 340
（算法）求数组中数字组合相加最接近并且等于或大于目标数的组合
规划求解——从一堆数据求指定和值的组合
05-09
从一堆数据中，要求出一个指定和值的组合，在财务审计中时常遇到这个头痛的问题，EXCEL中可以通过VBA的宏命令，快速解决这个头痛的问题。本文件，简单易学，上手快速，操作便宜，很值得推荐使用。
寻找数组中最接近目标的数字，Java实现
qq_53364137的博客
06-30 3947
给出一个排好序的整数数组。需要找到与给定数字最接近的值。数组可能包含重复的值 和负数。 例： Input : arr[] = {1, 2, 4, 5, 6, 6, 8, 9}Target number = 11Output : 9Input : arr[] = {2, 5, 6, 7, 8, 8, 9};Target number = 4Output :5......
js查找数组中与目标值最相近的数值
jerryJJYY的博客
09-21 4593
var arr = [500, 400, 320, 200, 1, 10, 8, 100, 130, 120, 135, 140, 180, 190, 170, -1, -2, -4]; // 原有数组 var targetNum = 125; // 目标数值 /** * @method * @author gedesiwen * @param {array} arr 需要查找的数组 * @param {number} num 目标数值，查找的是与这个数值最接近的 * @return {num.
【AI】java，在集合中找最接近给定值的数，且比给定值小
djj1015591892的博客
12-13 781
用AI工具，提高写代码和解决问题的能力
根据提供的某数值，找出与其最接近的一组数据
10-17
"根据提供的某数值，找出与其最接近的一组数据" 在这个问题中，我们需要根据提供的某数值，找出与其最接近的一组数据。这个问题可以使用 SQL 语言来解决。 首先，我们需要创建一个测试数据表 tb，用于存储物料、...
找出哪几个数值的和接近目标值
10-21
标题 "找出哪几个数值的和接近目标值" 描述了一个常见的算法问题，它涉及到寻找一组数值中的若干项，使得它们的和最接近于一个给定的目标值。在计算机科学和编程领域，这样的问题通常用于数据处理、数据分析或者优化...
旅行商问题-遗传算法--java
04-16
旅行商问题（Traveling Salesman Problem，TSP）是一个经典的组合优化问题，它涉及寻找最短的可能路线，使得旅行商能够访问每个城市一次并返回起点。这个问题在计算机科学、运筹学和图论中都有广泛的研究，因为它...
Java遗传算法之冲出迷宫
08-29
遗传算法是一种启发式搜索技术，源于生物学中的进化理论，通过模拟自然选择、遗传与突变等机制来寻找问题的最优解。这种方法尤其适用于解决复杂的优化问题，如路径规划、组合优化等。 遗传算法的基本步骤如下： 1....
遗传算法求解可满足性问题的java实现代码
05-10
在本文中，我们将深入探讨如何使用遗传算法解决可满足性问题（SAT问题），特别是3-SAT问题，并在Java编程环境中实现这一算法。首先，我们需要理解遗传算法的基本原理以及可满足性问题的背景。 遗传算法是一种受到...
算法 - 从数组中找出和为给定值的所有组合(java)
se-tester的专栏
01-09 2852
public class Pairs { public static void main(String[] args) { Pairs pairs = new Pairs(); // 输出结果为： //[1, 2] //[1, 2, 0] //[1, 3, 0, -1] //[1, 3, -1] //[3] //[3, 0] //[0, -1, 4] .
1686: Java两个集合输出距离最近的数字
weixin_52293201的博客
08-14 243
同一个数轴x有两个点的集合A={A1,A2,…,Am}和B={B1,B2,…,Bm}A(i)和B(j)均为正整数A、B已经按照从小到大排好序，AB均不为空给定一个距离R 正整数，列出同时满足如下条件的(A(i),B(j))数对：A(i)
给定升序数组，以及目标值，查找出最接近目标值的所有数组组合
qq_31217363的博客
11-10 3941
学习需要记录，还有进步的空间，争做越来越好的自己！！！ 解题思路： 1、已知给定的数组是升序的，需要找出和目标值target相近的一些数字的组合，我们通过先找出大于等于的一部分，把这部分先过滤，这样剩下的组合才是需要排查的范围。 2、假如排查后剩下：1，2，3，4，5，7 ；target=10 的话，我们依次拿数组 7开头的 1，2，3，4，5 5开头的1，2，3，4 … 这样递归/循环数组去寻找 3、每次循环我们都用Map存储下对应循环的深度以及开头的值 4、注意存值的时候需要过滤重复的数字组合
用java实现判断一个数组中的某个数和一个数最接近
03-27
以下是用Java实现判断一个数组中的某个数和一个数最接近的例子： ```java public class ClosestNumber { public static int findClosest(int[] arr, int target) { if (arr == null || arr.length == 0) { throw new IllegalArgumentException("Array is null or empty!"); } int closest = arr[0]; for (int i = 1; i < arr.length; i++) { if (Math.abs(arr[i] - target) < Math.abs(closest - target)) { closest = arr[i]; } } return closest; } public static void main(String[] args) { int[] arr = {1, 3, 5, 7, 9}; int target = 6; int closest = findClosest(arr, target); System.out.println("The closest number to " + target + " is " + closest); } } ``` 在这个例子中，我们先检查了数组是否为空或长度为零，如果是，则抛出异常。然后我们初始化closest变量为数组的第一个元素，然后遍历整个数组，检查每个元素与目标元素之间的距离。如果当前元素比closest更接近目标元素，则将closest设置为当前元素。最后，我们返回closest变量。在main方法中，我们创建了一个数组和一个目标元素，并调用findClosest方法来查找最接近的数字，并将结果打印到控制台上。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值