程序员面试金典：子串判断、 最大连续数列和

1.子串判断

题目描述

现有一个小写英文字母组成的字符串s和一个包含较短小写英文字符串的数组p，请设计一个高效算法，对于p中的每一个较短字符串，判断其是否为s的子串。

给定一个string数组p和它的大小n，同时给定string s，为母串，请返回一个bool数组，每个元素代表p中的对应字符串是否为s的子串。保证p中的串长度小于等于8，且p中的串的个数小于等于500，同时保证s的长度小于等于1000。
测试样例：

["a","b","c","d"],4,"abc"

返回：[true,true,true,false]

因为contains方法本身就返回一个true或者false，因此直接赋值给bp 布尔数组就行了

import java.util.*;

public class Substr {
public boolean[] chkSubStr(String[] p, int n, String s) {
boolean []bp=new boolean[p.length];
if(p.length>500||s.length()>1000)	return bp;
for(int i=0;i<n;i++){
bp[i]=s.contains(p[i]);
}
return bp;
}
}

2.最大连续数列和

题目描述

对于一个有正有负的整数数组，请找出总和最大的连续数列。给定一个int数组A和数组大小n，请返回最大的连续数列的和。保证n的大小小于等于3000。

测试样例：

[1,2,3,-6,1]

返回：6

方法1：暴力搜索，遍历每一个值

import java.util.*;

public class MaxSum {
public int getMaxSum(int[] A, int n) {
int max=Integer.MIN_VALUE;
int sum=0;
if(n>3000)	return 0;
for(int i=0;i<n;i++){
sum=0;
for(int j=i;j<n;j++){
sum+=A[j];
max=getMax(sum,max);
}
}
return max;
}
public int getMax(int a,int b){
return a>b? a:b;
}
}

方法2：动态规划

时间复杂度为o(n),空间复杂度为o(1)

import java.util.*;

public class MaxSum {
public int getMaxSum(int[] A, int n) {
int dp0=A[0],max=A[0];
for(int i=1;i<n;i++){
if(dp0+A[i]>A[i])
dp0=dp0+A[i];
else
dp0=A[i];
if(dp0>max){
max=dp0;
}
}
return max;
}
}

方法3：动态规划版本2（参考牛客网牛油回答）

import java.util.*;

public class MaxSum {
public int getMaxSum(int[] A, int n) {
// write code here
int [] bf=new int
;
bf[0]=A[0];
for(int i=1;i<n;i++){
bf[i]=A[i];
bf[i]=Math.max(bf[i-1]+A[i],bf[i]);
}
int temp=A[0];
for(int i=0;i<n;i++){
if(bf[i]>temp){
temp=bf[i];
}
}
return temp;
}
}

方法4：

从第一个数开始相加，加到小于0的数，就重新开始相加（总感觉有点bug）

public class Text {
public static void main(String[] args) {
int arr[]={2,1,-3,-3,5,4};
System.out.println(getMaxSum(arr, 5));
}

public static int getMaxSum(int[] A, int n) {
int max = A[0];
int sum = 0;
for (int i = 0; i < n; i++) {
sum += A[i];
max = Math.max(sum, max);
if (sum < 0)
sum = 0;
}
return max;
}
}