1019 最大乘积连续子串

题目详情

给一个浮点数序列，取最大乘积连续子串的值，例如 -2.5，4，0，3，0.5，8，-1，则取出的最大乘积连续子串为3，0.5，8。也就是说，上述数组中，3 0.5 8这3个数的乘积3*0.5*8=12是最大的，而且是连续的。

输入：

输入的第一行为n，表示序列数的个数

输入的第二行是n个浮点数序列

输出：

输出最大乘积子串的起点数，终点数，最大乘积结果值。

输入样例：

7

-2.5 4 0 3 0.5 8 -1

输出样例：

3 8 12

 

 

 

代码

 

package ausky.work.test;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

public class Pongo_1019 {

	/**
	 * 给一个浮点数序列，取最大乘积连续子串的值，例如
	 * -2.5，4，0，3，0.5，8，-1，则取出的最大乘积连续子串为3，0.5，8。也就是说，上述数组中，3 0.5
	 * 8这3个数的乘积3*0.5*8=12是最大的，而且是连续的。
	 * 
	 * 
	 * 
	 * 输入：
	 * 
	 * 输入的第一行为n，表示序列数的个数
	 * 
	 * 输入的第二行是n个浮点数序列
	 * 
	 * 输出：
	 * 
	 * 输出最大乘积子串的起点数，终点数，最大乘积结果值。
	 * 
	 * 
	 * 
	 * 输入样例：
	 * 
	 * 7
	 * 
	 * -2.5 4 0 3 0.5 8 -1
	 * 
	 * 输出样例：
	 * 
	 * 3 8 12
	 */

	/**
	 * @param args
	 * @throws Exception
	 */
	public static void main(String[] args) throws Exception {
		BufferedReader reader = new BufferedReader(new InputStreamReader(
				System.in));
		System.out.println("请输入第一行：");
		// 第一行为有多少个数字
		String firstLine = reader.readLine();
		Integer nums = Integer.parseInt(firstLine.trim());

		System.out.println("请输入第二行：");
		String secondLine = reader.readLine();
		String[] vals = secondLine.trim().split(",");

		if (nums != vals.length) {
			System.out.println("请输入有效的参数 谢谢！");
			return;
		}
		List<Double> ds = new ArrayList<Double>();
		for (String str : vals) {
			ds.add(Double.valueOf(str));
		}
		Double max = null;
		String maxStr = null;

		Double[] values = new Double[nums];
		values = ds.toArray(values);

		for (int i = 0; i < values.length; i++) {
			Map<String, Double> map = getMaxSum(values, values.length, i);
			Set<String> sets = map.keySet();
			int flag = 0;
			for (String str : sets) {
				if (flag <= 0) {
					if (max == null) {
						max = map.get(str);
						maxStr = str;
					} else if (map.get(str) > max) {
						max = map.get(str);
						maxStr = str;
					}
				} else {
					break;
				}
			}
		}
		String[] strs = maxStr.split(",");
		System.out.print(values[Integer.parseInt(strs[0])] + ",");
		System.out.print(values[Integer.parseInt(strs[0])
				+ Integer.parseInt(strs[0]) - 1]);
		System.out.println("," + max);
	}

	/**
	 * values 为数组 size为数组的长度 seat当前从那个开始 seat的取值范围 为 0 - size
	 * 
	 * @param values
	 * @param size
	 * @return
	 */
	public static Map<String, Double> getMaxSum(Double[] values, int size,
			int seat) {
		Map<String, Double> resMap = new HashMap<String, Double>();
		// 剩余的个数 假设剩余2个数 那么就有2个组合 1个是自身 另一个是 2个数的乘积
		int leave = size - seat;
		Double result = null;
		String local = null;
		for (int i = 1; i <= leave; i++) {
			double sum = 1.0;
			for (int j = 0; j < i; j++) {
				sum *= values[seat + j];
			}
			if (result == null) {
				result = sum;
				local = seat + "," + i;
			} else {
				if (sum > result) {
					result = sum;
					local = seat + "," + i;
				}
			}
		}
		resMap.put(local, result);
		return resMap;
	}

}