bzoj刷题记录4.10-4.14

最新推荐文章于 2019-06-11 15:56:11 发布
最新推荐文章于 2019-06-11 15:56:11 发布
阅读量443 收藏
点赞数
分类专栏： --bzoj--
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OIljt12138/article/details/70136442
版权

bzoj刷题记录4.10-4.14

bzoj1093: [ZJOI2007]最大半联通子图

仍然缩点。缩完点之后每个半联通子图就相当于一条带权链（权值是一个scc的点数）。之后dp即可。

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

const int MAXN = 100005, MAXM = 2000005;
struct g {
    struct node {
        int to, next;
    } edge[MAXM];
    int head[MAXN], top;
    g(){ top = 0, memset(head, 0, sizeof head); }
    void push(int i, int j)
    { edge[++top] = (node) {j, head[i]}, head[i] = top; }
}g, g1;

int dfn[MAXN], low[MAXN], stk[MAXN], top = 0, dft = 0;
int gp[MAXN], gtop = 0, gsiz[MAXN], vis[MAXN], n, m;

void tarjan(int nd)
{
    dfn[nd] = low[nd] = ++dft;
    stk[++top] = nd, vis[nd] = 1;
    for (int i = g.head[nd]; i; i = g.edge[i].next) {
        int to = g.edge[i].to;
        if (!dfn[to]) tarjan(to), low[nd] = min(low[nd], low[to]);
        else if (vis[to]) low[nd] = min(low[nd], dfn[to]);
    }
    if (dfn[nd] == low[nd]) {
        int now; ++gtop;
        do {
            now = stk[top--], vis[now] = 0, gp[now] = gtop, gsiz[gtop]++;
        } while (now != nd);
    }
}

long long x;

set<pair<int,int> > hst;

int dp[MAXN], cnt[MAXN];

int dfs(int nd)
{
    if (dp[nd] != -1) return dp[nd];
    dp[nd] = gsiz[nd];
    for (int i = g1.head[nd]; i; i = g1.edge[i].next)
        dp[nd] = max(dp[nd], dfs(g1.edge[i].to)+gsiz[nd]);
    return dp[nd];
}

int dfs_cnt(int nd)
{
    if (cnt[nd] != -1) return cnt[nd];
    if (!g1.head[nd]) return 1%x;
    cnt[nd] = 0;
    for (int i = g1.head[nd]; i; i = g1.edge[i].next) {
        int to = g1.edge[i].to;
        if (dp[nd] == dp[to] + gsiz[nd]) (cnt[nd] += dfs_cnt(to)) %= x;
    }
    return cnt[nd];
}

void work()
{
    for (int i = 1; i <= n; i++)
        if (!dfn[i])
            tarjan(i);
    for (int i = 1; i <= n; i++)
        for (int j = g.head[i]; j; j = g.edge[j].next) {
            int to = g.edge[j].to;
            if (gp[i] != gp[to] && !hst.count(make_pair(gp[i], gp[to]))) {
                hst.insert(make_pair(gp[i], gp[to]));
                g1.push(gp[to], gp[i]); // G^R
            }
        }
    memset(dp, -1, sizeof dp), memset(cnt, -1, sizeof cnt);
    int ans1; long long ans2; ans1 = ans2 = 0;
    for (int i = 1; i <= gtop; i++)
        ans1 = max(ans1, dfs(i));
    for (int i = 1; i <= gtop; i++)
        if (dfs(i) == ans1)
            (ans2 += dfs_cnt(i)) %= x;
    printf("%d\n%lld\n", ans1, ans2);
}
int main()
{
    scanf("%d%d%lld", &n, &m, &x);
    for (int i = 1; i <= m; i++) {
        int u, v; scanf("%d%d", &u, &v), g.push(u, v);
    }
    work();
    return 0;
}

bzoj2208: [JSOI2010] 联通数

缩点后暴力可过..
但是貌似有更好的算法？？比如在拓扑图上随意dfs一棵生成树然后dfs序维护？？
尚不清楚复杂度是否更优。

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

const int MAXN = 2005, MAXM = MAXN*MAXN;
struct graph {
    struct node {
        int to, next;
    } edge[MAXM];
    int head[MAXN], top;
    graph(){top = 0, memset(head, 0, sizeof head); }
    void push(int i, int j)
    { ++top, edge[top] = (node) {j, head[i]}, head[i] = top; }
} g, g1;

int dfn[MAXN], dft = 0, low[MAXN], vis[MAXN];
int stk[MAXN], top = 0;
int gp[MAXN], gtop = 0, gsiz[MAXN], n;

void tarjan(int nd)
{
    vis[nd] = 1, dfn[nd] = low[nd] = ++dft, stk[++top] = nd;
    for (int i = g.head[nd]; i; i = g.edge[i].next) {
        int to = g.edge[i].to;
        if (!dfn[to]) tarjan(to), low[nd] = min(low[nd], low[to]);
        else if (vis[to]) low[nd] = min(low[nd], dfn[to]);
    }
    if (dfn[nd] == low[nd]) {
        int now; ++gtop; //printf(" -- Group %d --\n", gtop);
        do {
            now = stk[top--];
            gp[now] = gtop, gsiz[gtop]++, vis[now] = 0;
            // cerr << now << " ";
        } while(now != nd); //puts("");
    }
}

