每周学算法/读英文/知识点心得分享 9.6

 每周一个 Algorithm，Review 一篇英文文章，总结一个工作中的技术 Tip，以及 Share 一个传递价值观的东西！

Algorithm: 学习算法

题目：Combination Sum （数字组合）

描述：

给定一个无重复元素的数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。

candidates 中的数字可以无限制重复被选取。

说明：

• 所有数字（包括 target）都是正整数。
• 解集不能包含重复的组合。 

解题过程：

一般要求列出所有组合的题目，都可以用回溯法来解决。

回溯的核心思想是：

1.通过深度优先的方式求解。

2.每探索一个节点时，判断是否包含可行解。

3.当目前不符合要求时，回退到上一步继续探索。

解法：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;

/**
 * description : https://leetcode.com/problems/combination-sum/
 * contains unique/duplicates solutions
 * 题目描述 : https://leetcode-cn.com/problems/combination-sum/
 * 包含 唯一/重复 两种解题思路
 */
public class CombinationSum {

    public List<List<Integer>> combine(int[] candidates, int target) {
        Integer[] objects =
                IntStream.of(candidates).boxed().toArray(Integer[]::new);
        Arrays.sort(objects);
        List<List<Integer>> result = new ArrayList<>();
        if (target > 0) {
            backtrace(result, new ArrayList<>(), target, objects, 0);
        }
        return result;
    }

    private void backtrace(List<List<Integer>> result,
                           List<Integer> arr, int remain,
                           Integer[] candidates, int index) {
        if (remain < 0) {
            return;
        } else if (remain == 0) {
            result.add(new ArrayList<>(arr));
        } else {
            for (int i = index; i < candidates.length; i++) {
                arr.add(candidates[i]);
                backtrace(result, arr, remain - candidates[i],
                        candidates, i);
                arr.remove(arr.size() - 1);
            }
        }
    }

    public List<List<Integer>> combineUnique(int[] candidates,
                                             int target) {
        Integer[] objects =
                IntStream.of(candidates).boxed().toArray(Integer[]::new);
        List<List<Integer>> result = new ArrayList<>();
        Arrays.sort(objects);
        if (target > 0) {
            backtraceUnqiue(result, new ArrayList<>(), target,
                    objects, 0);
        }
        return result;
    }

    private void backtraceUnqiue(List<List<Integer>> result,
                                 List<Integer> arr, int remain,
                                 Integer[] candidates, int index) {
        if (remain < 0) {
            return;
        } else if (remain == 0) {
            if (!result.contains(arr)) {
                result.add(new ArrayList<>(arr));
            }
        } else {
            for (int i = index; i < candidates.length; i++) {
                arr.add(candidates[i]);
                backtraceUnqiue(result, arr, remain - candidates[i],
                        candidates, i + 1);
                arr.remove(arr.size() - 1);
            }
        }
    }


}

Review: 学习英文

无

Tips: 知识点

举个例子，某一面包房要把早晨制作的面包分发到全市的所有合作店铺里，店铺需要的面包数量各异，位置分散，并且一辆车运不完，要用多辆车给所有店铺配送。面包房要找出一个办法，用最少的车，行驶最短路程，送完所有面包。

这个就是运筹学中的车辆路径规划问题（VRP）， 求解这个问题有很多方法，我介绍一种思路比较清晰，实现比较简单的方法 C-W 节约算法。

算法的核心思想是通过计算节点间的 节约距离， 根据节约距离来选择路径，从而节省最多的路程。

可以通过这个例子来理解： 节约里程法

具体实现参看我另一篇博文：基于C-W节约算法的车辆路径规划问题的Java实现

Share: 价值观

  人生苦难重重，如果你不解决问题，你就会成为问题。解决部分问题需要部分的自律，解决全部问题需要全部的自律。自律包括四部分：推迟满足感， 承担责任，忠于事实，平衡。