NCD2019部分题解

A

解题思路

  突破点在二分答案上，如果想到二分的话后面就好做了。
  假设我们二分答案的大小为x，判断是否可行，首先肯定需要在长度不小于2x的线段中找。考虑枚举竖线来找符合条件的横线，对于一条竖线\({x_1, y_1, c_1}(x_1 \leq y_1)\)来说，需要判断是否存在一条横线\({x_2, y_2, c_2}(x_2\leq y_2)\)，满足\(x_1+x \leq c_2 \leq y_1-x\)和\(x_2+x \leq c_1 \leq y_2-x\)，我们的问题有两个维度，如果想同时判断的话十分麻烦，可以考虑如何消去其中一维的影响，考虑另一维。
  这里有一个经典套路，我们发现对于横坐标x，一共分为三类，一类是横线的左端点，一类是横线的右端点，还有一类是竖线的横坐标。我们对于所有横坐标以及种类进行双关键字排序，从小到大遍历这些横坐标，如果当前横坐标是左端点，我们就把它对应的横线的纵坐标加进集合里，如果是右端点，因为横坐标是递增的，那么这个点对应的横线必定和后面的竖线没有交叉，将其从集合中删去，如果是竖线的横坐标，那我们就从集合里找一个大于等于竖线较小的纵坐标的最小的点，如果这个点小于竖线的较大的那个纵坐标，就说明有解。

代码

struct INFO {
    int a, b, c, tp;
} sgx[maxn], sgy[maxn];
int n, m; 
int check(int x) {
    int t1 = 0, t2 = 0;
    vector<INFO> sg;
    for (int i = 1; i<=n; ++i) {
        if (sgx[i].b-sgx[i].a<2*x) continue;
        sg.push_back({sgx[i].a+x, 0, sgx[i].c, 1});
        sg.push_back({sgx[i].b-x, 0, sgx[i].c, 3});
    }
    for (int i = 1; i<=m; ++i) {
        if (sgy[i].b-sgy[i].a<2*x) continue;
        sg.push_back({sgy[i].c, sgy[i].a+x, sgy[i].b-x, 2});
    }
    multiset<int> st;
    sort(sg.begin(), sg.end(), [](INFO A, INFO B) {return A.a==B.a ? A.tp<B.tp:A.a<B.a;});
    for (auto v : sg) {
        if (v.tp==1) st.insert(v.c);
        else if (v.tp==3) st.erase(st.find(v.c));
        else {
            auto it = st.lower_bound(v.b);
            if (it!=st.end() && *it<=v.c) return 1;
        }
    }
    return 0;
}
int main() { 
    IOS;
    int __; cin >> __;
    while(__--) {
        cin >> n >> m;
        for (int i = 1; i<=n; ++i) {
            cin >> sgx[i].a >> sgx[i].b >> sgx[i].c;
            if (sgx[i].a>sgx[i].b) swap(sgx[i].a, sgx[i].b);
        }
        for (int i = 1; i<=m; ++i) {
            cin >> sgy[i].a >> sgy[i].b >> sgy[i].c;
            if (sgy[i].a>sgy[i].b) swap(sgy[i].a, sgy[i].b);
        }
        int l = 0, r = 1e5;
        while(l<r) {
            int mid = (l+r+1)>>1;
            if (check(mid)) l = mid;
            else r = mid-1;
        }
        cout << l << endl;
    }
    return 0;   
} 

B

解题思路

  不难看出，能抓住Hasan的边是割边，而别的边没有影响。我们先对图中的所有连通块中的边双连通分量进行缩点，缩点后的图就变成了一片森林，我们在森林中的两棵树中连边，会变成一棵树，而割边数量会加1，如果我们对其中的一棵树上的两点连一条边，会发现两点简单路径上的所有点都会变成一个新的边双连通分量，减少的割边数量就是他们的最短距离，所以我们需要找到每棵树上任意两点的最长的最短距离，即树的直径，然后用割边数量-树的直径即为答案。

