其他分享
首页 > 其他分享> > 2020ICPC南京区域赛 补题 & 总结

2020ICPC南京区域赛 补题 & 总结

作者:互联网

前言

题目链接

https://ac.nowcoder.com/acm/contest/10272

参考题解

A - Ah, It’s Yesterday Once More

简要题意:

对于给定的 n × m n \times m n×m 的方格, 0 0 0 代表障碍, 1 1 1 代表袋鼠。有一串随机生成的长为 5 × 1 0 4 5 \times 10^4 5×104 的指令,仅包含 LRUD \text{LRUD} LRUD 字符,分别表示将所有袋鼠同时向某个方向移动(若能移动,即不经过障碍、不超出方格范围)。现要求构造一个 n × m n \times m n×m 方格图,使得对于随机生成的 500 500 500 串指令,至少有 125 125 125 个满足执行后,所有袋鼠不都在同一个方格。要求构造的袋鼠方格连通、且不含环。

1 ≤ n , m ≤ 20 1 \le n, m \le 20 1≤n,m≤20。

解题思路:

构造尽可能长且不对称的路径让袋鼠移动,还有就是构造一些分岔路口。可以构造一条沿对角线方向的 Z \text{Z} Z 形路径。

参考代码:
#include<bits/stdc++.h>
using namespace std;

int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    char ans[21][21] = {
    "20 20",
    "11011111011111011111",
    "10110100110100110100",
    "11101101101101101101",
    "10011011011011011001",
    "10110110110110110111",
    "01101101101101101101",
    "11011011011011011011",
    "10110110110110110110",
    "11101101101101101101",
    "10011011011011011001",
    "10110110110110110111",
    "01101101101101101101",
    "11011011011011011011",
    "10110110110110110110",
    "11101101101101101101",
    "10011011011011011001",
    "10110110110110110111",
    "01101101101101101101",
    "01011001011001011001",
    "11110111110111110111",
    };
    for(int i = 0; i <= 20; ++i){

        cout << ans[i] << endl;
    }
    return 0;
}

 
附上顺手写的 checker \text{checker} checker,检验袋鼠方格是否连通、无环,输出值为 500 500 500 组随机指令中通过的组数。

#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;

const int xp[] = {0, 0, -1, 1};
const int yp[] = {-1, 1, 0, 0};
char ss[23][23];
pii pre[23][23];
int a[23][23], b[23][23], siz[23][23];
int n, m;
mt19937 rnd(time(0));

void mov(int d){

    memset(b, 0, sizeof b);
    for(int i = 1; i <= n; ++i){

        for(int j = 1; j <= m; ++j){

            if(!a[i][j]) continue;
            int x = i + xp[d], y = j + yp[d];
            if(x < 1 || x > n || y < 1 || y > m || ss[x][y] == '0') x = i, y = j;
            if(a[i][j]) b[x][y] += a[i][j];
        }
    }
    memcpy(a, b, sizeof b);
}

int check(){

    int ret = 0;
    for(int i = 1; i <= n; ++i){

        for(int j = 1; j <= m; ++j){

            if(a[i][j]) ++ret;
        }
    }
    return ret > 1;
}

int isHack(){

    for(int i = 1; i <= n; ++i){

        for(int j = 1; j <= m; ++j) a[i][j] = ss[i][j] - '0';
    }
    for(int i = 1; i <= 50000; ++i){

        mov(rnd() % 4);
    }
    return check();
}

pii fin(pii x){

    auto &fx = pre[x.first][x.second];
    return x == fx ? x : fx = fin(fx);
}

int unite(pii x, pii y){

    auto fx = fin(x), fy = fin(y);
    if(fx == fy) return 0;
    pre[fx.first][fx.second] = fy;
    siz[fy.first][fy.second] += siz[fx.first][fx.second];
    return 1;
}

int isValid(){

    int tot = 0, x = 0, y = 0;
    for(int i = 1; i <= n; ++i){

        for(int j = 1; j <= m; ++j){

            pre[i][j] = pii{i, j};
            siz[i][j] = 1;
            if(ss[i][j] == '1') ++tot, x = i, y = j;
        }
    }
    if(!x) return 0;
    for(int i = 1; i <= n; ++i){

        for(int j = 1; j <= m; ++j){

            if(ss[i][j] != '1') continue;
            if(i > 1 && ss[i - 1][j] == '1'){

                if(!unite(pii{i - 1, j}, pii{i, j})) return 0;
            }
            if(j > 1 && ss[i][j - 1] == '1'){

                if(!unite(pii{i, j - 1}, pii{i, j})) return 0;
            }
        }
    }
    auto fx = fin(pii{x, y});
    return siz[fx.first][fx.second] == tot;
}

int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for(int i = 1; i <= n; ++i){

        cin >> ss[i] + 1;
    }
    if(!isValid()){

        cout << "0" << endl;
        return 0;
    }
    int ret = 0;
    for(int i = 1; i <= 500; ++i){

        if(isHack()) ++ret;
    }
    cout << ret << endl;
    return 0;
}

