总结一类编程题--数组的n项和为M的存在性问题

引言


  最近春招,同学都在各种面试和各种刷题,面试完之后常常互相分享在面试过程中遇到的题目,在分享过程中,我发现有些题目之间有雷同之处,所以总结一下

先上两道题


360的2018年面试真题:

  小明手中有一张游乐园的游玩券,凭该券可以在游乐园中游玩时长度为T的时间,游乐园中有一些项目,它们占用的时长分别是t1,t2,t3,t4等等(每个项目最多只能玩一次),如果T时间到了,但是有一个项目的游玩还没有结束,那么小明可以继续把这个项目玩完,请问小明在游乐园中最多可以游玩多长时间?

  为了更清晰地说明题意,举个例子:
  假如T是100,游乐园中项目的时长分别是10,20,33,40,50。那么为了在游乐园中可以游玩的最长时间是20 + 33 + 40 + 50=143分钟(在100分钟到的时候,因为那个50分钟的项目还没有结束,所以可以把游玩时间一直拖延到最后的那个50分钟的项目结束)。

网易2015年笔试真题:

  任意2n个数,从中选出n个数,使得它们的和与剩下的数的和的差最小。

题目分析


  两道题目看起来没什么关系,但是进过分析之后可以看出他们都衍生自同一个基本问题,分析如下:

第一题

  为了能够游玩的时间尽可能地长,时间最长的那个项目肯定要放在最后进行游玩,这样才能尽可能地拖延游玩时间,然后我们要从剩下的项目中选取n个项目,使得这n个项目时间的和最接近T(但是必须要小于T),然后再加上时长最长的那个项目就可以得到最长游玩时间了。
  举个例子:T为100,游乐园中项目的游玩时间分别为10,20,33,40,50,我们首先将50放在一旁,然后发现剩下的项目中(20 + 33 + 40 = 93)的和是最接近T(=100)的,然后将其加上时间最长的那个项目(93 + 50 = 143)就是最长的游玩时间了。
  现在问题就转换成如何求出最接近T的那个n项和,假如我们我们有一个方法,可以快速查询出是否存在n项的和等于T,T-1,T-2……,这样我们就可以从T开始向前(从T到0)查询,查找到为true的第一个数就是那个最接近T的n项和,所以问题可以进一步转换为数组的n项和为M的存在性问题。下面我们将会看到第二道题最后也可以转换成这个问题。

第二题

  为了能够在2n个数中找出n个数,使得这n个数的和与剩下的n个数的和尽可能地接近,那么选出的这n个数的和就要尽可能地接近2n个数的和的一半,这个问题就和第一题差不多了,根据第一题的分析,这个问题进一步可以转换成数组的n项和为M的存在性问题。

基本问题:数组的n项和为M的存在性问题–动态规划


  从上面分析可以看出,只要解决了这个问题就可以通杀一开始给出的两道题了。
  如果使用暴力破解的话,n项的组合有n!种,那么时间复杂度是指数级,显然难以接受。使用动态规划的方法可以在伪多项式的时间复杂度内解决该问题。
  为了使用动态规划方法,我们定义一个布尔类型的数组flag[n][m],规定如果数组中存在n项的和为m,则flag[n][m]=true,反之flag[n][m]=false,则存在如下的递推关系(设nums代表数组):

flag[n][m]=flag[n-1][m-nums[i]]

  上面的式子其实并不完全正确(只是为了表述得更加简洁),完整的算法是:只要在nums数组中存在一个数字num使得flag[n-1][m-num]为true,则flag[n][m]为true,否则为false。
  

计算flag数组

  首先初始化flag数组的第一行(下标为0),它代表0项和的存在性,显然0项的和只能是0,所以第一行中只有flag[0][0]是true,其他都是false,然后使用上面给出的递推公式一行行算出flag数组。
  为了循序渐进地介绍flag数组的计算方法,这里先假设数组中的元素可以被重复使用,举个例子:数组为{1,5,6},那么该数组存在3项的和为3(即1+1+1,1被重复使用了三次)。允许重复使用数组中数字的计算nums数组的flag的Java代码如下:(注:代码使用了Java中布尔数组初始化时默认值为false的特性)

boolean[][] flag = new boolean[nums.length][T];
flag[0][0] = true;

