小tips

qqqqc16

已于 2023-01-04 23:08:04 修改

阅读量237

点赞数

文章标签： java c++ 开发语言

于 2022-11-07 10:08:50 首次发布

本文链接：https://blog.csdn.net/qqqqc16/article/details/126258277

版权

普通莫队

#include <bits/stdc++.h>

#define int long long
#define ll long long
#define endl '\n'
using namespace std;

const int N = 2e5 + 7;

int n, t, blk, a[N], ans[N];

struct Q {
    int l, r;
    int id;

    bool operator<(const Q &p) {
        if (l / blk != p.l / blk) return l < p.l;
        return r < p.r;
    }
} q[N];

int cnt[N];

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);
    int T = 1;
    //cin >> T;
    while (T--) {
        cin >> n >> t;
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        for (int i = 1; i <= t; i++) {
            cin >> q[i].l >> q[i].r;
            q[i].id = i;
        }
        blk = max(1LL, (int) sqrt(n - 1) + 1);
        sort(q + 1, q + t + 1);
        int l = 1, r = 0;
        int nowAns = 0;
        for (int i = 1; i <= t; i++) {
            while (l > q[i].l) {
                l--;
                if (a[l] > n) continue;
                if (cnt[a[l]] == a[l]) nowAns--;
                cnt[a[l]]++;
                if (cnt[a[l]] == a[l]) nowAns++;
            }
            while (r < q[i].r) {
                r++;
                if (a[r] > n) continue;
                if (cnt[a[r]] == a[r]) nowAns--;
                cnt[a[r]]++;
                if (cnt[a[r]] == a[r]) nowAns++;
            }
            while (l < q[i].l) {
                if (a[l] > n) {
                    l++;
                    continue;
                }
                if (cnt[a[l]] == a[l]) nowAns--;
                cnt[a[l]]--;
                if (cnt[a[l]] == a[l]) nowAns++;
                l++;
            }
            while (r > q[i].r) {
                if (a[r] > n) {
                    r--;
                    continue;
                }
                if (cnt[a[r]] == a[r]) nowAns--;
                cnt[a[r]]--;
                if (cnt[a[r]] == a[r]) nowAns++;
                r--;
            }
            ans[q[i].id] = nowAns;
        }
        for (int i = 1; i <= t; i++) {
            cout << ans[i] << endl;
        }
    }
    return 0;
}

树上莫队

#include <bits/stdc++.h>

#define int long long
#define ll long long
#define endl '\n'
#define lowbit(x) (x & (-x))
#define pii pair<int, int>
#define lson rt << 1
#define rson rt << 1 | 1
#define debug(x) cout << "x: " << x << endl
using namespace std;

const int N = 1e5 + 7;
const int INF = 0x3f3f3f3f;
const ll inf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const double eps = 1e-8;

int n, m, blk, a[N], ans[N], dfn[N];
int l[N], r[N];
int f[N], g[N];
vector<int> G[N];

struct Q {
    int l, r, k;
    int id;

    bool operator<(const Q &p) {
        if (l / blk != p.l / blk) return l < p.l;
        return r < p.r;
    }
} q[N];

int cnt;

void dfs(int u, int fa) {
    l[u] = ++cnt;
    dfn[cnt] = a[u];
    for (auto v: G[u]) {
        if (v == fa) continue;
        dfs(v, u);
    }
    r[u] = cnt;
}

void add(int u) {
    ++f[dfn[u]];
    ++g[f[dfn[u]]];
}

void del(int u) {
    --g[f[dfn[u]]];
    --f[dfn[u]];
}

signed main() {
#ifndef ONLINE_JUDGE
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
    ios::sync_with_stdio(false);
    cin.tie(nullptr), cout.tie(nullptr);
    int T = 1;
//    cin >> T;
    while (T--) {
        cin >> n >> m;
        blk = max(1LL, (int) sqrt(n - 1) + 1);
        for (int i = 1; i <= n; i++) {
            cin >> a[i];
        }
        for (int i = 1; i < n; i++) {
            int x, y;
            cin >> x >> y;
            G[x].push_back(y);
            G[y].push_back(x);
        }
        dfs(1, 0);
        for (int i = 1; i <= m; i++) {
            int v, k;
            cin >> v >> k;
            q[i].l = l[v];
            q[i].r = r[v];
            q[i].k = k;
            q[i].id = i;
        }
        sort(q + 1, q + m + 1);
        int L = 1, R = 0;
        for (int i = 1; i <= m; i++) {
            while (L < q[i].l) del(L++);
            while (L > q[i].l) add(--L);
            while (R < q[i].r) add(++R);
            while (R > q[i].r) del(R--);
            ans[q[i].id] = g[q[i].k];
        }
        for (int i = 1; i <= m; i++) {
            cout << ans[i] << endl;
        }
    }
    return 0;
}

