8.26T1 日记和最短路（二分 哈希 倍增）

最新推荐文章于 2024-08-27 20:45:40 发布
最新推荐文章于 2024-08-27 20:45:40 发布
阅读量127 收藏
点赞数 1
文章标签： 二分 哈希 倍增
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangtingxiqwq/article/details/141575217
版权

http://cplusoj.com/d/senior/p/NOD2301A

题解做法复杂度是错的，hack掉了

比较两个字符串常见方法是二分加hash

在这题套个倍增就行

题解做法也有可取的，把一个串拆成一堆小字符，实现起来方便很多

最后我打了9k

复杂度两只log

#include<bits/stdc++.h>
using namespace std;
#ifdef LOCALd
 #define debug(...) fprintf(stdout, ##__VA_ARGS__)
 #define debag(...) fprintf(stderr, ##__VA_ARGS__)
#else
 #define debug(...) void(0)
 #define debag(...) void(0)
#endif
#define int long long
inline int read(){int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;
ch=getchar();}while(ch>='0'&&ch<='9'){x=(x<<1)+
(x<<3)+(ch^48);ch=getchar();}return x*f;}
#define Z(x) (x)*(x)
#define pb push_back
#define fi first
#define se second
#define M 2000010
#define mo 998244353
#define N 100010
vector<int>G1[N], G2[N]; 
int eff[N], pw[M], Du[N]; 
int n, m, i, j, k, T;
string str; 
map<pair<int, int>, vector<string> >S1, S2; 
map<pair<int, int>, string>mp; 

void dfs_eff1(int x) {
	if(eff[x] & 1) return ; 
	eff[x] |= 1; 
	for(int y : G1[x]) dfs_eff1(y); 
}

void dfs_eff2(int x) {
	if(eff[x] & 2) return ; 
	eff[x] |= 2; 
	for(int y : G2[x]) dfs_eff2(y); 
}

