arc058 F - Iroha Loves Strings & Z函数学习笔记

已于 2022-03-03 14:03:59 修改
阅读量286 收藏
点赞数 2
分类专栏： 笔记 刷题集 文章标签： 动态规划 算法 题解 c++ 学习
于 2022-03-03 13:41:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoyang1123/article/details/123249043
版权

F - Iroha Loves Strings

dp(i, j)表示考虑前i个串，拼成长度为j的字典序最小串。

显然这样状态数n * m,每个状态是一个长度为m的string，不可行。

发现一个性质，如果当前有字典序 dp(i, j) < dp(i, k)【此处的小于定义为严格存在第一个字符不同位置的小于，不包括dp(i, j)是dp(i, k)前缀或相反，之后的比较也是这样】且(i + 1 ~ n)能够拼出一个长度m - j的串（这一步可从后向前做个可行性dp即可），则dp(i, k)显然不可能成为最优答案的前缀。

然后会发现，当前可能的dp值，是某一个串s以及它的一些前缀，这样状态数就可以表示了。

再考虑转移，当前尝试往后拼接串t，等价于能转移到 s的一些前缀（不拼）或者 s的一些前缀 + t, 然后我们要求出字典序最小且之后有解且最长的s',以及它的可能前缀状态。

显然此时我们要支持快速比较串s的前缀、s的前缀+t的字典序大小，有两种做法，一种是哈希之后二分lcp然后比较下一位置，还有一种是Z函数快速查lcp、为O（1）。这里学了一下Z函数：

Z函数也称为扩展kmp，假设现在有一个串s和t，通过一个对t的O（n）时间预处理，之后可以线性时间对串s的每一个下标i，求以s[i]为开头能和串t匹配的最大长度。

具体做法是对t的每一个下标i求其能与t开头匹配的最大长度，求的时候利用一下之前已经求出的信息（类似manacher），匹配的时候同理。
Z函数模板题：

#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define sc second
#define pb push_back
#define ll long long
#define trav(v,x) for(auto v:x)
#define all(x) (x).begin(), (x).end()
#define VI vector<int>
#define VLL vector<ll>
#define pll pair<ll, ll>
#define double long double
//#define int long long
using namespace std;
const int N = 1e6 + 100;
const int inf = 1e9;
//const ll inf = 1e18;
const ll mod = 998244353;//1e9 + 7;

