Codeforces Round #477 (rated, Div. 2, based on VK Cup 2018 Round 3)

A. Mind the Gap

考虑一下边界问题，用另一个数组存两个着陆时间间隔，第一个存和0：00的间隔，判断两个间隔是否大于两倍的着陆间隔 +1，如果所有的间隔都小于的话，安排起飞的时间就是在最后，否则输出可以起飞的最近时间+等待时间+1

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;

public class A {
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	static String next() throws IOException {
		in.nextToken();
		return (String) in.sval;
	}

	static int a[] = new int[105];
	static int b[] = new int[105];
	static int c[] = new int[105];

	public static void main(String[] args) throws IOException {
		int n, s;
		n = nextInt();
		s = nextInt();

		for (int i = 0; i < n; i++) {
			a[i] = nextInt();
			b[i] = nextInt();
		}
		c[0] = 60 * a[0] + b[0]; // 0:00 到第一个着陆的时间间隔、、
		for (int i = 1; i < n; i++) { // 记录两次着陆的间隔时间、、
			c[i] = (a[i] - a[i - 1] - 1) * 60 + 60 - b[i - 1] + b[i]; // 两次间隔额时间哈、、
		}

/*		for (int i = 0; i < n; i++) {
			out.print(c[i] + " ");
		}
		out.println();
		out.flush();*/
		boolean flag = false;
		for (int i = 0; i < n; i++) {
			if (c[0] >= s + 1) {
				out.println(0 + " " + 0);
				flag = true;
				break;
			}
			if (c[i] > 2 * s + 1) {
				flag = true;
				out.println((a[i - 1] + (s + 1 + b[i - 1]) / 60) + " " + (b[i - 1] + s + 1) % 60);
				break;
			}
		}
		if (!flag) {
			out.println(a[n - 1] + (s + 1 + b[n - 1]) / 60 + " " + (s + 1 + b[n - 1]) % 60);
		}
		out.flush();
	}

}

B： Watering System

第一个水管口单独输入，其他的水管口排序，按从大到小的方式堵塞，第一个满足的情况就输出

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class B {
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	static String next() throws IOException {
		in.nextToken();
		return (String) in.sval;
	}
	static int zz[] = new int[100005];
	public static void main(String[] args) throws IOException {
		int n, a, b;
		n = nextInt();
		a = nextInt();
		b = nextInt();
		
		int cc = nextInt(); // 输入第一个的流水的比例、、
		long s = cc;  // 总的东东、、
		for(int i = 1; i < n; i++) {
			zz[i] = nextInt();	// 输入漏水的比例、 
			s += zz[i];
		}
		
		Arrays.sort(zz, 1, n);  // 排序啊、、
		int ans = 0; // 需要堵塞  多少个管孔、、
		if(a * cc * 1.0 / s >= b) {
//			out.println((a * cc * 1.0 / s) + " " + b);
			out.println(ans);
		}else {
			for(int i = n - 1; i >= 0; i--) {
				ans++;
				s -= zz[i];
				if(a * cc * 1.0 / s >= b) {
					out.println(ans);
					break;
				}
			}
		}
		
		out.flush();
	}

}

D: Resource Distribution

首先要知道一个事情就是，要选择其他的服务器的话，就要平均的分配，

所以，能不能负载得下，在于提供资源最小的服务器，

策略是：按照服务器能提供的资源从小到大，排序，那个先，都尝试一下，只要任意一种可能都行，

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;
import java.util.Comparator;
import java.util.LinkedList;
import java.util.PriorityQueue;

public class D {
	static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

	static int nextInt() throws IOException {
		in.nextToken();
		return (int) in.nval;
	}

	static String next() throws IOException {
		in.nextToken();
		return (String) in.sval;
	}

	static Node a[];
	static int n, x1, x2;

	public static void main(String[] args) throws IOException {
		n = nextInt();
		x1 = nextInt();
		x2 = nextInt();
		a = new Node[n + 1];
		for (int i = 1; i <= n; i++) {
			int zz = nextInt();
			a[i] = new Node(zz, i);
		}
		a[0] = new Node(-1, 0);
		Arrays.sort(a);
		buile(x1, x2, true);  // 先选、
		buile(x2, x1, false);  // 后选、
		out.println("No");
		out.flush();

	}

	static void buile(int x, int y, boolean flag) {
		StringBuffer sb1 = new StringBuffer();
		StringBuffer sb2 = new StringBuffer();

		for (int i = 1; i <= n; i++) {
			int val_x1 = a[i].x;
			int servers_x1 = x / val_x1 + (x % val_x1 == 0 ? 0 : 1); // 直接选取能提供的服务器（限制是最小的） 服务1需要的服务器的数量
			if (servers_x1 + i - 1 >= n) // 在服务器的范围内
				continue;

			int val_x2 = a[i + servers_x1].x;
			int servers_x2 = y / val_x2 + (y % val_x2 == 0 ? 0 : 1); // 服务二需要的服务器的数量
			if (i + servers_x1 + servers_x2 - 1 > n) // 服务器的范围内
				continue;

			out.println("Yes");
			if (!flag) {
				out.println(servers_x2 + " " + servers_x1);
			} else {
				out.println(servers_x1 + " " + servers_x2);
			}

			int second = servers_x1;
			for (int j = i; servers_x1 > 0; j++) {
				sb1.append(a[j].index + " ");  // 存服务器的序号
				servers_x1--;
			}
			for (int j = i + second; servers_x2 > 0; j++) {
				sb2.append(a[j].index + " "); // 存服务器的序号
				servers_x2--;
			}

			if (!flag) {
				out.println(sb2);
				out.println(sb1);
			} else {
				out.println(sb1);
				out.println(sb2);
			}
			out.flush();
			System.exit(0);
		}
	}

	static class Node implements Comparable<Node> {
		int x, index; // 能提供的资源和下标

		Node() {
		}

		Node(int x, int index) {
			this.x = x;
			this.index = index;
		}

		@Override
		public int compareTo(Node o) {
			return Integer.compare(x, o.x);
		}

	}

}