hdu6041仙人掌图

hdu6041
题意：给一个仙人掌图，f（i）为该图的第i小生成树的权值，问sum（f（i））1<=i<=k,简单说就是求前k小的生成树的权值的和。
仙人掌图有一个特点就是每条边只存在于图中的一个环中，
左图为仙人掌图，就是有点像仙人掌，有图因为两个环公用一条边，所以不能都成仙人掌图。
由于是仙人掌图，这个题就简单了，我们可以从每个环中取出一条边，那么圣剩下的就是一棵树，so，我们可以把所有权值加起来 记为sum_val,然后求出每个环，把每个环的边权值放入每个数组中，我们从每个数组中取出一个数，求和S，sum_val-S就是一棵生成数的权值了，那么从大到小取出前k个S，就得到前k小的生成树了。
这里有两个难点，一个是求环，一个是取前k个S。
求环思路：用深搜思想，用一个数组dfn记录该点的时间戳，就是第几次搜到的他，原图用双向边建图，搜索时控制一下不往回搜，例如边 u->v ， 当u搜到v发现v有一个不为0的时间戳，且dfn[u]>dfn[v]，说明我们搜到了一个环，那么就把该环的边的权值记录下来，怎么记呢，用一个栈记录dfn[v]==0的边的信息，当发现环时，退栈，直到栈里的边的u等于当前的v时停止，有点拗口 。看图
最后我们得到了一堆temp数组，我们要从这堆数组中每次取出一个数，求和得到前k大的数。设有w个数组，我们设ans数组存储前k大的和，那么我们可以用优先队列依次合并w个数组。看代码吧，不好说了，

#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <queue>
#include <vector>
#include <string.h>
using namespace std;
const int MAXN=2e5+10;
struct EDGE
{
    int u,v,w;
    EDGE() {}
    EDGE(int u,int v,int w):u(u),v(v),w(w) {}
} stack_me[MAXN];
struct node
{
    int val,u,v;
    node(){}
    node(int val,int u,int v):val(val),u(u),v(v) {}
    bool operator< (const node &a)const
    {
        return val<a.val;///优先队列里大的放上面
    }
};
vector<EDGE>edge[MAXN];
int K,tot,time_num,top;
int ans[MAXN],dfn[MAXN],set_me[MAXN];
bool cmp(int a,int b)
{
    return a>b;
}
void Merge()
{
    int temp[MAXN];
    priority_queue<node>que;
    sort(set_me+1,set_me+set_me[0]+1,cmp);
    for(int i=1;i<=set_me[0];i++)
          que.push(node(ans[1]+set_me[i],1,i));
    temp[0]=0;
    while(temp[0]<K&&!que.empty())
    {
        node now=que.top();
        que.pop();
        temp[++temp[0]]=now.val;
        if(now.u<ans[0])
            que.push(node(ans[now.u+1]+set_me[now.v],now.u+1,now.v));
    }
    for(int i=0;i<=temp[0];i++)
       ans[i]=temp[i];
}
void dfs(int u,int pre)
{
    int v;
    dfn[u]=++time_num;
    for(int i=0; i<edge[u].size(); i++)
    {
        v=edge[u][i].v;
        if(v==pre)
            continue;
        if(dfn[v]==0)
        {
            stack_me[++top]=edge[u][i];
            dfs(v,u);
            top--;
        }
        else if(dfn[u]>dfn[v])
        {
            set_me[0]=0;
            set_me[++set_me[0]]=edge[u][i].w;
            for(int j=top;; j--)
            {
                set_me[++set_me[0]]=stack_me[j].w;
                if(stack_me[j].u==v)
                    break;
            }
            Merge();
        }
    }
}
int main()
{
    int n,m;
    int T=1;
    while(scanf("%d%d",&n,&m)!=-1)
    {
        int u,v,w;
        unsigned allw=0;
        memset(ans,0,sizeof(ans));
        for(int i=0; i<m; i++)
        {
            scanf("%d%d%d",&u,&v,&w);
            edge[u].push_back(EDGE(u,v,w));
            edge[v].push_back(EDGE(v,u,w));
            allw+=w;
        }
        scanf("%d",&K);
        tot=top=0;
        time_num=0;
        ans[0]=0;
        ans[++ans[0]]=0;
        memset(dfn,0,sizeof(dfn));
        dfs(1,-1);
        unsigned sum=0;
        for(unsigned  i=1;i<=ans[0];i++)
            sum+=i*(allw-ans[i]);
        printf("Case #%d: %u\n",T++,sum);
        for(int i=1;i<=n;i++)
            edge[i].clear();
    }
    return 0;
}