s中找一个数使得xor x值最大

int ans = 0;
for (int i = 30; i >= 0; i--) {
    ans |= (~x & (1 << i));
    auto u = s.lower_bound(ans);
    if (u == s.end() || (*u >> i) != (ans >> i))
        ans ^= (1 << i);
}
ans ^= x;
cout << ans << endl;

互质个数

const int SIZE = 1e4 + 7;

vector<int> pme;
bool is_prime[SIZE];
int prime[SIZE], phi[SIZE]; // phi[i] 表示 i 的欧拉函数值
int Phi(int n) { // 线性筛素数的同时线性求欧拉函数
    phi[1] = 1;
    is_prime[1] = true;
    int p = 0;
    for (int i = 2; i <= n; ++i) {
        if (!is_prime[i]) prime[p++] = i, phi[i] = i - 1;
        for (int j = 0; j < p && prime[j] * i <= n; ++j) {
            is_prime[prime[j] * i] = true;
            if (!(i % prime[j])) {
                phi[i * prime[j]] = phi[i] * prime[j];
                break;
            }
            phi[i * prime[j]] = phi[i] * (prime[j] - 1);
        }
    }
    return p;
}

unordered_map<int, int> mp;
//计算1-n中与x和y都互质的数的个数
int count_prime(int n, int x, int y) {
    pme.clear();
    int res = 1;
    for (int i = 0; prime[i] * prime[i] <= max(x, y); ++i) {
        if (x % prime[i] == 0 || y % prime[i] == 0) {
            pme.push_back(prime[i]);
            res *= prime[i];
            while (x % prime[i] == 0) x /= prime[i];
            while (y % prime[i] == 0) y /= prime[i];
        }
    }
    if (x > 1) pme.push_back(x), res *= x;
    if (y > 1 && y != x) pme.push_back(y), res *= y;
    if (mp.count(res)) return mp[res];
    int sum = 0;
    for (int i = 1; i < (1 << pme.size()); ++i) {
        int z = 1, num = 0;
        for (int j = 0; j < pme.size(); ++j)
            if (i >> j & 1) z *= pme[j], ++num;
        if (num & 1) sum += n / z;
        else sum -= n / z;
    }
    return mp[res] = n - sum;
}

LCA

constexpr int SIZE = 100010;
constexpr int DEPTH = 21; // 最大深度 2^DEPTH - 1
int pa[SIZE][DEPTH], dep[SIZE];
vector<int> g[SIZE]; //邻接表

void dfs(int rt, int fin) { //预处理深度和祖先
    pa[rt][0] = fin;
    dep[rt] = dep[pa[rt][0]] + 1; //深度
    for (int i = 1; i < DEPTH; ++i) { // rt 的 2^i 祖先等价于 rt 的 2^(i-1) 祖先 的 2^(i-1) 祖先
        pa[rt][i] = pa[pa[rt][i - 1]][i - 1];
    }
    int sz = g[rt].size();
    for (int i = 0; i < sz; ++i) {
        if (g[rt][i] == fin) continue;
        dfs(g[rt][i], rt);
    }
}

int LCA(int x, int y) {
    if (dep[x] > dep[y]) swap(x, y);
    int dif = dep[y] - dep[x];
    for (int j = 0; dif; ++j, dif >>= 1) {
        if (dif & 1) {
            y = pa[y][j]; //先跳到同一高度
        }
    }
    if (y == x) return x;
    for (int j = DEPTH - 1; j >= 0 && y != x; --j) { //从底往上跳
        if (pa[x][j] != pa[y][j]) { //如果当前祖先不相等 我们就需要更新
            x = pa[x][j];
            y = pa[y][j];
        }
    }
    return pa[x][0];
}

二进制容斥

