Menci's OI Blog

「Sekai CTF 2022」Pafs - 树形 DP

2022-10-04T13:50:00.000Z

给定一棵有个节点的无根树，对每条无向边编号（和被认为是同一条边），定义一种新的路径 Pafs：一条 Pafs 路径是若干条不重复的边组成的序列，序列中两个相邻的边之间必须有且仅有一个公共端点。Pafs 路径是有向的，且相邻的边不需要首尾相连，如下图：

求给定的树上共有多少条 Pafs 路径，答案。

链接

Project SEKAI Online Judge

题解

考虑每条 Pafs 路径的形态：一定是以一条普通的路径作为主要部分，外加其中每个点都可以额外引入若干条分叉边。所以从主路径入手考虑这个问题。

对无根树进行 DFS，转化为有根树。在树上进行树形 DP，为每个节点维护两个值：

表示，主路径在该节点的子树（外加该节点的父节点）内，主路径从下向上以该节点的父节点结束，最后一条边为该节点与其父节点相连的边，的 Pafs 路径数量；
- 仅对非根节点有定义
- 根据定义最后一条边也可以算作分叉边，但为了解题这里将其算作主路径；
- 仅统计从下向上一个方向，其中除单条边组成的以外，每个对应一个反转的路径；
表示，主路径在该节点的子树内，主路径经过的深度最小的点为该节点，的 Pafs 路径数量。

最终答案为所有之和。

g(i)

对于每个节点，其每个子节点的中的每个 Pafs 路径均对有贡献。从每个子节点引入的 Pafs 路径，在到达当前节点之后，由于最后一条边属于主路径，所以可以再加入若干条分叉边，这些可供选择分叉边即为与其他子节点相连的边。

设共有个子节点，此时一共有条边可供选择。由于 Pafs 路径是有序的，所以分叉边的选择方案也是有序的，所以此时的方案数为：从条边中任选一条或多条边，并组成全排列，的方案数，即

由于的最大值为级别（考虑菊花图），所以不能使用时间复杂度为的算法来计算单个。将的前 10 项输出，可得
在 OEIS 上搜索，得到数列 A000522，并获得线性递推式
使用该递推式可在的时间内预处理所有值。

所以，对非根节点

s(i)

每个节点的分为两个个部分：

，表示以该节点的父节点作为最后一条边，且这条边作为主路径，且主路径上每个点深度递减的 Pafs 路径（以及其相反的路径）数量，显然（减以去除单条边组成的路径被重复计算两次的情况）；
，表示主路径可分为在的不同子树内的两部分，且主路径所有节点的最近公共祖先为，的 Pafs 路径数量。

对于第二部分，考虑主路径从一个子节点向上到达当前节点，再向下到另一个子节点。由于在的定义中，每条 Pafs 路径均以的边作为主路径结束，所以之间可以引入若干条分叉边，这些分叉边可以包含与其他个子节点相连的边，也可以包含与父节点相连的边，所以共有种选择。所以

所以

其中可以通过预处理所有子节点的之和并减去的方法来简化计算，不需要两层循环枚举分别所有子节点。

时间复杂度为。

代码

#include #include #include const int64_t MOD = 1e9 + 7;struct Node {    int id;    std::vector<Node *> adj;    bool visited;    std::vector<Node *> children;    int64_t g, s;};inline void addEdge(Node *u, Node *v) {    u->adj.push_back(v);    v->adj.push_back(u);}std::vector<int64_t> p0Cache;// inline void exgcd(int64_t a, int64_t b, int64_t &g, int64_t &x, int64_t &y) {//     if (!b) g = a, x = 1, y = 0;//     else exgcd(b, a % b, g, y, x), y -= x * (a / b);// }// inline int64_t inv(int64_t num) {//     int64_t g, x, y;//     exgcd(num, MOD, g, x, y);//     return ((x % MOD) + MOD) % MOD;// }inline void preprocess(int n) {    // std::vector frac(n + 1);    // frac[0] = 1;    // for (int i = 1; i <= n; i++) frac[i] = frac[i - 1] * i % MOD;    // p0Cache.resize(n + 1);    // for (int i = 0; i <= n; i++) {    //     for (int j = 0; j <= i; j++) {    //         (p0Cache[i] += frac[i] * inv(frac[i - j]) % MOD) %= MOD;    //     }    //     printf("P0(%d) = %llu\n", i, p0Cache[i]);    // }    p0Cache.resize(n + 1);    p0Cache[0] = 1;    for (int i = 1; i <= n; i++) {        p0Cache[i] = (p0Cache[i - 1] * i + 1) % MOD;        // printf("P0(%d) = %llu\n", i, p0Cache[i]);    }}inline void dfs(Node *u) {    u->visited = true;    for (Node *v : u->adj) {        if (!v->visited) {            dfs(v);            u->children.push_back(v);        }    }    int64_t p0 = u->adj.size() < 2 ? 0 : p0Cache[u->adj.size() - 2];    bool notRoot = u->adj.size() != u->children.size();    u->g = u->s = notRoot ? 1 : 0;    int64_t sumOfG = 0;    for (Node *ci : u->children) (sumOfG += ci->g) %= MOD;    for (Node *ci : u->children) {        (u->s += ci->g * p0 % MOD * ((sumOfG - ci->g + MOD + (notRoot ? 2 : 0)) % MOD) % MOD) %= MOD;        (u->g += ci->g * p0 % MOD) %= MOD;    }    // printf("g(%d) = %llu\n", u->id, u->g);    // printf("s(%d) = %llu\n", u->id, u->s);}int main() {    int n;    scanf("%d", &n);    preprocess(n);    std::vector<Node> nodes(n);    for (int i = 0; i < n - 1; i++) {        int u, v;        scanf("%d %d", &u, &v);        addEdge(&nodes[u - 1], &nodes[v - 1]);    }    for (int i = 0; i < n; i++) {        nodes[i].id = i + 1;        nodes[i].visited = false;    }    dfs(&nodes[0]);    int64_t answer = 0;    for (int i = 0; i < n; i++) (answer += nodes[i].s) %= MOD;    printf("%llu\n", answer);    return 0;}

「Sekai CTF 2022」Electric Box - 计算几何 + 并查集

2022-10-04T12:07:00.000Z

在一个宽度无限（横坐标到），高度有限（纵坐标到，其中整数）的游戏场地上，有（）个圆形障碍物，分布在横坐标到（其中整数）的位置，玩家同样为圆形。给定每个障碍物的坐标和半径（均为整数），玩家需要从左侧无限远的位置开始，经过障碍物区域，在不与上下边界及任何障碍物接触的情况下，到达右侧无限远的位置。

给定玩家的初始半径。为了增加游戏难度，玩家拥有（）份强化材料，其中第份材料可以将玩家的半径扩大（为整数；与使用顺序无关）。问最多使用多少份强化材料，可以使得游戏能够通关。

链接

Project SEKAI Online Judge

题解

由于使用顺序无关，强化材料的最优使用方案一定是从小到大依次使用。二分玩家的最大可通关半径，最后按从小到大顺序检查每个材料是否可以使用可得答案。转化为判定在给定的半径下，玩家是否可通关。虽然场地的参数、障碍物的坐标与半径、强化材料增加的半径均为整数，但显然玩家的最大半径可能不是整数，故采用浮点数二分。

对于一个给定的玩家半径，将每个障碍物半径各扩大，并将场地的上下边界各向内收缩，转化为判定是否存在一条通道使得无限小的玩家能够从左到右通过。考虑此时每个由一个或多个相交（或相切，下同）的障碍物组成的连通块，如果某个障碍物连通块同时与上下边界相交，则玩家不可能通过；否则该连通块的存在不影响玩家是否可通过。

使用计算几何判定每两个障碍物的是否相交，判定每个障碍物是否与边界相交，并使用并查集维护每个连通块与边界的相交关系，最后检查是否有连通块同时与上下边界相交即可。

时间复杂度为。

代码

#include #include #include #include #include const double EPS_CAL = 1e-7;const double EPS_BS = 1e-5;const double EPS_CMP = 1e-3;inline bool dcmp(double a, double b, double eps = EPS_CAL) {    return fabs(a - b) <= eps;}double binarySearch(double l, double r, std::function<bool (double)> check) {    double mid;    while (r - l > EPS_BS) {        mid = l + (r - l) / 2;        if (check(mid))            l = mid;        else            r = mid;    }    return mid;}double sq(double x) {    return x * x;}double sqLen(double x1, double y1, double x2, double y2) {    return sq(x1 - x2) + sq(y1 - y2);}bool circleIntersect(double x1, double y1, double r1, double x2, double y2, double r2) {    double cd = sqLen(x1, y1, x2, y2);    double rs = sq(r1 + r2);    return cd < rs || dcmp(cd, rs);}bool circleIntersectLine(double x1, double y1, double x2, double y2, double xc, double yc, double r) {    double v1x = x2 - x1, v1y = y2 - y1;    double v2x = xc - x1, v2y = yc - y1;    double cross = v1x * v2y - v2x * v1y;    double l1 = sqrt(sqLen(x1, y1, x2, y2));    double dist = fabs(cross / l1);    return dist < r || dcmp(dist, r);}struct UnionFindSet {    std::vector<int> a;    void init(int n) {        a.resize(n);        for (int i = 0; i < n; i++) a[i] = i;    }    int find(int x) {        return x == a[x] ? x : (a[x] = find(a[x]));    }    void merge(int x, int y) {        a[x] = y;    }};struct Intersectable {    bool intersectWithTop;    bool intersectWithRight;    bool intersectWithBottom;    bool intersectWithLeft;};struct Circle : Intersectable {    int x, y, originalRaduis;    double currentRadius;};int main() {    int r, n;    scanf("%d %d", &r, &n);    std::vector<int> t(n);    for (int i = 0; i < n; i++)        scanf("%d", &t[i]);    int l, w, m;    scanf("%d %d %d", &l, &w, &m);    std::vector<Circle> circles(m);    for (int i = 0; i < m; i++)        scanf("%d %d %d", &circles[i].x, &circles[i].y, &circles[i].originalRaduis);    UnionFindSet ufs;    std::vector<Intersectable> regions(m);    double maxPlayerRadius = binarySearch(0, (double)std::min(l, w) / 2 - EPS_BS, [&] (double d) {        double left = 0;        double bottom = d;        double right = l;        double top = w - d;        for (int i = 0; i < m; i++) {            double r = circles[i].originalRaduis + d;            circles[i].currentRadius = r;            // top: (0, w) - (l, w)            regions[i].intersectWithTop = circles[i].intersectWithTop = circleIntersectLine(left, top, right, top, circles[i].x, circles[i].y, r);            // right: (l, 0) - (l, w)            regions[i].intersectWithRight = circles[i].intersectWithRight = circleIntersectLine(right, bottom, right, top, circles[i].x, circles[i].y, r);            // bottom: (0, 0) - (l, 0)            regions[i].intersectWithBottom = circles[i].intersectWithBottom = circleIntersectLine(left, bottom, right, bottom, circles[i].x, circles[i].y, r);            // left: (0, 0) - (0, w)            regions[i].intersectWithLeft = circles[i].intersectWithLeft = circleIntersectLine(left, top, left, bottom, circles[i].x, circles[i].y, r);        }        ufs.init(m);        for (int i = 0; i < m; i++) {            for (int j = 0; j < i; j++) {                if (circleIntersect(circles[i].x, circles[i].y, circles[i].currentRadius, circles[j].x, circles[j].y, circles[j].currentRadius)) {                    int r1 = ufs.find(i), r2 = ufs.find(j);                    if (r1 == r2) continue;                    ufs.merge(r1, r2);                    regions[r2].intersectWithTop = regions[r1].intersectWithTop || regions[r2].intersectWithTop;                    regions[r2].intersectWithRight = regions[r1].intersectWithRight || regions[r2].intersectWithRight;                    regions[r2].intersectWithBottom = regions[r1].intersectWithBottom || regions[r2].intersectWithBottom;                    regions[r2].intersectWithLeft = regions[r1].intersectWithLeft || regions[r2].intersectWithLeft;                }            }        }        for (int i = 0; i < m; i++) {            auto &region = regions[ufs.find(i)];            if (region.intersectWithTop && region.intersectWithBottom) {                return false;            }        }        return true;    });    // printf("maxPlayerRadius = %f\n", maxPlayerRadius);    if (maxPlayerRadius < r || dcmp(maxPlayerRadius, r, EPS_CMP)) {        puts("-1");    } else {        std::sort(t.begin(), t.end());        int answer = 0;        for (int i = 0, curr = r; i < n; i++) {            curr += t[i];            if (curr < maxPlayerRadius && !dcmp(curr, maxPlayerRadius, EPS_CMP))                answer++;            else                break;        }        printf("%d\n", answer);    }    return 0;}

