其实很容易解决，只需要使用一个叫 DAVx⁵ 的开源软件即可。
在 Apple 账户 管理页面中添加一个应用密码，再在 DAVx⁵ 中选择 “使用 URL 和用户名登录”，URL 填写 https://icloud.com，账号填写 iCloud 账户， 密码填写刚才的应用密码，即可同步。
接下来注意如果要把安卓手机本地的日历同步到 iCloud，需要在日历软件中使用 iCloud 账户下的分类新增日程。
原来在手机上的日程无法自动同步。
效果大概是这样：
其实很容易解决，只需要使用一个叫 DAVx⁵ 的开源软件即可。
在 Apple 账户 管理页面中添加一个应用密码，再在 DAVx⁵ 中选择 “使用 URL 和用户名登录”，URL 填写 https://icloud.com，账号填写 iCloud 账户， 密码填写刚才的应用密码，即可同步。
接下来注意如果要把安卓手机本地的日历同步到 iCloud，需要在日历软件中使用 iCloud 账户下的分类新增日程。
原来在手机上的日程无法自动同步。
效果大概是这样：
回学校领毕业照和档案，一草一木似乎还是那么亲切，只是没看见那些更亲切的人。
凭我这孱弱的记忆力，高中的经历也会很快成为感性的、抽象的情绪记忆，而非理性的、具象的事件记忆……或许也并非坏事。
高考这两个字确实因为其结束而降格为意识中的符号了，但这不意味着其重量的流逝。反而潜意识中的重视让它在梦里出现，以不愉快的形式。
谈谈 2025 年的那个 6 月 7 号、6 月 8 号和 6 月 9 号吧。
那是三天苦中作乐的日子：
精神压力导致的恶心和胃部不适在不时发生着，熟悉而温暖的中成胃药并起不到安慰剂的作用。之所以归结为精神压力原因，是因为胃镜告诉我胃本身问题不大，这份不适又确实在高考之后迅速缓解。于是我在考试时多了份工作：对抗突如其来的呕吐欲、用方巾阻挡恶心所致咳嗽的飞沫。
但我仍把这场考试称之为乐，因为精神压力只存在于潜意识中，我并没有把考试认作为一件困难而有障碍的事，我也并没有太大的发挥失常。只是很中规中矩的一次考试——就像高三考过的 20 次模拟考一样。
我在考试后既痛骂试卷出得诡异，又感谢这份确定的不稳定发生在我面前，因为我期待一场不平凡的高考。
我没有在我喜欢的数学上取得太大优势，但反思后我觉得这很正常。我考前太过不屑于限时思考数学题了，我喜欢上了单纯解出题目的感觉。偏偏这次的试卷要拿到高分的思考量，超出我的限时训练负荷。
我没有把英语考出该有的水平，我更讨厌提起这件事。我错了三道阅读，每道都有些一念之差的感觉。我相信自己把文章读得很懂。但我到了高考时竟然还是无法稳定读懂题目考点，即使模拟考中往往能读懂。
语文也错了三道选择题，语用占两道。这是在 20 次模拟考中从未有过的。但我反倒不是很在意这个，因为语文题让我答得顺心，考前心心念念的背诵默写也都写对了。
写到这里，剩下的三科也没什么必要一一回忆了：它们都没有很差，但都差了一点。
其实我把五月过得太过死气沉沉，没有那种迎接挑战的心气，我也不知道是为什么。也许是累了，也许是无法忍受重复的生活了，于是把生活过得更加重复。
高考后参加两个学校的综评，我很开心，因为它们让我有一种久违的被认可的感觉。
我没有去复旦的强基，我知道我考不上。
南科大的综评很中规中矩，笔试面试都比较无聊。面试基本在描述高中的经历而非输出观点，这还相对容易一些。 倒是最后反向询问的环节，问了面试老师学校人文氛围会不会不好，老师解释了好几分钟，有点替学校证明自己的意味，还挺好玩。
港中深的综评非常有趣，差点导致了我激情填报它：让我写得酣畅淋漓的中英文写作、让我走出舒适区的无小组英文辩论、戳中我审美的校区建筑风格…… 尤其是校园随处可见的“走路不看手机”标语真真切切地提醒到了我，我喜欢这样可爱的人文关怀。我最后的综评排名是物理类第 19 名，这某种程度上让我觉得 我适合这所学校。
然最后反复思虑，还是在中流 985、港中深、南科大中选择了南科大。具体原因倒也难以具象化，不过我总觉得思虑后的感性才是对我来说做大决定的最好方式。
这个夏日，我过得很愉快。我相对来说很早就知道了我会被什么大学录取。我和我喜欢的人一起待了很多地方。福州、厦门、漳州、兰州、西宁、张掖…… 时间规划几乎自由、预算并不吃紧的旅行真是让人心旷神怡。
这 18 年来，尤其是高中三年，我已然走过了中国的不少地方。我很开心，我的世界从不因局部压力而变得狭窄。
地图的可交互版本在 这里，这里也会实时更新我去过的地方。
大概写这么多吧。很期待接下来的大学生活！我要学会很多东西，弄清楚未来自己真正想干什么，这感觉不太简单，但确很有必要。
祝自己万事顺遂。
]]>水汽凝聚在天上
我知道
该是燃一把火的时候了
赶在下雨之前
湿漉漉的干草堆在脚下碾碎
不可触及的是天圆地方的棉
既然被光染上它不存在的颜色
就借着光把它烧尽吧
欣赏幻象中的
不可复制的烟火
于是起舞
于干燥而浑浊的天地间
等待野火烧不尽的
云的轮回
]]>随便找了个模板，转换卡片类型单一、没有数学公式的牌组固然很好，但复杂一点的就出现问题了。
怎么办呢？首先我发现如果直接在模板里写死各种字段，若当前卡片没有找到这个字段，会出现提示 “## field … not found ##”
这个就是插件本身的问题了。正好 Anki 的插件是用 python 编写的，遂直接找源代码进行修改。
这个插件位于 C:\Users\用户名\AppData\Roaming\Anki2\addons21\1897277426\ExportDeckToHtml.py，我们搜索找到产生提示的子段
try:
value = card.note()[field[2:-2]]
key += value
except KeyError:
value = '## field ' + field + ' not found ##'
直接改成
try:
value = card.note()[field[2:-2]]
key += value
except KeyError:
value = ''
并且我发现在导出含图片的卡片时，出现了一些 bug，图片会把文字内容覆盖掉。查阅了插件的实现之后，我发现这又是插件写法的问题。 插件作者是用如下代码处理图片的：
pictures = re.findall(r'\<img src="(.*?)"', value)
if len(pictures):
img_tmp = '<img src="%s">'
value = ""
for pic in pictures:
full_img_path = join(
collection_path, pic)
img_tag = img_tmp % full_img_path
value += img_tag
key += value
content += value
card_html = card_html.replace(field, value)
value 变量本来存着这个字段的所有信息，这样处理一下，value 当然就变成只剩图片了。
这段代码的原逻辑有点不好改，用处就是把 Anki 卡片里存的图片的相对路径，改成绝对路径。
作者可能也是对正则表达式不熟练，只能这样粗糙地处理。其实，只要把这一整段改成下面两句即可。
value = re.sub('(?<=\<img src=").*?(?=")', lambda matched : join(collection_path, matched.group(0)), value)
card_html = card_html.replace(field, value)
这样效果很完美。
然后在模板网页里用 javascript 和 css 简单处理一下表格的着色、数学公式的渲染、填空题的显示，即可完成。
<head>
<meta charset="UTF-8">
<script type="text/x-mathjax-config">
MathJax = {
tex: {
inlineMath: [['$', '$'], ['\\(', '\\)']]
},
svg: {
fontCache: 'global'
}
};
</script>
<script type="text/javascript" id="MathJax-script" async
src="https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-svg.js">
</script>
<style>
table {
font-family: "Book Antiqua", "宋体";
font-size: 13px;
color: #000000;
border-width: 1px;
border-color: #000000;
border-collapse: collapse;
width: 100%;
}
@media print {
tr:nth-child(odd){
background-color: #dfdfdf ;
}
}
tr:nth-child(odd){
background-color: #dfdfdf ;
}
td, th {
border-width: 1px;
padding: 8px;
border-style: solid;
border-color: #000000;
}
img {
max-width: 50%;
height: auto;
}
</style>
<script>
window.onload = function() {
var bs = document.getElementsByTagName("span");
for(var i = 0; i < bs.length; i++) {
if(bs[i].style.backgroundColor != "") {
var par = bs[i].parentNode;
bs[i].style.backgroundColor = par.style.backgroundColor;
}
}
var texts = document.getElementsByTagName("td");
for(var i = 0; i < texts.length; i++) {
var text = texts[i].innerHTML;
var rep = text.replace(/{{c[1-9]::(.*?)}}/g, "<p style=\"color: rgb(0, 0, 255); display: inline; text-decoration: underline; \">$1</p>");
texts[i].innerHTML = rep;
}
}
</script>
</head>
<body>
<table>
<tr>
<td>{{正面}}{{文字}}{{Text}}</td>
<td>{{背面}}{{背面额外}}</td>
</tr>
</table>
</body>最后贴一张解决了上述各种坑点的效果图：
夜里的梦，也是白日梦。
2024.4.13 记梦
缝补解剖 渡河行岛 依稀水中远行
依序打卡 旅伴失散 挤压阁楼休憩
是指北针的无用 是地图的璀璨
是世界的风景线 是露珠攀上岩
有呜咽 有血肉 那无畏和心碎
有可爱 有可敬 那虚无和美满
白鸟绕林 山河环岛
是海中有岛 或岛中有海
老板 来一杯酒
洗去记忆中的尘世污浊
唯有精神中的印记
与毫不理性的留恋
超载 2024.5.2
不知不觉 行至渡口
身前是汹涌斜曲的江流
身后是苍茫模糊的大地
船老大说
不是所有人都能上船
卸下行囊 站上码头
虚无填满我的行囊
理想弥散我的身体
船老大说
我们不渡迷茫的人
造船 撑船 乘风破浪
诡谲的水波
深沉的亡灵
我带了违禁品
江流要销毁它们
取缔超载的小船
我不会游泳
祈祷
祈祷我走了正确的路
]]>对于那些主要面向国内用户的网站，自然首选国内服务器，这就存在一个备案的问题。虽然据说备案本身并不困难，但这其实加了一层拘束，比如要保持网站在线、服务器和域名都要在国内备案、要时刻小心被封禁等。
鉴于我的域名是在 Namesilo 上面买的，自然无法进行备案，也就只能选择墙外的服务器，这里选择硅云的香港服务器，最低配，活动价 219 CNY/年。只是后面由于自己开发过程遇到了些难以解决的问题，误认为服务器配置需要提升，花了一些活动价以外的冤枉钱提升带宽和内存。其实这是缺乏常识导致的额外消费，我部署的简单应用根本不需要多好的配置。总的来说这个活动价还是不错的。
根据不同的需求，可以在网上查找最新的服务器活动信息，关注优惠，毕竟小型的网站和项目迁移起来还是比较简单的，一年以后再换新的也不是什么难事。
初始化之后，几经周折，我最后使用 vscode 中的 SSH 插件来连接云服务器，这样连接的好处就是可以直接用 vscode 编辑各种文件，环境也是熟悉的，非常舒服。
安装了 nginx 等必要的软件后，就可以开始部署网站了。
安装 git，然后使用 git pull 把 github 上的网页源码拉取到云服务器上。
这里我的 blog 使用 jekyll 作为生成器，所以需要先后安装 ruby 和 jekyll，这个虽然比较麻烦，但是相比于 windows 上安装还是快很多、省心很多。
安装之后在本地生成一下静态博客，可以放到 /var/www/ 里面，作为之后配置要用的网站文件位置。
在 /etc/nginx/nginx.conf 的 http 子段中，添加：
server {
listen 80;
server_name {域名};
rewrite ^(.*)$ https://$host$1 permanent;
location / {
root {网站文件位置};
index index.html index.htm;
}
}
server {
listen 443 ssl http2;
server_name {域名};
ssl_certificate {证书位置};
ssl_certificate_key {证书位置};
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:1m;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_protocols TLSv1.2;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305;
ssl_prefer_server_ciphers on;
location / {
root {网站文件位置};
index index.html index.htm;
}
}
域名可以先填服务器公网 ip 进行测试，然后把域名解析到这个公网 ip 上，再尝试访问。
这里给出的 nginx 配置文件是最简单的版本，没有针对不同网站拆分出不同的配置文件，且针对静态网站。
这里做了一个强制 https 访问。我的 ssl 证书使用了 acme.sh 进行 freessl 证书的自动签发。
到这一步的过程中，好像还出现了挺多差错的，不过都通过搜索解决了。这里就不展开了。
这个其实有很多方法，比如说在云服务器上自己建立一个 git 远程仓库是一个不错的选择。
但我想保留 github 上面的备份，把 github 作为一个中转站，以便日后再次迁移。
于是，我找到了这样一个方案：在云服务器上创建一个 API，每次 POST 请求这个 API，就自动执行“从github上拉取”和“用jekyll渲染博客”这两件事。
然后通过 github 的 webhook 功能，可以建立一个每次 push 就 trigger 的 webhook，让他每次收到 push 就请求一下这个接口。这样就实现了自动同步。
具体实现，可以查看我参考的文章 利用Git Webhooks实现jekyll博客自动化部署。
我还用这个云服务器搭建了一个 hypixel 的加速 ip，这是一个知名的 minecraft 国际小游戏服务器。
这应该会持续运行一年左右，只需要在 minecraft 多人游戏中加入 hypixel.joyslog.top 即可使用。
出分了之后大概还会有一篇生涯回顾。
慎重考虑后决定今年停两周，包括免考半期考！这样的话暂时就可以全身心投入训练了。
可惜班主任不同意，说是要参加六科的考试，不然影响我们的学习状态。可能还是我们班竞赛的太少了吧，完全没有照顾，停课了也不会给我们录课，而钱一班就有录课看。而且对于他们来说，信竞还是所有竞赛中退役最早的，所以他们课表里还会继续排竞赛课，对他们来说就是自习了。真好。
后来还是找老师说理然后成功免考了。最会让步说理的一集。
两周打了 8 场左右的模拟赛，每天都把自己能订正的题订正了下，也补了不少题，还打了一场 ABC，vp 了一些 CF。感觉赛场水平还是没有长足进步，不过见过的套路正在逐渐变多。
有时候，做不出题，想不出正解灵感的来源和理由，总是会有些挫败感，觉得自己为啥想不到，为啥写不出来，是不是真的太笨了，反应太慢了。这时只能安慰自己：你学的如此之晚，停课训练如此之少，既不是天赋怪，又没有拼命努力学，那么没见过各种转化，没学过一些想法和算法，所谓的“降智”再正常不过了。
周四上午打了完整的一场模拟赛，考到 13：00，考完出去吃饭，发现大家都聚在一家兰州拉面店。于是聚餐，我点的红烧牛肉盖饭还挺好吃的。
下午我校 22 人直接入侵附中试机，体验下来就是他们机子更换之后性能很好，上拍一点都不卡，打开大样例也完全不会死机，不像本校 Linux 极其容易卡。
那天阳光十分美妙，让我感到附中的空气比三中香甜。试机之后正好遇到他们在打篮球段赛。
那天，风呼啸地吹着，青春碰撞着初冬，绽放出不可复制的浮光。
没有模拟赛了。上午打板子，发现欧拉路径板子写挂了，非常神秘，有一个纳入答案顺序的问题，改了就 $100\to 20$ 分。和同学讨论之后发现确实要在遍历完所有出边之后把答案入栈，否则形成不了欧拉路径，这个和 dfs 本身的特质有关。
下午做各种 dp。一个线段树优化 dp，一个单调队列优化 dp，还看了几题背包和树 dp 啥的。有些题看了之后加到做题计划里，估计高中剩余时间都不会动了。
各种原因导致，晚上紧张，瞎想，大哭，心悸，泪流不止。但还是早睡了。
早上不用闹钟就醒了。上附中的路堵住了，所以只能早早下车快步走到校门口，到的时候已经 $8:05$ 了。
$8:30$，准时下发密码，先敲了缺省源，然后调了下编辑环境。开 T1。考虑数据范围，需要一个 $\mathcal{O}(n m)$ 的解法，但考虑 CCF 的机子，感觉挂个 $\log$ 也无所谓。这题思路显然，排序之后把当前字典序最小的态和剩余的字典序最大的态分别做比较，暴力做是 $\mathcal{O}(n^2 m)$ 的。然后大部分人写了个预处理最小的最大态直接过了，但我写了个没见过有人写的傻逼做法，就是预处理哈希，然后倍增地跳相同的前缀，把单次比较变成 $\log$ 的。这样大概也能过，就是有点傻。没上拍，希望不要挂。
$9：25$，开 T2。最浪费时间的一题。感觉这玩意挺好转化成图论的，但是没有细想，因为感觉部分分很多，所以就一个一个开特殊性质。然后发现口胡的 U+ 和 +- 两个性质的做法复杂度都假了，最接近正解的并查集做法写挂，由于此时已经 $11:00$，只能转而写 $\mathcal{O}(n^2)$ 用 dfs 暴力判连通块是否要填 U。最后写了 4k，估计只有 $60pts$。这题给性质都拍上了几千组，但好像测的东西太小了。希望不要挂。
$11:15$，开 T3。特殊性质贪心想假了，摆烂。跳过。没想小范围 dp，简单分讨一下拿 $10pts$ 走人。
$11:45$，开 T4。看上去 $\mathcal{O}(n^2)$ dp 十分可做。于是随便设计状态，设 $f_{i,j,0/1}$ 表示前 $i$ 天，已经连续打卡 $j$ 天，当天打不打卡的最大能量值。乱写转移，发现样例 2 没过。然后重构了一下，调到 $12:30$，过了样例 2/3。这玩意看上去容易用数据结构优化，但没时间想了。最后也懒得滚动数组了，拼一个特殊性质 B 走人。如果没写假的话就有 $44pts$。
感觉考试策略有点小问题。T2 写了太久，一直对着十几二十分调，有点亏，其实 T3 的暴力 dp 三十五分更好拿。但不重要了。
出来发现今年本校咋这么强。hy233 又 AK 了。三百分以上的似乎有三四个。不会今年真有校线吧？祝三中 OIer 都前途无量。苯人不管这场考的怎样都要退场了，就算超常发挥也挤不进队线，何况今天只是普通的发挥水平。所以无所谓啦。
好好调整一下，重新起航，卷入文化课的漩涡吧 ^_^。
以上。
]]>给你一个 $n$ 个点，$m$ 条边的无向连通有权图，将其中任意不同两点的距离从小到大排列。
求这个排列中第 $k$ 个元素的大小，也即图中第 $k$ 短的最短路。
$n\le 2\times 10^5, k\le 400$
$k$ 很小，从它入手。
注意到直接选前 $k$ 短的边建新图，答案一定在新图产生，因为边权为正，如果多加了一条边，路径长度必然增加，而前 $k$ 短的边已经控制了第 $k$ 短的最短路的长度的上限，不会再增加了。
那么对于新图枚举起点做最短路即可。
时间复杂度 $O(k^2\log k)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, int> pii;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 2e5 + 10, MAX_K = 400 + 10;
const ll INF = (1ll << 60);
int n, m, k, tot, cnt, ecnt, fir[MAX_N], id[MAX_N];
ll D[MAX_N], res[MAX_N + MAX_K];
bool vis[MAX_N], used[MAX_N];
struct Ed {
int u, v, w;
Ed(int _u = 0, int _v = 0, int _w = 0) :
u(_u), v(_v), w(_w) { }
bool operator < (const Ed &t) const { return w < t.w; }
} edges[MAX_N];
struct edge {
int v, w, nxt;
edge() { }
edge(int _v, int _w, int _nxt) :
v(_v), w(_w), nxt(_nxt) { }
} E[MAX_N];
void AddEdge(int u, int v, int w) {
E[++ecnt] = edge(v, w, fir[u]);
fir[u] = ecnt;
}
void dijkstra(int s) {
for(int i = 1; i <= tot; i++)
D[i] = INF, vis[i] = false;
D[s] = 0;
priority_queue<pii, vector<pii>, greater<pii>> q;
q.push(make_pair(0, s));
while(!q.empty()) {
int u = q.top().second;
q.pop();
if(vis[u]) continue;
vis[u] = true;
for(int i = fir[u]; i; i = E[i].nxt) {
int v = E[i].v, w = E[i].w;
if(D[u] + w < D[v]) {
D[v] = D[u] + w;
q.push(make_pair(D[v], v));
}
}
}
}
int main() {
freopen("graph.in", "r", stdin);
freopen("graph.out", "w", stdout);
n = read(), m = read(), k = read();
for(int i = 1; i <= m; i++) {
int u = read(), v = read(), w = read();
edges[i] = Ed(u, v, w);
}
sort(edges + 1, edges + m + 1);
for(int i = 1; i <= k; i++) {
int u = edges[i].u, v = edges[i].v, w = edges[i].w;
if(!used[u]) {
used[u] = true;
id[u] = ++tot;
}
if(!used[v]) {
used[v] = true;
id[v] = ++tot;
}
AddEdge(id[u], id[v], w);
AddEdge(id[v], id[u], w);
}
for(int i = 1; i <= tot; i++) {
dijkstra(i);
for(int j = i + 1; j <= tot; j++)
res[++cnt] = D[j];
if(cnt > k) {
sort(res + 1, res + cnt + 1);
cnt = k;
}
}
write(res[k]), putchar('\n');
fclose(stdin);
fclose(stdout);
return 0;
}
给一棵 $n$ 个点的树，每个点有一个权值 $w_i$。
你每次可以选取树上的一个点集，要求点集中的每个点不能是另一个点 的祖先，而选出点集的代价为点集中权值最大点的权值。
问将所有点都选一遍的最小代价为多少，每次选的点集不能包含之前已 经被选过的点。
$n\le 2\times 10^5$
考虑若树是一条链，该怎么做。此时若树根是链的一端，则只能一个一个选。否则树根在链的中间，则只能每次从根的左右各选一个。要让代价最小，我们要贪心地把左的最大和右的最大配对。
考虑一般情况，那就和链上有点像，对于每个节点 $u$，维护一个 $u$ 的子树中可选的最优解集 $E_u$。这个集合显然可以从它的儿子节点中合并而来。只需要把子树两两合并，且每次配对后只保留两个最大值中较大的那一个进入新的最优解集，最后并上这个节点本身的权值。
但复杂度不太对，这么做最坏是 $\mathcal{O}(n^2 \log n)$。换成启发式合并就可以变成正解 $\mathcal{O}(n\log n)$ 的。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 2e5 + 10;
int n, cnt, M[MAX_N], tmp[MAX_N];
ll ans;
vector<int> G[MAX_N];
multiset<int, greater<int>> E[MAX_N];
void dfs(int u) {
for(int v : G[u]) {
dfs(v);
cnt = 0;
if(E[u].size() < E[v].size()) swap(E[u], E[v]);
while(!E[v].empty()) {
tmp[++cnt] = max(*E[u].begin(), *E[v].begin());
E[u].erase(E[u].begin());
E[v].erase(E[v].begin());
}
while(cnt) E[u].insert(tmp[cnt--]);
}
E[u].insert(M[u]);
}
int main() {
n = read();
for(int i = 1; i <= n; i++)
M[i] = read();
for(int i = 2, fa; i <= n; i++) {
fa = read();
G[fa].pb(i);
}
dfs(1);
for(int v : E[1])
ans += v;
write(ans), putchar('\n');
return 0;
}
我们称一棵权值为 $w$ 的树是 “好的”，当且仅当：
它的若干个（至少 $2$ 个）子树均为权值、结构相同的 “好的” 树，且权值和不超过 $w$。
称 “浪费的权值” 为 $w-$ 子树权值和，浪费的权值和 $<$ 子树个数。
特别地，一个点被视作权值为 $1$ 的 “好的” 树。
你需要求出权值为 $n$ 的，“好的” 树的形态数量。
$n \le 10^9$
显然考虑 dp，我们设 $f_w$ 为权值为 $w$ 的，“好的”树的形态数量。边界情况为 $f_1=1$。则枚举它的子树的个数 $i$ 和权值大小 $k$，暴力转移如下：
\[f_w=\sum_{i=2}^w \sum_{k=1}^{w} f_k\]暴力转移同时判断状态是否满足题意，时间复杂度 $\mathcal{O}(n^3)。$
考虑题目条件的另一种表达方式：$w=i\times k+p$，其中 $p$ 为 “浪费的权值”，所以 $k< i$。
这里可以看出很像余数的表达形式。即 $p$ 为余数，$k$ 只有一种取值，为 $\lfloor \frac{w}{i}\rfloor$。所以转移方程可以重新写出：
\[f_{w}=\sum_{i=2}^w f_{\lfloor \frac{w}{i}\rfloor}\]那么这个就是整除分块能做的事了。时间复杂度直线掉到 $\mathcal{O}(n\sqrt n)$。
然后本题可以证明，如果我们只需求出 $f_n$，则有用的状态并不多，大概级别为 $\mathcal{O}(n^{\frac{3}{4}})$。所以记忆化搜索可以过本题。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
int n;
unordered_map<int, ll> f;
ll dfs(int x) {
if(f[x]) return f[x];
ll res = 0;
for(int l = 2, r; l <= x; l = r + 1) {
r = min(x, x / (x / l));
res += dfs(x / l) * (r - l + 1);
}
return f[x] = res;
}
int main() {
n = read();
f[1] = 1;
write(dfs(n));
return 0;
}
共 $n$ 个人有顺序地站在宽度为 $W$ 的街道上，每人有一个宽度 $w_i$。
两个相邻的人宽度之和不超过街道宽度时，他们可以交换前后位置。
你需要统计出人群有多少种站位方式。答案对 $998244353$ 取模。
$n\le 10^6$
考虑比较特殊的两个人，宽度最小的人 $u$ 和宽度最大的人 $v$。分成两种情况考虑：
如果 $w_u + w_v\leq W$，则发现 $u$ 可以在 $1\sim n$ 上随便走。那我们可以把 $u$ 从人群中删掉，答案乘 $n$，然后继续计算。
如果 $w_u+w_v > W$，则发现 $v$ 完全动不了。所以不考虑 $v$ 的贡献，只需要分治计算 $v$ 左右的答案，乘起来即可。
然后发现，我们每一轮都可以至少扔掉一个人的影响。所以只会执行 $n$ 轮。每次需要找区间最小和最大，还需要考虑单点删除，所以用线段树维护即可。时间复杂度 $\mathcal{O}(n\log n)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1e6 + 10, INF = (1 << 30), MOD = 998244353;
int n, W, w[MAX_N];
struct node {
int mx, mxpos, mn, mnpos, delnum;
node(int _mx = -INF, int _mxpos = -1, int _mn = INF, int _mnpos = -1, int _delnum = 0) :
mx(_mx), mxpos(_mxpos), mn(_mn), mnpos(_mnpos), delnum(_delnum) { }
} d[MAX_N << 2];
inline int lc(int p) { return (p << 1); }
inline int rc(int p) { return (p << 1) | 1; }
inline int mid(int s, int t) { return s + ((t - s) >> 1); }
inline node U(node L, node R) {
node ret;
ret.mx = max(L.mx, R.mx);
ret.mxpos = L.mx > R.mx ? L.mxpos : R.mxpos;
ret.mn = min(L.mn, R.mn);
ret.mnpos = L.mn < R.mn ? L.mnpos : R.mnpos;
ret.delnum = L.delnum + R.delnum;
return ret;
}
inline void pu(int p) { d[p] = U(d[lc(p)], d[rc(p)]); }
void build_tree(int s, int t, int p) {
if(s == t) {
d[p] = node(w[s], s, w[s], s, 0);
return;
}
int m = mid(s, t);
build_tree(s, m, lc(p));
build_tree(m + 1, t, rc(p));
pu(p);
}
void del(int s, int t, int pos, int p) {
if(s == t) {
d[p] = node();
d[p].delnum = 1;
return;
}
int m = mid(s, t);
if(pos <= m) del(s, m, pos, lc(p));
else del(m + 1, t, pos, rc(p));
pu(p);
}
node query(int s, int t, int l, int r, int p) {
if(l <= s && t <= r) return d[p];
int m = mid(s, t);
node ret;
if(l <= m) ret = U(ret, query(s, m, l, r, lc(p)));
if(r > m) ret = U(ret, query(m + 1, t, l, r, rc(p)));
return ret;
}
ll solve(int l, int r) {
if(l >= r) return 1;
node P = query(1, n, l, r, 1);
if(P.mnpos == -1) return 1;
if(P.mn + P.mx <= W) {
del(1, n, P.mnpos, 1);
return solve(l, r) * (r - l + 1 - P.delnum) % MOD;
}
else return solve(l, P.mxpos - 1) * solve(P.mxpos + 1, r) % MOD;
}
int main() {
n = read(), W = read();
for(int i = 1; i <= n; i++)
w[i] = read();
build_tree(1, n, 1);
write(solve(1, n));
return 0;
}
给你一个只包含’+’、’-‘、正整数的式子，你需要在式子中添加一些括号，使运算结果最大，输出最大的结果。
$n\leq 10^5$
考虑贪心。
首先在加号后面添括号是毫无意义的。假设我们现在要在某个减号后面添括号，考虑它的最大贡献。考察一个例子：
\[a_1-a_3+a_4+a_5-a_6+a_7-a_8+a_9\]我们尝试在第一个负号后面添加括号。
\[a_1-(a_3+a_4+a_5-a_6+a_7-a_8+a_9)\]这样添加，看来 $a_3,a_4,a_5$ 的贡献只能为负了。但是对于后面的数，我们这样添加括号：
\[a_1-(a_3+a_4+a_5-(a_6+a_7)-(a_8+a_9))\]所以括号里的第一个负号后面的贡献都能为正。容易发现，这是在第一个负号后添加括号，能得到的最好结果。
那么枚举在第几个负号后面添加减号即可。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {
ll ret = 0, w = 1; char c = getchar();
while(!isdigit(c)) { if(c == '-') w = -1; c = getchar(); }
while(isdigit(c)) { ret = (ret << 1) + (ret << 3) + (c ^ 48); c = getchar(); }
return ret * w;
}
inline int readc() {
char c = getchar();
while(c != '+' && c != '-') c = getchar();
return c == '+' ? 1 : -1;
}
char buf[50];
inline void write(ll x) {
if(x < 0) x = -x, putchar('-');
int tp = 0;
do { buf[++tp] = x % 10 + 48; x /= 10; } while(x);
while(tp) putchar(buf[tp--]);
}
const int MAX_N = 1e6 + 10;
int n, cnt, sub[MAX_N];
ll ans, sum1[MAX_N], sum2[MAX_N];
int main() {
n = read();
for(int i = 1, w = 1, x; i <= n; i++) {
if(i > 1) w = readc();
x = read();
if(w == -1) sub[++cnt] = i;
sum1[i] = sum1[i - 1] + w * x;
sum2[i] = sum2[i - 1] + x;
}
ans = sum1[n];
for(int i = 1; i < cnt; i++) {
ll A = sum1[sub[i] - 1];
ll B = sum2[sub[i + 1] - 1] - sum2[sub[i] - 1];
ll C = sum2[n] - sum2[sub[i + 1] - 1];
ans = max(ans, A - B + C);
}
write(ans);
return 0;
}
给定一个 $n\times n$ 的黑白矩阵，请用价值和最少的一些矩形覆盖所有黑格。
一个矩形的价值是长与宽的最大值。
$1\le n\le 50$
二维区间 dp。设计状态 $dp_{x,y,X,Y}$ 表示以 $(x,y)$ 为左上角，$(X,Y)$ 为右下角的矩形的答案。
则枚举“断线”，把矩形切成上下/左右两个小矩形，合并答案即可。
具体实现可以记忆化搜索。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline bool readc() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 55;
int n, dp[MAX_N][MAX_N][MAX_N][MAX_N];
int dfs(int x, int y, int X, int Y) {
if(dp[x][y][X][Y] != -1) return dp[x][y][X][Y];
int res = max(X - x + 1, Y - y + 1);
for(int k = x; k < X; k++)
res = min(res, dfs(x, y, k, Y) + dfs(k + 1, y, X, Y));
for(int k = y; k < Y; k++)
res = min(res, dfs(x, y, X, k) + dfs(x, k + 1, X, Y));
return dp[x][y][X][Y] = res;
}
int main() {
n = read();
memset(dp, -1, sizeof(dp));
for(int i = 1; i <= n; i++)
for(int j = 1; j <= n; j++)
dp[i][j][i][j] = readc();
write(dfs(1, 1, n, n)), putchar('\n');
return 0;
}
$n$ 个人，每两个人之间都有一场比赛，故共 $\frac {n(n -1)} {2}$ 场比赛。
每个人都有自己想要的比赛顺序。例如 $x$ 要求按顺序与 $a_{x,1},a_{x,2},\cdots a_{x,n-1}$ 比赛。而且每个人每天只可以比一场比赛。
问最少比赛的天数为多少。若无解，输出 $-1$ 。
$n \leq 1000$
因为每个人都只能取当前的对手进行比赛，所以要让每一天都减少至少一场比赛，我们必须让每一天能安排的比赛都安排上。
所以暴力枚举每一天，考察每个元素是否满足比赛条件，即当前其对手的对手是自己。时间复杂度 $\mathcal{O}(n^3)$ 。
考虑优化。我们枚举到第 $i$ 天时，不需要枚举所有元素。这是因为考虑第 $i-1$ 天已经把能安排的比赛全安排完了，那现在能安排的比赛，必然要从前一天安排过的人中产生，因为只有他们的当前对手更新了。
这样，设每一轮安排了 $p$ 场比赛，则共有 $\mathcal{O}(\frac{n^2}{p})$ 轮。每一场的枚举也只有 $\mathcal{O}(p)$ 的复杂度。则时间复杂度为 $\mathcal{O}(n^2)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1005;
int n, cnt, cntt, a[MAX_N][MAX_N], lst[MAX_N], p[MAX_N];
bool ban[MAX_N];
int main() {
n = read();
for(int i = 1; i <= n; i++) {
a[i][0] = 1;
for(int j = 1; j <= n - 1; j++)
a[i][j] = read();
p[++cntt] = i;
}
for(int k = 1; k <= n * (n - 1) / 2; k++) {
cnt = 0;
bool flag = false;
for(int c = 1; c <= cntt; c++)
ban[p[c]] = false;
for(int c = 1; c <= cntt; c++) {
int i = p[c];
int aim = a[i][a[i][0]];
if(a[i][0] >= n || a[aim][0] >= n || ban[i] || ban[aim]) continue;
if(a[aim][a[aim][0]] == i) {
a[aim][0]++;
a[i][0]++;
lst[++cnt] = i;
lst[++cnt] = aim;
ban[i] = ban[aim] = flag = true;
}
}
cntt = cnt;
for(int c = 1; c <= cnt; c++)
p[c] = lst[c];
if(!flag) {
for(int i = 1; i <= n; i++)
if(a[i][0] != n) {
write(-1), putchar('\n');
return 0;
}
write(k - 1), putchar('\n');
return 0;
}
}
write(n * (n - 1) / 2), putchar('\n');
return 0;
}
$N$ 个任务，每个任务有耗时 $T_1$ 和截止时间 $T_2$。同时最多只能做一个任务。求最多能安排几个任务。
$1 \le N < 150000$，$1 \le T_1 < T_2 < 2^{31}$。
反悔贪心。
我们按截止时间将任务排序，逐渐加入答案。如果当前任务直接接着当前的答案做可以完成，则直接加进去。否则，从答案中找到耗时最长的任务，比较一下它的耗时与当前任务的耗时。如果当前任务耗时更短，则用当前任务替换耗时最长的任务，这样一定更优，因为给之后的任务留了更多时间。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 150000;
int n;
ll lt;
struct task {
int time, ddl;
} a[MAX_N];
priority_queue<int> pq;
int main() {
n = read();
for(int i = 1; i <= n; i++)
a[i].time = read(), a[i].ddl = read();
sort(a + 1, a + n + 1, [](task lhs, task rhs) { return lhs.ddl < rhs.ddl; });
for(int i = 1; i <= n; i++) {
if(a[i].time + lt <= a[i].ddl) {
pq.push(a[i].time);
lt += a[i].time;
}
else if(a[i].time < pq.top()) {
lt -= pq.top();
pq.pop();
lt += a[i].time;
pq.push(a[i].time);
}
}
write(pq.size());
putchar('\n');
return 0;
}
给定两个由小写字母组成的字符串 $s,t$，你可以对 $s$ 进行以下四种操作：
在任意位置添加任意一个字母，代价为 $a$。
删除任意一个字母，代价为 $b$。
替换任意一个字母，代价为 $c$。
交换相邻两个字母，代价为 $d$。
你需要求出将 $s$ 变为 $t$ 的最小代价。
| $ | s | , | t | \leq 4000 ,0 < a,b,c,d\leq 10000，a+b \leq 2d$ |
首先对于前三个操作，就是经典的编辑距离问题，可以用类似 LCS 的 $\mathcal{O}(n^2)$ 的字符串 dp 解决。即设计状态 $f(i,j)$ 表示 $s_{1\cdots i}$ 变为 $t_{1\cdots j}$ 的最小代价，显然有如下几种情况：
添加一个字母 $t_j$，则 $f(i,j)=f(i - 1,j) + b$。
删除一个字母 $s_i$，则 $f(i,j)=f(i,j - 1) + a$。
把 $s_i$ 替换成 $t_j$，则 $f(i,j) = f(i-1,j-1)+c\times [s_i\neq t_j]$。
考虑操作 $4$，我们发现「删除一次并添加一次」可以等效代替「交换两个字母」，并且数据范围中限制了 $a+b\leq 2d$，那么这告诉我们，交换操作多于一次是不优的。
我们还能推出，「交换后替换」是不优的。因为这也可以被「删除一次并添加一次」等效代替。
所以有这个限制，转移就变得简单很多了。我们找到 $s$ 中前一个 $t_j$ 的位置 $k$ 和 $t$ 中前一个 $s_i$ 的位置 $l$，则有这样一个转移：
\[f(i,j) = f(k-1,l-1) + d+ (i-k-1)\times b + (j-l-1)\times a\]预处理一下 $k$ 和 $l$ 即可。时间复杂度 $\mathcal{O}(n^2)$
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {
ll ret = 0, w = 1; char c = getchar();
while(!isdigit(c)) { if(c == '-') w = -1; c = getchar(); }
while(isdigit(c)) { ret = (ret << 1) + (ret << 3) + (c ^ 48); c = getchar(); }
return ret * w;
}
char buf[50];
inline void write(ll x) {
if(x < 0) x = -x, putchar('-');
int tp = 0;
do { buf[++tp] = x % 10 + 48; x /= 10; } while(x) ;
while(tp) putchar(buf[tp--]);
}
const int MAX_N = 4000;
ll dp[MAX_N][MAX_N];
int a, b, c, d, lst[27], K[MAX_N][27], L[MAX_N][27];
char s[MAX_N], t[MAX_N];
int main() {
memset(dp, 127, sizeof(dp));
a = read(), b = read(), c = read(), d = read();
scanf("%s%s", s + 1, t + 1);
int n = strlen(s + 1), m = strlen(t + 1);
for(int i = 1; i <= n; i++) {
dp[i][0] = i * b;
for(int p = 0; p < 27; p++)
K[i][p] = lst[p];
lst[s[i] - 'a'] = i;
}
for(int i = 0; i < 27; i++)
lst[i] = 0;
for(int j = 1; j <= m; j++) {
dp[0][j] = j * a;
for(int p = 0; p < 27; p++)
L[j][p] = lst[p];
lst[t[j] - 'a'] = j;
}
dp[0][0] = 0;
for(int i = 1; i <= n; i++)
for(int j = 1; j <= m; j++) {
if(s[i] == t[j]) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
dp[i][j] = min(dp[i][j], dp[i][j - 1] + a);
dp[i][j] = min(dp[i][j], dp[i - 1][j] + b);
dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + c);
int k = K[i][t[j] - 'a'], l = L[j][s[i] - 'a'];
if(!k || !l) continue;
dp[i][j] = min(dp[i][j], dp[k - 1][l - 1] + d + (i - k - 1) * b + (j - l - 1) * a);
}
write(dp[n][m]), putchar('\n');
return 0;
}
给定 $n$ 个点的树，起初每个节点都是黑色，有 $q$ 次操作，操作共三种：
把下标为 $[l,r]$ 的点染成白色；
把下标为 $[l,r]$ 的点染成黑色；
询问从节点 $x$ 出发到达任意一个白色节点的简单路径上经过的边，最大可能的权值。不存在则输出 $-1$.
$n,q \leq 3\times 10^5$
询问操作其实就是询问树上的瓶颈路，这个我们可以用 kruskal 重构树来做，所以 $x$ 到所有白色节点的路径上最大值就是 kruskal 重构树上 $x$ 与所有白色节点的 LCA 的权值。
然后考虑一个套路：树上一个点集的 LCA 为其中 dfs 序最大的点和 dfs 序最小的点的 LCA。所以我们用线段树维护一下白色节点中 dfs 序的最大值和最小值即可。
注意区间推平操作，我们可以维护两组最值。一个是不考虑黑白的，维护区间所有节点 dfs 序的最值 $A$；另一个是考虑黑白的，维护区间白色节点 dfs 序的最值 $V$。这样区间操作我们只需要 $V\gets A$ 或 $V\gets (\inf, -\inf)$即可。
接下来套一个倍增 LCA 就做完了。时间复杂度 $\mathcal{O}(n\log n)$。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
inline ll read() {...}
char buf[50];
void write(ll x) {...}
const int MAX_N = 6e5 + 10, MAX_LOG = 20, INF = (1 << 30);
const pii ORI = make_pair(INF, -INF);
int n, q, tot, dfncnt, log_2[MAX_N], id[MAX_N], dfn[MAX_N], val[MAX_N], fa[MAX_N][MAX_LOG], dep[MAX_N];
vector<int> K[MAX_N];
struct edge {
int u, v, w;
edge(int _u = 0, int _v = 0, int _w = 0) : u(_u), v(_v), w(_w) { }
bool operator < (const edge &t) const { return w < t.w; }
} E[MAX_N];
struct dsu {
int fa[MAX_N];
dsu(int n) { for(int i = 1; i <= n; i++) fa[i] = i; }
inline int find(int x) { return (x == fa[x] ? x : fa[x] = find(fa[x]));}
};
struct node {
pii V, A;
int tag;
node(pii _V = ORI, pii _A = ORI, int _tag = -1) :
V(_V), A(_A), tag(_tag) { }
} d[MAX_N << 2];
void kruskal() {
sort(E + 1, E + n);
dsu D = dsu(n << 1);
int ecnt = 0;
tot = n;
for(int i = 1; i <= n - 1; i++) {
int u = E[i].u, v = E[i].v, w = E[i].w;
int fu = D.find(u), fv = D.find(v);
if(fu == fv) continue;
int now = ++tot;
val[now] = w;
K[now].pb(fu), K[now].pb(fv);
D.fa[fu] = D.fa[fv] = now;
if(++ecnt == n - 1) return;
}
}
void dfsk(int u, int pre) {
dfn[u] = ++dfncnt, id[dfncnt] = u;
fa[u][0] = pre, dep[u] = dep[pre] + 1;
for(int i = 1; i < MAX_LOG; i++)
fa[u][i] = fa[fa[u][i - 1]][i - 1];
for(int v : K[u])
dfsk(v, u);
}
void init_log2() {
log_2[1] = 0;
for(int i = 1; i <= (n << 1); i++)
log_2[i] = log_2[i >> 1] + 1;
}
int lca(int x, int y) {
if(dep[x] < dep[y]) swap(x, y);
for(int i = log_2[dep[x]]; i >= 0; i--)
if(fa[x][i] && dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if(x == y) return x;
for(int i = log_2[dep[x]]; i >= 0; i--)
if(fa[x][i] && fa[y][i] && fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
inline int lc(int p) { return (p << 1); }
inline int rc(int p) { return (p << 1) | 1; }
inline int mid(int s, int t) { return s + ((t - s) >> 1); }
inline pii U(pii x, pii y) { return make_pair(min(x.first, y.first), max(x.second, y.second)); }
inline node change(node now, int type) {
if(type == 1) now.V = now.A;
if(type == 2) now.V = ORI;
now.tag = type;
return now;
}
inline void pd(int p) {
if(d[p].tag != -1) {
d[lc(p)] = change(d[lc(p)], d[p].tag);
d[rc(p)] = change(d[rc(p)], d[p].tag);
d[p].tag = -1;
}
}
void build_tree(int s, int t, int p) {
if(s == t) { d[p].A = make_pair(dfn[s], dfn[s]); return; }
int m = mid(s, t);
build_tree(s, m, lc(p));
build_tree(m + 1, t, rc(p));
d[p].A = U(d[lc(p)].A, d[rc(p)].A);
}
void update(int l, int r, int s, int t, int p, int type) {
if(l <= s && t <= r) { d[p] = change(d[p], type); return; }
pd(p);
int m = mid(s, t);
if(l <= m) update(l, r, s, m, lc(p), type);
if(r > m) update(l, r, m + 1, t, rc(p), type);
d[p].V = U(d[lc(p)].V, d[rc(p)].V);
}
int main() {
n = read(), q = read();
for(int i = 1; i <= n - 1; i++) {
int u = read(), v = read(), w = read();
E[i] = edge(u, v, w);
}
kruskal();
dfsk(tot, 0);
build_tree(1, n, 1);
init_log2();
while(q--) {
int t = read();
if(t < 3) {
int l = read(), r = read();
update(l, r, 1, n, 1, t);
}
else {
int x = read();
pii T = U(d[1].V, make_pair(dfn[x], dfn[x]));
if(T.first == INF || (T.first == T.second && T.first == dfn[x])) write(-1);
else write(val[lca(id[T.first], id[T.second])]);
putchar('\n');
}
}
return 0;
}
有两个长度为 $n$ 的数组 $a,b$，数组内的元素单调不降。
$q$ 次操作，操作有两种：
单点修改：$a_x\gets y$ 或 $b_x\gets y$。保证修改后的数组内的元素仍单调不降。
查询：将 $a$ 数组的 $[l_1,r_1]$ 内的元素和 $b$ 数组的 $[l_2, r_2]$ 内的元素合并在一起，查询这些元素的第 $k$ 小值。
$1\leq n\leq 5\times 10^5, 1\leq q,a_i,b_i\leq 10^6$
$\mathcal{O}(q\log n\log a_i)$，考虑二分答案 $mid$，在两个数组中二分查找比它小的数有多少个。此方法无法通过本题。
int L = 0, R = MAX_V;
while(L < R - 1) {
int mid = L + ((R - L) >> 1);
int pos1 = lower_bound(a + l1, a + r1 + 1, mid) - a - l1;
int pos2 = lower_bound(b + l2, b + r2 + 1, mid) - b - l2;
if(pos1 + pos2 >= k) R = mid;
else L = mid;
}
$\mathcal{O}(q\log n)$，考虑分治（或者说倍增的一种递归实现）。设答案为 $f(l_1,r_1,l_2,r_2,k)$，则我们令 $s=l_1+\lfloor \frac{k}{2}\rfloor -1, t = l_2+\lfloor \frac{k}{2}\rfloor -1$，若 $a_s<b_t$，则 $a_{l_1},a_{l_2},\dots a_{s}$ 都不可能成为答案，所以 $f(l_1,r_1,l_2,r_2,k)=f(s+1,r_1,l_2,r_2,k-(s-l_1+1))$。若 $a_s\geq b_t$ 同理。
每次都可以舍掉其中一个区间的一半，因此时间复杂度可以保证通过本题。递归实现即可，注意边界处理。
int f(int l1, int r1, int l2, int r2, int k) {
if(l1 > r1) return b[l2 + k - 1];
if(l2 > r2) return a[l1 + k - 1];
if(k == 1) return min(a[l1], b[l2]);
int s = min(l1 + (k >> 1) - 1, r1), t = min(l2 + (k >> 1) - 1, r2);
if(a[s] < b[t]) return f(s + 1, r1, l2, r2, k - (s - l1 + 1));
else return f(l1, r1, t + 1, r2, k - (t - l2 + 1));
}
给出一张 $n$ 个点 $m$ 条边的无向图，每个点的初始状态都为 $0$。
你可以操作任意一个点，操作结束后该点以及所有与该点相邻的点的状态都会改变，由 $0$ 变成 $1$ 或由 $1$ 变成 $0$。
你需要求出最少的操作次数，使得在所有操作完成之后所有 $n$ 个点的状态都是 $1$。
$1\le n\le35,1\le m\le595, 1\le a,b\le n$。
经典开关问题的无向图上版本。
显然可以枚举搜索每个点选不选，也可以高斯消元。
这里我们使用搜索，但是 $2^{35}$ 无法接受，所以可以使用 Meet in the middle 思想，把节点拆成 $1\sim \lfloor \frac{n}{2}\rfloor $ 和 $(\lfloor \frac{n}{2}\rfloor + 1)\sim n$ 两部分，分别进行搜索，并且考虑搜索的同时把两边的状态合并。
时间复杂度 $\mathcal{O}(n2^{\frac{n}{2}})$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 40;
int n, m, ans;
ll aim, v[MAX_N];
map<ll, int> step;
void dfs(int u, int r, ll state, int cnt) {
if(step.count(state)) step[state] = min(step[state], cnt);
else step[state] = cnt;
if(state == aim) ans = min(ans, cnt);
if(u > (n >> 1) && step.count(state ^ aim)) ans = min(ans, step[state ^ aim] + cnt);
if(u > r) return;
dfs(u + 1, r, state, cnt);
dfs(u + 1, r, (state ^ v[u]), cnt + 1);
}
int main() {
n = read(), m = read();
for(int i = 1; i <= n; i++)
v[i] |= (1ll << i);
for(int i = 1; i <= m; i++) {
int a = read(), b = read();
v[a] |= (1ll << b);
v[b] |= (1ll << a);
}
aim = (((1ll << n) - 1) << 1), ans = n;
dfs(1, (n >> 1), 0, 0);
dfs((n >> 1) + 1, n, 0, 0);
write(ans), putchar('\n');
return 0;
}
$n$ 头奶牛，第 $i$ 头奶牛重量为 $w_i$，才艺水平为 $t_i$。
从中选一些参加比赛的奶牛。这些奶牛的总重量至少为 $W$。
最大化选出奶牛的才艺和与重量和的比值。
$1 \leq n \leq 250$，$1 \leq W \leq 1000$，$1 \leq w_i \leq 10^6$，$1 \leq t_i \leq 10^3$。
01分数规划板子。
题意相当于最大化 $\frac{\sum p_i t_i}{\sum p_i w_i}$，其中 $p_i\in \left{ 0,1\right}$。二分答案 $x$，则答案合法，当且仅当 $\frac{\sum p_i t_i}{\sum p_i w_i}> x\iff \sum p_i(t_i-xw_i)>0$。所以转化成选出一些奶牛，重量为 $w_i$，价值为 $t_i-xw_i$，且满足重量和至少为 $W$。跑一个 01 背包即可，则式子左边的最大值为 $dp_{W}$。
时间复杂度 $\mathcal{O}(nW\log W)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 255, MAX_W = 1005;
const double MAX_ANS = 1e3 + 1, eps = 1e-4, INF = 1e9;
int n, W, w[MAX_N], t[MAX_N];
double dp[MAX_W];
bool check(double x) {
for(int i = 1; i <= W; i++)
dp[i] = -INF;
for(int i = 1; i <= n; i++)
for(int j = W; j >= 0; j--) {
int k = min(W, j + w[i]);
dp[k] = max(dp[k], dp[j] + t[i] - x * w[i]);
}
return dp[W] > 0;
}
int main() {
n = read(), W = read();
for(int i = 1; i <= n; i++)
w[i] = read(), t[i] = read();
double l = 0, r = MAX_ANS;
while(r - l > eps) {
double mid = (l + r) * 0.5;
if(check(mid)) l = mid;
else r = mid;
}
write(int(1000 * l));
return 0;
}
有一个 $n$ 个点的有向图，初始没有点有连边。
$q$ 次操作，操作有三种：
1 v u w：连边 $(v,u,w)$。
2 v l r w：$\forall \ l\leq u\leq r$，连边 $(v,u,w)$。
3 v l r w：$\forall\ l\leq u\leq r$，连边 $(u,v,w)$。
在所有操作后，求 $s$ 到所有点的最短距离。
$1\leq n,q\leq 10^5, 1\leq w\leq 10^9$
如果暴力建边，时空复杂度无法接受。由于有区间操作，我们可以考虑使用线段树来优化。
我们可以把线段树上的节点纳入原图中考虑，原图中的点 $1\sim n$ 对应线段树的叶子节点，线段树的其他节点对应一些区间。
建立两棵线段树，一个入树，一个出树。对于入树，从左右儿子向父亲连零边；对于出树，从父亲向左右儿子连零边。并且，我们把入树和出树的相同的叶子节点相互连零边。这样以来，最后的最短路就是从 $s$ 对应入树的叶子节点出发，到达出树的叶子节点的距离。
那么操作 $2$ 相当于 $v$ 对应入树的叶子节点向区间 $[l,r]$ 对应出树的节点连边；操作 $3$ 同理。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
typedef pair<ll, int> pii;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 3e6 + 10, DELTA = 5e5;
const ll INF = (1ll << 60);
int n, q, s, cnt, leaf1[MAX_N], leaf2[MAX_N], fir[MAX_N];
bool vis[MAX_N];
ll dis[MAX_N];
struct edge {
int v, w, nxt;
edge() { }
edge(int _v, int _w, int _nxt) :
v(_v), w(_w), nxt(_nxt) { }
} e[MAX_N << 2];
void AddEdge(int u, int v, int w) {
e[++cnt] = edge(v, w, fir[u]);
fir[u] = cnt;
}
inline int lc(int p) { return (p << 1); }
inline int rc(int p) { return (p << 1) | 1;}
inline int mid(int s, int t) { return s + ((t - s) >> 1); }
void build_tree(int s, int t, int p) {
if(s == t) {
leaf1[s] = p;
leaf2[s] = p + DELTA;
AddEdge(leaf1[s], leaf2[s], 0);
AddEdge(leaf2[s], leaf1[s], 0);
return;
}
int m = mid(s, t);
AddEdge(p, lc(p), 0), AddEdge(p, rc(p), 0);
AddEdge(lc(p) + DELTA, p + DELTA, 0), AddEdge(rc(p) + DELTA, p + DELTA, 0);
build_tree(s, m, lc(p));
build_tree(m + 1, t, rc(p));
}
void update(int s, int t, int p, int l, int r, int u, int type, int w) {
if(l <= s && t <= r) {
if(type == 2) AddEdge(leaf2[u], p, w);
else AddEdge(p + DELTA, leaf1[u], w);
return;
}
int m = mid(s, t);
if(l <= m) update(s, m, lc(p), l, r, u, type, w);
if(r > m) update(m + 1, t, rc(p), l, r, u, type, w);
}
void dijkstra(int s) {
priority_queue<pii, vector<pii>, greater<pii>> pq;
for(int i = 1; i < MAX_N; i++)
dis[i] = INF;
pq.push(make_pair(0, s));
dis[s] = 0;
while(!pq.empty()) {
int u = pq.top().second; pq.pop();
if(vis[u]) continue;
vis[u] = 1;
for(int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].v, w = e[i].w;
if(dis[u] + w < dis[v]) {
dis[v] = dis[u] + w;
pq.push(make_pair(dis[v], v));
}
}
}
}
int main() {
n = read(), q = read(), s = read();
build_tree(1, n, 1);
while(q--) {
int type = read();
if(type == 1) {
int v = read(), u = read(), w = read();
AddEdge(leaf2[v], leaf1[u], w);
}
else {
int v = read(), l = read(), r = read(), w = read();
update(1, n, 1, l, r, v, type, w);
}
}
dijkstra(leaf2[s]);
for(int i = 1; i <= n; i++)
write(dis[leaf1[i]] == INF ? -1 : dis[leaf1[i]]), putchar(" \n"[i == n]);
return 0;
}
洛谷 P6348：要求支持区间 $[a,b]$ 向区间 $[c,d]$ 连边。
这个可以通过建两个虚点 $x,y$，然后在入树将 $[a,b]$ 连到 $x$，在出树将 $y$ 连到 $[c,d]$，然后再连边 $(x,y,w)$ 即可。
有一个 $N$ 个点，$M$ 条边的无向图，边有黑白两种。要求找出原图的一个生成树，使得树上正好有 $K$ 条白边。
$1\leq N\leq 2\times 10^4,1\leq M\leq 10^5, 0\leq K \leq N - 1$
先按黑边优先来排序，跑一遍 Kruskal，求出加入的白边数量的最小值 $p$，以及此时加入了哪些白边。若 $p>K$，则无解。
再跑一遍 Kruskal，这次优先加入那些必须要加的白边，然后再加其他白边直到达到 $K$ 条，其次再加其他黑边。若白边达不到 $K$ 条或加完之后无法形成生成树，则无解。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1e5 + 10;
int n, m, k, cnt, tot;
struct edge { int u, v, w; } E[MAX_N], ans[MAX_N];
struct dsu {
int fa[MAX_N];
dsu(int n) {
for(int i = 1; i <= n; i++)
fa[i] = i;
}
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }
bool merge(int x, int y) {
int fx = find(x), fy = find(y);
if(fx == fy) return 0;
fa[fx] = fy;
return 1;
}
};
void solve() {
sort(E + 1, E + m + 1, [](edge x, edge y) { return x.w > y.w; });
dsu D = dsu(n);
for(int i = 1; i <= m; i++) {
bool f = D.merge(E[i].u, E[i].v); tot += f;
if(f && E[i].w == 0) cnt++, E[i].w = -1;
}
if(cnt > k || tot != n - 1) { puts("no solution"); return; }
sort(E + 1, E + m + 1, [](edge x, edge y) { return x.w < y.w; });
D = dsu(n);
cnt = tot = 0;
for(int i = 1; i <= m; i++) {
if(cnt == k && E[i].w <= 0) continue;
bool f = D.merge(E[i].u, E[i].v);
if(f) ans[++tot] = E[i];
if(f && E[i].w <= 0) cnt++;
}
if(cnt < k || tot != n - 1) { puts("no solution"); return; }
for(int i = 1; i <= tot; i++) {
write(ans[i].u), putchar(' ');
write(ans[i].v), putchar(' ');
write(max(ans[i].w, 0)), putchar('\n');
}
}
int main() {
n = read(), m = read(), k = read();
for(int i = 1; i <= m; i++)
E[i].u = read(), E[i].v = read(), E[i].w = read();
solve();
return 0;
}
给定一个序列 $A$，每次操作可以使 $A_i + 1$ （$i \in [1, n]$，$K$ 次操作的 $i$ 可以不同），最多可以做 $K$ 次。问 $\gcd{A_1, A_2, …, A_n}$ 的最大值。
$ 2\leq\ N\leq\ 3\times\ 10^5 , 1\leq\ K\leq\ 10^{18} ,1\ \leq\ A_i\leq\ 3\times\ 10^5 $
设序列 $A$ 中的最大值为 $t$。
当 $K\geq \sum\limits_{i=1}^n (t - A_i)$ 时，显然我们可以把所有数先加到 $t$，然后把剩下的操作次数平均分给每一个数，得到最大的答案。
否则，答案一定小于 $t$，我们就从 $t$ 到 $1$ 枚举 $ans$，检验它的合法性。要让所有数的 $\gcd$ 等于 $ans$，我们就让每个数加到它以上的最接近的 $ans$ 的倍数，所以需要的最少次数为 $\sum\limits_{i=1}^n (\lceil \frac{A_i}{ans} \rceil\times ans - A_i)$，判断它与 $K$ 的大小关系即可。
考虑加速上面式子的计算。我们发现 $\lceil \frac{A_i}{ans} \rceil$ 的取值是连续的，对于 $A_i\in ((k-1)\cdot ans, k\cdot ans]$，取值均为 $k$。所以把 $A_i$ 按值域分成 $\lceil \frac{t}{ans} \rceil$ 段，每一段的答案为 $k\cdot ans\cdot cnt-sum$，其中 $cnt$ 为区间中 $A_i$ 的数量，$sum$ 为区间中 $A_i$ 的和，这些都可以预处理。
所以最终的时间复杂度为 $\mathcal{O}(n \ln n)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 6e5 + 10;
ll n, K, delta, a[MAX_N], cnt[MAX_N], sum[MAX_N];
bool check(int ans) {
ll p = 0;
for(ll k = 1; k <= (a[n] + ans) / ans; k++) {
ll l = ans * (k - 1), r = ans * k;
p += k * ans * (cnt[r] - cnt[l]) - (sum[r] - sum[l]);
}
return p <= K;
}
int main() {
n = read(), K = read();
for(int i = 1; i <= n; i++)
a[i] = read();
sort(a + 1, a + n + 1);
for(int i = 1; i <= n; i++)
delta += a[n] - a[i];
if(delta <= K) write(a[n] + (K - delta) / n);
else {
for(int i = 1; i <= n; i++)
cnt[a[i]]++;
for(int i = 1; i <= 2 * a[n]; i++)
sum[i] = sum[i - 1] + cnt[i] * i, cnt[i] += cnt[i - 1];
int ans = a[n] - 1;
for(; ans >= 1; ans--)
if(check(ans)) break;
write(ans), putchar('\n');
}
return 0;
}
有一个左部和右部均为 $n$ 个点的二分图，求它的完美匹配方案数。
这个可以状压 dp，设 $dp[i][S]$ 为考虑到左部的第 $i$ 个点，右部的选择情况为状态 $S$ 的方案数。显然 $i=\text{popcount}(S)$，所以可以省略掉第一维。有转移方程如下：
\[dp[S]=\sum dp[S\oplus 2^j]\]其中 $j$ 为在 $S$ 中选中的右部点，且需要满足 $i$ 和 $j$ 有连边。
n = read();
for(int i = 0; i < n; i++)
for(int j = 0; j < n; j++)
a[i][j] = read();
S = (1 << n) - 1;
dp[0] = 1;
for(int s = 1; s <= S; s++) {
int i = __builtin_popcount(s) - 1;
for(int j = 0; j < n; j++)
if(a[i][j] && ((s >> j) & 1)) (dp[s] += dp[s ^ (1 << j)]) %= MOD;
}
write(dp[S]);
给定一个非空字符串包含 (，) 和 ?。
其中 ? 需要用 ( 或者 ) 替换掉，求替换后的字符串是合法的括号串的方案数对 $ 998244353$ 取模的值。
对于合法括号序列的判定问题，我们往往将左括号视为 $1$，右括号视为 $-1$，则序列为合法括号序列的充要条件为：
序列所有数之和为 $0$。
序列的所有前缀和都非负。
所以考虑 $f_{i,j}$ 表示考虑前 $i$ 个数，前缀和为 $j$ 的方案数。
如果第 $i$ 位是左括号，则 $f_{i,j}=\sum f_{i-1,j-1}$。
如果第 $i$ 位是右括号，则 $f_{i,j}=\sum f_{i-1,j+1}$。
如果第 $i$ 位是问号，则 $f_{i,j}=\sum f_{i-1,j-1} + \sum f_{i-1,j+1}$
时间复杂度：$\mathcal{O}(n^2)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 3005, MOD = 998244353;
char s[MAX_N];
int n, dp[MAX_N][MAX_N];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
dp[0][0] = 1;
for(int i = 1; i <= n; i++) {
if(s[i] == '(') {
for(int j = 1; j <= i; j++)
(dp[i][j] += dp[i - 1][j - 1]) %= MOD;
}
else if(s[i] == ')') {
for(int j = 0; j < i; j++)
(dp[i][j] += dp[i - 1][j + 1]) %= MOD;
}
else {
for(int j = 1; j <= i; j++)
(dp[i][j] += dp[i - 1][j - 1]) %= MOD;
for(int j = 0; j < i; j++)
(dp[i][j] += dp[i - 1][j + 1]) %= MOD;
}
}
write(dp[n][0]);
return 0;
}
给定一颗树，有若干个询问，每个询问给出 $l$，$r$，要求编号为 $l$~$r$ 的点任意删去一个之后剩余点的 LCA 深度最大，输出删去点的编号和 LCA 的最大深度。
经典小 Trick：一个点集内的点的 LCA 为他们之中 dfn 最大和 dfn 最小的点的 LCA。
所以，只有当删的点是 dfn 最大或最小的点时，LCA 才有可能改变。分两类讨论，用 ST 表维护 dfn 序的最大最小值的位置即可。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 100005, MAX_LOG = 18;
int n, q, dfncnt, dep[MAX_N], dfn[MAX_N], fa[MAX_N][MAX_LOG];
int log_2[MAX_N], stmin[MAX_N][MAX_LOG], stmax[MAX_N][MAX_LOG];
vector<int> G[MAX_N];
int Min(int x, int y) { return dfn[x] < dfn[y] ? x : y; }
int Max(int x, int y) { return dfn[x] > dfn[y] ? x : y; }
int qmin(int l, int r) {
int len = log_2[r - l + 1];
return Min(stmin[l][len], stmin[r - (1 << len) + 1][len]);
}
int qmax(int l, int r) {
int len = log_2[r - l + 1];
return Max(stmax[l][len], stmax[r - (1 << len) + 1][len]);
}
void pre(int N) {
log_2[1] = 0, log_2[2] = 1;
for(int i = 3; i <= N; i++)
log_2[i] = log_2[i >> 1] + 1;
}
void dfs(int u) {
dfn[u] = ++dfncnt;
dep[u] = dep[fa[u][0]] + 1;
for(int i = 1; i < MAX_LOG; i++)
fa[u][i] = fa[fa[u][i - 1]][i - 1];
for(int v : G[u])
dfs(v);
}
int lca(int x, int y) {
if(!x || !y) return x + y;
if(dep[x] < dep[y]) swap(x, y);
for(int i = MAX_LOG - 1; i >= 0; i--)
if(fa[x][i] && dep[fa[x][i]] >= dep[y]) x = fa[x][i];
if(x == y) return x;
for(int i = MAX_LOG - 1; i >= 0; i--)
if(fa[x][i] && fa[y][i] && fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return fa[x][0];
}
int cal(int l, int mid, int r) {
int lca1, lca2;
if(l < mid) lca1 = lca(qmin(l, mid - 1), qmax(l, mid - 1));
if(mid < r) lca2 = lca(qmin(mid + 1, r), qmax(mid + 1, r));
if(mid == r) return lca1;
if(mid == l) return lca2;
return lca(lca1, lca2);
}
int main() {
n = read(), q = read();
pre(n);
for(int i = 2; i <= n; i++) {
fa[i][0] = read();
G[fa[i][0]].pb(i);
}
dfs(1);
for(int i = 1; i <= n; i++)
stmin[i][0] = stmax[i][0] = i;
for(int j = 1; j < MAX_LOG; j++)
for(int i = 1; i + (1 << j) - 1 <= n; i++) {
stmin[i][j] = Min(stmin[i][j - 1], stmin[i + (1 << (j - 1))][j - 1]);
stmax[i][j] = Max(stmax[i][j - 1], stmax[i + (1 << (j - 1))][j - 1]);
}
while(q--) {
int l = read(), r = read();
int mn = qmin(l, r), mx = qmax(l, r);
int ans1 = cal(l, mn, r), ans2 = cal(l, mx, r);
if(dep[ans1] > dep[ans2]) write(mn), putchar(' '), write(dep[ans1] - 1);
else write(mx), putchar(' '), write(dep[ans2] - 1);
putchar('\n');
}
}
一个长度为 $n$ 的大数，用 $S_1S_2S_3 \cdots S_n$表示，其中 $S_i$ 表示数的第 $i$ 位, $S_1$ 是数的最高位。有 $m$ 个限制条件，每个条件表示为四个数，$l_1,r_1,l_2,r_2$，即两个长度相同的区间，表示子串$S_{l_1}S_{l_1+1}S_{l_1+2} \cdots S_{r_1}$与$S_{l_2}S_{l_2+1}S_{l_2+2} \cdots S_{r_2}$完全相同。
求有多少个满足所有条件的数。
一个朴素的想法是把区间的对应转化为点的对应，然后用并查集把对应的相同的点合并起来，最后答案即为 $9\times 10^{C-1}$，其中 $C$ 为集合个数。
然后你发现集合的合并具有可加性。用倍增的思想，把长为 $L$ 的区间分成若干长度为 $2$ 的幂的区间，创建 $\lfloor \log_2 n\rfloor$ 层并查集，设 $fa(x, k)$ 为以 $x$ 为左端点，长度为 $2^k$ 的区间的那一层并查集的父亲。这样合并就是 $\mathcal{O}(\log n)$ 的。
然后最后我们想看 $k=0$ 的那层并查集有多少个集合，所以下放一下，从第 $k$ 层的对应关系推到第 $k-1$ 层。最后统计答案即可。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 1e5 + 10, MAX_LOG = 17, MOD = 1e9 + 7;
int n, m, log_2[MAX_N];
void init_log2(int n) {
log_2[1] = 0;
for(int i = 1; i <= n; i++)
log_2[i] = log_2[i >> 1] + 1;
}
struct dsu {
int fa[MAX_N][MAX_LOG];
dsu(int n) {
for(int i = 1; i <= n; i++)
for(int j = 0; j < MAX_LOG; j++)
fa[i][j] = i;
}
int find(int x, int k) {
if(fa[x][k] == x) return x;
return fa[x][k] = find(fa[x][k], k);
}
void merge(int x, int y, int k) {
int fx = find(x, k), fy = find(y, k);
fa[fx][k] = fy;
}
};
int main() {
n = read(), m = read();
init_log2(n);
dsu D = dsu(n);
for(int i = 1; i <= m; i++) {
int l1 = read(), r1 = read(), l2 = read(), r2 = read();
for(int k = MAX_LOG - 1; k >= 0; k--)
if(l1 + (1 << k) - 1 <= r1) {
D.merge(l1, l2, k);
l1 += (1 << k), l2 += (1 << k);
}
}
for(int k = MAX_LOG - 1; k >= 1; k--)
for(int i = 1; i + (1 << k) - 1 <= n; i++) {
int I = D.find(i, k);
D.merge(i, I, k - 1), D.merge(i + (1 << (k - 1)), I + (1 << (k - 1)), k - 1);
}
ll ans = 1;
for(int i = 1; i <= n; i++)
if(D.fa[i][0] == i) ans = 1ll * ans * (ans == 1 ? 9 : 10) % MOD;
write(ans), putchar('\n');
return 0;
}
有一个 $n$ 个数的排列 $a$。
$q$ 次操作，每次操作交换 $a$ 中的两个数。
每次操作后，求一个最小的 $k$，使得在把 $a$ 的前 $k$ 个数放到排列末尾之后，$a$ 的逆序对数最大。
$q, n\leq 10^6$
设当前序列原来的逆序对数为 $x$。我们把序列的开头 $a_1$ 放到序列的最后时，由于有 $a_1-1$ 个数比它小， $n-a_1$ 个数比它大，所以逆序对数的变化量为 $(n-a_1)-(a_1-1)=n+1-2a_1$。
所以我们之后把 $a_2$ 放到末尾，逆序对数的变化量为 $n+1-2a_2$。以此类推，把前 $k$ 个元素放到末尾的逆序对数为 $x +\sum\limits_{i=1}^k (n+1-2a_i)$。这个数最大就是 $(n+1-2a_i)$ 的前缀和最大。
所以我们可以用线段树维护前缀和数组的最大值，交换可以拆成两个原数组的单点修改，即前缀和数组的区间加。
时间复杂度 $\mathcal{O}(n+q\log n)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1e6 + 10;
int n, q;
ll a[MAX_N], sum[MAX_N];
struct node {
ll val, tag;
int mxpos;
} d[MAX_N << 2];
inline int lc(int p) { return (p << 1); }
inline int rc(int p) { return (p << 1) | 1; }
inline void pu(int p) {
if(d[lc(p)].val >= d[rc(p)].val) d[p].val = d[lc(p)].val, d[p].mxpos = d[lc(p)].mxpos;
else d[p].val = d[rc(p)].val, d[p].mxpos = d[rc(p)].mxpos;
}
void pd(int p) {
if(d[p].tag) {
d[lc(p)].val += d[p].tag, d[rc(p)].val += d[p].tag;
d[lc(p)].tag += d[p].tag, d[rc(p)].tag += d[p].tag;
d[p].tag = 0;
}
}
void build_tree(int s, int t, int p) {
if(s == t) {
d[p].val = sum[s];
d[p].mxpos = s;
d[p].tag = 0;
return;
}
int mid = (s + t) >> 1;
build_tree(s, mid, lc(p));
build_tree(mid + 1, t, rc(p));
pu(p);
}
void update(int s, int t, int l, int r, int p, ll D) {
if(l <= s && t <= r) {
d[p].val += D;
d[p].tag += D;
return;
}
pd(p);
int mid = (s + t) >> 1;
if(l <= mid) update(s, mid, l, r, lc(p), D);
if(r > mid) update(mid + 1, t, l, r, rc(p), D);
pu(p);
}
int solve() { return d[1].mxpos == n ? 0 : d[1].mxpos; }
int main() {
n = read(), q = read();
for(int i = 1; i <= n; i++)
a[i] = read(), sum[i] = sum[i - 1] + n + 1 - 2 * a[i];
build_tree(1, n, 1);
write(solve()), putchar('\n');
while(q--) {
int u = read(), v = read();
update(1, n, u, n, 1, 2 * a[u] - 2 * a[v]);
update(1, n, v, n, 1, 2 * a[v] - 2 * a[u]);
swap(a[u], a[v]);
write(solve()), putchar('\n');
}
return 0;
}
本题有 $t$ 组数据。
现在有一个长度为 $n$ 的数列 $a_i$，给出 $m$ 个条件，每个条件形如 $(l,r,w)$，表示这个数列满足 $\sum\limits_{i=l}^r a_i = w$。问是否存在满足条件的数列。
$t\leq 100, n\leq 100, m\leq 1000$
考虑前缀和数组 $s_i$，则每个条件等价于 $s_{l-1}+w=s_r$。这个显然可以差分约束，但是这里条件只有等于，所以我们有更简单的做法。若存在条件 $(l,r,w)$，我们则称 $l-1$ 和 $r$ 连通，且它们的距离为 $w$。对于一个连通块，不如直接用 dfs，从连通块中任选一点为原点搜出其他点的距离。接下来只需要枚举所有条件，检验是否满足 $dis_r-dis_{l-1}=w$ 即可。
时间复杂度 $\mathcal{O}(t(m+n))$。
#include <bits/stdc++.h>
#define pb emplace_back
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
inline ll read() {...}
inline void write(ll x) {...}
const int MAX_N = 2e5 + 10;
int T, n, m, dis[MAX_N];
struct qry {
int u, v, w;
} Q[MAX_N];
vector<pii> G[MAX_N];
bool vis[MAX_N];
void dfs(int u) {
for(pii x : G[u]) {
int v = x.first, w = x.second;
if(!vis[v]) {
vis[v] = 1;
dis[v] = dis[u] + w;
dfs(v);
}
}
}
int main() {
T = read();
while(T--) {
n = read(), m = read();
for(int i = 0; i <= n; i++) {
dis[i] = vis[i] = 0;
G[i].clear();
}
for(int i = 1; i <= m; i++) {
int u = read() - 1, v = read(), w = read();
Q[i].u = u, Q[i].v = v, Q[i].w = w;
G[u].pb(make_pair(v, w)), G[v].pb(make_pair(u, -w));
}
for(int i = 0; i <= n; i++)
if(!vis[i]) vis[i] = 1, dfs(i);
bool flag = 1;
for(int i = 1; i <= m; i++) {
int u = Q[i].u, v = Q[i].v, w = Q[i].w;
if(dis[v] - dis[u] != w) {
flag = 0;
break;
}
}
puts(flag ? "true" : "false");
}
return 0;
}
小 P 最近参加了华为挑战赛，比赛中题目给定了 $n$ 个不同的元素和 $k$ 个存储位置。
接下来题目给出了一个元素的访问顺序 $a_1, a_2,\dots, a_m$。当一个元素被访问时它必须处于某个存储位置中，同时任意时刻小 P 都可以将某个元素插入到一个空的存储位置中，或者删除一个存储位置上的元素。
最初所有位置都是空的，题目的目标是最小化插入元素的次数。小 P 为了解决这个问题学习了 LRU 算法，即记录下每个存储位置元素的最后一次访问的时刻，随后如果需要删除就删除最后一次访问时刻最小的那个元素。
例如 $n=3, k=2$，且 $a = {1, 2, 3, 2, 1, 2}$，那么在需要访问 $a_1 , a_2$ 直接插入即可；访问 $a_3$ 的时候位置已满，LRU 算法会选择删除 $1$ 这个元素因为它的访问时刻更早，随后插入 $3$；当访问 $a_4$ 的时候可以发现 $2$ 存在于一个位置中所以不用操作；当访问 $a_5$ 的时候需要删除 $3$ 这个元素因为 $2$ 在 $a_4$ 时又被访问了一次,最后一次访问比 $3$ 要更晚，随 后插入 $1$；访问 $a_6$ 时 $2$ 仍在一个位置中，故不用操作。故总插入次数为 $4$。
现在小 P 为了测试 LRU 的效率，它给了你 $n$ 和 $a_1,a_2,\dots,a_m$，希望你对 $k = 1, 2,\dots, n$ 求出答案。
$1\leq n,m\leq 5\times 10^5, 1\leq a_i\leq n$
$\mathcal{O}(n^2)$：用队列模拟即可。
$\mathcal{O}(m\log n)$：考虑一个数 $a_i$ 可以对什么样的 $k$ 造成贡献。如果 $a_i$ 已经在一个位置中，而且在上一次到现在的时间内没有被换掉，则不需要插入，也就不会造成贡献。设 $a_i$ 上一次出现的位置为 $pre_i$，若 $[pre_i+1,i-1]$ 内的元素种类大于或等于 $k$，那么就会进行插入。我们可以通过扫描线 $\mathcal{O}(m\log n)$ 预处理出 $f_i$ 表示 $[pre_i+1,i-1]$ 的元素个数，则这会让 $k\in [1,f_i]$ 的答案加一，差分前缀和维护一下即可求出答案。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 5e5 + 10;
int n, m, a[MAX_N], pre[MAX_N], pos[MAX_N], f[MAX_N], ans[MAX_N];
struct BIT {
int t[MAX_N], mx;
BIT(int n) {
mx = n;
for(int i = 1; i <= mx; i++)
t[i] = 0;
}
int lowbit(int i) { return i & -i; }
void update(int i, int x) {
for(; i <= mx; i += lowbit(i))
t[i] += x;
}
int query(int i) {
int ret = 0;
for(; i >= 1; i -= lowbit(i))
ret += t[i];
return ret;
}
};
struct qry {
int l, r;
bool operator < (const qry &t) const { return r < t.r; }
} Q[MAX_N];
int main() {
freopen("manage.in", "r", stdin);
freopen("manage.out", "w", stdout);
n = read(), m = read();
for(int i = 1; i <= n; i++)
pre[i] = -1;
for(int i = 1; i <= m; i++) {
a[i] = read();
pre[a[i]] = pos[a[i]];
Q[i].l = pre[a[i]] + 1, Q[i].r = i - 1;
pos[a[i]] = i;
}
sort(Q + 1, Q + m + 1);
BIT tree = BIT(m + 10);
for(int i = 1; i <= n; i++)
pre[i] = -1;
for(int i = 1, j = 1; i <= m; i++) {
while(j <= Q[i].r) {
if(pre[a[j]] != -1) tree.update(pre[a[j]], -1);
pre[a[j]] = j;
tree.update(j, 1);
j++;
}
if(pre[a[Q[i].r + 1]] == -1) f[Q[i].r + 1] = -1;
else f[Q[i].r + 1] = tree.query(Q[i].r) - tree.query(Q[i].l - 1);
}
for(int i = 1; i <= m; i++) {
if(f[i] != -1) ans[1]++, ans[f[i] + 1]--;
else ans[1]++, ans[n + 1]--;
}
for(int i = 1; i <= n; i++) {
ans[i] += ans[i - 1];
write(ans[i]), putchar(" \n"[i == n]);
}
return 0;
}
给定一个仅由 $0$ 或 $1$ 组成的长度为 $n$ 的数列。定义一次操作是选择一个后缀并把这个后缀的所有元素取反，求最少使用多少次操作可以让这个序列单调不降。
$\sum n\leq 2\times 10^5$
首先，一个后缀最多只会取一次反。如果你选了以 $p_1,p_2,\dots,p_k$ 为开头的一系列后缀进行操作，你的操作实际上相当于 $[p_1,p_2-1]$ 取反，$[p_2,p_3-1]$ 不变，$[p_3,p_4-1]$ 取反，以此类推，奇数块取反，偶数块不变。
之后，观察到你对一段 $0/1$ 连通块同时取反，是不劣于把它拆开取反的。所以我们可以把连通块缩成一个元素，这时数列就等价转化成了 $0/1$ 交替出现的形式。丢掉开头的 $0$ 不管，最终数列一定变成以下形式：
\[10101010\dots\]接下来你可以构造一个对于这个数列进行操作的最优方案，不妨拆成 $10, 1, 0, 1, 0,\dots$ 这些块，其中奇数块取反，偶数块不变。那么答案就是缩成的序列的长度减一。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline bool read_bool() {...}
inline void write(ll x) {...}
const int MAX_N = 1e5 + 10;
int T, n, cnt;
bool f, a[MAX_N];
int main() {
T = read();
while(T--) {
n = read(), f = 0, cnt = 0;
for(int i = 1; i <= n; i++) {
a[i] = read_bool();
f |= a[i];
if(!f) continue;
if(a[i] != a[i - 1]) cnt++;
}
if(!f) cnt = 1;
write(cnt - 1), putchar('\n');
}
return 0;
}
既然是操作后缀，那么考虑从前往后 dp，每个点需不需要操作只和上一个有没有被取反有关。设计状态 $f(i, 0/1, 0/1)$ 表示考虑前 $i$ 个数，第 $i$ 个数取多少，第 $i$ 位是否和原数列中不同。转移显然，但代码写得有点抽象。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
inline bool read_bool() {...}
inline void write(ll x) {...}
const int INF = (1 << 30);
int T, n, dp[2][2][2];
int main() {
T = read();
while(T--) {
n = read();
dp[0][0][0] = dp[0][1][0] = 0, dp[0][0][1] = dp[0][1][1] = INF;
for(int i = 1; i <= n; i++) {
bool now = read_bool();
dp[i & 1][0][0] = dp[i & 1][1][0] = dp[i & 1][0][1] = dp[i & 1][1][1] = INF;
dp[i & 1][0][now] = min(dp[i & 1][0][now], dp[(i - 1) & 1][0][now]);
dp[i & 1][0][now] = min(dp[i & 1][0][now], dp[(i - 1) & 1][0][now ^ 1] + 1);
dp[i & 1][1][now ^ 1] = min(dp[i & 1][1][now ^ 1], min(dp[(i - 1) & 1][0][now ^ 1], dp[(i - 1) & 1][1][now ^ 1]));
dp[i & 1][1][now ^ 1] = min(dp[i & 1][1][now ^ 1], min(dp[(i - 1) & 1][0][now], dp[(i - 1) & 1][1][now]) + 1);
}
write(min({dp[n & 1][0][0], dp[n & 1][0][1], dp[n & 1][1][0], dp[n & 1][1][1]})), putchar('\n');
}
return 0;
}
给定一个 $n$ 个点，$m$ 条边的带权无向图，考虑它的最小生成树。每条边有三种情况：
一定在最小生成树上。
有可能在最小生成树上，但不一定在最小生成树上。
不可能在最小生成树上。
请你确定每条边属于哪种情况。
$n,m\leq 10^5$
先用 Kruskal 跑出任意一个最小生成树，现在这棵树的树边属于情况 1/2，非树边属于情况 2/3，不妨分别考虑。
对于非树边 $e(u,v,w)$，如果想要纳入最小生成树中，它就要在 Kruskal 的时候，作为较小的边，完成让 $u$ 和 $v$ 连通的任务。那么考虑树上的 $u$ 到 $v$ 的路径，只要在这条路径上存在一条边 $e_0(u_0,v_0,w_0)$，使得 $w_0\geq w$，那么我们就可以用 $e$ 替换 $e_0$，构造出合法的最小生成树。考虑充要转化，「存在一个大于或等于」等价于「最大值大于或等于」，那么我们只需要支持查询路径 $\max$ 即可，这个可以用倍增维护。
类似的，对于树边 $e(u,v,w)$，如果它不一定在最小生成树中，它就要能被一条非树边替换，也就是存在一条非树边 $e_0(u_0,v_0,w_0)$，使得 $e$ 属于树上 $u_0$ 到 $v_0$ 的路径，且 $w_0\leq w$，那么我们就可以用 $e_0$ 替换 $e$，构造出合法的最小生成树。考虑充要转化，「存在一个小于或等于」等价于「最小值小于或等于」。我们可以枚举非树边，然后将它两端的路径对这条边的权值取 $\min$，这个可以树剖加线段树维护。然而这也可以并查集，从小到大枚举非树边，然后暴力跳打最小值标记，对做过的部分用并查集跳过。
设 $n,m$ 同数量级，并查集的复杂度视为 $\mathcal{O}(\log n)$，则时间复杂度 $\mathcal{O}(n\log n)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1e6 + 10, MAX_LOG = 17, INF = 1e9;
int n, m, cnt, ans[MAX_N], mn[MAX_N], fir[MAX_N], dep[MAX_N], fa[MAX_LOG][MAX_N], mx[MAX_LOG][MAX_N];
bool mst[MAX_N];
struct link {
int v, w, nxt;
link(int _v = 0, int _w = 0, int _nxt = 0) :
v(_v), w(_w), nxt(_nxt) { }
} e[MAX_N];
void AddEdge(int u, int v, int w) {
e[++cnt] = link(v, w, fir[u]);
fir[u] = cnt;
}
struct edge {
int u, v, w, id;
bool operator < (const edge &t) const { return w < t.w; }
} E[MAX_N];
struct dsu {
int fa[MAX_N], mx;
dsu(int _mx) {
mx = _mx;
for(int i = 1; i <= mx; i++)
fa[i] = i;
}
int find(int x) { return fa[x] == x ? x : fa[x] = find(fa[x]); }
};
void kruskal() {
dsu D = dsu(n);
sort(E + 1, E + m + 1);
for(int i = 1; i <= m; i++) {
int u = E[i].u, v = E[i].v, w = E[i].w;
int fu = D.find(u), fv = D.find(v);
if(fu == fv) continue;
D.fa[fu] = fv;
AddEdge(u, v, w), AddEdge(v, u, w);
mst[i] = 1;
}
}
void dfs(int u, int pre, int val) {
fa[0][u] = pre, mx[0][u] = val, dep[u] = dep[pre] + 1;
for(int i = 1; i < MAX_LOG; i++) {
fa[i][u] = fa[i - 1][fa[i - 1][u]];
mx[i][u] = max(mx[i - 1][u], mx[i - 1][fa[i - 1][u]]);
}
for(int i = fir[u]; i; i = e[i].nxt) {
int v = e[i].v, w = e[i].w;
if(v == pre) continue;
dfs(v, u, w);
}
}
pii query(int u, int v) {
if(dep[u] < dep[v]) swap(u, v);
int res = 0;
for(int i = MAX_LOG - 1; i >= 0; i--)
if(fa[i][u] && dep[fa[i][u]] >= dep[v]) {
res = max(res, mx[i][u]);
u = fa[i][u];
}
if(u == v) return make_pair(res, u);
for(int i = MAX_LOG - 1; i >= 0; i--)
if(fa[i][u] && fa[i][v] && fa[i][u] != fa[i][v]) {
res = max({res, mx[i][u], mx[i][v]});
u = fa[i][u], v = fa[i][v];
}
res = max({res, mx[0][u], mx[0][v]});
return make_pair(res, fa[0][u]);
}
int main() {
n = read(), m = read();
for(int i = 1; i <= m; i++)
E[i].u = read(), E[i].v = read(), E[i].w = read(), E[i].id = i;
kruskal();
dfs(1, 0, 0);
dsu D = dsu(n);
for(int i = 1; i <= n; i++)
mn[i] = INF;
for(int i = 1; i <= m; i++)
if(!mst[i]) {
int u = E[i].u, v = E[i].v, w = E[i].w, id = E[i].id;
pii res = query(u, v);
ans[id] = (res.first >= w ? 2 : 3);
int lca = res.second;
while(dep[D.find(u)] > dep[lca]) {
int t = D.find(u);
mn[t] = w;
D.fa[t] = D.find(fa[0][t]);
}
while(dep[D.find(v)] > dep[lca]) {
int t = D.find(v);
mn[t] = w;
D.fa[t] = D.find(fa[0][t]);
}
}
for(int i = 1; i <= m; i++)
if(mst[i]) {
int u = E[i].u, v = E[i].v, w = E[i].w, id = E[i].id;
if(dep[u] < dep[v]) swap(u, v);
ans[id] = (mn[u] <= w ? 2 : 1);
}
for(int i = 1; i <= m; i++) {
if(ans[i] == 1) puts("any");
if(ans[i] == 2) puts("at least one");
if(ans[i] == 3) puts("none");
}
return 0;
}
有 $n$ 个魔咒，施展第 $i$ 个魔咒需要 $a_i$ 点能量。现在你有 $m$ 点能量。
如果现在你有 $a(a<m)$ 点能量，你可以用 $(m-a)$ 的代价回复 $1$ 点能量。
你有 $k$ 次机会，每次选定一个 $a_i\geq 1$，让它减一。
求把所有的魔咒都施展一遍的最小代价。
$1\leq n \leq 10^5,1\leq a_i\leq m\leq 10^6, 1\leq k\leq \sum a_i$
对于 $k=0$，考虑贪心。如果你需要回复能量，却不回满，那么下次回复的代价就会变大。所以答案就是有一些回满，直到剩下需要的能量和不大于 $m$ 时，就只要回到剩下需要的能量和。为了让总代价尽量小，则让不需要回的尽量多，按 $a_i$ 从小到大做这个过程即可。
你发现每次代价加的是一个连续段 $1,2,\dots ,a_i$。那么设 $c_i$ 表示 $i$ 被加了几次，则答案为 $\sum i\cdot c_i$。那么一次机会就是选一个 $i$，使得 $c_i\gets c_i-1$。那么贪心地优先减去较大的 $i$ 即可。而且这样的话，$i$ 被删除前，比 $i$ 大的数都被减掉了，所以这样操作肯定是合法的。
时间复杂度 $\mathcal{O}(n\log n +m)$。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = 1e6 + 10;
ll n, m, k, res, a[MAX_N], s[MAX_N], c[MAX_N];
int main() {
n = read(), m = read(), k = read();
for(int i = 1; i <= n; i++)
a[i] = read();
sort(a + 1, a + n + 1);
for(int i = 1; i <= n; i++)
s[i] = s[i - 1] + a[i];
for(int i = 1; i <= n - 1; i++)
if(s[n] - s[i] <= m) { c[m - (s[n] - s[i]) + 1]++, c[a[i] + 1]--; break; }
else c[1]++, c[a[i] + 1]--;
for(int i = 1; i <= m; i++)
c[i] += c[i - 1];
for(int i = m; i >= 1; i--) {
ll d = min(k, c[i]);
c[i] -= d, k -= d;
if(!k) break;
}
for(int i = 1; i <= m; i++)
res += c[i] * i;
write(res), putchar('\n');
return 0;
}
对于一个字符串 $S$，找到 $S$ 的所有具有下列形式的拆分方案数：
$S = ABC$，$S = ABABC$，$S = ABAB \ldots ABC$，其中 $A$，$B$，$C$ 均是非空字符串，且 $A$ 中出现奇数次的字符数量不超过 $C$ 中出现奇数次的字符数量。
| $1 \le t \le 5$，$1 \le | S | \le 2^{20}$。 |
### 题解
我们枚举 $AB$ 的长度 $i$，然后枚举把 $AB$ 重复 $j$ 次，这样的复杂度是 $\mathcal{O}(\frac{n}{1}+\frac{n}{2}+\dots+\frac{n}{n})=\mathcal{O}(n\log n)$ 的。在这个过程中，我们用字符串哈希检验这是否和原串对应。
然后考虑怎么统计答案。 设 $\text{prec}(i)$ 表示 $[1,i]$ 中出现奇数次的字符个数，$\text{sufc}(i)$ 表示 $[i,n]$ 中出现奇数次的字符个数，那么这两个数组可以 $\mathcal{O}(n)$ 预处理。
设当前 $AB$ 长度为 $i$，$C$ 起点为 $k$，答案就是在可能的 $A$，也就是所有 $\text{prec}(1),\text{prec}(2),\dots,\text{prec}(i-1)$ 中，小于或等于 $\text{sufc}(k)$ 的个数。这个可以用树状数组维护。
时间复杂度是常数比较小的 $\mathcal{O}(t(n\log n\log 26))$，可过。
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
inline ll read() {...}
char buf[50];
inline void write(ll x) {...}
const int MAX_N = (1 << 20) + 10, BASE = 13331, MOD = 998244353;
int T, n, cnt1[28], cnt2[28], val[MAX_N], power[MAX_N], prec[MAX_N], sufc[MAX_N];
ll ans;
char s[MAX_N];
struct BIT {
int t[MAX_N], mx;
BIT(int _mx) {
mx = _mx;
for(int i = 0; i <= mx; i++)
t[i] = 0;
}
int lowbit(int i) { return (i & -i); }
void update(int i, int x) {
for(; i <= mx; i += lowbit(i))
t[i] += x;
}
int query(int i) {
int res = 0;
for(; i; i -= lowbit(i))
res += t[i];
return res;
}
};
int get(int l, int r) { return (val[r] - 1ll * val[l - 1] * power[r - l + 1] % MOD + MOD) % MOD; }
void init() {
prec[0] = sufc[n + 1] = 0;
for(int i = 'a'; i <= 'z'; i++)
cnt1[i - 'a'] = cnt2[i - 'a'] = 0;
for(int i = 1, j; i <= n; i++) {
if(!power[i]) power[i] = 1ll * power[i - 1] * BASE % MOD;
val[i] = (1ll * val[i - 1] * BASE % MOD + (s[i] - 'a')) % MOD;
cnt1[s[i] - 'a']++;
if(cnt1[s[i] - 'a'] & 1) prec[i] = prec[i - 1] + 1;
else prec[i] = prec[i - 1] - 1;
j = n - i + 1;
cnt2[s[j] - 'a']++;
if(cnt2[s[j] - 'a'] & 1) sufc[j] = sufc[j + 1] + 1;
else sufc[j] = sufc[j + 1] - 1;
}
}
int main() {
T = read();
power[0] = 1;
while(T--) {
scanf("%s", s + 1);
n = strlen(s + 1), ans = 0;
init();
BIT tree(28);
for(int i = 2; i <= n; i++) {
tree.update(prec[i - 1] + 1, 1);
for(int j = 1; i * j < n; j++) {
int l = i * (j - 1) + 1, r = i * j;
if(get(l, r) != get(1, i)) break;
ans += tree.query(sufc[r + 1] + 1);
}
}
write(ans), putchar('\n');
}
return 0;
}