[BeiJing2010组队][BZOJ 1977]次小生成树 Tree

话说这个[BeiJing2010组队]是个什喵玩意？

这是一道严格次小生成树，而次小生成树的做法是层出不穷的

MATO IS NO.1 的博客里对两种算法都有很好的解释，值得拥有:  (果然除我以外，所有自称傻 X 的都是神犇喵~)

　　http://www.cppblog.com/MatoNo1/archive/2011/05/29/147627.aspx

MATO还讲了一个神级复杂度的次小生成树:  (请全部读完。如果被坑，后果自负)

　　http://www.cppblog.com/MatoNo1/archive/2011/11/16/149812.html

如果你可以打开人人网的话(你懂的喵~)，这也是篇很好的博文:

　　http://blog.renren.com/share/235365847/6633394303 

该说的都在上面了，我就扔扔代码吧  (高能勿喷)

#include <cstdio>
#include <algorithm>
typedef long long llint;
const int inf=0x7FFFFFFF;
const int sizeOfN=100001;
const int sizeOfM=300003;

namespace IOspace
{
    inline int getint()
    {
        register int num=0;
        register char ch;
        do ch=getchar(); while (ch<'0' || ch>'9');
        do num=num*10+ch-'0', ch=getchar(); while (ch>='0' && ch<='9');
        return num;
    }
    inline void putint(llint num, char ch='
')
    {
        char stack[15];
        register int top=0;
        if (num==0) stack[top=1]='0';
        for ( ;num;num/=10) stack[++top]=num%10+'0';
        for ( ;top;top--) putchar(stack[top]);
        if (ch) putchar(ch);
    }
}

int N, M;

struct node {int u, v, c;};
node a[sizeOfM];
bool b[sizeOfM];
inline bool operator < (node i, node j)
    {return i.c<j.c;}

struct edge {int point, dist; edge * next;};
edge MEM[sizeOfM], * PORT=MEM;
edge * E[sizeOfN];
inline edge * newedge(int _point, int _dist, edge * _next)
    {edge * ret=PORT++; ret->point=_point; ret->dist=_dist; ret->next=_next; return ret;}
inline void build(int u, int v, int c)
    {E[u]=newedge(v, c, E[u]); E[v]=newedge(u, c, E[v]);}

int r[sizeOfN];
int find(int x) {return r[x]==x?x:r[x]=find(r[x]);}

int f[sizeOfN][20], l[2][sizeOfN][20], h[sizeOfN];
bool vis[sizeOfN];
int top, stack[sizeOfN]; edge * temp[sizeOfN];
inline void search();

inline int max(int x, int y) {return x>y?x:y;}
inline int min(int x, int y) {return x<y?x:y;}
inline void swap(int & x, int & y) {int t=x; x=y; y=t;}
inline int lg(int x) {int i; for (i=0;x>1;i++) x>>=1; return i;}
inline int lowbit(int x) {return x & -x;}
inline int lca(int, int, int);
inline llint kurskal();
inline void prepare();
inline int calc();

int main()
{
    llint ans=0;

    N=IOspace::getint(); M=IOspace::getint();
    for (int i=0;i<M;i++) a[i].u=IOspace::getint(), a[i].v=IOspace::getint(), a[i].c=IOspace::getint();

    ans=kurskal();
    prepare();
    ans+=calc();

    IOspace::putint(ans);

    return 0;
}
inline void search()
{
    f[1][0]=0; h[1]=1;
    for (stack[++top]=1, temp[top]=E[1];top; )
    {
        int & u=stack[top]; edge *& i=temp[top];
        if (!vis[u]) vis[u]=1;
        for ( ;i;i=i->next) if (!vis[i->point])
        {
            f[i->point][0]=u; h[i->point]=h[u]+1;
            l[0][i->point][0]=i->dist; l[1][i->point][0]=-inf;
            stack[++top]=i->point; temp[top]=E[i->point];
            break;
        }
        if (i) continue;
        top--;
    }
}
inline llint kurskal()
{
    llint ret=0;
    int tot=N-1;

    std::sort(a, a+M);
    for (int i=1;i<=N;i++) r[i]=i;

    for (int i=0;i<M;i++)
    {
        int u=find(a[i].u), v=find(a[i].v);
        if (u!=v)
        {
            build(a[i].u, a[i].v, a[i].c); ret+=a[i].c;
            b[i]=1;
            r[u]=v;
            if (!--tot) break;
        }
    }

    return ret;
}
inline void prepare()
{
    search();
    for (int j=1;j<20;j++)
        for (int i=1;i<=N;i++) if (h[i]>=(1<<j))
        {
            f[i][j]=f[f[i][j-1]][j-1];
            l[0][i][j]=l[0][i][j-1]; l[1][i][j]=l[1][i][j-1];
            if (l[0][f[i][j-1]][j-1]>l[0][i][j]) l[1][i][j]=l[0][i][j], l[0][i][j]=l[0][f[i][j-1]][j-1];
            else if (l[0][f[i][j-1]][j-1]<l[0][i][j])
                if (l[0][f[i][j-1]][j-1]>l[1][i][j]) l[1][i][j]=l[0][f[i][j-1]][j-1];
        }
}
inline int lca(int u, int v, int x)
{
    int ret=-1, dis;

    if (h[u]<h[v]) swap(u, v);
    while (dis=h[u]-h[v])
    {
        int up=lg(lowbit(dis));
        ret=max(ret, l[l[0][u][up]==x][u][up]);
        u=f[u][up];
    }
    if (u==v) return ret;

    for (int i=19;i>=0;i--)
        if (f[u][i]!=f[v][i])
        {
            ret=max(ret, l[l[0][u][i]==x][u][i]);
            ret=max(ret, l[l[0][v][i]==x][v][i]);
            u=f[u][i]; v=f[v][i];
        }
    ret=max(ret, l[l[0][u][0]==x][u][0]);
    ret=max(ret, l[l[0][v][0]==x][v][0]);

    return ret;
}
inline int calc()
{
    int ret=inf;
    for (int i=0;i<M;i++)
        if (!b[i])
            ret=min(ret, a[i].c-lca(a[i].u, a[i].v, a[i].c));
    return ret;
}

写的比树套树还长，真是没脸见人了喵~