牛客小白月赛12题解简录

题目传送 

官方题解传送

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
 
const int maxm = 1e5 + 5;
int n, m, ans;
pair<int, int> p[maxm];
 
int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
     
    cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        cin >> p[i].first >> p[i].second;
    }
    p[++m] = {n + 1, n + 1};
    sort(p + 1, p + 1 + m);
    for (int i = 1, last = 1, pos; i <= m; i = pos + 1){
        if (p[i].first > last) {
            cout << -1 << endl;
            return 0;
        }
        pos = i;
        int tmp = p[pos].second;
        while (pos < m && p[pos + 1].first <= last) {
            tmp = max(tmp, p[++pos].second);
        }
        last = tmp + 1;
        ans++;
        if (last > n)    break;
    }
    cout << ans << endl;
    return 0;
}

#include <cstdio>
#include <cmath>
 
typedef long long ll;
int T;
ll a, b, p;
 
inline ll ksc(ll a, ll b, ll mod) {
    return ((a * b - (ll)((long double)a / mod * b) * mod) % mod + mod) % mod;
}
 
inline ll ksm(ll a, ll b, ll p) {
    ll res = 1ll;
    for (; b; b >>= 1) {
        if (b & 1)    res = ksc(res, a, p);
        a = ksc(a, a, p);
    }
    return res;
}
 
int main() {
    for (scanf("%d", &T); T; T--) {
        scanf("%lld %lld %lld", &a, &b, &p);
        printf("%lld
", ksm(a % p, b, p));
    }
}

#include <cstdio>

typedef long long ll;
const int maxn = 13e6 + 5;
const int mod = 1e9 + 7;
int n, primes[maxn], tot, val[maxn];
ll ans;
bool vis[maxn];

int ksm(int a, int b) {
    int res = 1ll;
    for (; b; b >>= 1) {
        if (b & 1)    res = (ll)res * a % mod;
        a = (ll)a * a % mod;
    }
    return res;
}

void pre(int n) {
    val[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            val[i] = ksm(i, n);
            primes[++tot] = i;
        }
        for (int j = 1; j <= tot && primes[j] * i <= n; j++) {
            vis[primes[j] * i] = true;
            val[primes[j] * i] = (ll)val[primes[j]] * val[i] % mod;
            if (i % primes[j] == 0)    break;
        }
    }
}

