转载的算法题

[成一粒]

一个整型数组里面散列存储的数据是正数，负数，零，求解数组中下标连续的一个片段使该片段的和是所有下标连续片段最大的？？？

[谢潇雨]

/*
* 一个整型数组里面散列存储的数据是正数，负数，零，
* 求解数组中下标连续的一
* 个片段使该片段的和是所有下标连续片段最大的
*/

package net.xhw.dp;

import java.util.*;

/**
* 存储最大连续段的基本信息
* @author Administrator
*
*/
class MaxStringInfo
{
private int start;
private int end;
private int length;
private int sum;

public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
}

/**
* 获取最大连续段的信息
* @author Administrator
*
*/
class MaxNumStringGet
{
private int num[];
private int fPosition[];
private int f=0;
private int maxSum=0;
private List<MaxStringInfo> list=new ArrayList<MaxStringInfo>();
public MaxNumStringGet(int a[])
{
num=a;
fPosition=a;
}
public int getMaxNum()
{
int i=0,j;
for(i=0;i<num.length;i++);
{
if(num[i]<0)
fPosition[f++]=i;
}

int start=0;
int sum=0;
int max=0;
for(i=0;i<f;i++)
{
for(j=start;j<fPosition[i];j++)
{
sum=sum+num[j];
}
if(sum>=max)
{
MaxStringInfo msi=new MaxStringInfo();
msi.setSum(sum);
msi.setStart(start);
msi.setEnd(fPosition[i]);
msi.setLength(fPosition[i]-start);
list.add(msi);
}
max=sum;
sum=0;
start=fPosition[i]+1;
}

maxSum=list.get(list.size()-1).getSum();
return maxSum;

}

public int getStringNum()
{
int i=0;
int count=0;
for(i=list.size()-1;i>=0;i--)
{
if(list.get(i).getSum()==maxSum)
count++;
else
break;
}
return count;
}

public ArrayList<MaxStringInfo> getPostionInfo()
{
ArrayList<MaxStringInfo> temp=new ArrayList<MaxStringInfo>();
int i=0;
int tempnum=list.size()-1;
for(i=0;i<getStringNum();i++)
temp.add(list.get(tempnum--));
return temp;
}


}

这个我采用是找到负数来将数组进行分段，可以获得最大连续串的值，以及这样的串的个数和位置信息等，思路是这样，但没来及检测对错，嘿嘿

[lacus87]

4楼的很精辟，楼主加点东西设两个值记录下首位和末位就满足要求了~~

[谢潇雨]

/*
* 一个整型数组里面散列存储的数据是正数，负数，零，
* 求解数组中下标连续的一
* 个片段使该片段的和是所有下标连续片段最大的
*/

package net.xhw.dp;

import java.util.*;

/**
* 存储最大连续段的基本信息
* @author Administrator
*
*/
class MaxStringInfo
{
private int start;
private int end;
private int length;
private int sum;

public int getStart() {
return start;
}
public void setStart(int start) {
this.start = start;
}
public int getEnd() {
return end;
}
public void setEnd(int end) {
this.end = end;
}
public int getLength() {
return length;
}
public void setLength(int length) {
this.length = length;
}
public int getSum() {
return sum;
}
public void setSum(int sum) {
this.sum = sum;
}
}

/**
* 获取最大连续段的信息
* @author Administrator
*
*/
class MaxNumStringGet
{
private final int len=10;
private int num[];
private int fPosition[];
private int f=0;
private int maxSum=0;
private List<MaxStringInfo> list=new ArrayList<MaxStringInfo>();
public MaxNumStringGet(String a)
{
String s[]=a.split(",");
num=new int[s.length];
fPosition=new int[s.length];
for(int i=0;i<s.length;i++)
{
num[i]=Integer.parseInt(s[i]);
}
//System.out.print(num.length);
}
public MaxNumStringGet(int[] a)
{
num=a;
fPosition=new int[a.length];
for(int i=0;i<a.length;i++)
fPosition[i]=a[i];
//System.out.print(num[0]);
}
public int getMaxNum()
{
int i,j;
int index=0;
//System.out.println(num.length);
while(index<(num.length))
{
//System.out.print(num[0]);
if(num[index]<0)
{
fPosition[f]=index;
//System.out.print(num[0]);
f++;
}
index++;
}
fPosition[f]=num.length;

int start=0;
int stringStart=0;
int sum=0;
int max=0;
for(i=0;i<=f;i++)
{
for(j=start;j<fPosition[i];j++)
{
sum=sum+num[j];
//System.out.println(num[0]);
}
if(sum>=max)
{
MaxStringInfo msi=new MaxStringInfo();
msi.setSum(sum);
msi.setStart(stringStart);
msi.setEnd(fPosition[i]);
msi.setLength(fPosition[i]-start);
list.add(msi);
max=sum;
//System.out.println(max);
}
if(fPosition[i]!=num.length)
if((sum+num[fPosition[i]])>=0)//若前面的数的和大于0，则并入到后面的计算值中肯定是增大的
sum=sum+num[fPosition[i]];
else//否则就从当前位置重新开始算
{
sum=0;
stringStart=fPosition[i]+1;
}
//System.out.println(sum);
start=fPosition[i]+1;

}

maxSum=list.get(list.size()-1).getSum();
return maxSum;

}

public int getStringNum()
{
int i=0;
int count=0;
for(i=list.size()-1;i>=0;i--)
{
if(list.get(i).getSum()==maxSum)
count++;
else
break;
}
return count;
}

public ArrayList<MaxStringInfo> getPostionInfo()
{
ArrayList<MaxStringInfo> temp=new ArrayList<MaxStringInfo>();
int i=0;
int tempnum=list.size()-1;
for(i=0;i<getStringNum();i++)
temp.add(list.get(tempnum--));
return temp;
}


}