//允许重复使用时的计算方法,假设待计算的数组为nums
for ( int i = 1; i < nums.length; i++ ){
    for ( int j = 0; j < T; j++ ){
        for ( int h = 0; h < nums.length - 1; h++ ){
            if ( j >= nums[h] && flag[i - 1][j - nums[h]] ){
                flag[i][j] = true;
                break;
            }
        }
    }
}

  稍微解释一下代码,flag[0][0]=true这一句代码初始化了flag数组的第一行,从之前给出的flag数组递推公式可以看出,每一行的flag数组的计算只依赖于上一行的结果,所以我们从第二行开始一行一行进行计算,最外层的循环变量i代表flag数组的行,第二层循环j代表flag数组的列,第三层循环则是遍历nums数组,只要在nums数组中存在一个num使得flag[i - 1][j - nums[h]]为true,则flag[i][j]为true,注意我在判断flag[i - 1][j - nums[h]]之前还加了一个j >= nums[h]的判断条件,这是为了避免后面计算flag的时候下标为负导致程序出错。
  上面的代码假设了nums中的项可以重复使用,因为它将nums数组遍历放在了循环的第三层,计算每一个flag单元时都会尝试nums中的每一个数,不管它在计算上一行的时候有没有使用过。但是很多问题都要求数组中的项不能够重复使用,比如一开始给出的那一道360面试题中每个项目就只能够玩一次。为了让数组中每个项只使用一次,就需要将代码改一改,将nums数组遍历放在最外层循环中。不允许重复使用数组中数字的计算nums数组的flag的Java代码如下:

boolean[][] flag = new boolean[nums.length][T];
flag[0][0] = true;

//不允许重复使用时的计算方法
for ( int h = 0; h < nums.length - 1; h++ ){
    for ( int i = h + 1; i > 0; i-- ){
        for ( int j = 0; j < T; j++ ){
            if ( j >= nums[h] && flag[i - 1][j - nums[h]] ){
                flag[i][j] = true;
            }
        }
    }
}

  为了方便理解,这个代码的i,j,h的含义和之前的代码是一样的,分别代表flag的行号,flag的列号以及nums数组下标。i从h +1开始遍历的原因时,h=0时只有一个数字,所以只能求出1项和(i=1),当h=1时有两个数字,可以求出1项和与2项和(i=1,2),以此类推。

使用基本问题来解决开头给出的问题


问题一

  思路(续之前的分析):在这个问题中,我只关心是否存在n项和为T,T-1,T-2……,而并不关心n具体等于多少,所以我们在计算flag数组时顺带再计算一个一维数组colFlag[0…T],通过colFlag数组的下标就可以快速查询出是否存在n项和为T,T-1,T-2……,Java代码如下(基本上没怎么用到Java的特性,所以不熟悉Java的童鞋也不要担心看不懂):

static private void swap(int[] array, int k, int t){
    int temp = array[k];
    array[k] = array[t];
    array[t] = temp;
}

public static void main(String[] args) {
    int T = 100;
    int[] nums = {10,20,33,40,50};
    int max = 0;
    int maxindex = 0;
    for ( int i = 0; i < nums.length; i++ ){
        if ( nums[i] > max ){
            max = nums[i];
            maxindex = i;
        }
    }
    //将时间最长的项目放到最后
    swap(nums, maxindex, nums.length - 1);

    //n个数的和为m是否存在标志数组
    boolean[][] flag = new boolean[nums.length][T];
    flag[0][0] = true;

    //计算flag数组
    boolean[] colFlag = new boolean[T];
    for ( int h = 0; h < nums.length - 1; h++ ){
        for ( int i = h + 1; i > 0; i-- ){
            for ( int j = 0; j < T; j++ ){
                if ( j >= nums[h] && flag[i - 1][j - nums[h]] ){
                    flag[i][j] = true;
                    colFlag[j] = true;
                }
             }
        }
    }

    for ( int i = T - 1; i >= 0; i-- ){
        if ( colFlag[i] ){
            System.out.println("小明的最长游玩时间是:" + (i + nums[nums.length - 1]));
            break;
        }
    }
}

问题二

  思路(续之前的分析):相比基本问题唯一的区别就是它的flag数组的行数不必和nums数组规模(2n)一样大,只要一半(n)就可以了,所以在求flag数的第二层循环i的初始值是((h + 1) > n ? n : h),代码如下:

public static void main(String[] args) {
    int nums[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

    //计算数组和的一半
    int sum = 0;
    for (int i = 0; i < nums.length; i++) {
        sum += nums[i];
    }
    int n = nums.length / 2;

    //计算flag数组
    boolean flag[][] = new boolean[n + 1][sum / 2 + 1];
    flag[0][0] = true;
    for (int h = 0; h < 2 * n; h++) {
        for (int i = (h + 1) > n ? n : h; i > 0; i--) {//只需要求到n项即可
            for (int j = 0; j <= sum / 2; j++) {
                if (j >= nums[h] && flag[i - 1][j - nums[h]]) {
                    flag[i][j] = true;
                }
            }
        }
    }

    for (int i = sum / 2; i > 0; i--) {
        if (flag[n][i]) {
            System.out.println("最小差值为:" + (sum - 2 * i));
            break;
        }
    }
}

END


  在面试前背一背flag数组的计算代码,应该就能轻松攻破这一类问题。

发布了35 篇原创文章 · 获赞 111 · 访问量 18万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 编程工作室 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览