LeeCode - 分发饼干

LeeCode - 分发饼干

题目：

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。可是，每一个孩子最多只能给一块饼干。对每一个孩子 i ，都有一个胃口值 gi ，这是能让孩子们知足胃口的饼干的最小尺寸；而且每块饼干 j ，都有一个尺寸 sj 。若是 sj >= gi ，咱们能够将这个饼干 j 分配给孩子 i ，这个孩子会获得知足。你的目标是尽量知足越多数量的孩子，并输出这个最大数值。

注意：

你能够假设胃口值为正。 一个小朋友最多只能拥有一块饼干。

示例 1:

输入: [1,2,3], [1,1]

输出: 1

解释: 你有三个孩子和两块小饼干，3个孩子的胃口值分别是：1,2,3。 虽然你有两块小饼干，因为他们的尺寸都是1，你只能让胃口值是1的孩子知足。 因此你应该输出1

分析：

个人想法很憨厚，先将两个数组排序，若是 s[0] < g[0]，说明该值不能知足最低胃口的小孩，此时将s[0]从数组中删掉，将修改后的数组从新赋值迭代。若是s[0] >= g[0]，则计数器自增，同时将匹配完成的值从各自的数组删除，将修改后的数组从新赋值迭代。

当sr[sr.length] < gr[0] || sr.length == 0 || gr.length == 0时，中止并返回计数器。

答案：

const sortArray = function (arr) { // 数组排序方法
  for (let i = 0; i < arr.length; i++) {
    for (let j = i + 1; j < arr.length; j ++) {
      if (arr[i] > arr[j]) {
        arr[i] = arr.splice(j, 1, arr[i])[0]
      }
    }
 }
 return arr
}

const findContentChildren = function(g, s, index) {
  let gr = sortArray(g) // 排序一下
  let sr = sortArray(s) 
  let x = index
  if (sr[sr.length] < gr[0] || sr.length == 0 || gr.length == 0) {
    console.log(x)
    return x
  }
  if (sr[0] < gr[0]) {
    sr.shift()
  } else {
    gr.shift()
    sr.shift()
    x ++
  }
  findContentChildren(gr, sr, x)
}
findContentChildren([3, 2, 1, 3, 6, 5], [2, 1, 4, 6, 1, 9], 0)
复制代码

结果：提交失败

由于 leecode 测试用的参数中没有计数器。。因此提交失败了，可是通过我的测试，这个方法能返回正确的值。

优化解法

贪心算法

贪心算法的基本思路是从问题的某一个初始解出发一步一步地进行，根据某个优化测度，每一步都要确保能得到局部最优解。每一步只考虑一个数据，他的选取应该知足局部优化的条件。若下一个数据和部分最优解连在一块儿再也不是可行解时，就不把该数据添加到部分解中，直到把全部数据枚举完，或者不能再添加算法中止

对于这个题目，个人理解就是，用最低的饼干值尽可能去知足最大的胃口值，因此得先对数组进行排序。

var findContentChildren = function(g, s) {
 let index = 0
  g.sort((a, b) => a - b)
  s.sort((a, b) => a - b)
  let length = g.length
  for (let i = 0; i < length; i++) {
      if (g.length > 0 && s.length > 0) {
          if (s[0] >= g[0]) {
              g.splice(0, 1)
              index += 1
          }
          s.splice(0, 1)
      } else {
          break
      }
  }
  return index
};
复制代码

结果：提交成功

耗时：160ms

内存：39.2MB

首先数组的排序使用了array.sort()方法，比个人简单不少。而后该答案使用了for循环，不用迭代计算，优化了过程。