考虑一下边界问题,用另一个数组存两个着陆时间间隔,第一个存和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();
}
}
第一个水管口单独输入,其他的水管口排序,按从大到小的方式堵塞,第一个满足的情况就输出
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();
}
}
首先要知道一个事情就是,要选择其他的服务器的话,就要平均的分配,
所以,能不能负载得下,在于提供资源最小的服务器,
策略是:按照服务器能提供的资源从小到大,排序,那个先,都尝试一下,只要任意一种可能都行,
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);
}
}
}