博客恢复维护~

2021-04-30T02:58:00.000Z

两年前改 Hexo 改的跑不起来了，于是之后再也没有更新过这个博客。

最近迁移数据的时候突然想起这个事，于是拿出来调了一下。现在 Hexo 修好了，也兼容了新版的 Node.js，可以继续更新了。同时也把整个博客项目整理开源了，在 https://github.com/Menci/oi.men.ci。欢迎大家查阅源代码，以及帮忙修复博客内容错误。

由于我已经离开算法竞赛比较久了，所以这个博客大概不会再有内容上的更新了，只会有错误修正。将来可能会给技术和生活相关的内容开个新的博客，敬请期待~

Goodbye, 2018

2019-01-01T02:15:00.000Z

不知从何时开始，对元旦这种重要节日的概念，开始变得越来越浅 —— 从童年时的日思夜想，到如今，已经不再有什么期待，而只是当做一个平常的周末了。除了多放一天假之外，也便没有多么特殊了。但这总归是一年的结束，新一年的开始，这一年的回忆，大多数都在前半年高三的生活中，那时候便想，自己的故事一定要写给大家看，而现在看来，那些回忆也不过只有寥寥数言，但终究还是要在淡忘之前将他们记录下来，作为人生的一个阶段留下的记号罢。于是，便有了这些文字。

冬令营上的感动

年初的那段日子，昼思夜想的，便是冬令营上想带给全国 OIer 的《退役的你》了。演出的那天，没有机会去现场，便只能在视频直播里，去看着他们收到这一惊喜。那几个月，躺在床上的时候，去思考每一句歌词，坐在电脑旁的时候，去把每一个点点滴滴的素材，拼成这样一个完整的视频。那些看似平凡的画面，听起来朗朗上口的歌词，想必是每一个热爱着这一切的 OIer 心头最大的执念了吧。这也许只是那些 OI 题材的填词里最普通的一首，甚至看起来有些仓促，但这成功地感动了我自己，和那些和我自己一样的退役 OIer。

照亮阴影的阳光

高三这一年的主旋律，也许就是无边的阴影吧。永远做不完的题，永远考不到的目标 …… 身累心更累。看着黑板旁的数字一点点在减少 —— 从两百盼到零，从一月盼到六月，从周一盼到周五，从晨读盼到晚自习 …… 每一天都在孤独中度过 —— 那个时候总在想，如果身边能有哪个朋友能和我说话该多好呀，而再怎么想，都只能让自己更加感到孤独吧。每一次看到同学们一起在走廊里有说有笑地走着，心里都不是滋味。晚上望着教学楼外天空的那种感觉，大概已经淡忘了吧。感到自己努力学习不见成效的时候，看到未来的路变得模糊的时候，才是最失落的时候吧 ……

可就在这些阴暗的日子里，也会有一些期待、一些温暖的呢 …… 每个疲惫的夜晚，看到她的一句晚安总会感觉轻松许多，不管遇到多么难过的事，看到她的消息，总能变得开心起来。每次感到太累想要松懈的时候，想到有那个人在未来等着我，便又有了坚持下去的理由，有了继续努力的动力。

又是一年省选季

又到了四月份。
又到了省选的季节。

看到他们一个个有梦想的 OIer 走上考场的时候，便想到了从前的自己 —— 自从 NOI2017 结束的那一天开始，梦想实现了，梦想也结束了。不管怎么说，那种单纯为了自己喜欢的东西而去努力，不为了任何功利的努力，再也不会有了吧。九省联考的 Day1 结束，看到大家都在担心自己的命运，而有人已经放弃了希望，Day2 结束时，尘埃落定，又是几家欢喜几家愁 …… 竞赛就是这样，任何一次失误都可能成为永远的遗憾，在一层一层的选拔面前，我们每个人，都是命运下的蝼蚁。

看着这场游戏的参与者一年年的更替，从两年前懵懂无知时在空间看到的那句「进队了，谢谢大家」，到现在就连回忆都开始离自己越来越远 …… 留在昨日的，是大半的青春呐 ……

黎明之前的黑暗

五月份，班里终日沉浸在紧张的气氛中，大家都在为高考做着最后的准备。每一次的模拟成绩，都在分数线之上，尽管最低的时候只超过了几分，但总归还是没有低过。就算如此，仍在害怕自己高考会失利。喜欢的人也在忙于学习，没有时间陪我。想让高考来得快一些 —— 这样便不用再过这种日子了；又想让高考来得慢一些 —— 这样就有更多的时间来巩固，让自己更有把握。每天都这样纠结着，不知道该怎么做，偶然一次实验题得了满分，便能高兴一天，而第二天又错了好多选择题，便又在害怕自己考不上。

那一个月的事情，大概已经忘记了吧 —— 谁会总想去记得不好的回忆呢？每天晚上仍然想着自己喜欢的人，似乎又想前一年的某一段时间那样，被感情上的事困扰着。但终究只剩下最后一个月了，就这样迎来了高考。

六月是你的高考

高考的第一天，从学校赶到考场的路上，心里便有些紧张。第一场的语文，不知道为什么，之前从来没有把答题纸写得这么满过。写到作文的时候，时间看起来还很充裕，但写到一半的时候，便发现写得有些慢了，最后仍然是草草地结束了作文。下午的数学出乎了我的意料 —— 模拟考试几乎不会错的题型，有两道大题没做出来，回到家里便心态崩溃，不知道自己晚上是怎么度过的。第二天的理综则中规中矩，但看了答案之后还是感觉选择题没底，计算题也没有记得答案是否正确。

以至于，高考结束后的一段时间，我和家长也都在担心，会不会考不到分数线。公布成绩的那天，我甚是紧张，便躺在床上装作睡觉。客厅里父母在紧张着看着电视刷新成绩查询页面，看到我的成绩时，我听到门外传来惊喜的叫声，便松了一口气。母亲走进我的卧室，抱起我说儿子真厉害的时候，我想，这一切，终于结束了。

看到超过分数线 50 分的成绩，模拟考试中从来没有达到过的成绩，突然感到，这一年的所有付出的努力，所有承受的孤独，都不重要了 —— 不是说它们没有意义，而是说，得到了结果之后，我发现，这些经历也不过如此，既不需要去歌颂，也不需要去回忆。在未来，无论是这五百多分的成绩，还是两百多天的努力，都将和不到两年的 OI 回忆一起，成为永远的历史，成为最亲切的怀念。

大学生活的开始

九月份来到人大的时候，对大学的生活满怀期待 —— 然而刚开始便承受了一次打击 —— 大学宿舍不如高中宿舍好。但之后便习惯了，毕竟这里离校门、食堂和教学楼都很近。和同学们相处的还算融洽，课程也蛮是喜欢。

这边的食堂很好吃，点外卖也很方便，吃饭自然不成问题。因为有高中住宿舍的经历，所以住宿也不成问题。唯一算得上问题的，可能就是学习成绩了 —— 期中的成绩并不理想，而下半个学期也感觉自己没有太大的提升。一边是在提高对自己学习上的要求，另一边也接受了自己不如别人的事实。

新生研讨课上讲道，大学最重要的是找到你自己，找到自己最喜欢做什么。我深知自己在他们中不算优秀的人，在未来，也许我不会有非常长远的目标，但做对这个世界有用的事，做自己喜欢的事，这两个目标总是没错的吧。

The End

正如第一段中所说，一年来的回忆写出来，也不过寥寥数言。从前的每天都觉得自己的故事一定能感动别人，而写出来才发现，只有自己懂得自己的经历。那些快乐或者痛苦的记忆，转眼间，便成为了我们口中的故事，再一转眼间，我们便忘了故事是如何发生的。时间就是这样匆匆而去，我们在为未来奔波的旅途中，又能留下多少回忆呢？

「2018 南京网络预赛」Sum - 线性筛

2018-09-14T22:13:00.000Z

定义为满足以下条件的有序二元组的方案数（即与被认为是不同的方案）：

；
和均为无平方因子数（即其因子中没有除以外的完全平方数）。

求，。

链接

计蒜客 30999

题解

显然，是积性函数，考虑线性筛。

当为素数时，，即与；
当的最小质因子为，且时，；
当的最小质因子为，且时：
- 如果，那么中的指数至少为，即无论如何划分，两个数中一定有一个数中的指数为，即不存在合法的划分方案。
- 否则，中的指数至少为，把这两个分别分给中的和，剩余的就是一个子问题了，即。

代码

#include // #include const int MAXN = 2e7;bool isNotPrime[MAXN + 1];int primes[MAXN + 1], primeCnt;int f[MAXN + 1];inline void sieve() {    f[1] = 1;    for (int i = 2; i <= MAXN; i++) {        if (!isNotPrime[i]) {            primes[++primeCnt] = i;            f[i] = 2;        }        for (int j = 1; j <= primeCnt && (long long)i * primes[j] <= MAXN; j++) {            isNotPrime[i * primes[j]] = true;            if (i % primes[j] == 0) {                f[i * primes[j]] = (i / primes[j] % primes[j] == 0) ? 0 : f[i] / 2;                break;            } else {                f[i * primes[j]] = f[i] * 2;            }        }    }}inline bool isSquareFree(int x) {    for (int i = 2; i * i <= x; i++) {        if (x % i == 0) {            x /= i;            if (x % i == 0) return false;        }    }    return true;}int main() {    sieve();    static int s[MAXN + 1];    for (int i = 1; i <= MAXN; i++) s[i] = s[i - 1] + f[i];    int T;    scanf("%d", &T);    while (T--) {        int n;        scanf("%d", &n);        printf("%d\n", s[n]);    }    // // int cnt = 0;    // std::vector v;    // for (int i = 1; i <= 10000; i++) {    //     if (isSquareFree(i)) v.push_back(i);    //     // if (i % int(1e6) == 0) printf("%d: %d\n", i, cnt);    // }    // // printf("%d\n", cnt);    // static int g[10000];    // for (int i = 0; i < (int)v.size(); i++) {    //     for (int j = 0; j < (int)v.size(); j++) {    //         int x = v[i] * v[j];    //         if (x < 10000) g[x]++;    //     }    // }    // for (int i = 1; i < 10000; i++) {    //     if (f[i] != g[i]) printf("f[%d] = %d, g[%d] = %d\n", i, f[i], i, g[i]);    // }    // int s = 0;    // for (int i = 1; i < 100; i++) printf("%d, ", s += f[i]);    // puts("");}

