hdu6832（2020hdu多校6t6）

最新推荐文章于 2020-08-10 18:40:15 发布
最新推荐文章于 2020-08-10 18:40:15 发布
阅读量281 收藏
点赞数
分类专栏： hdu多校 算法 ICPC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sidnee/article/details/107869409
版权
算法 同时被 3 个专栏收录
11 篇文章 0 订阅
订阅专栏
ICPC
4 篇文章 0 订阅
订阅专栏
hdu多校
2 篇文章 0 订阅
订阅专栏

题解

所有最短路肯定都出现在最小生成树上。因为克鲁斯卡尔按顺序连边，前面已经连上的肯定最优，所有加起来比当前的还小。
这个我感觉求单源多汇最短路后的剩余图其实和最小生成树其实是一样的。因为如果最小生成树的结论是对的，那么源点到所有点的最短路一定都在树上，剩余图就是这个最小生成树。我试了试都是可以AC的。
开始初始化错了，少初始化了一堆东西，dfs停不下来，MLE。后来wa，因为枚举边端点dp计数没想清。

AC代码

  • dij版本（跑的较慢）
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int modd=1e9+7;
const int oo=1e9+10;
const int NN=100100;
const int MM=200100;
int n,m;
int vis[NN],dis[NN];
struct edge{
	int to,cost,from;
}e[MM*2];
vector <int> con[NN];
int a[NN];
struct point{
	int id;
	long long d;
};
struct point_cmp{
	bool operator() (const point &x,const point &y)const{
		if(x.d>y.d)return 1;
		if(x.d==y.d && x.id>y.id)return 1;
		return 0;
	}
};
priority_queue <point ,vector<point> , point_cmp > q;
int pre[NN];
void dij(int origin){
	for(int i=0;i<=n+1;i++)dis[i]=oo;
	dis[origin]=0;
	point st;
	st.id=origin;st.d=0;
	q.push(st);
	while(!q.empty()){
		point root=q.top();
		q.pop();
		if(dis[root.id]!=root.d)continue;
		for(int i=0;i<con[root.id].size();i++){
			edge ed=e[con[root.id][i]];
			int nex=ed.to;
			if(dis[nex]>max(dis[root.id],ed.cost) ){
				pre[nex]=con[root.id][i];
				dis[nex]=max(dis[root.id],ed.cost);
				point neww;
				neww.id=nex;neww.d=dis[nex];
				q.push(neww);
			}
		}
	}
}
long long  siz[NN],sizfa[NN],numson1[NN],numfa1[NN],num1;
int f[MM];
void dfs(int cur,int fa){
	int up=con[cur].size();
	numson1[cur]=(a[cur]==1);
	siz[cur]=1;
	for(int i=0;i<up;i++){
		edge ed=e[con[cur][i]];
		int nex=ed.to;
		if(f[con[cur][i]]&&nex!=fa){
			dfs(nex,cur);
			siz[cur]+=siz[nex];
			numson1[cur]+=numson1[nex];
		}
	}
}
long long ans=0;
long long quan[MM];
void dfsfa(int cur,int fa,int co){
	int up=con[cur].size();
	numfa1[cur]=num1-numson1[cur];
	sizfa[cur]=n-siz[cur];
	if(cur!=1){
		ans+=quan[co]*
		(1ll*numfa1[cur]*(siz[cur]-numson1[cur])%modd+1ll*(sizfa[cur]-numfa1[cur])*numson1[cur]%modd )%modd;
		ans%=modd;
	}
	for(int i=0;i<up;i++){
		edge ed=e[con[cur][i]];
		int nex=ed.to;
		if(f[con[cur][i]]&&nex!=fa){
			dfsfa(nex,cur,ed.cost);
		}
	}
}
int fa[NN];
int getf(int x){
	if(fa[x]==x)return x;
	return (fa[x]=getf(fa[x]));
}
int main(){
	//freopen("1.in","r",stdin);
	quan[0]=1;
	for(int i=1;i<=200000;i++){
		quan[i]=(quan[i-1]<<1)%modd;
	}
	int t;scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&m);
		if(n==0)break;
		for(int i=1;i<=n;i++)con[i].clear(),fa[i]=i;
		for(int i=0;i<=m*2;i++)f[i]=0;
		num1=0;
		for(int i=1;i<=n;i++){
			scanf("%d",a+i);
			num1+=(a[i]==1);
		}
		int nume=-1;
		for(int i=1;i<=m;i++){
			int x,y;
			scanf("%d%d",&x,&y);
			e[++nume].to=y;
			e[nume].cost=i;
			e[nume].from=x;
			con[x].push_back(nume);
			e[++nume].to=x;
			e[nume].cost=i;
			e[nume].from=y;
			con[y].push_back(nume);
		}
		dij(1);
		for(int i=1;i<=n;i++){
			// int fx=getf(e[i].from);
			// int fy=getf(e[i].to);
			// if(fx!=fy){
				f[pre[i]]=1;
				f[pre[i]^1]=1;
				//printf("%d %d\n",fx,fy);
			// 	fa[fx]=fy;
			// 	f[i]=1;
			// 	f[i^1]=1;
			// }
		}
		dfs(1,-1);
		ans=0;
		dfsfa(1,-1,0);
		// printf("*%lld %lld %lld\n",sizfa[1],sizfa[2],sizfa[3]);
		// long long ans=0;
		// for(int i=0;i<=nume;i++){
		// 	if(f[i]){
		// 		int fr=e[i].from;
		// 		int to=e[i].to;
		// 		int co=e[i].cost;
		// 		printf("%lld %lld %lld\n",quan[co],numfa1[fr],sizfa[fr]);
		// 		ans=ans+quan[co]*
		// 			(numfa1[fr]*(siz[to]-numson1[to])%modd+(sizfa[fr]-numfa1[fr])*numson1[to]%modd )%modd;
		// 		ans%=modd;
		// 	}
		// }
		printf("%lld\n",ans);
	}
	return 0;
}
/*
6 9
1 1 0 1 0 1 
5 2
5 4
2 1
2 6
2 3
5 3
2 4
4 1
3 4
*/
  • 克鲁斯卡尔版
