Java实现 蓝桥杯 算法训练 Remember the A La Mode（暴力）

试题 算法训练 Remember the A La Mode

问题描述
　　Hugh Samston经营着一个为今年的ICPC世界总决赛的参与者提供甜点的餐饮服务。他将会提供上面有冰激凌的饼片。为了满足不同的需求，他准备了许多不同的饼片和冰激凌。
　　Hugh希望以一份饼片上一份冰激凌的方式来提供甜点。然而，作为一个商人，他希望能赚到尽可能多的钱。他知道不同种类的饼片和冰激凌组合的价格，也知道那些冰激凌和那些饼片不能组合在一起。
　　Hugh想根据每种饼片和冰激凌的数量，以及之前提到的不同组合的情况，确定他能获得的利润的范围。
输入格式
　　测试数据的输入一定会满足的格式。
　　输入的第一行包含两个整数P, I，分别表示饼片和冰激凌的种类数。
　　接下来一行包含P个整数，表示每种类型饼片的数量。
　　接下来一行包含I个整数，表示每种类型冰激凌的数量。
　　接下来P行，每行包含I个实数，表示每种类型饼片和冰激凌组合的结果。
　　如果这种饼片和这种冰激凌可以组合，则为一个(0,10)的实数，表示这种组合的收益。
　　否则，则为-1,表示这两种之间不能组合。
输出格式
　　输出一行，以"(最小收益) to (最大收益)"的方式输出利润的范围。

请注意：所有的饼片和冰激凌都必须用完。
样例输入
2 3
40 50
27 30 33
1.11 1.27 0.70
-1 2 0.34
样例输出
91.70 to 105.87
数据规模和约定
　　0 < P,I <= 50，每种类型饼片或冰激凌数量不超过100。

PS：

这个题给我晕坏了，我的天，这半天就肝了这么几道题，躺了，浑身晕

 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

public class Main {
	static int[] PArray, IArray, pre, dis;
	
	/*分别用来保存P和I的数量，pre和dis用作SPFA算法中保存前节点和点到源点的距离*/
	
	static int[][] Weight;
	
	/* 保存权重 */
	
	static List<List<Integer>> index;
	
	/* index[i]表示所有从i出发的边的集合 */
	
	static int minCost = 0, maxCost = 0, P, I,count = -1;
	
	static List<Edge> E;
	
	/* 保存图中所有边 */
	
	public static void main(String[] args) 
	{
		Scanner sc = new Scanner(System.in);
		P = sc.nextInt();
		I = sc.nextInt();
		PArray = new int[P];
		IArray = new int[I];
		pre = new int[P + I + 2];
		dis = new int[P + I + 2];
		Weight = new int[P + I + 2][P + I + 2];
		index = new ArrayList<List<Integer>>();
		E = new ArrayList<Edge>();
		sc.nextLine();
		
		for (int i = 0; i < P + I + 2; i++)
		{
			index.add(new ArrayList<Integer>());
		}
		for (int i = 0; i < P; i++)
		{
			PArray[i] = sc.nextInt();
		}
		sc.nextLine();
		for (int i = 0; i < I; i++)
		{
			IArray[i] = sc.nextInt();
		}
		sc.nextLine();
		for (int i = 1; i <= P; i++)
		{
			for (int j = P + 1; j <= I + P; j++)
			{
				BigDecimal in = new BigDecimal(Double.toString(sc.nextDouble()));
				in = in.multiply(new BigDecimal(100));
				String toStr = in.toString();
				int num = Integer.parseInt(toStr.substring(0, toStr.indexOf('.')));
				Weight[i][j] = num;
				if (num != -100)
				{
					add(i, j, Math.min(PArray[i - 1], IArray[j - P - 1]), 0, -num);
					add(j, i, 0, 0, num);
					/* 同时构造边和反向边，正向边的权重先取反，来求最大花费 */
				}
			}
			sc.nextLine();
		}
		for (int i = 1; i <= P; i++)
		{
			add(0, i, PArray[i - 1], 0, 0);
			add(i, 0, 0, 0, 0);
			/* 构造超级源点的边以及反向边 */
		}
		
		for (int i = P + 1; i <= P + I; i++)
		{
			add(i, P + I + 1, IArray[i - P - 1], 0, 0);
			add(P + I + 1, i, 0, 0, 0);
			/* 构造超级汇点的边以及反向边 */
		}
		MCMF(0, P + I + 1);
		maxCost = -minCost;
		E.clear();
		minCost = 0;
		
		/* 重新按照weight数组保存的权重值构造Edge集合，来计算最小收益
		 * 事先已经构造好index集合，这次可以直接向E中add
		 */
		for (int i = 1; i <= P; i++)
		{
			for (int j = P + 1; j <= I + P; j++)
			{
				if (Weight[i][j] != -100)
				{
					E.add(new Edge(i, j, Math.min(PArray[i - 1], IArray[j - P - 1]), 0, Weight[i][j]));
					E.add(new Edge(j, i, 0, 0, -Weight[i][j]));
				}
			}
		}
		for (int i = 1; i <= P; i++)
		{
			E.add(new Edge(0, i, PArray[i - 1], 0, 0));
			E.add(new Edge(i, 0, 0, 0, 0));
		}
		
		for (int i = P + 1; i <= P + I; i++)
		{
			E.add(new Edge(i, P + I + 1, IArray[i - P - 1], 0, 0));
			E.add(new Edge(P + I + 1, i, 0, 0, 0));
		}
		MCMF(0, I + P + 1);
		System.out.format("%.2f to %.2f", minCost / 100.0, maxCost / 100.0);
	}
	
