AtCoder Beginner Contest 324 E + F

E - Joint Two Strings

题意

有 $N$ 个只包含小写字母的字符串 $S_1...S_N$，可以形成 $N^2$ 个有序对 $(i,j)$，问有多少个字符串 $S=S_i+S_j$ 满足：

• 字符串 $T$ 是 $S$ 的子序列（非连续的字母）

思路

我们可以维护两个数组 $A$ 和 $B$ ，其中：

• $A_i$ 表示 $S_i$ 包含的最长 $T$ 的前缀字母个数
• $B_i$ 表示 $S_i$ 包含的最长 $T$ 的后缀字母个数

那么对于 $S=S_i+S_j$，只要 $A_i+B_j\ge |T|(T的长度)$ 即可，这样子 $T$ 就是 $S$ 的子序列了。

所以我们可以枚举第 $i$ 个字符串为前缀，那么后缀的 $B_j$ 只需要满足 $B_j\ge |T|-A_i$ 即可，符合条件的 $j$ 的个数就是以 $i$ 为前缀的答案。可以直接二层循环来寻找答案，这样子的时间复杂度是 $O(N)$ 的，因为已经确定了前缀的长度，那么后缀的长度其实已经确定了一个区间范围，最后可以证明遍历的长度不会超过字符串总长度 ${\sum }_{i=1}^n|S_i|\le 5\times 10^5$：

时间复杂度为：${\sum }_{i=1}^n{\sum }_{j=|T|-A_i}^{|T|}cnt[j]$，$cnt[j]$ 是后缀长度为 $j$ 的字符数量
$={\sum }_{i=1}^n(|T|-(|T|-A_i)+1)$
$={\sum }_{i=1}^n(A_i+1)$
$={\sum }_{i=1}^n{A}_i$
$\le 5\times 10^5$

AtCoder 的原证明

// Problem: E - Joint Two Strings
// Contest: AtCoder - Japan Registry Services (JPRS) Programming Contest 2023 (AtCoder Beginner Contest 324)
// URL: https://atcoder.jp/contests/abc324/tasks/abc324_e
// Memory Limit: 1024 MB
// Time Limit: 2000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n' 

const int INF=0x3f3f3f3f;
const long long INFLL=0x3f3f3f3f3f3f3f3fLL;

typedef long long ll;

const int N=500005;

std::string s[N];
int a[N];
int b[N];
ll cnt[N];

int cal(const std::string& s,const std::string& T){
	int idx = 0;
	for(auto c : s){
		if(c == T[idx])	++idx;
		if(idx == (int)T.size())	break;
	}
	return idx;
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n;
    std::string T;
    std::cin>>n>>T;
    fore(i,1,n+1){
    	std::cin>>s[i];
    	a[i] = cal(s[i],T);
    }
    reverse(T.begin(),T.end());
    fore(i,1,n+1){
    	reverse(s[i].begin(),s[i].end());
    	b[i] = cal(s[i],T);
    }
    fore(i,1,n+1)	++cnt[b[i]];
    
	ll ans = 0;
    fore(i,1,n+1){ //枚举每一个s[i]来做前缀
    	int len = (int)T.size() - a[i]; //后缀最起码的长度
    	fore(j,len,T.size()+1)	ans += cnt[j];
    }
    std::cout<<ans;
	return 0; 
}

---

F - Beautiful Path

题意

有一张有向图有 $N$ 个节点和 $M$ 条边，每条边有 漂亮值 $b_i$ 和 花费 $c_i$
对于每一条边，都有 $u_i<v_i$，即：只有从小节点到大节点的边
问从 $1\to N$ 的路径中 $\frac{\sum b_i}{\sum c_i}$ 最大 的值是多少？

思路

非常典型的 $01$ 分数规划，可以设 $\frac{\sum b_i}{\sum c_i}\ge x$，只要找到最大的 $x$ 就是答案。移项得：$\sum b_i-x\cdot \sum c_i\ge 0$
故我们可以把边权改为 $b_i-x\cdot c_i$，只需要跑一条最大路径即可。

由于答案的上界 $2\times 10^9$ 和下界精度 $10^{-9}$ 之间差了大概 $2^{60}$ 倍，因此二分次数设置成 $70$ 次就差不多了。

如果用 $Dijkstra$ 来跑最大路，时间复杂度是 $70\cdot M\cdot logN\approx 2\times 10^8$ 会 $TILE$

这里有个小 $Tips$:

由于这张图的特殊性，只有从小点到大点的边，所以这是一个 $DAG$，那么跑最大路时，可以依次遍历所有的节点，并更新这个节点对后面的贡献。有点像拓扑排序，当前扫到的节点 $i$ 前面的所有点到 $i$ 的路径一定都被查看过了。时间复杂度就是：$O(N+M)$

正确的时间复杂度：$O(70\times (M+N))$

// Problem: F - Beautiful Path
// Contest: AtCoder - Japan Registry Services (JPRS) Programming Contest 2023 (AtCoder Beginner Contest 324)
// URL: https://atcoder.jp/contests/abc324/tasks/abc324_f
// Memory Limit: 1024 MB
// Time Limit: 5000 ms
// 
// Powered by CP Editor (https://cpeditor.org)

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n' 

const int INF=0x3f3f3f3f;
const long long INFLL=0x3f3f3f3f3f3f3f3fLL;

typedef long long ll;

const int N=200005;
int n,m;
const double eps = 1e-15;

struct node{
	int to;
	double b;
	double c;
};
std::vector<node> g[N];

bool check(double x){
	std::vector<double> d(n+1,-1e20);
	d[1] = 0;
	fore(u,1,n)
		for(auto [v,b,c] : g[u])
			d[v] = std::max(d[v],d[u] + b - x*c);
	return d[n] >= 0;
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    std::cin>>n>>m;
    double l = 0 , r = 2e9;
    fore(i,0,m){
    	int u,v;
    	double b,c;
    	std::cin>>u>>v>>b>>c;
    	g[u].push_back({v,b,c});
    }
    double ans = 0;
    fore(i,0,70){
    	double mid = (l+r)/2.0;
    	if(check(mid)){
    		ans = mid;
    		l = mid;
    	}
    	else r = mid;
    }
    std::cout<<std::fixed<<std::setprecision(15)<<ans;
	return 0; 
}