#include<cstdio>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#include<iostream>
#include<queue>
using namespace std;
const int modd=1e9+7;
const int oo=1e9+10;
const int NN=100100;
const int MM=200100;
int n,m;
//int vis[NN],dis[NN];
struct edge{
    int to,cost,from;
}e[MM*2];
vector <int> con[NN];
int a[NN];
// struct point{
//     int id;
//     long long d;
// };
// struct point_cmp{
//     bool operator() (const point &x,const point &y)const{
//         if(x.d>y.d)return 1;
//         if(x.d==y.d && x.id>y.id)return 1;
//         return 0;
//     }
// };
// priority_queue <point ,vector<point> , point_cmp > q;
// int pre[NN];
// void dij(int origin){
//     for(int i=0;i<=n+1;i++)dis[i]=oo;
//     dis[origin]=0;
//     point st;
//     st.id=origin;st.d=0;
//     q.push(st);
//     while(!q.empty()){
//         point root=q.top();
//         q.pop();
//         if(dis[root.id]!=root.d)continue;
//         for(int i=0;i<con[root.id].size();i++){
//             edge ed=e[con[root.id][i]];
//             int nex=ed.to;
//             if(dis[nex]>max(dis[root.id],ed.cost) ){
//                 pre[nex]=con[root.id][i];
//                 dis[nex]=max(dis[root.id],ed.cost);
//                 point neww;
//                 neww.id=nex;neww.d=dis[nex];
//                 q.push(neww);
//             }
//         }
//     }
// }
long long  siz[NN],sizfa[NN],numson1[NN],numfa1[NN],num1;
int f[MM];
void dfs(int cur,int fa){
    int up=con[cur].size();
    numson1[cur]=(a[cur]==1);
    siz[cur]=1;
    for(int i=0;i<up;i++){
        edge ed=e[con[cur][i]];
        int nex=ed.to;
        if(f[con[cur][i]]&&nex!=fa){
            dfs(nex,cur);
            siz[cur]+=siz[nex];
            numson1[cur]+=numson1[nex];
        }
    }
}
long long ans=0;
long long quan[MM];
void dfsfa(int cur,int fa,int co){
    int up=con[cur].size();
    numfa1[cur]=num1-numson1[cur];
    sizfa[cur]=n-siz[cur];
    if(cur!=1){
        ans+=quan[co]*
        (1ll*numfa1[cur]*(siz[cur]-numson1[cur])%modd+1ll*(sizfa[cur]-numfa1[cur])*numson1[cur]%modd )%modd;
        ans%=modd;
    }
    for(int i=0;i<up;i++){
        edge ed=e[con[cur][i]];
        int nex=ed.to;
        if(f[con[cur][i]]&&nex!=fa){
            dfsfa(nex,cur,ed.cost);
        }
    }
}
int fa[NN];
int getf(int x){
    if(fa[x]==x)return x;
    return (fa[x]=getf(fa[x]));
}
int main(){
    //freopen("1.in","r",stdin);
    quan[0]=1;
    for(int i=1;i<=200000;i++){
        quan[i]=(quan[i-1]<<1)%modd;
    }
    int t;scanf("%d",&t);
    while(t--){
        scanf("%d%d",&n,&m);
        if(n==0)break;
        for(int i=1;i<=n;i++)con[i].clear(),fa[i]=i;
        for(int i=0;i<=m*2;i++)f[i]=0;
        num1=0;
        for(int i=1;i<=n;i++){
            scanf("%d",a+i);
            num1+=(a[i]==1);
        }
        int nume=-1;
        for(int i=1;i<=m;i++){
            int x,y;
            scanf("%d%d",&x,&y);
            e[++nume].to=y;
            e[nume].cost=i;
            e[nume].from=x;
            con[x].push_back(nume);
            e[++nume].to=x;
            e[nume].cost=i;
            e[nume].from=y;
            con[y].push_back(nume);
        }
        //dij(1);
        for(int i=0;i<=nume;i+=2){
            int fx=getf(e[i].from);
            int fy=getf(e[i].to);
            if(fx!=fy){
                //f[pre[i]]=1;
                //f[pre[i]^1]=1;
                //printf("%d %d\n",fx,fy);
                fa[fx]=fy;
                f[i]=1;
                f[i^1]=1;
            }
        }
        dfs(1,-1);
        ans=0;
        dfsfa(1,-1,0);
        // printf("*%lld %lld %lld\n",sizfa[1],sizfa[2],sizfa[3]);
        // long long ans=0;
        // for(int i=0;i<=nume;i++){
        //     if(f[i]){
        //         int fr=e[i].from;
        //         int to=e[i].to;
        //         int co=e[i].cost;
        //         printf("%lld %lld %lld\n",quan[co],numfa1[fr],sizfa[fr]);
        //         ans=ans+quan[co]*
        //             (numfa1[fr]*(siz[to]-numson1[to])%modd+(sizfa[fr]-numfa1[fr])*numson1[to]%modd )%modd;
        //         ans%=modd;
        //     }
        // }
        printf("%lld\n",ans);
    }
    return 0;
}
/*
6 9
1 1 0 1 0 1 
5 2
5 4
2 1
2 6
2 3
5 3
2 4
4 1
3 4
*/
Ada Chambers
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hdu.rar_hdu
09-23
HDU（杭州电子科技大学在线评测系统）是一个深受程序员喜爱的在线编程练习平台，它提供了丰富的算法题目供用户挑战，帮助他们提升编程技能和算法理解能力。"hdu.rar_hdu"这个压缩包文件很可能是某位程序员整理的他在...
hdu.zip_ACM_hdu
09-20
在ACM(国际大学生程序设计竞赛)中，数据结构与算法是至关重要的组成部分，而"杭电"(杭州电子科技大学)的在线判题系统HDU提供了许多这类问题供参赛者练习。"hdu.zip_ACM_hdu"这个压缩包很可能是包含了一道或若干道...
2020 hdu 多校 第6场 部分题解
yangzijiangac的博客
08-06 624
100110011001 RoadRoadRoad ToToTo TheTheThe 3rd3rd3rd BuildingBuildingBuilding 思路： 说实话写出这题的时候挺兴奋的，坑点比较多，而且一个队友没来，我和另一个队友孤军奋战，我让mh和我一起读题，然后我们俩确定题意后，我们开始分别想，之后我想了一个多小时，首先这题要确定分数的底数要相同，呢么就要求相同的底数。然后我们可以画图来看： 我们可以知道每一长度的和为k∗sum(1+....n)−前缀和的前缀−后缀和的后缀k*sum(1+..
*HDU6832（多校第六场）.A Very Easy Graph Problem(最小生成树+dfs)
Buyi的博客
08-07 170
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6832 题意： 找出所有满足ai=1&&aj=0的点连成的边的权值和 解题思路： 给出的第i条边的长度=2^i，2 ^1+2 ^2+…+2 ^(n-1)<2 ^n，所以可以得出越早出现的边或者连通边（间接连在一起的边）越短 ①使用并查集，保存能够相互连接的边，每加入一条边，先判断这两个点是否已经在同一并查集中，确保最短。经过这样的操作后，可以得到一个最小生成树，每两个点之间只有一条最短的路
2020杭电HDU-6832多校第六场A Very Easy Graph Problem（最短路转最小生成树+dfs）
孤风的博客
08-07 458
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6832 博客园食用链接：https://www.cnblogs.com/lonely-wind-/p/13455277.html An undirected connected graph has n nodes and m edges, The i-th edge’s length is 2i2^i2i. Each node i has a value aia_iai​, which is either 0 o
2020杭电多校第六场 A Very Easy Graph Problem 点分治 (HDU 6832)
流水
08-06 451
A Very Easy Graph Problem 不知道有没有人跟我一样点分治写的… 题解 根据题意，第iii条边长度为2i2^i2i，且21+22+⋅⋅⋅+2i−1=2i−1<2i2^1+2^2+···+2^{i - 1} =2^i-1<2^i21+22+⋅⋅⋅+2i−1=2i−1<2i，即后面加进去的边要大于前面所有边之和 那么显然，如果在加入当前边(u,v,2i)(u,v,2^i)(u,v,2i)之前，uuu和vvv已经连通了，我们就不用再加这条边了(加之前能连通，而且根据上面说的
HDU6582(最短路+最小割)
bestjerry007的博客
10-30 150
Hdu6582 思路比较简单，先找最短路，然后跑dinic求最小割，一开始还想再建图，后面看了别人的代码，其实只要把不是最短路径上的路径的权值归零就可以了。 #include<bits/stdc++.h> using namespace std; typedef long long ll; const ll inf = 1e17; const int maxn = 2e6+50; in...
hdu1020.rar_hdu1020
09-20
HDU 1020，又被称为"猜数字"，是一个经典的在线算法竞赛题目，源自中国杭州电子科技大学（Hangzhou Dianzi University）的在线评测系统HDU ACM/ICPC。这个题目要求参赛者编写一个程序，模拟一个猜数字的游戏过程，...
bfs.rar_hdu
09-22
6. 编程实践：编写清晰、可读且能够正确解决问题的C++代码，包括变量定义、函数调用、循环结构等。 以上就是基于题目信息分析出的相关知识点，这些内容对于理解并解答该题至关重要。实际解题时，需要结合“bfs.cpp...
HDU-ACM_java.rar_hdu
09-22
【标题】"HDU-ACM_java.rar" 是一个针对杭州电子科技大学（HDU）ACM竞赛的资源压缩包，其中包含的是使用Java语言编写的算法解决方案。这个压缩包主要面向那些参与或准备参与ACM国际大学生程序设计竞赛（ICPC）的参赛...
HDU 6832 A Very Easy Graph Problem 2020 HDU多校第六场
江小举的博客
08-07 439
题意：给定一张含有n个顶点和m条边的图。顶点有两种类型 0和1。第i条边的权值为2i 。求任意顶点0和任意顶点1之间的距离和。 思路：这题跟 这道2018CCPC网络赛 很类似。 由于边有2e5条。所以直接用dijkstra求最短距离是不可能的，复杂度直接炸了。 因为第i条边的权值是2i ，所以第i条的权值是大于前i-1条权值之和。也就是说。如果前i-1条边图已经联通了，那么我们就不需要剩下的边了。因为就算两点间需要经过i-1条边，那这个距离也是小于第i条边的。 所以我们可以先把图转成一颗树（最小生成树），
hdu 5867 Water problem
zoro_n的博客
08-18 1158
Problem Description If the numbers 1 to 5 are written out in words: one, two, three, four, five, then there are 3+3+5+4+4=19 letters used in total.If all the numbers from 1 to n (up to one thousand
hdu5673 Robot
单木的专栏
04-24 764
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5673 题目大意：一个机器人，可以向左，向右或停在当前位置每个动作都话费n个时间，但不能移动到原点左面，问n个时间后仍在原点位置有多少种走法。 解题思路：开始乱搞了一通，后来看的题解，枚举robot向左走的步数，同时它向右走的步数是一样的因为要回到原点，所以对于每一种情况，向左走i步，有C​n​2i...
HDU 6832 A Very Easy Graph Problem题解（最小生成树+思维）
hunxuewangzi的博客
08-07 217
题目链接 题目思路 给你一个n个点,m条无向边的图，每个点有是黑点或者白点，要你求所有黑点和所有白点的最短路的和。 题目思路 跑多次最短路显然会TLE，这个时候要注意他每条边的长度是2i2^i2i也就是说你跑了全部的前i条边的长度之和都比你跑第（i+1）条边的长度短，所以如果两个点能通过前i条边到达，那肯定比通过第i+1条更优，所以我们从1 到 m按顺序建最小生成树。对于白点和黑点的最短路，我们枚举每条边会被多少种白点和黑点通过，统计两侧的黑白点个数，计算贡献即可。 代码 #include<set&g
2020 HDU 杭电多校第六场
wodasini的专栏
08-07 550
2020 HDU 杭电多校第场六场 Little Rabbit’s Equation Divisibility A Very Easy Graph Problem Road To The 3rd Building Expectation Fragrant numbers Little Rabbit’s Equation 题目大意： 给一串数字符号表达式,形如"A1+30=B5" 判断这个最少是几进制的， 由于数据很小，直接模拟，注意每个数字必须严格小于进制数 #include <
HDU 6832 A Very Easy Graph Problem
菜鸡的学习记录
08-10 111
A Very Easy Graph Problem 题意： 给了一张连通图，有黑白两种颜色的点，求所有黑白点对之间的距离之和。 对于给的边的顺序，第i条边的权值为2^i 思路： 不难知道2 ^ 1 + 2 ^ 2 +2 ^ 3 + … + 2 ^ (i-1) < 2 ^ i 所以最后的图一定是原图的最小生成树，用并查集保存下来选择的边即可。 然后我们计算在最小生成树中的边对答案的贡献。 对于边(u,v)，我们只需要知道从1到u有多少个黑点，从v到n有多少个白点，贡献就是左边黑点个数乘右边白点个数乘上
HDU 6832 A Very Easy Graph Problem （最小生成树+dfs）
gongyuandaye的博客
08-07 185
题意： 题解：最小生成树+dfs 晚输入的边权比之前输入的边权和还要大，根据输入用kruskal求mst。 最短我们已经保证了，既然要求所有1到0的路径和，可以通过dfs求出每条边之后有多少个0和1，用dp数组记录，总的减去之后的就是之前的，根据乘法原理算一下即可。 ...
HDU - 2181 哈密顿绕行世界问题 （dfs）
07-29 113
题意：给出20个城市与其相邻的3个点，给出起始点，(经过其他所有城市然后回到原处)然后输出所有路径(并且字典序最小)思路： 用dfs来求出路径，然后对应字典序最小就对每个城市连接的城市先排一次顺序 完整代码： #include <iostream> #include <cstdio> #include <algorithm> #in...
母函数 HDU 2152
anjuepo2897的博客
05-16 242
Fruit Problem Description 转眼到了收获的季节，由于有TT的专业指导，Lele获得了大丰收。特别是水果，Lele一共种了N种水果，有苹果，梨子，香蕉，西瓜……不但味道好吃，样子更是好看。 于是，很多人们慕名而来，找Lele买水果。 甚至连大名鼎鼎的HDU ACM总教头 lcy 也来了。lcy抛出一打百元大钞，"我要买由M个水果组成的水果拼盘，不过我有个小...
java HDU2020
最新发布
12-18
以下是Java HDU2020的代码实现： ```java import java.util.Scanner; import java.util.Arrays; import java.util.Comparator; public class Main { public static void main(String[] args) { Scanner sc = new...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值