int bfstime = 0;
queue<int> que;
int lkt[MAXN][MAXN];

void work()
{
    for (int i = 1; i <= n; i++)
        if (!dfn[i])
            tarjan(i);
    for (int i = 1; i <= n; i++)
        for (int j = g.head[i]; j; j = g.edge[j].next) {
            int to = g.edge[j].to;
            if (gp[to] != gp[i] && !lkt[gp[i]][gp[to]]) {
                lkt[gp[i]][gp[to]] = 1;
                g1.push(gp[i], gp[to]);
            }
        }
    int ans = 0;
    memset(vis, 0, sizeof vis);
    for (int i = 1; i <= gtop; i++) {
        ++bfstime;
        que.push(i), vis[i] = bfstime;
        int cnt = 0;
        while (!que.empty()) {
            int t = que.front(); que.pop(), cnt += gsiz[t];
            for (int i = g1.head[t]; i; i = g1.edge[i].next) {
                int to = g1.edge[i].to;
                if (vis[to] != bfstime)
                    vis[to] = bfstime, que.push(to);
            }
        }
        ans += cnt*gsiz[i];
    }
    cout << ans << endl;
}

char str[2005];
int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%s", str+1);
        for (int j = 1; j <= n; j++)
            if (str[j] == '1')
                g.push(i, j);
    }
    work();
    return 0;
}

4.11 更新

今天来一波字符串。

bzoj3172: [Tjoi2013]单词

这个题就比较神了。首先建出AC自动机，然后先求出每个节点的“顺着路过的总数 dp[nd] ”，也就是trie树上子树finish标记的总数；然后每个节点表示的串出现的次数就是某个节点fail树的子树中所有 dp[nd] 的总和。

第一次做反了…
形如

sher
shers
her

的数据可以hack。因为shers不会算入her中去。

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

const int MAXN = 3000005;
int chl[MAXN][26], fail[MAXN], fin[MAXN], top = 0, root = 0;
vector<int> ids[MAXN];
int new_node()
{ return ++top, fail[top] = fin[top] = 0, memset(chl[top],0, sizeof chl[top]), top; }

void push(int &nd, const char *str, int id)
{
    if (nd == 0) nd = new_node();
    if (*str == '\0') fin[nd]++, ids[nd].push_back(id);
    else push(chl[nd][*str-'a'], str+1, id);
}

struct node {
    int to, next;
} edge[MAXN];
int head[MAXN], tp_edge = 0;
void push(int i, int j)
{ ++tp_edge, edge[tp_edge] = (node) {j, head[i]}, head[i] = tp_edge; }
int siz[MAXN], n;

queue<int> que;
void init()
{
    que.push(root); fail[root] = 0;
    while (!que.empty()) {
        int t = que.front(); que.pop();
        for (int i = 0; i < 26; i++) if (chl[t][i]) {
            int p = fail[t];
            while (p && !chl[p][i]) p = fail[p];
            if (!p) fail[chl[t][i]] = root;
            else fail[chl[t][i]] = chl[p][i];
            que.push(chl[t][i]);
            push(fail[chl[t][i]], chl[t][i]);
        }
    }
}

long long res[MAXN];
long long dp[MAXN];

int dfs(int nd)
{
    if (siz[nd] != -1) return siz[nd];
    siz[nd] = dp[nd];
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        siz[nd] += dfs(to);
    }
    return siz[nd];
}

long long dfs2(int nd)
{
    if (dp[nd] != -1) return dp[nd];
    dp[nd] = fin[nd];
    for (int i = 0; i < 26; i++)
        if (chl[nd][i])
            dp[nd] += dfs2(chl[nd][i]);
    return dp[nd];
}

char str[MAXN];

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%s", str);
        push(root, str, i);
    }
    init();
    memset(siz, -1, sizeof siz);
    memset(dp, -1, sizeof dp);
    dfs2(root);
    dfs(root);
    for (int i = 1; i <= top; i++)
        for (int j = 0; j < fin[i]; j++)
            res[ids[i][j]] = siz[i];
    for (int i = 1; i <= n; i++)
        printf("%lld\n", res[i]);
    return 0;
}

bzoj1090: [SCOI2003]字符串折叠

首先 |S|≤100 告诉我们必然不是什么高端结构…

区间dp是正解，方程容易想到，唯一的字符串trick就是用hashk判断相等。

特别注意取某一区间hash的小技巧。

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

const int MAXN = 105;
char str[MAXN];
int n;
unsigned long long hash_tab[MAXN], pwr[MAXN];

unsigned long long hash_val(int i, int j)
{ return hash_tab[j]-hash_tab[i-1]*pwr[j-i+1]; }

int dp[MAXN][MAXN];

int len(int num)
{ return num <= 9 ? 1 : (num <= 99 ? 2 : 3); }

