hdu4467|zoj3742改变一个点影响到它周围的线路属性，询问整张图某属性的值（重点，轻点）

最新推荐文章于 2019-01-08 19:13:09 发布
最新推荐文章于 2019-01-08 19:13:09 发布
阅读量988 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cacyth/article/details/51174184
版权

hdu4467题意：给定N个点，M条边，每个点为0或者为1，每条边有一个权值。接下来有Q组操作，要么翻转某个点的标号，要么询问某组边的权值一共为多少，总共有三种类型的边：端点分别为(0, 0), (0, 1), (1, 1)。

zoj3742题意：给定N个点，M条边，每条边有一个权值。接下来有Q组操作，要么使某个点连接的所有边取反，要么询问正边/负边的权值和为多少。

粗粗一看两道题很像，细细推敲却觉得又不像。码着码着却又觉得很像。如果能正确发现两道题目的关联那么这一类题目都没问题了。下题相对于上题的代码只是改动了极少一部分。

坑点：同一对点直接可能有多条连线。

证明：http://www.cnblogs.com/Lyush/archive/2013/05/02/3055525.html

//题目要做的是维护00，01，11这样的边的总数，用ans[0],ans[1],ans[2]去保存 00，01（10），11的情况。复杂度大约是n/2*sqrt(m)。
#include<iostream>
#include<algorithm>
#include<string>
#include<map>//int dx[4]={0,0,-1,1};int dy[4]={-1,1,0,0};
#include<set>//int gcd(int a,int b){return b?gcd(b,a%b):a;}
#include<vector>
#include<cmath>
#include<stack>
#include<string.h>
#include<stdlib.h>
#include<cstdio>
#define ll long long  
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]);  
        map<pair<ll,ll>,ll> r;
        for (i=1;i<=m;i++)  
        {  
            scanf("%I64d %I64d %I64d",&u,&v,&w); 
            if(u>v) swap(u,v); 
            r[{u,v}]+=w;
        }  
        m=0;
        for(map<pair<ll,ll>,ll>::iterator it=r.begin();it!=r.end();++it){
            e[++m].u=(*it).first.first; e[m].v=(*it).first.second; e[m].w=(*it).second;
        }
        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])  
                swap(e[i].u,e[i].v);
        }  
        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+=e[i].w;  
            else 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]+=p[x].w1;
                    ans[2]-=p[x].w0;  
                    ans[0]+=p[x].w0;  
                    ans[1]-=p[x].w1;  
                }  
                else  
                {  
                    ans[2]-=p[x].w1;
                    ans[2]+=p[x].w0;  
                    ans[0]-=p[x].w0;  
                    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;  
}  