public class MaxNumString {

//private int a[]={1,2,3,-1,-10,34,100};



public static void main(String args[])
{
String a="1,2,3,-1,-10,34,100";
int a1[]={1,2,3,-1,-10,34,100,-3,-5};
MaxNumStringGet mnsg=new MaxNumStringGet(a1);
ArrayList<MaxStringInfo> msi=new ArrayList<MaxStringInfo>();
int maxN=mnsg.getMaxNum();
int cnt=mnsg.getStringNum();
//System.out.println(mnsg.getMaxNum());
msi=mnsg.getPostionInfo();
System.out.println("最大值："+maxN);
System.out.println("共有这样的串："+cnt+"个");
for(int i=0;i<cnt;i++)
{
System.out.print("起始位置："+msi.get(msi.size()-i-1).getStart());
System.out.println(", 终止位置："+msi.get(msi.size()-i-1).getEnd());
}
}

}
这次应该对了。。。

[龙四]

上次不是说是淘宝的笔试题么

话说没有思路

[clarck_913]

我想的总是最最笨的办法，呵呵

public class Test {
	
	
	/**
	 * 获取最大的值区间方法
	 * @param array
	 * @return
	 * @throws Exception
	 */
	public Region getMaxSumPiece(int[] array) throws Exception{
		int maxSum = getSum(array, 0, array.length - 1);
		Region r = new Region(0, array.length - 1);
		
		/**
		 * i作为起始下标, j作为结束下标
		 * 依次循环所有可能的结果
		 */
		for(int i = 0, length = array.length; i < length; i++){
			for(int j = i; j < length; j++){
				int total = getSum(array, i , j);
				if(total > maxSum){
					maxSum = total;
					r.setStart(i);
					r.setEnd(j);
				}
			}
		}
		return r;
	}
	

	/**
	 * 获取一个数组中从start开始到end（含）结束的所有元素的和
	 * @param array
	 * @param start
	 * @param end
	 * @return
	 * @throws Exception
	 */
	private int getSum(int [] array, int start, int end)throws Exception {
		
		if(array == null || start < 0 || end > array.length || start > end){
			throw new Exception("你自己写异常信息吧");
		}
		
		int sum = 0;
		for(int index = start; index <= end; index++){
			sum += array[index];
		}
		
		return sum;
	}
	/**
	 * 记录取值区间其实和结束的内部类
	 * @author Administrator
	 *
	 */
	class Region{
		private int start = 0;
		
		private int end = 0;
		
		public Region(int start, int end){
			this.start = start;
			this.end = end;
		}

		public int getStart() {
			return start;
		}

		public int getEnd() {
			return end;
		}

		public void setStart(int start) {
			this.start = start;
		}

		public void setEnd(int end) {
			this.end = end;
		}
		
		
		
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		try {
			Region r = new Test().getMaxSumPiece(new int[] {1,23,0,-100,5,200});
			System.out.println(r.getStart() + "," + r.getEnd());
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

[keeya0416]

是求一个数组的连续子序列和的最大值吗

	public static int getMaxSumOfSubArray(int[] values) {
		int nStart = values[values.length - 1];
		int nAll = nStart;
		for (int i = values.length - 2; i >= 0; i--) {
			nStart = Math.max(values[i], nStart + values[i]);
			nAll = Math.max(nStart, nAll);
		}
		return nAll;
	}

[keeya0416]

[Quote=引用 4 楼 keeya0416 的回复:]
是求一个数组的连续子序列和的最大值吗

Java code

public static int getMaxSumOfSubArray(int[] values) {
int nStart = values[values.length - 1];
int nAll = nStart;
for (int i = values.l……
[/Quote]
其实就是一个 DP 问题
时间复杂度为O(n)