	public static void add(int from, int to, int cap, int flow, int weight)
	{
		/* 构造并保存边时，同时填写index */
		E.add(new Edge(from, to, cap, flow, weight));
		count++;
		index.get(from).add(count);
	}
	
	public static Edge getByNum(int from, int to, List<Edge> E)
	{
		/* 通过起点和终点确定边 */
		for (int i : index.get(from))
		{
			if (E.get(i).to == to)
			{
				return E.get(i);
			}
		}
		return null;
	}
	
	public static void MCMF(int s, int n)
	{
		while (SPFA(s, n))
		{
			int now = n, minFlow = Integer.MAX_VALUE;
			while (now != s)
			{
				/* 算出增广路径上每条边上能允许多出的最大流 */
				minFlow = Math.min(minFlow, getByNum(pre[now], now, E).cap);
				now = pre[now];
			}
			now = n;
			minCost += minFlow * dis[n];
			while (now != s)
			{
				/* 增广路径上每条边的容量减少minFlow， 反向路径则增加minFlow */
				getByNum(pre[now], now, E).cap -= minFlow;
				getByNum(now, pre[now], E).cap += minFlow;
				now = pre[now];
			}
		}
	}
	
	public static boolean SPFA(int s, int n)
	{
		/* 寻找s-n增广路径， 并用pre保存这条路径上每个节点的前节点 */
		Queue<Integer> Q = new LinkedList<Integer>();
		for (int i = 0; i < dis.length; i++)
		{
			dis[i] = Integer.MAX_VALUE;
			pre[i] = -1;
		}
		int[] count = new int[102];
		Q.add(s);
		dis[s] = 0;
		pre[s] = -1;
		count[s]++;
		while (!Q.isEmpty())
		{
			int from = Q.poll();
			for (int i : index.get(from))
			{
				if (E.get(i).cap > 0)
				{
					Edge e = E.get(i);
					int to = e.to;
					if (dis[to] > dis[from] + e.weight)
					{
						/* relax操作 */
						dis[to] = dis[from] + e.weight;
						pre[to] = from;
						if (!Q.contains(to))
						{
							Q.add(to);
							count[to]++;
							if (count[to] > n)
							{
								return false;
							}
						}
					}
				}
			}
		}
		return !(pre[n] == -1);
		/* 单纯写成 return true 则在pre数组全是-1的情况下也会return true */
	}

}

class Edge
{
	int from, to, cap, flow, weight;
	
	public Edge(int f, int t, int c, int fl, int w)
	{
		this.from = f;
		this.to = t;
		this.cap = c;
		this.flow = fl;
		this.weight = w;
	}
}