品成人欧美大片久久国产欧美...,草草久久久无码国产专区,91精品国产高清久久久久久io

【AHOI2013复仇】SCOI2008 斜堆

Mato_No1 — Sun, 07 Oct 2012 03:02:00 GMT

一开始想��M��?#8230;…不过很快��发现这其实是个��大水�?#8230;…
考虑斜堆�?strong>最后插入的那个�l�点�Q�容易发玎ͼ�
�Q?�Q�它一定是一个极左结点（��是从根往它的路上一直都是沿着左链赎ͼ��Q�因为插入的时候每�ơ都是插入到左子树中�Q?br />�Q?�Q�它一定木有右子树�Q�因为插入的时候每�ơ都是把原来的某��子树作为新�l�点的左子树�Q?br />
满��Q?�Q�（2�Q�的�l�点可能有多个，但紧接着可以发现�Q�这�?strong style="color: red">斜堆中的每个�l�点如果木有左子�l�点�Q�那么也木有叛_��l�点�Q�或者说�Q�每个非叶结炚w��有左子树�Q�，而在插入一个结点之前，其所有的��先都被交换了左叛_��树，所以，若新�l�点的祖先中有满��I��1�Q�（2�Q�的�Q�且新结点不是叶�l�点�Q�那么在新结�Ҏ��入之前，�q�个满��Q?�Q�（2�Q�的��先必然是只有右子树而木有左子树的，�q�与上面的那个性质矛盾�Q�所以，可以得出�Q?strong>最后插入的那个�l�点一定是满��Q?�Q�（2�Q�的�l�点中，深度最��的那个�Q�设为X�Q�，除非X的左子结�Ҏ��叶结点，此时��Z��满��字典序最��，应该取X的左子结点�ؓ最后插入的�?/span>扑ֈ��q�个最后插入的�l�点以后�Q�只需要把它删掉，�q�把它的所有祖先交换左叛_��树，��是插入该结点以前的状态了。这样可以找到字典序最��的插入��序�?br />———————————————————————————————————————————————————
但是�Q�这个题的意义还不止于此�Q�必��要搞清楚斜堆到底是什么，有什么应用囧……

斜堆是可合�ƈ堆的一�U�实现�Ş式，其更�E�_��的实现是左偏树（斜堆只能做到均摊logN�Q�而左偏树则可以严格做到每�ơ操作O(logN)�Q��?br />斜堆最典型的特点，上面已经说过了，如果一个结�Ҏ��有左子树�Q�那么它也一定没有右子树。这��P��大多数斜堆看上去是往左倾斜的（�q�也��是它的名字的由�?#8230;…�Q�。如果给每个�l�点加上一�?span style="color: #339966">距离值dist[]�Q��ؓ该结点到它最�q�的没有叛_��树的子结点的距离�Q��ƈ且满��Q意结点的左子�l�点的距��d��都不小于右子结点的距离�?/strong>的话�Q�就成了左偏树囧……

可合�q�堆�Q�顾名思义�Q�它必须满��两个性质�Q�（1�Q�是堆，也就是每个结点的关键字都不大于（��顶堆）/不小于（大顶堆）其两个子�l�点的关键字�Q�（2�Q�它必须在O(logN)旉��内完成合�q�操作，卛_��两个堆合�q��ؓ一个，且合�q�成的堆仍满��_��来的性质�?br />斜堆的合�q�操作有点像某些函数式数据结构，但它�q�不会动用额外的�I�间。该合�ƈ操作使用递归实现�Q�设两个斜堆�Q�小��堆�Q�的根结点�ؓA、B�Q�若A和B中的某一个�ؓ�I�，则返回另一个；若A和B均非�I�，则先��它们中关键字小的那个的叛_��树与关键字大的那个的整棵树合�qӞ��作�ؓ关键字小的那个的新的叛_��树，然后�Q�如果是左偏树的话要更新dist�Q�若dist不满��?#8220;左不��于�?#8221;�Q�还要交换左叛_��树�?br />
斜堆可以支持的操作有�Q�指能在O(logN)旉��内完成的操作�Q�：
�Q?�Q�插入结点：�Q�用合�ƈ实现�Q�；
�Q?�Q�删除�Q意结点：�Q�将待删除结点的两棵子树合�ƈ�Q�取代原来的位置�Q�若是左偏树的话�q�要往上更新dist直到dist不变为止�Q�某论文里有证明�Q�每�ơ删除更新dist�ơ数不会��过2logN�Q�；
�Q?�Q�合�q�两个斜堆；
�Q?�Q�找最��?大��|��
�Q?�Q�求以某个结点�ؓ根的子树大小�Q�维护sz卛_��Q�；

