项目管理（把与某点相邻边分为两类 是复杂度降为(n^(3/2)）

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4858

项目管理

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3744    Accepted Submission(s): 1409

Problem Description

我们建造了一个大项目！这个项目有n个节点，用很多边连接起来，并且这个项目是连通的！
两个节点间可能有多条边，不过一条边的两端必然是不同的节点。
每个节点都有一个能量值。

现在我们要编写一个项目管理软件，这个软件呢有两个操作：
1.给某个项目的能量值加上一个特定值。
2.询问跟一个项目相邻的项目的能量值之和。（如果有多条边就算多次，比如a和b有2条边，那么询问a的时候b的权值算2次）。

 

Input

第一行一个整数T(1 <= T <= 3),表示测试数据的个数。
然后对于每个测试数据，第一行有两个整数n(1 <= n <= 100000)和m(1 <= m <= n + 10)，分别表示点数和边数。

然后m行，每行两个数a和b，表示a和b之间有一条边。
然后一个整数Q。

然后Q行，每行第一个数cmd表示操作类型。如果cmd为0，那么接下来两个数u v表示给项目u的能量值加上v(0 <= v <= 100)。
如果cmd为1，那么接下来一个数u表示询问u相邻的项目的能量值之和。

所有点从1到n标号。

 

Output

对每个询问，输出一行表示答案。

 

Sample Input

1 3 2 1 2 1 3 6 0 1 15 0 3 4 1 1 1 3 0 2 33 1 2

 

Sample Output

4 15 15

 

思路：也算是一种暴力，但是是一种优化的暴力，把与本身相邻的点按度数分为两类，一类是度数大于自己的，另一类是度数小于自己的，可以确定的是度数大于自己的点不会超过根号n个

度数大于本身的点直接遍历就行了

看代码:

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<map>
using namespace std;
typedef long long LL;
const LL mod=1e9+7;
const LL INF=1e9+7;
const int maxn=1e5+50;
map<int,int>m[maxn];
int N;
int du[maxn];
int w[maxn],ww[maxn];//存度数比本身小的相邻点的能量值 度数大的直接遍历
int v[maxn];//存每个点的能量值
int head[maxn];
int cnt1;
struct Edge
{

    int x,y,num;//x-y之间有多少条边
    Edge()
    {
        x=y=num=0;
    }
}a[maxn];
struct E
{
    int next,to;
    E()
    {
        next=to=0;
    }
}e[maxn];
bool cmp(const Edge e1,const Edge e2)
{
    if(e1.x==e2.x) return e1.y<=e2.y;
    return e1.x<e2.x;
}
void add_edge(int x,int y)
{
    e[cnt1].to=y;
    e[cnt1].next=head[x];
    head[x]=cnt1;
    cnt1++;

}
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {

        memset(du,0,sizeof(du));
        memset(w,0,sizeof(w));
        memset(ww,0,sizeof(ww));
        memset(v,0,sizeof(v));
        memset(head,0,sizeof(head));
        cnt1=1;
        int N,M;
        scanf("%d%d",&N,&M);
        for(int i=1;i<=M;i++)
        {
            scanf("%d%d",&a[i].x,&a[i].y);m[a[i].x][a[i].y]=1;m[a[i].y][a[i].x]=1;//num表示有多少条边 也就是要算多少次
        }
        sort(a+1,a+1+M,cmp);//方便处理重边
        int cnt=1;
        for(int i=2;i<=M;i++)//去重边
        {
            if(a[i].x==a[cnt].x&&a[i].y==a[cnt].y)
            {
                m[a[i].x][a[i].y]++;
            }
            else
            {
                a[++cnt].x=a[i].x;a[cnt].y=a[i].y;
            }
        }
        for(int i=1;i<=cnt;i++)//存每个点度数
        {
            int x=a[i].x,y=a[i].y;
            du[x]++;du[y]++;
        }
        for(int i=1;i<=cnt;i++)//度数大于本身的相邻点存边
        {
            int x=a[i].x,y=a[i].y;
            if(du[x]<=du[y])
            {
                //此时并不需要存下w 因为初始值都是0
                add_edge(x,y);
            }
            else add_edge(y,x);
        }
        int Q;
        scanf("%d",&Q);
        while(Q--)
        {

            int cmd,u,vv;
            scanf("%d",&cmd);
            if(cmd==0)
            {
                scanf("%d%d",&u,&vv);//
                v[u]+=vv;
                for(int i=head[u];i;i=e[i].next)//遍历度数大于本身的点
                {
                    w[e[i].to]+=vv*m[u][e[i].to];//相对i来说 u就是度数小的点 直接处理
                }
            }
            else
            {
                scanf("%d",&u);
                int sum=0;
                for(int i=head[u];i;i=e[i].next)
                {
                    sum+=v[e[i].to]*m[u][e[i].to];//遍历度数大于本身的相邻点的能量值
                }
                int ans=0;
                ans=sum+w[u];
                printf("%d
",ans);
            }
        }
    }
    return 0;
}