【点分治】【哈希表】bzoj2599 [IOI2011]Race

给nlog2n随便过的跪了,不得已弄了个哈希表伪装成nlogn(当然随便卡,好孩子不要学)……

不过为啥哈希表的大小开小点就RE啊……?必须得超过数据范围一大截才行……谜

#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int f,c;
inline void R(int &x){
    c=0;f=1;
    for(;c<‘0‘||c>‘9‘;c=getchar())if(c==‘-‘)f=-1;
    for(x=0;c>=‘0‘&&c<=‘9‘;c=getchar())(x*=10)+=(c-‘0‘);
    x*=f;
}
#define INF 2147483647
#define MAXN 200001
#define MOD 200003
#define MAXN2 290003
typedef pair<int,int> Point;
struct HashTable
{
    Point v[MAXN2];
    int en,first[MOD],next[MAXN2];
    HashTable(){en=0;memset(first,-1,sizeof(first));}
    void insert(const Point &V)
      {
        int U=(int)(V.first%MOD);
        for(int i=first[U];i!=-1;i=next[i]) if(v[i].first==V.first)
		{v[i].second=min(v[i].second,V.second); return;}
        v[en]=V; next[en]=first[U]; first[U]=en++;
      }
}T;
int n,K,ans=INF,last;
int v[MAXN<<1],w[MAXN<<1],first[MAXN],next[MAXN<<1],en;
void AddEdge(const int &U,const int &V,const int &W)
{v[++en]=V; w[en]=W; next[en]=first[U]; first[U]=en;}
bool centroid[MAXN];
int size[MAXN];
int calc_sizes(int U,int Fa)
{
	int res=1;
	for(int i=first[U];i;i=next[i])
	  if(v[i]!=Fa&&(!centroid[v[i]]))
		res+=calc_sizes(v[i],U);
	return size[U]=res;
}
Point calc_centroid(int U,int Fa,int nn)
{
	Point res=make_pair(INF,-1);
	int sum=1,maxv=0;
	for(int i=first[U];i;i=next[i])
	  if(v[i]!=Fa&&(!centroid[v[i]]))
	    {
	      res=min(res,calc_centroid(v[i],U,nn));
	      maxv=max(maxv,size[v[i]]);
	      sum+=size[v[i]];
	    }
	maxv=max(maxv,nn-sum);
	res=min(res,make_pair(maxv,U));
	return res;
}
Point dis[MAXN];
int En;
void calc_dis(int U,int Fa,int d,int cnt)
{
	dis[En++]=make_pair(d,cnt);
	for(int i=first[U];i;i=next[i])
	  if(v[i]!=Fa&&(!centroid[v[i]]))
	    calc_dis(v[i],U,d+w[i],cnt+1);
}
int calc_pairs()
{
	int res=0;
	for(int i=last;i<En;++i)
	  {
	  	int U=(int)((K-dis[i].first)%MOD);
	  	for(int j=T.first[U];j!=-1;j=T.next[j])
	  	  if(T.v[j].first==K-dis[i].first)
	  	    {
	  	      ans=min(T.v[j].second+dis[i].second,ans);
	  	      break;
	  	    }
	  }
	for(int i=last;i<En;++i) T.insert(dis[i]);
}
void solve(int U)
{
	calc_sizes(U,-1);
	int s=calc_centroid(U,-1,size[U]).second;
	centroid[s]=1;
	for(int i=first[s];i;i=next[i])
	  if(!centroid[v[i]])
	    solve(v[i]);
	En=0; dis[En]=make_pair(0,0); T.insert(dis[En++]);
	for(int i=first[s];i;i=next[i])
	  if(!centroid[v[i]])
	    {
	      last=En;
		  calc_dis(v[i],s,w[i],1);
	      calc_pairs();
	    }
	for(int i=0;i<En;++i)
	  T.first[dis[i].first%MOD]=-1;
	T.en=0;
	centroid[s]=0;
}
int main()
{
	int a,b,c;
	R(n); R(K);
	if(!K) {puts("0"); return 0;}
	for(int i=1;i<n;++i)
	  {
	  	R(a); R(b); R(c);
	  	AddEdge(a,b,c);
	  	AddEdge(b,a,c);
	  }
	solve(1);
	printf("%d\n",ans==INF ? -1 : ans);
	return 0;
}
时间: 2024-10-11 12:28:53

【点分治】【哈希表】bzoj2599 [IOI2011]Race的相关文章

bzoj2599: [IOI2011]Race(点分治)

写了四五道点分治的题目了,算是比较理解点分治是什么东西了吧= = 点分治主要用来解决点对之间的问题的,比如距离为不大于K的点有多少对. 这道题要求距离等于K的点对中连接两点的最小边数. 那么其实道理是一样的.先找重心,然后先从重心开始求距离dis和边数num,更新ans,再从重心的儿子开始求得dis和num,减去这部分答案 因为这部分的答案中,从重心开始的两条链有重叠部分,所以要剪掉 基本算是模板题,但是减去儿子的答案的那部分还有双指针那里调了好久,所以还不算特别熟练.. PS跑了27秒慢到飞起