B - Baby’s First Suffix Array Problem

咕。

C - Certain Scientific Railgun

咕咕。

D - Degree of Spanning Tree

简要题意:

给定一个 n n n 个顶点、 m m m 条边的无向图,保证图连通,可能含有自环和重边。判断是否存在一棵生成树使得没有顶点的度数大于 n 2 \cfrac{n}{2} 2n​ ,存在则输出任意方案。

多组数据, 2 ≤ n ≤ 1 0 5 , n − 1 ≤ m ≤ 2 × 1 0 5 , ∑ n i ≤ 5 × 1 0 5 , ∑ m i ≤ 1 0 6 2 \le n \le 10^5, n - 1 \le m \le 2 \times 10^5, \sum n_i \le 5 \times 10^5, \sum m_i \le 10^6 2≤n≤105,n−1≤m≤2×105,∑ni​≤5×105,∑mi​≤106 。

解题思路:

对于 n n n 个顶点的树,用 d ( i ) d(i) d(i) 表示顶点 i i i 的度数,对任意两个顶点 u , v u, v u,v,有 d ( u ) + d ( v ) ≤ n d(u) + d(v) \le n d(u)+d(v)≤n,取等号当且仅当 u , v u, v u,v 邻接。故任意取一棵生成树,度数大于 n 2 \cfrac{n}{2} 2n​ 的顶点最多只有一个,若没有这样的点,则输出答案。否则将其设为根 r t rt rt 并试图调整其度数。接下来遍历其他所有边,若边 e ( u , v ) e(u, v) e(u,v) 能替换 r t rt rt 邻接的一条边,则替换,直到 d ( r t ) = ⌊ n 2 ⌋ d(rt) = \lfloor\cfrac{n}{2}\rfloor d(rt)=⌊2n​⌋ 。

注意到这个过程可能让某个顶点 u u u 的度数大于 n 2 \cfrac{n}{2} 2n​,这样的 u u u 只可能是 r t rt rt 的邻接点,因为当 d ( r t ) = ⌊ n 2 ⌋ d(rt) = \lfloor\cfrac{n}{2}\rfloor d(rt)=⌊2n​⌋ 时, d ( u ) + d ( r t ) = ( ⌊ n 2 ⌋ + 1 ) + ⌊ n 2 ⌋ ≥ n d(u) + d(rt) = (\lfloor\cfrac{n}{2}\rfloor + 1) + \lfloor\cfrac{n}{2}\rfloor \ge n d(u)+d(rt)=(⌊2n​⌋+1)+⌊2n​⌋≥n ,上面提到若两顶点不邻接,度数和将小于 n n n,故得证。

故替换边的过程,优先让 r t rt rt 的非邻接顶点度数增加,若枚举的边 e ( u , v ) e(u, v) e(u,v) 都是 r t rt rt 的邻接顶点呢?优先让度数小的度数增加,可以证明只有 n = 3 n = 3 n=3 时可能出现 d ( u ) > n 2 d(u) \gt \cfrac{n}{2} d(u)>2n​,而 n = 3 n = 3 n=3 是无解情况,特判即可。

参考代码:
#include<bits/stdc++.h>
using namespace std;
#define pb emplace_back
#define sz(a) ((int)a.size())
const int maxn = 2e5 + 5;

struct Edge{
    int u, v, p;
} ei[maxn];
vector<Edge> G[maxn];
int deg[maxn], pre[maxn], vis[maxn], fe[maxn], dep[maxn];
int n, m;

int fin(int x){

    return x == pre[x] ? x : pre[x] = fin(pre[x]);
}

void dfs(int u, int f, int t){

    pre[u] = t, dep[u] = dep[f] + 1;
    for(auto &e : G[u]){

        int v = e.v;
        if(v == f) continue;
        dfs(v, u, t);
    }
}