斜堆不能支持的操作有�Q�指不能在O(logN)旉��内完成的操作�Q�：
�Q?�Q�查找�Q意结炏V��因此，若要删除某个指定�l�点�Q�则必须先用下标�{�烦引到它；
�Q?�Q�找�W�K��（如果�q�个都能实现的话�Q�斜堆就可以替代�q��树了�?#8230;…�q�是可合�q��^衡树……�Q�；
�Q?�Q�找某个�l�点所在树的根�l�点�Q�但是配合�ƈ查集+索引可以实现�Q�详见HDU1512�Q�；

至于�~�程复杂度方�?#8230;…非常非常好写�Q�基本上一个合�q�操作就够了�Q?lt;10行（斜堆的好写程度仅�ơ于�q�查集和普通堆�Q�；
写的之后有三个主要的易疵点：
�Q?�Q�合�q�的时候别忘了更新一些东东，��其别忘了返回根�l�点�Q?br />�Q?�Q�（极易�늚��Q�！�Q�如果要删除某个�l�点�Q�必��L��它的所有信息恢复到孤立�l�点的状态，��x��开与原树的一切联�p�（pr、L、R全部�|?�Q�，dist�Q�如果是左偏树）�|?、sz�|?�Q�（3�Q�下标从1开始，0��L��点作�Ҏ��用途（dist��gؓ-1�Q�sz��gؓ0�Q�，如果某个�l�点的pr、L、R不存在则�?�Q?br />
例题�Q�由于想�E�_��Q�本沙茶全都是用左偏树写的囧�Q�：
�?�?a title="HDU1512" >HDU1512
基本操作题，配合�q�查�?索引找根卛_��Q?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 100010, INF = ~0U >> 2;
int n, u[MAXN], rt[MAXN], V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], res;
int UFS_find(int x)
{
    int tmp = x, r = x; while (u[r] >= 0) r = u[r]; while (x != r) {tmp = u[x]; u[x] = r; x = tmp;} return r;
}
void UFS_union(int s1, int s2, int rt0)
{
    if (u[s1] >= u[s2]) {u[s1] = s2; u[s2]--; rt[s2] = rt0;} else {u[s2] = s1; u[s1]--; rt[s1] = rt0;}
}
int heap_union(int s1, int s2)
{
    if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
        int z = heap_union(R[s1], s2);
        R[s1] = z; pr[z] = s1; if (dist[L[s1]] < dist[z]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;}
        dist[s1] = dist[R[s1]] + 1; return s1;
    } else {
        int z = heap_union(s1, R[s2]);
        R[s2] = z; pr[z] = s2; if (dist[L[s2]] < dist[z]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;}
        dist[s2] = dist[R[s2]] + 1; return s2;
    }
}
void prepare()
{
    dist[0] = -1; re1(i, n) {u[i] = -1; rt[i] = i; dist[i] = pr[i] = L[i] = R[i] = 0;}
}
void solve(int x, int y)
{
    int s1 = UFS_find(x), s2 = UFS_find(y); if (s1 == s2) {res = -1; return;}
    int rt1 = rt[s1], rt2 = rt[s2];
    int z1 = heap_union(L[rt1], R[rt1]); L[rt1] = R[rt1] = pr[z1] = 0;
    V[rt1] /= 2; z1 = heap_union(rt1, z1); pr[z1] = 0;
    int z2 = heap_union(L[rt2], R[rt2]); L[rt2] = R[rt2] = pr[z2] = 0;
    V[rt2] /= 2; z2 = heap_union(rt2, z2); pr[z2] = 0;
    int z = heap_union(z1, z2); pr[z] = 0;
    UFS_union(s1, s2, z);
    res = V[z];
}
int main()
{
    int m, x0, y0;
    while (scanf("%d", &n) != EOF) {
        re1(i, n) scanf("%d", &V[i]); prepare();
        scanf("%d", &m);
        re(i, m) {
            scanf("%d%d", &x0, &y0);
            solve(x0, y0);
            printf("%d\n", res);
        }
    }
    return 0;
}

