A - DDL 的恐惧
题目描述
ZJM 有 n 个作业，每个作业都有自己的 DDL，如果 ZJM 没有在 DDL 前做完这个作业，那么老师会扣掉这个作业的全部平时分。
所以 ZJM 想知道如何安排做作业的顺序，才能尽可能少扣一点分。
请你帮帮他吧！
input
输入包含T个测试用例。输入的第一行是单个整数T，为测试用例的数量。
每个测试用例以一个正整数N开头(1<=N<=1000)，表示作业的数量。
然后两行。第一行包含N个整数，表示DDL，下一行包含N个整数，表示扣的分。
Output
对于每个测试用例，您应该输出最小的总降低分数，每个测试用例一行。
Sample Input
3
3
3 3 3
10 5 1
3
1 3 1
6 2 3
7
1 4 6 4 2 4 3
3 2 1 7 6 5 4
Sample Output
0
3
5
Hint
上方有三组样例。
对于第一组样例，有三个作业它们的DDL均为第三天，ZJM每天做一个正好在DDL前全部做完，所以没有扣分，输出0。
对于第二组样例，有三个作业，它们的DDL分别为第一天，第三天、第一天。ZJM在第一天做了第一个作业，第二天做了第二个作业，共扣了3分，输出3。
题解
- easy 版
- 使用贪心策略：1.尽量选价值高的任务；2.安排任务时尽量安排的靠后。于是对于
n^2的做法，我们先按照大小顺序给任务排序，然后从大到小依次取出任务，对于该任务可以安排的时间，从ddl开始往前遍历，如果可以安排，那就放在这个地方，保证合法的情况下最晚。
- 使用贪心策略：1.尽量选价值高的任务；2.安排任务时尽量安排的靠后。于是对于
- hard 版
- 贪心策略：不再根据任务找时间，而是根据时间找合适的最有价值的任务。对于
nlogn的做法，我们从最后一个时间开始一次往前遍历，对于遍历到时间t，将所有满足ddl=t的任务按照价值排序加到优先队列中，维护一个最大值，这样每次取出价值最大的放到当前时间t，直到最后时间遍历完成。
- 贪心策略：不再根据任务找时间，而是根据时间找合适的最有价值的任务。对于
代码 easy版
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 1010;
struct DDL {
int d;
int a;
}ddls[MAXN];
bool myday[MAXN];
bool cmp(const DDL x, const DDL y) {
if(x.a != y.a) return x.a < y.a;
return x.d < y.d;
}
int main() {
int T;
cin >> T;
while (T --) {
int N;
cin >> N;
for(int i = 0; i <= N; ++i) ddls[i].a = ddls[i].d = 0;
memset(myday, 0, sizeof(myday));
for (int i = 1; i <= N; ++i) {
scanf("%d", &ddls[i].d);
}
for (int i = 1; i <= N; ++i) {
scanf("%d", &ddls[i].a);
ddls[0].a += ddls[i].a;
}
sort(ddls+1,ddls+N+1,cmp);
int sum = 0;
for (int i = N; i >= 1; i--) {
for (int j = ddls[i].d; j >= 1; j--) {
if (!myday[j]) {
myday[j] = true;
sum += ddls[i].a;
break;
}
}
}
cout << ddls[0].a-sum << endl;
}
return 0;
}
代码 hard版
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int MAXN = 1010;
struct DDL {
int d;
int a;
}ddls[MAXN];
bool cmp(const DDL x, const DDL y) {
return x.d > y.d;
}
priority_queue<int> q;
int main() {
int T;
cin >> T;
while (T --) {
int N;
cin >> N;
for(int i = 0; i <= N; ++i) ddls[i].a = ddls[i].d = 0;
while(q.size()) q.pop();
for (int i = 1; i <= N; ++i) {
scanf("%d", &ddls[i].d);
ddls[0].d = max(ddls[0].d,ddls[i].d);
}
for (int i = 1; i <= N; ++i) {
scanf("%d", &ddls[i].a);
ddls[0].a += ddls[i].a;
}
sort(ddls+1,ddls+N+1,cmp);
int sum = 0, nowid = 1;
for(int t = ddls[0].d; t >= 1; t--) {
while (ddls[nowid].d == t && nowid <= N) {
q.push(ddls[nowid].a);
nowid++;
}
if (q.size()) {
sum += q.top();
q.pop();
}
}
cout << ddls[0].a-sum << endl;
}
return 0;
}
B - 四个数列
题目描述
ZJM 有四个数列 A,B,C,D，每个数列都有 n 个数字。ZJM 从每个数列中各取出一个数，他想知道有多少种方案使得 4 个数的和为 0。
当一个数列中有多个相同的数字的时候，把它们当做不同的数对待。
input
第一行：n（代表数列中数字的个数） （1≤n≤4000）
接下来的 n 行中，第 i 行有四个数字，分别表示数列 A,B,C,D 中的第 i 个数字（数字不超过 2 的 28 次方）
Output
输出不同组合的个数。
Sample Input
6
-45 22 42 -16
-41 -27 56 30
-36 53 -37 77
-36 30 -75 -46
26 -38 -10 62
-32 -54 -6 45
Sample Output
5
题解
- 对于
a[i]+b[i]+c[i]+d[i] = 0，变换形式得到a[i]+b[i] = -(c[i]+d[i])，即其中两组数的和等于另外两组数的相反数，我们可以分别预处理出ab和cd的和，然后给ab组排序，这样在对于每一个cd[j]，我们都能在ab组中二分的查找符合条件的值的个数。时间复杂度为n^2logn. - 在二分查找时，先找到符合条件的最左端和最右端，然后
r-l+1便是个数。
代码
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>
using namespace std;
const int MAXN = 4000+10;
int tot = 0;
int a[MAXN], b[MAXN], c[MAXN], d[MAXN];
int ab[MAXN*MAXN];
int cd[MAXN*MAXN];
int find_l(int x) {
x = -x;
int l = 1, r = tot;
int mid = (l+r)>>1;
int res = -1;
while (l <= r) {
mid = (l+r)>>1;
if (x == ab[mid]) {
res = mid;
r = mid-1;
} else if (x < ab[mid]) {
r = mid-1;
} else if (x > ab[mid]) {
l = mid+1;
}
}
return res;
}
int find_r(int x) {
x = -x;
int l = 1, r = tot;
int mid = (l+r)>>1;
int res = -1;
while (l <= r) {
mid = (l+r)>>1;
if (x == ab[mid]) {
res = mid;
l = mid+1;
} else if (x < ab[mid]) {
r = mid-1;
} else if (x > ab[mid]) {
l = mid+1;
}
}
return res;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d%d",&a[i],&b[i],&c[i],&d[i]);
}
for(int i = 1; i <= n; ++i) {
for(int j = 1; j <= n; ++j) {
ab[++tot] = a[i]+b[j];
cd[tot] = c[i]+d[j];
}
}
int ans = 0;
sort(ab+1,ab+tot+1);
for(int i = 1; i <= tot; ++i) {
// cout << ab[i] << " " << cd[i] << endl;
int l = find_l(cd[i]);
int r = find_r(cd[i]);
// cout << l << " and " << r << endl;
if(l == -1 || r == -1) continue;
ans += r-l+1;
}
cout << ans << endl;
return 0;
}
C - TT 的神秘礼物
题目描述
TT 是一位重度爱猫人士，每日沉溺于 B 站上的猫咪频道。
有一天，TT 的好友 ZJM 决定交给 TT 一个难题，如果 TT 能够解决这个难题，ZJM 就会买一只可爱猫咪送给 TT。
任务内容是，给定一个 N 个数的数组 cat[i]，并用这个数组生成一个新数组 ans[i]。新数组定义为对于任意的 i, j 且 i != j，均有 ans[] = abs(cat[i] - cat[j])，1 <= i < j <= N。试求出这个新数组的中位数，中位数即为排序之后 (len+1)/2 位置对应的数字，’/’ 为下取整。
TT 非常想得到那只可爱的猫咪，你能帮帮他吗？
input
多组输入，每次输入一个 N，表示有 N 个数，之后输入一个长度为 N 的序列 cat， cat[i] <= 1e9 , 3 <= n <= 1e5
Output
输出新数组 ans 的中位数
Sample Input
4
1 3 2 4
3
1 10 2
Sample Output
1
8
题解
- 思路：先考虑暴力求解的复杂度，互相求差的绝对值，时间复杂度是
O(n)，会超时不可取。令两两相减生成的数组叫ans。我们观察中位数的特性，发现只要我们将原数组从小到大排序，然后按照顺序加减，我们就能得到对于某个数x来说ans数组里小于x的有多少个元素，而又因为ans数组有序，所以可以二分解决，复杂度可以为O(log(1e6)*n*logn)。 - 实现细节：先二分答案，下届为
0，上届为1e6，因为最大的数才1e5肯定够用。然后对于每一个mid进行check：计算这个在ans数组里，找出严格小于mid的的数字个数有k个，令m为我们ans数组中的中位数个数，如果k < m，即严格小于mid的的数字小于中位数应有的位数，表示mid刚好在中位数位置或者在中位数位置之前，偏小，那么返回1，在外层二分中令 左区间等于mid+1，朝右扩展。反之，朝左扩展。 - 二分边界问题：写的时候发现这个地方是自己知识的一个漏洞，之前写的时候非常麻烦的判断边界问题，这次参照了市面上的所有二分写法，最终选择如 https://www.zhihu.com/question/36132386 所示的二分问题写法：即
l,r分别用来逼近答案和缩小区间。在这个题中，如果不满足条件，那么就l=mid+1缩小区间，满足的话r=mid来逼近。最终符合条件的是mid 或 r。特别注意的一点：这时计算mid的时候要l + (r-l+1)/2否则会因为mid一直==l，而又check==1所以死循环。 - 类似的二分还可以有另外一种写法：用l逼近区间，r来缩小区间，但是这时候注意是左闭右开的，就是那mid正常写就可了。然后结果l-1的原因：观察最后小区间的状态可以得知：当我们检查到
mid，mid是中位数时，因为mid前面的严格小于的元素个数是小于mid所在的位置的，所以会执行l = mid+1，这一句话，所以最终的状态是 l-1 为最后我们检查合法的元素。 - 参考
- https://www.zhihu.com/question/36132386
- https://blog.csdn.net/OCEANtroye/article/details/82811432
- https://blog.csdn.net/yefengzhichen/article/details/52372407?depth_1-utm_source=distribute.pc_relevant.none-task&utm_source=distribute.pc_relevant.none-task
代码1
#include <iostream>
#include <cstdio>
#include <cstring>
#include <queue>
#include <map>
#include <algorithm>
using namespace std;
const int MAXN = 1e5+10;
int n, nums;
int cat[MAXN];
// 0 1 2 3 4 5 6 7 8 9
// 2 3 6 7 9 9 9 9 9 9
// // // / / / / // / /
// 1 2 3 4 5 6 7 8 9 10
// 2 3 6 7 9 9 9 9 9 9
bool check(int x) {
// 目的：找到在cat数组里，两数之差小于x的个数，即找满足 a[j]-a[i] < x 的个数，个数多说明x过大，个数少说明x小
// 也就是对于每一个i来说，要找到刚好满足条件的位置，j~n全是可以的。 a[j] < a[i]+x;
// cout << " - - - - - - - - - x = " << x << endl;
int sum = 0;
for (int i = 0; i < n; ++i) {
// cout << "t = " << cat[i]+x << endl;
// cout << "juedui:" << lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat) << ",posi = " << lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat+i+1) << endl;
int posi = lower_bound(cat+i+1, cat+n, cat[i]+x)-(cat+i+1); //在他前面的数的个数
sum += posi;
// cout << posi << ",";
}
// cout << endl;
// cout << "sum = " << sum << endl;
return sum < nums;
}
int main() {
while (cin >> n) {
nums = n*(n-1)/2;
nums = (nums+1)/2; // 中位数的位置
// cout << "mid:" << nums << endl;
memset(cat, 0, sizeof(cat));
for (int i = 0; i < n; ++i) {
scanf("%d", &cat[i]);
}
sort(cat,cat+n);
int l = 0, r = 1e6;
int mid = l+r >> 1;
int ans = 0;
while (l < r) {
mid = l + (r-l+1)/2;
// cout << l << ", " << mid << ", " << r << endl;
// cout << "now mid = " << mid << endl;
// 严格小于的个数小于真正中位数的位置
if (check(mid)) { // 如果这个数前面数字达不到中位数个数的情况// 前面如果有小于等于 nums 个数。这个数一定不行
l = mid;
} else {// 这个数字可能彳亍
r = mid-1;
}
}
// l-1的原因：观察最后小区间的状态可以得知：当我们检查到mid，mid是中位数时，因为mid前面的严格小于的元素个数是小于mid所在的位置的，
// 所以会执行 l = mid+1，这一句话，所以最终的状态是 l-1 为最后我们检查合法的元素。
printf("%d\n",l);
}
return 0;
}
代码2
while (l < r) {
mid = l + (r-l)/2;
// cout << l << ", " << r << "mid = " << mid << endl;
// cout << "now mid = " << mid << endl;
if (check(mid)) { // 如果这个数前面数字达不到中位数个数的情况// 前面如果有小于等于 nums 个数。这个数一定不行
l = mid+1;
} else {// 这个数字可能彳亍
r = mid;
}
}
printf("%d\n",l-1);