int dfs(int i, int j)
{
    if (dp[i][j] != -1) return dp[i][j];
    if (i == j) return 1;
    dp[i][j] = INT_MAX;
    for (int k = i; k < j; k++)
        dp[i][j] = min(dp[i][j], dfs(i,k)+dfs(k+1,j));
    for (int k = 1; k <= j-i+1; k++) { // 枚举每一块长度
        if ((j-i+1)%k != 0) continue;
        int flag = 1; unsigned long long val = 0;
        for (int p = 0; p < (j-i+1)/k; p++) {
            if (p == 0) val = hash_val(i+p*k, i+(p+1)*k-1);
            else if (val != hash_val(i+p*k, i+(p+1)*k-1)) { flag = 0; break; }
        }
        if (flag) dp[i][j] = min(dp[i][j], dfs(i, i+k-1)+2+len((j-i+1)/k));
    }
    return dp[i][j];
}
int main()
{
    scanf("%s", str+1), n = strlen(str+1);
    pwr[0] = 1;
    for (int i = 1; i <= n; i++) pwr[i] = pwr[i-1]*31;
    for (int i = 1; i <= n; i++) hash_tab[i] = hash_tab[i-1]*31+(str[i]-'A'+1);
    memset(dp, -1, sizeof dp);
    cout << dfs(1, n) << endl;
    return 0;
}

bzoj2124: 等差子序列

乍一看和字符串毫无关系…
事实上，存在一个等差数列当且仅当存在三个点 i<j<k ，满足：

ai=aj+d,ak=aj−d

然后对于这种对称的处理思路就两种：

  1. FFT
  2. 回文串

FFT貌似不太好处理，但回文串很兹瓷啊。用线段树记录每个点是否存在1/2并维护区间哈希，然后正反算哈希判断是不是相等即可。如果在某一时刻 i ，ai两侧不对称，就必然有一段回文串，也就有等差数列。

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

const int MAXN = 10005;
unsigned long long hash_tab[MAXN*4], hash_rev[MAXN*4], power[MAXN];
int lc[MAXN*4], rc[MAXN*4], l[MAXN*4], r[MAXN*4], top = 0, root = 0;
int n, a[MAXN];

inline int siz(int nd) { return r[nd]-l[nd]+1; }
void build(int &nd, int opl, int opr)
{
    nd = ++top, hash_tab[nd] = hash_rev[nd] = 1, lc[nd] = rc[nd] = 0, l[nd] = opl, r[nd] = opr;
    if (opl < opr) {
        build(lc[nd], opl, (opl+opr)/2), build(rc[nd], (opl+opr)/2+1, opr);
        hash_tab[nd] = hash_tab[lc[nd]]+power[siz(lc[nd])]*hash_tab[rc[nd]];
        hash_rev[nd] = hash_rev[rc[nd]]+power[siz(rc[nd])]*hash_rev[lc[nd]];
    }
}
void modify(int nd, int pos)
{
    if (l[nd] == r[nd]) hash_tab[nd] = hash_rev[nd] = 2;
    else {
        modify(pos<=(l[nd]+r[nd])/2?lc[nd]:rc[nd], pos);
        hash_tab[nd] = hash_tab[lc[nd]]+power[siz(lc[nd])]*hash_tab[rc[nd]];
        hash_rev[nd] = hash_rev[rc[nd]]+power[siz(rc[nd])]*hash_rev[lc[nd]];
    }
}
unsigned long long query(int nd, int opl, int opr)
{
    if (l[nd] == opl && r[nd] == opr) return hash_tab[nd];
    else {
        int mid = (l[nd]+r[nd])/2;
        if (opr <= mid) return query(lc[nd], opl, opr);
        else if (opl > mid) return query(rc[nd], opl, opr);
        else return query(lc[nd], opl, mid)+power[mid-opl+1]*query(rc[nd], mid+1, opr);
    }
}
unsigned long long query_reversed(int nd, int opl, int opr)
{
    if (l[nd] == opl && r[nd] == opr) return hash_rev[nd];
    else {
        int mid = (l[nd]+r[nd])/2;
        if (opr <= mid) return query_reversed(lc[nd], opl, opr);
        else if (opl > mid) return query_reversed(rc[nd], opl, opr);
        else return power[opr-mid]*query_reversed(lc[nd], opl, mid)+query_reversed(rc[nd], mid+1, opr);
    }
}
void init()
{
    scanf("%d", &n);
    top = root = 0;
    build(root, 1, n);
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
}
int main()
{
    int T; scanf("%d", &T);
    power[0] = 1;
    for (int i = 1; i <= 10000; i++) power[i] = power[i-1]*31;
    while (T--) {
        init();
        int flag = 0;
        for (int i = 1; i <= n; i++) {
            // cerr << query(root, 1, 3) << "--" << query_reversed(root, 1, 3) << endl;
            if (a[i] <= n-a[i]+1) {
                if (i >= 2 && i < n && query(root, 1, 2*a[i]-1) != query_reversed(root, 1, 2*a[i]-1)) {
                    flag = 1; break;
                }
            } else {
                int k = 2*(n-a[i]+1)-1;
                if (i >= 2 && i < n && query(root, n-k+1, n) != query_reversed(root, n-k+1, n)) {
                    flag = 1; break;
                }
            }
            modify(root, a[i]);
        }
        if (flag) puts("Y");
        else puts("N");
    }
    return 0;
}

bzoj3207: 花神的嘲讽计划Ⅰ

首先 k≤20 就可以暴力算出来每个块的哈希，然后就变成一个在区间内有没有某个值的问题了。莫队可解， O(nn√) 但跑比谁都快。

注意：hash一定要用ull…

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

const int MAXN = 400005, lgn = 20;
int n, m, k, bas, sqr;

unsigned long long hash_val(int a[], int l, int r)
{
    unsigned long long ans = 0;
    for (int i = l; i <= r; i++)
        ans = ans*bas+a[i];
    return ans;
}

