1. 技术文章
  2. Hello 2020

Hello 2020

由 时光总嘲笑我的痴心妄想 提交于 2020-01-07 02:01:04

A - New Year and Naming

题意：没看懂韩国是在搞啥，感觉像是天干地支。

题解：就是天干地支。

string s[505], t[505];
string res[250005];
 
void test_case() {
    int n, m;
    cin >> n >> m;
    for(int i = 0; i < n; ++i)
        cin >> s[i];
    for(int j = 0; j < m; ++j)
        cin >> t[j];
    int lcm = n * m / __gcd(n, m);
    int i = 0, j = 0;
    for(int k = 0; k < lcm; ++k) {
        res[k] = s[i] + t[j];
        ++i;
        ++j;
        if(i % n == 0)
            i = 0;
        if(j % m == 0)
            j = 0;
    }
    int q;
    cin >> q;
    while(q--) {
        int y;
        cin >> y;
        --y;
        y %= lcm;
        cout << res[y] << endl;
    }
}

B - New Year and Ascent Sequence

题意：给n个序列，要求先从n个里面选第一个串x，再（可以重复地）从n个里面选出第二个串y，求x+y串里面有顺序对的选法有几种。

题解：很显然需要统计一下每个序列的最大值与最小值，当y序列的最大值比x序列的最小值大的时候就一定有解。这样统计漏了一些情况：本身x或者y是有顺序对的，但是y的最大值比x的最小值小。所以要区分这几种情况。

一个简单的方法是，先把自己就有顺序对的序列全部去掉，剩下的就全部都是不严格降的序列，这里就要求一定要y的最大值比x的最小值大。被去掉的cnt个自己有顺序对的，会贡献cnt*n+n*cnt-cnt*cnt个。

int cntmi[2000005];
int cntma[2000005];
bool suc[2000005];
int cntsuc = 0;
 
void test_case() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        int l, t;
        scanf("%d%d", &l, &t);
        int mi = t, ma = t, pt = t;
        for(int j = 2; j <= l; ++j) {
            scanf("%d", &t);
            if(t > ma)
                ma = t;
            if(t < mi)
                mi = t;
            if(t > pt)
                suc[i] = 1;
            pt = t;
        }
        cntma[i] = ma;
        if(!suc[i])
            ++cntmi[mi];
        cntsuc += suc[i];
    }
    for(int i = 1; i <= 2000000; ++i)
        cntmi[i] += cntmi[i - 1];
    /*for(int i=1;i<=100;++i)
        printf("cntmi[%d]=%d\n",i,cntmi[i]);*/
    ll sum = 0;
    for(int i = 1; i <= n; ++i) {
        if(!suc[i])
            sum += cntmi[cntma[i] - 1];
        //printf("i=%d ans=%lld\n",i,sum);
    }
    sum += 2ll * n * cntsuc - 1ll * cntsuc * cntsuc;
    printf("%lld\n", sum);
}

C - New Year and Permutation

题意：给一个n，计算n的所有不同排列（共有n!种不同的排列）中，满足下面条件的“子区间（subsegment）”的数量。这里的“子区间”是指从前面以及后面删除>=0个元素得到的。对于不同的排列相同下标[l,r]的也是不同的子区间。

条件：最大值-最小值=区间长度

题解：

题目要求，先枚举所有排列，然后枚举所有子区间，然后统计。

尝试改变求和顺序，先枚举所有子区间，特别地，按长度来枚举。

枚举长度为1的子区间，选择1个数进入此区间，有n种选法，1个元素在里面随便排，有1!种排法，其他元素在外面随便排，有(n-1)!种排法，其他元素形成的空位（含两端）有n个，要求子区间连续所以只能选同一个空位插入整个子区间。

所以长度为1的子区间的贡献为：n*1!*n!

枚举长度为2的子区间，选择2个数进入此区间，但是不能乱选，要求不重不漏，所以选择一个数x作为最小值，另一个数就是x+1作为最大值，x有n-1种选法，2个元素在里面随便排，有2!种排法，其他元素在外面随便排，有(n-2)!种排法，其他元素形成的空位（含两端）有n-1个，要求子区间连续所以只能选同一个空位插入整个子区间。

