hdu6251-Inkopolis

给出一个基环树，每个边有自己的颜色，m次改变边的颜色
输出每次改变后，颜色区域的个数，颜色区域是两个边共用
一个点且颜色相同那么他们是一个区域，首先，考虑对于任何
不是环的颜色区域，一个颜色区域对于每个节点不同颜色个数的
贡献为1，那么n个点就有n个贡献，减去边的个数n-1，那么就是1个区域
所以，假设是一棵树的话，f[i]代表这个节点不同颜色的个数，那么
f[1]+f[2]+..f[n]-（n-1) 就是颜色块的个数，对于基环树，
若环只有一种颜色： 那么是f[1]+f[2]+...f[n]-(n-1)
否则                     f[1]+f[2]+...f[n]-n;
对于每个节点暴力set加multiset维护，环也弄个set+multiset暴力维护

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <map>
#include <cstring>
using namespace std;
const int maxn=2e5+100;
struct Edge
{
    int u,v,co,time;
};
vector<Edge> edges;
vector<int> G[maxn];
set<int> f[maxn],circle_co,circle_po;
bool vis[maxn];
int father[maxn];
multiset<int> ff[maxn],tcircle_co;
map<pair<int,int>,int> color;
void AddEdge(int u,int v,int co);
void dfs(int u,int fa);
void debug(int now)
{
    for(set<int>::iterator it=f[now].begin(); it!=f[now].end(); it++)
        cout<<*it<<" ";
    cout<<endl;
}
int main()
{
    int t,n,m,u,v,co,ans,manys=1;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d%d",&n,&m);
        edges.clear();
        memset(vis,0,sizeof(vis));
        ans=0;
        color.clear();
        for(int i=1; i<=n; i++) G[i].clear(),f[i].clear(),ff[i].clear();
        circle_co.clear(),circle_po.clear();
        tcircle_co.clear();
        for(int i=1; i<=n; i++)
        {
            scanf("%d%d%d",&u,&v,&co);
            AddEdge(u,v,co);
            AddEdge(v,u,co);
            color[make_pair(u,v)]=color[make_pair(v,u)]=co;
        }
        dfs(1,0);
        for(int i=0; i<edges.size(); i++)
        {
            if(edges[i].time>=2)
            {
                circle_co.insert(edges[i].co);
                tcircle_co.insert(edges[i].co);
                circle_po.insert(edges[i].u);
                circle_po.insert(edges[i].v);
            }
        }
        for(int i=1; i<=n; i++)
        {
            for(int j=0; j<G[i].size(); j++)
            {
                f[i].insert(edges[G[i][j]].co);
                ff[i].insert(edges[G[i][j]].co);
            }
            ans+=f[i].size();
        }
       // for(set<int>::iterator it=circle_po.begin();it!=circle_po.end();it++)
         //   cout<<*it<<"***";
      //  cout<<endl;
        printf("Case #%d:\n",manys++);
        for(int i=1; i<=m; i++)
        {
            scanf("%d%d%d",&u,&v,&co);
            int pu=f[u].size(),pv=f[v].size();
            int pco=color[make_pair(u,v)];
            multiset<int>::iterator it=ff[u].find(pco),it2=it;
            it2++;
            if(it2!=ff[u].end()&&*it==*it2)
                ff[u].erase(it);
            else
            {
                ff[u].erase(it);
                f[u].erase(pco);
            }
            it=ff[v].find(pco),it2=it;
            it2++;
            if(it2!=ff[v].end()&&*it==*it2)
                ff[v].erase(it);
            else
            {
                ff[v].erase(it);
                f[v].erase(pco);
            }
            it=ff[u].find(co);
            if(it==ff[u].end())
            {
                ff[u].insert(co);
                f[u].insert(co);
            }
            else
                ff[u].insert(co);
            it=ff[v].find(co);
            if(it==ff[v].end())
            {
                ff[v].insert(co);
                f[v].insert(co);
            }
            else
                ff[v].insert(co);
         //   debug(u);
        //    debug(v);
            color[make_pair(u,v)]=color[make_pair(v,u)]=co;
            if(circle_po.count(u)&&circle_po.count(v))
            {
                it=tcircle_co.find(pco),it2=it;
                it2++;
                if(it2!=tcircle_co.end()&&*it==*it2)
                {
                    tcircle_co.erase(it);
                }
                else
                {
                    tcircle_co.erase(it);
                    circle_co.erase(pco);
                }
                it=tcircle_co.find(co);
                if(it!=tcircle_co.end())
                {
                    tcircle_co.insert(co);
                }
                else
                {
                    tcircle_co.insert(co);
                    circle_co.insert(co);
                }
            }
            ans+=(f[u].size()-pu)+(f[v].size()-pv);
            int Ans=ans-n;
            if(circle_co.size()==1)
                Ans++;
            printf("%d\n",Ans);
        }
    }
    return 0;
}
void AddEdge(int u,int v,int co)
{
    Edge temp;
    temp.u=u,temp.v=v,temp.co=co;
    temp.time=0;
    edges.push_back(temp);
    G[u].push_back(edges.size()-1);
}
void dfs(int u,int fa)
{
    vis[u]=true;
    for(int i=0; i<G[u].size(); i++)
    {
        Edge &temp=edges[G[u][i]];
        if(temp.v==fa) continue;
        father[temp.v]=G[u][i];
        if(vis[temp.v])
        {
            int now=G[u][i];
            while(edges[now].u!=temp.v)
            {
                tcircle_co.insert(edges[now].co);
                circle_po.insert(edges[now].u);
                circle_co.insert(edges[now].co);
                now=father[edges[now].u];
            }
            circle_po.insert(edges[now].u);
            circle_co.insert(edges[now].co);
            tcircle_co.insert(edges[now].co);
            break;
        }
        dfs(temp.v,u);
    }
}
/*
给出一个基环树，每个边有自己的颜色，m次改变边的颜色
输出每次改变后，颜色区域的个数，颜色区域是两个边共用
一个点且颜色相同那么他们是一个区域，首先，考虑对于任何
不是环的颜色区域，一个颜色区域对于每个节点不同颜色个数的
贡献为1，那么n个点就有n个贡献，减去边的个数n-1，那么就是1个区域
所以，假设是一棵树的话，f[i]代表这个节点不同颜色的个数，那么
f[1]+f[2]+..f[n]-（n-1) 就是颜色块的个数，对于基环树，
若环只有一种颜色： 那么是f[1]+f[2]+...f[n]-(n-1)
否则                     f[1]+f[2]+...f[n]-n;
对于每个节点暴力set加multiset维护，环也弄个set+multiset暴力维护
*/