struct query {
    int l, r, dat, id, ans;
    friend bool operator < (const query &a, const query &b)
    { return a.l/sqr != b.l/sqr ? a.l < b.l : a.r < b.r; }
} q[MAXN];

bool cmp(const query &a, const query &b)
{ return a.id < b.id; }
int a[MAXN], tmp[30];
unsigned long long d[MAXN], dx[MAXN], qu[MAXN], top = 0;
void dx_init()
{
    memcpy(dx, d, sizeof d);
    sort(dx+1, dx+top+1);
}
int dx_num(unsigned long long dat)
{ return lower_bound(dx+1, dx+top+1, dat)-dx; }

int tab[MAXN];

int main()
{
    scanf("%d%d%d", &n, &m, &k), bas = n+1;
    sqr = sqrt(n); // 分块大小
    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
    for (int i = 1; i+k-1 <= n; i++) d[++top] = hash_val(a, i, i+k-1);
    for (int i = 1; i <= m; i++) {
        scanf("%d%d", &q[i].l, &q[i].r); q[i].r = q[i].r-k+1;
        for (int j = 1; j <= k; j++) scanf("%d", &tmp[j]);
        qu[i] = hash_val(tmp, 1, k);
        d[++top] = qu[i], q[i].id = i;
    }
    dx_init(); // 离散化
    for (int i = 1; i+k-1 <= n; i++) a[i] = dx_num(d[i]);
    for (int i = 1; i <= m; i++) q[i].dat = dx_num(qu[i]);
    sort(q+1, q+m+1);
    memset(tab, 0, sizeof tab);
    int L = q[1].l, R = q[1].r;
    for (int i = L; i <= R; i++) tab[a[i]]++; q[1].ans = tab[q[1].dat];
    for (int i = 2; i <= m; i++) {
        if (q[i].l > q[i].r) continue;
        while (L < q[i].l) tab[a[L++]]--;
        while (L > q[i].l) tab[a[--L]]++;
        while (R < q[i].r) tab[a[++R]]++;
        while (R > q[i].r) tab[a[R--]]--;
        q[i].ans = tab[q[i].dat];
    }
    sort(q+1, q+m+1, cmp);
    for (int i = 1; i <= m; i++)
        if (q[i].ans) puts("No");
        else puts("Yes");
    return 0;
}

bzoj1103: [POI2007]大都市meg

看题解dfs序+树状数组就水过去了， O(nlgn) 。
但是写了链剖 O(nlg2n) 也水过去了。
然而 O(nlgn) 的lct却死超死超的…
玄学啊…当然也可能我写跪了…

链剖

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

const int MAXN = 250005;

int C[MAXN], n, dstop = 0;
int lowbit(int i) { return i&(-i); }
void modify(int pos, int dt)
{ for (int i = pos; i <= n; i += lowbit(i)) C[i] += dt; }
int sum(int pos)
{
    int ans = 0;
    for (int i = pos; i > 0; i -= lowbit(i)) { ans += C[i];}
    return ans;
}
int sum(int l, int r)
{ return sum(r)-sum(l-1); }

struct node {
    int to, next;
} edge[MAXN*2];
int head[MAXN], top;
void push(int i, int j)
{ ++top, edge[top] = (node){j, head[i]}, head[i] = top; }

int siz[MAXN], id[MAXN], ind[MAXN], fa[MAXN];

void dfs1(int nd)
{
    siz[nd] = 1;
    for (int i = head[nd]; i; i = edge[i].next)
        dfs1(edge[i].to), siz[nd] += siz[edge[i].to], fa[edge[i].to] = nd;
}

void dfs2(int nd, int from = 0)
{
    id[nd] = ++dstop, ind[nd] = from, modify(id[nd], 1);
    int hev = 0;
    for (int i = head[nd]; i; i = edge[i].next)
        if (siz[edge[i].to] > siz[hev])
            hev = edge[i].to;
    if (!hev) return;
    dfs2(hev, from);
    for (int i = head[nd]; i; i = edge[i].next)
        if (edge[i].to != hev)
            dfs2(edge[i].to, edge[i].to);
}

void change(int nd)
{ modify(id[nd], -1); }

int ask(int nd)
{
    int ans = 0;
    while (nd) {
        // cout << nd << endl;
        ans += sum(id[ind[nd]], id[nd]), nd = fa[ind[nd]];
    }
    return ans;
}

int main()
{
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        int u, v; scanf("%d%d", &u, &v);
        if (u > v) swap(u,v);
        push(u, v);
    }
    dfs1(1), dfs2(1);
    int m; scanf("%d", &m);
    for (int i = 1; i <= m+n-1; i++) {
        char s; int u, v;
        scanf("\n%c", &s);
        if (s == 'A') { scanf("%d%d", &u, &v), change(max(u,v)); }
        else if (s == 'W') {scanf("%d", &u), printf("%d\n", ask(u)-1); }
        else throw;
    }
    return 0;
}

LCT（TLE）

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

const int MAXN = 250005;
int chl[MAXN][2], dat[MAXN], hv[MAXN], stk[MAXN], stktop = 0, fa[MAXN];
int rev[MAXN], n, m;

bool is_rt(int nd)
{ return nd != chl[fa[nd]][0] && nd != chl[fa[nd]][1]; }