所以长度为1的子区间的贡献为：(n-1)*2!*(n-1)!

...

枚举长度为n的子区间，这样的明显是都满足的，共有n!种选法。

可以猜出长度为i的子区间的贡献为：(n-i+1)*i!*(n-i)!

对上式求和。

ll fac[3000005];
 
void test_case() {
    int n, m;
    scanf("%d%d", &n, &m);
    fac[0] = 1;
    for(int i = 1; i <= n; ++i)
        fac[i] = fac[i - 1] * i % m;
    ll sum = 0;
    for(int i = 1; i <= n; ++i)
        sum += 1ll * fac[i] * fac[n - i + 1] % m * (n - i + 1) % m;
    sum %= m;
    printf("%lld\n", sum);
}

D - New Year and Conference

题意：给两组线段，第一组叫做ai，第二组叫做bi，要求验证是否任意一对(i,j),i!=j，都有：要么ai与aj有交点且bi与bj有交点，要么都没有交点。

题解：比赛的时候想了个分治，但是没想清楚，而且细节没处理好，其实比赛最后一次提交的代码只需要改动10行就可以AC了。

把题目转化成验证：当ai与aj有交点时，bi与bj有交点；且当bi与bj有交点时，ai与aj有交点。已知这个条件与题目条件是等价的。

先离散化。

然后solve_a(int l,int r)表示离散化后ai的右端点坐标在[l,r]之间的所有线段是否满足题意。

根据分治的原理，先递归给两个子区间，假如其中一个子区间不满足，那么这整个区间也不满足。否则处理跨越中点的情况。

  1. 把右子区间的所有aj的左端点插入树状数组，然后左子区间的ai的右端点在树状数组中询问，即可知道左子区间的右端点>=右子区间的所有左端点的信息，也就是跨越中点且ai与aj相交的线段的信息。

  2. 此时，要求i与每一个相交的j都有交点，画个图可以直观看出，要求 \(b_i的右端点>=max\{b_j的左端点\}\) 且 \(b_i的左端点<=min\{b_j的右端点\}\) 。

复杂度：由于会递归至多logn层，而每层的复杂度是树状数组的复杂度nlogn，总的复杂度是类似CDQ分治的 \(O(nlog^2n)\) 。

但是我感觉由于区间的长度实际上并不是每次都那么长，所以未必有这么坏。而假如造数据把所有的点都堆在很近的一个区间，那么根据我的递归的方法，应该层数又变少了。总而言之最坏是 \(O(nlog^2n)\) 但是可以过。

发现没有人给这道题贴分治的标签，果然我这个是歪门邪道吗……

vector<int> id[200005];
int la[200005], ra[200005];
int ax[200005], axtop;
int lb[200005], rb[200005];
int bx[200005], bxtop;
 
int maxbit[200005];
int minbit[200005];
 
int c;
 
void maxbit_update(int p, int v) {
    for(int x = p; x <= c; x += x & -x)
        maxbit[x] = max(maxbit[x], v);
}
 
void minbit_update(int p, int v) {
    for(int x = p; x <= c; x += x & -x)
        minbit[x] = min(minbit[x], v);
}
 
void maxbit_clear(int p) {
    for(int x = p; x <= c; x += x & -x)
        maxbit[x] = -INF;
}
 
void minbit_clear(int p) {
    for(int x = p; x <= c; x += x & -x)
        minbit[x] = INF;
}
 
int maxbit_query(int p) {
    int res = -INF;
    for(int x = p; x; x -= x & -x)
        res = max(res, maxbit[x]);
    return res;
}
 
int minbit_query(int p) {
    int res = INF;
    for(int x = p; x; x -= x & -x)
        res = min(res, minbit[x]);
    return res;
}
 