#ifdef LOCAL
void debug_out(){cerr << endl;}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T)
{
	cerr << " " << to_string(H);
	debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

void sol()
{
	string s, t;
	cin >> t >> s;
	int n, m;
	n = s.length();
	m = t.length();
	VI Z(n, 0);
	int lp, rp;
	lp = rp = 0;
	for(int i = 1; i < n; i++)
	{
		if(i <= rp && i + Z[i - lp] - 1 < rp)
			Z[i] = Z[i - lp];
		else
		{
			int k = max(0, rp - i + 1);
			while(i + k < n && s[k] == s[i + k])
				++k;
			Z[i] = k;
		}
		if(i + Z[i] - 1 > rp)
			lp = i, rp = i + Z[i] - 1;
	}
	Z[0] = n;
	ll res = 0;
	for(int i = 0; i < n; i++)
		res ^= 1LL * (i + 1) * (Z[i] + 1);
	cout << res << '\n';
	res = 0;
	lp = rp = -1;
	VI ans(m, 0);
	for(int i = 0; i < m; i++)
	{
		if(i <= rp && i + Z[i - lp] - 1 < rp)
			ans[i] = Z[i - lp];
		else
		{
			int k = max(0, rp - i + 1);
			while(i + k < m && k < n && s[k] == t[i + k])
				++k;
			ans[i] = k;
		}
		if(i + ans[i] - 1 > rp)
			lp = i, rp = i + ans[i] - 1;
		res ^= 1LL * (i + 1) * (ans[i] + 1);
	}
	cout << res << '\n';
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
//	int tt;
//	cin >> tt;
//	while(tt--)
		sol();
}

回到原题，分几类比较情况，需要用到Z函数的地方：比较s(1 ~ a) + t 和 s(1 ~ b) 字典序（b > a）,则就是比较s(a + 1 ~ b) 与t，因此对t预处理Z数组即可。

转移过程可以枚举下一轮长度，维护一个字典序相同，长度逐渐增长的栈，然后应用上述比较即可。

#include<bits/stdc++.h>
#define pii pair<int,int>
#define fi first
#define sc second
#define pb push_back
#define ll long long
#define trav(v,x) for(auto v:x)
#define all(x) (x).begin(), (x).end()
#define VI vector<int>
#define VLL vector<ll>
#define pll pair<ll, ll>
#define double long double
//#define int long long
using namespace std;
const int N = 1e6 + 100;
const int inf = 1e9;
//const ll inf = 1e18;
const ll mod = 998244353;//1e9 + 7;

#ifdef LOCAL
void debug_out(){cerr << endl;}
template<typename Head, typename... Tail>
void debug_out(Head H, Tail... T)
{
	cerr << " " << to_string(H);
	debug_out(T...);
}
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

void sol()
{
	int n, m;
	cin >> n >> m;
	vector<string> a(n);
	for(int i = 0; i < n; i++)
		cin >> a[i];
	vector<vector<bool>> can(n, vector<bool>(m + 1, 0));
	for(int i = n - 1; i >= 0; i--)
	{
		if(i == n - 1)
		{
			can[i][m] = 1;
			continue;
		}
		for(int j = 0; j <= m; j++)
		{
			if(can[i + 1][j] || (j + (int)a[i + 1].length() <= m && can[i + 1][j + a[i + 1].length()]))
				can[i][j] = 1;
		}
	}
	string s = "", t = "", ans = "";
	VI Z, mat;
	vector<pii> stk;
	vector<bool> ed(m + 1, 0);
	ed[0] = 1;
	for(int i = 0; i < n; i++)
	{
		t = a[i];
		stk.clear();
		int ls, lt;
		ls = s.length();
		lt = t.length();
		Z.resize(lt);
		mat.resize(ls);
		int lp, rp;
		lp = rp = -1;
		for(int j = 1; j < lt; j++)
		{
			if(j <= rp && j + Z[j - lp] - 1 < rp)
				Z[j] = Z[j - lp];
			else
			{
				int k = max(rp - j + 1, 0);
				while(j + k < lt && t[k] == t[j + k])
					++k;
				Z[j] = k;
			}
			if(j + Z[j] - 1 > rp)
				lp = j, rp = j + Z[j] - 1;
		}
		lp = rp = -1;
		for(int j = 0; j < ls; j++)
		{
			if(j <= rp && j + Z[j - lp] - 1 < rp)
				mat[j] = Z[j - lp];
			else
			{
				int k = max(0, rp - j + 1);
				while(k < lt && j + k < ls && t[k] == s[j + k])
					++k;
				mat[j] = k;
			}
			if(j + mat[j] - 1 > rp)
				lp = j, rp = j + mat[j] - 1;
		}
		auto small = [&](int x)
		{
			int len = mat[x];
			if(len == lt || x + len == ls)
				return (bool)0;
			return t[len] < s[x + len];
		};
		auto big = [&](int x)
		{
			int len = mat[x];
			if(len == lt || x + len == ls)
				return (bool)0;
			return t[len] > s[x + len];
		};
		auto same = [&](int x)
		{
			int len = mat[x];
			if(len == lt || x + len == ls)
				return 1;
			return 0;
		};
		auto cmp = [&](pii x, pii y)
		{
			if(y.sc == 0)
			{
				if(x.sc == 0 || x.fi >= y.fi)
					return 0;
				int len = mat[x.fi];
				if(x.fi + len >= y.fi)
					return 0;
				if(small(x.fi))
					return -1;
				return 1;
			}
			if(x.sc == 0)
			{
				if(big(y.fi))
					return -1;
				if(same(y.fi))
					return 0;
				return 1;
			}
			int len = mat[y.fi];
			if(y.fi + len > x.fi)
			{
				int ex = y.fi + len - x.fi;
				int le = Z[lt - ex];
				if(le == ex)
					return 0;
				if(t[le] < t[lt - ex + le])
					return -1;
				return 1;
			}
			else
			{
				if(big(y.fi))
					return -1;
				if(same(y.fi))
					return 0;
				return 1;
			}
		};
		for(int j = 1; j <= m; j++)
		{
			if(!can[i][j])
				continue;
			if(ed[j] || (j - lt >= 0 && ed[j - lt]))
			{
				int op = -1;
				if(ed[j] && j - lt >= 0 && ed[j - lt])
				{
					if(small(j - lt))
						op = 1;
					else op = 0;
				}
				else
				{
					if(ed[j])
						op = 0;
					else op = 1;
				}
				pii cur = pii(j - op * lt, op);
				while(!stk.empty() && cmp(cur, stk.back()) < 0)
					stk.pop_back();
				if(stk.empty() || cmp(cur, stk.back()) == 0)
					stk.pb(cur); 
			}
		}
		fill(all(ed), 0);
		ed[0] = 1;
		if(!stk.empty())
		{
			pii cur = stk.back();
			s = s.substr(0, cur.fi);
			if(cur.sc == 1)
				s += t;
			if(s.length() == m)
				ans = s;
			trav(v, stk)
			{
				int len = v.fi + v.sc * lt;
				ed[len] = 1;
			}
		}
		else
			s = "";
	}
	cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);
//	int tt;
//	cin >> tt;
//	while(tt--)
		sol();
}

