Northwestern Europe Regional Contest 2020 NWERC 2020 （Gym 103049）

A - Atomic Energy Gym - 103049A

分析：
玄学问题。
如果k很大，很容易贪心的想到取ar[i]/i小的那个。但当k比较接近n时这样就不对了，然后。。。一开始做法是贪心取，取到k<2 * n是就不取了，对于2*n之内的，跑for循环预处理，然后wa了，然后又改成贪心到k<n,然后还wa，最后，改成贪心取到k < n * n就停下，然后就A了。
？？？？？？？？？
AC代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;

ll n, q;
ll ar[50000];
struct node
{
    double a;
    double bi;
    int id;
}br[500];
ll k;

bool cmp(node x, node y)
{
    return x.bi < y.bi;
}

int main()
{
    scanf("%lld%lld", &n, &q);
    for(int i = 1; i <= n; ++i)
    {
        scanf("%lld", &ar[i]);
        br[i].a = (double)ar[i];
        br[i].bi = br[i].a / (double)i;
        br[i].id = i;
    }
    sort(br + 1, br + n + 1, cmp);
    for(int i = n + 1; i <= n * n; ++i)
    {
        ar[i] = 0x3f3f3f3f3f3f3f3f;
        for(int j = 1; j < i; ++j)
        {
            ar[i] = min(ar[i], ar[j] + ar[i - j]);
        }
    }
    ll min_id = br[1].id;
    for(int i = 1; i <= q; ++i)
    {
        scanf("%lld", &k);
        if(k <= n * n) printf("%lld\n", ar[k]);
        else
        {
            ll x = (k - n * n) / min_id;
            while(k - min_id * x > n * n)
            {
                x++;
            }
            ll y = k - min_id * x;
            ll ans = ar[y] + x * ar[min_id];
            printf("%lld\n", ans);
        }
    }
    return 0;
}

D - Dragon Balls Gym - 103049D

分析：
首先，这是一道交互题。emmmmm。。。
然后，这个题说找到一个龙珠就会忽略这个龙珠，加上龙珠个数不多。并且到某个点的距离平方是整个且这个点的横纵坐标都是整数的点也不多。因此，每次首先询问（0，0）,然后挨着试。
AC代码：

#include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair<ll,ll> PII;
vector<PII> vt;
int n;
ll dis;
ll x, y, tmp;
ll now;

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i)
    {
        printf("0 0\n");
        cout.flush();
        scanf("%lld", &dis);
        if(dis == 0) continue;
        vt.clear();
        for(ll j = 0; j * j <= dis && j <= 1000000; ++j)
        {
            x = j * j;
            y = dis - x;
            tmp = sqrt(y);
            if(tmp > 1000000) continue;
            if(tmp * tmp == y) vt.push_back({j, tmp});
        }
        for(int j = 0; j < vt.size(); ++j)
        {
            printf("%lld %lld\n", vt[j].first, vt[j].second);
            cout.flush();
            scanf("%lld", &now);
            if(now == 0) break;
        }
    }
    return 0;
}

I - Island Tour Gym - 103049I

分析：
首先能想到，暴力枚举每个人在每个起点的情况，这很容易想到，需要O（n^3）,而判断的方法很容想到就是维护一个二维数组，表示在这三个人起点为某种状态时，每个人在每个景点开始和结束的时间，然后对于每种状态都需要判断这n个景点3个人是否有重叠的，复杂度O（n），不大行。
但如果我们采用用低维遍历的组合来优化高维遍历的思路，即预处理出bool数组check[a][b][i][j]表示a这个人起点是i，b这个人起点是j的情况下，a和b这两个人是否冲突，那这样就可以O（1）判断了。
AC代码：

#include <bits/stdc++.h>

using namespace std;
typedef pair<int, int> P;

int d[505], t[5][505];
vector<P> vis[505];
int n;
bool check[5][5][505][505];
bool flag;
int now1, now2, nowt1, nowt2;

int main()
{
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) scanf("%d", &d[i]);
    for(int i = 0; i < 3; ++i)
    {
        for(int j = 1; j <= n; ++j) scanf("%d", &t[i][j]);
    }
    for(int t1 = 0; t1 < 3; ++t1)
    {
        for(int t2 = t1 + 1; t2 < 3; ++t2)
        {
            for(int i = 1; i <= n; ++i)
            {
                for(int j = 1; j <= n; ++j)
                {
                    if(i == j) continue;
                    for(int p = 0; p <= n; ++p) vis[p].clear();
                    now1 = i - 1; now2 = j - 1;
                    nowt1 = 0; nowt2 = 0;
                    for(int p = 1; p <= n; ++p)
                    {
                        now1++; now2++;
                        if(now1 > n) now1 = 1;
                        if(now2 > n) now2 = 1;
                        vis[now1].push_back(P{nowt1, nowt1 + t[t1][now1]});
                        vis[now2].push_back(P{nowt2, nowt2 + t[t2][now2]});
                        nowt1 += t[t1][now1] + d[now1];
                        nowt2 += t[t2][now2] + d[now2];
                    }
                    flag = 0;
                    for(int i = 1; i <= n; ++i)
                    {
                        sort(vis[i].begin(), vis[i].end());
                        if(vis[i][0].second > vis[i][1].first)
                        {
                            flag = 1;
                            break;
                        }
                    }
                    if(flag) check[t1][t2][i][j] = false;
                    else check[t1][t2][i][j] = true;
                }
            }
        }
    }
    for(int i = 1; i <= n; ++i)
    {
        for(int j = 1; j <= n; ++j)
        {
            if(i == j) continue;
            for(int k = 1; k <= n; ++k)
            {
                if(k == i || k == j) continue;
                if(check[0][1][i][j] && check[0][2][i][k] && check[1][2][j][k])
                {
                    printf("%d %d %d\n", i, j, k);
                    return 0;
                }
            }
        }
    }
    printf("impossible\n");
    return 0;
}