bzoj1758 [Wc2010]重建计划 &amp; bzoj2599 [IOI2011]Race

两题都是树分治. 1758这题可以二分答案avgvalue,因为avgvalue=Σv(e)/s,因此二分后只需要判断Σv(e)-s*avgvalue是否大于等于0,若大于等于0则调整二分下界,否则调整二分上界.假设一棵树树根为x,要求就是经过树根x的最大答案,不经过树根x的可以递归求解.假设B[i]为当前做到的一颗x的子树中的点到x的距离为i的最大权值,A[i]为之前已经做过的所有子数中的点到x的距离为i的最大权值(这里的权值是Σv(e)-i*avgvalue),那么对于当前子树的一个距离i,

[BZOJ2599][IOI2011]Race

试题描述 给一棵树,每条边有权.求一条简单路径,权值和等于K,且边的数量最小.N <= 200000, K <= 1000000 输入 第一行 两个整数 n, k第二..n行 每行三个整数 表示一条无向边的两端和权值 (注意点的编号从0开始) 输出 一个整数 表示最小边数量 如果不存在这样的路径 输出-1 输入示例 4 3 0 1 1 1 2 2 1 3 4 输出示例 2 数据规模及约定 见“试题描述” 题解 点分治裸题.我还调了半天TAT...好久没写什么都忘了... 每次找子树的中心往下递

【BZOJ2599】[IOI2011]Race 树的点分治

[BZOJ2599][IOI2011]Race Description 给一棵树,每条边有权.求一条简单路径,权值和等于K,且边的数量最小.N <= 200000, K <= 1000000 Input 第一行 两个整数 n, k第二..n行 每行三个整数 表示一条无向边的两端和权值 (注意点的编号从0开始) Output 一个整数 表示最小边数量 如果不存在这样的路径 输出-1 Sample Input 4 3 0 1 1 1 2 2 1 3 4 Sample Output 2 题解:本题大

BZOJ 2599: [IOI2011]Race( 点分治 )

数据范围是N:20w, K100w. 点分治, 我们只需考虑经过当前树根的方案. K最大只有100w, 直接开个数组CNT[x]表示与当前树根距离为x的最少边数, 然后就可以对根的子树依次dfs并更新CNT数组和答案. ------------------------------------------------------------------------------------------ #include<bits/stdc++.h> using namespace std; typ

【BZOJ-2599】Race 点分治

2599: [IOI2011]Race Time Limit: 70 Sec  Memory Limit: 128 MBSubmit: 2590  Solved: 769[Submit][Status][Discuss] Description 给一棵树,每条边有权.求一条简单路径,权值和等于K,且边的数量最小.N <= 200000, K <= 1000000 Input 第一行 两个整数 n, k第二..n行 每行三个整数 表示一条无向边的两端和权值 (注意点的编号从0开始) Output

哈希表

哈希表支持的一种最有效的检索方法:散列. 由于计算哈希值和在数组中进行索引都只消耗固定时间,因此哈希表的最大亮点在于他是一种运行时间在常量级的检索方法. 哈希表主要有两种: 1.链式哈希表:将数据存储在桶中的哈希表,每个桶里面都是一个链表,且链表的容量随着冲突的增大而增大.(换句话说就是如果有冲突,会在桶中的链表加上一个存储的值) 2.开地址哈希表:将数据存在表本身,而不是在桶中,他通过各种探查方法来避免冲突. 解决冲突: 不管在以上那种哈希表中,我们的目标是尽可能均匀的分配表中的元素.所以我们

8. 蛤蟆的数据结构进阶八哈希表相关概念

8. 蛤蟆的数据结构进阶八哈希表相关概念 本篇名言:"作家当然必须挣钱才能生活,写作,但是他决不应该为了挣钱而生活,写作.--马克思" 前些笔记我们学习了二叉树相关.现在我们来看下哈希表.这篇先来看下哈希表的相关概念 欢迎转载,转载请标明出处:http://blog.csdn.net/notbaron/article/details/47347273 1.  哈希表的概念 哈希表(HashTable)也叫散列表,是根据关键码值(Key Value)而直接进行访问的数据结构.它通过把关键

哈希表——线性探测法、链地址法、查找成功、查找不成功的平均长度

一.哈希表 1.概念 哈希表(Hash Table)也叫散列表,是根据关键码值(Key Value)而直接进行访问的数据结构.它通过把关键码值映射到哈希表中的一个位置来访问记录,以加快查找的速度.这个映射函数就做散列函数,存放记录的数组叫做散列表. 2.散列存储的基本思路 以数据中每个元素的关键字K为自变量,通过散列函数H(k)计算出函数值,以该函数值作为一块连续存储空间的的单元地址,将该元素存储到函数值对应的单元中. 3.哈希表查找的时间复杂度 哈希表存储的是键值对,其查找的时间复杂度与元素数