void update(int nd)
{ dat[nd] = dat[chl[nd][0]] + dat[chl[nd][1]] + hv[nd];}

void pdw(int nd)
{
    if (!rev[nd]) return;
    int &lc = chl[nd][0], &rc = chl[nd][1]; rev[nd] = 0;
    if (lc) rev[lc] ^= 1;
    if (rc) rev[rc] ^= 1;
    swap(lc, rc);
}

void zig(int nd)
{
    int p = fa[nd], g = fa[p], tp = chl[p][0] != nd, tg = chl[g][0] != p;
    int son = chl[nd][tp^1];
    if (!is_rt(p)) chl[g][tg] = nd; chl[nd][tp^1] = p, chl[p][tp] = son;
    fa[son] = p, fa[p] = nd, fa[nd] = g;
    update(p), update(nd);
}

void splay(int nd)
{
    stk[stktop = 1] = nd;
    for (int i = nd; !is_rt(i); i = fa[i]) stk[++stktop] = fa[i];
    while (stktop) pdw(stk[stktop--]);
    while (!is_rt(nd)) {
        int p = fa[nd], g = fa[p], tp = chl[p][0] != nd, tg = chl[g][0] != p;
        if (is_rt(p)) { zig(nd); break; }
        else if (tp == tg) zig(p), zig(nd);
        else zig(nd), zig(nd);
    }
}

void access(int x)
{
    for (int y = 0; x; x = fa[y = x])
        splay(x), chl[x][1] = y, update(x);
}

void make_rt(int x)
{ access(x), splay(x), rev[x] ^= 1; }

void link(int i, int j)
{ make_rt(j), fa[j] = i, access(j); }

void change(int nd)
{ make_rt(nd), splay(nd), hv[nd]--, update(nd); }

int ask(int nd)
{ make_rt(1), access(nd), splay(nd); return hv[nd]+dat[chl[nd][0]]; }

int main()
{
    scanf("%d", &n);
    for (int i = 2; i <= n; i++) hv[i] = 1;
    for (int i = 1; i < n; i++) {
        int u, v; scanf("%d%d", &u, &v);
        if (u > v) swap(u, v);
        link(u, v);
    }
    scanf("%d", &m);
    for (int i = 1; i <= n+m-1; i++) {
        char c; int u, v;
        scanf("\n%c", &c);
        if (c == 'W') { scanf("%d", &u), printf("%d\n", ask(u)); }
        else if (c == 'A') { scanf("%d%d", &u, &v), change(max(u, v)); }
    }
    return 0;
}

dfn&BIT

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

const int MAXN = 250005;
int C[MAXN], n, dstop = 0;
int lowbit(int i) { return i&(-i); }
void modify(int pos, int dt)
{ for (int i = pos; i <= n; i += lowbit(i)) C[i] += dt; }
int sum(int pos)
{
    int ans = 0;
    for (int i = pos; i > 0; i -= lowbit(i)) { ans += C[i];}
    return ans;
}

struct node {
    int to, next;
} edge[MAXN];
int head[MAXN], top = 0;
void push(int i, int j)
{ ++top, edge[top] = (node){j, head[i]}, head[i] = top; }

int depth[MAXN], dfi[MAXN], dfo[MAXN], dft = 0;

void dfs(int nd)
{
    dfi[nd] = ++dft;
    for (int i = head[nd]; i; i = edge[i].next) {
        int to = edge[i].to;
        depth[to] = depth[nd]+1;
        dfs(to);
    }
    dfo[nd] = dft;
}

void change(int nd)
{ modify(dfi[nd], 1), modify(dfo[nd]+1, -1); }

int ask(int nd)
{ return depth[nd]-sum(dfi[nd]); }

int main()
{
    scanf("%d", &n);
    for (int i = 1; i < n; i++) {
        int u, v; scanf("%d%d", &u, &v);
        if (u > v) swap(u,v);
        push(u, v);
    }
    depth[1] = 0, dfs(1);
    int m; scanf("%d", &m);
    for (int i = 1; i <= n+m-1; i++) {
        char s; int u, v;
        scanf("\n%c", &s);
        if (s == 'A') { scanf("%d%d", &u, &v), change(max(u,v)); }
        else if (s == 'W') {scanf("%d", &u), printf("%d\n", ask(u)); }
        else throw;
    }
    return 0;
}

4.13

bzoj3506: [Cqoi2014]排序机械臂

题面传送门

就是splay维护最小值和最小值位置，加上反转操作即可。
然而debug能力是硬伤…
注意重复元素的处理，就是 xi→xi(n+1)+i 

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

const int MAXN = 100005;
int chl[MAXN][2], fa[MAXN], rev[MAXN], stk[MAXN], stktop = 0;
int top = 0, min_pos[MAXN], siz[MAXN], root = 0;
long long min_val[MAXN], dat[MAXN];

void update(int nd)
{
    min_val[nd] = min(dat[nd], min(min_val[chl[nd][0]], min_val[chl[nd][1]]));
    min_pos[nd] = min_val[nd] == min_val[chl[nd][0]] ? min_pos[chl[nd][0]] : (min_val[nd] == dat[nd] ? nd : min_pos[chl[nd][1]]);
    siz[nd] = siz[chl[nd][0]] + siz[chl[nd][1]] + 1;
}

inline int new_node(long long d) { return ++top, dat[top] = d, update(top), top;}