bool solve_a(int l, int r) {
    if(l == r) {
        if(id[l].size() <= 1)
            return true;
        int maxl = 0, minr = INF;
        for(auto &i : id[l]) {
            maxl = max(maxl, lb[i]);
            minr = min(minr, rb[i]);
        }
        if(minr >= maxl)
            return true;
        return false;
    }
    int m = (l + r) >> 1;
    bool res = solve_a(l, m) && solve_a(m + 1, r);
    if(res == 0)
        return false;
    for(int p = m + 1; p <= r; ++p) {
        for(auto &i : id[p]) {
            maxbit_update(la[i], lb[i]);
            minbit_update(la[i], rb[i]);
        }
    }
    for(int p = l; p <= m; ++p) {
        for(auto &i : id[p]) {
            int maxans = maxbit_query(ra[i]);
            int minans = minbit_query(ra[i]);
            if(!(minans >= lb[i] && maxans <= rb[i])) {
//                printf("minr=%d maxl=%d\n",minans,maxans);
//                printf("FALSE ON p=%d [%d,%d]\n", p, l, r);
                return false;
            }
        }
    }
    for(int p = m + 1; p <= r; ++p) {
        for(auto &i : id[p]) {
            maxbit_clear(la[i]);
            minbit_clear(la[i]);
        }
    }
    return true;
}
 
bool solve_b(int l, int r) {
    if(l == r) {
        if(id[l].size() <= 1)
            return true;
        int maxl = 0, minr = INF;
        for(auto &i : id[l]) {
            maxl = max(maxl, la[i]);
            minr = min(minr, ra[i]);
        }
        if(minr >= maxl)
            return true;
        return false;
    }
    int m = (l + r) >> 1;
    bool res = solve_b(l, m) && solve_b(m + 1, r);
    if(res == 0)
        return false;
    for(int p = m + 1; p <= r; ++p) {
        for(auto &i : id[p]) {
            maxbit_update(lb[i], la[i]);
            minbit_update(lb[i], ra[i]);
        }
    }
    for(int p = l; p <= m; ++p) {
        for(auto &i : id[p]) {
            int maxans = maxbit_query(rb[i]);
            int minans = minbit_query(rb[i]);
            if(!(minans >= la[i] && maxans <= ra[i])) {
//                printf("minr=%d maxl=%d\n",minans,maxans);
//                printf("FALSE ON p=%d [%d,%d]\n", p, l, r);
                return false;
            }
        }
    }
    for(int p = m + 1; p <= r; ++p) {
        for(auto &i : id[p]) {
            maxbit_clear(lb[i]);
            minbit_clear(lb[i]);
        }
    }
    return true;
}
 
void test_case() {
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        scanf("%d%d%d%d", &la[i], &ra[i], &lb[i], &rb[i]);
        ax[++axtop] = la[i];
        ax[++axtop] = ra[i];
        bx[++bxtop] = lb[i];
        bx[++bxtop] = rb[i];
    }
    sort(ax + 1, ax + 1 + axtop);
    axtop = unique(ax + 1, ax + 1 + axtop) - (ax + 1);
    sort(bx + 1, bx + 1 + bxtop);
    bxtop = unique(bx + 1, bx + 1 + bxtop) - (bx + 1);
    for(int i = 1; i <= n; ++i) {
        la[i] = lower_bound(ax + 1, ax + 1 + axtop, la[i]) - ax;
        ra[i] = lower_bound(ax + 1, ax + 1 + axtop, ra[i]) - ax;
        lb[i] = lower_bound(bx + 1, bx + 1 + bxtop, lb[i]) - bx;
        rb[i] = lower_bound(bx + 1, bx + 1 + bxtop, rb[i]) - bx;
//        printf("i=%d\n", i);
//        printf("  [%d,%d] [%d,%d]\n", la[i], ra[i], lb[i], rb[i]);
        id[ra[i]].push_back(i);
    }
    c = axtop;
    memset(maxbit, -INF, sizeof(maxbit[0]) * (axtop + 1));
    memset(minbit, INF, sizeof(minbit[0]) * (axtop + 1));
    bool res = solve_a(1, axtop);
    if(res == 1) {
        for(int i = 1; i <= n; ++i)
            id[ra[i]].clear();
        for(int i = 1; i <= n; ++i)
            id[rb[i]].push_back(i);
        c = bxtop;
        memset(maxbit, -INF, sizeof(maxbit[0]) * (bxtop + 1));
        memset(minbit, INF, sizeof(minbit[0]) * (bxtop + 1));
        res = solve_b(1, bxtop);
    }
    if(res)
        puts("YES");
    else
        puts("NO");
}

