Oriol和David

最新推荐文章于 2024-07-25 21:13:04 发布

暴躁的梁小忠

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量402

点赞数 4

文章标签：算法数据结构 c语言 c++

本文链接：https://blog.csdn.net/qq_62898666/article/details/139608937

版权

Oriol 和 David 在一个边长为 16 单位长度的正方形区域内，初始位置分别为（7, 7）和（8, 8）。现在有 20 组、每组包含 20 个位置需要他们访问，位置以坐标（x, y）的形式给出，要求在时间 120 秒内访问尽可能多的点。（x和y均为正整数，且0 ≤ x < 16，0 ≤ y < 16）

注意事项：

针对任意一个位置，Oriol或David中的一人到达即视为访问成功；
Oriol和David必须从第 1 组位置开始访问，且必须访问完第 i 组全部20个位置之后，才可以开始第 i + 1 组 20 个位置的访问。同组间各位置的访问顺序可自由决定；
Oriol和David在完成当前组位置的访问后，无需返回开始位置、可以立即开始下一组位置的访问；
Oriol和David可以向任意方向移动，移动时速率为 2 单位长度/秒；移动过程中，无任何障碍物阻拦。

输入格式:

输入第一行是一个正整数 T (T ≤ 10)，表示数据组数。接下来给出 T 组数据。

对于每组数据，输入包含 20 组，每组 1 行，每行由 20 个坐标组成，每个坐标由 2 个整数 x 和 y 组成，代表 Oriol 和 David 要访问的 20 组 20 个位置的坐标；0 ≤ x < 16，0 ≤ y < 16，均用一个空格隔开。

输出格式:

每组数据输出的第一行是一个整数N，代表分配方案访问过的位置组数；

接下来的N组每组的第一行包含两个整数 Ba 和 Bb，分别代表每组分配方案中 Oriol 和 David 负责访问的位置数，第二行和第三行分别包含 Ba 和 Bb 个整数 i，分别代表 Oriol 和 David 负责访问的位置在组内的序号（从0开始计数）。

0 ≤ N ≤ 20，0 ≤ Ba ≤ 20，0 ≤ Bb ≤ 20，0 ≤ i ≤ 19。

输入样例:

1
5 5 3 13 8 7 13 6 6 11 2 0 1 14 9 15 8 9 3 12 4 6 2 10 2 5 4 9 4 1 15 0 11 4 10 0 15 5 10 14
1 0 14 8 0 7 6 8 4 12 12 8 9 8 10 14 9 4 13 4 9 1 2 1 0 2 11 10 7 15 9 6 13 11 3 5 4 5 10 7
7 3 8 13 15 0 5 4 2 8 7 14 4 13 11 1 8 15 4 5 4 7 7 10 6 7 13 4 6 2 9 13 1 12 10 7 10 5 5 11
5 8 12 12 11 5 12 9 2 2 11 15 5 14 0 0 14 0 2 5 7 3 10 1 2 8 4 2 4 8 9 14 1 11 1 9 15 7 3 3
1 9 10 14 7 3 15 5 5 15 3 2 12 11 8 10 3 3 11 5 7 4 6 11 6 1 4 10 11 13 12 4 3 4 1 3 7 5 13 11
3 11 9 8 12 9 14 10 11 13 5 5 4 11 1 12 13 2 10 14 5 15 10 15 11 0 3 6 7 11 4 9 15 0 12 14 10 10 13 11
10 4 9 12 0 13 6 6 7 10 11 15 6 14 1 2 4 9 8 5 4 0 13 11 5 3 13 3 9 8 2 4 13 14 12 12 14 2 8 15
2 8 4 9 13 10 8 5 2 13 12 6 4 4 10 6 14 13 11 5 12 1 6 0 11 2 8 15 12 4 13 8 8 2 9 7 7 13 0 9
0 0 4 0 2 3 10 2 7 3 9 4 2 13 11 11 1 8 11 15 11 2 8 11 10 15 7 9 13 15 15 10 1 2 11 9 14 6 5 5
2 13 6 8 7 14 8 5 15 14 5 6 4 10 14 12 3 14 0 5 4 1 0 14 13 14 12 5 5 9 1 2 2 12 4 8 1 15 7 11
10 5 15 7 6 8 11 10 7 13 14 0 12 2 9 12 4 5 3 8 8 13 7 12 15 15 12 9 15 6 14 3 9 6 15 12 7 9 4 15
0 10 6 2 3 2 6 3 14 6 10 13 3 10 15 9 10 0 7 0 14 15 1 2 13 9 11 11 10 3 6 13 0 14 11 2 9 8 15 5
3 9 13 11 1 1 0 9 5 4 4 9 4 13 10 1 12 11 4 2 0 4 1 7 4 10 4 0 2 1 2 0 13 2 11 10 0 5 15 3
15 11 8 1 12 5 8 5 7 5 7 7 2 4 0 4 7 3 12 6 9 15 5 12 14 11 15 10 8 11 4 10 4 14 13 10 4 4 2 12
9 12 15 13 0 12 0 14 3 1 10 15 15 11 1 12 3 0 5 2 15 10 8 4 9 1 8 0 1 13 2 7 12 13 14 10 6 0 13 15
13 7 14 15 9 4 8 2 7 3 7 11 2 13 5 0 13 5 4 0 12 2 3 2 11 15 9 2 9 7 3 7 4 5 14 5 14 12 9 13
12 11 2 14 2 6 6 12 5 15 13 11 2 0 9 13 7 1 7 11 4 4 2 10 0 8 5 3 6 13 2 7 2 15 6 8 3 5 8 11
12 5 9 9 4 14 3 2 14 2 2 1 9 11 8 10 2 14 12 15 0 13 4 7 0 0 0 6 0 1 4 13 4 3 3 10 15 2 10 10
11 15 8 5 6 15 9 8 2 7 15 14 1 10 14 6 13 6 0 15 4 1 3 12 7 8 12 4 0 10 7 10 0 14 13 5 11 1 15 6
1 12 13 14 6 12 9 0 6 8 3 15 5 4 4 2 15 10 3 6 13 12 8 4 15 3 1 5 7 1 6 14 8 6 2 6 11 3 4 4

输出样例:

2
10 10
1 2 3 4 5 6 7 8 9 0
11 12 13 14 15 16 17 18 19 10
1 19
1
0 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 10

注意：样例只代表格式，不具有特别含义。

评分方式：

本题按照你给出的方案的优良程度评定分数。

具体评分规则如下：

本题所有数据点输入均为一样的数据；
评分时，假定输入有 X 组数据，则你的评分答案为你的程序在所有 X 组数据中答案的平均值；
例如，你对 3 组数据，分别访问了 3 个、5 个、8 个点，则你的评分答案为 5.33333...
特别的，如果你输出的答案中有任意一组不合法，则你的评分答案恒定为 0；
输出方案行走超过 120 秒仍然合法，答案计算时只计算 120 秒内的部分；
评测时，从 0 开始的测试点的标准答案依次增大，只有评分答案超过标准答案时，你才可以得到对应测试点的分数。

不合法的情况如下：

输出格式不正确；
重复访问自己已访问的点；（但可以经过）
访问不存在的点。

部分评分标准答案如下：

第 0 号点：20；（即需要访问平均 20 个点才可以获得该点分数）
第 1 号点：70；（同上）
第 2 号点：90；
第 7 号点：150。

#include <stdio.h>
#include <math.h>
#include <utility>
#include <vector>
#include <algorithm>
using namespace std;

#include <stdio.h>
#include <string.h>
#include <assert.h>
FILE *input, *solution, *output;


#define N (20)
#define PB push_back
#define eps (1e-6)
typedef vector<int> intArray;

vector<int> va[N+2], vb[N+2];

struct point {
    double x, y;
    point(): x(0), y(0) {}
    point(double x, double y): x(x), y(y) {}
    void set(const point &t) {
        x = t.x, y = t.y;
    }
    void set(double _x, double _y) {
        x = _x, y = _y;
    }
    void read() {
        fscanf(input, "%lf%lf", &x, &y);
    }
} pt[N+2][N+2], a, b;

