The Preliminary Contest for ICPC Asia Nanjing 2019

传送门

A. The beautiful values of the palace

题意：

给出一个\(n*n\)的矩阵，并满足\(n\)为奇数，矩阵中的数从右上角开始往下，类似于蛇形填数那样来填充。

之后会给出\(m\)个有效数字的坐标，坐标左下角为\((1,1)\)，右上角为\((n,n)\)，其余数字都为\(0\)。

之后会有多个询问，每个询问给出一个子矩阵，问子矩阵中元素和为多少。

思路：

• 矩阵每个位置的数值可以\(O(1)\)计算；
• 将每个询问拆分成四个询问，接下来处理的问题就是怎么维护一个二维前缀和。
• 对于一个点\((x,y)\)，很显然我们要找的点就是\((x_i,y_i)\)并满足\(x_i\leq x, y_i\leq y\)。
• 这样类似的二维偏序，有很多做法，比如cdq分治；
• 但其实并不需要，类似于扫描线的思想，按\(y\)从小到大扫描，并不断加点，利用树状数组维护即可。

代码写得有点凌乱，很多冗余...

Code

#include <bits/stdc++.h>
#define y1 skljalkd
#define MP make_pair
#define fi first
#define se second
using namespace std;
typedef long long ll;
const int N = 1e6 + 5, M = 1e5 + 5;
int T;
struct node{
    int x, y, v, id;
    bool operator < (const node &A) const {
        if(A.y == y && A.x == x) return id < A.id;
        if(A.y == y) return x < A.x;
        return y < A.y;
    }
}a[M], b[N], d[N];
int n, m, p;
int X[N], Y[N];
inline int getv(int x,int y) {
	ll k=min(min(x,y),min(n-x+1,n-y+1));
	ll ans=(ll)n*n-(ll)(n-2*(k-1))*(n-2*(k-1));
	if(x==n-k+1) {
		ans+=(n-k+1 -y+1);
	} else if(y==n-k+1) {
		ans+=n-2*k+2 + n-2*k+1 +n-2*k +(x-k+1);
	} else if(x==y) {
		ans+=n-2*k+2 + n-2*k+1;
	} else if(x>y) {
		ans+=n-2*k+2 + (n-k-x+1);
	} else if(x<y) {
		ans+=n-2*k+2 + n-2*k + y-k+1;
	}
	int res = 0;
	while(ans) {
        res += ans % 10;
        ans /= 10;
	}
	return res;
}
void Hash() {
    X[0] = Y[0] = 0;
    for(int i = 1; i <= m; i++) X[++X[0]] = a[i].x, Y[++Y[0]] = a[i].y;
    for(int i = 1; i <= 4 * p; i++) X[++X[0]] = b[i].x, Y[++Y[0]] = b[i].y;
    sort(X + 1, X + X[0] + 1);
    sort(Y + 1, Y + Y[0] + 1);
    X[0] = unique(X + 1, X + X[0] + 1) - X - 1;
    Y[0] = unique(Y + 1, Y + Y[0] + 1) - Y - 1;
    for(int i = 1; i <= m; i++) a[i].x = lower_bound(X + 1, X + X[0] + 1, a[i].x) - X;
    for(int i = 1; i <= m; i++) a[i].y = lower_bound(Y + 1, Y + Y[0] + 1, a[i].y) - Y;
    for(int i = 1; i <= 4 * p; i++) b[i].x = lower_bound(X + 1, X + X[0] + 1, b[i].x) - X;
    for(int i = 1; i <= 4 * p; i++) b[i].y = lower_bound(Y + 1, Y + Y[0] + 1, b[i].y) - Y;
}
vector <pair<int, int> > col[N];
int c[N];
ll ans[N];
int lowbit(int x) {return x & (-x);}
void upd(int x, int v) {
    for(; x < N; x += lowbit(x)) c[x] += v;
}
ll query(int x) {
    ll res = 0;
    for(; x; x -= lowbit(x)) res += c[x];
    return res;
}
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> T;
    while(T--) {
        memset(c, 0, sizeof(c));
        cin >> n >> m >> p;
        for(int i = 1; i <= m; i++) {
            cin >> a[i].x >> a[i].y;
            a[i].v = getv(a[i].x, a[i].y);
            a[i].id = 0;
        }
        for(int i = 1; i <= p; i++) {
            int x1, y1, x2, y2;
            cin >> x1 >> y1 >> x2 >> y2;
            --x1, --y1;
            int x3 = x1, y3 = y2;
            int x4 = x2, y4 = y1;
            int v1 = getv(x1, y1), v2 = getv(x2, y2), v3 = getv(x3, y3), v4 = getv(x4, y4);
            b[4 * i - 1] = {x1, y1, v1, 4 * i};
            b[4 * i] = {x2, y2, v2, 4 * i - 2};
            b[4 * i - 2] = {x3, y3, v3, 4 * i - 1};
            b[4 * i - 3] = {x4, y4, v4, 4 * i - 3};
        }
        Hash();
        for(int i = 1; i <= Y[0]; i++) col[i].clear();
        for(int i = 1; i <= m; i++) d[i] = a[i];
        for(int i = 1; i <= 4 * p; i++) d[i + m] = b[i];
        int tot = m + 4 * p;
        sort(d + 1, d + tot + 1);
        for(int i = 1; i <= tot; i++) {
            col[d[i].y].push_back(MP(i, d[i].id == 0));
        }
        for(int i = 1; i <= Y[0]; i++) {
            for(auto it : col[i]) {
                if(it.se == 1) {
                    upd(d[it.fi].x, d[it.fi].v);
                }
                if(it.se == 0) {
                    int now = it.fi;
                    ans[d[now].id] = query(d[now].x);
                }
            }
        }
        for(int i = 1; i <= p; i++) {
            ll res = ans[4 * i - 2] + ans[4 * i] - ans[4 * i - 1] - ans[4 * i - 3];
            cout << res << '\n';
        }
    }
    return 0;
}