int calc(int n, int x) { // 计算1 ~ n中，有多少与x互质的数
    vector<int> p;
    for (int i = 0; i < cnt && prime[i] * prime[i] <= x; i++) {
        if (x % prime[i] == 0) {
            p.push_back(prime[i]);
            while (x % prime[i] == 0) x /= prime[i];
        }
    }
    if (x > 1) p.push_back(x);
    int res = 0;
    int sz = p.size();
    for (int i = 1; i < (1 << sz); i++) {
        int z = 1, num = 0;
        for (int j = 0; j < sz; j++) {
            if (i & (1 << j)) z *= p[j], ++num;
        }
        if (num & 1) res += n / z;
        else res -= n / z;
    }
    return n - res;
}

st表

constexpr int SIZE = 100010;
int lg2[SIZE];
pii mn[SIZE][21], mx[SIZE][21];
for (int i = 1; i <= n; i++) {
    if (i > 1) {
        lg2[i] = lg2[i / 2] + 1;
    }
    mn[i][0] = {in[i], i};
    mx[i][0] = {out[i], i};
}
for (int i = 1; i <= 20; i++) {
    for (int j = 1; j + (1 << i) - 1 <= n; j++) {
        mn[j][i] = min(mn[j][i - 1], mn[j + (1 << (i - 1))][i - 1]);
        mx[j][i] = max(mx[j][i - 1], mx[j + (1 << (i - 1))][i - 1]);
    }
}

int s = lg2[r - l + 1];
int max_id = max(mx[l][s], mx[r - (1 << s) + 1][s]).second;
int min_id = min(mn[l][s], mn[r - (1 << s) + 1][s]).second;

树哈希

#include <bits/stdc++.h>
using namespace std;

typedef unsigned long long ull;
mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());
ull base = rnd();
const int N = 1e6 + 10;
vector<int> g[N];
ull h[N];
ull H(ull x) {
	return x * x * x * 11451419 + 19260817;
}
ull F(ull x) {
	return H(x & ((1ll << 32) - 1)) + H(x >> 32);
}
void dfs(int u, int fa) {
	h[u] = base;
	for (auto &v : g[u]) {
		if (v == fa) continue;
		dfs(v, u);
		h[u] += F(h[v]);
	}
}
signed main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr), cout.tie(nullptr);
	int n, x, y;
	cin >> n;
	for (int i = 1; i < n; i++) {
		cin >> x >> y;
		g[x].push_back(y);
		g[y].push_back(x);
	}
	dfs(1, 0);
	sort(h + 1, h + 1 + n);
	cout << unique(h + 1, h + 1 + n) - h - 1 << '\n';
	return 0;
}

Pollard-Rho

mt19937_64 rnd(chrono::steady_clock::now().time_since_epoch().count());

using i128 = __int128;

int qpow(int a, int b, int mod) {
    int res = 1;
    while (b) {
        if (b & 1) res = (i128) res * a % mod;
        a = (i128) a * a % mod;
        b >>= 1;
    }
    return res;
}

bool Miller_Rabin(int p) {
    if (p < 2) return 0;
    if (p == 2 || p == 3) return 1;
    int d = p - 1, r = 0;
    while (!(d & 1)) ++r, d >>= 1;
    for (int k = 0; k < 10; k++) {
        int a = rand() % (p - 2) + 2;
        int x = qpow(a, d, p);
        if (x == 1 || x == p - 1) continue;
        for (int i = 1; i < r; ++i) {
            x = (i128) x * x % p;
            if (x == p - 1) break;
        }
        if (x != p - 1) return 0;
    }
    return 1;
}

int Pollard_Rho(int x) {
    int s = 0, t = 0;
    int c = rand() % (x - 1) + 1;
    int val = 1;
    for (int goal = 1;; goal *= 2, s = t, val = 1) {
        for (int step = 1; step <= goal; ++step) {
            t = ((i128) t * t + c) % x;
            val = (i128) val * abs(t - s) % x;
            if ((step % 127) == 0) {
                int d = __gcd(val, x);
                if (d > 1) return d;
            }
        }
        int d = __gcd(val, x);
        if (d > 1) return d;
    }
}

void fac(int x, vector<int> &ans) {
    if (x < 2) return;
    if (Miller_Rabin(x)) {
        ans.push_back(x);
        return;
    }
    int p = x;
    while (p >= x) p = Pollard_Rho(x);
    while ((x % p) == 0) x /= p;
    fac(x, ans), fac(p, ans);
}