好久久免费视频高清,国产成人无码精品久久久性色,久久亚洲AV永久无码精品

【AHOI2013复仇】关于线�D�|��下标的一�U�优化表�C�法

Mato_No1 — Sat, 01 Dec 2012 04:11:00 GMT

在线�D�|��中，一般都不需要刻意保存其左右子结点的下标�Q�而直接由其本�w�的下标导出�Q�传�l�的写法是：
根结点：1
A的左子结点：2A�Q�写成A<<1�Q?br />A的右子结点：2A+1�Q�写�?A<<1)+1�Q?br />�q�种表示法可以表�C�出整棵�U�段树，因�ؓ�Q?br />�Q?�Q�每个结点的子结点的下标都比它大�Q�这样就不会出现环；
�Q?�Q�每个结点的父结炚w��是唯一的（其本�w�下标整�?�Q�；
但是�Q�这�U�表�C�法有一个弱点：�l�点的下标是有可能超�q?N的，但不会超�q?N�Q�因此，��Z��表示��度�ؓN的线�D�，我们需要开4N的空��_��然而，其中只有2N-1个位�|�是有用的（因�ؓ表示跨度为N的线�D늚��U�段树共�?2N-1)个结点）�Q?span style="color: red">�q�样�Q�就有一半的�I�间被浪�?/strong>。尤其是�q�种�U�段树推�q�到多维的时�?#8212;—K�l�线�D�|��只�?/2^K的位�|�是有用的，�I�间利用率非�怽�。在某些卡空间的场合�Q�它��囧掉了�?br />
那么�Q�有木有好一点的写法呢？最好能使空间利用率辑ֈ�100%——也就是所有结点的下标刚好��是1~(2N-1)�Q�！�Q?��L��点一般作�?#8220;哨兵”�Q�不被占用）
�q�且�Q�这�U�写法要保证仅仅��q��点的下标和它表示的线�D늚�左右端点�Q�因为在遍历�U�段�Ӟ��下标和左右端点基本上都是同时知道的）�Q�就能得出其子结点的下标�Q�而不需要借助额外的东东（最好mid都不需要算�Q��?br />�q�种写法��是——直接��每个结点的DFS遍历�ơ序当做它的下标�Q�！
比如�Q�跨度�ؓ6的线�D�|��Q?br />
�Ҏ��发现�Q�根�l�点下标�?�Q�下标�ؓA的结点的左子�l�点下标�?A+1)�Q�右子结点下标�ؓA+SZ(A.L)+1�Q�其中SZ(A.L)为A的左子树大小�?br />若A的左右端点�ؓl、r�Q�mid=(l+r)/2�Q�下取整�Q�，则A的左子树所表示的线�D��ؓ[l, mid]�Q�所以SZ(A.L)=(mid-l+1)*2-1=(mid-l)*2+1=((r-l-1)/2�Q�上取整�Q?*2+1
�q�样�Q�A的右子结点下标就是A+((r-l+1)/2�Q�上取整))*2�Q�也��是A加上大于(r-l)的最��的偶数�Q?br />写在代码里就是：
int mid=l+r>>1;
opr(l, mid, A+1);
opr(mid+1, r, (r-l&1?A+r-l+1:A+r-l+2));
或者，借助位运��，可以免去条�g判断�Q?
int mid=l+r>>1;
opr(l, mid, A+1);
opr(mid+1, r, A+r-l+2-((r^l)&1));
�l�测试，后者（使用位运��的�Q�虽然�ȝ��q�算�ơ数多于前者（使用条�g判断的）�Q�但后者比前者快一点点�Q�其原因可能与C语言中的条�g�q�算�W�速度较慢有关�Q?br />
�q�样�Q�我们就成功地将�U�段树下标的�I�间利用率提高到�?00%�Q�！以后只需要开2N�I�间��p��了囧……
与传�l�表�C�法相比�Q�这�U�新式表�C�法虽然可以节省�I�间�Q�但旉��消耗要更大一些（旉��和空间��L��矛盾的囧……�Q�，因�ؓ它在扑֏�子结点的时候需要较多的�q�算。��^均�v来，新式表示法比传统表示法要�?0~15%�Q�对于某些坑爹的数据�Q�对叛_��l�点调用比较多的那种�Q�可能慢得更多。此外，在下放标记的时候，传统表示法只需要知道结点下标就行了�Q�而新式表�C�法必须同时知道�l�点的左右端点，�q�样在dm中就需要传递三个参敎ͼ�从而要慢一些，当然�Q�我们可以不用dm�Q�直接在操作里面写标��C��放�?img src ="http://www.shnenglu.com/MatoNo1/aggbug/195857.html" width = "1" height = "1" />