int main() {
    scanf("%d", &n);
    pre(n);
    for (int i = 1; i <= n; i++)
        ans = ans ^ val[i];
    printf("%lld
", ans);
    return 0;
}

D题不会推式子嘤。反演什么的更不敢试了，欧拉累加能过就行了（逃

#include <cstdio>
#include <cstring>
#include <cctype>

template <typename T> void read(T &x) {
    x = 0;
    int s = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')    s = -1;
    for (; isdigit(c); c = getchar())
        x = x * 10 + c - 48;
}

template <typename T> void write(T x) {
    if (x < 0)    x = -x, putchar('-');
    if (x > 9)    write(x / 10);
    putchar(x % 10 + '0');
}

template <typename T> void writeln(T x) {
    write(x);
    puts("");
}

const int maxn = 1e6 + 5;
int n;
int phi[maxn], primes[maxn], tot;
bool vis[maxn];
long long val[maxn];

void euler(int n) {
    phi[1] = 1;
    for (int i = 2; i <= n; i++) {
        if (!vis[i]) {
            primes[++tot] = i;
            phi[i] = i - 1;
        }
        for (int j = 1; j <= tot && primes[j] * i <= n; j++) {
            vis[primes[j] * i] = true;
            phi[primes[j] * i] = phi[i] * (i % primes[j] ? primes[j] - 1 : primes[j]);
            if (i % primes[j] == 0)    break;
        }
    }
}

void solve() {
    for (int d = 1; d <= n; d++) {
        val[d]++;
        for (int k = 2; k * d <= n; k++) {
            val[k * d] += (long long)phi[k] * k / 2;
        }
    }
    for (int i = 1; i <= n; i++) {
        writeln(val[i]);
    }
}

int main() {
    read(n);
    euler(n);
    solve();
    return 0;
}

#include <cstdio>

const int maxn = 2e5 + 5;
int N, K, a[maxn];

bool ok(int len) {
    long long res = 0;
    for (int i = 1; i <= N; i++)
        res += a[i] / len;
    return res >= K;
}

int main() {
    scanf("%d %d", &N, &K);
    for (int i = 1; i <= N; i++)
        scanf("%d", &a[i]);
    int l = 1, r = 1e9, ans;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (ok(mid)) {
            ans = mid;
            l = mid + 1;
        } else    r = mid - 1;
    }
    printf("%d
", ans);
    return 0;
}

F题说一说。

无脑树状数组显然会爆时间，命题人的方法是sqrt一个块作为界限，对于小复杂度的进行暴力插，大复杂度修改值的记录在桶里，然后每次询问时询问完树状数组再暴力扫一遍块里我们还应该加上的部分。温和地缓解了复杂度压力吧。

#include <cstdio>
#include <cctype>
#include <cmath>

typedef long long ll;
const int maxn = 1e5 + 5;
int N, M, T;
ll F[maxn], val[maxn];

template <typename T> void read(T &x) {
    x = 0;
    int s = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')    s = -1;
    for (; isdigit(c); c = getchar())
        x = x * 10 + c - 48;
    x *= s;
}

template <typename T> void write(T x) {
    if (x < 0)    x = -x, putchar('-');
    if (x > 9)    write(x / 10);
    putchar(x % 10 + '0');
}

template <typename T> void writeln(T x) {
    write(x);
    puts("");
}

void Add(int x, int val) {
    for (; x <= N; x += x&-x)
        F[x] += val;
}

ll Query(int x) {
    ll ret = 0;
    for (; x; x -= x&-x)
        ret += F[x];
    return ret;
}

ll cal(int n) {
    ll ret = Query(n);
    for (int i = 1; i <= T; i++) {
        ret += val[i] * (n / i);
    }
    return ret;
}

int main() {
    read(N), read(M);
    for (T = sqrt(N); M; M--) {
        int op, a, b;
        read(op), read(a), read(b);
        if (op == 1) {
            if (a > T) {
                for (int i = a; i <= N; i += a)
                    Add(i, b);
            } else {
                val[a] += b;
            }
        } else {
            writeln(cal(b) - cal(a - 1));
        }
    }
    return 0;
}

我又试了试，验题人的做法，然后最后一个点T了……也贴这吧。思路是树状数组只修改这个数字D，不用修改D的倍数，然后询问时用整除分块+树状数组查询前缀和的方式。

update：验题人本人代码也被T了233……

#include <cstdio>
 
typedef long long ll;
const int maxn = 1e5 + 5;
int N, M;
ll F[maxn];
 
void Add(int x, int val) {
    for (; x <= N; x += x&-x)
        F[x] += val;
}
 
ll Query(int x) {
    ll ret = 0;
    for (; x; x -= x&-x)
        ret += F[x];
    return ret;
}
 
ll cal(int n) {
    ll ret = 0;
    for (int l = 1, r; l <= n; l = r + 1) {
        r = n / (n / l);
        ret += (Query(r) - Query(l - 1)) * (n / l);
    }
    return ret;
}
 
int main() {
    for (scanf("%d %d", &N, &M); M; M--) {
        int op, a, b;
        scanf("%d %d %d", &op, &a, &b);
        if (op == 1) {
            Add(a, b);
        } else {
            printf("%lld
", cal(b) - cal(a - 1));
        }
    }
    return 0;
}

#include <cstdio>
#include <algorithm>

long long a, b;
char s[100005];

int main() {
    scanf("%lld %lld %s", &a, &b, s);
    printf("%lld
", std::__gcd(a, b));
}

H题说一说。

对所有的子树加操作，考虑树剖。把树建成以后dfs序一下进行转换会使得父子兄弟节点都挨着，这样就好维护了。（树剖是用线段树，本题官解用的差分树状数组。）

离线。之后重读一遍M个操作，如果是操作一，那这个点是新建的，则把它一个人的值清零（操作二会导致之前它还没出现但是却有值）；

如果是操作二，则把这个点加个值，因为树状数组维护了前缀和，所以如果查询的话其实他（dfs序）之后的点也加了值，所以差分一下，在孩子以后的点再减去这个不应属于它们的值；

操作三询问，直接询问前缀和即可。因为我们差分了，所以这个查询只会包含它本身及其各位祖先节点加过的值，正是所需。

#include <cstdio>
#include <cctype>
#include <vector>
using namespace std;

template <typename T> void read(T &x) {
    x = 0;
    int s = 1, c = getchar();
    for (; !isdigit(c); c = getchar())
        if (c == '-')    s = -1;
    for (; isdigit(c); c = getchar())
        x = x * 10 + c - 48;
    x *= s;
}

template <typename T> void write(T x) {
    if (x < 0)    x = -x, putchar('-');
    if (x > 9)    write(x / 10);
    putchar(x % 10 + '0');
}

template <typename T> void writeln(T x) {
    write(x);
    puts("");
}

const int maxn = 1e5 + 5, maxm = 4e5 + 5;
int M, tot, time, DFN[maxn], SIZE[maxn];
vector<int> v[maxn];

struct Operation {
    int op, i, a;
}OP[maxm];

struct BIT {
    int F[maxn];
    
    void Update(int pos, int val) {
        for (; pos <= time; pos += pos&-pos)
            F[pos] += val;
    }
    
    void Add(int l, int r, int val) {
        Update(l, val);
        Update(r, -val);
    }
    
    int Query(int pos) {
        int ret = 0;
        for (; pos; pos -= pos&-pos)
            ret += F[pos];
        return ret;
    }
}T;

void dfs(int cur) {
    DFN[cur] = ++time;
    SIZE[cur] = 1;
    for (auto son : v[cur]) {
        dfs(son);
        SIZE[cur] += SIZE[son];
    }
}

int main() {
    read(M);
    for (int i = 1; i <= M; i++) {
        read(OP[i].op), read(OP[i].i);
        if (OP[i].op == 1) {
            v[OP[i].i].push_back(++tot);
        } else if (OP[i].op == 2) {
            read(OP[i].a);
        }
    }
    dfs(0);
    tot = 0;
    for (int i = 1; i <= M; i++) {
        if (OP[i].op == 1) {
            ++tot;
            T.Add(DFN[tot], DFN[tot] + 1, -T.Query(DFN[tot]));
        } else if (OP[i].op == 2) {
            int curnode = OP[i].i;
            T.Add(DFN[curnode], DFN[curnode] + SIZE[curnode], OP[i].a);
        } else {
            writeln(T.Query(DFN[OP[i].i]));
        }
    }
    return 0;
}

#include <cstdio>
#define min(a, b) a < b ? a : b

const int maxn = 1e5 + 5;
const int maxm = 6e5 + 5;
int N, M, tot, time, ans;
int head[maxn], DFN[maxn], low[maxn];
bool vis[maxn];
struct EDGE {
    int to, nxt;
}e[maxm];

void add(int u, int v) {
    e[++tot].to = v;
    e[tot].nxt = head[u];
    head[u] = tot;
}

void dfs(int cur, int fa) {
    DFN[cur] = low[cur] = ++time;
    vis[cur] = true;
    for (int i = head[cur]; i; i = e[i].nxt) {
        int son = e[i].to;
        if (!vis[son]) {
            dfs(son, cur);
            low[cur] = min(low[cur], low[son]);
            if (low[son] > DFN[cur])
                ans++;
        } else if (son != fa) {
            low[cur] = min(low[cur], DFN[son]);
        }
    }
}

int main() {
    scanf("%d %d", &N, &M);
    for (int i = 1; i <= M; i++) {
        int u, v;
        scanf("%d %d", &u, &v);
        add(u, v);
        add(v, u);
    }
    dfs(1, 0);
    printf("%d
", M - ans);
    return 0;
}

J题说一说。

既然只有26个字母，考虑往这上转化。做法是：因为只是子序列就行，所以贪心选取，优先选取前面的位置。O（26*len）的复杂度预处理一个叫“序列自动机”的东西，得出“对于位置i，下一个字母j最早出现在哪个位置”。这样之后每个询问的串，只要跟着自动机跳就行了，复杂度都是O（m）的。

#include <cstdio>
#include <cstring>

const int maxn = 1e6 + 5;
int n, len;
int Go[maxn][27];
char str[maxn];
char t[maxn];

int main() {
    scanf("%s", str + 1);
    len = strlen(str + 1);
    for (int i = len - 1; ~i; --i) {
        for (int j = 1; j <= 26; ++j) {
            Go[i][j] = Go[i + 1][j];
        }
        Go[i][str[i + 1] - 'a' + 1] = i + 1;
    }
    for (scanf("%d", &n); n; n--) {
        scanf("%s", t);
        bool flag = true;
        for (int i = 0, j = 0; t[i]; ++i) {
            if (Go[j][t[i] - 'a' + 1]) {
                j = Go[j][t[i] - 'a' + 1];
            } else {
                flag = false;
                break;
            }
        }
        flag ? puts("Yes") : puts("No");
    }
    return 0;
}