《程序设计思维与实践》week4—作业题

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

解题思路

首先，将所有的作业按照所扣分数从大到小的顺序进行排列，分数相同的将ddl在前的放在前面；
申请一个大小为1002，所有元素值都为0的一个数组yns[ ]用来代表第n天没有被安排作业；
从第一个作业开始，一直往后遍历，对于第i个作业，从数组yns[deadline_i]开始往前，如果有为0的地方，那么这个作业就能按时完成，不会被扣分，同时将数组中这个位置的元素值置为1；

解题代码

#include <iostream>
#include <vector>
#include <list>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int T;
int N;
int S;
int D;

struct zuoye {
    int score;
    int deadline;
    
    zuoye() {score = 0; deadline = 0;}
};

bool PX(zuoye x, zuoye y) {
    if (x.score == y.score)
        return x.deadline < y.deadline;
    else
        return x.score > y.score;
}

vector<zuoye> ALL;

int panduan(vector<zuoye> A, int *yns, int sum) {
    for (vector<zuoye>::iterator i = A.begin(); i != A.end(); i++) {
        int symbol = i->deadline;
        while (symbol > 0) {
            if (yns[symbol] == 0) {
                yns[symbol] = 1;
                i->score = 0;
                break;
            }
            else
                symbol--;
        }
        sum = sum + i->score;
    }
    return sum;
}

int main()
{
    cin>>T;
    for (int a = 0; a < T; a++) {
        int sum = 0;
        cin>>N;
        int yns[1002];
        for (int b = 0; b <= 1001; b++) yns[b] = 0;
        
        zuoye z;
        for (int b = 0; b < N; b++) {
            cin>>D;
            z.deadline = D;
            ALL.push_back(z);
        }
        for (int b = 0; b < N; b++) {
            cin>>S;
            ALL[b].score = S;
        }
        sort(ALL.begin(), ALL.end(), PX);
        cout<<panduan(ALL, yns, sum)<<endl;
        ALL.clear();
    }
}

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

解题思路

由于 n <= 4000 ，所以采用枚举出所有的和的情况，必然超时；
整体代换思路：A + B + C + D = 0 => A + B = - (C + D)
将A + B的所有情况进行枚举，储存在一个vector< int > sab数组里面；
对于C + D，则是每计算出一种情况，就将这个值的相反数去 sab 中寻找；
寻找的方法： 利用二分的搜索方法，在 sab 中查找到等于- (C + D)的第一次出现位置和最后一次出现的位置，那么总共的种类数就是最后一次出现的位置数 – 第一次出现的位置数 + 1；如果没有查找到则是会返回-1；

解题代码

#include <iostream>
#include <vector>
#include <list>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int n;
int kinds = 0;

vector<int> A;
vector<int> B;
vector<int> C;
vector<int> D;

vector<int>sab;

int findF(int sum) {
    int left = 0;
    int right = sab.size() - 1;
    int ans = -1;
    while (right >= left) {
        int mid = (left + right) / 2;
        if (sab[mid] > sum) right = mid - 1;
        else if (sab[mid] == sum) {ans = mid; right = mid - 1;}
        else left = mid + 1;
    }
    return ans;
    
}

int findL(int sum) {
    int left = 0;
    int right = sab.size() - 1;
    int ans = -1;
    while (right >= left) {
        int mid = (left + right) / 2;
        if (sab[mid] > sum) right = mid - 1;
        else if (sab[mid] == sum) {ans = mid; left = mid + 1;}
        else left = mid + 1;
    }
    return ans;
}

int main() {
    cin>>n;
    int a, b, c, d;
    for (int m = 0; m < n; m++) {
        cin>>a>>b>>c>>d;
        A.push_back(a);
        B.push_back(b);
        C.push_back(c);
        D.push_back(d);
    }
    for (int l = 0; l < n; l++) {
        for (int m = 0; m < n; m++) {
            int sum = A[l] + B[m];
            sab.push_back(sum);
        }
    }
    sort(sab.begin(), sab.end());
    for (int l = 0; l < n; l++) {
        for (int m = 0; m < n; m++) {
            int sum = C[l] + D[m];
            int first = findF(-sum);
            int last = findL(-sum);
            if (first == -1 || last == -1) 
                kinds += 0;
            else
                kinds += (last - first + 1);
        }
    }
    cout<<kinds;
}

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

解题思路

利用sort函数将cat的元素从小到大进行排序，这样就避免考虑差值为负的情况下还要求其绝对值；
若已知了数组cat的数量，那么根据排列组合规则，可以得到差值的个数为 <N*(N - 1)/2>，也就可以得到中位数的名次应该为<(N * (N - 1) + 2) / 4>;
求目标中位数P：
由题意可得，Pmin = 0； Pmax = cat[N - 1] - cat[0]；即相当于二分的左端点是Pmin，右端点是Pmax；
P的名次相当与是cat[ ]中，x_i - x_j <= P的数对的数量，转换一下也就是x_i <= x_j + P，通过枚举下标 i 的值，然后计算满足条件的下标 j 的数量，即为P对应的名次；
求中位数的过程即是对于P的名次进行二分查找的过程，求Pmid的值之后求其名次，直到名次等于<(N * (N - 1) + 2) / 4>;
特别地结束循环的条件应该是（Rank >= mid_location）而不是（Rank == mid_location），因为可能会出现一个数它满足名次的条件，但是它并不存在与目标数组中；
例如：差值数组为1 1 1 3 3 3，依题意其中位数应该是1，但是可以发现2其实是满足条件的，假如判断条件是（Rank == mid_location）输出的结果是2，与题意不符；

解题代码

#include <iostream>
#include <vector>
#include <list>
#include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;

int N;
vector<int> cat;

int findL(int sum){
    int l = 0, r = cat.size() - 1, ans = -1;
    while (l <= r) {
        int mid = (l + r) / 2;
        if (cat[mid] > sum) r = mid - 1;
        else {
            ans = mid;
            l = mid + 1;
        }
    }
    return ans;
}

int RankP(int mid_location){
    int Pleft = 0;
    int Pright = cat[N - 1] - cat[0];
    int ans = -1;
    while (Pleft <= Pright) {
        int Pmid = (Pleft + Pright) / 2;
        int Rank = 0;
        for (int i = 0; i < cat.size(); i++) {
            int a = cat[i] + Pmid;
            int b = findL(a);
            if (b == -1) Rank += 0;
            else Rank += (b - i);
        }
        if (Rank >= mid_location) {
            ans = Pmid;
            Pright = Pmid - 1;
        }
        else Pleft = Pmid + 1;
    }
    return ans;
}

int main()
{
    while (scanf("%d", &N) != EOF) {
        cat.clear();
        int number;
        for (int a = 0; a < N; a++) {
            scanf("%d", &number);
            cat.push_back(number);
        }
        sort(cat.begin(), cat.end());
        int mid_location = (N * (N - 1) + 2) / 4;
        cout<<RankP(mid_location)<<endl;
    }
}