Mato_No1 2012-12-01 12:11 发表评论

【NOI2005 �l�护数列(sequence)】Splay Tree处理序列问题

Mato_No1 — Tue, 21 Jun 2011 08:06:00 GMT

【原题见�q�里�?br />本题是Splay Tree处理序列问题�Q�也��是当线�D�|��用）的一个典型例题�?br />
Splay Tree之所以可以当�U�段树用�Q�是因�ؓ它可以支持一个序列，然后�?#8220;左端前趋伸展到根�Q�右端后�l��展到根的叛_��l�点�Q�取根的叛_��l�点的左子结�?#8221;�q�种伸展�Ҏ��Q�对一个序列中的一整段�q�行整体操作。由于要防止出现前趋或后�l�不存在的情况，需要在�q�个序列的两端加入两个边界结点，要求其��g��能媄响到�l�点各种记蝲信息的维护（多取0�?#8734;�?∞�Q�。这两个边界�l�点在树中永�q�存在，不会被删除�?br />
�Q?�Q�结点的引用�Q?br />在当�U�段树用的Splay Tree中，真正的关键字是下标而不是��|��因此�Q?#8220;序列中第i个结�?#8221;实际上对应的�?#8220;树中�W?i+1)��的�l�点”�Q�因为左边还有一个边界结点）�Q�这��p��明在对结点引用时需要找�W�K��的操作。因此，下面�?#8220;�l�点x”指的�?#8220;树中�W?x+1)��的�l�点”�?br />�Q?�Q�标讎ͼ�
在线�D�|��中，如果对一个结�Ҏ��表示的线�D�|��体进行了某种操作�Q�需要在�q�个�l�点上打上一个标讎ͼ�在下一�ơ再扑ֈ��q�个�l�点�Ӟ��其标记就会下攑ֈ�其两个子�l�点上。在Splay Tree中也可以引入标记。比如要对[2, 6]�q�一�D�进行整体操作，��将�l�点1伸展到根的位�|�，��结�?伸展到根的右子树的位�|�，然后�l�点7的左子树��p��C�[2, 6]�q�一�D�，对这��子树的根结�Ҏ��上标记�ƈ立即生效�Q�必��L��立即生效�Q�而不是等下一�ơ引用再生效�Q�，也就是立��x��变该�l�点记录的一些信息的倹{��如果下�ơ再�ơ引用到�q�个�l�点�Q�就要将其标��C��攑ֈ�其两个子�l�点处；
需要注意的一�Ҏ��Q�如果要伸展某个�l�点x到r的子�l�点的位�|�，��必��M��证从x原来的位�|�到r的这个子�l�点�Q�x伸展后的位置�Q�上的所有结点上均没有标讎ͼ�否则��׃��D��标记混�ؕ。因此，必须首先扑ֈ��q�个�l�点x�Q�在此过�E�中不断下放标记�?br />�Q?�Q�自底向上维护的信息�Q?br />标记可以看成一�U�自��向下维护的信息。除了标��C��外，作�ؓ“�U�段�?#8221;�Q�往往�q�要�l�护一些自底向上维护的信息。比如在sequence�q�题中，��有lmax�Q�左�D�连�l�最大和�Q�、rmax�Q�右�D�连�l�最大和�Q�、midmax�Q�全�D�连�l�最大和�Q�以及sum�Q�全�D�|��d��Q�等信息要维护。对于这�c�M��东其实也很好办，因�ؓ子树大小�Q�sz域）��是一�U�自底向上维护的信息�Q�因此对于这些信息只要按照维护sz域的办法�l�护卛_��Q�统一写在upd函数里）。唯一的不同点是打标记时它们的值可能要改变�?br />�Q?�Q�对�q�箋插入的结点徏树：
本题的插入不是一个一个插入，而是一下子插入一整段�Q�因此需要先��它们徏成一��|��。一般徏树操作都是递归的，�q�里也一栗��设目前要对A[l..r]建树�Q�A为待插入序列�Q�，若l>r则退出，否则扑ֈ�位于中间的元素mid = l + r >> 1�Q�将A[mid]作根�Q�再对A[l..mid-1]建左子树�Q�对A[mid+1..r]建右子树卛_��。这样可以保证一开始徏的就是一��^衡树�Q�减��常数因子�?br />�Q?�Q�回收空��_��
�Ҏ��本题的数据范围提�C�，插入的结�Ҏ��L��最多可能达�?000000�Q�但在�Q何时��L��中最多只�?00002个结点（包括两个边界�Q�，此时��Z��节省�I�间�Q�可以采用��@环队列回收空间的�Ҏ��。即�Q�一开始将所有的可用�I�间�Q�可用下标，本题�?~500002�Q�存在��@环队列Q里，同时讄��头尾指针front和rear�Q�每�ơ如果有新结�Ҏ��入，��取出Q[front]�q�作为新�l�点的下标，如果有结点要删除�Q�本题是一�ơ删除整��子树，因此在删除后需要分别回收它们的�I�间�Q�，则从rear开始，��每个删除的�l�点的下标放回到Q里。当�Ӟ��q�种�Ҏ��是要牺牲一定的旉��的，因此在空间不是特别吃紧的情况下不要用�?br />
�?012�q?�?6日更新�?br />今天重写sequence的时候，�U�然发现加入的边界点可能会对lmax、rmax、midmax�{�的�l�护造成影响�Q�当序列中所有的值都是负数时�Q�若边界点的��D��?�Q�将使这3个��g��?�Q�所以，边界点的值应设�ؓ-INF�Q�不会媄响到sum�Q�因为可以单独调出[l, r]的sum�Q�避开边界�Q�。这��p��明�ƈ非所有这��L��题中都可以设�|�边界点�Q�比如HFTSC2011的那题就不行�Q�，如果边界点会对维护的信息造成影响�Q�就不能讄��边界点，在各个操作中�Q�分4�U�情况判断。（代码已经修改�Q?br />
下面上代码了�Q?
#include <iostream>
#include <stdio.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re1(i, n) for (int i=1; i<=n; i++)
const int MAXN = 500002, NOSM = -2000, INF = ~0U >> 2;
struct node {
    int v, c[2], p, sz, sum, lmax, rmax, midmax, sm;
    bool rev, d;
} T[MAXN + 1];
int root, Q[MAXN + 1], front, rear, a[MAXN], len, res;
int max(int SS0, int SS1)
{
    return SS0 >= SS1 ? SS0 : SS1;
}
int max(int SS0, int SS1, int SS2)
{
    int M0 = SS0 >= SS1 ? SS0 : SS1; return M0 >= SS2 ? M0 : SS2;
}
void newnode(int n, int _v)
{
    T[n].v = T[n].sum = T[n].lmax = T[n].rmax = T[n].midmax = _v; T[n].c[0] = T[n].c[1] = 0; T[n].sz = 1; T[n].sm = NOSM; T[n].rev = 0;
}
void sc(int _p, int _c, bool _d)
{
    T[_p].c[_d] = _c; T[_c].p = _p; T[_c].d = _d;
}
void sm_opr(int x, int SM)
{
    T[x].sum = T[x].sz * SM;
    if (SM > 0) T[x].lmax = T[x].rmax = T[x].midmax = T[x].sum; else T[x].lmax = T[x].rmax = T[x].midmax = SM;
}
void rev_opr(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1]; sc(x, c0, 1); sc(x, c1, 0);
    int tmp = T[x].lmax; T[x].lmax = T[x].rmax; T[x].rmax = tmp;
}
void dm(int x)
{
    int SM0 = T[x].sm;
    if (SM0 != NOSM) {
        T[x].v = T[T[x].c[0]].sm = T[T[x].c[1]].sm = SM0; T[x].sm = NOSM;
        sm_opr(T[x].c[0], SM0); sm_opr(T[x].c[1], SM0);
    }
    if (T[x].rev) {
        T[T[x].c[0]].rev = !T[T[x].c[0]].rev; T[T[x].c[1]].rev = !T[T[x].c[1]].rev; T[x].rev = 0;
        rev_opr(T[x].c[0]); rev_opr(T[x].c[1]);
    }
}
void upd(int x)
{
    int c0 = T[x].c[0], c1 = T[x].c[1];
    T[x].sz = T[c0].sz + T[c1].sz + 1;
    T[x].sum = T[c0].sum + T[c1].sum + T[x].v;
    T[x].lmax = max(T[c0].lmax, T[c0].sum + T[x].v + max(T[c1].lmax, 0));
    T[x].rmax = max(T[c1].rmax, max(T[c0].rmax, 0) + T[x].v + T[c1].sum);
    T[x].midmax = max(T[c0].midmax, T[c1].midmax, max(T[c0].rmax, 0) + T[x].v + max(T[c1].lmax, 0));
}
void rot(int x)
{
    int y = T[x].p; bool d = T[x].d;
    if (y == root) {root = x; T[root].p = 0;} else sc(T[y].p, x, T[y].d);
    sc(y, T[x].c[!d], d); sc(x, y, !d); upd(y);
}
void splay(int x, int r)
{
    int p; while ((p = T[x].p) != r) if (T[p].p == r) rot(x); else if (T[x].d == T[p].d) {rot(p); rot(x);} else {rot(x); rot(x);} upd(x);
}
int Find_Kth(int K)
{
    int i = root, S0;
    while (i) {
        dm(i); S0 = T[T[i].c[0]].sz + 1;
        if (K == S0) break; else if (K < S0) i = T[i].c[0]; else {K -= S0; i = T[i].c[1];}
    }
    return i;
}
int mkt(int l, int r)
{
    if (l > r) return 0;
    int n0 = Q[front], mid = l + r >> 1; if (front == MAXN) front = 1; else front++;
    newnode(n0, a[mid]); int l_r = mkt(l, mid - 1), r_r = mkt(mid + 1, r);
    sc(n0, l_r, 0); sc(n0, r_r, 1); upd(n0); return n0;
}
void ins(int pos)
{
    int P0 = Find_Kth(pos); splay(P0, 0); int P1 = Find_Kth(pos + 1); splay(P1, root); sc(P1, mkt(0, len - 1), 0); upd(P1); upd(P0);
}
void era(int x)
{
    if (!x) return;
    if (rear == MAXN) rear = 1; else rear++; Q[rear] = x;
    era(T[x].c[0]); era(T[x].c[1]);
}
void del(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int root0 = T[P1].c[0]; sc(P1, 0, 0); upd(P1); upd(P0); era(root0);
}
void mksame(int l, int r, int x)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].sm = x; sm_opr(n, x); upd(P1); upd(P0);
}
void reve(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; T[n].rev = !T[n].rev; rev_opr(n); upd(P1); upd(P0);
}
int get_sum(int l, int r)
{
    int P0 = Find_Kth(l - 1); splay(P0, 0); int P1 = Find_Kth(r + 1); splay(P1, root);
    int n = T[P1].c[0]; return T[n].sum;
}
int max_sum()
{
    return T[root].midmax;
}
void prepare()
{
    T[0].sz = T[0].sum = T[0].lmax = T[0].rmax = T[0].midmax = 0;
    front = 3; rear = MAXN; re1(i, MAXN) Q[i] = i;
    newnode(1, -INF); newnode(2, -INF); sc(1, 2, 1); root = 1; T[root].p = 0;
}
int main()
{
    freopen("sequence.in", "r", stdin);
    freopen("sequence.out", "w", stdout);
    prepare();
    int m, l, r, x;
    scanf("%d%d", &len, &m); char ch = getchar(), str[1000];
    re(i, len) scanf("%d", &a[i]); ins(1);
    re(i, m) {
        scanf("%s", str);
        if (!strcmp(str, "INSERT")) {scanf("%d%d", &l, &len); re(i, len) scanf("%d", &a[i]); ins(++l);}
        if (!strcmp(str, "DELETE")) {scanf("%d%d", &l, &r); r += l++; del(l, r);}
        if (!strcmp(str, "MAKE-SAME")) {scanf("%d%d%d", &l, &r, &x); r += l++; mksame(l, r, x);}
        if (!strcmp(str, "REVERSE")) {scanf("%d%d", &l, &r); r += l++; reve(l, r);}
        if (!strcmp(str, "GET-SUM")) {scanf("%d%d", &l, &r); r += l++; printf("%d\n", get_sum(l, r));}
        if (!strcmp(str, "MAX-SUM")) printf("%d\n", max_sum());
        ch = getchar();
    }
    fclose(stdin); fclose(stdout);
    return 0;
}