void pdw(int nd)
{
    if (!rev[nd]) return;
    int &lc = chl[nd][0], &rc = chl[nd][1];
    if (lc) rev[lc] ^= 1;
    if (rc) rev[rc] ^= 1;
    swap(lc, rc), rev[nd] ^= 1;
}

void zig(int nd)
{
    int p = fa[nd], g = fa[p], tp = chl[p][0] != nd, tg = chl[g][0] != p;
    int son = chl[nd][tp^1];
    fa[son] = son==0?0:p, fa[p] = nd, fa[nd] = g;
    chl[g][tg] = g==0?0:nd, chl[nd][tp^1] = p, chl[p][tp] = son;
    root = g?root:nd;
    update(p), update(nd);
}

void splay(int nd, int tar = 0)
{
    stk[stktop = 1] = nd;
    for (int i = nd; fa[i]; i = fa[i]) stk[++stktop] = fa[i];
    for (; stktop; stktop--) pdw(stk[stktop]);
    while (fa[nd] != tar) {
        int p = fa[nd], g = fa[p], tp = chl[p][0] != nd, tg = chl[g][0] != p;
        if (g == tar) {zig(nd); break; }
        else if (tp == tg) zig(p), zig(nd);
        else zig(nd), zig(nd);
    }
}

void dfs(int nd)
{
    if (!nd) return;
    pdw(nd);
    dfs(chl[nd][0]);
    cerr << dat[nd] << " ";
    dfs(chl[nd][1]);
}

void insert(long long nd)
{
    if (root == 0) root = new_node(nd);
    else {
        chl[root][1] = new_node(nd), fa[top] = root;
        splay(top), update(top);
        // dfs(top);
    }
}

int get_min()
{
    splay(min_pos[root]);
    int ans = siz[chl[root][0]]+1;
    return ans;
}

int get_by_order(int k)
{
    int nd = root; k--; // have k element on left
    while (nd) {
        pdw(nd), update(nd);
        if (siz[chl[nd][0]] == k) break;
        nd = siz[chl[nd][0]]>k?chl[nd][0]:(k -= siz[chl[nd][0]]+1, chl[nd][1]);
    }
    return nd;
}

int get_segment(int l, int r)
{
    if (l == 1 && r == siz[root]) return root;
    if (l == 1) return splay(get_by_order(r+1)), chl[root][0];
    if (r == siz[root]) return splay(get_by_order(l-1)), chl[root][1];
    return splay(get_by_order(l-1)), splay(get_by_order(r+1), root), chl[chl[root][1]][0];
}

void del_root()
{
    int t = get_segment(siz[chl[root][0]]+1, siz[chl[root][0]]+1);
    int tp = chl[fa[t]][0] != t; chl[fa[t]][tp] = 0;
    for (int i = fa[t]; i; i = fa[i]) update(i);
    fa[t] = 0;
}

void reverse(int l, int r)
{
    int t = get_segment(l, r);
    rev[t] ^= 1;
}

int ans()
{
    int ret = get_min();
    reverse(1, ret);
    splay(min_pos[root]), del_root();
    return ret;
}

int n;

int main()
{
    memset(min_val, 127/3, sizeof min_val);
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        int u; scanf("%d", &u); insert((long long)u*(n+1)+i);
    }
    for (int i = 1; i <= n; i++) printf("%d ", ans()+i-1);
    return 0;
}

bzoj3530: [Sdoi2014]数数

大爷题解：http://blog.csdn.net/aarongzk/article/details/50472209#

就是AC自动机上dp，然而数位dp仍然跪烂…要注意前导零的处理。
AC自动机忘记push儿子调试1h…

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

const int MAXL = 1505;

int vis[MAXL];
struct ACM {
    struct node {
        int chl[10];
        int finished, fail;
        node() { memset(chl, 0, sizeof chl), finished = fail = 0; }
    } tree[MAXL];
    int top, root;
    ACM() { top = root = 0; }
    inline int new_node() { return ++top; }
    void insert(int &nd, const char *str)
    {
        if (!nd) nd = new_node();
        if (*str == '\0') tree[nd].finished = 1, vis[nd] = 1;
        else insert(tree[nd].chl[*str-'0'], str+1);
    }
    queue<int> que;
    void init()
    {
        tree[root].fail = 0, que.push(root);
        while (!que.empty()) {
            int nd = que.front(); que.pop(); vis[nd] |= vis[tree[nd].fail];
            for (int i = 0; i < 10; i++) {
                if (!tree[nd].chl[i]) continue;
                int p = tree[nd].fail;
                while (p && !tree[p].chl[i]) p = tree[p].fail;
                if (!p) tree[tree[nd].chl[i]].fail = root;
                else tree[tree[nd].chl[i]].fail = tree[p].chl[i];
                que.push(tree[nd].chl[i]);
            }
        } ;
    }
    int trans(int nd, int ths)
    {
        if (tree[nd].chl[ths]) return tree[nd].chl[ths];
        int p = tree[nd].fail;
        while (p && !tree[p].chl[ths]) p = tree[p].fail;
        if (!p) return root;
        else return tree[p].chl[ths];
    }
} ac;

long long dp[1500][MAXL][3]; // 1 随意 0 不随意
char str[MAXL]; int s[MAXL];
long long mod = 1e9+7;
int n, m;