代码

const int maxn = 1e6+10;                                                               
const int maxm = 1e6+10;
struct E {
    int to, nxt;
} e[maxm];
int h[maxn], tot = 1;
void add(int u, int v) {
    e[++tot] = {v, h[u]};
    h[u] = tot;
}
int n, m;
int dfn[maxn], low[maxn], __dfn;
int sk[maxn], tp, dcc, id[maxn];
int isbrige[maxn];
vector<int> g[maxn];
void tarjan(int u, int fa) {
    dfn[u] = low[u] = ++__dfn;
    sk[++tp] = u;
    for (int i = h[u]; i; i = e[i].nxt) {
        if ((fa^1)==i) continue;
        int v = e[i].to;
        if (!dfn[v]) {
            tarjan(v, i);
            low[u] = min(low[u], low[v]);
            if (low[v]>dfn[u]) isbrige[i] = isbrige[i^1] = 1;
        }
        else low[u] = min(low[u], dfn[v]);
    }
    if (low[u]==dfn[u]) {
        int v; ++dcc;
        do {
            v = sk[tp--];
            id[v] = dcc;
        } while(v!=u);
    }
}
int maxx, vis[maxn];
int dfs(int u) {
    vis[u] = 1;
    int f = 0;
    for (auto v : g[u]) {
        if (vis[v]) continue;
        int dis = dfs(v)+1;
        maxx = max(maxx, f+dis);
        f = max(f, dis);
    }
    return f;
}
void init() {
    __dfn = tp = dcc = 0;
    clr(isbrige, 0);
    tot = 1;
    for (int i = 0; i<=n; ++i) {
        h[i] = vis[i] = dfn[i] = low[i] = sk[i] = id[i] = 0;
        g[i].clear();
    }
}
int main() { 
    IOS;
    int __; cin >> __;
    while(__--) {
        cin >> n >> m;
        init();
        for (int i = 1, a, b; i<=m; ++i) {
            cin >> a >> b;
            add(a, b); add(b, a);
        }
        for (int i = 1; i<=n; ++i) 
            if (!dfn[i]) tarjan(i, -1);
        int ans = 0;
        for (int i = 1; i<=n; ++i)
            for (int j = h[i]; j; j = e[j].nxt) {
                int v = e[j].to;
                if (isbrige[j]) g[id[i]].push_back(id[v]), ++ans;
            }
        ans /= 2;
        maxx = 0;
        for (int i = 1; i<=dcc; ++i)
            if (!vis[i]) dfs(i);
        ans -= maxx;
        cout << ans << endl;
    }
    return 0;   
} 

C

解题思路

  这题也是经典套路了，考虑\(O(n^2)\)的做法，设dp[j]为以j结尾的lis长度，我们在遍历前面比当前a[i]小的数a[j]的时候，如果dp[j]可以更新答案，那么方案数同dp[j]的方案数，如果dp[j]+1和dp[i]相同，那么方案数就可以累加。

代码

const int maxn = 2e5+10;                                                               
const int maxm = 2e6+10;
int a[maxn], dp[maxn], cnt[maxn];
int main() { 
    IOS;
    int __; cin >> __;
    while(__--) {
        int n; cin >> n;
        for (int i = 1; i<=n; ++i) cin >> a[i];
        int maxx = 0, sum = 0;
        for (int i = 1; i<=n; ++i) {
            cnt[i] = dp[i] = 1;
            for (int j = i-1; j>=1; --j) {
                if (a[j]<a[i]) {
                   if (dp[i]<dp[j]+1) {
                       dp[i] = dp[j]+1;
                       cnt[i] = cnt[j];
                   }
                   else if (dp[i]==dp[j]+1) {
                       cnt[i] = (cnt[i]+cnt[j])%MOD;
                   }
                }
            }
            if (dp[i]>maxx) maxx = dp[i], sum = cnt[i];
            else if (dp[i]==maxx) sum = (sum+cnt[i])%MOD;
        }
        cout << maxx << ' ' << sum << endl;
    }
    return 0;   
}