B. super_log

题意：

定义一下式子：

\[log_a^*(x)=\left\{
\begin{aligned}
&-1,&x<1\\
&1+log_a^*(log_ax),&x\geq 1
\end{aligned}
\right.
\]

求最小的\(x\)，满足\(log_a^*(x)\geq b\)。

思路：

稍微推一下式子，会变成这样：

\[log_a^*(x)=b+log_a^*(log_a{log_a{\cdots log_ax}})
\]

那么就有\(x=a^{a^{\cdots ^{a}}}\)，这里共\(b\)个\(a\)。

之后利用广义欧拉降幂搞一下即可。

注意取模函数，这是一个技巧，有了它我们就可以不用管广义欧拉降幂中的条件了。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1000005;
bool vis[N];
int prime[N], phi[N], tot;
void pre() {
    phi[1] = 1;
    for(int i = 2; i < N; i++) {
        if(!vis[i]) {
            vis[i] = 1; prime[++tot] = i;
            phi[i] = i - 1;
        }
        for(int j = 1; j <= tot && prime[j] * i < N; j++) {
            vis[i * prime[j]] = 1;
            if(i % prime[j] == 0) {
                phi[i * prime[j]] = phi[i] * prime[j];
                break;
            }
            phi[i * prime[j]] = phi[i] * (prime[j] - 1);
        }
    }
}
ll Mod(ll a, ll b) {
    return a < b ? a : a % b + b;
}
int qp(ll a, ll b, ll p) {
    int ans = 1;
    while(b) {
        if(b & 1) ans = Mod(ans * a, p);
        a = Mod(a * a, p);
        b >>= 1;
    }
    return ans;
}
int calc(ll a, ll b, ll m) {
    if(m == 1 || !b) return 1;
    int p = phi[m];
    int x = calc(a, b - 1, p);
    return qp(a, x, m);
}
int T;
int a, b, m;
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    pre();
    cin >> T;
    while(T--) {
        cin >> a >> b >> m;
        ll ans = calc(a, b, m) % m;
        cout << ans << '\n';
    }
    return 0;
}

D. Robots

题意：

给出一张有向无环图。

现在有一个机器人在上面走，每一天可以行动一步，这一步可以选择停留原地或者沿着某一条边走。

定义每一天的消耗为已经经过天数的消耗。

求最终到达\(n\)点时的期望消耗值。

思路：

这个题怎么这么难读，感觉读不懂QAQ。

假设\(dp2[u]\)为从\(u\)出发，到达\(n\)的期望消耗值。那么就有：

\[dp2[u]=\frac{dp2[u]+dp[u]+1}{out[u]+1}+\sum_{(u,v)\in Edge}\frac{dp2[v]+dp[v]+1}{out[u]+1}
\]

分别表示停留在原地的期望消耗以及走向下一个点的期望消耗，加起来就是目前点的期望消耗。

那这里的\(dp[u]\)指的是什么？

指的就是从\(u\)到\(n\)的期望天数，有了它就相当于求出当前这天的期望消耗。

