找出数组中连续最大的子数组、根据字典拆分字符串

这几天面试遇到的几个算法题，记录一下

一、找出数组中连续最大的子数组

public static void main(String[] args) {
    // 找出和最大的子数组
    // 3-6  6
    int[] arr = {-2,1,-3,4,-1,-2,17,-5,4};
    System.out.println(test(arr));
}

public static Integer test(int[] arr){
    // 最大累加值
    int sumMax = Integer.MIN_VALUE;
    // 当前的累加值
    int sum = 0;
    // 当前累加的起始索引
    int start = 0;
    // 最大子数组的结束索引
    int end = 0;

    for (int i = 0; i < arr.length; i++) {
        // 累加总和
        sum += arr[i];
        // 如果当前的累加值大于最大的累加值，说明有可能找到了最大的子数组
        if(sum > sumMax){
            // 将最大累加值替换
            sumMax = sum;
            // 记录结束索引
            end = i;
        }
        // 如果当前值大于最大累加值，说明子数组的起始索引应该是当前值
        if(sumMax < arr[i]){
            // 用当前值替换最大累加值
            sumMax = arr[i];
            // 记录起始索引
            start = i;
            // 暂时记录结束索引
            end = i;
        }
        // 如果当前值大于累加总和，就使用当前值替换累加值
        if(sum < arr[i]){
            sum = 0 + arr[i];
            start = i;
        }
    }
    System.out.println(start+"-------");
    System.out.println(end+"-------");
    return sumMax;
}

二、根据字典将字符串拆分成独立的单词

思路：如果给出的字段中，肯定对应字典中的一个单词的话，每次只需要取一个字符取字典中匹配，找到首字母匹配的单词后，按照单词长度从字符串中截取比较即可；如果有多个匹配的单词，首个不变，第二个匹配的就需要新建一个数组来存放。

public static void main(String[] args) {
    String str = "catsanddog";
    String[] wordDict = new String[]{"cat", "cats", "and", "sand", "dog"};
    for (List<String> strings : test1(str,wordDict)) {
        System.out.println(strings);
    }
    String str1 = "pineapplepenapple";
    String[] wordDict1 = new String[]{"apple", "pen", "applepen", "pine", "pineapple"};
    for (List<String> strings : test1(str1,wordDict1)) {
        System.out.println(strings);
    }
}

/**
 * "给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，在字符串中增加空格来构建一个句子，使得句子中所有的单词都在词典中。返回所有这些可能的句子。
 *
 * 说明：
 *
 * 分隔时可以重复使用字典中的单词。
 * 你可以假设字典中没有重复的单词。
 *
 * 示例 1：
 * 输入:
 * s = "catsanddog"
 * wordDict = ["cat", "cats", "and", "sand", "dog"]
 * 输出:
 * [
 *   ""cats and dog"",
 *   ""cat sand dog""
 * ]
 *
 * 示例 2：
 * 输入:
 * s = "pineapplepenapple"
 * wordDict = ["apple", "pen", "applepen", "pine", "pineapple"]
 * 输出:
 * [
 *   "pine apple pen apple",
 *   "pineapple pen apple",
 *   "pine applepen apple"
 * ]
 * 解释: 注意你可以重复使用字典中的单词。
 */
public static List<List<String>> test1(String str, String[] dict) {
    List<List<String>> result = new ArrayList<>();
    for(String s : dict){
        String substring = str.substring(0, s.length());
        if(s.startsWith(str.substring(0,1)) && s.equals(substring)){
            List<String> subList = new ArrayList<>();
            result.add(subList);
            subList.add(substring);
            subtest(str.substring(substring.length()),dict,subList,result);
        }
    }
    return result;
}

private static void subtest(String str,String[] dict,List<String> subList,List<List<String>> result) {
    // 是否是第一次匹配上的标志符
    Boolean flag = true;
    // 缓存一下传入的数组，方便后面新建数组时克隆
    List<String> middleList = new ArrayList<>(subList);
    for(String s : dict){
        if(s.length() <= str.length()){
            String substring = str.substring(0, s.length());
            if(s.startsWith(str.substring(0,1)) && s.equals(substring)){
                if(flag){
                    flag = false;
                    subList.add(substring);
                    subtest(str.substring(substring.length()),dict,subList,result);
                }else{
                    // 第二次匹配上的话，就需要将前面的数组拷贝，新建一个数组
                    List<String> cloneList = new ArrayList<>(middleList);
                    cloneList.add(substring);
                    result.add(cloneList);
                    subtest(str.substring(substring.length()),dict,cloneList,result);
                }
            }
        }
    }
}