「NOI2010」超级钢琴 - 可持久化线段树 + 堆

2018-08-18T08:12:00.000Z

给一个长度为的序列，定义一个区间的价值为这个区间中数的总和。求区间长度在之间的所有区间中，价值最大的个区间的价值总和。

链接

BZOJ 2006
Luogu 2048

题解

预处理整个序列的前缀和，将区间的总和转化为。

建立棵可持久化线段树，初始时每棵线段树的维护值均为数组。

首先求出以每个位置为左端点的价值最大的区间（通过线段树查询与前缀和转化得到），将它们加入到堆中。每次从堆中取出最大的区间价值，假设它为，那么在第棵线段树中将处的值置为（以确保这个区间不会被再次使用），并重新求出以为左端点的的价值最大的区间，加入到堆中。以上过程重复次即可得到答案。

时空复杂度均为。

代码

#include #include #include const int MAXN = 500000;const int MAXN_LOG = 19; // Math.log2(500000) = 18.931568569324174struct Value {    int pos;    long long val;    Value() {}    Value(int pos, long long val) : pos(pos), val(val) {}    bool operator<(const Value &other) const {        return val < other.val;    }};extern struct SegT *curr;struct SegT {    SegT *lc, *rc;    int l, r;    Value val;    SegT() {}    SegT(int l, int r, SegT *lc, SegT *rc, const Value &val) : l(l), r(r), lc(lc), rc(rc), val(val) {}    SegT(int l, int r, SegT *lc, SegT *rc) : l(l), r(r), lc(lc), rc(rc), val(std::max(lc->val, rc->val)) {}    SegT *update(int pos, long long newVal) {        if (pos < l || pos > r) return this;        else if (l == r) return new (curr++) SegT(l, r, NULL, NULL, Value(pos, newVal));        else return new (curr++) SegT(l, r, lc->update(pos, newVal), rc->update(pos, newVal));    }    Value query(int l, int r) {        if (l <= this->l && r >= this->r) return val;        else {            int mid = this->l + (this->r - this->l) / 2;            Value res(-1, LLONG_MIN);            if (l <= mid) res = std::max(res, lc->query(l, r));            if (r > mid) res = std::max(res, rc->query(l, r));            return res;        }    }    static SegT *build(int l, int r, long long *a) {        if (l == r) return new (curr++) SegT(l, r, NULL, NULL, Value(l, a[l]));        else {            int mid = l + (r - l) / 2;            return new (curr++) SegT(l, r, build(l, mid, a), build(mid + 1, r, a));        }    }} *segt[MAXN + 1], _pool[MAXN * MAXN_LOG * 2], *curr = _pool;long long sum[MAXN + 1];int min, max;struct Interval {    int l, r, maxPos;    long long val;    Interval() {}    Interval(int l, int r) : l(l), r(r) {        int ql = l + min - 1, qr = std::min(l + max - 1, r);        if (ql > r) val = LLONG_MIN, maxPos = -1;        else {            Value x = segt[l]->query(ql, qr);            val = x.val - sum[l - 1];            maxPos = x.pos;        }        // printf("Interval(%d, %d): ql = %d, qr = %d, maxPos = %d, val = %lld\n", l, r, ql, qr, maxPos, val);    }    bool operator<(const Interval &other) const {        return val < other.val;    }};struct Heap {    Interval a[MAXN + 1];    int n;    void push(const Interval &x) {        int i = ++n;        a[i] = x;        while (i > 1 && a[i / 2] < a[i]) {            std::swap(a[i], a[i / 2]);            i /= 2;        }    }    const Interval &top() {        return a[1];    }    int size() {        return n;    }    void pop() {        a[1] = a[n--];        int i = 1;        while (i * 2 <= n) {            int l = i * 2, r = i * 2 + 1;            int next = r <= n && a[l] < a[r] ? r : l;            if (a[i] < a[next]) {                std::swap(a[next], a[i]);                i = next;            } else break;        }    }} heap;int main() {    int n, k;    scanf("%d %d %d %d", &n, &k, &min, &max);    static int a[MAXN + 1];    for (int i = 1; i <= n; i++) {        scanf("%d", &a[i]);        sum[i] = sum[i - 1] + a[i];    }    SegT *init = SegT::build(1, n, sum);    for (int i = 1; i <= n; i++) segt[i] = init;    for (int i = 1; i <= n; i++) heap.push(Interval(i, n));    long long ans = 0;    while (k--) {        Interval v = heap.top();        heap.pop();        ans += v.val;        // printf("ans += %lld\n", v.val);        segt[v.l] = segt[v.l]->update(v.maxPos, LLONG_MIN);        v = Interval(v.l, v.r);        if (v.val != LLONG_MAX) heap.push(v);    }    printf("%lld\n", ans);}

「NOIP 模拟赛」Azuki loves chess - 数论

2018-07-18T08:53:00.000Z

在一个无穷大的中国象棋棋盘上，马每次可以在一个方向上移动一个单位，在另一个方向上移动两个单位。现将规则改为，马每次可以在一个方向上移动个单位，在另一个方向上移动个单位。问放置在的马能否移动到。

链接

LYOI #406

题解

题意可转化为，判断以下关于的方程是否存在整数解：

将两维分开考虑，即

两式相加得

整理这三个式子得到

结论：这三个二元一次不定方程同时有解，是本题答案为 Yes 的充要条件，即：

必要性显然，下证充分性。

如果前两个方程有解，那么，通过它们的解构造出一组原方程一组可行解的方法是：

所以，原题有解，等价于前两个方程有解，且对应位置的未知数值的奇偶性相同。即，对于以下两个方程，存在一组整数解，使得与奇偶性相同，与奇偶性相同。

我们可以将上式都除去，即

上述方程化为

下面证明，在第三个方程有解的前提条件下，从前两个方程的任意一组解，都可得到一组满足条件（对应未知数的值奇偶性相同）的解。

由于互质，所以它们不可能都是偶数。

-一奇一偶时">当 eadab630-b312-4b03-ad2f-8b731b22c170 一奇一偶时

根据一元二次不定方程的通解公式（为任意整数）：

调整的大小，可以在保持中一个数的奇偶性不变的情况下，调整另一个数的奇偶性。

所以可以通过调整，使得

中的奇偶性与相同，的奇偶性与相同。

-均为奇数时">当 41f69653-1424-42e5-bc5b-5d9c84fd74b4 均为奇数时

方程三有解的充要条件为。而一定是一个偶数（并且其值为，因为互质），所以此时一定是偶数，所以一定均为奇数或均为偶数。

如果均为奇数，以方程一为例，只有当和一奇一偶时，方程才有解，这时一定是一奇一偶。方程二同理。

如果均为偶数，以方程一为例，只有当和均为奇数时，方程才有解，这时一定均为奇数。方程二同理。

Q.E.D.

代码

#include #include int main() {    freopen("chess.in", "r", stdin);    freopen("chess.out", "w", stdout);    int T;    scanf("%d", &T);    while (T--) {        long long a, b, n, m;        scanf("%lld %lld %lld %lld", &a, &b, &n, &m);        puts((n % std::__gcd(a, b) == 0 && m % std::__gcd(a, b) == 0 && (n + m) % std::__gcd(a + b, a - b) == 0) ? "Yes" : "No");    }}

「Codeforces 650D」Zip-line - 树状数组 + LIS

2018-07-06T11:16:00.000Z

给一个序列，每次求原序列的第个数修改为时的最长严格上升子序列长度。

链接

Codeforces 650D

题解

首先，预处理整个序列的 LIS 长度和以第个数结尾的 LIS 长度、以第个数开头的 LIS 长度。

查询时，考虑求包含被修改的数的 LIS 长度。假设被修改的是第个数，那么找到其左边比新值小的数对应的的最大值，加上其右边比新值大的数对应的的最大值，再加上（即把三段拼起来）。如果求得的数比原 LIS 长度更大，则即为答案，否则考虑被修改的数是否一定在 LIS 中。
若被修改的数可以不在 LIS 中，则答案一定不会比原 LIS 长度更小。
若被修改的数一定在 LIS 中，则答案最多减小（从原 LIS 中去掉这个数）。

现在的问题是，如何求出哪些数一定在 LIS 中。

首先，用类似上文中的方法分别求出包含原序列中第个数的 LIS 长度，如果该长度等于原序列的 LIS 长度，则第个数可以在 LIS 中；
对于一个可以在 LIS 中的数，如果左边有比更大的数可以在 LIS 中，则它可以不在 LIS 中；
对于一个可以在 LIS 中的数，如果右边有比更小的数可以在 LIS 中，则它可以不在 LIS 中；

「对于且的，求的最值」可在离散化后用离线加树状数组解决。

代码

#include #include const int MAXN = 400000;const int MAXL = MAXN + MAXN;struct Question {    int pos, newVal, *ans;    bool operator<(const Question &other) const {        return pos < other.pos;    }} q[MAXN + 1];int n, m, a[MAXN + 1], lisLeft[MAXN + 1], lisRight[MAXN + 1], required[MAXN + 1], initAns, cnt;inline int processLis(int *a, int *lis) {    static int tmp[MAXN + 1];    int max = 0;    for (int i = 1; i <= n; i++) {        int x = std::lower_bound(tmp + 1, tmp + max + 1, a[i]) - tmp;        if (x == max + 1) tmp[++max] = a[i];        else tmp[x] = std::min(tmp[x], a[i]);        lis[i] = x;    }    return max;}inline void discrete() {    static int tmp[MAXL + 1];    for (int i = 1; i <= n; i++) tmp[++cnt] = a[i];    for (int i = 1; i <= m; i++) tmp[++cnt] = q[i].newVal;    std::sort(tmp + 1, tmp + cnt + 1);    int *end = std::unique(tmp + 1, tmp + cnt + 1);    for (int i = 1; i <= n; i++) a[i] = std::lower_bound(tmp + 1, end, a[i]) - tmp;    for (int i = 1; i <= m; i++) q[i].newVal = std::lower_bound(tmp + 1, end, q[i].newVal) - tmp;}struct BinaryIndexedTree {    int a[MAXL + 1], n;    static int lowbit(int x) {        return x & -x;    }    void init(int n) {        this->n = n;        std::fill(a + 1, a + n + 1, 0);    }    int query(int pos) {        int res = 0;        for (int i = pos; i > 0; i -= lowbit(i)) res = std::max(res, a[i]);        return res;    }    void update(int pos, int x) {        for (int i = pos; i <= MAXL; i += lowbit(i)) a[i] = std::max(a[i], x);    }} bit;inline void determineRequire() {    static int len[MAXN + 1];    bit.init(cnt);    for (int i = 1; i <= n; i++) {        len[i] += bit.query(a[i] - 1);        bit.update(a[i], lisLeft[i]);    }    bit.init(cnt);    for (int i = n; i >= 1; i--) {        len[i] += bit.query(cnt - a[i] + 1 - 1);        bit.update(cnt - a[i] + 1, lisRight[i]);    }    // for (int i = 1; i <= n; i++) printf("%d%c", len[i], " \n"[i == n]);    static bool usable[MAXN + 1];    for (int i = 1; i <= n; i++) if (len[i] + 1 == initAns) usable[i] = required[i] = true;    int max = 0;    for (int i = 1; i <= n; i++) {        if (max >= a[i]) required[i] = false;        if (usable[i]) max = std::max(max, a[i]);    }    int min = cnt + 1;    for (int i = n; i >= 1; i--) {        if (min <= a[i]) required[i] = false;        if (usable[i]) min = std::min(min, a[i]);    }}inline void solve() {    std::sort(q + 1, q + m + 1);    bit.init(cnt);    for (int i = 1, j = 1; i <= n && j <= m; i++) {        for (; j <= m && q[j].pos == i; j++) *q[j].ans += bit.query(q[j].newVal - 1);        bit.update(a[i], lisLeft[i]);    }    bit.init(cnt);    for (int i = n, j = m; i >= 1 && j >= 1; i--) {        for (; j >= 1 && q[j].pos == i; j--) *q[j].ans += bit.query(cnt - q[j].newVal + 1 - 1);        bit.update(cnt - a[i] + 1, lisRight[i]);    }    for (int i = 1; i <= m; i++) {        (*q[i].ans)++;        if (!required[q[i].pos]) *q[i].ans = std::max(*q[i].ans, initAns);        else *q[i].ans = std::max(*q[i].ans, initAns - 1);    }}int main() {    scanf("%d %d", &n, &m);    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);    static int ans[MAXN + 1];    for (int i = 1; i <= m; i++) {        scanf("%d %d", &q[i].pos, &q[i].newVal);        q[i].ans = &ans[i];    }    discrete();    initAns = processLis(a, lisLeft);        static int revA[MAXN + 1];    for (int i = 1; i <= n; i++) revA[i] = -a[n - i + 1];    processLis(revA, lisRight);    std::reverse(lisRight + 1, lisRight + n + 1);    determineRequire();    // for (int i = 1; i <= n; i++) printf("%d%c", lisLeft[i], " \n"[i == n]);    // for (int i = 1; i <= n; i++) printf("%d%c", lisRight[i], " \n"[i == n]);    // for (int i = 1; i <= n; i++) printf("%d%c", required[i], " \n"[i == n]);    solve();    for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);}