�?�?a title="HDU3031" >HDU3031
�l�合操作题，需要sz�Q�同时也可以考察数据�l�构的综合应用能力�?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 1000010, MAXM = 101, MAXLEN_M = 10010, INF = ~0U >> 2;
int n, m, len[MAXM], V0[MAXM][MAXLEN_M], root[2];
int V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], sz[MAXN];
bool FS;
void upd(int x)
{
    sz[x] = sz[L[x]] + sz[R[x]] + 1;
}
int heap_union(int s1, int s2)
{
    if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
        int s0 = heap_union(R[s1], s2);
        pr[s0] = s1; R[s1] = s0; if (dist[L[s1]] < dist[s0]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;} dist[s1] = dist[R[s1]] + 1; upd(s1);
        return s1;
    } else {
        int s0 = heap_union(s1, R[s2]);
        pr[s0] = s2; R[s2] = s0; if (dist[L[s2]] < dist[s0]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;} dist[s2] = dist[R[s2]] + 1; upd(s2);
        return s2;
    }
}
void opr_T(int x)
{
    sort(V0[x], V0[x] + len[x]); int root0 = n + 1;
    rre(i, len[x]) {
        n++; if (i == len[x] - 1) pr[n] = 0; else pr[n] = n - 1; if (i) L[n] = n + 1; else L[n] = 0; R[n] = dist[n] = 0; V[n] = V0[x][i]; sz[n] = i + 1;
    }
    root[FS] = heap_union(root[FS], root0);
}
void opr_A(int x)
{
    V[root[FS]] += x;
}
void opr_E(int x)
{
    int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1; V[root0] = x;
    root[FS] = heap_union(z0, root0);
}
void opr_L()
{
    int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1;
}
void opr_C()
{
    int root0 = root[0], root1 = root[1];
    if (V[root0] > V[root1]) {
        root[0] = heap_union(root0, root1); root[1] = 0;
    } else if (V[root0] < V[root1]) {
        root[1] = heap_union(root0, root1); root[0] = 0;
    }
}
int main()
{
    int tests, sc0 = 0, sc1 = 0, P, tmp; char ssss[10];
    scanf("%d", &tests);
    re(testno, tests) {
        scanf("%d%d", &P, &m);
        re(i, m) scanf("%d", &len[i]);
        re(i, m) re(j, len[i]) scanf("%d", &V0[i][j]); n = root[0] = root[1] = 0; dist[0] = -1; sz[0] = 0; FS = 0;
        re(i, P) {
            scanf("%s", ssss);
            if (ssss[0] == 'T') {scanf("%d", &tmp); opr_T(--tmp);}
            else if (ssss[0] == 'A') {scanf("%d", &tmp); opr_A(tmp);}
            else if (ssss[0] == 'E') {scanf("%d", &tmp); opr_E(tmp);}
            else if (ssss[0] == 'L') opr_L(); else opr_C();
            FS = !FS;
        }
        printf("%d:%d\n", sz[root[0]], sz[root[1]]);
        if (sz[root[0]] >= sz[root[1]]) sc0++; else sc1++;
    }
    if (sc0 > sc1) puts("HahahaI win!!"); else puts("I will be back!!");
    return 0;
}

Mato_No1 2012-10-07 11:02 发表评论

块状数组

Mato_No1 — Tue, 17 Jan 2012 12:31:00 GMT