namespace Sol2 {
	int f[N][22], g[N][22], L[N][22]; 
	vector<int>H[N], T[N]; 
	int len, Len;
	int h1[M], h2[M], t1[M], t2[M];	
	int nxt[N], dep[N], du[N]; 
	queue<int>q; 
	int merge(int x, int y, int l) {
		return (x * pw[l] + y) % mo; 
	}
	int Qry1(int x, int l) {
		if(l <= Len) return h1[l]; 
		int nw = h1[Len]; l -= Len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l >= L[x][k])  {
				nw = merge(nw, g[x][k], L[x][k]); 
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return nw; 
		assert(l <= L[x][0]); 
		nw = merge(nw, H[x][l], l); 
		return nw; 
	}
	int Qry2(int x, int l) {
		if(l <= len) return h2[l]; 
		int nw = h2[len]; l -= len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l >= L[x][k])  {
				nw = merge(nw, g[x][k], L[x][k]); 
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return nw; 
		assert(l <= L[x][0]); 
		nw = merge(nw, H[x][l], l); 
		return nw; 
	}
	int Qu1(int x, int l) {
		if(l <= Len) return t1[l]; 
		l -= Len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l > L[x][k])  {
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return 0; 
		debug("== %lld %lld %c %lld\n", x, l, (char)(T[x][l] + 'a' - 1), T[x][l]); 
		return T[x][l]; 
	}
	int Qu2(int x, int l) {
		if(l <= len) return t2[l]; 
		l -= len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l > L[x][k])  {
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return 0; 
		debug("== %lld %lld %c %lld\n", x, l, (char)(T[x][l] + 'a' - 1), T[x][l]); 
		return T[x][l]; 
	}
	int cmp(int x, int u, int v) {
		debug("%lld [%lld %lld]\n", x, u, v); 
		if(n <= 10) str = S2[{x, v}][S2[{x, v}].size() - 1], S2[{x, v}].pop_back(); 
		else str = mp[{x, v}]; 
		
		len = str.size(); 
//		debug("In %lld cmping(%lld %lld) %lld\n", x, u, v, len); 
		for(i = 0; i < len; ++i) {
			t2[i + 1] = str[i] - 'a' + 1; 
			h2[i + 1] = (h2[i] * 47 + t2[i + 1]) % mo; 
		}
		if(!u) {
			Len = len; 
			for(i = 1; i <= len; ++i) 
				h1[i] = h2[i], t1[i] = t2[i]; 
			return v; 
		}
//		if(dep[u] + Len < dep[v] + len) return u; 
//		assert(dep[u] + Len == dep[v] + len) ; 
		int l, r; l = 0; r = 100000; 
		while(l < r) { // lcp
			int mid = (l + r + 1) >> 1; 
			debug("Today is %lld\n", mid); 
			int s1 = Qry1(u, mid); 
			int s2 = Qry2(v, mid);
			if(x == 1 && mid == 4)  debug("%lld %lld\n", s1, s2); 
			if(s1 == s2) l = mid; 
			else r = mid - 1; 
		}
		if(x == 1) debug("%lld[%lld %lld]\n", l, u, v); 
		int c1 = Qu1(u, l + 1); 
		int c2 = Qu2(v, l + 1); 
		debug("%lld %lld\n", c1, c2); 
		if(c2 < c1) {
			Len = len; 
			for(i = 1; i <= len; ++i) 
				h1[i] = h2[i], t1[i] = t2[i]; 
			swap(u, v); 
		}
		return u; 
	}
	void calc(int x) {
		H[x].resize(Len + 5); 
		T[x].resize(Len + 5); 
		for(i = 1; i <= Len; ++i) 
			H[x][i] = h1[i], T[x][i] = t1[i]; 
		dep[x] = dep[nxt[x]] + Len; 
		f[x][0] = nxt[x]; g[x][0] = H[x][Len]; L[x][0] = Len; 
		for(k = 1; k <= 20; ++k) {
			f[x][k] = f[f[x][k - 1]][k - 1]; 
			g[x][k] = merge(g[x][k - 1], g[f[x][k - 1]][k - 1], L[f[x][k - 1]][k - 1]); 
			L[x][k] = L[x][k - 1] + L[f[x][k - 1]][k - 1]; 
		}
	}
	void work(int x) {
		Len = 0; 
		for(int y : G1[x]) if(eff[y] == 3) {
			nxt[x] = cmp(x, nxt[x], y); 
		}
		calc(x); 
	}
	void print(int x) {
		if(!nxt[x]) return ; 
		for(i = 1; i <= L[x][0]; ++i) printf("%c", (char)(T[x][i] + 'a' - 1)); 
//		str = mp[{x, nxt[x]}]; cout << str; 
		print(nxt[x]); 
	}
	void main() {
		memcpy(du, Du, sizeof(Du)); q.push(n); 
		while(!q.empty()) {
			int u = q.front(); q.pop(); 
			for(int v : G2[u]) if(eff[v] == 3) {
				if(--du[v] == 0) work(v), q.push(v); 
			}
		}
//		print(6); debug("\n"); 
		print(1); 
	}
}