梦结束的地方

2017-08-30T18:50:00.000Z

“终于 …… 要离开了吗 ……”

徘徊在绍兴一中的校园里，不舍地望着这里的一切，仿佛这曾是我所拥有的全部。

这里，是梦成真的地方；也是，梦结束的地方 ……

一

我叫 Menci，是个准高中生。

OI 的学习是那年暑假开始的，八月初，第一次走进小机房的时候，我从没想过这会改变我整个高中的命运。

从那时起，ljz 学长便成了我很好的朋友。学长的教导总是有用的，无论在学习或是其它的方面。

那时候看着 Vijos 首页上写的「北京第八十中学」，好奇着「北京到底有多少中学？」从来不敢想自己有一天也能认识这个学校的人，更不敢想这个学校的人会看到我的 OJ。看着 Luogu 的花哨的 UI，也不敢想自己有一天能认识这个网站的主人。

开学后不就便是联赛，至今记得赛场上想出一道题时的兴奋，和调过大样例后长舒的一口气 —— 那是我第一次拿到一等奖。小机房的生活不久便结束了，学长们退役了，LYOI 便只剩下我一个人，和与我一级的新生。

二

我叫 Menci，是个无名蒟蒻。

第一次进入 OI「圈子」，便是那个在贴吧上看到的群吧。很难想象，正是一个在我今天看来再普通不过的群，正式开始了我的 OI 生涯。

不久后便认识了一些同在山东的 OIer，他们大多是高二。从那时起，我便了解到，从 NOIP 到省选再到 NOI，是多么远的路。

第一次「面基」，就是在 WC2016 了吧。也便是那时候见的 fqk、yzy 和 sxb；印象最深的是「yts 大爷」当时做的题，我至今还不会；偶然的机会认识了 Sengxian，后来成了很好的朋友 …… 那次 WC 让我知道了这个圈子是有多么的大，我想，总有一天，我也要成为这个圈子里不平凡的一员。

回到学校之后的事情，没有什么可讲的了。整个下学期都在停课，三月份，我去了安师大附中集训，相比于集训，更重要的是认识了来自河南的可爱的学姐 Fancy，对我 OI 生涯影响最大的人之一。

那之后又去了省常中集训，很多事已经不怎么记的住了，而印象最深的就是那个时候认识了~小学弟~ Leaves 吧。

三

我叫 Menci，是个 NOI 选手。

五月份的 CTSC / APIO 像是去北京旅游了一趟，印象最深的就是第一次住那么高档的酒店，还有久闻大名的「北京第八十中学」。成绩当然也没有想象中那么好。

六月份的 PKUSC 我没有参加，刚好是那几天，认识了新高一的小学妹 lyx。后来，她便是我在下一届中最看中的人，也是我非常重要的朋友。我一直在努力的去做一个「善良的学长」，但终究还是受限于能力 ……

省选的失利并不是一件多么严重的事，毕竟这才是高一，抱着试试看的心态申请了 D 类，结果竟然过了。我便成为了临沂一中的第一个 NOI 选手，虽然只拿了铜牌，但在当时看来已经是值得骄傲的成绩了吧。NOI 的最后两天晚上，和 zyz 去操场上聊了好久，关于过往，关于 OI，关于未来。也便是那时候，zyz 成了我最好的朋友。

八月份回到学校便开始给同一级的同学出题，说是出题，不过是一些把现有的 idea「转化」为成题罢了。同时也搭建了自己的 OJ，那便是后来的 ly.men.ci。

四

我叫 Menci，是个碌碌无为的人。

高二上学期一直是半停课状态，NOIP 之后还在担心成绩，但也还是没有想象中那么差的。没有进全省前十名是个遗憾，没上 500 分也是的。

那段时间被感情所折磨的恐惧，可不是每个人都能感受得到吧。那让我真正的感觉到自己是多么的有软弱与无能。好在，那样的事，终究不会有第二次了吧。

浪费掉的时间，也不会再有了。

五

我叫 Menci，是个有名蒟蒻。

冬令营上的《膜你抄》很成功，很多人都是从那时起认识 Menci 的。梦寐以求的在全国 OIer 面前表演节目，那便是我最快乐的时刻了吧。

三月份的雅礼集训，终于见识到了那些强校选手的整体实力，我思考着，强校到底是好是坏呢，如果我生在强校，但水平没有那么高，我还会有这么多机会吗 ……

终于，我站在了一个被羡慕的位置上。

可是，我真的值得羡慕吗 ……

省选失利，PKUSC 协议对 D 类无效，我想，只有名气没有实力，也是一种悲哀吧 ……

六

我叫 Menci，是个 OIer。

三次省队集训，学到了很多东西，当然也都是过着集体生活的快乐的时光。终于，倒计时开始了，作为一个 OIer 的时间，已经「过一天少一天」的在流逝了。

五月，六月，七月，好像昨天还是省选后的哭泣，明天就要去 NOI 了。

坐在去绍兴的火车上，想着，这是最后一站了吧。

不久前不还在说「高一不要有压力，还有一次机会」吗？

这一年一点都不漫长，像是很充实，又像是在虚度。

晚上和他们一起，最后一次练习那些模板。

睡觉的时候，心情仍是如此的平静。

Day1 结束了，社会活动日，所有人都在愉快地玩耍。

终于，在 Day2 考场上，最后一分钟，保存了程序，在闪烁的命令行下打出「AFO」。

签约，最终选择了人大，满意的结果。

回到宿舍，看着来时的行李，不敢相信这就是我的最后一程。

我想让自己醒来，就像之前那样，可惜，这就是现实了。

终于，我用两年的青春，换来了一块银牌，和一纸协议。

我成功了。

七

我叫 Menci，是个退役的 OIer。

最初的时候，我们都在想，要取得什么样的成绩。殊不知，中间的经历，才是最珍贵的。

总有人说，看戏人终成戏中人。实际上，戏中人，也终成看戏人。下一个赛季依然是那么华丽 ——
只是，那都不属于我了。

“终于 …… 要离开了吗 ……”

徘徊在绍兴一中的校园里，不舍地望着这里的一切，仿佛这曾是我所拥有的全部。

这里，是梦成真的地方；也是，梦结束的地方 ……

「Codeforces 808G」Anthem of Berland - KMP + DP

2017-05-27T10:55:00.000Z

给一个含有字母以及 ? 的串和一个含有字母的串，其中 ? 可以匹配任何字符，求串最多匹配串多少次。

链接

Codeforces 808G

题解

对进行 KMP，用类似 AC 自动机的方法预处理出串的前个字符加上字符后，其后缀最多能匹配串多长的前缀。

设表示串的前个字符，其后缀最长匹配到串的前缀长度为，串的最多匹配次数，刷表转移。

代码

#include #include #include const int MAXN = 1e5;int main() {    static char s[MAXN + 2], t[MAXN + 2];    scanf("%s %s", s + 1, t + 1);    int n = strlen(s + 1), m = strlen(t + 1);    static int ch[MAXN + 1][26], fail[MAXN + 1];    for (int i = 1; i <= m; i++) ch[i - 1][t[i] - 'a'] = i;    for (int i = 1, k = 0; i <= m; i++) {        if (i > 1) {            while (k && t[k + 1] != t[i]) k = fail[k];            if (t[k + 1] == t[i]) fail[i] = ++k;            else fail[i] = 0;            // printf("fail[%d] = %d\n", i, fail[i]);        }        for (int j = 0; j < 26; j++) {            if (!ch[i][j]) {                ch[i][j] = ch[fail[i]][j];            }        }    }    std::vector< std::vector<int> > f(n + 1, std::vector<int>(m + 1, -1));    f[0][0] = 0;    for (int i = 0; i < n; i++) {        for (int j = 0; j <= m; j++) {            if (f[i][j] == -1) continue;            // printf("f(%d, %d) = %d\n", i, j, f[i][j]);            for (int c = s[i + 1] == '?' ? 0 : (s[i + 1] - 'a'); c < (s[i + 1] == '?' ? 26 : (s[i + 1] - 'a' + 1)); c++) {                f[i + 1][ch[j][c]] = std::max(f[i + 1][ch[j][c]], f[i][j] + (ch[j][c] == m));            }        }    }    int ans = 0;    for (int i = 0; i <= m; i++) ans = std::max(ans, f[n][i]);    printf("%d\n", ans);}

「APIO2013」TOLL - 搜索 + 最小生成树

2017-05-27T10:31:00.000Z

幸福国度可以用个城镇（用到编号）构成的集合来描述，这些城镇最开始由条双向道路（用到编号）连接。城镇是中央城镇。保证一个人从城镇出发，经过这些道路，可以到达其他的任何一个城市。这些道路都是收费道路，道路的使用者必须向道路的主人支付分钱的费用。已知所有的这些是互不相等的。最近有条新道路建成，这些道路都属于亿万富豪 Mr. Greedy。

Mr. Greedy 可以决定每条新道路的费用（费用可以相同），并且他必须在明天宣布这些费用。

两周以后，幸福国度将举办一个盛况空前的嘉年华！大量的参与者将沿着这些道路游行并前往中央城镇。共计个参与者将从城镇出发前往中央城镇。这些人只会沿着一个选出的道路集合前行，并且这些选出的道路将在这件事的前一天公布。根据一个古老的习俗，这些道路将由幸福国度中最有钱的人选出，也就是 Mr. Greedy。同样根据这个习俗，Mr. Greedy 选出的这个道路集合必须使所有选出道路的费用之和最小，并且仍要保证任何人可以从城镇前往城镇（因此，这些选出的道路来自将费用作为相应边边权的“最小生成树”）。如果有多个这样的道路集合，Mr. Greedy 可以选其中的任何一个，只要满足费用和是最小的。

