Graph

0

4

分析：题目意思我就不多说了，相信应该还是容易看懂的，求和时只有三种情况0 0、0 1、1 1 ，于是可以用三个变量ans[0]、ans[2]、ans[1],来记录总权值之和，遇到Asksum时直接输出就行了，遇到change时，则进行相关处理，来调整ans的值，最暴力

的方法就是将与x点相连的每条边和点进行处理，q*m的复杂付，无疑是超时的，我当时也就想到了这里，q肯定是不能优化了，

那么我们的优化对象就应该放在m上了，我当时有个想法，如果把每个点记录与之相连的点中，分别记录0和1 的权值之和，以w0和w1来表示。那么，该点改变时，例如：当当前点由0->1时，ans[0]-w[0],ans[1]+w[1],ans[2]-w[1]+w[0];  这样就是O(1)复杂度了，而且当前点得出的就结果是正确的。但是，当处理其他点时，其他点的w0和w1 没有给到更新，这显然是不行的，还需要再做些文章。说到这里，先说个结论，对于点x，与x相连并且度数大于x的度数的点不会超过（2m)^(1/2），这个证明很好证，可以自己去推下。接下来，我采取的方法是，用w0和w1表示度数比它小的权值之和，至于度数比它大，则逐边进行处理。这样复杂度是q*(m)^1/2,可以过。最后，我来说下这样为什么不会对其他点的更新造成影响。对于点x，度数大于它的是逐边处理的，点的信息也得到了更新；度数小于它的，信息则没有更新，那么，当处理到那些度数小的点时，也是按同样的方法在处理，度数大于的点逐边处理，这不就是把以前没有更新的过程给完成了吗？这样，就不会出现需要使用改点时，信息没得到完善。总而言之，就是利用度数形成一种顺序的结构，使其不会混乱。

# include<stdio.h>
# include<string.h>
# include<algorithm>
typedef __int64 ll;

using namespace std;
struct node
{
    int st;
    ll w0,w1;
} p[100005];
struct edge
{
    ll u,v;
    ll w;
} e[100005],ed;
int color[100005],deg[100005];
ll ans[3];
bool cmp(edge x,edge y)
{
    if (x.u>y.u) return true;
    else return false;
}
int main()
{
    int n,m,i,Case;
    ll u,v,w;
    char s[10];
    Case=1;
    while (scanf("%d%d",&n,&m)!=EOF)
    {
        memset(deg,0,sizeof(deg));
        for (i=1;i<=n;i++) scanf("%d",&color[i]);
        for (i=1;i<=m;i++)
        {
            scanf("%I64d %I64d %I64d",&u,&v,&w);
            e[i].w=w; e[i].v=v; e[i].u=u;
            if (u>v)
            {
                ll tmp;
                tmp=e[i].u;
                e[i].u=e[i].v;
                e[i].v=tmp;
            }  
        }
        sort(e+1,e+m+1,cmp);  //使u<v,并按u排序，如此可快速判重边
        int k=0;
        for (i=2;i<=m;i++)   //将重边合并
        {
            if (e[i].u==e[i-1].u&&e[i].v==e[i-1].v)
            {
                k++;
                e[i-k].w+=e[i].w;
            } else
            {
                e[i-k].w=e[i].w;
                e[i-k].u=e[i].u;
                e[i-k].v=e[i].v;
            }
        }
        m-=k; 
        ans[0]=ans[1]=ans[2]=0;
        for (i=1;i<=m;i++)
        {
            u=e[i].u; v=e[i].v;
            deg[u]++; deg[v]++;  //记录度数
            if (color[u]!=color[v]) ans[2]+=e[i].w;
            else ans[color[u]]+=e[i].w;  //初始化三种情况的权值和
        }
        for (i=1;i<=m;i++)
        {
            u=e[i].u; v=e[i].v;
            if (deg[u]>deg[v])
            {
                ll tmp;
                tmp=e[i].u;
                e[i].u=e[i].v;
                e[i].v=tmp;
            }
        }
        sort(e+1,e+m+1,cmp);  //是u的度数小于v的度数，并排序，这样可以直接逐边处理
        memset(p,0,sizeof(p));
        for (i=1;i<=m;i++)
        {
            u=e[i].u; v=e[i].v;
            if (p[u].st==0) p[u].st=i;  //记录u节点第一次出现的位置
            if (color[u]) p[v].w1=p[v].w1+e[i].w;
            else p[v].w0=p[v].w0+e[i].w;  //存储点的w0和w1
        }
        int q;
        scanf("%d",&q);
        printf("Case %d:\n",Case++);
        while (q--)
        {
            int x,y;
            scanf("%s",s);
            if (s[0]=='A')
            {
                scanf("%d%d",&x,&y);
                if (x!=y) printf("%I64d\n",ans[2]);
                else printf("%I64d\n",ans[x]);  //这里可以发现为什么ans的表示的巧妙
            }
            else
            {
                scanf("%d",&x);
                if (color[x])  //处理小度数的
                {
                    ans[2]=ans[2]+p[x].w1-p[x].w0;
                    ans[0]=ans[0]+p[x].w0;
                    ans[1]=ans[1]-p[x].w1;
                }
                else
                {
                    ans[2]=ans[2]+p[x].w0-p[x].w1;
                    ans[0]=ans[0]-p[x].w0;
                    ans[1]=ans[1]+p[x].w1;
                }
                color[x]=1-color[x];
                int st=p[x].st;
                while (st<=m&&e[st].u==x) //大度数的
                {
                    v=e[st].v;
                    if (color[x]!=color[v])
                    {
                        ans[2]+=e[st].w;
                        ans[1-color[x]]-=e[st].w;
                    }
                    else
                    {
                        ans[color[x]]+=e[st].w;
                        ans[2]-=e[st].w;
                    }
                    if (color[x]==0)
                    {
                        p[v].w0+=e[st].w;
                        p[v].w1-=e[st].w;
                    }
                    else
                    {
                        p[v].w0-=e[st].w;
                        p[v].w1+=e[st].w;
                    }
                    st++;
                }
            }
        }
    }
    return 0;
}
/*
1、输出long long 变量时需要用%lld
2、注意在HDOJ上使用%I64d，但是现场赛使用%lld
*/