求\(dp[u]\)类似推一遍就行。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int n, m;
vector <int > g[N];
double dp[N][2];
bool vis[N];
double dfs1(int u) {
    if(u >= n) return dp[n][0] = 0;
    if(vis[u]) return dp[u][0];
    vis[u] = 1;
    double res = 0;
    for(auto it : g[u]) res += dfs1(it);
    int x = g[u].size();
    res /= (double)(x + 1);
    res = 1.0 * (x + 1) / x * (res + 1);
    return dp[u][0] = res;
}
double dfs2(int u) {
    if(u >= n) return dp[n][1] = 0;
    if(vis[u]) return dp[u][1];
    vis[u] = 1;
    double res = 0;
    for(auto it : g[u]) res += dfs2(it) + dp[it][0];
    res += dp[u][0];
    int x = g[u].size();
    res /= (double)(x + 1);
    res = 1.0 * (x + 1) / x * (res + 1);
    return dp[u][1] = res;
}
int main() {
//    ios::sync_with_stdio(false); cin.tie(0);
    int T; cin >> T;
    while(T--) {
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i++) g[i].clear();
        for(int i = 1; i <= m; i++) {
            int u, v; cin >> u >> v;
            g[u].push_back(v);
        }
        fill(vis + 1, vis + n + 1, false);
        dfs1(1);
        fill(vis + 1, vis + n + 1, false);
        dfs2(1);
        printf("%.2f\n", dp[1][1]);
    }
    return 0;
}

E. K Sum

题意：

定义函数：

\[f_n(k)=\sum_{l_1=1}^{n}\sum_{l_2=1}^{n}\cdots \sum_{l_k=1}^{n}(gcd(l_1,l_2,\cdots,l_k))^2
\]

其中\(n\leq 10^9,2\leq k\leq 10^{10^5}\)。

要求：

\[\sum_{i=2}^kf_n(i) \ \%\ 1e9+7
\]

思路：

这个题给我的感觉就是数论大杂烩...融进来了好多东西，也正好对之前的学习相当于一次复习。

开始愉快(套路)的推式子环节：

\[\begin{aligned}
f_n(k)&=\sum_{l_1=1}^{n}\sum_{l_2=1}^{n}\cdots \sum_{l_k=1}^{n}(gcd(l_1,l_2,\cdots,l_k))^2\\
&=\sum_dd^2\sum_{l_1=1}^{n}\sum_{l_2=1}^{n}\cdots \sum_{l_k=1}^{n}[gcd(l_1,l_2,\cdots,l_k)=d]\\
&=\sum_dd^2\sum_{l_1=1}^{\frac{n}{d}}\sum_{l_2=1}^{\frac{n}{d}}\cdots \sum_{l_k=1}^{\frac{n}{d}}[gcd(l_1,l_2,\cdots,l_k)=1]\\
&=\sum_dd^2\sum_{l_1=1}^{\frac{n}{d}}\sum_{l_2=1}^{\frac{n}{d}}\cdots \sum_{l_k=1}^{\frac{n}{d}}\sum_{t|gcd(l_1,l_2,\cdots,l_k)}\mu(t)\\
&=\sum_dd^2\sum_t\mu(t)\sum_{l_1=1}^{\frac{n}{td}}\sum_{l_2=1}^{\frac{n}{td}}\cdots \sum_{l_k=1}^{\frac{n}{td}}1
\end{aligned}
\]

之后令\(T=td\)，就有：

\[=\sum_{T=1}^{n}\sum_{d|T} d^2\mu(\frac{T}{d})\sum_{l_1=1}^{\frac{n}{T}}\sum_{l_2=1}^{\frac{n}{T}}\cdots \sum_{l_k=1}^{\frac{n}{T}}1
\]

一直化到这一步都是比较套路的部分。

观察后面那一堆求和式，其实可以等价于\(\lfloor\frac{n}{T}\rfloor^k\)，而\(\sum_{d|T} d^2\mu(\frac{T}{d})\)就相当于\(\mu * id^2\)。

所以所求式子可以化为：

\[\begin{aligned}
\sum_{i=2}^kf_n(i)&=\sum_{i=1}^k\sum_{T=1}^{n}\sum_{d|T} d^2\mu(\frac{T}{d})\lfloor\frac{n}{T}\rfloor^k\\
&=\sum_{T=1}^n(\sum_{i=1}^k\lfloor\frac{n}{T}\rfloor^k)(\sum_{d|T} d^2\mu(\frac{T}{d}))
\end{aligned}
\]

因为注意到\(k\)的范围可能很大，所以就交换一下和式，发现第一个括号内就相当于一个等比数列求和，那么就有一个公式，并且在公比不为1的情况下，\(k\)可以直接模\(1e9+6\)来处理。如果公比为1，特判一下即可。