namespace Sol1 {
	int f[N][22], g[N][22], L[N][22]; 
	vector<int>H[N], T[N]; 
	int len, Len;
	int h1[M], h2[M], t1[M], t2[M];	
	int nxt[N], dep[N], du[N]; 
	queue<int>q; 
	int merge(int x, int y, int l) {
		return (x * pw[l] + y) % mo; 
	}
	int Qry1(int x, int l) {
		if(l <= Len) return h1[l]; 
		int nw = h1[Len]; l -= Len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l >= L[x][k])  {
				nw = merge(nw, g[x][k], L[x][k]); 
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return nw; 
		assert(l <= L[x][0]); 
		nw = merge(nw, H[x][l], l); 
		return nw; 
	}
	int Qry2(int x, int l) {
		if(l <= len) return h2[l]; 
		int nw = h2[len]; l -= len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l >= L[x][k])  {
				nw = merge(nw, g[x][k], L[x][k]); 
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return nw; 
		assert(l <= L[x][0]); 
		nw = merge(nw, H[x][l], l); 
		return nw; 
	}
	int Qu1(int x, int l) {
		if(l <= Len) return t1[l]; 
		l -= Len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l > L[x][k])  {
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return 0; 
		debug("== %lld %lld %c %lld\n", x, l, (char)(T[x][l] + 'a' - 1), T[x][l]); 
		return T[x][l]; 
	}
	int Qu2(int x, int l) {
		if(l <= len) return t2[l]; 
		l -= len; 
		for(k = 20; k >= 0; --k)
			if(f[x][k] && l > L[x][k])  {
				l -= L[x][k]; 
				x = f[x][k]; 
			}
		if(x == n) return 0; 
		debug("== %lld %lld %c %lld\n", x, l, (char)(T[x][l] + 'a' - 1), T[x][l]); 
		return T[x][l]; 
	}
	int cmp(int x, int u, int v) {
//		str = *S1[{x, v}].begin(); S1[{x, v}].erase(*S1[{x, v}].begin()); 
		if(n <= 10) str = S1[{x, v}][S1[{x, v}].size() - 1], S1[{x, v}].pop_back(); 
		else str = mp[{x, v}]; 
		len = str.size(); 
//		debug("In %lld cmping(%lld %lld) %lld\n", x, u, v, len); 
		for(i = 0; i < len; ++i) {
			t2[i + 1] = str[i] - 'a' + 1; 
			h2[i + 1] = (h2[i] * 47 + t2[i + 1]) % mo; 
		}
		if(!u || dep[u] + Len > dep[v] + len) {
			Len = len; 
			for(i = 1; i <= len; ++i) 
				h1[i] = h2[i], t1[i] = t2[i]; 
			return v; 
		}
		if(dep[u] + Len < dep[v] + len) return u; 
		assert(dep[u] + Len == dep[v] + len) ; 
		int l, r; l = 0; r = 100000; 
		while(l < r) { // lcp
			int mid = (l + r + 1) >> 1; 
			debug("Today is %lld\n", mid); 
			int s1 = Qry1(u, mid); 
			int s2 = Qry2(v, mid);
			if(x == 1 && mid == 4)  debug("%lld %lld\n", s1, s2); 
			if(s1 == s2) l = mid; 
			else r = mid - 1; 
		}
		if(x == 1) debug("%lld[%lld %lld]\n", l, u, v); 
		int c1 = Qu1(u, l + 1); 
		int c2 = Qu2(v, l + 1); 
		debug("%lld %lld\n", c1, c2); 
		if(c2 < c1) {
			Len = len; 
			for(i = 1; i <= len; ++i) 
				h1[i] = h2[i], t1[i] = t2[i]; 
			swap(u, v); 
		}
		return u; 
	}
	void calc(int x) {
		H[x].resize(Len + 5); 
		T[x].resize(Len + 5); 
		for(i = 1; i <= Len; ++i) 
			H[x][i] = h1[i], T[x][i] = t1[i]; 
		dep[x] = dep[nxt[x]] + Len; 
		f[x][0] = nxt[x]; g[x][0] = H[x][Len]; L[x][0] = Len; 
		for(k = 1; k <= 20; ++k) {
			f[x][k] = f[f[x][k - 1]][k - 1]; 
			g[x][k] = merge(g[x][k - 1], g[f[x][k - 1]][k - 1], L[f[x][k - 1]][k - 1]); 
			L[x][k] = L[x][k - 1] + L[f[x][k - 1]][k - 1]; 
		}
	}
	void work(int x) {
		Len = 0; 
		for(int y : G1[x]) if(eff[y] == 3) {
			nxt[x] = cmp(x, nxt[x], y); 
		}
		calc(x); 
	}
	void print(int x) {
		if(!nxt[x]) return ; 
		for(i = 1; i <= L[x][0]; ++i) printf("%c", (char)(T[x][i] + 'a' - 1)); 
//		str = mp[{x, nxt[x]}]; cout << str; 
		print(nxt[x]); 
	}
	void main() {
		memcpy(du, Du, sizeof(Du)); q.push(n); 
		while(!q.empty()) {
			int u = q.front(); q.pop(); 
			for(int v : G2[u]) if(eff[v] == 3) {
				if(--du[v] == 0) work(v), q.push(v); 
			}
		}
//		print(6); debug("\n"); 

		print(1); 
	}
}