最后把我的�q�个代码与BYVoid��犇的本题代码进行测试比较，�l�果�Q�BYVoid��犇的代码见�q�里�Q�：

BYVoid��犇的：

本沙茶的�Q?br />

【相兌��文�?br />Mato_No1 2011-06-21 16:06 发表评论

Mato_No1 — Sun, 29 May 2011 08:03:00 GMT

�l�出一个带�Ҏ��的无向图G�Q�设其最��生成树为T�Q�求出图G的与T不完全相�?/strong>的边权和最��的生成树（即G的次��生成树�Q�。一个无向图的两��는�成树不完全相同，当且仅当�q�两��|��中至��有一条边不同。注意，图G可能不连通，可能有��^行边�Q�但一定没有自环（其实对于自环也很好处理：直接舍弃。因为生成树中不可能出现自环�Q��?br />【具体题目�?a title="URAL1416" >URAL1416�Q�注意，�q�一题的�Ҏ��M的范围没有给出，视�ؓ124750�Q?br />【分析�?br />定义生成树T的一个可行变�?-E1, +E2)�Q�将T中的边E1删除后，再加入边E2�Q�满��E2原来不在T中但在G中）�Q�若得到的仍然是图G的一��는�成树�Q�则该变换�ؓ可行变换�Q�该可行变换�?strong style="color: red">代�h�?E2权�?- E1权�?。这��P��很容易证明，G的次��生成树��是由G的最��生成树�l�过一个代��h��的可行变换得到。进一步可以发玎ͼ��q�个代�h最��的可行变换中加入的边E2的两端点如果为V1和V2�Q�那么E1一定是原来最��生成树中从V1到V2的�\径上的权值最大的�?/strong>�?br />
�q�样�Q�对于本题就有两�U�算法了�Q�（以下的T全部指G的最��生成树�Q?br />�Q?�Q�Prim�Q?br />讄��数组F�Q�F[x][y]表示T中从x到y路径上的最大边的权倹{��F数组可以在用Prim��法求最��生成树的过�E�中得出。每�ơ将�?i, j)加入后（j是新加入树的边，i=c[j]�Q�，枚�D树中原有的每个点k�Q�包括i�Q�但不包括j�Q�，则F[k][j]=max{F[k][i], (i, j)�Ҏ��值}�Q�又�׃��F数组是对�U�的�Q�可以得到F[j][k]=F[k][j]。然后千万记住将图G中的�?i, j)删除�Q�就是将��L��矩阵�?i, j)�Ҏ��值改�?#8734;�Q�！因�ؓT中的�Ҏ��不能被加入的。等T被求出后�Q�所有的F��g��求出了，然后�Q�枚丄��i、j�Q�若��L��矩阵中边(i, j)权��g��是无�I�大�Q�这说明i、j间存在不在T中的边）�Q�则求出{(i, j)�Ҏ��?- F[i][j]}的��|��即�ؓ加入�?i, j)的代��P��求最��的��M��价即可�?br />另外注意三种�Ҏ��情况�Q��?】图G不连通，此时最��生成树和次��生成树均不存在。判定方法：在扩展T的过�E�中找不到新的可以加入的边；�?】图G本��n��是一��|��Q�此时最��生成树存在�Q�就是G本��n�Q�但�ơ小生成树不存在。判定方法：在成功求出T后，发现��L��矩阵中的值全部是无穷大；�?】图G存在�q��辏V��这�U�情冉|��ȝ��Q�因��时代��h��的可行变换(-E1, +E2)中，E1和E2可能是��^行边�Q�因此，只有建立两个��L��矩阵�Q�分别存储每两点间权值最��的边和权值次��的边的权��|��然后�Q�每当一条新�?i, j)加入�Ӟ��不是��邻接矩阵中�?i, j)权值改为无�I�大�Q�而是改�ؓ�q�接点i、j的权值次��的边的权倹{�?br />
代码�Q?
#include <iostream>
using namespace std;
#define re(i, n) for (int i=0; i
#define re2(i, l, r) for (int i=l; i
const int MAXN = 7000, INF = ~0U >> 2;
int n, s[MAXN][MAXN], s2[MAXN][MAXN], f[MAXN][MAXN], c[MAXN], v[MAXN], res1 = 0, res2 = 0;
bool vst[MAXN];
void init()
{
    freopen("mst.in", "r", stdin);
    scanf("%d", &n);
    re(i, n) re(j, n) s[i][j] = s2[i][j] = INF;
    int m, a, b, len;
    scanf("%d", &m);
    if (!m) {
        if (n > 1) res1 = -INF; res2 = -INF;
        return;
    }
    re(i, m) {
        scanf("%d%d%d", &a, &b, &len); a--; b--;
        if (len < s[a][b]) {s2[a][b] = s2[b][a] = s[a][b]; s[a][b] = s[b][a] = len;} else if (len < s2[a][b]) s2[a][b] = s2[b][a] = len;
    }
    fclose(stdin);
}
void solve()
{
    re(i, n) {f[i][i] = c[i] = vst[i] = 0; v[i] = s[0][i];} vst[0] = 1;
    int l0, l1 = INF, x, y, z;
    re2(i, 1, n) {
        l0 = INF; re(j, n) if (!vst[j] && v[j] < l0) {l0 = v[j]; x = j; y = c[j];}
        if (l0 == INF) {res1 = res2 = -INF; return;}
        vst[x] = 1; res1 += l0; s[x][y] = s[y][x] = INF; if (s2[x][y] < INF && s2[x][y] - l0 < l1) l1 = s2[x][y] - l0;
        re(j, n) if (!vst[j] && s[x][j] < v[j]) {v[j] = s[x][j]; c[j] = x;}
        re(j, n) if (vst[j] && j != x) f[j][x] = f[x][j] = max(f[j][y], l0);
    }
    re(i, n-1) re2(j, i+1, n) if (s[i][j] < INF) {
        z = s[i][j] - f[i][j];
        if (z < l1) l1 = z;
    }
    if (l1 == INF) res2 = -INF; else res2 = res1 + l1;
}
void pri()
{
    freopen("mst.out", "w", stdout);
    printf("Cost: %d\nCost: %d\n", res1 == -INF ? -1 : res1, res2 == -INF ? -1 : res2);
    fclose(stdout);
}
int main()
{
    init();
    if (!res2) solve();
    pri();
    return 0;
}
效率分析�Q�Prim��法求次��生成树的时�I�复杂度均�ؓO(N²)�?/span>