主要就是后面那一堆和式怎么搞，设\(g(n)=\sum_{d|n}d^2\mu(\frac{n}{d})\)。

可以发现，\(g\)也为一个积性函数，那么我们就可以将值线性筛筛出来:\(g(1)=1,g(p)=p^2\)，如果我们能找到\(g(p^k)\)的值，那么就很好筛了。

因为后面有一个\(\mu\)，所以\(g(p^k)=-p^{2k-2}+p^{2k}=p^{2k-2}(p^2-1)\)。

那么就有\(g(p^k)=g(p^{k-1})\cdot p^2\)。

由于是积性函数，那么就很好筛了~每一个素因子直接独立出来计算，最后乘起来，写在代码里就直接拆就是了。

观察到第一个括号部分可以直接数论分块，那么这就需要我们求后面一部分的前缀和，所以直接杜教筛来搞后面那一块就行，找\(I\)卷积一下即可。

复杂度：\(O\)(肯定能过)。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5, MOD = 1e9 + 7, inv6 = 166666668;
ll n, k, k2;
char s[N];
int T, tot;
ll sum[N], prime[N], g[N];
bool vis[N];
void pre() {
    g[1] = vis[1] = 1;
    for(int i = 2; i < N; i++) {
        if(!vis[i]) {
            vis[i] = 1; prime[++tot] = i;
            g[i] = (1ll * i * i - 1) % MOD;
        }
        for(int j = 1; j <= tot && i * prime[j] < N; j++) {
            vis[i * prime[j]] = 1;
            if(i % prime[j] == 0) {
                g[i * prime[j]] = g[i] * prime[j] % MOD * prime[j] % MOD;
                break;
            }
            g[i * prime[j]] = g[i] * g[prime[j]] % MOD;
        }
    }
    for(int i = 1; i < N; i++) sum[i] = (sum[i - 1] + g[i]) % MOD;
}
ll qp(ll a, ll b) {
    ll ans = 1;
    while(b) {
        if(b & 1) ans = ans * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return ans;
}
ll calc(int q) {
    if(q == 1) return k2 - 1;
    ll b = 1 - q + MOD;
    b = qp(b, MOD - 2);
    ll a = 1ll * q * (1 - qp(q, k) + MOD) % MOD;
    return (a * b % MOD - q + MOD) % MOD;
}
unordered_map <int, int> mp;
ll djs(int x) {
    if(x < N) return sum[x];
    if(mp.find(x) != mp.end()) return mp[x];
    ll ans = 1ll * x * (x + 1) % MOD * (2 * x + 1) % MOD * inv6 % MOD;
    for(ll i = 2, j; i <= x; i = j + 1) {
        j = x / (x / i);
        ans -= (j - i + 1) * djs(x / i) % MOD;
        ans %= MOD;
    }
    if(ans < 0) ans += MOD;
    return mp[x] = ans;
}
int main() {
    //freopen("input.in", "r", stdin);
    ios::sync_with_stdio(false); cin.tie(0);
    pre();
    cin >> T;
    while(T--) {
        cin >> n >> s + 1;
        int len = strlen(s + 1);
        k = k2 = 0;
        for(int i = 1; i <= len; i++) {
            k = (k * 10 + (s[i] - '0')) % (MOD - 1);
            k2 = (k2 * 10 + (s[i] - '0')) % MOD;
        }
        ll ans, res = 0;
        for(ll i = 1, j; i <= n; i = j + 1) {
            j = n / (n / i);
            ans = calc(n / i) * (djs(j) - djs(i - 1) + MOD) % MOD;
            res = (res + ans) % MOD;
        }
        cout << res << '\n';
    }
    return 0;
}

F. Greedy Sequence

很容易分析，对一个数求答案的话，就是找相应区间内小于他的最大的数，所以就有很多种做法。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
int T, n, k;
int maxv[N << 2];
void push_up(int o) {
    maxv[o] = max(maxv[o << 1], maxv[o << 1|1]);
}
void build(int o, int l, int r) {
    maxv[o] = 0;
    if(l == r) return;
    int mid = (l + r) >> 1;
    build(o << 1, l, mid); build(o << 1|1, mid + 1,r);
}
void update(int o, int l, int r, int p, int v) {
    if(l == r) {
        maxv[o] = v; return;
    }
    int mid = (l + r) >> 1;
    if(p <= mid) update(o << 1, l, mid, p, v);
    else update(o << 1|1, mid + 1, r, p, v);
    push_up(o);
}
int query(int o, int l, int r, int L, int R) {
    if(L > R) return 0;
    if(L <= l && r <= R) return maxv[o];
    int mid = (l + r) >> 1;
    int res = 0;
    if(L <= mid) res = max(res, query(o << 1, l, mid, L, R));
    if(R > mid) res = max(res, query(o << 1|1, mid + 1, r, L, R));
    return res;
}
int a[N], ans[N], pos[N];
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    cin >> T;
    while(T--) {
        cin >> n >> k;
        build(1, 1, n);
        for(int i = 1; i <= n; i++) cin >> a[i], pos[a[i]] = i;
        for(int i = 1; i <= n; i++) {
            int mx = query(1, 1, n, max(1, pos[i] - k), pos[i] - 1);
            mx = max(mx, query(1, 1, n, pos[i] + 1, min(n, pos[i] + k)));
            ans[i] = ans[mx] + 1;
            update(1, 1, n, pos[i], i);
        }
        for(int i = 1; i <= n; i++) cout << ans[i] << " \n"[i == n];
    }
    return 0;
}

