目录
分治(divide and conquer)的全称称为“分而治之”,分治即是将大问题划分为若干个规模较小、可以直接解决的子问题,然后解决这些子问题,最后将这些子问题的解合并起来,即是原问题的解。
分治是一种思想,它不涉及到具体的算法,而大多数情况下,分治都是借由递归来实现的。
一、241. 为运算表达式设计优先级
1.1 题目描述
给定一个含有数字和运算符的字符串,为表达式添加括号,改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。
示例 1:输入: "2-1-1"
输出: [0, 2]
解释:
((2-1)-1) = 0
(2-(1-1)) = 2示例 2:输入: "2*3-4*5"
输出: [-34, -14, -10, -10, 10]
解释:
(2*(3-(4*5))) = -34
((2*3)-(4*5)) = -14
((2*(3-4))*5) = -10
(2*((3-4)*5)) = -10
(((2*3)-4)*5) = 10
1.2 代码
1.2.1 分治+递归
对于一个形如 x op y(op 为运算符,x 和 y 为数) 的算式而言,它的结果组合取决于 x 和 y 的结果组合数,而 x 和 y 又可以写成形如 x op y 的算式。
因此,该问题的子问题就是 x op y 中的 x 和 y:以运算符分隔的左右两侧算式解。
然后我们来进行 分治算法三步走:
- 分解:按运算符分成左右两部分,分别求解
- 解决:实现一个递归函数,输入算式,返回算式解
- 合并:根据运算符合并左右两部分的解,得出最终解
package DivideConquer;
import java.util.ArrayList;
import java.util.List;
/**
* @author : lkw
* @data : 2021/4/1 8:14
* @description :241. 为运算表达式设计优先级(中等)
**/
public class diffWaysToCompute_01 {
public static void main(String[] args) {
//String expression ="2-1-1";
String expression ="2*3-4*5";
System.out.println(diffWaysToCompute(expression));
}
public static List<Integer> diffWaysToCompute(String expression) {
List<Integer> list =new ArrayList();
for (int i = 0; i < expression.length(); i++) {
char c= expression.charAt(i);
if (c=='+' ||c=='-' ||c=='*'){
List<Integer> left =diffWaysToCompute(expression.substring(0,i));
List<Integer> right =diffWaysToCompute(expression.substring(i+1));
for (int le:left){
for (int ri:right){
switch (c) {
case '+':
list.add(le+ri);
break;
case '-':
list.add(le-ri);
break;
case '*':
list.add(le*ri);
break;
}
}
}
}
}
//若expression本身就是一个数字的情况下
// Integer. valueOf()可以将基本类型int或者String转换为包装类型Integer,
// String如果为Null或“”都会报错
if (list.size()==0){
list.add(Integer.valueOf(expression));
}
return list;
}
}
补充:Integer. valueOf()可以将基本类型int或者String转换为包装类型Integer,String如果为Null或“”都会报错。
二、95. 不同的二叉搜索树 II
2.1 题目描述
给定一个整数 n,生成所有由 1 ... n 为节点所组成的 二叉搜索树 。(难度中等)
2.2 代码
2.2.1 分治+递归
二叉搜索树关键的性质是根节点的值大于左子树所有节点的值,小于右子树所有节点的值,且左子树和右子树也同样为二叉搜索树。
class Solution {
public List<TreeNode> generateTrees(int n) {
if (n == 0) {
return new LinkedList<TreeNode>();
}
return trees(1, n);
}
public List<TreeNode> trees(int start, int end) {
List<TreeNode> allTrees = new LinkedList<TreeNode>();
if (start > end) {
allTrees.add(null);
return allTrees;
}
// 枚举可行根节点
for (int i = start; i <= end; i++) {
// 获得所有可行的左子树集合
List<TreeNode> leftTrees = trees(start, i - 1);
// 获得所有可行的右子树集合
List<TreeNode> rightTrees = trees(i + 1, end);
// 从左子树集合中选出一棵左子树,从右子树集合中选出一棵右子树,拼接到根节点上
for (TreeNode left : leftTrees) {
for (TreeNode right : rightTrees) {
TreeNode currTree = new TreeNode(i);
currTree.left = left;
currTree.right = right;
allTrees.add(currTree);
}
}
}
return allTrees;
}
}