巨石滚滚
帕秋莉掌握了一种土属性魔法
她使用这种魔法建造了一个大型的土球,并让其一路向下去冲撞障碍
土球有一个稳定性x,如果x < 0,它会立刻散架
每冲撞一个障碍,土球会丧失ai的稳定性,冲撞之后,又会从障碍身上回馈bi的稳定性
帕秋莉想知道,如果合理的安排障碍的顺序,在保证土球不散架的情况下,是否可以将障碍全部撞毁呢?
输入描述:
输入一个整数T,代表T组数据,每组数据中:
前一行两个整数n , m,表示障碍个数和土球的稳定性
接下来一行两个整数,分别表示障碍的ai和bi
输出描述:
若可以,输出“Yes”(不含引号),否则输出“No”(不含引号)
示例1
输入
复制
1
5 50
49 49
52 0
5 10
26 24
70 70
输出
复制
No
备注:
Σn <= 500000, 1<=m<=100000,0<=a,b<=100000
大致做法就是贪心,排序。然后模拟。
这道题最大的问题就是 Comparable比较器条件如何写,它要满足,回馈-损失 最大,并且这个差值为正数的时候,损失最小的要排在前面,这个差值为负数时,价值最大的要排在前面,所以比较条件不止一个
//key为损失价值,value为回馈价值,m为两者的差值
//自定义的比较器(比较规则)
@Override
public int compareTo(Boo2 o) {
//冲撞回馈后为正价值,按照损失小的排前面
if(this.m>=0&&o.m>=0) return (int) (this.key-o.key);
//冲撞回馈后为负价值,按照价值大的排前面
if(this.m<0&&o.m<0) return (int) (o.value-this.value);
//否则回馈-冲撞 大的排前面
return (int) (o.m-this.m);
}
详细代码:
/**
* 测试数据
1
5 50
20 40
80 200
30 104
33 22
100 5
*/
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;
public class 巨石滚滚 {
static Boo2[] arr=new Boo2[(int) (5e5+10)];
static long t,m;
static int n;
//java的快读
static StreamTokenizer in=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
static long nexlong() throws IOException {in.nextToken();return (long) in.nval;}
public static void main(String[] args) throws IOException {
t=nexlong();
n1: while (t-- >0){
n= (int) nexlong();
m=nexlong();
for (int i = 1; i <=n; i++) {
long a=nexlong();
long b=nexlong();
//读入损失,回馈,和差值存放在外部类里面
arr[i]=new Boo2(a,b,b-a);
}
//外部类里面重写了比较器这里sort一下
//注意这个比较器是这道题的重点
Arrays.sort(arr,1, n+1);
//模拟一下
for (int i = 1; i <=n; i++) {
//根据题意判断
if(m>arr[i].key) m=m-arr[i].key+arr[i].value;
else {
System.out.println("No");
continue n1;
}
}
System.out.println("Yes");
}
}
}
class Boo2 implements Comparable<Boo2>{
long key;
long value;
long m;
Boo2(long key,long value,long m){
this.key=key;
this.value=value;
this.m=m;
}
@Override
public String toString() {
return "Boo2{" +
"key=" + key +
", value=" + value +
'}';
}
//自定义的比较器(比较规则)
@Override
public int compareTo(Boo2 o) {
//冲撞回馈后为正价值,按照损失小的排前面
if(this.m>=0&&o.m>=0) return (int) (this.key-o.key);
//冲撞回馈后为负价值,按照价值大的排前面
if(this.m<0&&o.m<0) return (int) (o.value-this.value);
//否则回馈-冲撞 大的排前面
return (int) (o.m-this.m);
}
}