#include<iostream>
#include<algorithm>
#include<string>
#include<map>//int dx[4]={0,0,-1,1};int dy[4]={-1,1,0,0};
#include<set>//int gcd(int a,int b){return b?gcd(b,a%b):a;}
#include<vector>
#include<cmath>
#include<stack>
#include<string.h>
#include<stdlib.h>
#include<cstdio>
#define ll long long  
using namespace std;  
struct node{  
    int st;  
    ll w0[2],w1[2];
	node(){
		memset(w0,0,sizeof(w0));
		memset(w1,0,sizeof(w1));
	}  
} p[50005];  
struct edge{  
    int u,v;  
    ll w;  
} e[50005];
int color[50005],deg[50005];
ll ans[3][2];
bool cmp(edge x,edge y)  
{  
    if (x.u>y.u) return true;  
    else return false;  
}  
int main()  
{  
    int n,m,q,i;
    int u,v,w;  
    char s[2];  
    int ok=0;
    while (scanf("%d%d%d",&n,&m,&q)!=EOF)  
    {  
    	if(ok==0)
    		ok=1;
    	else
    		printf("\n");  
    	memset(color,0,sizeof(color)); 
        memset(deg,0,sizeof(deg));  
        map<pair<int,int>,ll> r;
        memset(ans,0,sizeof(ans));
        for (i=1;i<=m;i++)  
        {  
            scanf("%d%d%d",&u,&v,&w); 
            if(u>v) swap(u,v); 
            if (color[u]!=color[v]){
            	if(w>0) 
            		ans[2][0]+=w; 
            	else
            		ans[2][1]+=w;
            } 
            else{
            	if(w>0) 
			ans[color[u]][0]+=w;   
		else
			ans[color[u]][1]+=w;  //初始化三种情况的权值和 
	    }
            r[{u,v}]+=w;
        }  
        m=0;
        for(map<pair<int,int>,ll>::iterator it=r.begin();it!=r.end();++it){
            e[++m].u=(*it).first.first; e[m].v=(*it).first.second; e[m].w=(*it).second;
        }
        for (i=1;i<=m;i++)  
        {  
            u=e[i].u; v=e[i].v;  
            deg[u]++; deg[v]++;  //记录度数  
        }  
        for (i=1;i<=m;i++)  
        {  
            u=e[i].u; v=e[i].v;  
            if (deg[u]>deg[v])  
                swap(e[i].u,e[i].v);
        }  
        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]){
            	if(e[i].w>0)
            		p[v].w1[0]+=e[i].w;  
            	else
            		p[v].w1[1]+=e[i].w; 
            }
            else{    //存储点的w0和w1  
            	if(e[i].w>0)
            		p[v].w0[0]+=e[i].w;  
            	else
            		p[v].w0[1]+=e[i].w; 
            } 
        }  
        while (q--)  
        {  
            int x,y;  
            scanf("%s",s);  
            if (s[0]=='Q')  
            {  
                char c[2];
                scanf("%s",c);  
                if(c[0]=='+')
                	cout<<ans[0][0]+ans[1][0]-ans[2][1]<<endl;
                else if(c[0]=='-')
                	cout<<ans[0][1]+ans[1][1]-ans[2][0]<<endl;
                else
                        cout<<ans[0][0]+ans[1][0]-ans[2][1]+ans[0][1]+ans[1][1]-ans[2][0]<<endl; 
            }  
            else  
            {  
                scanf("%d",&x);   
                if (color[x])  //处理小度数的  
                {   
                    ans[2][1]+=p[x].w1[1];
                    ans[2][0]+=p[x].w1[0];
                    
                    ans[2][0]-=p[x].w0[0];
                    ans[2][1]-=p[x].w0[1];
					  
                    ans[0][0]+=p[x].w0[0];  
                    ans[0][1]+=p[x].w0[1]; 
                    
                    ans[1][1]-=p[x].w1[1];  
                    ans[1][0]-=p[x].w1[0];  
                }  
                else  
                {  
                    ans[2][1]-=p[x].w1[1];
                    ans[2][0]-=p[x].w1[0];
                    
                    ans[2][0]+=p[x].w0[0];
                    ans[2][1]+=p[x].w0[1];
					  
                    ans[0][0]-=p[x].w0[0];  
                    ans[0][1]-=p[x].w0[1]; 
                    
                    ans[1][1]+=p[x].w1[1];  
                    ans[1][0]+=p[x].w1[0];  
                }  
                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])  
                    {  
                    	if(e[st].w>0){
	                        ans[2][0]+=e[st].w;  
                        	ans[1-color[x]][0]-=e[st].w;  
                        }
                        else{
                        	ans[2][1]+=e[st].w;  
                        	ans[1-color[x]][1]-=e[st].w; 
                        }
                    }  
                    else  
                    {  
                    	if(e[st].w>0){
                        	ans[color[x]][0]+=e[st].w;  
                        	ans[2][0]-=e[st].w; 
			}
			else{
				ans[color[x]][1]+=e[st].w;  
                        	ans[2][1]-=e[st].w; 
			}
                    }  
                    if (color[x]==0)  
                    {  
                    	if(e[st].w>0)
		            	p[v].w0[0]+=e[st].w;  
		        else
		            	p[v].w0[1]+=e[st].w; 
                        if(e[st].w>0)
		            	p[v].w1[0]-=e[st].w;  
		        else
		            	p[v].w1[1]-=e[st].w;  
                    }  
                    else  
                    {  
                        if(e[st].w>0)
		            	p[v].w0[0]-=e[st].w;  
		        else
		            	p[v].w0[1]-=e[st].w; 
                        if(e[st].w>0)
		            	p[v].w1[0]+=e[st].w;  
		        else
		            	p[v].w1[1]+=e[st].w;    
                    }  
                    st++;  
                } 
            }  
        }
    }  
    return 0;  
}