事实上上面的复杂度在于一个点反复插进树状数组里面以及反复在树状数组里面查询，仔细观察发现其实按ra排序之后，只需要右侧的点的左端点<=当前点的右端点，就是有交点。

struct Node {
    int la, ra, lb, rb;
    bool operator<(const Node& n)const {
        return ra < n.ra;
    }
} node[200005];

int ax[200005], axtop;
int bx[200005], bxtop;

int maxbit[200005];
int minbit[200005];

int n, c;

void maxbit_update(int p, int v) {
    for(int x = p; x <= c; x += x & -x)
        maxbit[x] = max(maxbit[x], v);
}

void minbit_update(int p, int v) {
    for(int x = p; x <= c; x += x & -x)
        minbit[x] = min(minbit[x], v);
}

int maxbit_query(int p) {
    int res = -INF;
    for(int x = p; x; x -= x & -x)
        res = max(res, maxbit[x]);
    return res;
}

int minbit_query(int p) {
    int res = INF;
    for(int x = p; x; x -= x & -x)
        res = min(res, minbit[x]);
    return res;
}

bool check() {
    sort(node + 1, node + 1 + n);
    memset(maxbit, -INF, sizeof(maxbit[0]) * (c + 1));
    memset(minbit, INF, sizeof(minbit[0]) * (c + 1));
    for(int i = n; i >= 1; --i) {
        int maxans = maxbit_query(node[i].ra);
        int minans = minbit_query(node[i].ra);
        if(!(minans >= node[i].lb && maxans <= node[i].rb))
            return false;
        maxbit_update(node[i].la, node[i].lb);
        minbit_update(node[i].la, node[i].rb);
    }
    return true;
}

void test_case() {
    scanf("%d", &n);
    for(int i = 1; i <= n; ++i) {
        scanf("%d%d%d%d", &node[i].la, &node[i].ra, &node[i].lb, &node[i].rb);
        ax[++axtop] = node[i].la;
        ax[++axtop] = node[i].ra;
        bx[++bxtop] = node[i].lb;
        bx[++bxtop] = node[i].rb;
    }
    sort(ax + 1, ax + 1 + axtop);
    axtop = unique(ax + 1, ax + 1 + axtop) - (ax + 1);
    sort(bx + 1, bx + 1 + bxtop);
    bxtop = unique(bx + 1, bx + 1 + bxtop) - (bx + 1);
    for(int i = 1; i <= n; ++i) {
        node[i].la = lower_bound(ax + 1, ax + 1 + axtop, node[i].la) - ax;
        node[i].ra = lower_bound(ax + 1, ax + 1 + axtop, node[i].ra) - ax;
        node[i].lb = lower_bound(bx + 1, bx + 1 + bxtop, node[i].lb) - bx;
        node[i].rb = lower_bound(bx + 1, bx + 1 + bxtop, node[i].rb) - bx;
    }
    c = axtop;
    bool res = check();
    if(res) {
        for(int i = 1; i <= n; ++i) {
            swap(node[i].la, node[i].lb);
            swap(node[i].ra, node[i].rb);
        }
        c = bxtop;
        res = check();
    }
    if(res)
        puts("YES");
    else
        puts("NO");
}

E - New Year and Castle Construction

题意：给n<=2500个点，没有三点共线，求每个点能被四元组构成的简单四边形包含的四元组个数的和。

题解：想了一个假算法，枚举每个点，然后极角排序，在旋转的过程中有cntl*cntr*(n-3)种选法？也就是线上的点必选，左右各选一个，然后再任选一个。但是好假哦，错的好明显。

标签
printf
lb
易学教程内所有资源均来自网络或用户发布的内容，如有违反法律规定的内容欢迎反馈！
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!