inline double sqr(double x) {
    return x*x;
}
inline double dis(const point &a, const point &b) {
    return sqrt(sqr(a.x-b.x)+sqr(a.y-b.y));
}
int getClosest(const point &a, const point *pt, const int *f) {
    int res = -1;
    for (int i = 0; i < N; ++i) {
        if (!f[i]) {
            if (res == -1) {
                res = i;
            }
            else {
                if (dis(pt[i], a) < dis(pt[res], a)) {
                    res = i;
                }
            }
        }
    }
    return res;
}

const point* splitSegment(const point &a, const point &b, double p, double q) {
    return new point((a.x*q+b.x*p)/(p+q), (a.y*q+b.y*p)/(p+q));
}

double totalTime = 0;
double endTime = 120;

double getTime(const point &a, const point &b, const point *pt, const intArray &va, const intArray &vb) {
    double ta = va.size() > 0 ? dis(a, pt[va[0]]) : 0, tb = vb.size() > 0 ? dis(b, pt[vb[0]]) : 0;
    for (int i = 1; i < va.size(); ++i) {
        ta += dis(pt[va[i]], pt[va[i-1]]);
    }
    for (int i = 1; i < vb.size(); ++i) {
        tb += dis(pt[vb[i]], pt[vb[i-1]]);
    }
    return max(ta, tb) / 2;
}

int getRest(const point &a, const point &b, const point *pt, const intArray &va, const intArray &vb) {
    double ta = va.size() > 0 ? dis(a, pt[va[0]]) / 2 : 0, tb = vb.size() > 0 ? dis(b, pt[vb[0]]) / 2 : 0;
    double restTime = endTime - totalTime;
    int ans = (va.size() > 0 && ta < restTime) + (vb.size() > 0 && tb < restTime);
    int ff[30] = {};
    
    for (int i = 1; i < va.size(); ++i) {
        if ((ta += dis(pt[va[i]], pt[va[i-1]]) / 2) < restTime) {
            if (!ff[va[i]]) {
                ans++;
                ff[va[i]] = 1;
            }
        } else {
            break;
        }
    }
    for (int i = 1; i < vb.size(); ++i) {
        if ((tb += dis(pt[vb[i]], pt[vb[i-1]]) / 2) < restTime) {
            if (!ff[vb[i]]) {
                ans++;
                ff[vb[i]] = 1;
            }
        } else {
            break;
        }
    }
    return ans;
}

int f[N+2][N+2];

double time = 0;

void work(const point *pt, int f[], intArray &va, intArray &vb) {
    int ta = -1, tb = -1, cnt = 0;
    double disa = 0, disb = 0;
    while (cnt < N) {
        // a arrives at ta -> set next target
        if (ta == -1 || (disa = dis(a, pt[ta])) < eps) {
            disa = dis(pt[ta = getClosest(a, pt, f)], a);
            if (ta != -1 && time + disa / 2 < endTime) {
                f[ta] = 1;
                va.PB(ta);
                cnt++;
            }
        }
        // b arrives at tb -> set next target
        if (tb == - 1 || (disb = dis(b, pt[tb])) < eps) {
            disb = dis(pt[tb = getClosest(b, pt, f)], b);
            if (tb != -1 && time + disb / 2 < endTime) {
                f[tb] = 2;
                vb.PB(tb);
                cnt++;
            }
        }
        // move
        if (disa < disb) {
            a.set(pt[ta]);
            b.set(*splitSegment(b, pt[tb], disa, disb-disa));
            time += disa / 2;
            // printf("a move to %f %f, b move to %f %f, time %f\n", a.x, a.y, b.x, b.y, time);
        }
        else {
            b.set(pt[tb]);
            a.set(*splitSegment(a, pt[ta], disb, disa-disb));
            time += disb / 2;
            // printf("a move to %f %f, b move to %f %f, time %f\n", a.x, a.y, b.x, b.y, time);
        }
    }
    
    a.set(pt[va[va.size() - 1]]);
    b.set(pt[vb[vb.size() - 1]]);
}