int main(){

    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    while(T--){

        cin >> n >> m;
        for(int i = 1; i <= n; ++i){

            G[i].clear();
            deg[i] = 0;
            pre[i] = i;
        }
        for(int i = 1; i <= m; ++i){

            vis[i] = 0;
        }
        for(int i = 1; i <= m; ++i){

            int u, v; cin >> u >> v;
            ei[i] = Edge{u, v, i};
            if(fin(u) == fin(v)) continue;
            G[u].pb(Edge{u, v, i}), G[v].pb(Edge{v, u, i});
            pre[fin(u)] = fin(v);
            ++deg[u], ++deg[v], vis[i] = 1;
        }
        int rt = max_element(deg + 1, deg + 1 + n) - deg;
        auto print = [](const string &ans){

            cout << ans << "\n";
            if(ans == "No") return;
            for(int i = 1; i <= m; ++i){

                if(vis[i]) cout << ei[i].u << " " << ei[i].v << "\n";
            }
        };
        if(n == 3){

            print("No");
            continue;
        }
        if(deg[rt] <= n / 2){

            print("Yes");
            continue;
        }
        pre[rt] = rt, dep[rt] = 0;
        for(auto &e : G[rt]){

            int v = e.v;
            fe[v] = e.p;
            dfs(v, rt, v);
        }
        for(int i = 1; i <= m; ++i){

            int u = ei[i].u, v = ei[i].v;
            if(u == rt || v == rt) continue;
            int fu = fin(u), fv = fin(v);
            if(fu == fv) continue;
            if(dep[u] < dep[v]) swap(u, v), swap(fu, fv);
            if(dep[v] == 1 && deg[u] > deg[v]) swap(u, v), swap(fu, fv);
            ++deg[u], ++deg[v];
            --deg[rt], --deg[fv];
            vis[ei[i].p] = 1, vis[fe[fv]] = 0;
            pre[fv] = fu;
            if(deg[rt] <= n / 2) break;
        }
        print(deg[rt] <= n / 2 ? "Yes" : "No");
    }
    return 0;
}

E - Evil Coordinate

简要题意:

二维网格图上,给定起点 ( 0 , 0 ) (0, 0) (0,0),再给一个障碍 ( m x , m y ) (m_x, m_y) (mx​,my​) 和一串长为 n n n 的指令,仅包含 LRUD \text{LRUD} LRUD 字符,分别表示向某个方向移动,求调整指令顺序让移动过程不经过 ( m x , m y ) (m_x, m_y) (mx​,my​),无解输出 impossible \text{impossible} impossible 。

多组数据, 1 ≤ n ≤ 1 0 5 , − 1 0 9 ≤ m x , m y ≤ 1 0 9 , ∑ n i ≤ 1 0 6 1 \le n \le 10^5, -10^9 \le m_x, m_y \le 10^9, \sum n_i \le 10^6 1≤n≤105,−109≤mx​,my​≤109,∑ni​≤106 。

解题思路:

可以证明如果有解,一定存在一种解是每个方向都连续走完,故枚举四个方向的排列即可。证明免了,看我代码分类讨论吧。

参考代码:
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;

const int xp[] = {0, 0, -1, 1};
const int yp[] = {1, -1, 0, 0};
int has[256];
char s[maxn];
int n, mx, my;

int main(){
    
    ios::sync_with_stdio(0); cin.tie(0);
    has['U'] = 0, has['D'] = 1, has['L'] = 2, has['R'] = 3;
    int T; cin >> T;
    while(T--){
        cin >> mx >> my;
        cin >> s + 1;
        n = strlen(s + 1);
        int x = 0, y = 0;
        map<int, int> cnt;
        for(int i = 1; i <= n; ++i){
            ++cnt[s[i]];
            x += xp[has[s[i]]], y += yp[has[s[i]]];
        }
        string ans = "";
        auto walk4 = [&](const string &s){
            for(int i = 0; i < 4; ++i){
                ans += string(cnt[s[i]], s[i]);
            }
        };
        auto sign = [](int x){
            return x > 0 ? 1 : -1;
        };
        int ret = 1;
        if(mx == 0 && my == 0 || x == mx && y == my) ret = 0;
        else if(mx == 0){
            if(x != 0) walk4("LRUD");
            else{
                int dy = cnt['U'] - cnt['D'];
                if(sign(dy) == sign(my) && abs(dy) >= abs(my)){
                    if(!cnt['L']) ret = 0;
                    else walk4("LUDR");
                }
                else if(my > 0) walk4("DULR");
                else walk4("UDLR");
            }
        }
        else if(my == 0){
            if(y != 0) walk4("UDLR");
            else{
                int dx = cnt['R'] - cnt['L'];
                if(sign(dx) == sign(mx) && abs(dx) >= abs(mx)){
                    if(!cnt['U']) ret = 0;
                    else walk4("ULRD");
                }
                else if(mx > 0) walk4("LRUD");
                else walk4("RLUD");
            }
        }
        else if(mx == x){
            walk4("UDLR");
        }
        else if(my == y){
            walk4("LRUD");
        }
        else{
            walk4("UDLR");
        }
        if(ret) cout << ans << endl;
        else cout << "Impossible" << endl;
    }
    return 0;
}

F - Fireworks

简要题意:

制作一支烟花需要花费 n n n 分钟,每支烟花有 p × 1 0 − 4 p \times 10^{-4} p×10−4 的概率是完美的,每次可以花费 m m m 分钟点燃之前制作的所有烟花,若发现至少有一支完美的,则停止。问最优策略下,最短的停下的时间期望是多少?

多组数据, 1 ≤ T ≤ 1 0 4 , 1 ≤ n , m ≤ 1 0 9 , 1 ≤ p ≤ 1 0 4 1 \le T \le 10^4, 1 \le n, m \le 10^9, 1 \le p \le 10^4 1≤T≤104,1≤n,m≤109,1≤p≤104 。