signed main()
{
	#ifdef LOCAL
	  freopen("in.txt", "r", stdin);
	  freopen("out.txt", "w", stdout);
	#endif
//	srand(time(NULL));
//	T=read();
//	while(T--) {
//
//	}
	n = read(); m = read(); 
	if(n <= 10) {
		for(i = 1; i <= m; ++i) {
			int u, v; u = read(); v = read(); 
			assert(u != v); 
			G1[u].pb(v); G2[v].pb(u); 
			cin >> str; S1[{u, v}].pb(str); S2[{u, v}].pb(str); 
		}
	}
	else {
		for(i = 1; i <= m; ++i) {
			int u, v; u = read(); v = read(); 
			assert(u != v); 
			G1[u].pb(v); G2[v].pb(u); 
			cin >> str; mp[{u, v}] = str; 
		}
	}
	dfs_eff1(1); 
	dfs_eff2(n); 
	for(i = 1; i <= n; ++i) if(eff[i] == 3) {
		for(int y : G1[i]) if(eff[y] == 3) ++Du[i]; 
	}
	for(i = pw[0] = 1; i <= 2e6; ++i) pw[i] = pw[i - 1] * 47 % mo; 
	Sol1 :: main(); printf(" "); 
	Sol2 :: main(); 
	return 0;
}
Qres821
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
三菱8.26级版本软件
08-25
本文将深入探讨“三菱8.26级版本软件”，这是一个专门针对三菱PLC（可编程逻辑控制器）的软件更新，用于提高控制系统的性能和功能。 【描述】：“三菱8.26级版本软件” 这个描述简洁地指出我们关注的是三菱PLC软件...
bitvise ssh client 8.26
04-30
Windows最强ssh客户端,原名Tunnelier，解除它是因为为了sshFQ，没想到它既有SSH Terminal，又集成SFTP，还能FQ，功能一应区全。 还支持pem证书，回想最初使用putty，还要把pem证书进行转换才能使用。...
8.26训练日记
weixin_43244265的博客
08-26 91
一：HDU4442 　这个题是个贪心的水题，但介绍了一种找贪心标准的方法，就是先举个例子比较先后，看他是拿什么来比较的，然后想办法化成贪心标准（用一个状态的量就能表示的式子） 二：POJ 3984 　这是一个典型的广搜找最短路径的问题，没什么特别的，但是我发现一个结构体的赋值方式挺有意思； 　struct Node { int r,c; int time;//时间 Node(int r,int c...
8.26 T2 日记和欧拉函数（欧拉函数）
zhangtingxiqwq的博客
08-26 229
的话相当于求小于它的质数。预处理直接暴力做，求。我们预处理中间的就行。
8.26学习日记
qq_39657313的博客
08-27 260
感知机（Perceptron）是一个基本的线性分类器，是最早的人工神经网络模型之一。它可以用于二分类问题，主要用于学习将数据分成两个类别的超平面。原理：1.感知机接收一个输入向量,每个输入特征x都有一个对应的权重 w2.计算输入向量和权重的线性组合，再加上一个偏置项后构成Z=WX+b，其中W是权重向量，X是输入向量3.使用激活函数进行处理，感知机用的是阶跃函数，这样输入向量会被分为正或负说白了就是一堆向量通过这个公式得到了一堆值，然后根据阶跃函数分成正负。
8.26 T4 日记和编辑器（fhq维护kmp——kmp本身含有的单射与可合并性）
zhangtingxiqwq的博客
08-27 159
而这个东西是非常好pushup的！我们直接按照左、中、右的顺序就行了。（也就是kmp匹配到的位置），我们是可以直接预处理得到出来的。前4个操作拿fhq treap是很好维护的。如果我们知道一个串进入的指针。
哈希算法和哈希学习分类
weixin_40396948的博客
01-17 7101
哈希 1.先来了解一下Hash的基本思路： 设要存储对象的个数为num, 那么我们就用len个内存单元来存储它们(len>=num); 以每个对象ki的关键字为自变量，用一个函数h(ki)来映射出ki的内存地址，也就是ki的下标，将ki对象的元素内容全部存入这个地址中就行了。这个就是Hash的基本思路。 Hash为什么这么想呢？换言之，为什么要用一个函数来映射出它们的地址单元呢？ Th
8.26力扣练习
2302_82073997的博客
08-26 109
/先判断字符的长度，如果长度为奇数，则不为有效括号，将括号的各种左右两边存入哈希表pairs，再定义一个队列，遍历给定字符串，判断映射 pairs 中是否存在键为 ch 的条目，如果有则进入下一个判断(注意这里如果判断符号为右括号则会进入下一个判断，所以说stack存的全是右括号)，判断队列是否为空或者队列stact的队顶是否与pairs里面以ch为键值的字符相等（而ch为键值的字符全是左括号），如果不相等直接返回false,否则将队顶元素剔除，，如果不存在该键值则将该字符插入队顶。
哈希冲突和内存溢出
crystal_hhj的博客
08-19 902
哈希冲突产生的原因 哈希是通过对数据进行再压缩，提高效率的一种解决方法 ，但是通过哈希函数产生的哈希值是有限的，而数据的总量可能很大，这就导致总会有不同的数据拥有相同的哈希值，从而产生了哈希冲突。 产生哈希冲突的影响因素 填充比（填充比=数据总数/哈希表长）又叫加载因子，哈希函数，处理哈希冲突的算法。 解决哈希冲突的四种方法 1，开放地址法 线性探测再散列法 按顺序决定值时，如果某数据的值已经存在，则在原来值的基础上往后加一个单位，直至不发生哈希冲突。 二次平方再散列法 按顺序决定...
GitHub每日最火火火项目（8.26）
qq_37281548的博客
08-26 505
GitHub每日最火火火项目（8.26）
设备管理 小牛固定资产管理系统 v8.26 网络条码版
10-30
《小牛固定资产管理系统v8.26：网络条码版详解》 在信息化时代，企业的资产管理变...通过GBS-v8.26这个压缩包文件，用户可以获取完整的系统安装和使用指南，轻松实现系统的部署和运行，进一步提升企业的资产管理能力。
MITSUBISHIGX8.26 三菱PLC编程软件.rar
10-17
- **编程工具**：GX8.26提供了完善的编程工具，包括编辑器、仿真器和调试器，使得程序编写、测试和故障排除更为便捷。 - **在线诊断**：软件具有强大的在线诊断功能，能实时监控PLC的状态，及时发现并解决问题。 ...
GX8.26中文PLC软件.pdf
10-15
8. 中图分类号TP273：这表明该文档属于自动化学报，分类号TP273涉及工业过程控制和自动化技术，这反映了文档内容的技术层面和应用领域。 总结来说，文档涉及了远程控制系统的设计、QoS性能监测与补偿、网络传输时延...
基于单片机的红外感应防盗报警器的硬件设计-本科毕业设计.doc
08-27
基于单片机的红外感应防盗报警器的硬件设计-本科毕业设计.doc
java基于ssm+vue量化积分管理系统源码 带毕业论文
08-27
【资源说明】 1、开发环境：ssm框架；内含Mysql数据库；VUE技术 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料学习借鉴。 4、本资源作为“参考资料”如果需要实现其他功能，需要能看懂代码，并且热爱钻研，自行调试。
毕业设计（论文）-基于51单片机的硬件加密锁的设计与实现.doc
08-27
毕业设计（论文）-基于51单片机的硬件加密锁的设计与实现.doc
模块化生产系统硬件设计.doc
最新发布
08-27
模块化生产系统硬件设计.doc
二叉树建立.c
08-27
二叉树建立.c
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值