Mr. Greedy 很明确地知道，他从条新道路中获得的收入不只是与费用有关。一条道路的收入等于所有经过这条路的人的花费之和。更准确地讲，如果个人经过道路，道路产生的收入为乘积。注意 Mr. Greedy 只能从新道路收取费用，因为原来的道路都不属于他。

Mr. Greedy 有一个阴谋。他计划通过操纵费用和道路的选择来最大化他的收入。他希望指定每条新道路的费用（将在明天公布），并且选择嘉年华用的道路（将在嘉年华的前一天公布），使得他在条新道路的收入最大。注意 Mr. Greedy 仍然需要遵循选出花费之和最小的道路集合的习俗。

你是一个记者，你想揭露他的计划。为了做成这件事，你必须先写一个程序来确定 Mr. Greedy 可以通过他的阴谋获取多少收入。

链接

BZOJ 3206
UOJ #108

题解

问题的本质是，用条边中的一些边去替换最小生成树中的边，使得最小生成树大小不变，并使得每条新边的经过次数乘上边权的总和最大。

如果我们将所有条新边都加入到最小生成树中，然后从小到大加入原有的边。考虑这些仍然被加入到最小生成树中的旧边，这些边是无论如何都要被加入的 —— 所以可以缩点，缩点后只会剩下个点，剩下的旧边只会有条。搜索条边要选哪些，将其加入后从小到大加入旧边，之后每一条边都会使到路径上的所有新边的权值对其权值取。

并查集维护这个取的过程即可。

代码

#include #include #include #include #include #include #include const int __buffsize = 500000;char __buff[__buffsize];char *__buffs, *__buffe;#define getchar() (__buffs == __buffe ? fread(__buff, 1, __buffsize, stdin), __buffe = __buff + __buffsize, *((__buffs = __buff)++) : *(__buffs++))inline int read() {    static int n, ch;    n = 0, ch = getchar();    while (!isdigit(ch)) ch = getchar();    while (isdigit(ch)) n = n * 10 + ch - '0', ch = getchar();    return n;}const int MAXN = 100000;const int MAXK = 20;const int MAXM = 300000 + MAXK;struct Node {    std::vector<struct Edge> e;    Node *fa;    int w, dep;    long long s, initS;    bool modifiable;} N[MAXK + 1 + 1];struct Edge {    Node *s, *t;    int w;    Edge(Node *s, Node *t, int w) : s(s), t(t), w(w) {}};inline void addEdge(int s, int t, int w) {#ifdef DBG    printf("addEdge(%d, %d, %d)\n", s, t, w);#endif    N[s].e.push_back(Edge(&N[s], &N[t], w));    N[t].e.push_back(Edge(&N[t], &N[s], w));}struct PlainEdge {    int u, v, w;    bool selected;    bool operator<(const PlainEdge &other) const {        return w < other.w;    }} E[MAXM + 1], newE[MAXM + 1];int n, m, k, p[MAXN + 1], cnt, belong[MAXN + 1], edgeCnt;struct UnionFindSet {    int fa[MAXN + 1];    void init(int n) {        for (int i = 1; i <= n; i++) fa[i] = i;    }    void merge(int x, int y) {        fa[find(x)] = find(y);    }    int find(int x) {        return x == fa[x] ? x : fa[x] = find(fa[x]);    }} ufs;inline void prepare() {    // Kruskal    ufs.init(n);    for (int i = m + 1; i <= m + k; i++) {        ufs.merge(E[i].u, E[i].v);    }    std::sort(E + 1, E + m + 1);    for (int i = 1; i <= m; i++) {        if (ufs.find(E[i].u) != ufs.find(E[i].v)) {            E[i].selected = true;            ufs.merge(E[i].u, E[i].v);#ifdef DBG            printf("Must Select Edge: (%d, %d, %d)\n", E[i].u, E[i].v, E[i].w);#endif        }    }    // Discrete    ufs.init(n);    for (int i = 1; i <= m; i++) if (E[i].selected) ufs.merge(E[i].u, E[i].v);    static int a[MAXN + 1];    for (int i = 1; i <= n; i++) a[i] = ufs.find(i);    static int set[MAXN + 1];    std::copy(a + 1, a + n + 1, set + 1);    std::sort(set + 1, set + n + 1);    int *end = std::unique(set + 1, set + n + 1);    for (int i = 1; i <= n; i++) {        belong[i] = std::lower_bound(set + 1, end, a[i]) - set;#ifdef DBG        printf("%d belongs to block %d\n", i, belong[i]);#endif        N[belong[i]].initS += p[i];    }    cnt = end - (set + 1);    static int w[MAXK + 2][MAXK + 2];    for (int i = 1; i <= cnt; i++) for (int j = 1; j <= cnt; j++) w[i][j] = INT_MAX;    for (int i = 1; i <= m; i++) {        if (E[i].selected) continue;        int u = belong[E[i].u], v = belong[E[i].v];        w[u][v] = w[v][u] = std::min(w[v][u], E[i].w);    }    for (int i = 1; i <= cnt; i++) {        for (int j = i + 1; j <= cnt; j++) {            if (w[i][j] != INT_MAX) {                edgeCnt++;                newE[edgeCnt].u = i;                newE[edgeCnt].v = j;                newE[edgeCnt].w = w[i][j];                // addEdge(i, j, w[i][j]);            }        }    }    std::sort(newE + 1, newE + edgeCnt + 1);    // assert(belong[1] == 1);}inline void dfs(Node *v, Node *fa = NULL) {    v->s = v->initS;    for (Edge *e = &v->e.front(); e && e <= &v->e.back(); e++) {        if (e->t == fa) continue;        e->t->modifiable = e->w == INT_MAX;        e->t->w = e->w;        e->t->fa = v;        e->t->dep = v->dep + 1;        dfs(e->t, v);        v->s += e->t->s;    }}inline void clear() {    for (int i = 1; i <= edgeCnt; i++) newE[i].selected = false;    for (int i = 1; i <= cnt; i++) {        N[i].modifiable = false;        N[i].w = N[i].dep = N[i].s = 0;        N[i].fa = NULL;        N[i].e.clear();    }#ifdef DBG    puts("[Cleared]");#endif}/*inline Node *lca(Node *u, Node *v) {    for (; u != v; u = u->fa) if (u->dep < v->dep) std::swap(u, v);    return u;}*/inline void applyMin(int u, int v, int w) {    /*    Node *p = lca(&N[u], &N[v]);    for (Node *a = &N[u]; a != p; a = a->fa) if (a->modifiable) a->w = std::min(a->w, w);    for (Node *a = &N[v]; a != p; a = a->fa) if (a->modifiable) a->w = std::min(a->w, w);    */    // printf("apply min (%d, %d, %d)\n", v, u, w);    u = ufs.find(u);    v = ufs.find(v);    while (u != v) {        if (N[u].dep < N[v].dep) std::swap(u, v);        if (N[u].modifiable) N[u].w = w;        ufs.merge(u, N[u].fa - N);        u = ufs.find(u);    }}inline long long solve() {    long long ans = 0;    for (int s = 0; s < (1 << k); s++) {        clear();        ufs.init(cnt);        // k new edges        bool circle = false;        for (int i = 0; i < k; i++) {            if (s & (1 << i)) {                int u = belong[E[m + 1 + i].u], v = belong[E[m + 1 + i].v];                if (ufs.find(u) != ufs.find(v)) {                    ufs.merge(u, v);                    addEdge(u, v, INT_MAX);                } else {                    circle = true;                    break;                }            }        }        if (circle) continue;        // Old edges        for (int i = 1; i <= edgeCnt; i++) {            if (ufs.find(newE[i].u) != ufs.find(newE[i].v)) {                ufs.merge(newE[i].u, newE[i].v);                newE[i].selected = true;                addEdge(newE[i].u, newE[i].v, newE[i].w);            }        }        /*        for (int i = 1; i <= cnt; i++) {            for (int j = i + 1; j <= cnt; j++) {                if (w[i][j] != INT_MAX) {                    if (ufs.find(i) != ufs.find(j)) {                        ufs.merge(i, j);                        selected[i][j] = true;                        addEdge(i, j, w[i][j]);                    }                }            }        }        */        dfs(&N[belong[1]]);        ufs.init(cnt);        for (int i = 1; i <= edgeCnt; i++) {            if (!newE[i].selected) {                applyMin(newE[i].u, newE[i].v, newE[i].w);            }        }        long long sum = 0;        for (int i = 1; i <= cnt; i++) {            if (N[i].modifiable) sum += N[i].s * N[i].w;        }        ans = std::max(ans, sum);    }    return ans;}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();        // scanf("%d %d %d", &E[i].u, &E[i].v, &E[i].w);    }    for (int i = m + 1; i <= m + k; i++) {        E[i].u = read();        E[i].v = read();        // scanf("%d %d", &E[i].u, &E[i].v);        E[i].w = -1;    }    for (int i = 1; i <= n; i++) p[i] = read(); // scanf("%d", &p[i]);    prepare();    printf("%lld\n", solve());}

「APIO2014」Split the sequence - 斜率优化 DP

2017-05-26T21:48:00.000Z

你正在玩一个关于长度为的非负整数序列的游戏。这个游戏中你需要把序列分成个非空的块。为了得到块，你需要重复下面的操作次：

选择一个有超过一个元素的块（初始时你只有一块，即整个序列）
选择两个相邻元素把这个块从中间分开，得到两个非空的块。

每次操作后你将获得那两个新产生的块的元素和的乘积的分数。你想要最大化最后的总得分。

链接

BZOJ 3675
UOJ #104

题解

首先，可以发现分割顺序对答案不影响，所以可以 DP，设表示前个数分成段的答案，设为前缀和，则

时间复杂度为，考虑优化

设，上式化为

设考虑两个决策和，比优当且仅当

斜率优化。

代码

#include #include #include #include const int MAXN = 100000;const int MAXK = 200;long long f[MAXK + 1][MAXN], *f0;int n, t, g[MAXK + 1][MAXN];long long s[MAXN + 1];inline long long F(int i) {    return f0[i] - s[i] * s[n];}inline double slope(int k1, int k2) {    return s[k2] == s[k1] ? -DBL_MAX : (double)(F(k1) - F(k2)) / (s[k2] - s[k1]);}inline long long solve() {    long long ans = 0;    for (int j = 1; j <= t; j++) {        f0 = f[j - 1];        static int q[MAXN + 1];        int *l = q, *r = q - 1;        *++r = j - 1;        for (int i = j; i < n; i++) {            while (r - l >= 1 && slope(*l, *(l + 1)) <= s[i]) l++;            f[j][i] = F(*l) + s[i] * (s[n] - s[i] + s[*l]);            g[j][i] = *l;            // printf("f(%d, %d) = %lld (%d)\n", i, j, f[j][i], *l);            ans = std::max(ans, f[j][i]);            while (r - l >= 1 && slope(*r, i) < slope(*(r - 1), *r)) r--;            *++r = i;            // *++r = f0[i] - s[i] * s[n];        }    }    return ans;}int main() {    scanf("%d %d", &n, &t);    static int a[MAXN + 1];    for (int i = 1; i <= n; i++) {        scanf("%d", &a[i]);        s[i] = s[i - 1] + a[i];    }    /*    static long long f[MAXN + 1][MAXK + 1];    static int g[MAXN + 1][MAXK + 1];    // long long ans = 0;    for (int j = 1; j <= t; j++) {        for (int i = j; i <= n; i++) {            for (int k = j - 1; k <= i - 1; k++) {                if (f[i][j] < f[k][j - 1] + (s[i] - s[k]) * (s[n] - s[i])) {                    f[i][j] = f[k][j - 1] + (s[i] - s[k]) * (s[n] - s[i]);                    // ans = std::max(ans, f[i][j]);                    g[i][j] = k;                }            }            printf("f(%d, %d) = %lld (%d)\n", i, j, f[i][j], g[i][j]);        }    }    */    long long ans = solve();    printf("%lld\n", ans);    for (int i = n - 1; i >= 0; i--) {        if (f[t][i] == ans) {            printf("%d", i);            for (int k = t, p = g[t][i], cnt = 1; cnt < t; p = g[--k][p], cnt++) printf(" %d", p);            puts("");            goto end;        }    }end:;}