D略

E

解题思路

  如果没有修改操作只有询问的话，我们求正反两个字符串的哈希值就能做，如果加上修改操作，比如i的位置修改一下，对于正的字符串来说，i到n的哈希值会改变，对于颠倒后的字符串的哈希值来说，n-i+1到n的哈希值会改变。
  如果是按照常规的计算哈希值的方法的话，我们就是对区间修改一个变量，这样维护起来十分的痛苦。我的方法是把每一个哈希值都往后补0，使得每一个哈希值对应的都是P进制下的一个n位整数，这样带来的好处是，由于长度是固定的，那么修改i的值之后，i到n这个区间上改变的值也是一样的，我们区间修改的就是一个常量了。这样我们只要写一个区间修改，单点询问的线段树。修改操作就不说了，对于查询，我们用r对应的值减去l-1对应的值，再去掉末尾0，得到一段字符串的哈希值，然后用类似的方法求出颠倒后的区间的哈希值，两者比较即可。

const int maxn = 1e5+10;                                                               
const int maxm = 2e6+10;
ll lz[maxn<<2][2], tr[maxn<<2][2], f[maxn], h[maxn][2];
inline void push_down(int rt, int s) {
    if (lz[rt][s]) {
        tr[rt<<1][s] = (tr[rt<<1][s]+lz[rt][s]+MOD)%MOD;
        tr[rt<<1|1][s] = (tr[rt<<1|1][s]+lz[rt][s]+MOD)%MOD;
        lz[rt<<1][s] = (lz[rt<<1][s]+lz[rt][s]+MOD)%MOD;
        lz[rt<<1|1][s] = (lz[rt<<1|1][s]+lz[rt][s]+MOD)%MOD;
        lz[rt][s] = 0;
    }
}
void build(int rt, int l, int r, int s) {
    tr[rt][s] = lz[rt][s] = 0;
    if (l==r) {
        tr[rt][s] = h[l][s];
        return;
    }
    int mid = (l+r)>>1;
    build(rt<<1, l, mid, s);
    build(rt<<1|1, mid+1, r, s);
}
void update(int rt, int l, int r, int L, int R, int V, int s) {
    if (l>=L && r<=R) {
        tr[rt][s] = (tr[rt][s]+V+MOD)%MOD;
        lz[rt][s] = (lz[rt][s]+V+MOD)%MOD;
        return;
    }
    push_down(rt, s);
    int mid = (l+r)>>1;
    if (L<=mid) update(rt<<1, l, mid, L, R, V, s);
    if (R>mid) update(rt<<1|1, mid+1, r, L, R, V, s);
}
ll ask(int rt, int l, int r, int pos, int s) {
    if (!pos) return 0;
    if (l==r) return tr[rt][s];
    push_down(rt, s);
    int mid = (l+r)>>1;
    if (pos<=mid) return ask(rt<<1, l, mid, pos, s);
    else return ask(rt<<1|1, mid+1, r, pos, s);
}
void ck(int rt, int l, int r, int s) {
    if (l==r) {
        cout << tr[rt][s] << ' ';
        return;
    }
    push_down(rt, s);
    int mid = (l+r)>>1;
    ck(rt<<1, l, mid, s);
    ck(rt<<1|1, mid+1, r, s);
}
char str[maxn], str2[maxn];
int n, m;
void change(int pos, ll ff) {
    ll x = 1ll*(str[pos])*f[n-pos]%MOD;
    update(1, 1, n, pos, n, MOD+ff*x, 0);
    int rpos = n-pos+1;
    ll y = 1ll*(str2[rpos])*f[n-rpos]%MOD;
    //cout << x << ' ' << y << endl;
    update(1, 1, n, rpos, n, MOD+ff*y, 1);
}
ll qp(ll x, ll y) {
    x %= MOD;
    ll res = 1;
    while(y) {
        if (y&1) res = res*x%MOD;
        x = x*x%MOD;
        y >>= 1;
    }
    return res;
}
int main() { 
    IOS;
    f[0] = 1;
    for (int i = 1; i<maxn; ++i) f[i] = f[i-1]*P%MOD;
    int __; cin >> __;
    while(__--) {
        cin >> n >> m;
        cin >> str+1;
        for (int i = 1; i<=n; ++i) str2[i] = str[n-i+1];
        for (int i = 1; i<=n; ++i) h[i][0] = (h[i-1][0]+1ll*(str[i])*f[n-i])%MOD;
        for (int i = 1; i<=n; ++i) h[i][1] = (h[i-1][1]+1ll*(str2[i])*f[n-i])%MOD;
        build(1, 1, n, 0);
        build(1, 1, n, 1);
        int op, l, r, pos; char ch[10];
        while(m--) {
            cin >> op;
            if (op==1) {
                cin >> pos >> ch;
                change(pos, -1);
                str[pos] = ch[0];
                str2[n-pos+1] = ch[0];
                change(pos, 1);
            }
            else {
                cin >> l >> r;
                ll A = (ask(1, 1, n, r, 0)-ask(1, 1, n, l-1, 0)+MOD)%MOD;
                //cout << A << endl;
                A = A*qp(f[n-r], MOD-2)%MOD;
                A = (A%MOD+MOD)%MOD;
                l = n-l+1, r = n-r+1;
                if (l>r) swap(l, r);
                //cout << l << ' ' << r << endl;
                ll B = (ask(1, 1, n, r, 1)-ask(1, 1, n, l-1, 1)+MOD)%MOD;
                B = B*qp(f[n-r], MOD-2)%MOD;
                B = (B%MOD+MOD)%MOD;
                //cout << A << ' ' << B << endl;
                if (A==B) cout << "Adnan Wins" << endl;
                else cout << "ARCNCD!" << endl;
            }
            //ck(1, 1, n, 0); cout << endl;
            //ck(1, 1, n, 1); cout << endl;
            //cout << "!" << endl;
        }
    }
    return 0;   
} 

