hdu 6041 I Curse Myself

题目：

　　点这里OvO http://acm.hdu.edu.cn/showproblem.php?pid=6041

　　2017 Multi-University Training Contest - Team 1 - 1009  　　

题解：

　　1.由于每条边只在一个环中，每个环必然要拿掉一条边，而这些边都是不重复的，那么最小生成树就对应的是通过求每个环中拿掉一条边，总和最大的组合对应的剩下的树（第k小生成树对应第k大组合剩下的树）。xjbdfs搜一下环，把每个环中的点放到一个集合中。

　　2.然后对集合排序，xjb利用优先队列 ( 要注意优先队列中的元素的数量要保持和新集合的元素个数相同,以降低时间复杂度 ) 求最大的k（如果总数没k个那就不是k个）个组合（每个集合中取一个元素的组合）

 #include <iostream>
 #include <cstring>
 #include <cstdio>
 #include <algorithm>
 #include <cmath>
 #include <vector>
 #include <queue>

 using namespace std;

 typedef long long ll;

 const int N=1e4+;
 const int M=2e3+;
 const ll mod=(ll)pow(,);

 struct node{
     int u,v,d;
     int next;
 }edge[*N];

 struct NODE
 {
     int v,now;    //value is (v), now add with (now)
     friend bool operator<(NODE x,NODE y)
     {
         return x.v < y.v;
     }
 };//small to big

 priority_queue<NODE> Q;
 int num;
 int head[N];
 int n,m,k;
 ll ans;
 int snum;
 int stk[N],lstk;
 bool instk[M];
 vector<int> s[N];
 int val[M][M];
 vector<int> f,tmpf;
 ll sum_of_edge;
 ll du[M];

 bool cmp(int a,int b)
 {
     return a>b;
 }

 void addedge(int u,int v,int d)
 {
     edge[num].u=u;
     edge[num].v=v;
     edge[num].d=d;
     edge[num].next=head[u];
     head[u]=num++;
 }

 void init()
 {
     num=;                  //记得初始化
        memset (head,-,sizeof(head));
        memset(du,,sizeof(du));
        snum=;
     lstk=;
     memset(instk,,(n+)*sizeof(bool));
     for(int i=;i<=n;i++)
         s[i].clear();
     ans=;
     sum_of_edge=;
 }

 void dfs(int rt,int fa)
 {
     int v;
     if(instk[rt])
     {
         snum++;
         int sav=rt;
         int sav_lstk=lstk;
         while(stk[lstk]!=rt)
         {
             s[snum].push_back(val[sav][stk[lstk]]);
             sav=stk[lstk--];
         }
         s[snum].push_back(val[sav][stk[lstk]]);
         lstk=sav_lstk;
         return ;
     }
     instk[rt]=;
     stk[++lstk]=rt;
     for(int i=head[rt];i!=-;i=edge[i].next)
     {
         v=edge[i].v;
         if(v==fa || du[v]==) continue;
         du[rt]--; du[v]--;
         dfs(v,rt);
     }
     instk[rt]=;
     lstk--;
 }

 void merge()
 {
     NODE q;
     int i,j,cnt;
     f.clear();
     if(snum==)
     {
         f.push_back();
         return  ;
     }
     for(int i=;i<s[].size();i++)
         f.push_back(s[][i]);
     for(int i=;i<=snum;i++)
     {
         cnt=f.size()*s[i].size();
         if(cnt>k) cnt=k;
         while(!Q.empty())
             Q.pop();
         for(j=;j<s[i].size();j++)
         {
             q.v=s[i][j]+f[];
             q.now=;
             Q.push(q);
         }
         tmpf.clear();
         while(cnt--)
         {
             q=Q.top();
             Q.pop();
             tmpf.push_back(q.v);
             if(q.now!=f.size()-)
             {
                 q.v-=f[q.now];
                 q.now++;
                 q.v+=f[q.now];
                 Q.push(q);
             }
         }
         swap(f,tmpf);
     }
 //    cout<<"check merge\n";
 //    for(int i=0;i<f.size();i++)
 //        printf("%d ",f[i]);
 //    printf("\n");
 //    printf("end of check of merge\n");
 }

 void solve()
 {
     dfs(,-);
     for(int i=;i<=snum;i++)
         sort(s[i].begin(),s[i].end(),cmp);
 //    printf("check s\n");
 //    for(int i=1;i<=snum;i++)
 //    {
 //        for(int j=0;j<s[i].size();j++)
 //            printf("%d",s[i][j]);
 //        printf("\n");
 //    }
 //    printf("end of check of s\n");
     merge();
 }          

 int main()
 {
     int cas=,a,b,c;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         init();
         for(int i=;i<=m;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             addedge(a,b,c);
             addedge(b,a,c);
             du[a]++; du[b]++;
             val[a][b]=val[b][a]=c;
             sum_of_edge+=c;
         }
         scanf("%d",&k);
         solve();
         for(int i=;i<f.size();i++)
             ans=(ans+1ll*(i+)*(sum_of_edge-f[i])%mod)%mod;
         printf("Case #%d: %lld\n",++cas,ans%mod);
     }
     return ;
 }