int main()
{
    memset(vis, 0, sizeof vis);
    scanf("%s", str+1); n = strlen(str+1);
    for (int i = 1; i <= n; i++) s[i] = str[i]-'0';
    scanf("%d", &m);
    for (int i = 1; i <= m; i++) {
        scanf("%s", str);
        ac.insert(ac.root, str);
    }
    long long ans = 0;
    ac.init();
    memset(dp, 0, sizeof dp);
    for (int i = 1; i < 10; i++) if (!vis[ac.trans(ac.root, i)]) dp[2][ac.trans(ac.root, i)][0]++;
    for (int i = 2; i < n; i++)
        for (int j = 1; j <= ac.top; j++)
            for (int k = 0; k < 10; k++) if (!vis[ac.trans(j, k)])
                (dp[i+1][ac.trans(j, k)][0] += dp[i][j][0]) %= mod;
    for (int i = 2; i <= n; i++)
        for (int j = 1; j <= ac.top; j++)
            (ans += dp[i][j][0]) %= mod; // 前导0
    memset(dp, 0, sizeof dp);
    for (int i = 1; i <= s[1]; i++)
        if (!vis[ac.trans(ac.root, i)])
            dp[2][ac.trans(ac.root, i)][i == s[1]]++;
    for (int i = 2; i <= n; i++) {
        for (int j = 1; j <= ac.top; j++)
            for (int k = 0; k < 10; k++) {
                if (vis[ac.trans(j, k)]) continue;
                (dp[i+1][ac.trans(j, k)][0] += dp[i][j][0]) %= mod;
                if (k < s[i]) (dp[i+1][ac.trans(j, k)][0] += dp[i][j][1]) %= mod;
                else if (k == s[i]) (dp[i+1][ac.trans(j, k)][1] += dp[i][j][1]) %= mod;
            }
    }
    for (int i = 1; i <= ac.top; i++)
        (ans += dp[n+1][i][0]+dp[n+1][i][1]) %= mod;
    cout << ans << endl;
    return 0;
}
OIljt12138
关注
专栏目录
bzoj刷题记录：4.5-4.9
OIljt12138的博客
04-09 572
bzoj刷题记录：4.5-4.9
BZOJ 刷题计划
cugsl的博客
12-19 537
水题练手 巨水无比（4） 1214 3816 模拟/枚举/暴力（15） 4063傻子模拟； 1968小学生暴力； 1218前缀和暴力； 3856读英文； 4106直接算； 1800暴力判断； 2208暴力判断（要会邻接表）； 1028枚举； 1789&amp;amp;amp;1830高能暴力； 2241暴力； 2120神奇的暴力； 4145子集暴力； 4029模拟处理； 1086DFS树； 1224暴力；...
bzoj刷题(shui)记录
Vampire
08-31 2287
放假刷了一个月的水题，集中写一下题解吧。bzoj1858:线段树随便维护一下。 code bzoj2705:莫比乌斯反演裸题。 code bzoj1202:并查集，但是我写了一种跟floyd很像的奇怪的东西。 code bzoj1072:暴力。 bzoj2431:dp f[i][j]=sum(f[i-1],[k]) code bzoj3505:组合数学。 code bzoj1058:
BZOJ刷题记录
mrcrack的博客
05-15 1401
BZOJ刷题记录 转自http://lbn187.is-programmer.com/2015/5/16/bzoj.93165.html 学习一天可做 普及组难度 提高组难度弱省省选(NOI)难度 学习一天可做 详见https://blog.csdn.net/mrcrack/article/details/90228821 普及组难度 详见https://blog.csdn.n...
BZOJ 刷题记录
xyyxyyx的博客
01-23 442
前言 这篇博客完全是为了个人记录用的，用来防止计划咕咕咕。 对除了博主本人之外的任何人没有参考价值，而且没有题解。 开始 2019年 1月 23：[HNOI2008] 水平可见直线 ...
BZOJ刷题记录(2014)
WZJRJ28
02-16 1203
BZOJ刷题记录 1000: A+B Problem   太神不会。。 1001: [BeiJing2006]狼抓兔子 平面图转对偶图，然后SPFA求最小割   1002: [FJOI2007]轮状病毒   分三类讨论，可DP，需要高精度。  设f[n]表示第n个原子和中心相连的病毒数，g[n]表示第n个原子不和中心相连的病毒数，那么最后的结
bzoj刷题列表（by——hzwer）
qq_41510496的博客
04-22 1507
BZOJ1601 BZOJ1003 BZOJ1002 BZOJ1192 BZOJ1303 BZOJ1270 BZOJ3039 BZOJ1191 BZOJ1059 BZOJ1202 BZOJ1051 BZOJ1001 BZOJ1588 BZOJ1208 BZOJ1491 BZOJ1084 BZOJ1295 BZOJ3109 BZOJ1085 BZOJ1041 BZOJ1087 BZOJ3038 BZ...
各种OJ刷题记录6.27-7.6
OIljt12138的博客
06-29 1009
各种OJ刷题记录6.27-7.6
【BZOJ】3159决战-LCT
远行客
06-12 382
先贴代码，果断时间再补题解。可以套两颗LCT。 本蒟蒻一晚上就耗这了… #include&amp;amp;amp;amp;lt;cstdio&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;algorithm&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;cstring&amp;amp;amp;amp;gt; #include&amp;a
BZOJ刷题记录---提高组难度
mrcrack的博客
06-11 1703
BZOJ刷题记录---提高组难度 总目录详见https://blog.csdn.net/mrcrack/article/details/90228694 序号 题号 算法 思想难度 实现难度 总难度 推荐指数 1 1876 高精求GCD 18 33 51 2 2 2173 找规律 37 14...
bzoj刷题记录5.6-5.10
OIljt12138的博客
05-07 530
bzoj刷题记录5.6-5.10
BZOJ刷题记录---学习一天可做 AC
mrcrack的博客
05-15 657
BZOJ刷题记录---学习一天可做 AC 总目录详见https://blog.csdn.net/mrcrack/article/details/90228694 序号 题号 算法 思想难度 实现难度 总难度 推荐指数 1 1214 Ruby 0 0 0 10 2 3816 Ruby 0 ...
bzoj刷题记录4.25-5.1
OIljt12138的博客
05-01 502
bzoj刷题记录4.25-5.11 作业又双叒叕写不完了...
BZOJ刷题指南
duanghaha的博客
09-05 1519
http://lbn187.is-programmer.com/posts/103404.html
BZOJ刷题记录---普及组难度 AC
mrcrack的博客
05-19 1198
BZOJ刷题记录---普及组难度 总目录详见https://blog.csdn.net/mrcrack/article/details/90228694 序号 题号 算法 思想难度 实现难度 总难度 推荐指数 1 2659 数学 20 7 27 2 2 1968 枚举 15 13 28...
BZOJ 刷题总结
Yancy_的博客
01-29 1479
背景 辣鸡的人总要想法自救，便产生了寒假学些新算法、在Bzoj刷些题的想法。一来为明年省赛做准备…压力不小；二来寒假也可以有些事情做。 PS 1.不定时更新做题的思路和吐槽 2.按照hzw刷题顺序训练，具体依照BZOJ题表 3.希望寒假能够至少刷够100道题目吧，在此立个FLAG，希望别被青岛的妖风吹跑 Problem &amp; Solution BZOJ 1003 ...
基于深度学习的行人分类.zip
09-21
深度学习是机器学习的一个子领域，它基于人工神经网络的研究，特别是利用多层次的神经网络来进行学习和模式识别。深度学习模型能够学习数据的高层次特征，这些特征对于图像和语音识别、自然语言处理、医学图像分析等应用至关重要。以下是深度学习的一些关键概念和组成部分： 1. **神经网络（Neural Networks）**：深度学习的基础是人工神经网络，它是由多个层组成的网络结构，包括输入层、隐藏层和输出层。每个层由多个神经元组成，神经元之间通过权重连接。 2. **前馈神经网络（Feedforward Neural Networks）**：这是最常见的神经网络类型，信息从输入层流向隐藏层，最终到达输出层。 3. **卷积神经网络（Convolutional Neural Networks, CNNs）**：这种网络特别适合处理具有网格结构的数据，如图像。它们使用卷积层来提取图像的特征。 4. **循环神经网络（Recurrent Neural Networks, RNNs）**：这种网络能够处理序列数据，如时间序列或自然语言，因为它们具有记忆功能，能够捕捉数据中的时间依赖性。 5. **长短期记忆网络（Long Short-Term Memory, LSTM）**：LSTM 是一种特殊的 RNN，它能够学习长期依赖关系，非常适合复杂的序列预测任务。 6. **生成对抗网络（Generative Adversarial Networks, GANs）**：由两个网络组成，一个生成器和一个判别器，它们相互竞争，生成器生成数据，判别器评估数据的真实性。 7. **深度学习框架**：如 TensorFlow、Keras、PyTorch 等，这些框架提供了构建、训练和部署深度学习模型的工具和库。 8. **激活函数（Activation Functions）**：如 ReLU、Sigmoid、Tanh 等，它们在神经网络中用于添加非线性，使得网络能够学习复杂的函数。 9. **损失函数（Loss Functions）**：用于评估模型的预测与真实值之间的差异，常见的损失函数包括均方误差（MSE）、交叉熵（Cross-Entropy）等。 10. **优化算法（Optimization Algorithms）**：如梯度下降（Gradient Descent）、随机梯度下降（SGD）、Adam 等，用于更新网络权重，以最小化损失函数。 11. **正则化（Regularization）**：技术如 Dropout、L1/L2 正则化等，用于防止模型过拟合。 12. **迁移学习（Transfer Learning）**：利用在一个任务上训练好的模型来提高另一个相关任务的性能。 深度学习在许多领域都取得了显著的成就，但它也面临着一些挑战，如对大量数据的依赖、模型的解释性差、计算资源消耗大等。研究人员正在不断探索新的方法来解决这些问题。
机械制造工艺学课程设计手柄座设计“手柄座”零件的机械加工工艺规程及工艺装备.doc
最新发布
09-21
机械制造工艺学课程设计手柄座设计“手柄座”零件的机械加工工艺规程及工艺装备.doc
BZOJ JOI 2013-2014春季训练合宿题目解析1
"BZOJ JOI 2013~2014 春季training合宿 系列题解1" 这篇题解涉及到的是一个编程竞赛中的题目，主要运用了哈希算法来解决。哈希算法在计算机科学中是一种高效的数据结构和算法，它能够快速查找、插入和删除元素，其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值