例题
本沙茶觉得块状数�l�又好写又有用（其实��是另一�U�朴素）……只是那个O(sqrt(n))的复杂度比较大而已�Q�其实如果加上常数的话它�q�不比Segplaytree慢多��）
�~�程技巧：
�Q?�Q�每块长度设为m=floor(sqrt(n))�Q�最后不��长度的不补��|��设n0为��d��敎ͼ�昄��n0=(n-1)/m+1�Q�；
�Q?�Q�设立LEN[i]=�W�i块的实际长度�Q�显焉��了最后一块都是m�Q�，可以在徏立块状数�l�（真正搞成块状�Q�也��是二维�Q�的时候得刎ͼ�
�Q?�Q�对于区间[l, r]�Q�要注意�Q?lt;1>l、r位于同一块（l/m==r/m�Q�的情况�Q?lt;2>r位于最后一块的情况�Q?br />�Q?�Q�别忘了同时更新原数�l�与块状数组�Q?br />
另外�Q�本例题需要二�?扑֤��个比它��的�q�样的操作，��L��间复杂度是O(N*sqrt(N)*log₂N*log₂N)�Q�幸亏N只有10000……�Q��?br />
如果有插入删除元素，��需要用动态的块状链表�?#8230;…极其难搞�Q�本沙茶不敢试了……遇到�q�种题还是写Segplaytree吧囧……

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 100002, MAXM = 320, INF = ~0U >> 2;
int n, m, n0, A[MAXN], T[MAXM][MAXM], LEN[MAXM], res;
int cmp(const void *s1, const void *s2)
{
    return *(int *)s1 - *(int *)s2;
}
void prepare()
{
    m = (int) floor(sqrt(n) + 1e-7); n0 = (n - 1) / m + 1; re(i, n0) LEN[i] = 0;
    re(i, n) T[i / m][LEN[i / m]++] = A[i];
    re(i, n0) qsort(T[i], LEN[i], sizeof(int), cmp);
}
void opr0(int No, int x)
{
    A[No] = x; int S = No / m; re(i, LEN[S]) T[S][i] = A[S * m + i]; qsort(T[S], LEN[S], sizeof(int), cmp);
}
int opr1(int l, int r, int x)
{
    int S0 = l / m, l0 = l % m, S1 = r / m, r0 = r % m, l1, r1, mid, res0 = 0;
    if (S0 == S1) re3(i, l0, r0) {if (A[S0 * m + i] < x) res0++;} else {
        re2(i, l0, LEN[S0]) if (A[S0 * m + i] < x) res0++;
        re3(i, 0, r0) if (A[S1 * m + i] < x) res0++;
        re2(i, S0+1, S1) {
            l1 = 0; r1 = LEN[i];
            while (l1 < r1) {
                mid = l1 + r1 >> 1;
                if (T[i][mid] >= x) r1 = mid; else l1 = mid + 1;
            }
            res0 += l1;
        }
    }
    return res0;
}
int main()
{
    int M, a0, b0, x0, l, r, mid; char ss[20];
    scanf("%d%d", &n, &M);
    re(i, n) scanf("%d", &A[i]); prepare();
    re(i, M) {
        scanf("%s", ss);
        if (ss[0] == 'C') {
            scanf("%d%d", &a0, &x0); opr0(--a0, x0);
        } else {
            scanf("%d%d%d", &a0, &b0, &x0); a0--; b0--;
            l = 0; r = 1000000000;
            while (l < r) {
                mid = l + r + 1 >> 1;
                if (opr1(a0, b0, mid) < x0) l = mid; else r = mid - 1;
            }
            printf("%d\n", l);
        }
    }
    return 0;
}

Mato_No1 2012-01-17 20:31 发表评论

Mato_No1 — Mon, 27 Jun 2011 12:54:00 GMT
首先�Q�Orz一下AHdoc��犇�Q�本沙茶是看他的�ȝ��才搞懂划分树的�?br />原文地址