「CTSC2012」Cheat - SAM + 二分 + 单调队列 DP

2017-04-06T21:09:00.000Z

给出个串组成的「标准作文库」。对于任意一个串，如果它的长度不少于且在标准作文库中出现过，则它是「熟悉」的。对于任意一个串，如果能将它划分为若干个串，使「熟悉」的串的长度超过总长度的，则称这个串是「熟悉的文章」，定义为使这个串成为「熟悉的文章」的最大的。给出若干个串，求每个串的值。

链接

BZOJ 2806

题解

对标准做文库中的串建立 SAM，将每个串在 SAM 上运行，求出以每个字符结尾的最长匹配长度。二分一个，设表示前个字符划分为若干个串，「熟悉」的串的长度和的最大值，则有

化为这种形式

单调队列优化即可。

代码

#include #include #include const int MAXN = 1100000;const int CHARSET_SIZE = 3;const double EPS = 1e-6;struct SuffixAutomaton {    struct Node {        Node *ch[CHARSET_SIZE], *next;        int max;        Node(int max = 0) : ch(), next(NULL), max(max) {}    } *start, *last;    void init() {        start = last = new Node;    }    Node *extend(int c) {        Node *u = new Node(last->max + 1), *v = last;        do {            v->ch[c] = u;            v = v->next;        } while (v && !v->ch[c]);        if (!v) {            u->next = start;        } else if (v->ch[c]->max == v->max + 1) {            u->next = v->ch[c];        } else {            Node *n = new Node(v->max + 1), *o = v->ch[c];            std::copy(o->ch, o->ch + CHARSET_SIZE, n->ch);            n->next = o->next;            o->next = u->next = n;            for (; v && v->ch[c] == o; v = v->next) v->ch[c] = n;        }        last = u;        return u;    }} sam;char s[MAXN + 2];int len, matchLen[MAXN + 1];inline void match() {    SuffixAutomaton::Node *v = sam.start;    int matched = 0;    for (int i = 1; i <= len; i++) {        int c = s[i] - '0';        while (v != sam.start && !v->ch[c]) {            v = v->next;            matched = v->max;        }        if (v->ch[c]) {            v = v->ch[c];            matched++;        }        matchLen[i] = matched;        // printf("%d, matched = %d\n", c, matched);    }}/*inline bool check(int l) {    // printf("l = %d\n", l);    static int f[MAXN + 1];    std::fill(f + 1, f + len + 1, 0);    for (int i = 1; i <= len; i++) {        f[i] = f[i - 1];        for (int j = i - matchLen[i]; j <= i - l; j++) {            // f[i] = std::max(f[i], f[j] + (i - j));            f[i] = std::max(f[i], f[j] - j + i);        }        // printf("f[%d] = %d\n", i, f[i]);    }    return f[len] + EPS >= len * 0.9;}*/inline bool check(int l) {    static int q[MAXN + 1], f[MAXN + 1];    int *ql = q, *qr = q - 1;    std::fill(f + 1, f + len + 1, 0);    for (int i = 1; i <= len; i++) {        f[i] = f[i - 1];        // Insert curr pos        int curr = i - l;        if (curr >= 0) {            while (ql <= qr && f[curr] - curr > f[*qr] - *qr) qr--;            *++qr = curr;        }        // Remove invalid pos        while (ql <= qr && *ql < i - matchLen[i]) ql++;        // Get best pos        if (ql <= qr) f[i] = std::max(f[i], f[*ql] - *ql + i);    }    return f[len] + EPS >= len * 0.9;}int main() {    int n, m;    scanf("%d %d", &n, &m);    sam.init();    while (m--) {        scanf("%s", s + 1);        int len = strlen(s + 1);        for (int i = 1; i <= len; i++) sam.extend(s[i] - '0');        if (m) sam.extend(2);    }    while (n--) {        scanf("%s", s + 1);        len = strlen(s + 1);        match();        /*        check(4);        break;        */        int l = 0, r = len;        while (l < r) {            int mid = l + (r - l) / 2 + 1;            if (check(mid)) l = mid;            else r = mid - 1;        }        printf("%d\n", l);    }}

「BZOJ 2555」SubString - SAM + LCT

2017-04-06T17:53:00.000Z

在当前字符串的后面插入一个字符串；
询问字符串在当前字符串中出现了几次？（作为连续子串）

链接

BZOJ 2555

题解

在线查询字符串的出现次数，需要在线维护集合的大小。使用 Link-Cut Tree 维护有根树的子树和。每次 Link 两个节点后，重新将根节点置为有根树的根，然后将子节点的权值加到父节点到根的一条链上；反之，Cut 后要将其减去。

代码

#include #include #include const int MAXN = 600000;const int MAXL = 3000000;const int MAXM = 10000;const int CHARSET_SIZE = 26;struct LinkCutTree {    struct Node {        Node *ch[2], *fa, *pathFa;        int val, tag;        bool rev;        int relation() {            return this == fa->ch[1];        }        void pushDown() {            if (rev) {                rev ^= 1;                std::swap(ch[0], ch[1]);                if (ch[0]) ch[0]->rev ^= 1;                if (ch[1]) ch[1]->rev ^= 1;            }            if (tag) {                if (ch[0]) ch[0]->add(tag);                if (ch[1]) ch[1]->add(tag);                tag = 0;            }        }        void rotate() {            pushDown();            int r = relation();            Node *o = fa;            std::swap(pathFa, o->pathFa);            fa = o->fa;            if (o->fa) o->fa->ch[o->relation()] = this;            o->ch[r] = ch[r ^ 1];            if (ch[r ^ 1]) ch[r ^ 1]->fa = o;            ch[r ^ 1] = o;            o->fa = this;        }        void splay() {            while (fa) {                if (fa->fa) fa->fa->pushDown();                fa->pushDown();                if (!fa->fa) rotate();                else if (fa->relation() == relation()) fa->rotate(), rotate();                else rotate(), rotate();            }        }        void expose() {            splay();            pushDown();            if (ch[1]) {                std::swap(ch[1]->fa, ch[1]->pathFa);                ch[1] = NULL;            }        }        bool splice() {            splay();            if (!pathFa) return false;            pathFa->expose();            pathFa->ch[1] = this;            std::swap(pathFa, fa);            return true;        }        void access() {            expose();            while (splice());        }        void evert() {            access();            splay();            rev ^= 1;        }        void add(int delta) {            val += delta;            tag += delta;        }    } N[MAXN * 2 + 1];    void link(int fa, int ch) {        Node *f = &N[fa], *c = &N[ch];        f->evert();        c->splay();        c->pathFa = f;        N[0].evert();        f->access();        f->splay();        f->val += c->val;        if (f->ch[0]) f->ch[0]->add(c->val);    }    void cut(int fa, int ch) {        Node *f = &N[fa], *c = &N[ch];        f->evert();        c->access();        f->splay();        f->pushDown();        f->ch[1] = NULL;        c->fa = NULL;        N[0].evert();        f->access();        f->splay();        f->val -= c->val;        if (f->ch[0]) f->ch[0]->add(-c->val);    }    void update(int u, int val) {        N[u].val = val;    }    int query(int u) {        Node *a = &N[u];        a->splay();        return a->val;    }} lct;struct SuffixAutomaton {    struct Node {        Node *ch[CHARSET_SIZE], *next;        int max;        Node(int max = 0) : ch(), next(NULL), max(max) {}    } *start, *last, _pool[MAXN * 2 + 1], *_curr;    void init() {        _curr = _pool;        start = last = new (_curr++) Node;    }    int id(Node *v) {        return v - _pool;    }    Node *extend(int c) {        Node *u = new (_curr++) Node(last->max + 1), *v = last;        lct.update(id(u), 1);        do {            v->ch[c] = u;            v = v->next;        } while (v && !v->ch[c]);        if (!v) {            u->next = start;            lct.link(id(start), id(u));        } else if (v->ch[c]->max == v->max + 1) {            u->next = v->ch[c];            lct.link(id(v->ch[c]), id(u));        } else {            Node *n = new (_curr++) Node(v->max + 1), *o = v->ch[c];            std::copy(o->ch, o->ch + CHARSET_SIZE, n->ch);            lct.cut(id(o->next), id(o));            lct.link(id(o->next), id(n));            lct.link(id(n), id(o));            lct.link(id(n), id(u));            n->next = o->next;            o->next = u->next = n;            for (; v && v->ch[c] == o; v = v->next) v->ch[c] = n;        }        last = u;        return u;    }} sam;char s[MAXL + 2];int len;inline void decode(int mask) {    for (int i = 0; i < len; i++) {        mask = (mask * 131 + i) % len;        std::swap(s[i + 1], s[mask + 1]);    }}inline void extend() {    for (int i = 1; i <= len; i++) sam.extend(s[i] - 'A');}inline int solve() {    SuffixAutomaton::Node *v = sam.start;    for (int i = 1; i <= len; i++) {        int c = s[i] - 'A';        if (!v->ch[c]) return 0;        v = v->ch[c];    }    return lct.query(sam.id(v));}int main() {    int q;    scanf("%d", &q);    sam.init();    scanf("%s", s + 1);    len = strlen(s + 1);    extend();    int mask = 0;    while (q--) {        char type[sizeof("QUERY")];        scanf("%s %s", type, s + 1);        len = strlen(s + 1);        decode(mask);        // puts(s + 1);        if (type[0] == 'Q') {            int ans = solve();            printf("%d\n", ans);            mask ^= ans;        } else {            extend();        }    }    return 0;}

「TJOI2015」弦论 - SAM

2017-04-06T16:46:00.000Z

对于一个给定长度为的字符串，求它的字典序第小的子串。

链接

BZOJ 3998

题解

对串建立 SAM，预处理出每个节点沿着转移边向下走能走到的节点数量和节点的大小之和，然后用类似权值线段树的方式查找第小。

代码