�Q?�Q�Kruskal�Q?/span>
Kruskal��法也可以用来求�ơ小生成树。在准备加入一条新�?a, b)�Q�该边加入后不会出现环）�Ӟ��选择原来a所在连通块�Q�设为S1�Q�与b所在连通块�Q�设为S2�Q?/span>中，点的个数��的那个�Q�如果随侉K��一个，最坏情况下可能每次都碰到点数多的那个，旉��复杂度可能增至O(NM)�Q�，扑ֈ�该连通块中的每个点i�Q��ƈ遍历所有与i相关联的边，若发现某条边的另一端点j在未选择的那个连通块中（也就是该�?i, j)跨越了S1和S2�Q�时�Q�就说明最�l�在T�?删除�?a, b)�q�加入该�?一定是一个可行变换，且由于加�Ҏ��按照权值递增��序的，(a, b)也一定是T中从i到j路径上权值最大的边，故这个可行变换可能成��Z��h��的可行变换�Q�计��其代�h为[(i, j)�Ҏ��?- (a, b)�Ҏ��值]�Q�取最��代价即可。注意，在遍历时需要排除一条边�Q�就�?a, b)本��n�Q�具体实现时�׃��用DL边表�Q�可以将�?a, b)的编号代入）。另外还有一个难搞的地方�Q�如何快速找出某�q�通块内的所有点�Q�方法：�׃��使用�q�查集，�q�通块是用树的方式存储的，可以直接��Z��|��Q�准��来说是一个森林）�Q�用“最左子�l�点+盔R��l�点”表示�Q�则扑և�树根后遍历这��|��p��了，另外注意在合�q�连通块时也要同时合�q�树�?br />对于三种�Ҏ��情况�Q��?】图G不连通。判定方法：遍历完所有的边后�Q�实际加入T的边数小�?N-1)�Q��?】图G本��n��是一��|��。判定方法：找不到这��L��?i, j)�Q��?】图G存在�q��辏V��这个对于Kruskal来说完全可以无视�Q�因为Kruskal中两条边只要�~�号不同��p��Z��同的辏V�?br />其实Kruskal��法求次��生成树�q�有一个优化：每次扑ֈ��?i, j)后，一处理完这条边��把它从图中删掉�Q�因为当S1和S2合�ƈ后，(i, j)��永�q�不可能再是可行变换中的E2了�?br />
代码�Q?br />
#include <iostream>
#include <stdlib.h>
using namespace std;
#define re(i, n) for (int i=0; i
#define re3(i, l, r) for (int i=l; i<=r; i++)
const int MAXN = 7000, MAXM = 130000, INF = ~0U >> 2;
struct edge {
    int a, b, len, pre, next;
} ed[MAXM + MAXM];
struct edge2 {
    int a, b, len, No;
} ed2[MAXM];
int n, m = 0, m2, u[MAXN], ch[MAXN], nx[MAXN], q[MAXN], res1 = 0, res2 = INF;
void init_d()
{
    re(i, n) ed[i].a = ed[i].pre = ed[i].next = i;
    if (n % 2) m = n + 1; else m = n;
}
void add_edge(int a, int b, int l)
{
    ed[m].a = a; ed[m].b = b; ed[m].len = l; ed[m].pre = ed[a].pre; ed[m].next = a; ed[a].pre = m; ed[ed[m].pre].next = m++;
    ed[m].a = b; ed[m].b = a; ed[m].len = l; ed[m].pre = ed[b].pre; ed[m].next = b; ed[b].pre = m; ed[ed[m].pre].next = m++;
}
void del_edge(int No)
{
    ed[ed[No].pre].next = ed[No].next; ed[ed[No].next].pre = ed[No].pre;
    ed[ed[No ^ 1].pre].next = ed[No ^ 1].next; ed[ed[No ^ 1].next].pre = ed[No ^ 1].pre;
}
void init()
{
    freopen("mst.in", "r", stdin);
    scanf("%d%d", &n, &m2);
    if (!m2) {
        if (n > 1) res1 = -INF;
        res2 = -INF; return;
    }
    init_d();
    int a, b, len;
    re(i, m2) {
        scanf("%d%d%d", &a, &b, &len);
        ed2[i].No = m; add_edge(--a, --b, len);
        ed2[i].a = a; ed2[i].b = b; ed2[i].len = len;
    }
    fclose(stdin);
}
int cmp(const void *s1, const void *s2)
{
    return ((edge2 *)s1)->len - ((edge2 *)s2)->len;
}
void prepare()
{
    re(i, n) u[i] = ch[i] = nx[i] = -1;
    qsort(ed2, m2, 16, cmp);
}
int find(int x)
{
    int r = x, r0 = x, tmp;
    while (u[r] >= 0) r = u[r];
    while (u[r0] >= 0) {tmp = u[r0]; u[r0] = r; r0 = tmp;}
    return r;
}
void uni(int r1, int r2, int No, int l0)
{
    q[0] = r1;
    int j, k, l1, front, rear;
    for (front=0, rear=0; front<=rear; front++) {
        j = ch[q[front]];
        while (j != -1) {
            q[++rear] = j;
            j = nx[j];
        }
    }
    re3(i, 0, rear) {
        j = q[i];
        for (int p=ed[j].next; p != j; p=ed[p].next) {
            k = ed[p].b;
            if (p != No && find(k) == r2) {
                l1 = ed[p].len - l0;
                if (l1 < res2) res2 = l1;
                del_edge(p);
            }
        }
    }
    u[r2] += u[r1]; u[r1] = r2; nx[r1] = ch[r2]; ch[r2] = r1;
}
void solve()
{
    int r1, r2, l0, num = 0;
    re(i, m2) {
        r1 = find(ed2[i].a); r2 = find(ed2[i].b);
        if (r1 != r2) {
            l0 = ed2[i].len; res1 += l0; num++;
            if (u[r1] >= u[r2]) uni(r1, r2, ed2[i].No, l0); else uni(r2, r1, ed2[i].No ^ 1, l0);
        }
    }
    if (num < n - 1) {res1 = res2 = -INF; return;}
    if (res2 == INF) res2 = -INF; else res2 += res1;
}
void pri()
{
    freopen("mst.out", "w", stdout);
    printf("Cost: %d\nCost: %d\n", res1 == -INF ? -1 : res1, res2 == -INF ? -1 : res2);
    fclose(stdout);
}
int main()
{
    init();
    if (!res1 && res2 == INF) {
        prepare();
        solve();
    }
    pri();
    return 0;
}
效率分析�Q�可以证明，如果每次都选取点少的连通块�Q�Kruskal��法求次��生成树的时间复杂度为O(M*(logN+logM))�Q�空间复杂度为O(M)�?br />�ȝ��Q�显然Prim适用于稠密图�Q�而Kruskal适用于稀疏图�?br />
下面是对于一些数据的��试�l�果�Q�数据说明：�W?~9个点和第15个点为稠密图或一般图�Q�第10~14个点为稀疏图�Q?br />
Prim�Q?br />

Kruskal�Q�加入删边优化）�Q?br />

Kruskal�Q�未加删边优化）�Q?br />

Mato_No1 2011-05-29 16:03 发表评论

Mato_No1 — Sat, 19 Mar 2011 09:55:00 GMT

代码1�Q�SAP单�\增广�Q�非递归�Q�；

代码2�Q�SAP多�\增广�Q�递归�Q�；

代码3�Q�Dinic单�\增广�Q�非递归�Q�；

代码4�Q�Dinic多�\增广�Q�递归�Q�；

�l�果�Q?/p>
代码1�Q?br>
代码2�Q?

代码3�Q?br>
代码4�Q?br>
�l�果�Q?br>SAP加了多�\增广后，直接�U�掉�?个点�Q?br>Dinic加了多�\增广后效率差不多�Q�还更低了一�?#8230;…

�Q�另外发玎ͼ�SAP的多路增�q�不支持当前弧优�?#8230;…�q�点和zkw费用��有点像�?#8230;…不过效率影响不大……�Q?br>

Mato_No1 2011-03-19 17:55 发表评论