您好,欢迎访问代理记账网站
  • 价格透明
  • 信息保密
  • 进度掌控
  • 售后无忧

【每日一题】day29_01 正数数组的最小不可组成和

学习目标:

目标:熟练运用Java所学知识


学习内容:

本文内容:使用java解决 正数数组的最小不可组成和


文章目录

  • 学习目标:
  • 学习内容:
  • 题目描述
  • 解题思路:
  • 实现代码

题目描述

链接:https://www.nowcoder.com/questionTerminal/f5368cd8008d41f58b2da7ced2f4d809
来源:牛客网

给定一个正数数组arr,其中所有的值都为整数,以下是最小不可组成和的概念
把arr每个子集内的所有元素加起来会出现很多值,其中最小的记为min,最大的记为max 在区间[min,
max]上,如果有数不可以被arr某一个子集相加得到,那么其中最小的那个数是arr的最小不可组成和 在区间[min,
max]上,如果所有的数都可以被arr的某一个子集相加得到,那么max+1是arr的最小不可组成和
请写函数返回正数数组arr的最小不可组成和 时
在这里插入图片描述

输入描述:

第一行一个整数N,表示数组长度。
接下来一行N个整数表示数组内的元素。

输出描述:

输出一个整数表示数组的最小不可组成和

示例1

输入
3
2 3 9
输出
4

示例2

输入
3
1 2 4
输出
8
说明
3 = 1 + 2
5 = 1 + 4
6 = 2 + 4
7 = 1 + 2 + 4

解题思路:

这个题目是一个典型的动态规划题目
状态:
ary[]表示给定的数组
F(i,j):表示ary的前 i+1 个数字是否有和为 j 的组成序列
初始化:
F(i,0)=true 表示和是零一定能得到
F(0,ary[0])=true :表示可以得到以第一个元素为和的序列(只包含第一个元素)
递推关系:
在这里插入图片描述
其中

j - ary[ i ] < 0表示:当前和 j 小于当前位置元素 ary[i] ,不能通过包含当前位置元素的序列得到
j - ary[ i ] >= 0表示:当前和 j 大于等于当前位置元素 ary[i] ,可能可以通过包含当前位置元素的序列得到

以ary={2,3,9}为例
此时min=2,max=14

  1. 初始化二维数组
    在这里插入图片描述
    表示前i+1个数字 { 2 } 可以得到的和是 0 ,2两个值
  2. 第一步循环,得到第二行的可组成和
    在这里插入图片描述

其中的连线表示下面一行的 T 是根据上面一行得到的

  1. 第二步循环,得到第三行的值
    在这里插入图片描述
    (由于线太多,所以我把图片分开了 (`・ω・´) )

实现代码

  1. 二维数组实现:
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[] ary = new int[n];
            for (int i = 0; i < n; i++) {
                ary[i] = sc.nextInt();
            }
            System.out.println(getFirstUnFormedNum(ary));
        }
    }

    public static int getFirstUnFormedNum(int[] ary) {
        int min = Integer.MAX_VALUE;//记录最小和
        int max = 0;//记录最大和
        for (int i = 0; i < ary.length; i++) {
            max += ary[i];
            min = Math.min(min, ary[i]);
        }
        boolean[][] res = new boolean[ary.length][max + 1];
        for (int i = 0; i < ary.length; i++) {
            //初始化第一列
            res[i][0] = true;
        }
        res[0][ary[0]] = true;//初始化第一行,其他位置默认是false
        for (int i = 1; i < res.length; i++) {
            for (int j = 1; j < res[0].length; j++) {
                if (j - ary[i] < 0) {
                    //F(i,j)=F(i-1,j)
                    res[i][j] = res[i - 1][j];
                } else {
                    //F(i,j)=F(i-1,j)||F(i-1,j-ary[i])
                    res[i][j] = res[i - 1][j] || res[i - 1][j - ary[i]];
                }
            }
        }
        for (int i = min; i < res[0].length; i++) {
            if (!res[res.length - 1][i]) {
                return i;
            }
        }
        return res[0].length;
    }
}
  1. 代码优化,一位数组实现
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n = sc.nextInt();
            int[] ary = new int[n];
            for (int i = 0; i < n; i++) {
                ary[i] = sc.nextInt();
            }
            System.out.println(getFirstUnFormedNum(ary));
        }
    }
    public static int getFirstUnFormedNum(int[] arr) {
        int min = Integer.MAX_VALUE;
        int max = 0;
        for (int i = 0; i < arr.length; i++) {
            max += arr[i];
            min = Math.min(min, arr[i]);
        }
        boolean res[] = new boolean[max + 1];
        res[0] = true; // 为了使单个元素去求和时是真的 (i + 0 = i)
        for (int i = 0; i < arr.length; i++) {
            for (int j = max; j >= arr[i]; j--) {
                res[j] = res[j - arr[i]] || res[j];
            }
        }
        for (int i = min; i < res.length; i++) {
            if (!res[i])
                return i;
        }
        return max + 1;
    }
}


分享:

低价透明

统一报价,无隐形消费

金牌服务

一对一专属顾问7*24小时金牌服务

信息保密

个人信息安全有保障

售后无忧

服务出问题客服经理全程跟进