这几天面试遇到的几个算法题,记录一下
一、找出数组中连续最大的子数组
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);
}
}
}
}
}