H. Holy Grail

签到题，跑六次最短路即可。

Code

#include<bits/stdc++.h>
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
const int MAXN = 3e2+5,MAXM = 5e2+5,MOD = 20130427,INF = 0x3f3f3f3f,N=100050;
const ll INFL = 0x3f3f3f3f3f3f3f3f;
const db eps = 1e-9;
#define lson o<<1,l,m
#define rson o<<1|1,m+1,r
#define mid l + ((r-l)>>1)
#define rep(i,a,b) for(register int i=(a);i<=(b);i++)
#define vii vector<pair<int,int>>
#define vi vector<int>
using namespace std;

struct Edge{
    int u,v;
    ll w;
}e[MAXM];
int t,n,m,start[10],target[10];
ll d[MAXN];
int main(){
    ios::sync_with_stdio(false);cin.tie(0);
    //freopen("../A.in","r",stdin);
    //freopen("../A.out","w",stdout);
    cin>>t;
    while(t--){
        cin>>n>>m;
        for(int i=1;i<=m;i++){
            cin>>e[i].u>>e[i].v>>e[i].w;
        }
        for(int i=1;i<=6;i++)cin>>start[i]>>target[i];
        for(int s=1;s<=6;s++){
            for(int i=0;i<n;i++)d[i]=INF;
            d[target[s]]=0;
            for(int i=1;i<n;i++){
                for(int j=1;j<=m;j++){
                    d[e[j].v]=min(d[e[j].v],d[e[j].u]+e[j].w);
                }
            }
            cout << -d[start[s]]<<'\n';
            e[++m]={start[s],target[s],-d[start[s]]};
        }
    }
    return 0;
}

I. Washing clothes

题意：

现在有\(n\)个人要洗衣服，有一个洗衣机。

这些人都会在\(a_i\)的时间来，并且有两种选择，花\(y\)的时间手洗衣服，或者花\(x\)的时间洗衣机洗。洗衣机每次只能洗一个人的衣服，手洗可以大家一起洗。

现在问当\(x\in [1,y]\)时，洗完所有衣服的最终时刻是多少。

思路：

• 很显然我们要从后面开始考虑，这样才能让最终时刻缩短。
• 并且有个这样的观察：最优情况中存在一个位置\(p\)，\(p\)之后的所有人都是洗衣机洗，前面的都是手洗。
• 简略证明(口胡)：若\(i,k\)位置的人都是洗衣机洗，\(i<j<k\)，并且\(j\)是用手洗的，那么很显然，\(i\)用洗衣机洗肯定不如\(j\)用洗衣机洗。
• 所以就直接枚举后面有多少个人用洗衣机来洗就行了。
• 但复杂度是\(O(n^2)\)的，这里又有个观察，就是用洗衣机的人不会超过\(\lfloor\frac{m}{x}\rfloor\)个。
• 为什么？
• 人再多点，对于某个人来说，还不如他手洗呢。

所以复杂度优化到了\(O(nlogn)\)。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e6 + 6;
int a[N];
int n, y;
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    while(cin >> n >> y) {
        for(int i = 1; i <= n; i++) cin >> a[i];
        sort(a + 1, a + n + 1);
        for(int x = 1; x <= y; x++) {
            ll ans = 0;
            int p = min(n, y / x);
            if(p < n) ans = a[n - p] + y;
            for(int i = n; i > n - p; i--) ans = max(ans, a[i] + 1ll * (n - i + 1) * x);
            cout << ans << " \n"[x == y];
        }
    }
    return 0;
}