caoyang1123
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
20180713练习赛 [AtCoder]ARC058-059 EASY
岂曰无衣，与子同袍
08-22 457
A - こだわり者いろはちゃん / Iroha’s Obsession AtCoder - 1973 B - いろはちゃんとマス目 / Iroha and a Grid AtCoder - 1974 C - いっしょ / Be Together AtCoder - 2019 D - アンバランス / Unbalanced AtCoder - 2020 A 水题 ...
iroha：Iroha-一个简单的，分散的分类帐
02-02
什么是Hyperledger Iroha？ Iroha是一种简单的分布式分类帐技术（DLT），受日本Kaizen原则的启发-消除过度性（muri）。 Iroha具有满足您的资产，信息和身份管理需求的基本功能，同时又是满足企业需求的高效且值得...
Iroha Loves Strings II
Stone 不会喝水的博客
01-20 349
问题 : Iroha Loves Strings II 时间限制: 1 Sec 内存限制: 128 MB 题目描述 Iroha has a sequence of N strings S1,S2,…,SN. The length of each string is L. She will concatenate all of the strings in some order, to produ...
ARC#058F Iroha Loves Strings（贪心+字符串处理+dp预处理）
juruo? juruo!
03-09 870
题面在这里 这题网上找不到题解啊。。于是我就自己对着某大佬的ac代码看了inf小时后终于（假装）懂了。。 题意 小C有NNN个字符串s1,s2,s3,...,sNs1,s2,s3,...,sNs_1, s_2, s_3, ..., s_N，并且他准备选择一些字符串顺次连接起来。问所有能得到的字符串中长度为KKK的字典序最小的。N≤2000,K≤104N≤2000,K≤104N ≤ 200...
一：Find Amir 二：Iroha Loves Strings 三： Iroha's Obsession
fanxingxue的博客
04-02 201
Find Amir：链接 题目大意：有n所学校，需要每所学校都走一遍，每两所学校之间的车票费为（i+j)%(n+1) ，学校的起始点与终止点任意，问怎样选择，使车费最低 思路：每次都是选择最靠前的与最靠后的，假设有10所学校，（1+10)%11=0 (2+9)%11=0 以此类推共五组，把这五组接起来，车费为4.例如从10到9 （10+9）%11=1 依次类推共四组 代码： ...
文字列大好きいろはちゃんイージー / Iroha Loves Strings (ABC Edition) （优先队列）...
weixin_30357231的博客
08-04 203
题目链接：http://abc042.contest.atcoder.jp/tasks/abc042_b Time limit: 2sec /Memory limit: 256MB Score :200points Problem Statement Iroha has a sequence ofNstringsS1,S2,…,SN. The length of e...
iroha-api：Iroha API
02-05
iroha-api：Iroha API
iroha-wallet-js:Iroha的钱包申请样例
05-06
Iroha钱包 伊吕波电子钱包是一个例子钱包应用。 Iroha钱包具有以下功能： 使用您的Iroha帐户登录。 查看您的资产和交易。 将您的资产转移到另一个Iroha帐户。入门先决条件首先，您需要有一个Iroha实例。 您可以在...
iroha-nihoheto
02-17
&quot;iroha-nihoheto&quot; 是一个以 C++ 语言为基础的项目，其名称来源于日语，可能是指一种特定的编程理念或者项目代号。这个项目看起来是一个代码样本和试验用的仓库，目的是为了提供学习、实践 C++ 编程的资源。 在深入...
iroha-sample-working
05-12
Iroha示例应用程序这是Hyperledger Hackfest的热身运动-2018年6月您必须克隆此存储库。 它有一个失败的测试，您的任务是更改正在测试的类，以使测试通过。 您应该更改的类位于以下位置： src/main/kotlin/...
ARC058F 文字列大好きいろはちゃん / Iroha Loves Strings dp+贪心
Wolf_Reiser的博客
06-04 1130
给出NNN个字符串，要求选出其中一些串按顺序拼接成一个长度为KKK的串，并且要求拼接串的字典序最小。N≤2000,K≤10000,N≤2000,K≤10000,N\leq2000,K\leq10000, 每个串长度不超过KKK，总长度不超过10610610^6. 设ok[i][j]ok[i][j]ok[i][j]表示最后iii个串，能否组成长度为jjj的字符串. 背包转移即可，可以用bitse...
文字列大好きいろはちゃんイージー / Iroha Loves Strings (ABC Edition) AtCoder - 1978
baku6967的博客
05-02 327
文字列大好きいろはちゃんイージー / Iroha Loves Strings (ABC Edition) AtCoder - 1978 Problem Statement Iroha has a sequence ofNstringsS1,S2,…,SN. The length of each string isL. She will concatenate a...
ARC 058
weixin_30591551的博客
08-22 133
所以为啥要写来着........... 链接 T1 直接枚举大于等于$n$的所有数，暴力分解判断即可 复杂度$O(10n \log n)$ #include &lt;cstdio&gt; #include &lt;iostream&gt; using namespace std; #define sid 15 #define ri register int in...
ARC58F 文字列大好きいろはちゃん / Iroha Loves Strings-暴力+剪枝
Fizzmy的博客
02-06 1324
传送门 题意： 给出n个字符串，要求按给出的顺序选择一些字符串，使得这些字符串按顺序拼起来后长度为k且字典序最小 Solution: 正解目前还不会…先写一波学来的暴力算法： can[i][j]can[i][j]can[i][j]表示后i个是否可以组成长度为j的字符串 先加入初始能加入的串，存入一个数组中 然后顺序枚举答案串的每一位，对于每一位贪心找出最小字典序，对于最优状态...
Iroha Loves Strings (ABC Edition) 题解分析
AkiharaAhi的博客
07-07 273
Iroha Loves Strings (ABC Edition) 题解分析
ARC058 E Iroha and Haiku 状压dp
forever_shi的博客
10-18 284
题目链接 题意： 你现在有n个数，每一个数可以填1到10中的任何一个数，求满足下列条件的序列数量：对于给定的X,Y,ZX,Y,ZX,Y,Z，当一个数组存在0&amp;amp;lt;=x&amp;amp;lt;y&amp;amp;lt;z&amp;amp;lt;w&amp;amp;lt;=N0&amp;amp;lt;=x&amp;amp;lt;y&amp;amp;lt;z&amp;amp;lt;w&amp;amp;lt;=N0&amp;lt;=x&amp;lt;y&amp;lt;z&amp;lt;w&amp;
ARC058 C - Iroha‘s Obsession（暴力）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
05-11 388
题意： 解法： 由于n很小,只有1e4. 我们可以直接从n开始枚举答案,判断答案是否满足条件即可. 容易证明不会枚举太多次. code： #include &lt;bits/stdc++.h&gt; using namespace std; const int maxm=2e6+5; int mp[10]; int check(int x){ while(x){ if(mp[x%10])return 0; x/=10; } return 1;
[arc058d]Iroha and a Grid
不来也不去的一只失忆蝴蝶
11-03 844
题目大意一个矩形，从左上角开始，只能往下或往右走，不经过左下角一个给定大小的矩形，到达右下角的方案数。做法显然可以容斥，统计非法方案，那么枚举左下角矩形最上面一行第一个到达的格子即可。#include<cstdio> #include<algorithm> #define fo(i,a,b) for(i=a;i<=b;i++) #define fd(i,a,b) for(i=a;i>=b;i--)
ARC058 E - Iroha and Haiku（状压dp，状态压缩技巧）
zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz
05-11 242
题意： 解法： d[i][2][2][2][j] 长度为i, 是否满足条件1 是否满足条件2 是否满足条件3 当前和为j的方案数. 对于长度为i的合法子数组, 还可以在左右两边添加n-i个数, 用组合数学计算一下贡献就行了, 但是深入思考之后发现这样会重复计算, 因为左右两边随便放可能也会组成满足条件的方案. --- 正着做不好计算,考虑反过来计算: 用总方案数减去不合法方案数, 总方案数显然为10^n. 如何计算不合法方案数: 令d[i][s]表示长度为i的序列,末尾状态为s的方案数, 其中s
区块链系统性能测试流程
最新发布
08-23
一个常用的区块链性能测试框架是Caliper，它可以测试不同的区块链实现，如fabric、sawtooth和Iroha。通过性能测试，可以评估区块链系统在处理交易、执行智能合约等方面的性能指标。 可靠性测试是测试区块链平台在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值