解题思路:

不是完美烟花的概率 q = 1 − ( p × 1 0 − 4 ) q = 1 - (p \times 10^{-4}) q=1−(p×10−4),假设最优策略为连续制作 k k k 支烟花后点燃检验,若发现有完美烟花则停止,若没有则回到初始状态,继续执行最优策略,制作轮数 X X X 服从几何分布,故期望制作轮数 E ( X ) = 1 1 − q k E(X) = \cfrac{1}{1 - q^k} E(X)=1−qk1​,期望时间为 f ( k ) = n × k + m 1 − q k f(k) = \cfrac{n \times k + m}{1 - q^k} f(k)=1−qkn×k+m​ ,这是一个单峰函数,可以直接三分答案。

参考代码:
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
typedef long long ll;
#define eps 1e-7

ll n, m;
double p;

double cal(ll k){
    return ((double)k * n + m) / (1 - pow(1 - p, k));
}

double solve(){
    ll L = 0, R = 2e18, x = L, pw = R - L;
    double fx = cal(x);
    while(pw > 0){
        ll l = max(L, x - pw), r = min(R, x + pw);
        double fl = cal(l), fr = cal(r);
        if(fl < fx) x = l, fx = fl;
        else if(fr < fx) x = r, fx = fr;
        else pw >>= 1;
    }
    return fx;
}

int main(){
    
    ios::sync_with_stdio(0); cin.tie(0);
    cout << fixed << setprecision(10);
    int T; cin >> T;
    while(T--){
        ll P; cin >> n >> m >> P;
        p = P * 0.0001;
        cout << solve() << endl;
    }
    return 0;
}

G - Go

咕咕咕。

H - Harmonious Rectangle

简要题意:

