CCF 201809-4 再卖菜 Java

问题描述
　　在一条街上有n个卖菜的商店，按1至n的顺序排成一排，这些商店都卖一种蔬菜。
　　第一天，每个商店都自己定了一个正整数的价格。店主们希望自己的菜价和其他商店的一致，第二天，每一家商店都会根据他自己和相邻商店的价格调整自己的价格。具体的，每家商店都会将第二天的菜价设置为自己和相邻商店第一天菜价的平均值（用去尾法取整）。
　　注意，编号为1的商店只有一个相邻的商店2，编号为n的商店只有一个相邻的商店n-1，其他编号为i的商店有两个相邻的商店i-1和i+1。
　　给定第二天各个商店的菜价，可能存在不同的符合要求的第一天的菜价，请找到符合要求的第一天菜价中字典序最小的一种。
　　字典序大小的定义：对于两个不同的价格序列(a1, a2, …, an)和(b1, b2, b3, …, bn)，若存在i (i>=1), 使得ai<bi，且对于所有j<i，aj=bj，则认为第一个序列的字典序小于第二个序列。
输入格式
　　输入的第一行包含一个整数n，表示商店的数量。
　　第二行包含n个正整数，依次表示每个商店第二天的菜价。
输出格式
　　输出一行，包含n个正整数，依次表示每个商店第一天的菜价。
样例输入
8
2 2 1 3 4 9 10 13
样例输出
2 2 2 1 6 5 16 10
数据规模和约定
　　对于30%的评测用例，2<=n<=5，第二天每个商店的菜价为不超过10的正整数；
　　对于60%的评测用例，2<=n<=20，第二天每个商店的菜价为不超过100的正整数；
　　对于所有评测用例，2<=n<=300，第二天每个商店的菜价为不超过100的正整数。
　　请注意，以上都是给的第二天菜价的范围，第一天菜价可能会超过此范围。
思路解析
　　该题采用差分约束与SPFA方法。
代码如下

import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Java_201809_4 {
	static int n, index = 0;
	static int head[], dist[];
	static boolean[] visited;
	static Edge edges[];

	public static void main(String[] args) {
		head = new int[306];
		dist = new int[306];
		visited = new boolean[306];
		edges = new Edge[2006];
		Arrays.fill(head, -1);
		// edges不能用Arrays.fill(edges,new Edge())赋值!!!!!
		for(int i = 0; i < 2006; i++) {
			edges[i] = new Edge();
		}

		Scanner scanner = new Scanner(System.in);
		n = scanner.nextInt();
		int[] a = new int[306];
		for (int i = 1; i <= n; i++) {
			a[i] = scanner.nextInt();
		}
		scanner.close();
		
		
		for (int i = 0; i < n - 2; i++) {
			addEdge(i + 3, i, -(a[i + 2] * 3 + 2));
			addEdge(i, i + 3, a[i + 2] * 3);
		}		
		addEdge(2, 0, -(a[1] * 2 + 1)); // 对开始两个单独处理
		addEdge(0, 2, a[1] * 2);
		addEdge(n, n - 2, -(a[n] * 2 + 1));// 对结尾两个单独处理
		addEdge(n - 2, n, a[n] * 2); 
		for (int i = 1; i <= n; i++) // 每个数都要大于等于1
			addEdge(i - 1, i, 1); 
		
		spfa();
	
		a[1] = dist[1];
		for (int i = 2; i < n + 1; i++)
			a[i] = dist[i] - dist[i - 1];
		for (int i = 1; i <= n; i++) {
			System.out.print(a[i] + " ");
		}
	}

	
	static void spfa() {
		Queue<Integer> queue = new LinkedList<>();
		for (int i = 0; i <= n; i++) {
			queue.offer(i);
			visited[i] = false;
			dist[i] = 0;
		}
		while (!queue.isEmpty()) {
			int x = queue.poll();
			visited[x] = false;
			for (int i = head[x]; i != -1; i = edges[i].next) {
				int nx = edges[i].to;
				if (dist[nx] < dist[x] + edges[i].weight) {
					dist[nx] = dist[x] + edges[i].weight;
					if (!visited[nx]) {
						visited[nx] = true;
						queue.offer(nx);
					}
				}
			}
		}
	}

	static void addEdge(int x, int y, int w) {
		edges[index].to = y;
		edges[index].next = head[x];
		edges[index].weight = w;
		head[x] = index;
		index++;
	}

	static class Edge {
		int to; // 边的另一个节点
		int next; // 节点的下一条边
		int weight; // 权值
	}
}