#include #include #include const int MAXN = 5e5;const int CHARSET_SIZE = 26;struct SuffixAutomaton {    struct Node {        Node *ch[CHARSET_SIZE], *next;        int max, posCnt, size, sizeAll;        Node(int max = 0, bool newSuffix = false) : ch(), next(NULL), max(max), posCnt(newSuffix) {}        int getMin() {            return next->max + 1;        }    } *start, *last, _pool[MAXN * 2 + 1], *_curr;    std::vector<Node *> topo;    void init() {        _curr = _pool;        start = last = new (_curr++) Node;    }    Node *extend(int c) {        Node *u = new (_curr++) Node(last->max + 1, true), *v = last;        do {            v->ch[c] = u;            v = v->next;        } while (v && !v->ch[c]);        if (!v) {            u->next = start;        } else if (v->ch[c]->max == v->max + 1) {            u->next = v->ch[c];        } else {            Node *n = new (_curr++) Node(v->max + 1, false), *o = v->ch[c];            std::copy(o->ch, o->ch + CHARSET_SIZE, n->ch);            n->next = o->next;            o->next = u->next = n;            for (; v && v->ch[c] == o; v = v->next) v->ch[c] = n;        }        last = u;        return u;    }    std::vector<Node *> &toposort() {        static int buc[MAXN * 2 + 1];        int max = 0;        for (Node *p = _pool; p != _curr; p++) {            max = std::max(max, p->max);            buc[p->max]++;        }        for (int i = 1; i <= max; i++) buc[i] += buc[i - 1];        topo.resize(_curr - _pool);        for (Node *p = _pool; p != _curr; p++) {            topo[--buc[p->max]] = p;        }        return topo;    }    void calc() {        toposort();        for (int i = topo.size() - 1; i > 0; i--) {            Node *v = topo[i];            v->next->posCnt += v->posCnt;        }        for (int i = topo.size() - 1; i > 0; i--) {            Node *v = topo[i];            v->size = 1;            v->sizeAll = v->posCnt;            for (int j = 0; j < CHARSET_SIZE; j++) {                if (v->ch[j]) {                    v->size += v->ch[j]->size;                    v->sizeAll += v->ch[j]->sizeAll;                }            }            // printf("topo[%d]: (max = %d, min = %d, wordCnt = %d / %d, posCnt = %d, size = %d, sizeAll = %d)\n", i, v->max, v->getMin(), v->getWordCnt(true), v->getWordCnt(false), v->posCnt, v->size, v->sizeAll);        }    }} sam;inline void solveNoDup(int k) {    SuffixAutomaton::Node *v = sam.start;    while (k) {        bool flag = false;        for (int i = 0; i < CHARSET_SIZE; i++) {            if (v->ch[i]) {                if (k - v->ch[i]->size <= 0) {                    v = v->ch[i];                    k--;                    putchar('a' + i);                    flag = true;                    break;                } else k -= v->ch[i]->size;            }        }        if (!flag) {            puts("-1");            return;        }    }    putchar('\n');}inline void solveDup(int k) {    SuffixAutomaton::Node *v = sam.start;    while (k) {        bool flag = false;        for (int i = 0; i < CHARSET_SIZE; i++) {            if (v->ch[i]) {                if (k - v->ch[i]->sizeAll <= 0) {                    v = v->ch[i];                    k -= v->posCnt;                    putchar('a' + i);                    flag = true;                    break;                } else k -= v->ch[i]->sizeAll;            }        }        if (!flag) {            puts("-1");            return;        }    }    putchar('\n');}int main() {    static char s[MAXN + 1];    scanf("%s", s);    int n = strlen(s);    sam.init();    for (int i = 0; i < n; i++) sam.extend(s[i] - 'a');    sam.calc();    int t, k;    scanf("%d %d", &t, &k);    if (t == 0) solveNoDup(k);    else solveDup(k);    return 0;}

「BZOJ 1396」识别子串 - SAM + 线段树

2017-04-06T15:45:00.000Z

对于一个字符串，和中的第个字符，定义子串为一个关于的识别子串，当且仅当：

；
在中只出现一次。

求关于每一位字符的最短识别子串长度。

链接

BZOJ 1396

题解

对建立 SAM，找出其中所有集合大小为的，这些节点所表示的字符串只出现过一次。

用线段树维护每个位置的最短识别子串长度。对于一个符合条件的节点，它表示的所有子串的结束位置是固定的，设这个位置为，设最短的子串的起始位置为，则对于范围内的每个位置，都是它的识别子串，用去更新它们的答案。起始位置在左侧的那些子串（起始位置在之间），以每个起始位置开始的子串长度为，是一个关于的一次函数，可以用线段树（李超树）维护。

代码

#include #include #include #include #include const int MAXN = 1e5;const int CHARSET_SIZE = 26;struct SuffixAutomaton {    struct Node {        Node *ch[CHARSET_SIZE], *next;        int max, posCnt, pos;        Node(int max = 0, bool newSuffix = false) : ch(), next(NULL), max(max), posCnt(newSuffix), pos(-1) {}        int getMin() {            return next->max + 1;        }    } *start, *last, _pool[MAXN * 2 + 1], *_curr;    std::vector<Node *> topo;    void init() {        _curr = _pool;        start = last = new (_curr++) Node;    }    Node *extend(int c) {        Node *u = new (_curr++) Node(last->max + 1, true), *v = last;        do {            v->ch[c] = u;            v = v->next;        } while (v && !v->ch[c]);        if (!v) {            u->next = start;        } else if (v->ch[c]->max == v->max + 1) {            u->next = v->ch[c];        } else {            Node *n = new (_curr++) Node(v->max + 1, false), *o = v->ch[c];            std::copy(o->ch, o->ch + CHARSET_SIZE, n->ch);            n->next = o->next;            o->next = u->next = n;            for (; v && v->ch[c] == o; v = v->next) v->ch[c] = n;        }        last = u;        return u;    }    std::vector<Node *> &toposort() {        static int buc[MAXN * 2 + 1];        int max = 0;        for (Node *p = _pool; p != _curr; p++) {            max = std::max(max, p->max);            buc[p->max]++;        }        for (int i = 1; i <= max; i++) buc[i] += buc[i - 1];        topo.resize(_curr - _pool);        for (Node *p = _pool; p != _curr; p++) {            topo[--buc[p->max]] = p;        }        for (int i = 0; i <= max; i++) buc[i] = 0;        return topo;    }    void calc() {        toposort();        for (int i = topo.size() - 1; i > 0; i--) {            Node *v = topo[i];            v->next->posCnt += v->posCnt;        }    }} sam;struct LinearFunction {    int k, b;    LinearFunction(int x) : k(0), b(x) {}    LinearFunction(int k, int b) : k(k), b(b) {}    int operator()(int x) {        return k * x + b;    }};struct SegT {    int l, r, mid;    SegT *lc, *rc;    LinearFunction f;    SegT(int l, int r, SegT *lc, SegT *rc) : l(l), r(r), mid(l + (r - l) / 2), lc(lc), rc(rc), f(INT_MAX) {}    int query(int pos) {        if (l == r) return f(pos);        else return std::min(f(pos), (pos > mid ? rc : lc)->query(pos));    }    void cover(LinearFunction f) {        if (f(mid) < this->f(mid)) std::swap(f, this->f);        if (f(l) < this->f(l)) lc->cover(f);        if (f(r) < this->f(r)) rc->cover(f);    }    void update(int ql, int qr, const LinearFunction &f) {        if (ql > r || qr < l) return;        else if (ql <= l && qr >= r) cover(f);        else lc->update(ql, qr, f), rc->update(ql, qr, f);;    }    static SegT *build(int l, int r) {        if (l == r) return new SegT(l, r, NULL, NULL);        else {            int mid = l + (r - l) / 2;            return new SegT(l, r, build(l, mid), build(mid + 1, r));        }    }};int main() {    static char s[MAXN + 1];    scanf("%s", s);    int n = strlen(s);    sam.init();    for (int i = 0; i < n; i++) {        SuffixAutomaton::Node *v = sam.extend(s[i] - 'a');        v->pos = i;    }    sam.calc();    /*    static int ans[MAXN + 1];    for (int i = 0; i < n; i++) ans[i] = INT_MAX;    */    SegT *seg = SegT::build(0, n - 1);    for (int i = sam.topo.size() - 1; i > 0; i--) {        SuffixAutomaton::Node *v = sam.topo[i];        if (v->posCnt == 1 && v->pos != -1) {            // printf("pos = %d, [%d, %d]\n", v->pos, v->getMin(), v->max);            int min = v->getMin(), max = v->max, right = v->pos;            // [right - min + 1, right] <-- min            seg->update(right - min + 1, right, LinearFunction(min));            int l = right - max + 1, r = right - min + 1;            // f(x) = -(x - l) + max            //      = -x + (l + max)            // seg->update(l, r, LinearFunction(-1, l + max));            seg->update(l, r, LinearFunction(-1, right + 1));            /*            for (int j = v->getMin(); j <= v->max; j++) {                for (int k = v->pos - j + 1; k <= v->pos; k++) {                    putchar(s[k]);                    ans[k] = std::min(ans[k], j);                }                puts("");            }            */        }    }    for (int i = 0; i < n; i++) printf("%d\n", seg->query(i));}

「SDOI2010」古代猪文 - 费马小定理 + Lucas + CRT

2017-04-06T11:55:00.000Z

远古时期猪王国有个文字，现有的文字数量为远古时期的（是的一个正约数），剩余的个文字有很多种情况，假设有种情况，则研究这些文字的代价为，求这个代价对取模后的结果。

链接

BZOJ 1951

题解

列出式子，答案为

模数是指数，根据费马小定理，指数可以化为

枚举，转化为快速求组合数。对模数分解质因数的结果为，分别预处理在模这几个数意义下的阶乘及阶乘逆元，用 Lucas 定理计算出在模每个数意义下的组合数，并用 CRT 合并。

最后使用快速幂计算即可。

代码

#include const long long MOD = 999911659;const long long MOD_FACTORS[] = { 2, 3, 4679, 35617 }; // Factors of 999911659 - 1const int MAXN = 35617;long long n;long long fac[4][MAXN + 1], facInv[4][MAXN + 1];inline void exgcd(long long a, long long b, long long &g, long long &x, long long &y) {    if (!b) g = a, x = 1, y = 0;    else exgcd(b, a % b, g, y, x), y -= x * (a / b);}inline long long inv(long long a, long long p) {    long long g, res, tmp;    exgcd(a, p, g, res, tmp);    return (res % p + p) % p;}inline void prepare() {    for (int i = 0; i < 4; i++) {        int p = MOD_FACTORS[i];        fac[i][0] = facInv[i][0] = 1;        for (int j = 1; j <= MAXN; j++) {            fac[i][j] = fac[i][j - 1] * j % p;            facInv[i][j] = inv(fac[i][j], p);        }    }}inline long long C(int n, int k, int i) {    if (!k) return 1;    if (n < k) return 0;    int p = MOD_FACTORS[i];    // printf("C(%d, %d) %% %d = %lld\n", n, k, p, fac[i][n] * facInv[i][k] % p * facInv[i][n - k] % p);    return fac[i][n] * facInv[i][k] % p * facInv[i][n - k] % p;}// mod MOD_FACTORS[i]inline long long lucas(long long n, long long k, int i) {    if (!k) return 1;    int p = MOD_FACTORS[i];    return C(n % p, k % p, i) * lucas(n / p, k / p, i) % p;}inline void crtMerge(long long a1, long long p1, long long a2, long long p2, long long &na, long long &np) {    // x = a1 (mod p1)    // x = a2 (mod p2)    //    // => x = a1 + p1 * t1    //    x = a2 + p2 * t2    //    // => a1 + p1 * t1 = a2 + p2 * t2    //    a1 - a2 = p2 * t2 - p1 * t1    //    // => g = gcd(p1, p2) = p2 * d2 - p1 * d1    //    t2 = d2 * ((a1 - a2) / g)    //    t1 = d1 * ((a1 - a2) / g)    long long g, d1, d2;    exgcd(p2, -p1, g, d2, d1);    long long t2 = d2 * ((a1 - a2) / g);    np = p1 / g * p2;    if (np < 0) np = -np;    na = ((a2 + p2 * t2) % np + np) % np;    // printf("crtMerge((%lld, %lld), (%lld, %lld)) = (%lld, %lld)\n", a1, p1, a2, p2, na, np);}inline long long crt(const long long a[], const long long p[], int n) {    long long a0 = a[0], p0 = p[0];    for (int i = 1; i < n; i++) {        long long na, np;        crtMerge(a0, p0, a[i], p[i], na, np);        a0 = na;        p0 = np;    }    return a0;}inline long long addFactor(long long d) {    long long a[4];    for (int i = 0; i < 4; i++) {        a[i] = lucas(n, n / d, i);        // printf("C(%lld, %lld) = %lld\n", n, n / d, a[i]);    }    long long res = crt(a, MOD_FACTORS, 4);    // printf("addFactor(%lld) = %lld\n", d, res);    return res;}inline long long pow(long long a, long long n, long long p) {    long long res = 1;    for (; n; n >>= 1, a = a * a % p) if (n & 1) res = res * a % p;    return res;}int main() {    prepare();    long long g;    scanf("%lld %lld", &n, &g);    if (g == MOD) {        puts("0");    } else {        long long sum = 0;        for (int d = 1; (long long)d * d <= n; d++) {            if (n % d == 0) {                sum += addFactor(d);                if (d != n / d) sum += addFactor(n / d);                sum %= (MOD - 1);            }        }        long long ans = pow(g, sum, MOD);        printf("%lld\n", ans);    }}