给定 n n n 和 m m m ,问有多少个不同的 n × m n \times m n×m 矩阵满足:矩阵元素 a i , j ∈ { 1 , 2 , 3 } a_{i, j} \in \{1,2,3\} ai,j​∈{1,2,3},并且存在 1 ≤ x 1 < x 2 ≤ n 1 \le x_1 \lt x_2 \le n 1≤x1​<x2​≤n 和 1 ≤ y 1 < y 2 ≤ m 1 \le y_1 \lt y_2 \le m 1≤y1​<y2​≤m 满足
{ a ( x 1 , y 1 ) = a ( x 1 , y 2 ) a ( x 2 , y 1 ) = a ( x 2 , y 2 )  或  { a ( x 1 , y 1 ) = a ( x 2 , y 1 ) a ( x 1 , y 2 ) = a ( x 2 , y 2 ) \left\{\begin{aligned} a(x_1, y_1) = a(x_1, y_2) \\ a(x_2, y_1) = a(x_2, y_2) \end{aligned}\right. ~\text{或}~ \left\{\begin{aligned} a(x_1, y_1) = a(x_2, y_1) \\ a(x_1, y_2) = a(x_2, y_2) \end{aligned}\right. {a(x1​,y1​)=a(x1​,y2​)a(x2​,y1​)=a(x2​,y2​)​ 或 {a(x1​,y1​)=a(x2​,y1​)a(x1​,y2​)=a(x2​,y2​)​
输出答案模上 1 0 9 + 7 10^9 + 7 109+7 。

多组数据, 1 ≤ T ≤ 1 0 4 , 1 ≤ n , m ≤ 2 × 1 0 3 1 \le T \le 10^4, 1 \le n, m \le 2 \times 10^3 1≤T≤104,1≤n,m≤2×103 。

解题思路:

由于不同的两个元素组合只有 9 9 9 种,当 max ⁡ ( n , m ) > 9 \max(n, m) \gt 9 max(n,m)>9 时,根据抽屉原理,任意矩阵都满足条件。对于其他情况,暴搜打表找出不符合的情况即可。

参考代码:
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1e9 + 7;

// int a[10][10], row[10][10][16], col[10][10][16];
// int n, m;

// int check(int x, int y){

//     for(int i = 1; i < y; ++i){

//         if(row[i][y][a[x][i] * 4 + a[x][y]]) return 0;
//     }
//     for(int i = 1; i < x; ++i){

//         if(col[i][x][a[i][y] * 4 + a[x][y]]) return 0;
//     }
//     return 1;
// }

// void cal(int x, int y, int d){

//     for(int i = 1; i < y; ++i){

//         row[i][y][a[x][i] * 4 + a[x][y]] += d;
//     }
//     for(int i = 1; i < x; ++i){

//         col[i][x][a[i][y] * 4 + a[x][y]] += d;
//     }
// }

// int dfs(int x, int y){

//     if(x > n) return 1;
//     if(y > m) return dfs(x + 1, 1);
//     int ret = 0;
//     for(int i = 1; i <= 3; ++i){

//         a[x][y] = i;
//         if(!check(x, y)) continue;
//         cal(x, y, 1);
//         ret += dfs(x, y + 1);
//         cal(x, y, -1);
//     }
//     return ret;
// }

ll qpow(ll a, ll b){

    ll ret = 1;
    while(b){

        if(b & 1) ret = ret * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return ret;
}

int ans[10][10] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 15, 339, 4761, 52929, 517761, 4767849, 43046721, 387420489, 
    0, 0, 339, 16485, 518265, 14321907, 387406809, 460338013, 429534507, 597431612,
    0, 0, 4761, 518265, 43022385, 486780060, 429534507, 792294829, 175880701, 246336683,
    0, 0, 52929, 14321907, 486780060, 288599194, 130653412, 748778899, 953271190, 644897553,
    0, 0, 517761, 387406809, 429534507, 130653412, 246336683, 579440654, 412233812, 518446848,       
    0, 0, 4767849, 460338013, 792294829, 748778899, 579440654, 236701429, 666021604, 589237756,      
    0, 0, 43046721, 429534507, 175880701, 953271190, 412233812, 666021604, 767713261, 966670169,     
    0, 0, 387420489, 597431612, 246336683, 644897553, 518446848, 589237756, 966670169, 968803245, 
};

int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    while(T--){

        int n, m; cin >> n >> m;
        ll ret = n <= 9 && m <= 9 ? ans[n][m] : qpow(3, n * m);
        if(n == 1 || m == 1) ret = 0;
        cout << ret << "\n";
    }
    return 0;
}

I - Interested in Skiing

简要题意:

二维平面 [ − m , m ] × R [-m, m] \times \mathbb{R} [−m,m]×R 上有 n n n 条线段作为障碍,以端点坐标 ( x 1 , y 1 ) (x_1, y_1) (x1​,y1​) 和 ( x 2 , y 2 ) (x_2, y_2) (x2​,y2​) 表示,起点为 ( 0 , − inf ⁡ ) (0, -\inf) (0,−inf) 的一个点以 v y v_y vy​ 的速度向 y \text{y} y 轴正方向移动,终点为 ( 0 , inf ⁡ ) (0, \inf) (0,inf) 。求最小的 v x ∗ v_x^* vx∗​,使得当水平速度 v x > v x ∗ v_x \gt v_x^* vx​>vx∗​ 时,能从起点移动到终点,无解则输出 − 1 -1 −1 。

1 ≤ n ≤ 100 , 1 ≤ m ≤ 1 0 4 , 1 ≤ v y ≤ 10 , − m ≤ x 1 , x 2 ≤ m , − 1 0 − 4 ≤ y 1 , y 2 ≤ 1 0 4 1 \le n \le 100, 1 \le m \le 10^4, 1 \le v_y \le 10, -m \le x_1, x_2 \le m, -10^{-4} \le y_1, y_2 \le 10^4 1≤n≤100,1≤m≤104,1≤vy​≤10,−m≤x1​,x2​≤m,−10−4≤y1​,y2​≤104 。

解题思路:

最优策略是经过一些线段的端点,将所有端点按 y \text{y} y 升序排序,以该顺序拓扑转移, d p i dp_i dpi​ 表示到达第 i i i 个点所需的最小 v x v_x vx​ ,转移时枚举 O ( n ) O(n) O(n) 判断两点间是否能判断,总时间复杂度 O ( n 3 ) O(n^3) O(n3) 。

参考代码:
#include<bits/stdc++.h>
using namespace std;

struct Point{
    int x, y;
};
struct Line{
    Point s, e;
};

inline int sign(int x){
 
    return x == 0 ? 0 : x > 0 ? 1 : -1;
}
 
inline int cross(const Point &a, const Point &b, const Point &c){
 
    return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
}
 
inline int isIns(const Line &l1, const Line &l2){
 
    return 
        max(l1.s.x, l1.e.x) > min(l2.s.x, l2.e.x) && 
        max(l2.s.x, l2.e.x) > min(l1.s.x, l1.e.x) &&
        max(l1.s.y, l1.e.y) > min(l2.s.y, l2.e.y) &&
        max(l2.s.y, l2.e.y) > min(l1.s.y, l1.e.y) &&
        sign(cross(l1.s, l2.s, l1.e)) * sign(cross(l1.s, l2.e, l1.e)) < 0 && 
        sign(cross(l2.s, l1.s, l2.e)) * sign(cross(l2.s, l1.e, l2.e)) < 0; 
}

int main(){

    ios::sync_with_stdio(0); cin.tie(0);
    cout << fixed << setprecision(10);
    int n, m, vy; cin >> n >> m >> vy;
    vector<Point> pi(2 * n);
    vector<Line> li(n);
    for(int i = 0; i < n; ++i){

        cin >> pi[i << 1].x >> pi[i << 1].y;
        cin >> pi[i << 1 | 1].x >> pi[i << 1 | 1].y;
        li[i] = Line{pi[i << 1], pi[i << 1 | 1]};
    }
    auto isOK = [&](const Point &a, const Point &b) -> int{

        Line l = Line{a, b};
        for(int i = 0; i < n; ++i){

            if(isIns(l, li[i])) return 0;
        }
        return 1;
    };
    sort(pi.begin(), pi.end(), [](const Point &a, const Point &b){ return a.y < b.y; });
    vector<double> dp(2 * n, 1e20);
    double ans = 1e20;
    for(int i = 0; i < 2 * n; ++i){

        if(pi[i].x <= -m || pi[i].x >= m) continue;
        if(isOK(Point{pi[i].x, -10001}, pi[i])) dp[i] = 0;
        for(int j = 0; j < i; ++j){

            if(pi[j].y == pi[i].y) break;
            if(isOK(pi[j], pi[i])){

                double ki = 1.0 * (pi[i].x - pi[j].x) / (pi[i].y - pi[j].y);
                dp[i] = min(dp[i], max(dp[j], abs(ki)));
            }
        }
        if(isOK(Point{pi[i].x, 10001}, pi[i])) ans = min(ans, dp[i]);
        // cout << i << " " << pi[i].x << " " << pi[i].y << " " << ans << endl;
    }
    if(isOK(Point{0, -10001}, Point{0, 10001})) ans = 0;
    if(ans > 1e10) cout << "-1" << endl;
    else cout << ans * vy << endl;
    return 0;
}

J - Just Another Game of Stones

简要题意:

给定一个长度为 n n n 的数组 a i a_i ai​ ,有 q q q 次操作:

1 ≤ n , q ≤ 2 × 1 0 5 , 1 ≤ l , r ≤ n , 0 ≤ a i , x < 2 30 − 1 1 \le n, q \le 2 \times 10^5, 1 \le l, r \le n, 0 \le a_i, x \lt 2^{30} - 1 1≤n,q≤2×105,1≤l,r≤n,0≤ai​,x<230−1 。

解题思路:

Nim \text{Nim} Nim 博弈,当石子数量异或和不为 0 0 0 时为必胜态,否则为必败态。假设异或和为 S S S,第一步操作就是取一堆石子,让异或和变成 0 0 0,即对石子个数为 a i a_i ai​ 的石堆,取走 a i − a i ⊕ S a_i - a_i \oplus S ai​−ai​⊕S 个石子,故询问答案就是 a i ≥ a i ⊕ S a_i \ge a_i \oplus S ai​≥ai​⊕S 的 i i i 的个数。

考虑 S S S 二进制最高位 1 1 1,若 a i a_i ai​ 对应位也是 1 1 1 ,则必有 a i ≥ a i ⊕ S a_i \ge a_i \oplus S ai​≥ai​⊕S ,反之不成立。修改操作使用 segment tree beats \text{segment tree beats} segment tree beats 的维护技巧。

参考代码:
#include<bits/stdc++.h>
using namespace std;
#define lson (rt << 1)
#define rson (rt << 1 | 1)
#define gmid (l + r >> 1)
const int inf = 1 << 30;
const int maxn = 2e5 + 5;
 
int ans[30];
int a[maxn], n, q;
 
struct SegTree{
 
    int mn[maxn << 2], mn2[maxn << 2], sum[maxn << 2][30], cov[maxn << 2], num[maxn << 2];
    void pushUp(int rt){
 
        for(int i = 0; i < 30; ++i) sum[rt][i] = sum[lson][i] + sum[rson][i];
        if(mn[lson] == mn[rson]){
 
            mn[rt] = mn[lson], num[rt] = num[lson] + num[rson];
            mn2[rt] = min(mn2[lson], mn2[rson]);
        }
        else if(mn[lson] < mn[rson]){
 
            mn[rt] = mn[lson], num[rt] = num[lson];
            mn2[rt] = min(mn2[lson], mn[rson]);
        }
        else{
 
            mn[rt] = mn[rson], num[rt] = num[rson];
            mn2[rt] = min(mn[lson], mn2[rson]);
        }
    }
    void build(int l, int r, int rt){
 
        cov[rt] = -1;
        if(l == r){
 
            for(int i = 0; i < 30; ++i) sum[rt][i] = (a[l] >> i) & 1;
            mn[rt] = a[l], mn2[rt] = inf, num[rt] = 1;
            return;
        }
        int mid = gmid;
        build(l, mid, lson);
        build(mid + 1, r, rson);
        pushUp(rt);
    }
    void pushDown2(int rt, int son){
 
        if(cov[rt] <= mn[son]) return;
        for(int i = 0; i < 30; ++i){
 
            sum[son][i] -= num[son] * ((mn[son] >> i) & 1);
            sum[son][i] += num[son] * ((cov[rt] >> i) & 1);
        }
        mn[son] = cov[son] = cov[rt];
    }
    void pushDown(int l, int r, int rt){
 
        if(cov[rt] != -1){
 
            int mid = gmid;
            pushDown2(rt, lson);
            pushDown2(rt, rson);
            cov[rt] = -1;
        }
    }
    void update(int l, int r, int rt, int L, int R, int val){
 
        if(val <= mn[rt]) return;
        if(l >= L && r <= R && val < mn2[rt]){
 
            cov[0] = val, pushDown2(0, rt);
            return;
        }
        int mid = gmid; pushDown(l, r, rt);
        if(L <= mid) update(l, mid, lson, L, R, val);
        if(R > mid) update(mid + 1, r, rson, L, R, val);
        pushUp(rt);
    }
    void query(int l, int r, int rt, int L, int R){
 
        if(l >= L && r <= R){
 
            for(int i = 0; i < 30; ++i){
 
                ans[i] += sum[rt][i];
            }
            return;
        }
        int mid = gmid; pushDown(l, r, rt);
        if(L <= mid) query(l, mid, lson, L, R);
        if(R > mid) query(mid + 1, r, rson, L, R);
    }
} tr;

int main(){
 
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> q;
    for(int i = 1; i <= n; ++i){
 
        cin >> a[i];
    }
    tr.build(1, n, 1);
    while(q--){
 
        int opt, l, r, x; cin >> opt >> l >> r >> x;
        if(opt == 1){
 
            tr.update(1, n, 1, l, r, x);
        }
        else{
 
            memset(ans, 0, sizeof ans);
            tr.query(1, n, 1, l, r);
            int ret = 0;
            for(int i = 29; i >= 0; --i){
 
                ans[i] += (x >> i) & 1;
                if(ans[i] & 1) { ret = ans[i]; break; }
            }
            cout << ret << "\n";
        }
    }
    return 0;
}

K - K Co-prime Permutation

简要题意:

给定 n n n 和 k k k ,构造一个排列 p i p_i pi​ 使得 gcd ⁡ ( p i , i ) = 1 \gcd(p_i, i) = 1 gcd(pi​,i)=1 的 i i i 的个数恰有 k k k 个,无解输出 − 1 -1 −1 。

1 ≤ n ≤ 1 0 6 , 0 ≤ k ≤ n 1 \le n \le 10^6, 0 \le k \le n 1≤n≤106,0≤k≤n 。

解题思路:

当 i > 1 i \gt 1 i>1 , gcd ⁡ ( i , i − 1 ) = 1 \gcd(i, i - 1) = 1 gcd(i,i−1)=1 。特判 k = 0 k = 0 k=0 无解。

参考代码:
#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;

int ans[maxn];
int n, k;

int main(){
    
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> k;
    if(k == 0) cout << "-1" << endl;
    else{
        for(int i = 2; i <= k; ++i) ans[i - 1] = i;
        ans[k] = 1;
        for(int i = k + 1; i <= n; ++i) ans[i] = i;
        for(int i = 1; i < n; ++i) cout << ans[i] << " ";
        cout << ans[n] << endl;
    }
    return 0;
}

L - Let’s Play Curling

简要题意:

给定长度为 n n n 的数组 a i a_i ai​ 和长度为 m m m 的数组 b i b_i bi​ ,对于一个数 c c c,若 a i a_i ai​ 满足对于所有 j j j , ∣ c − a i ∣ < ∣ c − b j ∣ \vert c - a_i \vert \lt \vert c - b_j \vert ∣c−ai​∣<∣c−bj​∣ 则得分加 1 1 1 ,最终得分 f ( c ) f(c) f(c) 为满足的 i i i 的个数,求最大的 f ( c ) f(c) f(c) 。

多组数据, 1 ≤ n , m ≤ 1 0 5 , 1 ≤ a i , b i ≤ 1 0 9 , ∑ n i , ∑ m i ≤ 5 × 1 0 5 1 \le n, m \le 10^5, 1 \le a_i, b_i \le 10^9, \sum n_i, \sum m_i \le 5 \times 10^5 1≤n,m≤105,1≤ai​,bi​≤109,∑ni​,∑mi​≤5×105 。

解题思路:

选择若干 a i a_i ai​ ,需要满足 max ⁡ {   ∣ c − a i ∣   } < min ⁡ {   ∣ c − b j ∣   } \max\{~\vert c - a_i\vert~\} \lt \min\{~\vert c - b_j\vert~\} max{ ∣c−ai​∣ }<min{ ∣c−bj​∣ } ,若确定 a i a_i ai​ ,则 c c c 取值为 max ⁡ { a i } + min ⁡ { a i } 2 \cfrac{\max\{a_i\} + \min\{a_i\}}{2} 2max{ai​}+min{ai​}​ 最优,显然不能有 b j b_j bj​ 落在 [ min ⁡ { a i } , max ⁡ { a i } ] [\min\{a_i\}, \max\{a_i\}] [min{ai​},max{ai​}] 。故答案就是 ( b j , b j + 1 ) (b_j, b_{j + 1}) (bj​,bj+1​) 最多有多少个 a i a_i ai​ 。

参考代码:
#include<bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;

int a[maxn], b[maxn];
int n, m;

int main(){
    
    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    while(T--){
        
        cin >> n >> m;
        for(int i = 1; i <= n; ++i) cin >> a[i];
        for(int i = 1; i <= m; ++i) cin >> b[i];
        b[++m] = 0, b[++m] = 1e9 + 1;
        sort(a + 1, a + 1 + n);
        sort(b + 1, b + 1 + m);
        int ret = 0;
        for(int i = 1; i < m; ++i){
            int p1 = lower_bound(a + 1, a + 1 + n, b[i] + 1) - a;
            int p2 = lower_bound(a + 1, a + 1 + n, b[i + 1]) - a;
            ret = max(ret, p2 - p1);
        }
        if(ret > 0) cout << ret << endl;
        else cout << "Impossible" << endl;
    }
    return 0;
}

M - Monster Hunter

简要题意:

给一棵 n n n 个结点的有根树, 1 1 1 号结点为根结点,每个结点上有一个血量为 h p i hp_i hpi​ 的怪物。必须从根到叶逐一消灭怪物,消灭第 u u u 号怪物的代价为 h p u + ∑ h p v hp_u + \sum hp_v hpu​+∑hpv​ ,其中 v v v 是 u u u 的直接子结点。使用一次魔法可以让一只怪物血量归零,求使用魔法次数为 0 , 1 , 2 , ⋯   , n 0, 1, 2, \cdots, n 0,1,2,⋯,n 时所需的最小代价分别是多少。

多组数据, 2 ≤ n ≤ 2 × 1 0 3 , 1 ≤ h p i ≤ 1 0 9 , ∑ n i ≤ 2 × 1 0 3 2 \le n \le 2 \times 10^3, 1 \le hp_i \le 10^9, \sum n_i \le 2 \times 10^3 2≤n≤2×103,1≤hpi​≤109,∑ni​≤2×103 。

解题思路:

考虑一次魔法操作能减少的代价,如果对 u u u 结点使用,首先对父结点 f f f,消灭父结点 f f f 的代价减少 h p u hp_u hpu​ ,然后是减少 h p u + ∑ h p v hp_u + \sum hp_v hpu​+∑hpv​ ,可以想象一次魔法操作对应将边 ( u , f ) (u, f) (u,f) 和所有 ( u , v ) (u, v) (u,v) 覆盖,将结点 u u u 覆盖。多次魔法操作后,一条边、一个结点被覆盖多次,也只能减少一次代价,然后就是树上背包枚举子树合并转移了。

参考代码:
#include<bits/stdc++.h>
using namespace std;
#define sz(a) ((int)a.size())
#define pb push_back
const int maxn = 2e3 + 5;
typedef long long ll;
const ll oo = 1ll << 60;

vector<int> G[maxn];
int siz[maxn];
ll a[maxn], sum[maxn], dp[maxn][maxn][2], ans[maxn];
int n;

void dfs(int u, int f){
    dp[u][0][0] = 0, dp[u][1][1] = sum[u], siz[u] = 1;
    for(auto &v : G[u]){
        if(v == f) continue;
        dfs(v, u);
        for(int i = siz[u]; i >= 0; --i){
            for(int j = siz[v]; j >= 0; --j){
                dp[u][i + j][0] = max(dp[u][i + j][0], dp[u][i][0] + max(dp[v][j][0], dp[v][j][1]));
                dp[u][i + j][1] = max(dp[u][i + j][1], dp[u][i][1] + max(dp[v][j][0], dp[v][j][1] - a[v]));
            }
        }
        siz[u] += siz[v];
    }
}

int main(){
    
    ios::sync_with_stdio(0); cin.tie(0);
    int T; cin >> T;
    while(T--){
        cin >> n;
        for(int i = 1; i <= n; ++i){
            G[i].clear();
            for(int j = 0; j <= n; ++j){
                dp[i][j][0] = dp[i][j][1] = -oo;
            }
        }
        for(int i = 2; i <= n; ++i){
            int u; cin >> u;
            G[u].pb(i);
        }
        for(int i = 1; i <= n; ++i){
            cin >> a[i];
        }
        for(int i = 0; i <= n; ++i){
            ans[i] = 0;
        }
        for(int i = 1; i <= n; ++i){
            sum[i] = a[i];
            for(auto &v : G[i]) sum[i] += a[v];
            ans[0] += sum[i];
            if(i > 1) sum[i] += a[i];
        }
        dfs(1, 0);
        for(int i = 1; i <= n; ++i){
            ans[i] = ans[0] - max(dp[1][i][0], dp[1][i][1]);
        }
        for(int i = 0; i < n; ++i) cout << ans[i] << " ";
        cout << ans[n] << endl;
    }
    return 0;
}

标签:总结,rt,le,return,10,int,cin,2020ICPC,补题
来源: https://blog.csdn.net/weixin_44059127/article/details/112850536