F略

G

  (代补)

H略

J

解题思路

  很简单的题，题目就两种操作，一种区间加1，一种询问区间出现最多的数，而且就一个询问，直接差分数组做就行了。

const int maxn = 1e6+10;                                                               
const int maxm = 1e6+10;
int a[maxn], b[maxn], sub[maxn];
int main() { 
    IOS;
    int __; cin >> __;
    while(__--) {
        int n, m; cin >> n >> m;
        for (int i = 0; i<=n; ++i) sub[i] = 0;
        for (int i = 1; i<=m; ++i) cin >> a[i], --a[i];
        for (int i = 1; i<=m; ++i) {
            cin >> b[i];
            if (abs(b[i])==n) {
                ++sub[a[i]];
                --sub[a[i]+1];
                ++sub[0];
                --sub[n];
            }
            else if (b[i]>=0) {
                ++sub[a[i]];
                --sub[min(n, a[i]+b[i]+1)];
                if (a[i]+b[i]>=n) {
                    b[i] = (a[i]+b[i])%n;
                    ++sub[0];
                    --sub[b[i]+1];
                }
            }
            else if (b[i]<0) {
                ++sub[max(0, a[i]+b[i])];
                --sub[a[i]+1];
                if (a[i]+b[i]<0) {
                    b[i] = (a[i]+b[i])+n;
                    ++sub[b[i]];
                    --sub[n];
                }
            }
        }
        for (int i = 1; i<=n; ++i) sub[i] += sub[i-1];
        int c = 0;
        for (int i = 0; i<n; ++i) {
            if (sub[i]>sub[c]) c = i;
            //cout << sub[i] << endl;
        }
        cout << c+1 << ' ' << sub[c] << endl;
    }   
    return 0;   
} 

K略

L略

M

  经典取log，需要注意底数为0的时候会返回-inf，而两个-inf不相等