划分树，��是每个�l�点代表一个序列，设这个序列的长度为len�Q�若len>1�Q�则序列中前len/2�Q�上取整�Q�这里数学公式不好打�Q�真囧）个元素被分到左子�l�点�Q�左子结点代表的序列��是�q�些元素按照根结点中的顺�?/strong>�l�成的序列，而剩下的元素被分到右子结点，叛_��l�点代表的序列也��是剩下的元素按照根�l�点中的��序�l�成的序列；若len=1�Q�则该结点�ؓ叶结炏V��划分树最重要的应用就是找区间�W�K��（只是查找�Q�不包括修改�Q��?br />
写划分树时主要有两个函数�Q�徏树和扑֌�间第K��。由于后者AHdoc��犇已经�ȝ��了，所以这里只�ȝ��建树的函数�?br />
讄��前结点�ؓ[l..r]�Q�l>1。然后可以得刎ͼ�[l..r]中小于中值的的元素一定被划分到左子结点，[l..r]中大于中值的元素一定被划分到右子结点，而[l..r]中等于中值的元素则不��定�Q�有的被划分到左子结点，有的被划分到叛_��l�点�Q�这��需要先扑ֈ�应被划分到左子结点的�{�于中值的元素个数sm�Q�从mid开始不断往左，直到扑ֈ�边界处或者找��C��个小于中值的元素为止�Q�或者说�Q�sm��是a0[l..mid]中等于中值的元素个数�Q�，然后开始划分，��于中值分到左子结点，大于中值分到右子结点，�{�于中值的�Q�若目前�q�没满sm则分到左子结点否则分到右子结炏V��另外中间有两个值需要记录（扑֌�间第K��时必须要用刎ͼ��Q�sl和sr。sl[i]表示[l..i]中被分到左子�l�点的元素个敎ͼ�sr[i]表示[l..i]中被分到叛_��l�点的元素个敎ͼ��q�里l<=i<=r。显然sl[i]+sr[i]=i-l+1�Q�其实sr[i]可以不用记录的，�q�里只是��Z��在找�W�K��操作中减少计算�ơ数�Q��v到空间换旉��的作用）�?br />建树代码�Q?
int mkt(int l, int r, int d)
{
    T[++No].l = l; T[No].r = r; int mid = l + r >> 1; T[No].mid = mid;
    if (l == r) return No;
    int midv = a0[mid], sm = mid - l + 1; rre2(i, mid, l) if (a0[i] < midv) {sm = mid - i; break;}
    int x = l, y = mid + 1;
    if (a[d][l] < midv) {
        a[d + 1][x++] = a[d][l]; sl[d][l] = 1; sr[d][l] = 0;
    } else if (a[d][l] == midv && sm) {
        a[d + 1][x++] = a[d][l]; sl[d][l] = 1; sr[d][l] = 0; sm--;
    } else {
        a[d + 1][y++] = a[d][l]; sl[d][l] = 0; sr[d][l] = 1;
    }
    re3(i, l+1, r) {
        if (a[d][i] < midv) {
            a[d + 1][x++] = a[d][i]; sl[d][i] = sl[d][i - 1] + 1; sr[d][i] = sr[d][i - 1];
        } else if (a[d][i] == midv && sm) {
            a[d + 1][x++] = a[d][i]; sl[d][i] = sl[d][i - 1] + 1; sr[d][i] = sr[d][i - 1]; sm--;
        } else {
            a[d + 1][y++] = a[d][i]; sl[d][i] = sl[d][i - 1]; sr[d][i] = sr[d][i - 1] + 1;
        }
    }
    int No0 = No; T[No0].lch = mkt(l, mid, d + 1); T[No0].rch = mkt(mid + 1, r, d + 1); return No0;
}
�q�里a是每层划分后的序列�?br />查找区间�W�K��的代码�Q?
int Find_Kth(int l, int r, int K)
{
    int i = root, d = 0, l0, r0, mid0, s0, s1;
    while (1) {
        l0 = T[i].l, r0 = T[i].r; mid0 = T[i].mid;
        if (l0 == r0) return a[d][l];
        if (l == l0) s0 = l; else s0 = l0 + sl[d][l - 1]; s1 = l0 + sl[d][r] - 1;
        if (K <= s1 - s0 + 1) {
            i = T[i].lch; l = s0; r = s1; d++;
        } else {
            K -= (s1 - s0 + 1); if (l == l0) l = mid0 + 1; else l = mid0 + sr[d][l - 1] + 1;
            r = mid0 + sr[d][r]; i = T[i].rch; d++;
        }
    }
}

【具体题目�?a title="PKU2104" >PKU2104�?a title="PKU2761" >PKU2761�Q�两道�Q选一道）

Mato_No1 2011-06-27 20:54 发表评论