「SDOI2013」随机数生成器 - 数学 + BSGS

2017-04-06T11:33:00.000Z

给定、、、，现有一数列

求最小的满足。

链接

BZOJ 3122

题解

令，得

当时

否则，设

令代入得

未知量只有左边的指数，使用 BSGS 求出即可。

代码

#include #include #include inline void exgcd(long long a, long long b, long long &g, long long &x, long long &y) {    if (!b) g = a, x = 1, y = 0;    else exgcd(b, a % b, g, y, x), y -= x * (a / b);}inline long long inv(long long x, long long p) {    long long g, res, tmp;    exgcd(x, p, g, res, tmp);    return (res % p + p) % p;}inline long long bsgs(long long a, long long b, long long p) {    a %= p;    b %= p;    /*    long long tmp = 1;    for (int i = 1; i <= p; i++) {        if (tmp == b) return i - 1;        tmp = tmp * a % p;    }    return -1;    */    std::map<long long, long long> map;    long long m = ceil(sqrt(p)), t = 1;    for (int i = 0; i < m; i++) {        if (!map.count(t)) map[t] = i;        t = t * a % p;    }    long long k = inv(t, p), w = b;    for (int i = 0; i < m; i++) {        if (map.count(w)) return i * m + map[w];        w = w * k % p;    }    return -1;}inline long long solve(long long p, long long a, long long b, long long x1, long long t) {    if (t == x1) return 1;    else if (a == 0) return b == t ? 2 : -1;    else if (a == 1) {        if (!b) return -1;        return ((((t - x1) % p + p) % p) * inv(b, p) % p) + 1;    } else {        long long q = inv(1 - a + p, p);        long long d = (((t - b * q) % p + p) % p) * inv(((x1 - b * q) % p + p) % p, p);        long long ans = bsgs(a, d, p);        if (ans == -1) return -1;        else return ans + 1;    }}inline long long force(int p, int a, int b, int x1, int t) {    if (a == 1) {        if (!b) return -1;        return ((((t - x1) % p + p) % p) * inv(b, p) % p) + 1;    }    /*    int x = x1;    for (int i = 1; i <= p; i++) {        // printf("a[%d] = %d\n", i, x);        if (x == t) return i;        x = (a * x + b) % p;    }    return -1;    */    long long q = inv(1 - a + p, p), ai = 1;    /*    for (int i = 1; i <= p; i++) {        long long x = (ai * (((x1 - b * q) % p + p) % p) + b * q % p) % p;        // printf("a[%d] = %lld\n", i, x);        if (x == t) return i;        ai = (ai * a) % p;    }    return -1;    */    long long tmp = (((t - b * q) % p + p) % p) * inv(((x1 - b * q) % p + p) % p, p) % p;    for (int i = 1; i <= p; i++) {        if (ai == tmp) return i;        ai = (ai * a) % p;    }    return -1;}int main() {    int T;    scanf("%d", &T);    while (T--) {        int p, a, b, x1, t;        scanf("%d %d %d %d %d", &p, &a, &b, &x1, &t);        printf("%lld\n", solve(p, a, b, x1, t));    }}

「SDOI2008」Sandy 的卡片 - 差分 + SAM

2017-04-05T21:50:00.000Z

相同的定义为：两个子串长度相同且一个串的全部元素加上一个数就会变成另一个串。给个串，求它们相同的子串最大长度。

链接

BZOJ 4698

题解

将每个串差分（转化），转化为求最长公共子串，然后将结果即为答案。

对第一个串建立 SAM，对 SAM 的每个节点维护当前匹配长度。对于每个串，将其放在 SAM 上运行，在每个节点处走到这个节点时这个串的最长匹配后缀长度。然后用每个点的当前匹配长度去更新其后缀链接指向节点的当前匹配长度（能匹配这么长，则也能匹配这么长）。每个串的匹配长度取最小值，即为最长的公共「这个节点上字符串」长度。对每个节点的这个值去最大，即为答案。

代码

#include #include #include #include #include const int MAXN = 1000;const int MAXL = 1000;struct SuffixAutomaton {    struct Node {        std::map<int, Node *> ch;        Node *next;        int max, currMatch, minMatch;        Node(int max = 0) : next(NULL), max(max), currMatch(0), minMatch(max) {}    } *start, *last, _pool[MAXL * 2 + 1], *_curr;    std::vector<Node *> topo;    void init() {        _curr = _pool;        start = last = new (_curr++) Node;    }    Node *extend(int c) {        Node *u = new (_curr++) Node(last->max + 1), *v = last;        for (; v && !v->ch[c]; v = v->next) v->ch[c] = u;        if (!v) {            u->next = start;        } else if (v->ch[c]->max == v->max + 1) {            u->next = v->ch[c];        } else {            Node *o = v->ch[c], *n = new (_curr++) Node(v->max + 1);            n->ch = o->ch;            n->next = o->next;            u->next = o->next = n;            for (; v && v->ch[c] == o; v = v->next) v->ch[c] = n;        }        last = u;        return u;    }    std::vector<Node *> toposort() {        static int buc[MAXL * 2 + 1];        int max = 0;        for (Node *p = _pool; p != _curr; p++) {            buc[p->max]++;            max = std::max(max, p->max);        }        for (int i = 1; i <= max; i++) buc[i] += buc[i - 1];        topo.resize(_curr - _pool);        for (Node *p = _pool; p != _curr; p++) topo[--buc[p->max]] = p;        std::fill(buc, buc + max + 1, 0);        return topo;    }} sam;inline int lcs(std::vector<int> a[], int n) {    sam.init();    for (int i = 1; i <= int(a[1].size()); i++) {        sam.extend(a[1][i]);    }    int ans = a[1].size() - 1;    std::vector<SuffixAutomaton::Node *> topo = sam.toposort();    for (int i = 2; i <= n; i++) {        SuffixAutomaton::Node *v = sam.start;        int l = 0;        for (int j = 1; j <= int(a[i].size()); j++) {            int c = a[i][j];            while (v != sam.start && !v->ch.count(c)) {                v = v->next;                l = v->max;            }            if (v->ch.count(c)) {                v = v->ch[c];                l++;            }            v->currMatch = std::max(v->currMatch, l);        }        int tmp = 0;        for (int i = topo.size() - 1; i > 0; i--) {            SuffixAutomaton::Node *v = topo[i];            v->next->currMatch = std::max(v->next->currMatch, v->currMatch);            v->minMatch = std::min(v->minMatch, v->currMatch);            v->currMatch = 0;            tmp = std::max(tmp, v->minMatch);        }        ans = std::min(ans, tmp);    }    return ans;}int main() {    int n;    scanf("%d", &n);    static std::vector<int> a[MAXN + 1];    int maxAns = INT_MAX;    for (int i = 1; i <= n; i++) {        int m;        scanf("%d", &m);        maxAns = std::min(maxAns, m);        a[i].resize(m + 1);        for (int j = 1; j <= m; j++) {            scanf("%d", &a[i][j]);        }        for (int j = m; j > 1; j--) a[i][j] -= a[i][j - 1];    }    printf("%d\n", std::min(lcs(a, n) + 1, maxAns));}

「BZOJ 3809」Gty 的二逼妹子序列 - 莫队 + 分块

2017-04-05T20:38:00.000Z

给一个序列，每次求之间权值在之间的不同的数的数量。

链接

BZOJ 3809

题解

莫队，用一个数据结构维护前缀和，维护当前区间每个数的出现次数，某个数第一次出现时在数据结构中加上这个数，最后一次删除时在数据结构中将其删除，每次转移到目标区间后在数据结构中查询两个前缀和作差。

这个数据结构可以用分块维护，分别维护每个位置的值和每个块的值，修改时分别在目标位置和所在块的值上加上增量，复杂度，查询时将整块的和整块外的值分别加入，复杂度。因为只需要进行次查询，所以这部分的时间复杂度为，并且转移时的复杂度相对与树状数组等结构少一个。

代码

#include #include #include const int MAXN = 100000;const int MAXN_SQRT = 317 + 10; // Math.sqrt(100000) = 316.22776601683796const int MAXM = 1000000;int n, blockSize, m, a[MAXN + 1], cnt[MAXN + 1];struct Query {    int l, r, a, b, *ans;    bool operator<(const Query &other) const    {        if (l / blockSize == other.l / blockSize) return (l / blockSize % 2 == 1) ? (r < other.r) : (r > other.r);        else return l / blockSize < other.l / blockSize;    }} Q[MAXM + 1];struct Blocklize {    int blockSize, blockCnt, valBlock[MAXN_SQRT + 1], val[MAXN + 1];    void init(int n)    {        blockSize = ceil(sqrt(n));        blockCnt = n / blockSize + (n % blockSize != 0);    }    int whichBlock(int x)    {        return (x - 1) / blockSize + 1;    }    int getBlockL(int bid)    {        return (bid - 1) * blockSize + 1;    }    int query(int pos)    {        int bid = whichBlock(pos), ans = 0;        for (int i = 1; i < bid; i++) ans += valBlock[i];        for (int i = getBlockL(bid); i <= pos; i++) ans += val[i];        return ans;    }    void update(int pos, int delta)    {        int bid = whichBlock(pos);        valBlock[bid] += delta;        val[pos] += delta;    }} ds; // data structureinline void extend(int pos, int d){    int x = a[pos];    if (d == 1)    {        if (++cnt[x] == 1) ds.update(x, d);    }    else    {        if (--cnt[x] == 0) ds.update(x, d);    }}inline int query(int a, int b){    return ds.query(b) - ds.query(a - 1);}inline void mo(){    int l = 1, r = 0;    for (int i = 1; i <= m; i++)    {        Query &q = Q[i];        while (r < q.r) extend(++r, 1);        while (r > q.r) extend(r--, -1);        while (l > q.l) extend(--l, 1);        while (l < q.l) extend(l++, -1);        *q.ans = query(q.a, q.b);    }}int main(){    scanf("%d %d", &n, &m);    blockSize = ceil(sqrt(n));    ds.init(n);    for (int i = 1; i <= n; i++) scanf("%d", &a[i]);    static int ans[MAXM + 1];    for (int i = 1; i <= m; i++)    {        scanf("%d %d %d %d", &Q[i].l, &Q[i].r, &Q[i].a, &Q[i].b);        Q[i].ans = &ans[i];    }    std::sort(Q + 1, Q + m + 1);    mo();    for (int i = 1; i <= m; i++) printf("%d\n", ans[i]);}