void print() {
    int n = 0;
    for (; n < N; ++n) {
        int ok = 0;
        for (int j = 0; j < N; ++j) {
            ok |= f[n][j];
        }
        if (!ok) {
            break;
        }
    }
    printf("%d\n", n);
    for (int i = 0; i < n; ++i) {
        printf("%d %d\n", va[i].size(), vb[i].size());
        for (int j = 0; j < va[i].size(); ++j) {
            printf("%d%c", va[i][j], " \n"[j == va[i].size() - 1]);
        }
        for (int j = 0; j < vb[i].size(); ++j) {
            printf("%d%c", vb[i][j], " \n"[j == vb[i].size() - 1]);
        }
    }
}

void my_assert(bool x, const char* err) {
    if (!x) {
        fprintf(stderr, "%s\n", err);
        exit(1);
    }
}

int main(int argc, char** argv) {
    input = fopen("input", "r");
    output = fopen("output", "r");
    solution = fopen("user_output", "r");
    int valve = 300;
    fscanf(output, "%d", &valve);
    my_assert(valve >= 0 && valve <= 300, "valve should be in [0, 300]");
    if (input && solution) {
        int number;
        fscanf(input, "%d", &number);
        my_assert(number >= 0 && number <= 10, "case number should be in [0, 10]");
        int res = 0;
        for (int _ = 0; _ < number; ++_) {
            for (int i = 0; i < N; ++i) {
                for (int j = 0; j < N; ++j) {
                    pt[i][j].read();
                    f[i][j] = 0;
                    va[i].clear();
                    vb[i].clear();
                }
            }
            
            int n = 0;
            fscanf(solution, "%d", &n);
            my_assert(0 <= n && n <= N, "n should be in [0, 20]");
            for (int i = 0, sa, sb; i < n; ++i) {
                fscanf(solution, "%d%d", &sa, &sb);
                my_assert((sa >= 0 && sa <= N && sb >= 0 && sb <= N), "sa and sb should be in [0, 20]");
                int f[N+4] = {};
                for (int j = 0, x; j < sa; ++j) {
                    fscanf(solution, "%d", &x);
                    my_assert((x >= 0 && x < N && (f[x] & 1) == 0), "a index range error or duplicate");
                    va[i].PB(x);
                    f[x] |= 1; 
                }
                for (int j = 0, x; j < sb; ++j) {
                    fscanf(solution, "%d", &x);
                    // assert(f[x] == 0);
                    my_assert((x >= 0 && x < N && (f[x] & 2) == 0), "b index range error or duplicate");
                    vb[i].PB(x);
                    f[x] |= 2;
                }
            }
            totalTime = 0;
            a.set(7.0,7.0);
            b.set(8.0,8.0);
            for (int i = 0; i < n; ++i) {
                totalTime += getTime(a, b, pt[i], va[i], vb[i]);
                int tot = 0;
                int ff[30] = {};
                for (auto ia: va[i]) {
                    ff[ia] = 1;
                }
                for (auto ib: vb[i]) {
                    ff[ib] = 1;
                }
                for (int j = 0; j < 20; ++j) {
                    tot += ff[j];
                }
                if (totalTime > endTime || tot < 20) {
                    totalTime -= getTime(a, b, pt[i], va[i], vb[i]);
                    tot = getRest(a, b, pt[i], va[i], vb[i]);
                    printf("%d\n", tot);
                    res += i*20 + tot;
                    break;
                }
                if (va[i].size() > 0) a.set(pt[i][va[i][va[i].size() - 1]]);
                if (vb[i].size() > 0) b.set(pt[i][vb[i][vb[i].size() - 1]]);
            }
            printf("Total time: %f\n", totalTime);
        }
        printf("Score: %f\n", res / (double) number);
        return res < valve * number;
    }
}

暴躁的梁小忠

关注

4
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
1
评论
Oriol和David

Oriol 和 David 在一个边长为 16 单位长度的正方形区域内，初始位置分别为（7, 7）和（8, 8）。现在有 20 组、每组包含 20 个位置需要他们访问，位置以坐标（x, y）的形式给出，要求在时间 120 秒内访问尽可能多的点。（x和y均为正整数，且0 ≤ x < 16，0 ≤ y < 16）
复制链接

扫一扫