ccyy-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
hdu4467 Graph(构造法求解)
ophunter的专栏
07-22 1663
Graph Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 642    Accepted Submission(s): 94 Problem Description P. T. Tigris is a stud
vue 改变table某一行的值_jquery 在 table 中修改某行值
weixin_39631094的博客
12-19 2038
修改 table 中某行的的方法步骤如下：1、选择要修改的行，事件触发，比如我的 双击某行时修改2、将要修改的行，替换为input，原先的列中的值，需要放到对应的input中作为默认值3、修改完成后，事件触发将其还原，比如我的 如果鼠标移走，不在该行上时触发$(function(){$('tr.modifyType').dblclick(function(){var oldid = $(this)...
hdu_4467_Graph(莫队算法思想)
weixin_30898109的博客
07-06 113
题目连接：hdu_4467_Graph 题意：给你n个点，m条边，每条边有一个权值，有两个操作，一个是修改单点的颜色，一个是询问边的两个端点都为指定颜色的权值和 题解：这题如果暴力的话，就是维护3个ans,一个是两个端点都为0的，一个是一个为1一个为0的，最后还有个两个端点都为1的，对于每个询问，可以做到O(1)，但对于修改单点操作，极限状态下，一个单点的边最大可为1e5，这样果断T飞，如果我...
HDU 4467 块状结构
I will Do iT @ hlyblog.net
08-12 1060
题意很简单。就是两个操作
HDU 4467 Graph
long long ago
09-02 974
传送门 我们把度大于等于n−−√\sqrt{n}的点称为重点，其他的点称为轻点。 我们忽略轻点和轻点之间的连边，对于轻点和重点之间的边，只考虑轻点向重点的边。 对于每一个重点uu，维护另一端颜色是cc的他的边的和sum[u][c]sum[u][c]。 维护ans[x+y]为两端颜色分别是x和y的边和。#include <bits/stdc++.h> using namespace std;
Hdu 4467 Graph(点分块)
_zidaoziyan的博客
09-16 416
传送门:Hdu 4467 Graph 题意:给你n个点，m条边，每条边有一个权值，有两个操作，一个是修改单点的颜色，一个是询问边的两个端点都为指定颜色的权值和 思路: 对点进行分块,度数大于等于根号n的点称为重点, 否则称为轻点 对于轻点,存下与其相连的所有的边,对于重点,只存下与这个重点相连的重点的边 对于一个点的更新,如果这个点是轻点,暴力更新与其相连的所有点
HDU-1535-.zip_多源点
最新发布
09-24
标题中的"HDU-1535-.zip_多源点"表明这是一个关于解决 ACM (国际大学生程序设计竞赛)问题的程序代码包，问题编号为 HDU 1535，且该问题涉及到多源点的最短路径计算。描述中提到的"求多源点到单终点的最短路（反向...
hdu-api:A simple SDK for HDU. 一个提供一卡通服务、考试、课表、选课和公共信息等 API 的 SDK
05-04
hdu-api 是一个集结 HDU 所有教务管理服务的 SDK，提供了一卡通服务、考试、课表、选课和一些公共信息如空闲教室、上课时间等信息的 API。 hdu-api 主要基于 Requests 库和 Beautiful Soup 库写成。 特性 支持一卡通...
leetcode下载-algorithm-1:力扣、HDU、ZOJ、POJ
06-29
Interview，ZOJ，POJ 等平台。 欢迎Coders对代码加以指正和提议！ 常见问题总结 两整数求平均值 average = min + (max - min) / 2 防止两整数的和越界 整数乘积对比 1.0 * m * m == num 类似乘积对比， 需转为double...
hdu-page-11-answer.rar_hdu_hdu oj第十一页_page_搜题_杭电oj
09-14
《杭电OJ第十一页题目题解：基础算法与ACM入门》 在计算机科学的世界里，算法是解决问题的关键，而ACM（国际大学生程序设计竞赛）则为学生们提供了磨炼算法技能的绝佳平台。杭州电子科技大学（简称“杭电”）的在线...
HDU-4467-Graph（莫队思想）
sugarbliss
01-08 209
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=4467 题意：给你n个点，m条边，每条边有一个权值，有两个操作，一个是修改单点的颜色（颜色只有0,1两种），一个是询问边的两个端点都为指定颜色的权值和。 思路：由于每个点的颜色只有0，1两种，那么答案只有3种情况（00,01,11），用一个数组维护即可。即ans[0]统计边的两端都是0的权值和，an...
hdu4467 Graph(分段处理)
咸鱼有梦想
10-15 309
GraphTime Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)Total Submission(s): 3694    Accepted Submission(s): 644Problem DescriptionP. T. Tigris is a student currently ...
hdu 4467 Graph ( 神奇的思想 降低复杂度 )
To be what you what to be!
07-23 1714
Graph Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 695    Accepted Submission(s): 113 Problem Description P. T. Tigris is a stu
HDU 4467 Graph (莫队思想+图的分块)*
满月照亮的路
09-14 410
题目链接：acm.hdu.edu.cn/showproblem.php?pid=4467 #include&lt;bits/stdc++.h&gt; using namespace std; #define debug puts("YES"); #define rep(x,y,z) for(int (x)=(y);(x)&lt;(z);(x)++) #define read(x,y) sca...
hdu4467 Graph（图的分块）
可视化和机器学习
10-09 1528
Graph Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 2736    Accepted Submission(s): 443 Problem Description P. T. Tigris is a st
hdu 4467 莫队算法
qq_39898877的博客
09-25 254
k=根号（入度出度之和） 与该点相连的点大于等于k为重点，否则为轻点 对轻点进行暴力维护，重点就将他周围的权值用一个二维数组sum[i][j]维护，i表示这个重点它周围的j这个颜色的权值和  #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;cmath&gt; ...
hdu 4467( 轻重点维护）
weixin_30848775的博客
11-23 82
写了7000b代码 真是醉了 #include <iostream> #include <cstdio> #include <algorithm> #include <cmath> #include <cctype> #include <complex> #include <cstring> #...
hdu 4467 Graph
绝望的乐园
10-06 879
题意：给出n个点，m条边，每个点都有一个颜色，黑色(用1表示)或白色(用0表示)。有两种操作，一种是询问所有边中满足边的两个点是00,01 or 11这三种情况的边的权值的和，另一种是修改某一点的颜色。 思路：这一题最直观的思路就是暴力，查询简单，用一个数组预处理三种情况的边就能在O(1)的时间内完成了，修改一个点u的话，再遍历所有与u相连的点，把数组更新就好了。但是这样还是有问题的，由于m比较
HDU 4467 Graph（分块）
GODSPEED
12-04 485
题意：给出n个点，m条边，每个点都有一个颜色，黑色(用1表示)或白色(用0表示)。有两种操作，一种是询问所有边中满足边的两个点是00,01 or 11这三种情况的边的权值的和，另一种是修改某一点的颜色。 思路：如果直接暴力做的话，每次修改的复杂度达到O(m)，考虑分块，对于度数小于lim的点，修改时暴力来做， 对于度数大于lim的点u，用sum[u][0]记录u向外连接颜色为零的边的权值和，然
扇心点划分任意多边形为N个三角形的计算几何方法
"任意点为扇心的三角形剖分是计算几何中的一个重要概念，它涉及到将一个多边形分解为更小的三角形，以便于进行进一步的分析和计算。在ACM课件中，通常会探讨为何多边形最多只能被分成N-2个三角形，这与欧拉公式相关...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值