LeetCode 探索 初级算法 数组 第二题：买卖股票的最佳时机 II

问题：

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

示例 1:

输入: [7,1,5,3,6,4]
输出: 7
解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。
     随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。

解题思路：

穷举出所有情况，对所有的情况求值，计算最大值。

代码块：

import java.util.ArrayList;
import java.util.List;

public class maxProfit3 {
	private List<String> contian = new ArrayList<String>();

	public maxProfit3() {
		// TODO Auto-generated constructor stub
		int[] prices = {1,2,3,4,5};
		System.out.println(maxProfit(prices));

	}

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		new maxProfit3();
	}

	public int maxProfit(int[] prices) {
                if(prices.length==0||prices.length==1)
		{
			return 0;
		}
		List<List<String>> listvec = new ArrayList<List<String>>();
		int priceslength = prices.length;
		contian.add(prices[prices.length - 2] + "-" + prices[prices.length - 1]);
		if (priceslength / 2 == 0) {
			return 0;
		} else {
			for (int i = 0; i < 1; i++) {
			//	System.out.println("i=" + i);
				for (int j = i + 1; j < 2; j++) {
					List<String> pricelist = new ArrayList<String>();
					pricelist.add(i + "-" + j);

					while (j + 1 < priceslength - 1 && j + 2 < priceslength) {
						pricelist.add((j + 1) + "-" + (j + 2));
						j = j + 2;
					}
					listvec.add(pricelist);// [0-1, 2-3, 4-5, 6-7]
					financial(listvec, prices, pricelist, pricelist.size() - 1, priceslength);

				}
			}

			// System.out.println(listvec);
			// System.out.println(listvec.get(listvec.size() - 1));

		}

		List<Integer> numlist = new ArrayList<Integer>();

		for (int t = 0; t < listvec.size(); t++) {

			List<String> lists = listvec.get(t);
			//System.out.println(lists);

			List<String> suzhulist = new ArrayList<String>();
			for (int i = 0; i < lists.size() - 1; i++) {
				for (int j = i + 1; j < lists.size(); j++) {
					suzhulist.add(i + "-" + j);
				}
			}
			financial2(suzhulist, suzhulist, lists.size() - 1);

			for (int i = 0; i < lists.size(); i++) {
				suzhulist.add(i + "");
			}

		//	System.out.println("穷举组合\n="+suzhulist);

			for (int i = 0; i < suzhulist.size(); i++) {
				int sum = 0;
				String[] xiabiaoshuzu = suzhulist.get(i).split("-");
				for (int j = 0; j < xiabiaoshuzu.length; j++) {
					int shuzuxiabiao = Integer.valueOf(xiabiaoshuzu[j]);
					String[] shijixiabiaozu = lists.get(shuzuxiabiao).split("-");
					sum = sum
							+ (prices[Integer.valueOf(shijixiabiaozu[1])] - prices[Integer.valueOf(shijixiabiaozu[0])]);
				}
				numlist.add(sum);
			}
		}

		//System.out.println("num数组="+numlist);
		int max = numlist.get(0);
		for (int i = 1; i < numlist.size(); i++) {
			if(max<numlist.get(i))
			{
				max = numlist.get(i);
			}
		}
		if(max<0)
		{
			return 0;
		}
		return max;

	}

	public void financial(List<List<String>> listvec, int[] prices, List<String> pricelist, int index,
			int priceslength) {
		if (listvec.contains(contian)) {
			return;
		}

		if (index > -1 && !listvec.contains(contian)) {
			String indexvalue = pricelist.get(index);
			List<String> pricelist2 = new ArrayList<String>();
			for (int i = 0; i < index; i++) {
				pricelist2.add(pricelist.get(i));
			}
			int leftindex = Integer.valueOf(indexvalue.substring(0, indexvalue.indexOf("-")));
			int rightindex = Integer.valueOf(indexvalue.substring(indexvalue.indexOf("-") + 1, indexvalue.length()));

			int leftxunhuan = leftindex + 1;
			int rightxunhuan = rightindex + 1;

			while (rightxunhuan < priceslength) {
				pricelist2 = new ArrayList<String>();
				for (int i = 0; i < index; i++) {
					pricelist2.add(pricelist.get(i));
				}
				pricelist2.add(leftindex + "-" + rightxunhuan);

				List<String> originlist = new ArrayList<String>();
				for (int i = 0; i < pricelist2.size(); i++) {
					originlist.add(pricelist2.get(i));
				}

				if (rightxunhuan + 1 < priceslength - 1) {
					int flag = rightxunhuan + 1;
					while (flag < priceslength - 1) {
						originlist.add(flag + "-" + (flag + 1));
						flag = flag + 2;
					}
					listvec.add(originlist);
					financial(listvec, prices, originlist, originlist.size() - 1, priceslength);
					if (listvec.contains(contian)) {
						return;
					}

				} else {
					listvec.add(pricelist2);
				}

				rightxunhuan++;
			}

			while (leftxunhuan < priceslength - 1) {
				for (int i = leftxunhuan + 1; i < priceslength; i++) {
					pricelist2 = new ArrayList<String>();
					for (int k = 0; k < index; k++) {
						pricelist2.add(pricelist.get(k));
					}
					pricelist2.add(leftxunhuan + "-" + i);

					List<String> originlist = new ArrayList<String>();
					for (int t = 0; t < pricelist2.size(); t++) {
						originlist.add(pricelist2.get(t));
					}
					if (i + 1 < priceslength - 1) {
						int flag = i + 1;
						while (flag < priceslength - 1) {
							originlist.add(flag + "-" + (flag + 1));
							flag = flag + 2;
						}
						listvec.add(originlist);
						// financial2(listvec, prices,
						// originlist,originlist.size()-1);
						financial(listvec, prices, originlist, originlist.size() - 1, priceslength);
						if (listvec.contains(contian)) {
							return;
						}
					} else {
						listvec.add(pricelist2);
					}

				}
				leftxunhuan++;
			}
			financial(listvec, prices, pricelist2, index - 1, priceslength);
		}
	}

	public void financial2(List<String> list, List<String> suzhulist, int maxindex) {
		List<String> suzhu = new ArrayList<String>();
		for (int i = 0; i < list.size(); i++) {
			int rightindex = Integer
					.valueOf(list.get(i).substring(list.get(i).lastIndexOf("-") + 1, list.get(i).length()));
			while (rightindex < maxindex) {
				rightindex++;
				suzhu.add(list.get(i) + "-" + rightindex);
				suzhulist.add(list.get(i) + "-" + rightindex);
				if (rightindex + 1 < maxindex) {
					financial2(suzhu, suzhulist, maxindex);
				}
			}

		}
	}

}